eu07/maszyna
16
0
Fork 0
mirror of https://github.com/MaSzyna-EU07/maszyna.git synced 2026-07-22 16:19:19 +02:00
Code Issues 123 Wiki Activity

Add brush mode in editor mode

Browse Source
This commit is contained in:
Hirek
2026-01-03 18:02:15 +01:00
parent 1cafe15917
commit f9c95e2de0
10 changed files with 2319 additions and 2099 deletions
Download Patch File Download Diff File Expand all files Collapse all files

449
application.cpp
View File

@@ -70,20 +70,24 @@ extern WNDPROC BaseWindowProc;
// user input callbacks // user input callbacks
void focus_callback( GLFWwindow *window, int focus ) { void focus_callback(GLFWwindow *window, int focus)
{
Application.on_focus_change(focus != 0); Application.on_focus_change(focus != 0);
} }
void framebuffer_resize_callback( GLFWwindow *, int w, int h ) { void framebuffer_resize_callback(GLFWwindow *, int w, int h)
{
Global.fb_size = glm::ivec2(w, h); Global.fb_size = glm::ivec2(w, h);
} }
void window_resize_callback( GLFWwindow *, int w, int h ) { void window_resize_callback(GLFWwindow *, int w, int h)
{
Global.window_size = glm::ivec2(w, h); Global.window_size = glm::ivec2(w, h);
Application.on_window_resize(w, h); Application.on_window_resize(w, h);
} }
void cursor_pos_callback( GLFWwindow *window, double x, double y ) { void cursor_pos_callback(GLFWwindow *window, double x, double y)
{
Global.cursor_pos = glm::ivec2(x, y); Global.cursor_pos = glm::ivec2(x, y);
Application.on_cursor_pos(x, y); Application.on_cursor_pos(x, y);
} }
@@ -93,11 +97,13 @@ void mouse_button_callback( GLFWwindow* window, int button, int action, int mods
Application.on_mouse_button(button, action, mods); Application.on_mouse_button(button, action, mods);
} }
void scroll_callback( GLFWwindow* window, double xoffset, double yoffset ) { void scroll_callback(GLFWwindow *window, double xoffset, double yoffset)
{
Application.on_scroll(xoffset, yoffset); Application.on_scroll(xoffset, yoffset);
} }
void key_callback( GLFWwindow *window, int key, int scancode, int action, int mods ) { void key_callback(GLFWwindow *window, int key, int scancode, int action, int mods)
{
Application.on_key(key, scancode, action, mods); Application.on_key(key, scancode, action, mods);
} }
@@ -127,11 +133,13 @@ int eu07_application::run_crashgui()
bool y, n; bool y, n;
if (Global.asLang == "pl") { if (Global.asLang == "pl")
{
ImGui::Begin(u8"Raportowanie błędów", nullptr, ImGuiWindowFlags_NoCollapse | ImGuiWindowFlags_NoSavedSettings | ImGuiWindowFlags_NoResize); ImGui::Begin(u8"Raportowanie błędów", nullptr, ImGuiWindowFlags_NoCollapse | ImGuiWindowFlags_NoSavedSettings | ImGuiWindowFlags_NoResize);
ImGui::TextUnformatted(u8"Podczas ostatniego uruchomienia symulatora wystąpił błąd.\nWysłać raport o błędzie do deweloperów?\n"); ImGui::TextUnformatted(u8"Podczas ostatniego uruchomienia symulatora wystąpił błąd.\nWysłać raport o błędzie do deweloperów?\n");
ImGui::TextUnformatted((u8"Usługa udostępniana przez " + crashreport_get_provider() + "\n").c_str()); ImGui::TextUnformatted((u8"Usługa udostępniana przez " + crashreport_get_provider() + "\n").c_str());
y = ImGui::Button(u8"Tak", ImVec2S(60, 0)); ImGui::SameLine(); y = ImGui::Button(u8"Tak", ImVec2S(60, 0));
ImGui::SameLine();
ImGui::Checkbox(u8"W przyszłości przesyłaj raporty o błędach automatycznie", &autoup); ImGui::Checkbox(u8"W przyszłości przesyłaj raporty o błędach automatycznie", &autoup);
ImGui::SameLine(); ImGui::SameLine();
@@ -146,11 +154,14 @@ int eu07_application::run_crashgui()
ImGui::NewLine(); ImGui::NewLine();
n = ImGui::Button(u8"Nie", ImVec2S(60, 0)); n = ImGui::Button(u8"Nie", ImVec2S(60, 0));
ImGui::End(); ImGui::End();
} else { }
else
{
ImGui::Begin("Crash reporting", nullptr, ImGuiWindowFlags_NoCollapse | ImGuiWindowFlags_NoSavedSettings | ImGuiWindowFlags_NoResize); ImGui::Begin("Crash reporting", nullptr, ImGuiWindowFlags_NoCollapse | ImGuiWindowFlags_NoSavedSettings | ImGuiWindowFlags_NoResize);
ImGui::TextUnformatted("Crash occurred during last launch of the simulator.\nSend crash report to developers?\n"); ImGui::TextUnformatted("Crash occurred during last launch of the simulator.\nSend crash report to developers?\n");
ImGui::TextUnformatted(("Service provided by " + crashreport_get_provider() + "\n").c_str()); ImGui::TextUnformatted(("Service provided by " + crashreport_get_provider() + "\n").c_str());
y = ImGui::Button("Yes", ImVec2S(60, 0)); ImGui::SameLine(); y = ImGui::Button("Yes", ImVec2S(60, 0));
ImGui::SameLine();
ImGui::Checkbox("In future send crash reports automatically", &autoup); ImGui::Checkbox("In future send crash reports automatically", &autoup);
ImGui::SameLine(); ImGui::SameLine();
@@ -170,14 +181,16 @@ int eu07_application::run_crashgui()
ui_layer::render_internal(); ui_layer::render_internal();
glfwSwapBuffers(m_windows.front()); glfwSwapBuffers(m_windows.front());
if (y) { if (y)
{
crashreport_upload_accept(); crashreport_upload_accept();
if (autoup) if (autoup)
crashreport_set_autoupload(); crashreport_set_autoupload();
return 0; return 0;
} }
if (n) { if (n)
{
crashreport_upload_reject(); crashreport_upload_reject();
return 0; return 0;
} }
@@ -282,9 +295,6 @@ void eu07_application::DiscordRPCService()
} }
} }
Discord_UpdatePresence(&discord_rpc); Discord_UpdatePresence(&discord_rpc);
} }
std::this_thread::sleep_for(std::chrono::milliseconds(5000)); // update RPC every 5 secs std::this_thread::sleep_for(std::chrono::milliseconds(5000)); // update RPC every 5 secs
@@ -292,8 +302,8 @@ void eu07_application::DiscordRPCService()
#endif #endif
} }
int int eu07_application::init(int Argc, char *Argv[])
eu07_application::init( int Argc, char *Argv[] ) { {
int result{0}; int result{0};
// start logging service // start logging service
@@ -302,12 +312,12 @@ eu07_application::init( int Argc, char *Argv[] ) {
init_debug(); init_debug();
init_files(); init_files();
if( ( result = init_settings( Argc, Argv ) ) != 0 ) { if ((result = init_settings(Argc, Argv)) != 0)
{
ErrorLog("Failed to initialize settings! Maybe you're missing eu07.ini file?"); ErrorLog("Failed to initialize settings! Maybe you're missing eu07.ini file?");
return result; return result;
} }
WriteLog("Starting MaSzyna rail vehicle simulator (release: " + Global.asVersion + ")"); WriteLog("Starting MaSzyna rail vehicle simulator (release: " + Global.asVersion + ")");
WriteLog("For online documentation and additional files refer to: http://eu07.pl"); WriteLog("For online documentation and additional files refer to: http://eu07.pl");
WriteLog("Authors: Marcin_EU, McZapkie, ABu, Winger, Tolaris, nbmx, OLO_EU, Bart, Quark-t, " WriteLog("Authors: Marcin_EU, McZapkie, ABu, Winger, Tolaris, nbmx, OLO_EU, Bart, Quark-t, "
@@ -329,16 +339,19 @@ eu07_application::init( int Argc, char *Argv[] ) {
WriteLog("// startup"); WriteLog("// startup");
if( ( result = init_glfw() ) != 0 ) { if ((result = init_glfw()) != 0)
{
ErrorLog("Failed to initialize glfw!"); ErrorLog("Failed to initialize glfw!");
return result; return result;
} }
if( needs_ogl() && ( result = init_ogl() ) != 0 ) { if (needs_ogl() && (result = init_ogl()) != 0)
{
ErrorLog("Failed to initialize ogl!"); ErrorLog("Failed to initialize ogl!");
return result; return result;
} }
if (crashreport_is_pending()) { // run crashgui as early as possible if (crashreport_is_pending())
{ // run crashgui as early as possible
if ((result = run_crashgui()) != 0) if ((result = run_crashgui()) != 0)
{ {
ErrorLog("Failed to run crash gui!"); ErrorLog("Failed to run crash gui!");
@@ -346,33 +359,40 @@ eu07_application::init( int Argc, char *Argv[] ) {
} }
} }
if( ( result = init_locale() ) != 0 ) { if ((result = init_locale()) != 0)
{
ErrorLog("Failed to initialize locales! Maybe you're missing lang directory?"); ErrorLog("Failed to initialize locales! Maybe you're missing lang directory?");
return result; return result;
} }
if( ( result = init_gfx() ) != 0 ) { if ((result = init_gfx()) != 0)
{
ErrorLog("Failed to initialize GFX!"); ErrorLog("Failed to initialize GFX!");
return result; return result;
} }
if( ( result = init_ui() ) != 0 ) { // ui now depends on activated renderer if ((result = init_ui()) != 0)
{ // ui now depends on activated renderer
ErrorLog("Failed to init UI!"); ErrorLog("Failed to init UI!");
return result; return result;
} }
if( ( result = init_audio() ) != 0 ) { if ((result = init_audio()) != 0)
{
ErrorLog("Failed to initialize OpenAL"); ErrorLog("Failed to initialize OpenAL");
return result; return result;
} }
if( ( result = init_data() ) != 0 ) { if ((result = init_data()) != 0)
{
ErrorLog("Failed to load data/ contents! Maybe your installation is broken?"); ErrorLog("Failed to load data/ contents! Maybe your installation is broken?");
return result; return result;
} }
crashreport_add_info("python_enabled", Global.python_enabled ? "yes" : "no"); crashreport_add_info("python_enabled", Global.python_enabled ? "yes" : "no");
if( Global.python_enabled ) { if (Global.python_enabled)
{
m_taskqueue.init(); m_taskqueue.init();
} }
if( ( result = init_modes() ) != 0 ) { if ((result = init_modes()) != 0)
{
ErrorLog("Failed to initialize game modes"); ErrorLog("Failed to initialize game modes");
return result; return result;
} }
@@ -387,13 +407,13 @@ eu07_application::init( int Argc, char *Argv[] ) {
return result; return result;
} }
double eu07_application::generate_sync()
{
double eu07_application::generate_sync() {
if (Timer::GetDeltaTime() == 0.0) if (Timer::GetDeltaTime() == 0.0)
return 0.0; return 0.0;
double sync = 0.0; double sync = 0.0;
for (const TDynamicObject* vehicle : simulation::Vehicles.sequence()) { for (const TDynamicObject *vehicle : simulation::Vehicles.sequence())
{
auto const pos{vehicle->GetPosition()}; auto const pos{vehicle->GetPosition()};
sync += pos.x + pos.y + pos.z; sync += pos.x + pos.y + pos.z;
} }
@@ -401,8 +421,10 @@ double eu07_application::generate_sync() {
return sync; return sync;
} }
void eu07_application::queue_quit(bool direct) { void eu07_application::queue_quit(bool direct)
if (direct || !m_modes[m_modestack.top()]->is_command_processor()) { {
if (direct || !m_modes[m_modestack.top()]->is_command_processor())
{
glfwSetWindowShouldClose(m_windows[0], GLFW_TRUE); glfwSetWindowShouldClose(m_windows[0], GLFW_TRUE);
return; return;
} }
@@ -411,20 +433,20 @@ void eu07_application::queue_quit(bool direct) {
relay.post(user_command::quitsimulation, 0.0, 0.0, GLFW_PRESS, 0); relay.post(user_command::quitsimulation, 0.0, 0.0, GLFW_PRESS, 0);
} }
bool bool eu07_application::is_server() const
eu07_application::is_server() const { {
return (m_network && m_network->servers); return (m_network && m_network->servers);
} }
bool bool eu07_application::is_client() const
eu07_application::is_client() const { {
return (m_network && m_network->client); return (m_network && m_network->client);
} }
int int eu07_application::run()
eu07_application::run() { {
auto frame{0}; auto frame{0};
// main application loop // main application loop
while (!glfwWindowShouldClose(m_windows.front()) && !m_modestack.empty()) while (!glfwWindowShouldClose(m_windows.front()) && !m_modestack.empty())
@@ -448,7 +470,8 @@ eu07_application::run() {
double frameStartTime = Timer::GetTime(); double frameStartTime = Timer::GetTime();
if (m_modes[m_modestack.top()]->is_command_processor()) { if (m_modes[m_modestack.top()]->is_command_processor())
{
// active mode is doing real calculations (e.g. drivermode) // active mode is doing real calculations (e.g. drivermode)
int loop_remaining = MAX_NETWORK_PER_FRAME; int loop_remaining = MAX_NETWORK_PER_FRAME;
while (--loop_remaining > 0) while (--loop_remaining > 0)
@@ -486,7 +509,8 @@ eu07_application::run() {
loop_remaining = -1; loop_remaining = -1;
} }
// if we're master // if we're master
else { else
{
// just push local commands to execution // just push local commands to execution
add_to_dequemap(commands_to_exec, local_commands); add_to_dequemap(commands_to_exec, local_commands);
@@ -518,9 +542,9 @@ eu07_application::run() {
if (m_network && m_network->client) if (m_network && m_network->client)
{ {
// verify sync // verify sync
if (sync != slave_sync) { if (sync != slave_sync)
WriteLog("net: desync! calculated: " + std::to_string(sync) {
+ ", received: " + std::to_string(slave_sync), logtype::net); WriteLog("net: desync! calculated: " + std::to_string(sync) + ", received: " + std::to_string(slave_sync), logtype::net);
Global.desync = slave_sync - sync; Global.desync = slave_sync - sync;
} }
@@ -531,17 +555,22 @@ eu07_application::run() {
} }
} }
if (!loop_remaining) { if (!loop_remaining)
{
// loop break forced by counter // loop break forced by counter
float received = m_network->client->get_frame_counter(); float received = m_network->client->get_frame_counter();
float awaiting = m_network->client->get_awaiting_frames(); float awaiting = m_network->client->get_awaiting_frames();
// TODO: don't meddle with mode progresbar // TODO: don't meddle with mode progresbar
m_modes[m_modestack.top()]->set_progress(100.0f * (received - awaiting) / received); m_modes[m_modestack.top()]->set_progress(100.0f * (received - awaiting) / received);
} else { }
else
{
m_modes[m_modestack.top()]->set_progress(0.0f, 0.0f); m_modes[m_modestack.top()]->set_progress(0.0f, 0.0f);
} }
} else { }
else
{
// active mode is loader // active mode is loader
// clear local command queue // clear local command queue
@@ -567,7 +596,8 @@ eu07_application::run() {
m_modes[m_modestack.top()]->on_event_poll(); m_modes[m_modestack.top()]->on_event_poll();
if (m_screenshot_queued) { if (m_screenshot_queued)
{
m_screenshot_queued = false; m_screenshot_queued = false;
GfxRenderer->MakeScreenshot(); GfxRenderer->MakeScreenshot();
} }
@@ -576,7 +606,8 @@ eu07_application::run() {
m_network->update(); m_network->update();
auto const frametime{Timer::subsystem.mainloop_total.stop()}; auto const frametime{Timer::subsystem.mainloop_total.stop()};
if( Global.minframetime.count() != 0.0f && ( Global.minframetime - frametime ).count() > 0.0f ) { if (Global.minframetime.count() != 0.0f && (Global.minframetime - frametime).count() > 0.0f)
{
std::this_thread::sleep_for(Global.minframetime - frametime); std::this_thread::sleep_for(Global.minframetime - frametime);
} }
} }
@@ -598,33 +629,33 @@ eu07_application::run() {
} }
// issues request for a worker thread to perform specified task. returns: true if task was scheduled // issues request for a worker thread to perform specified task. returns: true if task was scheduled
bool bool eu07_application::request(python_taskqueue::task_request const &Task)
eu07_application::request( python_taskqueue::task_request const &Task ) { {
auto const result{m_taskqueue.insert(Task)}; auto const result{m_taskqueue.insert(Task)};
if( ( false == result ) if ((false == result) && (Task.input != nullptr))
&& ( Task.input != nullptr ) ) { {
// clean up allocated resources since the worker won't // clean up allocated resources since the worker won't
} }
return result; return result;
} }
// ensures the main thread holds the python gil and can safely execute python calls // ensures the main thread holds the python gil and can safely execute python calls
void void eu07_application::acquire_python_lock()
eu07_application::acquire_python_lock() { {
m_taskqueue.acquire_lock(); m_taskqueue.acquire_lock();
} }
// frees the python gil and swaps out the main thread // frees the python gil and swaps out the main thread
void void eu07_application::release_python_lock()
eu07_application::release_python_lock() { {
m_taskqueue.release_lock(); m_taskqueue.release_lock();
} }
void void eu07_application::exit()
eu07_application::exit() { {
Global.applicationQuitOrder = true; Global.applicationQuitOrder = true;
auto it = Global.threads.find("LogService"); auto it = Global.threads.find("LogService");
if (it != Global.threads.end()) if (it != Global.threads.end())
@@ -640,7 +671,6 @@ eu07_application::exit() {
it->second.join(); it->second.join();
} }
for (auto &mode : m_modes) for (auto &mode : m_modes)
mode.reset(); mode.reset();
@@ -652,7 +682,8 @@ eu07_application::exit() {
ui_layer::shutdown(); ui_layer::shutdown();
for( auto *window : m_windows ) { for (auto *window : m_windows)
{
glfwDestroyWindow(window); glfwDestroyWindow(window);
} }
m_taskqueue.exit(); m_taskqueue.exit();
@@ -662,37 +693,48 @@ eu07_application::exit() {
system(Global.exec_on_exit.c_str()); system(Global.exec_on_exit.c_str());
} }
void void eu07_application::render_ui()
eu07_application::render_ui() { {
if( m_modestack.empty() ) { return; } if (m_modestack.empty())
{
return;
}
m_modes[m_modestack.top()]->render_ui(); m_modes[m_modestack.top()]->render_ui();
} }
void eu07_application::begin_ui_frame() { void eu07_application::begin_ui_frame()
{
if( m_modestack.empty() ) { return; } if (m_modestack.empty())
{
return;
}
m_modes[m_modestack.top()]->begin_ui_frame(); m_modes[m_modestack.top()]->begin_ui_frame();
} }
bool bool eu07_application::pop_mode()
eu07_application::pop_mode() { {
if( m_modestack.empty() ) { return false; } if (m_modestack.empty())
{
return false;
}
m_modes[m_modestack.top()]->exit(); m_modes[m_modestack.top()]->exit();
m_modestack.pop(); m_modestack.pop();
return true; return true;
} }
bool bool eu07_application::push_mode(mode const Mode)
eu07_application::push_mode( mode const Mode ) { {
if (Mode >= count_) if (Mode >= count_)
return false; return false;
if (!m_modes[Mode]) { if (!m_modes[Mode])
{
if (Mode == launcher) if (Mode == launcher)
m_modes[Mode] = std::make_shared<launcher_mode>(); m_modes[Mode] = std::make_shared<launcher_mode>();
if (Mode == scenarioloader) if (Mode == scenarioloader)
@@ -712,36 +754,42 @@ eu07_application::push_mode( mode const Mode ) {
return true; return true;
} }
void void eu07_application::set_title(std::string const &Title)
eu07_application::set_title( std::string const &Title ) { {
glfwSetWindowTitle(m_windows.front(), Title.c_str()); glfwSetWindowTitle(m_windows.front(), Title.c_str());
} }
void void eu07_application::set_progress(float const Progress, float const Subtaskprogress)
eu07_application::set_progress( float const Progress, float const Subtaskprogress ) { {
if( m_modestack.empty() ) { return; } if (m_modestack.empty())
{
return;
}
m_modes[m_modestack.top()]->set_progress(Progress, Subtaskprogress); m_modes[m_modestack.top()]->set_progress(Progress, Subtaskprogress);
} }
void void eu07_application::set_tooltip(std::string const &Tooltip)
eu07_application::set_tooltip( std::string const &Tooltip ) { {
if( m_modestack.empty() ) { return; } if (m_modestack.empty())
{
return;
}
m_modes[m_modestack.top()]->set_tooltip(Tooltip); m_modes[m_modestack.top()]->set_tooltip(Tooltip);
} }
void void eu07_application::set_cursor(int const Mode)
eu07_application::set_cursor( int const Mode ) { {
ui_layer::set_cursor(Mode); ui_layer::set_cursor(Mode);
} }
void void eu07_application::set_cursor_pos(double const Horizontal, double const Vertical)
eu07_application::set_cursor_pos( double const Horizontal, double const Vertical ) { {
glfwSetCursorPos(m_windows.front(), Horizontal, Vertical); glfwSetCursorPos(m_windows.front(), Horizontal, Vertical);
} }
@@ -757,13 +805,16 @@ eu07_application::get_input_hint( user_command const Command ) const {
} }
*/ */
void void eu07_application::on_key(int const Key, int const Scancode, int const Action, int const Mods)
eu07_application::on_key( int const Key, int const Scancode, int const Action, int const Mods ) { {
if (ui_layer::key_callback(Key, Scancode, Action, Mods)) if (ui_layer::key_callback(Key, Scancode, Action, Mods))
return; return;
if( m_modestack.empty() ) { return; } if (m_modestack.empty())
{
return;
}
#ifdef __unix__ #ifdef __unix__
if (Key == GLFW_KEY_LEFT_SHIFT || Key == GLFW_KEY_RIGHT_SHIFT) if (Key == GLFW_KEY_LEFT_SHIFT || Key == GLFW_KEY_RIGHT_SHIFT)
@@ -777,43 +828,55 @@ eu07_application::on_key( int const Key, int const Scancode, int const Action, i
m_modes[m_modestack.top()]->on_key(Key, Scancode, Action, Mods); m_modes[m_modestack.top()]->on_key(Key, Scancode, Action, Mods);
} }
void void eu07_application::on_cursor_pos(double const Horizontal, double const Vertical)
eu07_application::on_cursor_pos( double const Horizontal, double const Vertical ) { {
if( m_modestack.empty() ) { return; } if (m_modestack.empty())
{
return;
}
m_modes[m_modestack.top()]->on_cursor_pos(Horizontal, Vertical); m_modes[m_modestack.top()]->on_cursor_pos(Horizontal, Vertical);
} }
void void eu07_application::on_mouse_button(int const Button, int const Action, int const Mods)
eu07_application::on_mouse_button( int const Button, int const Action, int const Mods ) { {
if (ui_layer::mouse_button_callback(Button, Action, Mods)) if (ui_layer::mouse_button_callback(Button, Action, Mods))
return; return;
if( m_modestack.empty() ) { return; } if (m_modestack.empty())
{
return;
}
m_modes[m_modestack.top()]->on_mouse_button(Button, Action, Mods); m_modes[m_modestack.top()]->on_mouse_button(Button, Action, Mods);
} }
void void eu07_application::on_scroll(double const Xoffset, double const Yoffset)
eu07_application::on_scroll( double const Xoffset, double const Yoffset ) { {
if (ui_layer::scroll_callback(Xoffset, Yoffset)) if (ui_layer::scroll_callback(Xoffset, Yoffset))
return; return;
if( m_modestack.empty() ) { return; } if (m_modestack.empty())
{
return;
}
m_modes[m_modestack.top()]->on_scroll(Xoffset, Yoffset); m_modes[m_modestack.top()]->on_scroll(Xoffset, Yoffset);
} }
void eu07_application::on_char(unsigned int c) { void eu07_application::on_char(unsigned int c)
{
if (ui_layer::char_callback(c)) if (ui_layer::char_callback(c))
return; return;
} }
void eu07_application::on_focus_change(bool focus) { void eu07_application::on_focus_change(bool focus)
if( Global.bInactivePause && m_network.has_value() && !m_network->client) {// jeśli ma być pauzowanie okna w tle {
if (Global.bInactivePause && m_network.has_value() && !m_network->client)
{ // jeśli ma być pauzowanie okna w tle
command_relay relay; command_relay relay;
relay.post(user_command::focuspauseset, focus ? 1.0 : 0.0, 0.0, GLFW_PRESS, 0); relay.post(user_command::focuspauseset, focus ? 1.0 : 0.0, 0.0, GLFW_PRESS, 0);
} }
@@ -826,15 +889,12 @@ void eu07_application::on_window_resize(int w, int h)
m_modes[m_modestack.top()]->on_window_resize(w, h); m_modes[m_modestack.top()]->on_window_resize(w, h);
} }
GLFWwindow *eu07_application::window(int const Windowindex, bool visible, int width, int height, GLFWmonitor *monitor, bool keep_ownership, bool share_ctx)
{
GLFWwindow * if (Windowindex >= 0)
eu07_application::window(int const Windowindex, bool visible, int width, int height, GLFWmonitor *monitor, bool keep_ownership , bool share_ctx) { {
return (Windowindex < m_windows.size() ? m_windows[Windowindex] : nullptr);
if( Windowindex >= 0 ) {
return (
Windowindex < m_windows.size() ?
m_windows[ Windowindex ] :
nullptr );
} }
// for index -1 create a new child window // for index -1 create a new child window
@@ -849,8 +909,7 @@ eu07_application::window(int const Windowindex, bool visible, int width, int hei
glfwWindowHint(GLFW_VISIBLE, visible); glfwWindowHint(GLFW_VISIBLE, visible);
auto *childwindow = glfwCreateWindow( width, height, "eu07window", monitor, auto *childwindow = glfwCreateWindow(width, height, "eu07window", monitor, share_ctx ? m_windows.front() : nullptr);
share_ctx ? m_windows.front() : nullptr);
if (!childwindow) if (!childwindow)
return nullptr; return nullptr;
@@ -863,11 +922,13 @@ eu07_application::window(int const Windowindex, bool visible, int width, int hei
} }
// private: // private:
GLFWmonitor* eu07_application::find_monitor(const std::string &str) const { GLFWmonitor *eu07_application::find_monitor(const std::string &str) const
{
int monitor_count; int monitor_count;
GLFWmonitor **monitors = glfwGetMonitors(&monitor_count); GLFWmonitor **monitors = glfwGetMonitors(&monitor_count);
for (size_t i = 0; i < monitor_count; i++) { for (size_t i = 0; i < monitor_count; i++)
{
if (describe_monitor(monitors[i]) == str) if (describe_monitor(monitors[i]) == str)
return monitors[i]; return monitors[i];
} }
@@ -875,7 +936,8 @@ GLFWmonitor* eu07_application::find_monitor(const std::string &str) const {
return nullptr; return nullptr;
} }
std::string eu07_application::describe_monitor(GLFWmonitor *monitor) const { std::string eu07_application::describe_monitor(GLFWmonitor *monitor) const
{
std::string name(glfwGetMonitorName(monitor)); std::string name(glfwGetMonitorName(monitor));
std::replace(std::begin(name), std::end(name), ' ', '_'); std::replace(std::begin(name), std::end(name), ' ', '_');
@@ -892,7 +954,8 @@ bool eu07_application::needs_ogl() const
return !Global.NvRenderer; return !Global.NvRenderer;
} }
void eu07_application::init_debug() { void eu07_application::init_debug()
{
#if defined(_MSC_VER) && defined(_DEBUG) #if defined(_MSC_VER) && defined(_DEBUG)
// memory leaks // memory leaks
@@ -907,8 +970,8 @@ void eu07_application::init_debug() {
#endif #endif
} }
void void eu07_application::init_files()
eu07_application::init_files() { {
#ifdef _WIN32 #ifdef _WIN32
DeleteFile("log.txt"); DeleteFile("log.txt");
@@ -922,8 +985,8 @@ eu07_application::init_files() {
} }
namespace fs = std::filesystem; namespace fs = std::filesystem;
int int eu07_application::init_settings(int Argc, char *Argv[])
eu07_application::init_settings( int Argc, char *Argv[] ) { {
Global.asVersion = VERSION_INFO; Global.asVersion = VERSION_INFO;
fs::path iniPath; fs::path iniPath;
@@ -950,26 +1013,29 @@ eu07_application::init_settings( int Argc, char *Argv[] ) {
} }
// process command line arguments // process command line arguments
for( int i = 1; i < Argc; ++i ) { for (int i = 1; i < Argc; ++i)
{
std::string token{Argv[i]}; std::string token{Argv[i]};
if( token == "-s" ) { if (token == "-s")
if( i + 1 < Argc ) { {
if (i + 1 < Argc)
{
Global.SceneryFile = ToLower(Argv[++i]); Global.SceneryFile = ToLower(Argv[++i]);
} }
} }
else if( token == "-v" ) { else if (token == "-v")
if( i + 1 < Argc ) { {
if (i + 1 < Argc)
{
Global.local_start_vehicle = ToLower(Argv[++i]); Global.local_start_vehicle = ToLower(Argv[++i]);
} }
} }
else { else
std::cout {
<< "usage: " << std::string( Argv[ 0 ] ) std::cout << "usage: " << std::string(Argv[0]) << " [-s sceneryfilepath]"
<< " [-s sceneryfilepath]" << " [-v vehiclename]" << std::endl;
<< " [-v vehiclename]"
<< std::endl;
return -1; return -1;
} }
} }
@@ -977,16 +1043,16 @@ eu07_application::init_settings( int Argc, char *Argv[] ) {
return 0; return 0;
} }
int int eu07_application::init_locale()
eu07_application::init_locale() { {
Translations.init(); Translations.init();
return 0; return 0;
} }
int int eu07_application::init_glfw()
eu07_application::init_glfw() { {
{ {
int glfw_major, glfw_minor, glfw_rev; int glfw_major, glfw_minor, glfw_rev;
glfwGetVersion(&glfw_major, &glfw_minor, &glfw_rev); glfwGetVersion(&glfw_major, &glfw_minor, &glfw_rev);
@@ -994,7 +1060,8 @@ eu07_application::init_glfw() {
} }
#ifdef GLFW_ANGLE_PLATFORM_TYPE #ifdef GLFW_ANGLE_PLATFORM_TYPE
if (m_glfwversion >= 30400) { if (m_glfwversion >= 30400)
{
int platform = GLFW_ANGLE_PLATFORM_TYPE_NONE; int platform = GLFW_ANGLE_PLATFORM_TYPE_NONE;
if (Global.gfx_angleplatform == "opengl") if (Global.gfx_angleplatform == "opengl")
platform = GLFW_ANGLE_PLATFORM_TYPE_OPENGL; platform = GLFW_ANGLE_PLATFORM_TYPE_OPENGL;
@@ -1013,7 +1080,8 @@ eu07_application::init_glfw() {
} }
#endif #endif
if( glfwInit() == GLFW_FALSE ) { if (glfwInit() == GLFW_FALSE)
{
ErrorLog("Bad init: failed to initialize glfw"); ErrorLog("Bad init: failed to initialize glfw");
return -1; return -1;
} }
@@ -1023,7 +1091,8 @@ eu07_application::init_glfw() {
GLFWmonitor **monitors = glfwGetMonitors(&monitor_count); GLFWmonitor **monitors = glfwGetMonitors(&monitor_count);
WriteLog("available monitors:"); WriteLog("available monitors:");
for (size_t i = 0; i < monitor_count; i++) { for (size_t i = 0; i < monitor_count; i++)
{
WriteLog(describe_monitor(monitors[i])); WriteLog(describe_monitor(monitors[i]));
} }
} }
@@ -1033,7 +1102,8 @@ eu07_application::init_glfw() {
monitor = glfwGetPrimaryMonitor(); monitor = glfwGetPrimaryMonitor();
glfwWindowHint(GLFW_AUTO_ICONIFY, GLFW_FALSE); glfwWindowHint(GLFW_AUTO_ICONIFY, GLFW_FALSE);
if ((Global.gfx_skippipeline || Global.LegacyRenderer) && Global.iMultisampling > 0) { if ((Global.gfx_skippipeline || Global.LegacyRenderer) && Global.iMultisampling > 0)
{
glfwWindowHint(GLFW_SAMPLES, 1 << Global.iMultisampling); glfwWindowHint(GLFW_SAMPLES, 1 << Global.iMultisampling);
} }
@@ -1043,17 +1113,21 @@ eu07_application::init_glfw() {
{ {
glfwWindowHint(GLFW_CLIENT_API, GLFW_NO_API); glfwWindowHint(GLFW_CLIENT_API, GLFW_NO_API);
} }
else { else
if( !Global.LegacyRenderer ) { {
if (!Global.LegacyRenderer)
{
Global.bUseVBO = true; Global.bUseVBO = true;
// activate core profile for opengl 3.3 renderer // activate core profile for opengl 3.3 renderer
if( !Global.gfx_usegles ) { if (!Global.gfx_usegles)
{
glfwWindowHint(GLFW_OPENGL_PROFILE, GLFW_OPENGL_CORE_PROFILE); glfwWindowHint(GLFW_OPENGL_PROFILE, GLFW_OPENGL_CORE_PROFILE);
glfwWindowHint(GLFW_OPENGL_FORWARD_COMPAT, GLFW_TRUE); glfwWindowHint(GLFW_OPENGL_FORWARD_COMPAT, GLFW_TRUE);
glfwWindowHint(GLFW_CONTEXT_VERSION_MAJOR, 3); glfwWindowHint(GLFW_CONTEXT_VERSION_MAJOR, 3);
glfwWindowHint(GLFW_CONTEXT_VERSION_MINOR, 3); glfwWindowHint(GLFW_CONTEXT_VERSION_MINOR, 3);
} }
else { else
{
#ifdef GLFW_CONTEXT_CREATION_API #ifdef GLFW_CONTEXT_CREATION_API
if (m_glfwversion >= 30200) if (m_glfwversion >= 30200)
glfwWindowHint(GLFW_CONTEXT_CREATION_API, GLFW_EGL_CONTEXT_API); glfwWindowHint(GLFW_CONTEXT_CREATION_API, GLFW_EGL_CONTEXT_API);
@@ -1062,8 +1136,11 @@ eu07_application::init_glfw() {
glfwWindowHint(GLFW_CONTEXT_VERSION_MAJOR, 3); glfwWindowHint(GLFW_CONTEXT_VERSION_MAJOR, 3);
glfwWindowHint(GLFW_CONTEXT_VERSION_MINOR, 0); glfwWindowHint(GLFW_CONTEXT_VERSION_MINOR, 0);
} }
} else { }
if (Global.gfx_usegles) { else
{
if (Global.gfx_usegles)
{
ErrorLog("legacy renderer not supported in gles mode"); ErrorLog("legacy renderer not supported in gles mode");
return -1; return -1;
} }
@@ -1079,17 +1156,18 @@ eu07_application::init_glfw() {
glfwWindowHint(GLFW_SRGB_CAPABLE, !Global.gfx_shadergamma); glfwWindowHint(GLFW_SRGB_CAPABLE, !Global.gfx_shadergamma);
if( Global.fullscreen_windowed ) { if (Global.fullscreen_windowed)
{
auto const mode = glfwGetVideoMode(monitor); auto const mode = glfwGetVideoMode(monitor);
Global.window_size.x = mode->width; Global.window_size.x = mode->width;
Global.window_size.y = mode->height; Global.window_size.y = mode->height;
Global.bFullScreen = true; Global.bFullScreen = true;
} }
auto *mainwindow = window( auto *mainwindow = window(-1, true, Global.window_size.x, Global.window_size.y, (Global.bFullScreen ? monitor : nullptr), true, false);
-1, true, Global.window_size.x, Global.window_size.y, ( Global.bFullScreen ? monitor : nullptr ), true, false );
if( mainwindow == nullptr ) { if (mainwindow == nullptr)
{
ErrorLog("Bad init: failed to create glfw window"); ErrorLog("Bad init: failed to create glfw window");
return -1; return -1;
} }
@@ -1118,8 +1196,8 @@ eu07_application::init_glfw() {
return 0; return 0;
} }
void void eu07_application::init_callbacks()
eu07_application::init_callbacks() { {
auto *window{m_windows.front()}; auto *window{m_windows.front()};
glfwSetWindowSizeCallback(window, window_resize_callback); glfwSetWindowSizeCallback(window, window_resize_callback);
@@ -1132,8 +1210,8 @@ eu07_application::init_callbacks() {
glfwSetWindowFocusCallback(window, focus_callback); glfwSetWindowFocusCallback(window, focus_callback);
} }
int int eu07_application::init_ogl()
eu07_application::init_ogl() { {
if (!Global.gfx_usegles) if (!Global.gfx_usegles)
{ {
if (!gladLoadGLLoader((GLADloadproc)glfwGetProcAddress)) if (!gladLoadGLLoader((GLADloadproc)glfwGetProcAddress))
@@ -1154,19 +1232,21 @@ eu07_application::init_ogl() {
return 0; return 0;
} }
int int eu07_application::init_ui()
eu07_application::init_ui() { {
if( false == ui_layer::init( m_windows.front() ) ) { if (false == ui_layer::init(m_windows.front()))
{
return -1; return -1;
} }
init_callbacks(); init_callbacks();
return 0; return 0;
} }
int int eu07_application::init_gfx()
eu07_application::init_gfx() { {
if( Global.GfxRenderer == "default" ) { if (Global.GfxRenderer == "default")
{
// default render path // default render path
GfxRenderer = gfx_renderer_factory::get_instance()->create("modern"); GfxRenderer = gfx_renderer_factory::get_instance()->create("modern");
} }
@@ -1174,18 +1254,21 @@ eu07_application::init_gfx() {
{ {
GfxRenderer = gfx_renderer_factory::get_instance()->create(Global.GfxRenderer); GfxRenderer = gfx_renderer_factory::get_instance()->create(Global.GfxRenderer);
} }
else { else
{
// legacy render path // legacy render path
GfxRenderer = gfx_renderer_factory::get_instance()->create("legacy"); GfxRenderer = gfx_renderer_factory::get_instance()->create("legacy");
Global.DisabledLogTypes |= static_cast<unsigned int>(logtype::material); Global.DisabledLogTypes |= static_cast<unsigned int>(logtype::material);
} }
if (!GfxRenderer) { if (!GfxRenderer)
{
ErrorLog("no renderer found!"); ErrorLog("no renderer found!");
return -1; return -1;
} }
if( false == GfxRenderer->Init( m_windows.front() ) ) { if (false == GfxRenderer->Init(m_windows.front()))
{
return -1; return -1;
} }
@@ -1199,26 +1282,26 @@ eu07_application::init_gfx() {
return 0; return 0;
} }
int int eu07_application::init_audio()
eu07_application::init_audio() { {
if( Global.bSoundEnabled ) { if (Global.bSoundEnabled)
{
Global.bSoundEnabled &= audio::renderer.init(); Global.bSoundEnabled &= audio::renderer.init();
} }
// NOTE: lack of audio isn't deemed a failure serious enough to throw in the towel // NOTE: lack of audio isn't deemed a failure serious enough to throw in the towel
return 0; return 0;
} }
int int eu07_application::init_data()
eu07_application::init_data() { {
// HACK: grab content of the first {} block in load_unit_weights using temporary parser, then parse it normally. on any error our weight list will be empty string // HACK: grab content of the first {} block in load_unit_weights using temporary parser, then parse it normally. on any error our weight list will be empty string
auto loadweights{cParser(cParser("data/load_weights.txt", cParser::buffer_FILE).getToken<std::string>(true, "{}"), cParser::buffer_TEXT)}; auto loadweights{cParser(cParser("data/load_weights.txt", cParser::buffer_FILE).getToken<std::string>(true, "{}"), cParser::buffer_TEXT)};
while( true == loadweights.getTokens( 2 ) ) { while (true == loadweights.getTokens(2))
{
std::pair<std::string, float> weightpair; std::pair<std::string, float> weightpair;
loadweights loadweights >> weightpair.first >> weightpair.second;
>> weightpair.first
>> weightpair.second;
weightpair.first.erase(weightpair.first.end() - 1); // trim trailing ':' from the key weightpair.first.erase(weightpair.first.end() - 1); // trim trailing ':' from the key
simulation::Weights.emplace(weightpair.first, weightpair.second); simulation::Weights.emplace(weightpair.first, weightpair.second);
} }
@@ -1228,11 +1311,12 @@ eu07_application::init_data() {
return 0; return 0;
} }
int int eu07_application::init_modes()
eu07_application::init_modes() { {
Global.local_random_engine.seed(std::random_device{}()); Global.local_random_engine.seed(std::random_device{}());
if ((!Global.network_servers.empty() || Global.network_client) && Global.SceneryFile.empty()) { if ((!Global.network_servers.empty() || Global.network_client) && Global.SceneryFile.empty())
{
ErrorLog("launcher mode is currently not supported in network mode"); ErrorLog("launcher mode is currently not supported in network mode");
return -1; return -1;
} }
@@ -1246,21 +1330,27 @@ eu07_application::init_modes() {
return 0; return 0;
} }
bool eu07_application::init_network() { bool eu07_application::init_network()
if (!Global.network_servers.empty() || Global.network_client) { {
if (!Global.network_servers.empty() || Global.network_client)
{
// create network manager // create network manager
m_network.emplace(); m_network.emplace();
} }
for (auto const &pair : Global.network_servers) { for (auto const &pair : Global.network_servers)
{
// create all servers // create all servers
m_network->create_server(pair.first, pair.second); m_network->create_server(pair.first, pair.second);
} }
if (Global.network_client) { if (Global.network_client)
{
// create client // create client
m_network->connect(Global.network_client->first, Global.network_client->second); m_network->connect(Global.network_client->first, Global.network_client->second);
} else { }
else
{
// we're simulation master // we're simulation master
if (!Global.random_seed) if (!Global.random_seed)
Global.random_seed = std::random_device{}(); Global.random_seed = std::random_device{}();
@@ -1275,8 +1365,7 @@ bool eu07_application::init_network() {
tmp = std::gmtime(&utc_now); tmp = std::gmtime(&utc_now);
memcpy(&tm_utc, tmp, sizeof(tm)); memcpy(&tm_utc, tmp, sizeof(tm));
int64_t offset = (tm_local.tm_hour * 3600 + tm_local.tm_min * 60 + tm_local.tm_sec) int64_t offset = (tm_local.tm_hour * 3600 + tm_local.tm_min * 60 + tm_local.tm_sec) - (tm_utc.tm_hour * 3600 + tm_utc.tm_min * 60 + tm_utc.tm_sec);
- (tm_utc.tm_hour * 3600 + tm_utc.tm_min * 60 + tm_utc.tm_sec);
Global.starting_timestamp = utc_now + offset; Global.starting_timestamp = utc_now + offset;
Global.ready_to_load = true; Global.ready_to_load = true;

276
editormode.cpp
View File

@@ -21,28 +21,27 @@ http://mozilla.org/MPL/2.0/.
#include "renderer.h" #include "renderer.h"
#include "AnimModel.h" #include "AnimModel.h"
bool bool editor_mode::editormode_input::init()
editor_mode::editormode_input::init() { {
return ( return (mouse.init() && keyboard.init());
mouse.init()
&& keyboard.init() );
} }
void void editor_mode::editormode_input::poll()
editor_mode::editormode_input::poll() { {
keyboard.poll(); keyboard.poll();
} }
editor_mode::editor_mode() { editor_mode::editor_mode()
{
m_userinterface = std::make_shared<editor_ui>(); m_userinterface = std::make_shared<editor_ui>();
} }
// initializes internal data structures of the mode. returns: true on success, false otherwise // initializes internal data structures of the mode. returns: true on success, false otherwise
bool bool editor_mode::init()
editor_mode::init() { {
Camera.Init({0, 15, 0}, {glm::radians(-30.0), glm::radians(180.0), 0}, nullptr); Camera.Init({0, 15, 0}, {glm::radians(-30.0), glm::radians(180.0), 0}, nullptr);
@@ -50,8 +49,8 @@ editor_mode::init() {
} }
// mode-specific update of simulation data. returns: false on error, true otherwise // mode-specific update of simulation data. returns: false on error, true otherwise
bool bool editor_mode::update()
editor_mode::update() { {
Timer::UpdateTimers(true); Timer::UpdateTimers(true);
@@ -63,16 +62,81 @@ editor_mode::update() {
// fixed step render time routines: // fixed step render time routines:
fTime50Hz += deltarealtime; // w pauzie też trzeba zliczać czas, bo przy dużym FPS będzie problem z odczytem ramek fTime50Hz += deltarealtime; // w pauzie też trzeba zliczać czas, bo przy dużym FPS będzie problem z odczytem ramek
while( fTime50Hz >= 1.0 / 50.0 ) { while (fTime50Hz >= 1.0 / 50.0)
{
#ifdef _WIN32 #ifdef _WIN32
Console::Update(); // to i tak trzeba wywoływać Console::Update(); // to i tak trzeba wywoływać
#endif #endif
m_userinterface->update(); m_userinterface->update();
if (mouseHold)
{
auto const mode = static_cast<editor_ui *>(m_userinterface.get())->mode();
auto const rotation_mode = static_cast<editor_ui *>(m_userinterface.get())->rot_mode();
auto const fixed_rotation_value = static_cast<editor_ui *>(m_userinterface.get())->rot_val();
int Action = GLFW_REPEAT;
int Button = GLFW_MOUSE_BUTTON_LEFT;
{
GfxRenderer->Pick_Node_Callback(
[this, mode, rotation_mode, fixed_rotation_value, Action, Button](scene::basic_node *node)
{
editor_ui *ui = static_cast<editor_ui *>(m_userinterface.get());
if (mode == nodebank_panel::BRUSH)
{
const std::string *src = ui->get_active_node_template();
// std::string name = "editor_" + std::to_string(LocalRandom(0.0, 100000.0));
std::string name = "editor_" + generate_uuid_v4();
if (!src)
return;
glm::vec3 newPos = GfxRenderer->Mouse_Position();
float distance = glm::distance(newPos, oldPos);
if (distance < ui->getSpacing())
return;
TAnimModel *cloned = simulation::State.create_model(*src, name, Camera.Pos + newPos);
oldPos = newPos;
if (!cloned)
return;
// if (!m_dragging)
// return;
m_node = cloned;
if (rotation_mode == functions_panel::RANDOM)
{
auto const rotation{glm::vec3{0, LocalRandom(0.0, 360.0), 0}};
m_editor.rotate(m_node, rotation, 1);
}
else if (rotation_mode == functions_panel::FIXED)
{
auto const rotation{glm::vec3{0, fixed_rotation_value, 0}};
m_editor.rotate(m_node, rotation, 0);
}
// Application.set_cursor( GLFW_CURSOR_DISABLED );
ui->set_node(m_node);
}
});
}
}
// decelerate camera // decelerate camera
Camera.Velocity *= 0.65; Camera.Velocity *= 0.65;
if( std::abs( Camera.Velocity.x ) < 0.01 ) { Camera.Velocity.x = 0.0; } if (std::abs(Camera.Velocity.x) < 0.01)
if( std::abs( Camera.Velocity.y ) < 0.01 ) { Camera.Velocity.y = 0.0; } {
if( std::abs( Camera.Velocity.z ) < 0.01 ) { Camera.Velocity.z = 0.0; } Camera.Velocity.x = 0.0;
}
if (std::abs(Camera.Velocity.y) < 0.01)
{
Camera.Velocity.y = 0.0;
}
if (std::abs(Camera.Velocity.z) < 0.01)
{
Camera.Velocity.z = 0.0;
}
fTime50Hz -= 1.0 / 50.0; fTime50Hz -= 1.0 / 50.0;
} }
@@ -90,8 +154,8 @@ editor_mode::update() {
return true; return true;
} }
void void editor_mode::update_camera(double const Deltatime)
editor_mode::update_camera( double const Deltatime ) { {
// uwzględnienie ruchu wywołanego klawiszami // uwzględnienie ruchu wywołanego klawiszami
Camera.Update(); Camera.Update();
@@ -102,26 +166,21 @@ editor_mode::update_camera( double const Deltatime ) {
} }
// maintenance method, called when the mode is activated // maintenance method, called when the mode is activated
void void editor_mode::enter()
editor_mode::enter() { {
m_statebackup = {Global.pCamera, FreeFlyModeFlag, Global.ControlPicking}; m_statebackup = {Global.pCamera, FreeFlyModeFlag, Global.ControlPicking};
Camera = Global.pCamera; Camera = Global.pCamera;
// NOTE: camera placement is effectively a copy of drivermode DistantView( true ) // NOTE: camera placement is effectively a copy of drivermode DistantView( true )
// TBD, TODO: refactor into a common vehicle method? // TBD, TODO: refactor into a common vehicle method?
if( false == FreeFlyModeFlag ) { if (false == FreeFlyModeFlag)
{
auto const *vehicle{Camera.m_owner}; auto const *vehicle{Camera.m_owner};
auto const cab { auto const cab{(vehicle->MoverParameters->CabOccupied == 0 ? 1 : vehicle->MoverParameters->CabOccupied)};
( vehicle->MoverParameters->CabOccupied == 0 ?
1 :
vehicle->MoverParameters->CabOccupied ) };
auto const left{vehicle->VectorLeft() * cab}; auto const left{vehicle->VectorLeft() * cab};
Camera.Pos = Camera.Pos = Math3D::vector3(Camera.Pos.x, vehicle->GetPosition().y, Camera.Pos.z) + left * vehicle->GetWidth() + Math3D::vector3(1.25 * left.x, 1.6, 1.25 * left.z);
Math3D::vector3( Camera.Pos.x, vehicle->GetPosition().y, Camera.Pos.z )
+ left * vehicle->GetWidth()
+ Math3D::vector3( 1.25 * left.x, 1.6, 1.25 * left.z );
Camera.m_owner = nullptr; Camera.m_owner = nullptr;
Camera.LookAt = vehicle->GetPosition(); Camera.LookAt = vehicle->GetPosition();
Camera.RaLook(); // jednorazowe przestawienie kamery Camera.RaLook(); // jednorazowe przestawienie kamery
@@ -134,26 +193,24 @@ editor_mode::enter() {
} }
// maintenance method, called when the mode is deactivated // maintenance method, called when the mode is deactivated
void void editor_mode::exit()
editor_mode::exit() { {
EditorModeFlag = false; EditorModeFlag = false;
Global.ControlPicking = m_statebackup.picking; Global.ControlPicking = m_statebackup.picking;
FreeFlyModeFlag = m_statebackup.freefly; FreeFlyModeFlag = m_statebackup.freefly;
Global.pCamera = m_statebackup.camera; Global.pCamera = m_statebackup.camera;
Application.set_cursor( Application.set_cursor((Global.ControlPicking ? GLFW_CURSOR_NORMAL : GLFW_CURSOR_DISABLED));
( Global.ControlPicking ?
GLFW_CURSOR_NORMAL :
GLFW_CURSOR_DISABLED ) );
if( false == Global.ControlPicking ) { if (false == Global.ControlPicking)
{
Application.set_cursor_pos(0, 0); Application.set_cursor_pos(0, 0);
} }
} }
void void editor_mode::on_key(int const Key, int const Scancode, int const Action, int const Mods)
editor_mode::on_key( int const Key, int const Scancode, int const Action, int const Mods ) { {
#ifndef __unix__ #ifndef __unix__
Global.shiftState = (Mods & GLFW_MOD_SHIFT) ? true : false; Global.shiftState = (Mods & GLFW_MOD_SHIFT) ? true : false;
Global.ctrlState = (Mods & GLFW_MOD_CONTROL) ? true : false; Global.ctrlState = (Mods & GLFW_MOD_CONTROL) ? true : false;
@@ -162,44 +219,60 @@ editor_mode::on_key( int const Key, int const Scancode, int const Action, int co
bool anyModifier = Mods & (GLFW_MOD_SHIFT | GLFW_MOD_CONTROL | GLFW_MOD_ALT); bool anyModifier = Mods & (GLFW_MOD_SHIFT | GLFW_MOD_CONTROL | GLFW_MOD_ALT);
// give the ui first shot at the input processing... // give the ui first shot at the input processing...
if( !anyModifier && true == m_userinterface->on_key( Key, Action ) ) { return; } if (!anyModifier && true == m_userinterface->on_key(Key, Action))
{
return;
}
// ...if the input is left untouched, pass it on // ...if the input is left untouched, pass it on
if( true == m_input.keyboard.key( Key, Action ) ) { return; } if (true == m_input.keyboard.key(Key, Action))
{
return;
}
if( Action == GLFW_RELEASE ) { return; } if (Action == GLFW_RELEASE)
{
return;
}
// legacy hardcoded keyboard commands // legacy hardcoded keyboard commands
// TODO: replace with current command system, move to input object(s) // TODO: replace with current command system, move to input object(s)
switch( Key ) { switch (Key)
{
case GLFW_KEY_F11: { case GLFW_KEY_F11:
{
if( Action != GLFW_PRESS ) { break; } if (Action != GLFW_PRESS)
{
break;
}
// mode switch // mode switch
// TODO: unsaved changes warning // TODO: unsaved changes warning
if( ( false == Global.ctrlState ) if ((false == Global.ctrlState) && (false == Global.shiftState))
&& ( false == Global.shiftState ) ) { {
Application.pop_mode(); Application.pop_mode();
} }
// scenery export // scenery export
if( Global.ctrlState if (Global.ctrlState && Global.shiftState)
&& Global.shiftState ) { {
simulation::State.export_as_text(Global.SceneryFile); simulation::State.export_as_text(Global.SceneryFile);
} }
break; break;
} }
case GLFW_KEY_F12: { case GLFW_KEY_F12:
{
// quick debug mode toggle // quick debug mode toggle
if( Global.ctrlState if (Global.ctrlState && Global.shiftState)
&& Global.shiftState ) { {
DebugModeFlag = !DebugModeFlag; DebugModeFlag = !DebugModeFlag;
} }
break; break;
} }
// TODO: ensure delete method can play nice with history stack // TODO: ensure delete method can play nice with history stack
case GLFW_KEY_DELETE: { case GLFW_KEY_DELETE:
{
TAnimModel *model = dynamic_cast<TAnimModel *>(m_node); TAnimModel *model = dynamic_cast<TAnimModel *>(m_node);
if (!model) if (!model)
break; break;
@@ -214,34 +287,45 @@ editor_mode::on_key( int const Key, int const Scancode, int const Action, int co
break; break;
} }
default: { default:
{
break; break;
} }
} }
} }
void void editor_mode::on_cursor_pos(double const Horizontal, double const Vertical)
editor_mode::on_cursor_pos( double const Horizontal, double const Vertical ) { {
auto const mousemove{glm::dvec2{Horizontal, Vertical} - m_input.mouse.position()}; auto const mousemove{glm::dvec2{Horizontal, Vertical} - m_input.mouse.position()};
m_input.mouse.position(Horizontal, Vertical); m_input.mouse.position(Horizontal, Vertical);
if( m_input.mouse.button( GLFW_MOUSE_BUTTON_LEFT ) == GLFW_RELEASE ) { return; } if (m_input.mouse.button(GLFW_MOUSE_BUTTON_LEFT) == GLFW_RELEASE)
if( m_node == nullptr ) { return; } {
return;
}
if (m_node == nullptr)
{
return;
}
if( m_takesnapshot ) { if (m_takesnapshot)
{
// take a snapshot of selected node(s) // take a snapshot of selected node(s)
// TODO: implement this // TODO: implement this
m_takesnapshot = false; m_takesnapshot = false;
} }
if( mode_translation() ) { if (mode_translation())
{
// move selected node // move selected node
if( mode_translation_vertical() ) { if (mode_translation_vertical())
{
auto const translation{mousemove.y * -0.01f}; auto const translation{mousemove.y * -0.01f};
m_editor.translate(m_node, translation); m_editor.translate(m_node, translation);
} }
else { else
{
auto const mouseworldposition{Camera.Pos + GfxRenderer->Mouse_Position()}; auto const mouseworldposition{Camera.Pos + GfxRenderer->Mouse_Position()};
m_editor.translate(m_node, mouseworldposition, mode_snap()); m_editor.translate(m_node, mouseworldposition, mode_snap());
} }
@@ -307,28 +391,33 @@ editor_mode::on_mouse_button( int const Button, int const Action, int const Mods
m_input.mouse.button( Button, Action ); m_input.mouse.button( Button, Action );
} }
*/ */
void void editor_mode::on_mouse_button(int const Button, int const Action, int const Mods)
editor_mode::on_mouse_button( int const Button, int const Action, int const Mods ) { {
// give the ui first shot at the input processing... // give the ui first shot at the input processing...
if( true == m_userinterface->on_mouse_button( Button, Action ) ) { return; }
if( Button == GLFW_MOUSE_BUTTON_LEFT ) { if (Button == GLFW_MOUSE_BUTTON_LEFT)
{
if( Action == GLFW_PRESS ) {
// left button press
auto const mode = static_cast<editor_ui *>(m_userinterface.get())->mode(); auto const mode = static_cast<editor_ui *>(m_userinterface.get())->mode();
auto const rotation_mode = static_cast<editor_ui *>(m_userinterface.get())->rot_mode(); auto const rotation_mode = static_cast<editor_ui *>(m_userinterface.get())->rot_mode();
auto const fixed_rotation_value = auto const fixed_rotation_value = static_cast<editor_ui *>(m_userinterface.get())->rot_val();
static_cast<editor_ui *>(m_userinterface.get())->rot_val();
if (true == m_userinterface->on_mouse_button(Button, Action))
{
return;
}
if (Action == GLFW_PRESS)
{
// left button press
mouseHold = true;
m_node = nullptr; m_node = nullptr;
GfxRenderer->Pick_Node_Callback([this, mode, rotation_mode, fixed_rotation_value, GfxRenderer->Pick_Node_Callback(
Action, Button](scene::basic_node *node) { [this, mode, rotation_mode, fixed_rotation_value, Action, Button](scene::basic_node *node)
{
editor_ui *ui = static_cast<editor_ui *>(m_userinterface.get()); editor_ui *ui = static_cast<editor_ui *>(m_userinterface.get());
if (mode == nodebank_panel::MODIFY)
if (mode == nodebank_panel::MODIFY) { {
if (!m_dragging) if (!m_dragging)
return; return;
@@ -339,8 +428,10 @@ editor_mode::on_mouse_button( int const Button, int const Action, int const Mods
// m_dragging = false; // m_dragging = false;
ui->set_node(m_node); ui->set_node(m_node);
} }
else if (mode == nodebank_panel::COPY) { else if (mode == nodebank_panel::COPY)
if (node && typeid(*node) == typeid(TAnimModel)) { {
if (node && typeid(*node) == typeid(TAnimModel))
{
std::string as_text; std::string as_text;
node->export_as_text(as_text); node->export_as_text(as_text);
@@ -349,9 +440,10 @@ editor_mode::on_mouse_button( int const Button, int const Action, int const Mods
m_dragging = false; m_dragging = false;
} }
else if (mode == nodebank_panel::ADD) { else if (mode == nodebank_panel::ADD)
{
const std::string *src = ui->get_active_node_template(); const std::string *src = ui->get_active_node_template();
std::string name = "editor_" + std::to_string(LocalRandom(0.0, 100000.0)); std::string name = "editor_" + generate_uuid_v4();
if (!src) if (!src)
return; return;
@@ -364,7 +456,6 @@ editor_mode::on_mouse_button( int const Button, int const Action, int const Mods
if (!m_dragging) if (!m_dragging)
return; return;
m_node = cloned; m_node = cloned;
if (rotation_mode == functions_panel::RANDOM) if (rotation_mode == functions_panel::RANDOM)
@@ -379,7 +470,6 @@ editor_mode::on_mouse_button( int const Button, int const Action, int const Mods
auto const rotation{glm::vec3{0, fixed_rotation_value, 0}}; auto const rotation{glm::vec3{0, fixed_rotation_value, 0}};
m_editor.rotate(m_node, rotation, 0); m_editor.rotate(m_node, rotation, 0);
} }
// Application.set_cursor( GLFW_CURSOR_DISABLED ); // Application.set_cursor( GLFW_CURSOR_DISABLED );
ui->set_node(m_node); ui->set_node(m_node);
@@ -388,7 +478,11 @@ editor_mode::on_mouse_button( int const Button, int const Action, int const Mods
m_dragging = true; m_dragging = true;
} }
else { else
{
if (Action == GLFW_RELEASE)
mouseHold = false;
// left button release // left button release
// if( m_node ) // if( m_node )
// Application.set_cursor( GLFW_CURSOR_NORMAL ); // Application.set_cursor( GLFW_CURSOR_NORMAL );
@@ -440,26 +534,26 @@ editor_mode::on_mouse_button( int const Button, int const Action, int const Mods
m_input.mouse.button(Button, Action); m_input.mouse.button(Button, Action);
} }
void void editor_mode::on_event_poll()
editor_mode::on_event_poll() { {
m_input.poll(); m_input.poll();
} }
bool bool editor_mode::is_command_processor() const
editor_mode::is_command_processor() const { {
return false; return false;
} }
bool bool editor_mode::mode_translation() const
editor_mode::mode_translation() const { {
return (false == Global.altState); return (false == Global.altState);
} }
bool bool editor_mode::mode_translation_vertical() const
editor_mode::mode_translation_vertical() const { {
return (true == Global.shiftState); return (true == Global.shiftState);
} }
@@ -480,8 +574,8 @@ bool editor_mode::mode_rotationZ() const
return ((true == Global.altState) && (true == Global.ctrlState) && (true == Global.shiftState)); return ((true == Global.altState) && (true == Global.ctrlState) && (true == Global.shiftState));
} }
bool bool editor_mode::mode_snap() const
editor_mode::mode_snap() const { {
return ((false == Global.altState) && (true == Global.ctrlState) && (false == Global.shiftState)); return ((false == Global.altState) && (true == Global.ctrlState) && (false == Global.shiftState));
} }

42
editormode.h
View File

@@ -16,7 +16,8 @@ http://mozilla.org/MPL/2.0/.
#include "sceneeditor.h" #include "sceneeditor.h"
#include "scenenode.h" #include "scenenode.h"
class editor_mode : public application_mode { class editor_mode : public application_mode
{
public: public:
// constructors // constructors
@@ -34,14 +35,21 @@ public:
void on_key(int Key, int Scancode, int Action, int Mods) override; void on_key(int Key, int Scancode, int Action, int Mods) override;
void on_cursor_pos(double Horizontal, double Vertical) override; void on_cursor_pos(double Horizontal, double Vertical) override;
void on_mouse_button(int Button, int Action, int Mods) override; void on_mouse_button(int Button, int Action, int Mods) override;
void on_scroll( double const Xoffset, double const Yoffset ) override { ; } void on_scroll(double const Xoffset, double const Yoffset) override
void on_window_resize( int w, int h ) override { ; } {
;
}
void on_window_resize(int w, int h) override
{
;
}
void on_event_poll() override; void on_event_poll() override;
bool is_command_processor() const override; bool is_command_processor() const override;
private: private:
// types // types
struct editormode_input { struct editormode_input
{
editormouse_input mouse; editormouse_input mouse;
editorkeyboard_input keyboard; editorkeyboard_input keyboard;
@@ -50,27 +58,21 @@ private:
void poll(); void poll();
}; };
struct state_backup { struct state_backup
{
TCamera camera; TCamera camera;
bool freefly; bool freefly;
bool picking; bool picking;
}; };
// methods // methods
void void update_camera(double const Deltatime);
update_camera( double const Deltatime ); bool mode_translation() const;
bool bool mode_translation_vertical() const;
mode_translation() const; bool mode_rotationY() const;
bool bool mode_rotationX() const;
mode_translation_vertical() const; bool mode_rotationZ() const;
bool bool mode_snap() const;
mode_rotationY() const;
bool
mode_rotationX() const;
bool
mode_rotationZ() const;
bool
mode_snap() const;
// members // members
state_backup m_statebackup; // helper, cached variables to be restored on mode exit state_backup m_statebackup; // helper, cached variables to be restored on mode exit
editormode_input m_input; editormode_input m_input;
@@ -80,4 +82,6 @@ private:
scene::basic_node *m_node; // currently selected scene node scene::basic_node *m_node; // currently selected scene node
bool m_takesnapshot{true}; // helper, hints whether snapshot of selected node(s) should be taken before modification bool m_takesnapshot{true}; // helper, hints whether snapshot of selected node(s) should be taken before modification
bool m_dragging = false; bool m_dragging = false;
glm::vec3 oldPos;
bool mouseHold{false};
}; };

42
editoruilayer.cpp
View File

@@ -14,7 +14,8 @@ http://mozilla.org/MPL/2.0/.
#include "scenenode.h" #include "scenenode.h"
#include "renderer.h" #include "renderer.h"
editor_ui::editor_ui() { editor_ui::editor_ui()
{
clear_panels(); clear_panels();
// bind the panels with ui object. maybe not the best place for this but, eh // bind the panels with ui object. maybe not the best place for this but, eh
@@ -25,12 +26,13 @@ editor_ui::editor_ui() {
} }
// updates state of UI elements // updates state of UI elements
void void editor_ui::update()
editor_ui::update() { {
set_tooltip(""); set_tooltip("");
if( Global.ControlPicking && DebugModeFlag ) { if (Global.ControlPicking && DebugModeFlag)
{
const auto sceneryNode = GfxRenderer->Pick_Node(); const auto sceneryNode = GfxRenderer->Pick_Node();
const std::string content = sceneryNode ? sceneryNode->tooltip() : ""; const std::string content = sceneryNode ? sceneryNode->tooltip() : "";
set_tooltip(content); set_tooltip(content);
@@ -41,37 +43,39 @@ editor_ui::update() {
m_functionspanel.update(m_node); m_functionspanel.update(m_node);
} }
void void editor_ui::set_node(scene::basic_node *Node)
editor_ui::set_node( scene::basic_node * Node ) { {
m_node = Node; m_node = Node;
} }
void void editor_ui::add_node_template(const std::string &desc)
editor_ui::add_node_template(const std::string &desc) { {
m_nodebankpanel.add_template(desc); m_nodebankpanel.add_template(desc);
} }
std::string const * std::string const *editor_ui::get_active_node_template()
editor_ui::get_active_node_template() { {
return m_nodebankpanel.get_active_template(); return m_nodebankpanel.get_active_template();
} }
nodebank_panel::edit_mode nodebank_panel::edit_mode editor_ui::mode()
editor_ui::mode() { {
return m_nodebankpanel.mode; return m_nodebankpanel.mode;
} }
float editor_ui::getSpacing()
{
return m_nodebankpanel.spacing;
}
functions_panel::rotation_mode functions_panel::rotation_mode editor_ui::rot_mode()
editor_ui::rot_mode() { {
return m_functionspanel.rot_mode; return m_functionspanel.rot_mode;
} }
float float editor_ui::rot_val()
editor_ui::rot_val() { {
return m_functionspanel.rot_value; return m_functionspanel.rot_value;
} }
bool bool editor_ui::rot_from_last()
editor_ui::rot_from_last()
{ {
return m_functionspanel.rot_from_last; return m_functionspanel.rot_from_last;
} }

31
editoruilayer.h
View File

@@ -12,35 +12,30 @@ http://mozilla.org/MPL/2.0/.
#include "uilayer.h" #include "uilayer.h"
#include "editoruipanels.h" #include "editoruipanels.h"
namespace scene { namespace scene
{
class basic_node; class basic_node;
} }
class editor_ui : public ui_layer { class editor_ui : public ui_layer
{
public: public:
// constructors // constructors
editor_ui(); editor_ui();
// methods // methods
// updates state of UI elements // updates state of UI elements
void void update() override;
update() override; void set_node(scene::basic_node *Node);
void void add_node_template(const std::string &desc);
set_node( scene::basic_node * Node ); float rot_val();
void bool rot_from_last();
add_node_template(const std::string &desc); functions_panel::rotation_mode rot_mode();
float const std::string *get_active_node_template();
rot_val(); nodebank_panel::edit_mode mode();
bool float getSpacing();
rot_from_last();
functions_panel::rotation_mode
rot_mode();
const std::string *
get_active_node_template();
nodebank_panel::edit_mode
mode();
private: private:
// members // members

408
editoruipanels.cpp
View File

@@ -17,14 +17,18 @@ http://mozilla.org/MPL/2.0/.
#include "Track.h" #include "Track.h"
#include "Event.h" #include "Event.h"
#include "MemCell.h" #include "MemCell.h"
#include "editoruilayer.h"
#include "renderer.h" #include "renderer.h"
#include "utilities.h" #include "utilities.h"
void void itemproperties_panel::update(scene::basic_node const *Node)
itemproperties_panel::update( scene::basic_node const *Node ) { {
m_node = Node; m_node = Node;
if( false == is_open ) { return; } if (false == is_open)
{
return;
}
text_lines.clear(); text_lines.clear();
m_grouplines.clear(); m_grouplines.clear();
@@ -35,7 +39,8 @@ itemproperties_panel::update( scene::basic_node const *Node ) {
auto const *node{Node}; auto const *node{Node};
auto const &camera{Global.pCamera}; auto const &camera{Global.pCamera};
if( node == nullptr ) { if (node == nullptr)
{
auto const mouseposition{camera.Pos + GfxRenderer->Mouse_Position()}; auto const mouseposition{camera.Pos + GfxRenderer->Mouse_Position()};
textline = "mouse location: [" + to_string(mouseposition.x, 2) + ", " + to_string(mouseposition.y, 2) + ", " + to_string(mouseposition.z, 2) + "]"; textline = "mouse location: [" + to_string(mouseposition.x, 2) + ", " + to_string(mouseposition.y, 2) + ", " + to_string(mouseposition.z, 2) + "]";
text_lines.emplace_back(textline, Global.UITextColor); text_lines.emplace_back(textline, Global.UITextColor);
@@ -56,142 +61,130 @@ itemproperties_panel::update( scene::basic_node const *Node ) {
} }
} }
*/ */
textline = textline = "name: " + (node->name().empty() ? "(none)" : Bezogonkow(node->name())) + "\nlocation: [" + to_string(node->location().x, 2) + ", " + to_string(node->location().y, 2) + ", " +
"name: " + ( node->name().empty() ? "(none)" : Bezogonkow( node->name() ) ) to_string(node->location().z, 2) + "]" +
+ "\nlocation: [" + to_string( node->location().x, 2 ) + ", " + to_string( node->location().y, 2 ) + ", " + to_string( node->location().z, 2 ) + "]" " (distance: " + to_string(glm::length(glm::dvec3{node->location().x, 0.0, node->location().z} - glm::dvec3{camera.Pos.x, 0.0, camera.Pos.z}), 1) + " m)";
+ " (distance: " + to_string( glm::length( glm::dvec3{ node->location().x, 0.0, node->location().z } -glm::dvec3{ camera.Pos.x, 0.0, camera.Pos.z } ), 1 ) + " m)";
text_lines.emplace_back(textline, Global.UITextColor); text_lines.emplace_back(textline, Global.UITextColor);
// subclass-specific data // subclass-specific data
// TBD, TODO: specialized data dump method in each node subclass, or data imports in the panel for provided subclass pointer? // TBD, TODO: specialized data dump method in each node subclass, or data imports in the panel for provided subclass pointer?
if( typeid( *node ) == typeid( TAnimModel ) ) { if (typeid(*node) == typeid(TAnimModel))
{
auto const *subnode = static_cast<TAnimModel const *>(node); auto const *subnode = static_cast<TAnimModel const *>(node);
textline = "angle_x: " + to_string(clamp_circular(subnode->vAngle.x, 360.f), 2) + " deg, " + textline = "angle_x: " + to_string(clamp_circular(subnode->vAngle.x, 360.f), 2) + " deg, " + "angle_y: " + to_string(clamp_circular(subnode->vAngle.y, 360.f), 2) + " deg, " +
"angle_y: " + to_string(clamp_circular(subnode->vAngle.y, 360.f), 2) + " deg, " +
"angle_z: " + to_string(clamp_circular(subnode->vAngle.z, 360.f), 2) + " deg"; "angle_z: " + to_string(clamp_circular(subnode->vAngle.z, 360.f), 2) + " deg";
textline += ";\nlights: "; textline += ";\nlights: ";
if( subnode->iNumLights > 0 ) { if (subnode->iNumLights > 0)
{
textline += '['; textline += '[';
for( int lightidx = 0; lightidx < subnode->iNumLights; ++lightidx ) { for (int lightidx = 0; lightidx < subnode->iNumLights; ++lightidx)
{
textline += to_string(subnode->lsLights[lightidx]); textline += to_string(subnode->lsLights[lightidx]);
if( lightidx < subnode->iNumLights - 1 ) { if (lightidx < subnode->iNumLights - 1)
{
textline += ", "; textline += ", ";
} }
} }
textline += ']'; textline += ']';
} }
else { else
{
textline += "(none)"; textline += "(none)";
} }
text_lines.emplace_back(textline, Global.UITextColor); text_lines.emplace_back(textline, Global.UITextColor);
// 3d shape // 3d shape
auto modelfile { ( auto modelfile{((subnode->pModel != nullptr) ? subnode->pModel->NameGet() : "(none)")};
( subnode->pModel != nullptr ) ? if (modelfile.find(szModelPath) == 0)
subnode->pModel->NameGet() : {
"(none)" ) };
if( modelfile.find( szModelPath ) == 0 ) {
// don't include 'models/' in the path // don't include 'models/' in the path
modelfile.erase(0, std::string{szModelPath}.size()); modelfile.erase(0, std::string{szModelPath}.size());
} }
// texture // texture
auto texturefile { ( auto texturefile{((subnode->Material()->replacable_skins[1] != null_handle) ? GfxRenderer->Material(subnode->Material()->replacable_skins[1])->GetName() : "(none)")};
( subnode->Material()->replacable_skins[ 1 ] != null_handle ) ? if (texturefile.find(szTexturePath) == 0)
GfxRenderer->Material( subnode->Material()->replacable_skins[ 1 ] )->GetName() : {
"(none)" ) };
if( texturefile.find( szTexturePath ) == 0 ) {
// don't include 'textures/' in the path // don't include 'textures/' in the path
texturefile.erase(0, std::string{szTexturePath}.size()); texturefile.erase(0, std::string{szTexturePath}.size());
} }
text_lines.emplace_back("mesh: " + modelfile, Global.UITextColor); text_lines.emplace_back("mesh: " + modelfile, Global.UITextColor);
text_lines.emplace_back("skin: " + texturefile, Global.UITextColor); text_lines.emplace_back("skin: " + texturefile, Global.UITextColor);
} }
else if( typeid( *node ) == typeid( TTrack ) ) { else if (typeid(*node) == typeid(TTrack))
{
auto const *subnode = static_cast<TTrack const *>(node); auto const *subnode = static_cast<TTrack const *>(node);
std::string isolatedlist; std::string isolatedlist;
for (const TIsolated *iso : subnode->Isolated) { for (const TIsolated *iso : subnode->Isolated)
{
if (!isolatedlist.empty()) if (!isolatedlist.empty())
isolatedlist += ", "; isolatedlist += ", ";
isolatedlist += iso->asName; isolatedlist += iso->asName;
} }
// basic attributes // basic attributes
textline = textline = "isolated: " + (!isolatedlist.empty() ? isolatedlist : "(none)") + "\nvelocity: " + to_string(subnode->SwitchExtension ? subnode->SwitchExtension->fVelocity : subnode->fVelocity) +
"isolated: " + ( !isolatedlist.empty() ? isolatedlist : "(none)" ) "\nwidth: " + to_string(subnode->fTrackWidth) + " m" + "\nfriction: " + to_string(subnode->fFriction, 2) + "\nquality: " + to_string(subnode->iQualityFlag);
+ "\nvelocity: " + to_string( subnode->SwitchExtension ? subnode->SwitchExtension->fVelocity : subnode->fVelocity )
+ "\nwidth: " + to_string( subnode->fTrackWidth ) + " m"
+ "\nfriction: " + to_string( subnode->fFriction, 2 )
+ "\nquality: " + to_string( subnode->iQualityFlag );
text_lines.emplace_back(textline, Global.UITextColor); text_lines.emplace_back(textline, Global.UITextColor);
// textures // textures
auto texturefile { ( auto texturefile{((subnode->m_material1 != null_handle) ? GfxRenderer->Material(subnode->m_material1)->GetName() : "(none)")};
( subnode->m_material1 != null_handle ) ? if (texturefile.find(szTexturePath) == 0)
GfxRenderer->Material( subnode->m_material1 )->GetName() : {
"(none)" ) };
if( texturefile.find( szTexturePath ) == 0 ) {
texturefile.erase(0, std::string{szTexturePath}.size()); texturefile.erase(0, std::string{szTexturePath}.size());
} }
auto texturefile2{ ( auto texturefile2{((subnode->m_material2 != null_handle) ? GfxRenderer->Material(subnode->m_material2)->GetName() : "(none)")};
( subnode->m_material2 != null_handle ) ? if (texturefile2.find(szTexturePath) == 0)
GfxRenderer->Material( subnode->m_material2 )->GetName() : {
"(none)" ) };
if( texturefile2.find( szTexturePath ) == 0 ) {
texturefile2.erase(0, std::string{szTexturePath}.size()); texturefile2.erase(0, std::string{szTexturePath}.size());
} }
textline = "skins:\n " + texturefile + "\n " + texturefile2; textline = "skins:\n " + texturefile + "\n " + texturefile2;
text_lines.emplace_back(textline, Global.UITextColor); text_lines.emplace_back(textline, Global.UITextColor);
// paths // paths
textline = "paths: "; textline = "paths: ";
for( auto const &path : subnode->m_paths ) { for (auto const &path : subnode->m_paths)
textline += {
"\n [" textline += "\n [" + to_string(path.points[segment_data::point::start].x, 3) + ", " + to_string(path.points[segment_data::point::start].y, 3) + ", " +
+ to_string( path.points[ segment_data::point::start ].x, 3 ) + ", " to_string(path.points[segment_data::point::start].z, 3) + "]->" + " [" + to_string(path.points[segment_data::point::end].x, 3) + ", " +
+ to_string( path.points[ segment_data::point::start ].y, 3 ) + ", " to_string(path.points[segment_data::point::end].y, 3) + ", " + to_string(path.points[segment_data::point::end].z, 3) + "] ";
+ to_string( path.points[ segment_data::point::start ].z, 3 ) + "]->"
+ " ["
+ to_string( path.points[ segment_data::point::end ].x, 3 ) + ", "
+ to_string( path.points[ segment_data::point::end ].y, 3 ) + ", "
+ to_string( path.points[ segment_data::point::end ].z, 3 ) + "] ";
} }
text_lines.emplace_back(textline, Global.UITextColor); text_lines.emplace_back(textline, Global.UITextColor);
// events // events
textline.clear(); textline.clear();
std::vector< std::pair< std::string, TTrack::event_sequence const * > > const eventsequences { std::vector<std::pair<std::string, TTrack::event_sequence const *>> const eventsequences{{"ev0", &subnode->m_events0}, {"ev0all", &subnode->m_events0all},
{ "ev0", &subnode->m_events0 }, { "ev0all", &subnode->m_events0all },
{"ev1", &subnode->m_events1}, {"ev1all", &subnode->m_events1all}, {"ev1", &subnode->m_events1}, {"ev1all", &subnode->m_events1all},
{"ev2", &subnode->m_events2}, {"ev2all", &subnode->m_events2all}}; {"ev2", &subnode->m_events2}, {"ev2all", &subnode->m_events2all}};
for( auto const &eventsequence : eventsequences ) { for (auto const &eventsequence : eventsequences)
{
if( eventsequence.second->empty() ) { continue; } if (eventsequence.second->empty())
{
continue;
}
textline += (textline.empty() ? "" : "\n") + eventsequence.first + ": ["; textline += (textline.empty() ? "" : "\n") + eventsequence.first + ": [";
for( auto const &event : *( eventsequence.second ) ) { for (auto const &event : *(eventsequence.second))
if( textline.back() != '[' ) { {
if (textline.back() != '[')
{
textline += ", "; textline += ", ";
} }
textline += ( textline += (event.second != nullptr ? Bezogonkow(event.second->m_name) : event.first + " (missing)");
event.second != nullptr ?
Bezogonkow( event.second->m_name ) :
event.first + " (missing)" );
} }
textline += "] "; textline += "] ";
} }
text_lines.emplace_back(textline, Global.UITextColor); text_lines.emplace_back(textline, Global.UITextColor);
} }
else if( typeid( *node ) == typeid( TMemCell ) ) { else if (typeid(*node) == typeid(TMemCell))
{
auto const *subnode = static_cast<TMemCell const *>(node); auto const *subnode = static_cast<TMemCell const *>(node);
textline = textline = "data: [" + subnode->Text() + "]" + " [" + to_string(subnode->Value1(), 2) + "]" + " [" + to_string(subnode->Value2(), 2) + "]";
"data: [" + subnode->Text() + "]"
+ " [" + to_string( subnode->Value1(), 2 ) + "]"
+ " [" + to_string( subnode->Value2(), 2 ) + "]";
text_lines.emplace_back(textline, Global.UITextColor); text_lines.emplace_back(textline, Global.UITextColor);
textline = "track: " + (subnode->asTrackName.empty() ? "(none)" : Bezogonkow(subnode->asTrackName)); textline = "track: " + (subnode->asTrackName.empty() ? "(none)" : Bezogonkow(subnode->asTrackName));
text_lines.emplace_back(textline, Global.UITextColor); text_lines.emplace_back(textline, Global.UITextColor);
@@ -200,12 +193,13 @@ itemproperties_panel::update( scene::basic_node const *Node ) {
update_group(); update_group();
} }
void void itemproperties_panel::update_group()
itemproperties_panel::update_group() { {
auto const grouphandle{m_node->group()}; auto const grouphandle{m_node->group()};
if( grouphandle == null_handle ) { if (grouphandle == null_handle)
{
m_grouphandle = null_handle; m_grouphandle = null_handle;
m_groupprefix.clear(); m_groupprefix.clear();
return; return;
@@ -213,77 +207,88 @@ itemproperties_panel::update_group() {
auto const &nodegroup{scene::Groups.group(grouphandle)}; auto const &nodegroup{scene::Groups.group(grouphandle)};
if( m_grouphandle != grouphandle ) { if (m_grouphandle != grouphandle)
{
// calculate group name from shared prefix of item names // calculate group name from shared prefix of item names
std::vector<std::reference_wrapper<std::string const>> names; std::vector<std::reference_wrapper<std::string const>> names;
// build list of custom item and event names // build list of custom item and event names
for( auto const *node : nodegroup.nodes ) { for (auto const *node : nodegroup.nodes)
{
auto const &name{node->name()}; auto const &name{node->name()};
if( name.empty() || name == "none" ) { continue; } if (name.empty() || name == "none")
{
continue;
}
names.emplace_back(name); names.emplace_back(name);
} }
for( auto const *event : nodegroup.events ) { for (auto const *event : nodegroup.events)
{
auto const &name{event->m_name}; auto const &name{event->m_name};
if( name.empty() || name == "none" ) { continue; } if (name.empty() || name == "none")
{
continue;
}
names.emplace_back(name); names.emplace_back(name);
} }
// find the common prefix // find the common prefix
if( names.size() > 1 ) { if (names.size() > 1)
{
m_groupprefix = names.front(); m_groupprefix = names.front();
for( auto const &name : names ) { for (auto const &name : names)
{
// NOTE: first calculation runs over two instances of the same name, but, eh // NOTE: first calculation runs over two instances of the same name, but, eh
auto const prefixlength{len_common_prefix(m_groupprefix, name)}; auto const prefixlength{len_common_prefix(m_groupprefix, name)};
if( prefixlength > 0 ) { if (prefixlength > 0)
{
m_groupprefix = m_groupprefix.substr(0, prefixlength); m_groupprefix = m_groupprefix.substr(0, prefixlength);
} }
else { else
{
m_groupprefix.clear(); m_groupprefix.clear();
break; break;
} }
} }
} }
else { else
{
// less than two names to compare means no prefix // less than two names to compare means no prefix
m_groupprefix.clear(); m_groupprefix.clear();
} }
m_grouphandle = grouphandle; m_grouphandle = grouphandle;
} }
m_grouplines.emplace_back( m_grouplines.emplace_back("nodes: " + to_string(static_cast<int>(nodegroup.nodes.size())) + "\nevents: " + to_string(static_cast<int>(nodegroup.events.size())), Global.UITextColor);
"nodes: " + to_string( static_cast<int>( nodegroup.nodes.size() ) ) m_grouplines.emplace_back("names prefix: " + (m_groupprefix.empty() ? "(none)" : m_groupprefix), Global.UITextColor);
+ "\nevents: " + to_string( static_cast<int>( nodegroup.events.size() ) ),
Global.UITextColor );
m_grouplines.emplace_back(
"names prefix: " + ( m_groupprefix.empty() ? "(none)" : m_groupprefix ),
Global.UITextColor );
} }
void itemproperties_panel::render()
{
void if (false == is_open)
itemproperties_panel::render() { {
return;
}
if (true == text_lines.empty())
{
return;
}
if( false == is_open ) { return; } auto flags = ImGuiWindowFlags_NoFocusOnAppearing | ImGuiWindowFlags_NoCollapse | (size.x > 0 ? ImGuiWindowFlags_NoResize : 0);
if( true == text_lines.empty() ) { return; }
auto flags = if (size.x > 0)
ImGuiWindowFlags_NoFocusOnAppearing {
| ImGuiWindowFlags_NoCollapse
| ( size.x > 0 ? ImGuiWindowFlags_NoResize : 0 );
if( size.x > 0 ) {
ImGui::SetNextWindowSize(ImVec2S(size.x, size.y)); ImGui::SetNextWindowSize(ImVec2S(size.x, size.y));
} }
if( size_min.x > 0 ) { if (size_min.x > 0)
{
ImGui::SetNextWindowSizeConstraints(ImVec2S(size_min.x, size_min.y), ImVec2(size_max.x, size_max.y)); ImGui::SetNextWindowSizeConstraints(ImVec2S(size_min.x, size_min.y), ImVec2(size_max.x, size_max.y));
} }
auto const panelname { ( auto const panelname{(title.empty() ? m_name : title) + "###" + m_name};
title.empty() ? if (true == ImGui::Begin(panelname.c_str(), nullptr, flags))
m_name : {
title )
+ "###" + m_name };
if( true == ImGui::Begin( panelname.c_str(), nullptr, flags ) ) {
// header section // header section
for( auto const &line : text_lines ) { for (auto const &line : text_lines)
{
ImGui::TextColored(ImVec4(line.color.r, line.color.g, line.color.b, line.color.a), line.data.c_str()); ImGui::TextColored(ImVec4(line.color.r, line.color.g, line.color.b, line.color.a), line.data.c_str());
} }
// group section // group section
@@ -292,24 +297,33 @@ itemproperties_panel::render() {
ImGui::End(); ImGui::End();
} }
bool bool itemproperties_panel::render_group()
itemproperties_panel::render_group() { {
if( m_node == nullptr ) { return false; } if (m_node == nullptr)
if( m_grouplines.empty() ) { return false; } {
return false;
}
if (m_grouplines.empty())
{
return false;
}
if( false == ImGui::CollapsingHeader( "Parent Group" ) ) { return false; } if (false == ImGui::CollapsingHeader("Parent Group"))
{
return false;
}
for( auto const &line : m_grouplines ) { for (auto const &line : m_grouplines)
{
ImGui::TextColored(ImVec4(line.color.r, line.color.g, line.color.b, line.color.a), line.data.c_str()); ImGui::TextColored(ImVec4(line.color.r, line.color.g, line.color.b, line.color.a), line.data.c_str());
} }
return true; return true;
} }
nodebank_panel::nodebank_panel(std::string const &Name, bool const Isopen) : ui_panel(Name, Isopen)
{
nodebank_panel::nodebank_panel( std::string const &Name, bool const Isopen ) : ui_panel( Name, Isopen ) {
size_min = {100, 50}; size_min = {100, 50};
size_max = {1000, 1000}; size_max = {1000, 1000};
@@ -319,44 +333,30 @@ nodebank_panel::nodebank_panel( std::string const &Name, bool const Isopen ) : u
file.open("nodebank.txt", std::ios_base::in | std::ios_base::binary); file.open("nodebank.txt", std::ios_base::in | std::ios_base::binary);
std::string line; std::string line;
while( std::getline( file, line ) ) { while (std::getline(file, line))
if( line.size() < 4 ) { {
if (line.size() < 4)
{
continue; continue;
} }
auto const labelend{line.find("node")}; auto const labelend{line.find("node")};
auto const nodedata { ( auto const nodedata{(labelend == std::string::npos ? "" : labelend == 0 ? line : line.substr(labelend))};
labelend == std::string::npos ? "" : auto const label{(labelend == std::string::npos ? line : labelend == 0 ? generate_node_label(nodedata) : line.substr(0, labelend))};
labelend == 0 ? line :
line.substr( labelend ) ) };
auto const label { (
labelend == std::string::npos ? line :
labelend == 0 ? generate_node_label( nodedata ) :
line.substr( 0, labelend ) ) };
m_nodebank.push_back({label, std::make_shared<std::string>(nodedata)}); m_nodebank.push_back({label, std::make_shared<std::string>(nodedata)});
} }
// sort alphabetically content of each group // sort alphabetically content of each group
auto groupbegin{m_nodebank.begin()}; auto groupbegin{m_nodebank.begin()};
auto groupend{groupbegin}; auto groupend{groupbegin};
while( groupbegin != m_nodebank.end() ) { while (groupbegin != m_nodebank.end())
groupbegin = {
std::find_if( groupbegin = std::find_if(groupend, m_nodebank.end(), [](auto const &Entry) { return (false == Entry.second->empty()); });
groupend, m_nodebank.end(), groupend = std::find_if(groupbegin, m_nodebank.end(), [](auto const &Entry) { return (Entry.second->empty()); });
[]( auto const &Entry ) { std::sort(groupbegin, groupend, [](auto const &Left, auto const &Right) { return (Left.first < Right.first); });
return ( false == Entry.second->empty() ); } );
groupend =
std::find_if(
groupbegin, m_nodebank.end(),
[]( auto const &Entry ) {
return ( Entry.second->empty() ); } );
std::sort(
groupbegin, groupend,
[]( auto const &Left, auto const &Right ) {
return ( Left.first < Right.first ); } );
} }
} }
void void nodebank_panel::nodebank_reload()
nodebank_panel::nodebank_reload(){ {
m_nodebank.clear(); m_nodebank.clear();
std::ifstream file; std::ifstream file;
file.open("nodebank.txt", std::ios_base::in | std::ios_base::binary); file.open("nodebank.txt", std::ios_base::in | std::ios_base::binary);
@@ -368,12 +368,8 @@ nodebank_panel::nodebank_reload(){
continue; continue;
} }
auto const labelend{line.find("node")}; auto const labelend{line.find("node")};
auto const nodedata{ auto const nodedata{(labelend == std::string::npos ? "" : labelend == 0 ? line : line.substr(labelend))};
(labelend == std::string::npos ? "" : labelend == 0 ? line : line.substr(labelend))}; auto const label{(labelend == std::string::npos ? line : labelend == 0 ? generate_node_label(nodedata) : line.substr(0, labelend))};
auto const label{
(labelend == std::string::npos ?
line :
labelend == 0 ? generate_node_label(nodedata) : line.substr(0, labelend))};
m_nodebank.push_back({label, std::make_shared<std::string>(nodedata)}); m_nodebank.push_back({label, std::make_shared<std::string>(nodedata)});
} }
@@ -382,44 +378,41 @@ nodebank_panel::nodebank_reload(){
auto groupend{groupbegin}; auto groupend{groupbegin};
while (groupbegin != m_nodebank.end()) while (groupbegin != m_nodebank.end())
{ {
groupbegin = std::find_if(groupend, m_nodebank.end(), [](auto const &Entry) { groupbegin = std::find_if(groupend, m_nodebank.end(), [](auto const &Entry) { return (false == Entry.second->empty()); });
return (false == Entry.second->empty()); groupend = std::find_if(groupbegin, m_nodebank.end(), [](auto const &Entry) { return (Entry.second->empty()); });
}); std::sort(groupbegin, groupend, [](auto const &Left, auto const &Right) { return (Left.first < Right.first); });
groupend = std::find_if(groupbegin, m_nodebank.end(),
[](auto const &Entry) { return (Entry.second->empty()); });
std::sort(groupbegin, groupend,
[](auto const &Left, auto const &Right) { return (Left.first < Right.first); });
} }
} }
void void nodebank_panel::render()
nodebank_panel::render() { {
if( false == is_open ) { return; } if (false == is_open)
{
return;
}
auto flags = auto flags = ImGuiWindowFlags_NoFocusOnAppearing | ImGuiWindowFlags_NoCollapse | (size.x > 0 ? ImGuiWindowFlags_NoResize : 0);
ImGuiWindowFlags_NoFocusOnAppearing
| ImGuiWindowFlags_NoCollapse
| ( size.x > 0 ? ImGuiWindowFlags_NoResize : 0 );
if( size.x > 0 ) { if (size.x > 0)
{
ImGui::SetNextWindowSize(ImVec2S(size.x, size.y)); ImGui::SetNextWindowSize(ImVec2S(size.x, size.y));
} }
if( size_min.x > 0 ) { if (size_min.x > 0)
{
ImGui::SetNextWindowSizeConstraints(ImVec2S(size_min.x, size_min.y), ImVec2S(size_max.x, size_max.y)); ImGui::SetNextWindowSizeConstraints(ImVec2S(size_min.x, size_min.y), ImVec2S(size_max.x, size_max.y));
} }
auto const panelname { ( auto const panelname{(title.empty() ? name() : title) + "###" + name()};
title.empty() ?
name() :
title )
+ "###" + name() };
if( true == ImGui::Begin( panelname.c_str(), nullptr, flags ) ) { if (true == ImGui::Begin(panelname.c_str(), nullptr, flags))
{
ImGui::RadioButton("Modify node", (int *)&mode, MODIFY); ImGui::RadioButton("Modify node", (int *)&mode, MODIFY);
ImGui::SameLine(); ImGui::SameLine();
ImGui::RadioButton("Insert from bank", (int *)&mode, ADD); ImGui::RadioButton("Insert from bank", (int *)&mode, ADD);
ImGui::SameLine(); ImGui::SameLine();
ImGui::RadioButton("Brush mode", (int *)&mode, BRUSH);
ImGui::SameLine();
ImGui::RadioButton("Copy to bank", (int *)&mode, COPY); ImGui::RadioButton("Copy to bank", (int *)&mode, COPY);
ImGui::SameLine(); ImGui::SameLine();
if (ImGui::Button("Reload Nodebank")) if (ImGui::Button("Reload Nodebank"))
@@ -427,6 +420,10 @@ nodebank_panel::render() {
nodebank_reload(); nodebank_reload();
} }
if (mode == BRUSH)
{
ImGui::SliderFloat("Spacing", &spacing, 0.1f, 20.0f, "%.1f m");
}
ImGui::PushItemWidth(-1); ImGui::PushItemWidth(-1);
ImGui::InputTextWithHint("Search", "Search node bank", m_nodesearch, IM_ARRAYSIZE(m_nodesearch)); ImGui::InputTextWithHint("Search", "Search node bank", m_nodesearch, IM_ARRAYSIZE(m_nodesearch));
@@ -435,17 +432,21 @@ nodebank_panel::render() {
auto idx{0}; auto idx{0};
auto isvisible{false}; auto isvisible{false};
auto const searchfilter{std::string(m_nodesearch)}; auto const searchfilter{std::string(m_nodesearch)};
for (auto const &entry : m_nodebank) { for (auto const &entry : m_nodebank)
if( entry.second->empty() ) { {
if (entry.second->empty())
{
// special case, header indicator // special case, header indicator
isvisible = ImGui::CollapsingHeader(entry.first.c_str()); isvisible = ImGui::CollapsingHeader(entry.first.c_str());
} }
else { else
if( false == isvisible ) { {
if (false == isvisible)
{
continue; continue;
} }
if( ( false == searchfilter.empty() ) if ((false == searchfilter.empty()) && (false == contains(entry.first, searchfilter)))
&& ( false == contains( entry.first, searchfilter ) ) ) { {
continue; continue;
} }
auto const label{" " + entry.first + "##" + std::to_string(idx)}; auto const label{" " + entry.first + "##" + std::to_string(idx)};
@@ -461,8 +462,8 @@ nodebank_panel::render() {
ImGui::End(); ImGui::End();
} }
void void nodebank_panel::add_template(const std::string &desc)
nodebank_panel::add_template(const std::string &desc) { {
auto const label{generate_node_label(desc)}; auto const label{generate_node_label(desc)};
m_nodebank.push_back({label, std::make_shared<std::string>(desc)}); m_nodebank.push_back({label, std::make_shared<std::string>(desc)});
@@ -472,12 +473,13 @@ nodebank_panel::add_template(const std::string &desc) {
file << label << " " << desc; file << label << " " << desc;
} }
const std::string *nodebank_panel::get_active_template() { const std::string *nodebank_panel::get_active_template()
{
return m_selectedtemplate.get(); return m_selectedtemplate.get();
} }
std::string std::string nodebank_panel::generate_node_label(std::string Input) const
nodebank_panel::generate_node_label( std::string Input ) const { {
auto tokenizer{cParser(Input)}; auto tokenizer{cParser(Input)};
tokenizer.getTokens(9, false); // skip leading tokens tokenizer.getTokens(9, false); // skip leading tokens
@@ -486,10 +488,7 @@ nodebank_panel::generate_node_label( std::string Input ) const {
replace_slashes(model); replace_slashes(model);
erase_extension(model); erase_extension(model);
replace_slashes(texture); replace_slashes(texture);
return ( return (texture == "none" ? model : model + " (" + texture + ")");
texture == "none" ?
model :
model + " (" + texture + ")" );
} }
void functions_panel::update(scene::basic_node const *Node) void functions_panel::update(scene::basic_node const *Node)
@@ -509,44 +508,41 @@ void functions_panel::update(scene::basic_node const *Node)
// scenario inspector // scenario inspector
auto const *node{Node}; auto const *node{Node};
auto const &camera{Global.pCamera}; auto const &camera{Global.pCamera};
} }
void void functions_panel::render()
functions_panel::render() { {
if( false == is_open ) { return; } if (false == is_open)
{
return;
}
auto flags = auto flags = ImGuiWindowFlags_NoFocusOnAppearing | ImGuiWindowFlags_NoCollapse | (size.x > 0 ? ImGuiWindowFlags_NoResize : 0);
ImGuiWindowFlags_NoFocusOnAppearing
| ImGuiWindowFlags_NoCollapse
| ( size.x > 0 ? ImGuiWindowFlags_NoResize : 0 );
if( size.x > 0 ) { if (size.x > 0)
{
ImGui::SetNextWindowSize(ImVec2S(size.x, size.y)); ImGui::SetNextWindowSize(ImVec2S(size.x, size.y));
} }
if( size_min.x > 0 ) { if (size_min.x > 0)
{
ImGui::SetNextWindowSizeConstraints(ImVec2S(size_min.x, size_min.y), ImVec2(size_max.x, size_max.y)); ImGui::SetNextWindowSizeConstraints(ImVec2S(size_min.x, size_min.y), ImVec2(size_max.x, size_max.y));
} }
auto const panelname { ( auto const panelname{(title.empty() ? m_name : title) + "###" + m_name};
title.empty() ? if (true == ImGui::Begin(panelname.c_str(), nullptr, flags))
m_name : {
title )
+ "###" + m_name };
if( true == ImGui::Begin( panelname.c_str(), nullptr, flags ) ) {
// header section // header section
ImGui::RadioButton("Random rotation", (int *)&rot_mode, RANDOM); ImGui::RadioButton("Random rotation", (int *)&rot_mode, RANDOM);
ImGui::RadioButton("Fixed rotation", (int *)&rot_mode, FIXED); ImGui::RadioButton("Fixed rotation", (int *)&rot_mode, FIXED);
if(rot_mode == FIXED){ if (rot_mode == FIXED)
{
// ImGui::Checkbox("Get rotation from last object", &rot_from_last); // ImGui::Checkbox("Get rotation from last object", &rot_from_last);
ImGui::SliderFloat("Rotation Value", &rot_value, 0.0f, 360.0f, "%.1f"); ImGui::SliderFloat("Rotation Value", &rot_value, 0.0f, 360.0f, "%.1f");
}; };
ImGui::RadioButton("Default rotation", (int *)&rot_mode, DEFAULT); ImGui::RadioButton("Default rotation", (int *)&rot_mode, DEFAULT);
for( auto const &line : text_lines ) { for (auto const &line : text_lines)
{
ImGui::TextColored(ImVec4(line.color.r, line.color.g, line.color.b, line.color.a), line.data.c_str()); ImGui::TextColored(ImVec4(line.color.r, line.color.g, line.color.b, line.color.a), line.data.c_str());
} }
} }

17
editoruipanels.h
View File

@@ -26,12 +26,11 @@ struct item_properties {
changeable<glm::vec3> rotation {}; changeable<glm::vec3> rotation {};
}; };
*/ */
class itemproperties_panel : public ui_panel { class itemproperties_panel : public ui_panel
{
public: public:
itemproperties_panel( std::string const &Name, bool const Isopen ) itemproperties_panel(std::string const &Name, bool const Isopen) : ui_panel(Name, Isopen) {}
: ui_panel( Name, Isopen )
{}
void update(scene::basic_node const *Node); void update(scene::basic_node const *Node);
void render() override; void render() override;
@@ -48,10 +47,12 @@ private:
std::vector<text_line> m_grouplines; std::vector<text_line> m_grouplines;
}; };
class nodebank_panel : public ui_panel { class nodebank_panel : public ui_panel
{
public: public:
enum edit_mode { enum edit_mode
{
MODIFY, MODIFY,
COPY, COPY,
ADD, ADD,
@@ -59,6 +60,8 @@ public:
}; };
edit_mode mode = MODIFY; edit_mode mode = MODIFY;
float spacing{1.0f};
nodebank_panel(std::string const &Name, bool const Isopen); nodebank_panel(std::string const &Name, bool const Isopen);
void nodebank_reload(); void nodebank_reload();
void render() override; void render() override;
@@ -94,11 +97,9 @@ class functions_panel : public ui_panel
void update(scene::basic_node const *Node); void update(scene::basic_node const *Node);
void render() override; void render() override;
private: private:
// methods // methods
// members // members
scene::basic_node const *m_node{nullptr}; // scene node bound to the panel scene::basic_node const *m_node{nullptr}; // scene node bound to the panel
scene::group_handle m_grouphandle{null_handle}; // scene group bound to the panel scene::group_handle m_grouphandle{null_handle}; // scene group bound to the panel

43
uilayer.cpp
View File

@@ -55,13 +55,11 @@ void ui_panel::render()
ImGui::SetNextWindowSizeConstraints(ImVec2S(size_min.x, size_min.y), ImVec2S(size_max.x, size_max.y)); ImGui::SetNextWindowSizeConstraints(ImVec2S(size_min.x, size_min.y), ImVec2S(size_max.x, size_max.y));
auto const panelname{(title.empty() ? m_name : title) + "###" + m_name}; auto const panelname{(title.empty() ? m_name : title) + "###" + m_name};
if (ImGui::Begin(panelname.c_str(), &is_open, flags)) { if (ImGui::Begin(panelname.c_str(), &is_open, flags))
{
render_contents(); render_contents();
popups.remove_if([](const std::unique_ptr<ui::popup> &popup) popups.remove_if([](const std::unique_ptr<ui::popup> &popup) { return popup->render(); });
{
return popup->render();
});
} }
ImGui::End(); ImGui::End();
@@ -138,7 +136,8 @@ void ui_layer::load_random_background()
if (f.is_regular_file()) if (f.is_regular_file())
images.emplace_back(std::filesystem::relative(f.path(), "textures/").string()); images.emplace_back(std::filesystem::relative(f.path(), "textures/").string());
if (!images.empty()) { if (!images.empty())
{
std::string &selected = images[std::lround(LocalRandom(images.size() - 1))]; std::string &selected = images[std::lround(LocalRandom(images.size() - 1))];
set_background(selected); set_background(selected);
} }
@@ -219,8 +218,7 @@ bool ui_layer::init(GLFWwindow *Window)
// m_imguiio->ConfigFlags |= ImGuiConfigFlags_NavEnableKeyboard; // m_imguiio->ConfigFlags |= ImGuiConfigFlags_NavEnableKeyboard;
// m_imguiio->ConfigFlags |= ImGuiConfigFlags_NavEnableGamepad; // m_imguiio->ConfigFlags |= ImGuiConfigFlags_NavEnableGamepad;
static const ImWchar ranges[] = static const ImWchar ranges[] = {
{
0x0020, 0x00FF, // Basic Latin + Latin Supplement 0x0020, 0x00FF, // Basic Latin + Latin Supplement
0x0100, 0x017F, // Latin Extended-A 0x0100, 0x017F, // Latin Extended-A
0x2070, 0x2079, // superscript 0x2070, 0x2079, // superscript
@@ -269,27 +267,33 @@ bool ui_layer::on_key(int const Key, int const Action)
{ {
if (Action == GLFW_PRESS) if (Action == GLFW_PRESS)
{ {
if (Key == GLFW_KEY_PRINT_SCREEN) { if (Key == GLFW_KEY_PRINT_SCREEN)
{
Application.queue_screenshot(); Application.queue_screenshot();
return true; return true;
} }
if (Key == GLFW_KEY_F9) { if (Key == GLFW_KEY_F9)
{
m_logpanel.is_open = !m_logpanel.is_open; m_logpanel.is_open = !m_logpanel.is_open;
return true; return true;
} }
if (Key == GLFW_KEY_F10) { if (Key == GLFW_KEY_F10)
{
m_quit_active = !m_quit_active; m_quit_active = !m_quit_active;
return true; return true;
} }
if (m_quit_active) if (m_quit_active)
{ {
if (Key == GLFW_KEY_Y) { if (Key == GLFW_KEY_Y)
{
Application.queue_quit(false); Application.queue_quit(false);
return true; return true;
} else if (Key == GLFW_KEY_N) { }
else if (Key == GLFW_KEY_N)
{
m_quit_active = false; m_quit_active = false;
return true; return true;
} }
@@ -315,13 +319,13 @@ void ui_layer::on_window_resize(int w, int h)
panel->on_window_resize(w, h); panel->on_window_resize(w, h);
} }
void ui_layer::update() void ui_layer::update()
{ {
for (auto *panel : m_panels) for (auto *panel : m_panels)
panel->update(); panel->update();
for (auto it = m_ownedpanels.rbegin(); it != m_ownedpanels.rend(); it++) { for (auto it = m_ownedpanels.rbegin(); it != m_ownedpanels.rend(); it++)
{
(*it)->update(); (*it)->update();
if (!(*it)->is_open) if (!(*it)->is_open)
m_ownedpanels.erase(std::next(it).base()); m_ownedpanels.erase(std::next(it).base());
@@ -408,7 +412,8 @@ void ui_layer::clear_panels()
void ui_layer::add_owned_panel(ui_panel *Panel) void ui_layer::add_owned_panel(ui_panel *Panel)
{ {
for (auto &panel : m_ownedpanels) for (auto &panel : m_ownedpanels)
if (panel->name() == Panel->name()) { if (panel->name() == Panel->name())
{
delete Panel; delete Panel;
return; return;
} }
@@ -443,7 +448,8 @@ void ui_layer::render_menu_contents()
if (ImGui::BeginMenu(STR_C("General"))) if (ImGui::BeginMenu(STR_C("General")))
{ {
bool flag = DebugModeFlag; bool flag = DebugModeFlag;
if (ImGui::MenuItem(STR_C("Debug mode"), nullptr, &flag)) { if (ImGui::MenuItem(STR_C("Debug mode"), nullptr, &flag))
{
command_relay relay; command_relay relay;
relay.post(user_command::debugtoggle, 0.0, 0.0, GLFW_RELEASE, 0); relay.post(user_command::debugtoggle, 0.0, 0.0, GLFW_RELEASE, 0);
} }
@@ -467,7 +473,8 @@ void ui_layer::render_menu_contents()
if (ImGui::BeginMenu(STR_C("Windows"))) if (ImGui::BeginMenu(STR_C("Windows")))
{ {
ImGui::MenuItem(STR_C("Log"), "F9", &m_logpanel.is_open); ImGui::MenuItem(STR_C("Log"), "F9", &m_logpanel.is_open);
if (DebugModeFlag) { if (DebugModeFlag)
{
ImGui::MenuItem(STR_C("ImGui Demo"), nullptr, &m_imgui_demo); ImGui::MenuItem(STR_C("ImGui Demo"), nullptr, &m_imgui_demo);
bool ret = ImGui::MenuItem(STR_C("Headlight config"), nullptr, GfxRenderer->Debug_Ui_State(std::nullopt)); bool ret = ImGui::MenuItem(STR_C("Headlight config"), nullptr, GfxRenderer->Debug_Ui_State(std::nullopt));

290
utilities.cpp
View File

@@ -53,7 +53,8 @@ double Min0R(double x1, double x2)
// shitty replacement for Borland timestamp function // shitty replacement for Borland timestamp function
// TODO: replace with something sensible // TODO: replace with something sensible
std::string Now() { std::string Now()
{
std::time_t timenow = std::time(nullptr); std::time_t timenow = std::time(nullptr);
std::tm tm = *std::localtime(&timenow); std::tm tm = *std::localtime(&timenow);
@@ -65,7 +66,8 @@ std::string Now() {
// zwraca różnicę czasu // zwraca różnicę czasu
// jeśli pierwsza jest aktualna, a druga rozkładowa, to ujemna oznacza opóżnienie // jeśli pierwsza jest aktualna, a druga rozkładowa, to ujemna oznacza opóżnienie
// na dłuższą metę trzeba uwzględnić datę, jakby opóżnienia miały przekraczać 12h (towarowych) // na dłuższą metę trzeba uwzględnić datę, jakby opóżnienia miały przekraczać 12h (towarowych)
double CompareTime(double t1h, double t1m, double t2h, double t2m) { double CompareTime(double t1h, double t1m, double t2h, double t2m)
{
if ((t2h < 0)) if ((t2h < 0))
return 0; return 0;
@@ -80,28 +82,35 @@ double CompareTime(double t1h, double t1m, double t2h, double t2m) {
} }
} }
bool SetFlag( int &Flag, int const Value ) { bool SetFlag(int &Flag, int const Value)
{
if( Value > 0 ) { if (Value > 0)
if( false == TestFlag( Flag, Value ) ) { {
if (false == TestFlag(Flag, Value))
{
Flag |= Value; Flag |= Value;
return true; // true, gdy było wcześniej 0 i zostało ustawione return true; // true, gdy było wcześniej 0 i zostało ustawione
} }
} }
else if( Value < 0 ) { else if (Value < 0)
{
// Value jest ujemne, czyli zerowanie flagi // Value jest ujemne, czyli zerowanie flagi
return ClearFlag(Flag, -Value); return ClearFlag(Flag, -Value);
} }
return false; return false;
} }
bool ClearFlag( int &Flag, int const Value ) { bool ClearFlag(int &Flag, int const Value)
{
if( true == TestFlag( Flag, Value ) ) { if (true == TestFlag(Flag, Value))
{
Flag &= ~Value; Flag &= ~Value;
return true; return true;
} }
else { else
{
return false; return false;
} }
} }
@@ -119,6 +128,31 @@ int RandomInt(int min, int max)
return dist(engine); return dist(engine);
} }
std::string generate_uuid_v4()
{
std::random_device rd;
std::mt19937 gen(rd());
std::uniform_int_distribution<int> dist(0, 255);
std::array<uint8_t, 16> bytes;
for (auto &b : bytes)
b = static_cast<uint8_t>(dist(gen));
// UUID v4 (RFC 4122)
bytes[6] = (bytes[6] & 0x0F) | 0x40;
bytes[8] = (bytes[8] & 0x3F) | 0x80;
char buf[37]; // 36 znaków + \0
std::snprintf(buf, sizeof(buf),
"%02x%02x%02x%02x-"
"%02x%02x-"
"%02x%02x-"
"%02x%02x-"
"%02x%02x%02x%02x%02x%02x",
bytes[0], bytes[1], bytes[2], bytes[3], bytes[4], bytes[5], bytes[6], bytes[7], bytes[8], bytes[9], bytes[10], bytes[11], bytes[12], bytes[13], bytes[14], bytes[15]);
return std::string(buf);
}
double LocalRandom(double a, double b) double LocalRandom(double a, double b)
{ {
@@ -129,8 +163,7 @@ double LocalRandom(double a, double b)
bool FuzzyLogic(double Test, double Threshold, double Probability) bool FuzzyLogic(double Test, double Threshold, double Probability)
{ {
if ((Test > Threshold) && (!DebugModeFlag)) if ((Test > Threshold) && (!DebugModeFlag))
return return (Random() < Probability * Threshold * 1.0 / Test) /*im wiekszy Test tym wieksza szansa*/;
(Random() < Probability * Threshold * 1.0 / Test) /*im wiekszy Test tym wieksza szansa*/;
else else
return false; return false;
} }
@@ -138,8 +171,7 @@ bool FuzzyLogic(double Test, double Threshold, double Probability)
bool FuzzyLogicAI(double Test, double Threshold, double Probability) bool FuzzyLogicAI(double Test, double Threshold, double Probability)
{ {
if ((Test > Threshold)) if ((Test > Threshold))
return return (Random() < Probability * Threshold * 1.0 / Test) /*im wiekszy Test tym wieksza szansa*/;
(Random() < Probability * Threshold * 1.0 / Test) /*im wiekszy Test tym wieksza szansa*/;
else else
return false; return false;
} }
@@ -162,12 +194,20 @@ std::string DWE(std::string s) /*Delete After Equal sign*/
std::string ExchangeCharInString(std::string const &Source, char const From, char const To) std::string ExchangeCharInString(std::string const &Source, char const From, char const To)
{ {
std::string replacement; replacement.reserve( Source.size() ); std::string replacement;
std::for_each( replacement.reserve(Source.size());
std::begin( Source ), std::end( Source ), std::for_each(std::begin(Source), std::end(Source),
[&](char const idx) { [&](char const idx)
if( idx != From ) { replacement += idx; } {
else { replacement += To; } } ); if (idx != From)
{
replacement += idx;
}
else
{
replacement += To;
}
});
return replacement; return replacement;
} }
@@ -203,15 +243,14 @@ std::vector<std::string> Split(const std::string &s)
return elems; return elems;
} }
std::pair<std::string, int> std::pair<std::string, int> split_string_and_number(std::string const &Key)
split_string_and_number( std::string const &Key ) { {
auto const indexstart{Key.find_first_of("-1234567890")}; auto const indexstart{Key.find_first_of("-1234567890")};
auto const indexend{Key.find_first_not_of("-1234567890", indexstart)}; auto const indexend{Key.find_first_not_of("-1234567890", indexstart)};
if( indexstart != std::string::npos ) { if (indexstart != std::string::npos)
return { {
Key.substr( 0, indexstart ), return {Key.substr(0, indexstart), std::stoi(Key.substr(indexstart, indexend - indexstart))};
std::stoi( Key.substr( indexstart, indexend - indexstart ) ) };
} }
return {Key, 0}; return {Key, 0};
} }
@@ -285,23 +324,18 @@ bool string_starts_with(const std::string &string, const std::string &begin)
std::string const fractionlabels[] = {" ", u8"¹", u8"²", u8"³", u8"⁴", u8"⁵", u8"⁶", u8"⁷", u8"⁸", u8"⁹"}; std::string const fractionlabels[] = {" ", u8"¹", u8"²", u8"³", u8"⁴", u8"⁵", u8"⁶", u8"⁷", u8"⁸", u8"⁹"};
std::string to_minutes_str( float const Minutes, bool const Leadingzero, int const Width ) { std::string to_minutes_str(float const Minutes, bool const Leadingzero, int const Width)
{
float minutesintegral; float minutesintegral;
auto const minutesfractional{std::modf(Minutes, &minutesintegral)}; auto const minutesfractional{std::modf(Minutes, &minutesintegral)};
auto const width{Width - 1}; auto const width{Width - 1};
auto minutes = ( auto minutes = (std::string(width - 1, ' ') + (Leadingzero ? to_string(100 + minutesintegral).substr(1, 2) : to_string(minutesintegral, 0)));
std::string( width - 1, ' ' ) return (minutes.substr(minutes.size() - width, width) + fractionlabels[static_cast<int>(std::floor(minutesfractional * 10 + 0.1))]);
+ ( Leadingzero ?
to_string( 100 + minutesintegral ).substr( 1, 2 ) :
to_string( minutesintegral, 0 ) ) );
return (
minutes.substr( minutes.size() - width, width )
+ fractionlabels[ static_cast<int>( std::floor( minutesfractional * 10 + 0.1 ) ) ] );
} }
int stol_def(const std::string &str, const int &DefaultValue)
int stol_def(const std::string &str, const int &DefaultValue) { {
int result{DefaultValue}; int result{DefaultValue};
std::stringstream converter; std::stringstream converter;
@@ -310,49 +344,44 @@ int stol_def(const std::string &str, const int &DefaultValue) {
return result; return result;
} }
std::string ToLower(std::string const &text) { std::string ToLower(std::string const &text)
{
auto lowercase{text}; auto lowercase{text};
std::transform( std::transform(std::begin(text), std::end(text), std::begin(lowercase), [](unsigned char c) { return std::tolower(c); });
std::begin( text ), std::end( text ),
std::begin( lowercase ),
[]( unsigned char c ) { return std::tolower( c ); } );
return lowercase; return lowercase;
} }
std::string ToUpper(std::string const &text) { std::string ToUpper(std::string const &text)
{
auto uppercase{text}; auto uppercase{text};
std::transform( std::transform(std::begin(text), std::end(text), std::begin(uppercase), [](unsigned char c) { return std::toupper(c); });
std::begin( text ), std::end( text ),
std::begin( uppercase ),
[]( unsigned char c ) { return std::toupper( c ); } );
return uppercase; return uppercase;
} }
// replaces polish letters with basic ascii // replaces polish letters with basic ascii
void void win1250_to_ascii(std::string &Input)
win1250_to_ascii( std::string &Input ) { {
std::unordered_map<char, char> const charmap { std::unordered_map<char, char> const charmap{{165, 'A'}, {198, 'C'}, {202, 'E'}, {163, 'L'}, {209, 'N'}, {211, 'O'}, {140, 'S'}, {143, 'Z'}, {175, 'Z'},
{ 165, 'A' }, { 198, 'C' }, { 202, 'E' }, { 163, 'L' }, { 209, 'N' }, { 211, 'O' }, { 140, 'S' }, { 143, 'Z' }, { 175, 'Z' }, {185, 'a'}, {230, 'c'}, {234, 'e'}, {179, 'l'}, {241, 'n'}, {243, 'o'}, {156, 's'}, {159, 'z'}, {191, 'z'}};
{ 185, 'a' }, { 230, 'c' }, { 234, 'e' }, { 179, 'l' }, { 241, 'n' }, { 243, 'o' }, { 156, 's' }, { 159, 'z' }, { 191, 'z' }
};
std::unordered_map<char, char>::const_iterator lookup; std::unordered_map<char, char>::const_iterator lookup;
for( auto &input : Input ) { for (auto &input : Input)
{
if ((lookup = charmap.find(input)) != charmap.end()) if ((lookup = charmap.find(input)) != charmap.end())
input = lookup->second; input = lookup->second;
} }
} }
std::string win1250_to_utf8(const std::string &Input) { std::string win1250_to_utf8(const std::string &Input)
std::unordered_map<char, std::string> const charmap { {
{ 165, u8"Ą" }, { 198, u8"Ć" }, { 202, u8"Ę" }, { 163, u8"Ł" }, { 209, u8"Ń" }, { 211, u8"Ó" }, { 140, u8"Ś" }, { 143, u8"Ź" }, { 175, u8"Ż" }, std::unordered_map<char, std::string> const charmap{{165, u8"Ą"}, {198, u8"Ć"}, {202, u8"Ę"}, {163, u8"Ł"}, {209, u8"Ń"}, {211, u8"Ó"}, {140, u8"Ś"}, {143, u8"Ź"}, {175, u8"Ż"},
{ 185, u8"ą" }, { 230, u8"ć" }, { 234, u8"ę" }, { 179, u8"ł" }, { 241, u8"ń" }, { 243, u8"ó" }, { 156, u8"ś" }, { 159, u8"ź" }, { 191, u8"ż" } {185, u8"ą"}, {230, u8"ć"}, {234, u8"ę"}, {179, u8"ł"}, {241, u8"ń"}, {243, u8"ó"}, {156, u8"ś"}, {159, u8"ź"}, {191, u8"ż"}};
};
std::string output; std::string output;
std::unordered_map<char, std::string>::const_iterator lookup; std::unordered_map<char, std::string>::const_iterator lookup;
for( auto &input : Input ) { for (auto &input : Input)
{
if ((lookup = charmap.find(input)) != charmap.end()) if ((lookup = charmap.find(input)) != charmap.end())
output += lookup->second; output += lookup->second;
else else
@@ -362,27 +391,31 @@ std::string win1250_to_utf8(const std::string &Input) {
} }
// Ra: tymczasowe rozwiązanie kwestii zagranicznych (czeskich) napisów // Ra: tymczasowe rozwiązanie kwestii zagranicznych (czeskich) napisów
char charsetconversiontable[] = char charsetconversiontable[] = "E?,?\"_++?%S<STZZ?`'\"\".--??s>stzz"
"E?,?\"_++?%S<STZZ?`'\"\".--??s>stzz"
" ^^L$A|S^CS<--RZo±,l'uP.,as>L\"lz" " ^^L$A|S^CS<--RZo±,l'uP.,as>L\"lz"
"RAAAALCCCEEEEIIDDNNOOOOxRUUUUYTB" "RAAAALCCCEEEEIIDDNNOOOOxRUUUUYTB"
"raaaalccceeeeiiddnnoooo-ruuuuyt?"; "raaaalccceeeeiiddnnoooo-ruuuuyt?";
// wycięcie liter z ogonkami // wycięcie liter z ogonkami
std::string Bezogonkow(std::string Input, bool const Underscorestospaces) { std::string Bezogonkow(std::string Input, bool const Underscorestospaces)
{
char const extendedcharsetbit{static_cast<char>(0x80)}; char const extendedcharsetbit{static_cast<char>(0x80)};
char const space{' '}; char const space{' '};
char const underscore{'_'}; char const underscore{'_'};
for( auto &input : Input ) { for (auto &input : Input)
if( input & extendedcharsetbit ) { {
if (input & extendedcharsetbit)
{
input = charsetconversiontable[input ^ extendedcharsetbit]; input = charsetconversiontable[input ^ extendedcharsetbit];
} }
else if( input < space ) { else if (input < space)
{
input = space; input = space;
} }
else if( Underscorestospaces && ( input == underscore ) ) { else if (Underscorestospaces && (input == underscore))
{
input = space; input = space;
} }
} }
@@ -390,35 +423,41 @@ std::string Bezogonkow(std::string Input, bool const Underscorestospaces) {
return Input; return Input;
} }
template <> template <> bool extract_value(bool &Variable, std::string const &Key, std::string const &Input, std::string const &Default)
bool {
extract_value( bool &Variable, std::string const &Key, std::string const &Input, std::string const &Default ) {
auto value = extract_value(Key, Input); auto value = extract_value(Key, Input);
if( false == value.empty() ) { if (false == value.empty())
{
// set the specified variable to retrieved value // set the specified variable to retrieved value
Variable = (ToLower(value) == "yes"); Variable = (ToLower(value) == "yes");
return true; // located the variable return true; // located the variable
} }
else { else
{
// set the variable to provided default value // set the variable to provided default value
if( false == Default.empty() ) { if (false == Default.empty())
{
Variable = (ToLower(Default) == "yes"); Variable = (ToLower(Default) == "yes");
} }
return false; // couldn't locate the variable in provided input return false; // couldn't locate the variable in provided input
} }
} }
bool FileExists( std::string const &Filename ) { bool FileExists(std::string const &Filename)
{
return std::filesystem::exists(Filename); return std::filesystem::exists(Filename);
} }
std::pair<std::string, std::string> std::pair<std::string, std::string> FileExists(std::vector<std::string> const &Names, std::vector<std::string> const &Extensions)
FileExists( std::vector<std::string> const &Names, std::vector<std::string> const &Extensions ) { {
for( auto const &name : Names ) { for (auto const &name : Names)
for( auto const &extension : Extensions ) { {
if( FileExists( name + extension ) ) { for (auto const &extension : Extensions)
{
if (FileExists(name + extension))
{
return {name, extension}; return {name, extension};
} }
} }
@@ -428,8 +467,8 @@ FileExists( std::vector<std::string> const &Names, std::vector<std::string> cons
} }
// returns time of last modification for specified file // returns time of last modification for specified file
std::time_t std::time_t last_modified(std::string const &Filename)
last_modified( std::string const &Filename ) { {
std::string fn = Filename; std::string fn = Filename;
struct stat filestat; struct stat filestat;
if (::stat(fn.c_str(), &filestat) == 0) if (::stat(fn.c_str(), &filestat) == 0)
@@ -439,14 +478,18 @@ last_modified( std::string const &Filename ) {
} }
// potentially erases file extension from provided file name. returns: true if extension was removed, false otherwise // potentially erases file extension from provided file name. returns: true if extension was removed, false otherwise
bool bool erase_extension(std::string &Filename)
erase_extension( std::string &Filename ) { {
auto const extensionpos{Filename.rfind('.')}; auto const extensionpos{Filename.rfind('.')};
if( extensionpos == std::string::npos ) { return false; } if (extensionpos == std::string::npos)
{
return false;
}
if( extensionpos != Filename.rfind( ".." ) + 1 ) { if (extensionpos != Filename.rfind("..") + 1)
{
// we can get extension for .mat or, in legacy files, some image format. just trim it and set it to material file extension // we can get extension for .mat or, in legacy files, some image format. just trim it and set it to material file extension
Filename.erase(extensionpos); Filename.erase(extensionpos);
return true; return true;
@@ -454,70 +497,62 @@ erase_extension( std::string &Filename ) {
return false; return false;
} }
void void erase_leading_slashes(std::string &Filename)
erase_leading_slashes( std::string &Filename ) { {
while( Filename[ 0 ] == '/' ) { while (Filename[0] == '/')
{
Filename.erase(0, 1); Filename.erase(0, 1);
} }
} }
// potentially replaces backward slashes in provided file path with unix-compatible forward slashes // potentially replaces backward slashes in provided file path with unix-compatible forward slashes
void void replace_slashes(std::string &Filename)
replace_slashes( std::string &Filename ) { {
std::replace( std::replace(std::begin(Filename), std::end(Filename), '\\', '/');
std::begin( Filename ), std::end( Filename ),
'\\', '/' );
} }
// returns potential path part from provided file name // returns potential path part from provided file name
std::string std::string substr_path(std::string const &Filename)
substr_path( std::string const &Filename ) { {
return ( return (Filename.rfind('/') != std::string::npos ? Filename.substr(0, Filename.rfind('/') + 1) : "");
Filename.rfind( '/' ) != std::string::npos ?
Filename.substr( 0, Filename.rfind( '/' ) + 1 ) :
"" );
} }
// returns length of common prefix between two provided strings // returns length of common prefix between two provided strings
std::ptrdiff_t std::ptrdiff_t len_common_prefix(std::string const &Left, std::string const &Right)
len_common_prefix( std::string const &Left, std::string const &Right ) { {
auto const *left{Left.data()}; auto const *left{Left.data()};
auto const *right{Right.data()}; auto const *right{Right.data()};
// compare up to the length of the shorter string // compare up to the length of the shorter string
return ( Right.size() <= Left.size() ? return (Right.size() <= Left.size() ? std::distance(right, std::mismatch(right, right + Right.size(), left).first) : std::distance(left, std::mismatch(left, left + Left.size(), right).first));
std::distance( right, std::mismatch( right, right + Right.size(), left ).first ) :
std::distance( left, std::mismatch( left, left + Left.size(), right ).first ) );
} }
// returns true if provided string ends with another provided string // returns true if provided string ends with another provided string
bool bool ends_with(std::string_view String, std::string_view Suffix)
ends_with( std::string_view String, std::string_view Suffix ) { {
return ( String.size() >= Suffix.size() ) return (String.size() >= Suffix.size()) && (0 == String.compare(String.size() - Suffix.size(), Suffix.size(), Suffix));
&& ( 0 == String.compare( String.size() - Suffix.size(), Suffix.size(), Suffix ) );
} }
// returns true if provided string begins with another provided string // returns true if provided string begins with another provided string
bool bool starts_with(std::string_view const String, std::string_view Prefix)
starts_with( std::string_view const String, std::string_view Prefix ) { {
return ( String.size() >= Prefix.size() ) return (String.size() >= Prefix.size()) && (0 == String.compare(0, Prefix.size(), Prefix));
&& ( 0 == String.compare( 0, Prefix.size(), Prefix ) );
} }
// returns true if provided string contains another provided string // returns true if provided string contains another provided string
bool bool contains(std::string_view const String, std::string_view Substring)
contains( std::string_view const String, std::string_view Substring ) { {
return (String.find(Substring) != std::string::npos); return (String.find(Substring) != std::string::npos);
} }
bool bool contains(std::string_view const String, char Character)
contains( std::string_view const String, char Character ) { {
return (String.find(Character) != std::string::npos); return (String.find(Character) != std::string::npos);
} }
@@ -525,39 +560,40 @@ contains( std::string_view const String, char Character ) {
// helper, restores content of a 3d vector from provided input stream // helper, restores content of a 3d vector from provided input stream
// TODO: review and clean up the helper routines, there's likely some redundant ones // TODO: review and clean up the helper routines, there's likely some redundant ones
glm::dvec3 LoadPoint( cParser &Input ) { glm::dvec3 LoadPoint(cParser &Input)
{
// pobranie współrzędnych punktu // pobranie współrzędnych punktu
glm::dvec3 point; glm::dvec3 point;
Input.getTokens(3); Input.getTokens(3);
Input Input >> point.x >> point.y >> point.z;
>> point.x
>> point.y
>> point.z;
return point; return point;
} }
// extracts a group of tokens from provided data stream, returns one of them picked randomly // extracts a group of tokens from provided data stream, returns one of them picked randomly
std::string std::string deserialize_random_set(cParser &Input, char const *Break)
deserialize_random_set( cParser &Input, char const *Break ) { {
auto token{Input.getToken<std::string>(true, Break)}; auto token{Input.getToken<std::string>(true, Break)};
std::replace(token.begin(), token.end(), '\\', '/'); std::replace(token.begin(), token.end(), '\\', '/');
if( token != "[" ) { if (token != "[")
{
// simple case, single token // simple case, single token
return token; return token;
} }
// if instead of a single token we've encountered '[' this marks a beginning of a random set // if instead of a single token we've encountered '[' this marks a beginning of a random set
// we retrieve all entries, then return a random one // we retrieve all entries, then return a random one
std::vector<std::string> tokens; std::vector<std::string> tokens;
while( ( ( token = deserialize_random_set( Input, Break ) ) != "" ) while (((token = deserialize_random_set(Input, Break)) != "") && (token != "]"))
&& ( token != "]" ) ) { {
tokens.emplace_back(token); tokens.emplace_back(token);
} }
if( false == tokens.empty() ) { if (false == tokens.empty())
{
std::shuffle(std::begin(tokens), std::end(tokens), Global.random_engine); std::shuffle(std::begin(tokens), std::end(tokens), Global.random_engine);
return tokens.front(); return tokens.front();
} }
else { else
{
// shouldn't ever get here but, eh // shouldn't ever get here but, eh
return ""; return "";
} }

234
utilities.h
View File

@@ -61,6 +61,7 @@ inline long Round(double const f)
double Random(double a, double b); double Random(double a, double b);
int RandomInt(int min, int max); int RandomInt(int min, int max);
std::string generate_uuid_v4();
double LocalRandom(double a, double b); double LocalRandom(double a, double b);
inline double Random() inline double Random()
@@ -99,12 +100,12 @@ std::string Now();
double CompareTime(double t1h, double t1m, double t2h, double t2m); double CompareTime(double t1h, double t1m, double t2h, double t2m);
/*funkcje logiczne*/ /*funkcje logiczne*/
inline inline bool TestFlag(int const Flag, int const Value)
bool TestFlag( int const Flag, int const Value ) { {
return ((Flag & Value) == Value); return ((Flag & Value) == Value);
} }
inline inline bool TestFlagAny(int const Flag, int const Value)
bool TestFlagAny( int const Flag, int const Value ) { {
return ((Flag & Value) != 0); return ((Flag & Value) != 0);
} }
bool SetFlag(int &Flag, int const Value); bool SetFlag(int &Flag, int const Value);
@@ -133,18 +134,18 @@ std::string to_string(double Value, int precision, int width);
std::string to_hex_str(int const Value, int const width = 4); std::string to_hex_str(int const Value, int const width = 4);
std::string to_minutes_str(float const Minutes, bool const Leadingzero, int const Width); std::string to_minutes_str(float const Minutes, bool const Leadingzero, int const Width);
inline inline std::string to_string(bool Value)
std::string to_string(bool Value) { {
return (Value == true ? "true" : "false"); return (Value == true ? "true" : "false");
} }
template <typename Type_, glm::precision Precision_ = glm::defaultp> template <typename Type_, glm::precision Precision_ = glm::defaultp> std::string to_string(glm::tvec3<Type_, Precision_> const &Value)
std::string to_string( glm::tvec3<Type_, Precision_> const &Value ) { {
return to_string(Value.x, 2) + ", " + to_string(Value.y, 2) + ", " + to_string(Value.z, 2); return to_string(Value.x, 2) + ", " + to_string(Value.y, 2) + ", " + to_string(Value.z, 2);
} }
template <typename Type_, glm::precision Precision_ = glm::defaultp> template <typename Type_, glm::precision Precision_ = glm::defaultp> std::string to_string(glm::tvec4<Type_, Precision_> const &Value, int const Width = 2)
std::string to_string( glm::tvec4<Type_, Precision_> const &Value, int const Width = 2 ) { {
return to_string(Value.x, Width) + ", " + to_string(Value.y, Width) + ", " + to_string(Value.z, Width) + ", " + to_string(Value.w, Width); return to_string(Value.x, Width) + ", " + to_string(Value.y, Width) + ", " + to_string(Value.z, Width) + ", " + to_string(Value.w, Width);
} }
@@ -163,17 +164,18 @@ std::string Bezogonkow( std::string Input, bool const Underscorestospaces = fals
std::string win1250_to_utf8(const std::string &input); std::string win1250_to_utf8(const std::string &input);
inline inline std::string extract_value(std::string const &Key, std::string const &Input)
std::string {
extract_value( std::string const &Key, std::string const &Input ) {
// NOTE, HACK: the leading space allows to uniformly look for " variable=" substring // NOTE, HACK: the leading space allows to uniformly look for " variable=" substring
std::string const input{" " + Input}; std::string const input{" " + Input};
std::string value; std::string value;
auto lookup = input.find(" " + Key + "="); auto lookup = input.find(" " + Key + "=");
if( lookup != std::string::npos ) { if (lookup != std::string::npos)
{
value = input.substr(input.find_first_not_of(' ', lookup + Key.size() + 2)); value = input.substr(input.find_first_not_of(' ', lookup + Key.size() + 2));
lookup = value.find(' '); lookup = value.find(' ');
if( lookup != std::string::npos ) { if (lookup != std::string::npos)
{
// trim everything past the value // trim everything past the value
value.erase(lookup); value.erase(lookup);
} }
@@ -181,21 +183,23 @@ extract_value( std::string const &Key, std::string const &Input ) {
return value; return value;
} }
template <typename Type_> template <typename Type_> bool extract_value(Type_ &Variable, std::string const &Key, std::string const &Input, std::string const &Default)
bool {
extract_value( Type_ &Variable, std::string const &Key, std::string const &Input, std::string const &Default ) {
auto value = extract_value(Key, Input); auto value = extract_value(Key, Input);
if( false == value.empty() ) { if (false == value.empty())
{
// set the specified variable to retrieved value // set the specified variable to retrieved value
std::stringstream converter; std::stringstream converter;
converter << value; converter << value;
converter >> Variable; converter >> Variable;
return true; // located the variable return true; // located the variable
} }
else { else
{
// set the variable to provided default value // set the variable to provided default value
if( false == Default.empty() ) { if (false == Default.empty())
{
std::stringstream converter; std::stringstream converter;
converter << Default; converter << Default;
converter >> Variable; converter >> Variable;
@@ -204,9 +208,7 @@ extract_value( Type_ &Variable, std::string const &Key, std::string const &Input
} }
} }
template <> template <> bool extract_value(bool &Variable, std::string const &Key, std::string const &Input, std::string const &Default);
bool
extract_value( bool &Variable, std::string const &Key, std::string const &Input, std::string const &Default );
bool FileExists(std::string const &Filename); bool FileExists(std::string const &Filename);
@@ -216,16 +218,13 @@ std::pair<std::string, std::string> FileExists( std::vector<std::string> const &
std::time_t last_modified(std::string const &Filename); std::time_t last_modified(std::string const &Filename);
// potentially erases file extension from provided file name. returns: true if extension was removed, false otherwise // potentially erases file extension from provided file name. returns: true if extension was removed, false otherwise
bool bool erase_extension(std::string &Filename);
erase_extension( std::string &Filename );
// potentially erase leading slashes from provided file path // potentially erase leading slashes from provided file path
void void erase_leading_slashes(std::string &Filename);
erase_leading_slashes( std::string &Filename );
// potentially replaces backward slashes in provided file path with unix-compatible forward slashes // potentially replaces backward slashes in provided file path with unix-compatible forward slashes
void void replace_slashes(std::string &Filename);
replace_slashes( std::string &Filename );
// returns potential path part from provided file name // returns potential path part from provided file name
std::string substr_path(std::string const &Filename); std::string substr_path(std::string const &Filename);
@@ -241,97 +240,96 @@ bool starts_with( std::string_view String, std::string_view Prefix );
bool contains(std::string_view const String, std::string_view Substring); bool contains(std::string_view const String, std::string_view Substring);
bool contains(std::string_view const String, char Character); bool contains(std::string_view const String, char Character);
template <typename Type_> template <typename Type_> void SafeDelete(Type_ &Pointer)
void SafeDelete( Type_ &Pointer ) { {
delete Pointer; delete Pointer;
Pointer = nullptr; Pointer = nullptr;
} }
template <typename Type_> template <typename Type_> void SafeDeleteArray(Type_ &Pointer)
void SafeDeleteArray( Type_ &Pointer ) { {
delete[] Pointer; delete[] Pointer;
Pointer = nullptr; Pointer = nullptr;
} }
template <typename Type_> template <typename Type_> Type_ is_equal(Type_ const &Left, Type_ const &Right, Type_ const Epsilon = 1e-5)
Type_ {
is_equal( Type_ const &Left, Type_ const &Right, Type_ const Epsilon = 1e-5 ) {
if( Epsilon != 0 ) { if (Epsilon != 0)
{
return glm::epsilonEqual(Left, Right, Epsilon); return glm::epsilonEqual(Left, Right, Epsilon);
} }
else { else
{
return (Left == Right); return (Left == Right);
} }
} }
template <typename Type_> template <typename Type_> Type_ clamp(Type_ const Value, Type_ const Min, Type_ const Max)
Type_ {
clamp( Type_ const Value, Type_ const Min, Type_ const Max ) {
Type_ value = Value; Type_ value = Value;
if( value < Min ) { value = Min; } if (value < Min)
if( value > Max ) { value = Max; } {
value = Min;
}
if (value > Max)
{
value = Max;
}
return value; return value;
} }
// keeps the provided value in specified range 0-Range, as if the range was circular buffer // keeps the provided value in specified range 0-Range, as if the range was circular buffer
template <typename Type_> template <typename Type_> Type_ clamp_circular(Type_ Value, Type_ const Range = static_cast<Type_>(360))
Type_ {
clamp_circular( Type_ Value, Type_ const Range = static_cast<Type_>(360) ) {
Value -= Range * (int)(Value / Range); // clamp the range to 0-360 Value -= Range * (int)(Value / Range); // clamp the range to 0-360
if( Value < Type_(0) ) Value += Range; if (Value < Type_(0))
Value += Range;
return Value; return Value;
} }
// rounds down provided value to nearest power of two // rounds down provided value to nearest power of two
template <typename Type_> template <typename Type_> Type_ clamp_power_of_two(Type_ Value, Type_ const Min = static_cast<Type_>(1), Type_ const Max = static_cast<Type_>(16384))
Type_ {
clamp_power_of_two( Type_ Value, Type_ const Min = static_cast<Type_>(1), Type_ const Max = static_cast<Type_>(16384) ) {
Type_ p2size{Min}; Type_ p2size{Min};
Type_ size; Type_ size;
while( ( p2size <= Max ) && ( p2size <= Value ) ) { while ((p2size <= Max) && (p2size <= Value))
{
size = p2size; size = p2size;
p2size = p2size << 1; p2size = p2size << 1;
} }
return size; return size;
} }
template <typename Type_> template <typename Type_> Type_ quantize(Type_ const Value, Type_ const Step)
Type_ {
quantize( Type_ const Value, Type_ const Step ) {
return (Step * std::round(Value / Step)); return (Step * std::round(Value / Step));
} }
template <typename Type_> template <typename Type_> Type_ min_speed(Type_ const Left, Type_ const Right)
Type_ {
min_speed( Type_ const Left, Type_ const Right ) {
if( Left == Right ) { return Left; } if (Left == Right)
{
return std::min( return Left;
( Left != -1 ?
Left :
std::numeric_limits<Type_>::max() ),
( Right != -1 ?
Right :
std::numeric_limits<Type_>::max() ) );
} }
template <typename Type_> return std::min((Left != -1 ? Left : std::numeric_limits<Type_>::max()), (Right != -1 ? Right : std::numeric_limits<Type_>::max()));
Type_ }
interpolate( Type_ const &First, Type_ const &Second, float const Factor ) {
template <typename Type_> Type_ interpolate(Type_ const &First, Type_ const &Second, float const Factor)
{
return static_cast<Type_>((First * (1.0f - Factor)) + (Second * Factor)); return static_cast<Type_>((First * (1.0f - Factor)) + (Second * Factor));
} }
template <typename Type_> template <typename Type_> Type_ interpolate(Type_ const &First, Type_ const &Second, double const Factor)
Type_ {
interpolate( Type_ const &First, Type_ const &Second, double const Factor ) {
return static_cast<Type_>((First * (1.0 - Factor)) + (Second * Factor)); return static_cast<Type_>((First * (1.0 - Factor)) + (Second * Factor));
} }
@@ -345,43 +343,43 @@ template <typename Type_> Type_ smoothInterpolate(Type_ const &First, Type_ cons
} }
// tests whether provided points form a degenerate triangle // tests whether provided points form a degenerate triangle
template <typename VecType_> template <typename VecType_> bool degenerate(VecType_ const &Vertex1, VecType_ const &Vertex2, VecType_ const &Vertex3)
bool {
degenerate( VecType_ const &Vertex1, VecType_ const &Vertex2, VecType_ const &Vertex3 ) {
// degenerate( A, B, C, minarea ) = ( ( B - A ).cross( C - A ) ).lengthSquared() < ( 4.0f * minarea * minarea ); // degenerate( A, B, C, minarea ) = ( ( B - A ).cross( C - A ) ).lengthSquared() < ( 4.0f * minarea * minarea );
return (glm::length2(glm::cross(Vertex2 - Vertex1, Vertex3 - Vertex1)) == 0.0); return (glm::length2(glm::cross(Vertex2 - Vertex1, Vertex3 - Vertex1)) == 0.0);
} }
// calculates bounding box for provided set of points // calculates bounding box for provided set of points
template <class Iterator_, class VecType_> template <class Iterator_, class VecType_> void bounding_box(VecType_ &Mincorner, VecType_ &Maxcorner, Iterator_ First, Iterator_ Last)
void {
bounding_box( VecType_ &Mincorner, VecType_ &Maxcorner, Iterator_ First, Iterator_ Last ) {
Mincorner = VecType_(std::numeric_limits<typename VecType_::value_type>::max()); Mincorner = VecType_(std::numeric_limits<typename VecType_::value_type>::max());
Maxcorner = VecType_(std::numeric_limits<typename VecType_::value_type>::lowest()); Maxcorner = VecType_(std::numeric_limits<typename VecType_::value_type>::lowest());
std::for_each( std::for_each(First, Last,
First, Last, [&](typename Iterator_::value_type &point)
[&]( typename Iterator_::value_type &point ) { {
Mincorner = glm::min(Mincorner, VecType_{point}); Mincorner = glm::min(Mincorner, VecType_{point});
Maxcorner = glm::max( Maxcorner, VecType_{ point } ); } ); Maxcorner = glm::max(Maxcorner, VecType_{point});
});
} }
// finds point on specified segment closest to specified point in 3d space. returns: point on segment as value in range 0-1 where 0 = start and 1 = end of the segment // finds point on specified segment closest to specified point in 3d space. returns: point on segment as value in range 0-1 where 0 = start and 1 = end of the segment
template <typename VecType_> template <typename VecType_> typename VecType_::value_type nearest_segment_point(VecType_ const &Segmentstart, VecType_ const &Segmentend, VecType_ const &Point)
typename VecType_::value_type {
nearest_segment_point( VecType_ const &Segmentstart, VecType_ const &Segmentend, VecType_ const &Point ) {
auto const v = Segmentend - Segmentstart; auto const v = Segmentend - Segmentstart;
auto const w = Point - Segmentstart; auto const w = Point - Segmentstart;
auto const c1 = glm::dot(w, v); auto const c1 = glm::dot(w, v);
if( c1 <= 0.0 ) { if (c1 <= 0.0)
{
return 0.0; return 0.0;
} }
auto const c2 = glm::dot(v, v); auto const c2 = glm::dot(v, v);
if( c2 <= c1 ) { if (c2 <= c1)
{
return 1.0; return 1.0;
} }
return c1 / c2; return c1 / c2;
@@ -390,30 +388,30 @@ nearest_segment_point( VecType_ const &Segmentstart, VecType_ const &Segmentend,
glm::dvec3 LoadPoint(class cParser &Input); glm::dvec3 LoadPoint(class cParser &Input);
// extracts a group of tokens from provided data stream // extracts a group of tokens from provided data stream
std::string std::string deserialize_random_set(cParser &Input, char const *Break = "\n\r\t ;");
deserialize_random_set( cParser &Input, char const *Break = "\n\r\t ;" );
int count_trailing_zeros(uint32_t val); int count_trailing_zeros(uint32_t val);
// extracts a group of <key, value> pairs from provided data stream // extracts a group of <key, value> pairs from provided data stream
// NOTE: expects no more than single pair per line // NOTE: expects no more than single pair per line
template <typename MapType_> template <typename MapType_> void deserialize_map(MapType_ &Map, cParser &Input)
void {
deserialize_map( MapType_ &Map, cParser &Input ) {
while( Input.ok() && !Input.eof() ) { while (Input.ok() && !Input.eof())
{
auto const key{Input.getToken<typename MapType_::key_type>(false)}; auto const key{Input.getToken<typename MapType_::key_type>(false)};
auto const value{Input.getToken<typename MapType_::mapped_type>(false, "\n")}; auto const value{Input.getToken<typename MapType_::mapped_type>(false, "\n")};
Map.emplace(key, value); Map.emplace(key, value);
} }
} }
namespace threading { namespace threading
{
// simple POD pairing of a data item and a mutex // simple POD pairing of a data item and a mutex
// NOTE: doesn't do any locking itself, it's merely for cleaner argument arrangement and passing // NOTE: doesn't do any locking itself, it's merely for cleaner argument arrangement and passing
template <typename Type_> template <typename Type_> struct lockable
struct lockable { {
Type_ data; Type_ data;
std::mutex mutex; std::mutex mutex;
@@ -421,40 +419,36 @@ struct lockable {
// basic wrapper simplifying use of std::condition_variable for most typical cases. // basic wrapper simplifying use of std::condition_variable for most typical cases.
// has its own mutex and secondary variable to ignore spurious wakeups // has its own mutex and secondary variable to ignore spurious wakeups
class condition_variable { class condition_variable
{
public: public:
// methods // methods
void void wait()
wait() { {
std::unique_lock<std::mutex> lock(m_mutex); std::unique_lock<std::mutex> lock(m_mutex);
m_condition.wait( m_condition.wait(lock, [this]() { return m_spurious == false; });
lock, }
[ this ]() { template <class Rep_, class Period_> void wait_for(const std::chrono::duration<Rep_, Period_> &Time)
return m_spurious == false; } ); } {
template< class Rep_, class Period_ >
void
wait_for( const std::chrono::duration<Rep_, Period_> &Time ) {
std::unique_lock<std::mutex> lock(m_mutex); std::unique_lock<std::mutex> lock(m_mutex);
m_condition.wait_for( m_condition.wait_for(lock, Time, [this]() { return m_spurious == false; });
lock, }
Time, void notify_one()
[ this ]() { {
return m_spurious == false; } ); }
void
notify_one() {
spurious(false); spurious(false);
m_condition.notify_one(); m_condition.notify_one();
} }
void void notify_all()
notify_all() { {
spurious(false); spurious(false);
m_condition.notify_all(); m_condition.notify_all();
} }
void void spurious(bool const Spurious)
spurious( bool const Spurious ) { {
std::lock_guard<std::mutex> lock(m_mutex); std::lock_guard<std::mutex> lock(m_mutex);
m_spurious = Spurious; } m_spurious = Spurious;
}
private: private:
// members // members
@@ -463,6 +457,6 @@ private:
bool m_spurious{true}; bool m_spurious{true};
}; };
} // threading } // namespace threading
//--------------------------------------------------------------------------- //---------------------------------------------------------------------------