mirror of
https://github.com/MaSzyna-EU07/maszyna.git
synced 2026-10-17 06:19:19 +02:00
c15e200e37
The editor branch was written against headers and the PCH, both of which this
branch has done away with, so its own files were ported rather than merged: the
five headers it added are now interface units and their .cpp files module
implementation units.
- editor/{puwg1992,polandmap,turnouts,orthophoto} become eu07.editor.* modules,
application/planpanel becomes eu07.application.planpanel. The plan tool keeps
to its own module rather than joining the eu07.simcore partitions: it stands on
the editor's libraries and eu07.application.uilayer, not on the simulation core,
so :editoruilayer can export import it without a cycle.
- glm arrives by import eu07.glm, never by include, as the rest of the tree does.
maj0sted is header-only and glm-free, so its headers stay includes in the global
module fragment - every unit that names those types includes them itself, since
a global fragment is not visible across units.
- the one textual conflict was :editoruilayer's include block against this
branch's imports; resolved this branch's way plus the planpanel import.
Builds with clang 22 (-DWITH_BETTER_RENDERER=OFF) and starts into the editor on
empty ground with -editor alone.
123 lines
3.8 KiB
C++
123 lines
3.8 KiB
C++
module;
|
|
#include <array>
|
|
#include <cstddef>
|
|
#include <deque>
|
|
#include <limits>
|
|
#include <mutex>
|
|
#include <sstream>
|
|
#include <type_traits>
|
|
#include <unordered_map>
|
|
#include <utility>
|
|
#include <vector>
|
|
#include <ostream>
|
|
#include <memory>
|
|
#include <GLFW/glfw3.h>
|
|
#include <chrono>
|
|
#include <string>
|
|
#include <typeinfo>
|
|
#include "utilities/Globals_macros.h"
|
|
#include "utilities/translation_macros.h"
|
|
|
|
module eu07.application.scenarioloadermode;
|
|
import eu07.utilities.classes;
|
|
import eu07.utilities.globals;
|
|
import eu07.simulation.simulation;
|
|
import eu07.simulation.simulationtime;
|
|
import eu07.simulation.simulationenvironment;
|
|
import eu07.application.application;
|
|
import eu07.application.scenarioloaderuilayer;
|
|
import eu07.rendering.renderer;
|
|
import eu07.utilities.logs;
|
|
import eu07.utilities.translation;
|
|
/*
|
|
This Source Code Form is subject to the
|
|
terms of the Mozilla Public License, v.
|
|
2.0. If a copy of the MPL was not
|
|
distributed with this file, You can
|
|
obtain one at
|
|
http://mozilla.org/MPL/2.0/.
|
|
*/
|
|
|
|
|
|
|
|
scenarioloader_mode::scenarioloader_mode() {
|
|
m_userinterface = std::make_shared<scenarioloader_ui>();
|
|
}
|
|
|
|
// initializes internal data structures of the mode. returns: true on success, false otherwise
|
|
bool scenarioloader_mode::init() {
|
|
// nothing to do here
|
|
return true;
|
|
}
|
|
|
|
// mode-specific update of simulation data. returns: false on error, true otherwise
|
|
bool scenarioloader_mode::update() {
|
|
if (!Global.ready_to_load)
|
|
// waiting for network connection
|
|
return true;
|
|
|
|
if (!state) {
|
|
WriteLog("using simulation seed: " + std::to_string(Global.random_seed), logtype::generic);
|
|
WriteLog("using simulation starting timestamp: " + std::to_string(Global.starting_timestamp), logtype::generic);
|
|
|
|
Application.set_title( Global.AppName + " (" + Global.SceneryFile + ")" );
|
|
WriteLog( "\nLoading scenario \"" + Global.SceneryFile + "\"..." );
|
|
|
|
timestart = std::chrono::system_clock::now();
|
|
state = simulation::State.deserialize_begin(Global.SceneryFile);
|
|
}
|
|
|
|
try {
|
|
if (simulation::State.deserialize_continue(state))
|
|
return true;
|
|
}
|
|
catch (invalid_scenery_exception &e) {
|
|
ErrorLog( "Bad init: scenario loading failed" );
|
|
state.reset();
|
|
Application.pop_mode();
|
|
}
|
|
|
|
WriteLog( "Scenario loading time: " + std::to_string( std::chrono::duration_cast<std::chrono::seconds>( std::chrono::system_clock::now() - timestart ).count() ) + " seconds" );
|
|
// TODO: implement and use next mode cue
|
|
|
|
// the mode object is kept for the next time a scenery is loaded; without dropping the context
|
|
// here, a later enter() would skip deserialize_begin and finish an already-spent parser again
|
|
state.reset();
|
|
|
|
Application.pop_mode();
|
|
// starting into the editor the simulation never runs at all: there's no driver mode underneath, so
|
|
// no physics, no AI and no timetables - just the loaded world to work on
|
|
Application.push_mode(
|
|
Global.editor_startup ?
|
|
eu07_application::mode::editor :
|
|
eu07_application::mode::driver );
|
|
|
|
return true;
|
|
}
|
|
|
|
bool scenarioloader_mode::is_command_processor() const {
|
|
return false;
|
|
}
|
|
|
|
// maintenance method, called when the mode is activated
|
|
void scenarioloader_mode::enter() {
|
|
// TBD: hide cursor in fullscreen mode?
|
|
Application.set_cursor( GLFW_CURSOR_NORMAL );
|
|
|
|
// a new map from the editor re-enters this mode while the previous load's context is still
|
|
// sitting in `state`; clear it so update() opens the file again instead of re-finishing an
|
|
// exhausted parser (Groups.close / create_map_geometry on an already-built region)
|
|
state.reset();
|
|
|
|
simulation::is_ready = false;
|
|
|
|
Application.set_title( Global.AppName + " (" + Global.SceneryFile + ")" );
|
|
m_userinterface->set_progress(STR("Loading scenery"));
|
|
}
|
|
|
|
// maintenance method, called when the mode is deactivated
|
|
void scenarioloader_mode::exit() {
|
|
simulation::Time.init( Global.starting_timestamp );
|
|
simulation::Environment.init();
|
|
}
|