eu07/maszyna
1
0
Fork 0
mirror of https://github.com/MaSzyna-EU07/maszyna.git synced 2026-03-22 15:05:03 +01:00
Code Issues Packages Projects Releases Wiki Activity

snapshot

Browse Source
This commit is contained in:
milek7
2019-07-09 22:09:37 +02:00
parent a0c44fbaa3
commit 8f7e06c25c
19 changed files with 227 additions and 1079 deletions
Download Patch File Download Diff File Expand all files Collapse all files

34
Driver.cpp
View File

@@ -1644,7 +1644,7 @@ TController::TController(bool AI, TDynamicObject *NewControll, bool InitPsyche,
#ifdef _WIN32 #ifdef _WIN32
CreateDirectory( "physicslog", NULL ); CreateDirectory( "physicslog", NULL );
#elif __unix__ #elif __unix__
mkdir( "physicslog", 0644 ); mkdir( "physicslog", 0744 );
#endif #endif
LogFile.open( std::string( "physicslog/" + VehicleName + ".dat" ), LogFile.open( std::string( "physicslog/" + VehicleName + ".dat" ),
std::ios::in | std::ios::out | std::ios::trunc ); std::ios::in | std::ios::out | std::ios::trunc );
@@ -1709,19 +1709,19 @@ std::string TController::OrderCurrent() const
{ // pobranie aktualnego rozkazu celem wyświetlenia { // pobranie aktualnego rozkazu celem wyświetlenia
auto const order { OrderCurrentGet() }; auto const order { OrderCurrentGet() };
if( order & Change_direction ) { if( order & Change_direction ) {
return STR(driver_scenario_changedirection); return STR("Change direction");
} }
switch( OrderList[ OrderPos ] ) { switch( OrderList[ OrderPos ] ) {
case Wait_for_orders: { return STR(driver_scenario_waitfororders); } case Wait_for_orders: { return STR("Wait for orders"); }
case Prepare_engine: { return STR(driver_scenario_prepareengine); } case Prepare_engine: { return STR("Start the engine"); }
case Release_engine: { return STR(driver_scenario_releaseengine); } case Release_engine: { return STR("Shut down the engine"); }
case Change_direction: { return STR(driver_scenario_changedirection); } case Change_direction: { return STR("Change direction"); }
case Connect: { return STR(driver_scenario_connect); } case Connect: { return STR("Couple to consist ahead"); }
case Disconnect: { case Disconnect: {
if( iVehicleCount < 0 ) { if( iVehicleCount < 0 ) {
// done with uncoupling, order should update shortly // done with uncoupling, order should update shortly
return STR(driver_scenario_waitfororders); return STR("Wait for orders");
} }
// try to provide some task details // try to provide some task details
auto const count { iVehicleCount }; auto const count { iVehicleCount };
@@ -1729,26 +1729,24 @@ std::string TController::OrderCurrent() const
if( iVehicleCount > 1 ) { if( iVehicleCount > 1 ) {
std::snprintf( std::snprintf(
orderbuffer.data(), orderbuffer.size(), orderbuffer.data(), orderbuffer.size(),
( iVehicleCount < 5 ? STR_C("the engine plus %d next vehicles"), // TODO: implement plural forms
STR_C(driver_scenario_fewvehicles) : // 2-4
STR_C(driver_scenario_somevehicles) ), // 5+
count ); count );
} }
auto const countstring { ( auto const countstring { (
count == 0 ? STR(driver_scenario_allvehicles) : count == 0 ? STR("the engine") :
count == 1 ? STR(driver_scenario_onevehicle) : count == 1 ? STR("the engine plus the next vehicle") :
orderbuffer.data() ) }; orderbuffer.data() ) };
std::snprintf( std::snprintf(
orderbuffer.data(), orderbuffer.size(), orderbuffer.data(), orderbuffer.size(),
STR_C(driver_scenario_disconnect), STR_C("Uncouple %s"),
countstring.c_str() ); countstring.c_str() );
return orderbuffer.data(); return orderbuffer.data();
} }
case Shunt: { return STR(driver_scenario_shunt); } case Shunt: { return STR("Shunt according to signals"); }
case Loose_shunt: { return STR(driver_scenario_looseshunt); } case Loose_shunt: { return STR("Loose shunt according to signals"); }
case Obey_train: { return STR(driver_scenario_obeytrain); } case Obey_train: { return STR("Drive according to signals and timetable"); }
case Bank: { return STR(driver_scenario_bank); } case Bank: { return STR("Bank consist ahead"); }
default: { return{}; } default: { return{}; }
} }
}; };

61
Texture.cpp
View File

@@ -180,7 +180,7 @@ opengl_texture::load() {
if( type == ".dds" ) { load_DDS(); } if( type == ".dds" ) { load_DDS(); }
else if( type == ".tga" ) { load_TGA(); } else if( type == ".tga" ) { load_TGA(); }
else if( type == ".png" ) { load_PNG(); } else if( type == ".png" ) { load_PNG(); }
else if( type == ".bmp" ) { load_BMP(); } else if( type == ".bmp" ) { load_STBI(); }
else if( type == ".jpg" ) { load_STBI(); } else if( type == ".jpg" ) { load_STBI(); }
else if( type == ".tex" ) { load_TEX(); } else if( type == ".tex" ) { load_TEX(); }
else { goto fail; } else { goto fail; }
@@ -257,6 +257,7 @@ void opengl_texture::load_PNG()
void opengl_texture::load_STBI() void opengl_texture::load_STBI()
{ {
int x, y, n; int x, y, n;
stbi_set_flip_vertically_on_load(1);
uint8_t *image = stbi_load((name + type).c_str(), &x, &y, &n, 4); uint8_t *image = stbi_load((name + type).c_str(), &x, &y, &n, 4);
if (!image) { if (!image) {
@@ -304,64 +305,6 @@ opengl_texture::make_request() {
Application.request( { ToLower( components.front() ), dictionary, rt } ); Application.request( { ToLower( components.front() ), dictionary, rt } );
} }
void
opengl_texture::load_BMP() {
std::ifstream file( name + type, std::ios::binary ); file.unsetf( std::ios::skipws );
BITMAPFILEHEADER header;
file.read((char *) &header, sizeof( BITMAPFILEHEADER ) );
if( file.eof() ) {
data_state = resource_state::failed;
return;
}
// Read in bitmap information structure
BITMAPINFO info;
unsigned int infosize = header.bfOffBits - sizeof( BITMAPFILEHEADER );
if( infosize > sizeof( info ) ) {
WriteLog( "Warning - BMP header is larger than expected, possible format difference.", logtype::texture );
}
file.read((char *) &info, std::min( (size_t)infosize, sizeof( info ) ) );
data_width = info.bmiHeader.biWidth;
data_height = info.bmiHeader.biHeight;
if( info.bmiHeader.biCompression != BI_RGB ) {
ErrorLog( "Bad texture: compressed BMP textures aren't supported.", logtype::texture );
data_state = resource_state::failed;
return;
}
unsigned long datasize = info.bmiHeader.biSizeImage;
if( 0 == datasize ) {
// calculate missing info
datasize = ( data_width * info.bmiHeader.biBitCount + 7 ) / 8 * data_height;
}
data.resize( datasize );
file.read((char*) &data[0], datasize );
// we're storing texture data internally with bottom-left origin
// so BMP origin matches, no flipping needed
// fill remaining data info
if( info.bmiHeader.biBitCount == 32 ) {
data_format = GL_BGRA;
data_components = GL_RGBA;
}
else {
data_format = GL_BGR;
data_components = GL_RGB;
}
data_mapcount = 1;
data_state = resource_state::good;
return;
}
DDCOLORKEY opengl_texture::deserialize_ddck(std::istream &s) DDCOLORKEY opengl_texture::deserialize_ddck(std::istream &s)
{ {
DDCOLORKEY ddck; DDCOLORKEY ddck;

1
Texture.h
View File

@@ -64,7 +64,6 @@ struct opengl_texture {
private: private:
// methods // methods
void make_request(); void make_request();
void load_BMP();
void load_PNG(); void load_PNG();
void load_DDS(); void load_DDS();
void load_TEX(); void load_TEX();

20
driveruilayer.cpp
View File

@@ -37,17 +37,17 @@ driver_ui::driver_ui() {
add_external_panel( &m_cameraviewpanel ); add_external_panel( &m_cameraviewpanel );
m_logpanel.is_open = false; m_logpanel.is_open = false;
m_aidpanel.title = STR(driver_aid_header); m_aidpanel.title = STR("Driving Aid");
m_scenariopanel.title = STR(driver_scenario_header); m_scenariopanel.title = STR("Scenario");
m_scenariopanel.size_min = { 435, 85 }; m_scenariopanel.size_min = { 435, 85 };
m_scenariopanel.size_max = { Global.iWindowWidth * 0.95, Global.iWindowHeight * 0.95 }; m_scenariopanel.size_max = { Global.iWindowWidth * 0.95, Global.iWindowHeight * 0.95 };
m_timetablepanel.title = STR(driver_timetable_header); m_timetablepanel.title = STR("%-*.*s Time: %d:%02d:%02d");
m_timetablepanel.size_min = { 435, 110 }; m_timetablepanel.size_min = { 435, 110 };
m_timetablepanel.size_max = { 435, Global.iWindowHeight * 0.95 }; m_timetablepanel.size_max = { 435, Global.iWindowHeight * 0.95 };
m_transcriptspanel.title = STR(driver_transcripts_header); m_transcriptspanel.title = STR("Transcripts");
m_transcriptspanel.size_min = { 435, 85 }; m_transcriptspanel.size_min = { 435, 85 };
m_transcriptspanel.size_max = { Global.iWindowWidth * 0.95, Global.iWindowHeight * 0.95 }; m_transcriptspanel.size_max = { Global.iWindowWidth * 0.95, Global.iWindowHeight * 0.95 };
} }
@@ -55,10 +55,10 @@ driver_ui::driver_ui() {
void driver_ui::render_menu_contents() { void driver_ui::render_menu_contents() {
ui_layer::render_menu_contents(); ui_layer::render_menu_contents();
if (ImGui::BeginMenu(STR_C(ui_mode_windows))) if (ImGui::BeginMenu(STR_C("Mode windows")))
{ {
ImGui::MenuItem(m_aidpanel.title.c_str(), "F1", &m_aidpanel.is_open); ImGui::MenuItem(m_aidpanel.title.c_str(), "F1", &m_aidpanel.is_open);
ImGui::MenuItem(STR_C(driver_timetable_name), "F2", &m_timetablepanel.is_open); ImGui::MenuItem(STR_C("Timetable"), "F2", &m_timetablepanel.is_open);
ImGui::MenuItem(m_debugpanel.name().c_str(), "F12", &m_debugpanel.is_open); ImGui::MenuItem(m_debugpanel.name().c_str(), "F12", &m_debugpanel.is_open);
ImGui::MenuItem(m_mappanel.name().c_str(), "Tab", &m_mappanel.is_open); ImGui::MenuItem(m_mappanel.name().c_str(), "Tab", &m_mappanel.is_open);
ImGui::MenuItem(m_vehiclelist.name().c_str(), nullptr, &m_vehiclelist.is_open); ImGui::MenuItem(m_vehiclelist.name().c_str(), nullptr, &m_vehiclelist.is_open);
@@ -228,18 +228,18 @@ driver_ui::set_cursor( bool const Visible ) {
void void
driver_ui::render_() { driver_ui::render_() {
// pause/quit modal // pause/quit modal
auto const popupheader { STR_C(driver_pause_header) }; auto const popupheader { STR_C("Simulation Paused") };
if (m_paused && !m_pause_modal_opened) if (m_paused && !m_pause_modal_opened)
{ {
m_pause_modal_opened = true; m_pause_modal_opened = true;
ImGui::OpenPopup(popupheader); ImGui::OpenPopup(popupheader);
} }
if( ImGui::BeginPopupModal( popupheader, &m_pause_modal_opened, ImGuiWindowFlags_AlwaysAutoResize ) ) { if( ImGui::BeginPopupModal( popupheader, &m_pause_modal_opened, ImGuiWindowFlags_AlwaysAutoResize ) ) {
auto const popupwidth{ STR(driver_pause_header).size() * 7 }; auto const popupwidth{ STR("Simulation Paused").size() * 7 };
if( ImGui::Button( STR_C(driver_pause_resume), ImVec2( popupwidth, 0 ) ) ) { if( ImGui::Button( STR_C("Resume"), ImVec2( popupwidth, 0 ) ) ) {
m_relay.post(user_command::pausetoggle, 0.0, 0.0, GLFW_PRESS, 0); m_relay.post(user_command::pausetoggle, 0.0, 0.0, GLFW_PRESS, 0);
} }
if( ImGui::Button( STR_C(driver_pause_quit), ImVec2( popupwidth, 0 ) ) ) { if( ImGui::Button( STR_C("Quit"), ImVec2( popupwidth, 0 ) ) ) {
m_relay.post(user_command::quitsimulation, 0.0, 0.0, GLFW_PRESS, 0); m_relay.post(user_command::quitsimulation, 0.0, 0.0, GLFW_PRESS, 0);
} }
if (!m_paused) if (!m_paused)

56
driveruipanels.cpp
View File

@@ -53,7 +53,7 @@ drivingaid_panel::update() {
if( std::abs( grade ) >= 0.25 ) { if( std::abs( grade ) >= 0.25 ) {
std::snprintf( std::snprintf(
m_buffer.data(), m_buffer.size(), m_buffer.data(), m_buffer.size(),
STR_C(driver_aid_grade), STR_C(" Grade: %.1f%%%%"),
grade ); grade );
gradetext = m_buffer.data(); gradetext = m_buffer.data();
} }
@@ -64,7 +64,7 @@ drivingaid_panel::update() {
if( nextspeedlimit != speedlimit ) { if( nextspeedlimit != speedlimit ) {
std::snprintf( std::snprintf(
m_buffer.data(), m_buffer.size(), m_buffer.data(), m_buffer.size(),
STR_C(driver_aid_nextlimit), STR_C(", new limit: %d km/h in %.1f km"),
nextspeedlimit, nextspeedlimit,
driver->ActualProximityDist * 0.001 ); driver->ActualProximityDist * 0.001 );
nextspeedlimittext = m_buffer.data(); nextspeedlimittext = m_buffer.data();
@@ -72,7 +72,7 @@ drivingaid_panel::update() {
// current speed and limit // current speed and limit
std::snprintf( std::snprintf(
m_buffer.data(), m_buffer.size(), m_buffer.data(), m_buffer.size(),
STR_C(driver_aid_speedlimit), STR_C(" Speed: %d km/h (limit %d km/h%s)%s"),
static_cast<int>( std::floor( mover->Vel ) ), static_cast<int>( std::floor( mover->Vel ) ),
speedlimit, speedlimit,
nextspeedlimittext.c_str(), nextspeedlimittext.c_str(),
@@ -82,7 +82,7 @@ drivingaid_panel::update() {
// base data and optional bits put together // base data and optional bits put together
std::snprintf( std::snprintf(
m_buffer.data(), m_buffer.size(), m_buffer.data(), m_buffer.size(),
STR_C(driver_aid_throttle), STR_C("Throttle: %2d+%d %c%s"),
driver->Controlling()->MainCtrlPos, driver->Controlling()->MainCtrlPos,
driver->Controlling()->ScndCtrlPos, driver->Controlling()->ScndCtrlPos,
( mover->ActiveDir > 0 ? 'D' : mover->ActiveDir < 0 ? 'R' : 'N' ), ( mover->ActiveDir > 0 ? 'D' : mover->ActiveDir < 0 ? 'R' : 'N' ),
@@ -96,14 +96,14 @@ drivingaid_panel::update() {
if( is_expanded ) { if( is_expanded ) {
std::snprintf ( std::snprintf (
m_buffer.data(), m_buffer.size(), m_buffer.data(), m_buffer.size(),
STR_C(driver_aid_pressures), STR_C(" Pressure: %.2f kPa (train pipe: %.2f kPa)"),
mover->BrakePress * 100, mover->BrakePress * 100,
mover->PipePress * 100 ); mover->PipePress * 100 );
expandedtext = m_buffer.data(); expandedtext = m_buffer.data();
} }
std::snprintf( std::snprintf(
m_buffer.data(), m_buffer.size(), m_buffer.data(), m_buffer.size(),
STR_C(driver_aid_brakes), STR_C("Brakes: %4.1f+%-2.0f%c%s"),
mover->fBrakeCtrlPos, mover->fBrakeCtrlPos,
mover->LocalBrakePosA * LocalBrakePosNo, mover->LocalBrakePosA * LocalBrakePosNo,
( mover->SlippingWheels ? '!' : ' ' ), ( mover->SlippingWheels ? '!' : ' ' ),
@@ -119,7 +119,7 @@ drivingaid_panel::update() {
if( stoptime > 0 ) { if( stoptime > 0 ) {
std::snprintf( std::snprintf(
m_buffer.data(), m_buffer.size(), m_buffer.data(), m_buffer.size(),
STR_C(driver_aid_loadinginprogress), STR_C(" Loading/unloading in progress (%d s left)"),
stoptime ); stoptime );
expandedtext = m_buffer.data(); expandedtext = m_buffer.data();
} }
@@ -128,7 +128,7 @@ drivingaid_panel::update() {
if( trackblockdistance <= 75.0 ) { if( trackblockdistance <= 75.0 ) {
std::snprintf( std::snprintf(
m_buffer.data(), m_buffer.size(), m_buffer.data(), m_buffer.size(),
STR_C(driver_aid_vehicleahead), STR_C(" Another vehicle ahead (distance: %.1f m)"),
trackblockdistance ); trackblockdistance );
expandedtext = m_buffer.data(); expandedtext = m_buffer.data();
} }
@@ -136,11 +136,11 @@ drivingaid_panel::update() {
} }
std::string textline = std::string textline =
( mover->SecuritySystem.is_vigilance_blinking() ? ( mover->SecuritySystem.is_vigilance_blinking() ?
STR(driver_aid_alerter) : STR("!ALERTER! ") :
" " ); " " );
textline += textline +=
( mover->SecuritySystem.is_cabsignal_blinking() ? ( mover->SecuritySystem.is_cabsignal_blinking() ?
STR(driver_aid_shp) : STR("!SHP!") :
" " ); " " );
text_lines.emplace_back( textline + " " + expandedtext, Global.UITextColor ); text_lines.emplace_back( textline + " " + expandedtext, Global.UITextColor );
@@ -169,7 +169,7 @@ scenario_panel::update() {
if( owner == nullptr ) { return; } if( owner == nullptr ) { return; }
std::string textline = std::string textline =
STR(driver_scenario_currenttask) + "\n " STR("Current task:") + "\n "
+ owner->OrderCurrent(); + owner->OrderCurrent();
text_lines.emplace_back( textline, Global.UITextColor ); text_lines.emplace_back( textline, Global.UITextColor );
@@ -205,7 +205,7 @@ scenario_panel::render() {
m_nearest->Mechanik : m_nearest->Mechanik :
m_nearest->ctOwner ) }; m_nearest->ctOwner ) };
if( owner != nullptr ) { if( owner != nullptr ) {
auto const assignmentheader { STR(driver_scenario_assignment) }; auto const assignmentheader { STR("Assignment") };
if( ( false == owner->assignment().empty() ) if( ( false == owner->assignment().empty() )
&& ( true == ImGui::CollapsingHeader( assignmentheader.c_str() ) ) ) { && ( true == ImGui::CollapsingHeader( assignmentheader.c_str() ) ) ) {
ImGui::TextWrapped( "%s", owner->assignment().c_str() ); ImGui::TextWrapped( "%s", owner->assignment().c_str() );
@@ -236,9 +236,9 @@ timetable_panel::update() {
{ // current time { // current time
std::snprintf( std::snprintf(
m_buffer.data(), m_buffer.size(), m_buffer.data(), m_buffer.size(),
STR_C(driver_timetable_header), STR_C("%-*.*s Time: %d:%02d:%02d"),
37, 37, 37, 37,
STR_C(driver_timetable_name), STR_C("Timetable"),
time.wHour, time.wHour,
time.wMinute, time.wMinute,
time.wSecond ); time.wSecond );
@@ -300,7 +300,7 @@ timetable_panel::update() {
} }
std::snprintf( std::snprintf(
m_buffer.data(), m_buffer.size(), m_buffer.data(), m_buffer.size(),
STR_C(driver_timetable_consistdata), STR_C("Consist weight: %d t (specified) %d t (actual)\nConsist length: %d m"),
static_cast<int>( table->LocLoad ), static_cast<int>( table->LocLoad ),
static_cast<int>( consistmass / 1000 ), static_cast<int>( consistmass / 1000 ),
static_cast<int>( consistlength ) ); static_cast<int>( consistlength ) );
@@ -311,7 +311,7 @@ timetable_panel::update() {
if( 0 == table->StationCount ) { if( 0 == table->StationCount ) {
// only bother if there's stations to list // only bother if there's stations to list
text_lines.emplace_back( STR(driver_timetable_notimetable), Global.UITextColor ); text_lines.emplace_back( STR("(no timetable)"), Global.UITextColor );
} }
else { else {
@@ -554,9 +554,9 @@ debug_panel::update_section_vehicle( std::vector<text_line> &Output ) {
std::snprintf( std::snprintf(
m_buffer.data(), m_buffer.size(), m_buffer.data(), m_buffer.size(),
STR_C(debug_vehicle_nameloadstatuscouplers), STR_C("Name: %s%s\nLoad: %.0f %s\nStatus: %s%s\nCouplers:\n front: %s\n rear: %s"),
mover.Name.c_str(), mover.Name.c_str(),
std::string( isowned ? STR(debug_vehicle_owned) + vehicle.ctOwner->OwnerName() : "" ).c_str(), std::string( isowned ? STR(", owned by: ") + vehicle.ctOwner->OwnerName() : "" ).c_str(),
mover.LoadAmount, mover.LoadAmount,
mover.LoadType.name.c_str(), mover.LoadType.name.c_str(),
mover.EngineDescription( 0 ).c_str(), mover.EngineDescription( 0 ).c_str(),
@@ -569,7 +569,7 @@ debug_panel::update_section_vehicle( std::vector<text_line> &Output ) {
std::snprintf( std::snprintf(
m_buffer.data(), m_buffer.size(), m_buffer.data(), m_buffer.size(),
STR_C(debug_vehicle_devicespower), STR_C("Devices: %c%c%c%c%c%c%c%c%c%c%c%c%c%c%s%s\nPower transfers: %.0f@%.0f%s%s%s%.0f@%.0f"),
// devices // devices
( mover.Battery ? 'B' : '.' ), ( mover.Battery ? 'B' : '.' ),
( mover.Mains ? 'M' : '.' ), ( mover.Mains ? 'M' : '.' ),
@@ -585,8 +585,8 @@ debug_panel::update_section_vehicle( std::vector<text_line> &Output ) {
( mover.ConvOvldFlag ? '!' : '.' ), ( mover.ConvOvldFlag ? '!' : '.' ),
( mover.CompressorFlag ? 'C' : ( false == mover.CompressorAllowLocal ? '-' : ( ( mover.CompressorAllow || mover.CompressorStart == start_t::automatic ) ? 'c' : '.' ) ) ), ( mover.CompressorFlag ? 'C' : ( false == mover.CompressorAllowLocal ? '-' : ( ( mover.CompressorAllow || mover.CompressorStart == start_t::automatic ) ? 'c' : '.' ) ) ),
( mover.CompressorGovernorLock ? '!' : '.' ), ( mover.CompressorGovernorLock ? '!' : '.' ),
std::string( isplayervehicle ? STR(debug_vehicle_radio) + ( mover.Radio ? std::to_string( m_input.train->RadioChannel() ) : "-" ) : "" ).c_str(), std::string( isplayervehicle ? STR(" radio: ") + ( mover.Radio ? std::to_string( m_input.train->RadioChannel() ) : "-" ) : "" ).c_str(),
std::string( isdieselenginepowered ? STR(debug_vehicle_oilpressure) + to_string( mover.OilPump.pressure, 2 ) : "" ).c_str(), std::string( isdieselenginepowered ? STR(" oil pressure: ") + to_string( mover.OilPump.pressure, 2 ) : "" ).c_str(),
// power transfers // power transfers
mover.Couplers[ end::front ].power_high.voltage, mover.Couplers[ end::front ].power_high.voltage,
mover.Couplers[ end::front ].power_high.current, mover.Couplers[ end::front ].power_high.current,
@@ -600,11 +600,11 @@ debug_panel::update_section_vehicle( std::vector<text_line> &Output ) {
std::snprintf( std::snprintf(
m_buffer.data(), m_buffer.size(), m_buffer.data(), m_buffer.size(),
STR_C(debug_vehicle_controllersenginerevolutions), STR_C("Controllers:\n master: %d(%d), secondary: %s\nEngine output: %.1f, current: %.0f\nRevolutions:\n engine: %.0f, motors: %.0f\n engine fans: %.0f, motor fans: %.0f+%.0f, cooling fans: %.0f+%.0f"),
// controllers // controllers
mover.MainCtrlPos, mover.MainCtrlPos,
mover.MainCtrlActualPos, mover.MainCtrlActualPos,
std::string( isdieselinshuntmode ? to_string( mover.AnPos, 2 ) + STR(debug_vehicle_shuntmode) : std::to_string( mover.ScndCtrlPos ) + "(" + std::to_string( mover.ScndCtrlActualPos ) + ")" ).c_str(), std::string( isdieselinshuntmode ? to_string( mover.AnPos, 2 ) + STR(" (shunt mode)") : std::to_string( mover.ScndCtrlPos ) + "(" + std::to_string( mover.ScndCtrlActualPos ) + ")" ).c_str(),
// engine // engine
mover.EnginePower, mover.EnginePower,
std::abs( mover.TrainType == dt_EZT ? mover.ShowCurrent( 0 ) : mover.Im ), std::abs( mover.TrainType == dt_EZT ? mover.ShowCurrent( 0 ) : mover.Im ),
@@ -622,7 +622,7 @@ debug_panel::update_section_vehicle( std::vector<text_line> &Output ) {
if( isdieselenginepowered ) { if( isdieselenginepowered ) {
std::snprintf( std::snprintf(
m_buffer.data(), m_buffer.size(), m_buffer.data(), m_buffer.size(),
STR_C(debug_vehicle_temperatures), STR_C("\nTemperatures:\n engine: %.2f, oil: %.2f, water: %.2f%c%.2f"),
mover.dizel_heat.Ts, mover.dizel_heat.Ts,
mover.dizel_heat.To, mover.dizel_heat.To,
mover.dizel_heat.temperatura1, mover.dizel_heat.temperatura1,
@@ -635,7 +635,7 @@ debug_panel::update_section_vehicle( std::vector<text_line> &Output ) {
std::snprintf( std::snprintf(
m_buffer.data(), m_buffer.size(), m_buffer.data(), m_buffer.size(),
STR_C(debug_vehicle_brakespressures), STR_C("Brakes:\n train: %.2f, independent: %.2f, mode: %d, delay: %s, load flag: %d\nBrake cylinder pressures:\n train: %.2f, independent: %.2f, status: 0x%.2x\nPipe pressures:\n brake: %.2f (hat: %.2f), main: %.2f, control: %.2f\nTank pressures:\n auxiliary: %.2f, main: %.2f, control: %.2f"),
// brakes // brakes
mover.fBrakeCtrlPos, mover.fBrakeCtrlPos,
mover.LocalBrakePosA, mover.LocalBrakePosA,
@@ -661,7 +661,7 @@ debug_panel::update_section_vehicle( std::vector<text_line> &Output ) {
if( mover.EnginePowerSource.SourceType == TPowerSource::CurrentCollector ) { if( mover.EnginePowerSource.SourceType == TPowerSource::CurrentCollector ) {
std::snprintf( std::snprintf(
m_buffer.data(), m_buffer.size(), m_buffer.data(), m_buffer.size(),
STR_C(debug_vehicle_pantograph), STR_C(" pantograph: %.2f%cMT"),
mover.PantPress, mover.PantPress,
( mover.bPantKurek3 ? '-' : '|' ) ); ( mover.bPantKurek3 ? '-' : '|' ) );
textline += m_buffer.data(); textline += m_buffer.data();
@@ -677,7 +677,7 @@ debug_panel::update_section_vehicle( std::vector<text_line> &Output ) {
std::snprintf( std::snprintf(
m_buffer.data(), m_buffer.size(), m_buffer.data(), m_buffer.size(),
STR_C(debug_vehicle_forcesaccelerationvelocityposition), STR_C("Forces:\n tractive: %.1f, brake: %.1f, friction: %.2f%s\nAcceleration:\n tangential: %.2f, normal: %.2f (path radius: %s)\nVelocity: %.2f, distance traveled: %.2f\nPosition: [%.2f, %.2f, %.2f]"),
// forces // forces
mover.Ft * 0.001f * ( mover.ActiveCab ? mover.ActiveCab : vehicle.ctOwner ? vehicle.ctOwner->Controlling()->ActiveCab : 1 ) + 0.001f, mover.Ft * 0.001f * ( mover.ActiveCab ? mover.ActiveCab : vehicle.ctOwner ? vehicle.ctOwner->Controlling()->ActiveCab : 1 ) + 0.001f,
mover.Fb * 0.001f, mover.Fb * 0.001f,
@@ -702,7 +702,7 @@ debug_panel::update_section_vehicle( std::vector<text_line> &Output ) {
std::string std::string
debug_panel::update_vehicle_coupler( int const Side ) { debug_panel::update_vehicle_coupler( int const Side ) {
// NOTE: mover and vehicle are guaranteed to be valid by the caller // NOTE: mover and vehicle are guaranteed to be valid by the caller
std::string couplerstatus { STR(debug_vehicle_none) }; std::string couplerstatus { STR("none") };
auto const *connected { m_input.vehicle->MoverParameters->Neighbours[ Side ].vehicle }; auto const *connected { m_input.vehicle->MoverParameters->Neighbours[ Side ].vehicle };

2
editoruilayer.cpp
View File

@@ -74,7 +74,7 @@ const std::string *editor_ui::get_active_node_template() {
void editor_ui::render_menu_contents() { void editor_ui::render_menu_contents() {
ui_layer::render_menu_contents(); ui_layer::render_menu_contents();
if (ImGui::BeginMenu(STR_C(ui_mode_windows))) if (ImGui::BeginMenu(STR_C("Mode windows")))
{ {
ImGui::MenuItem(m_nodebankpanel.title.c_str(), nullptr, &m_nodebankpanel.is_open); ImGui::MenuItem(m_nodebankpanel.title.c_str(), nullptr, &m_nodebankpanel.is_open);
ImGui::EndMenu(); ImGui::EndMenu();

2
scenarioloadermode.cpp
View File

@@ -83,7 +83,7 @@ scenarioloader_mode::enter() {
m_userinterface->set_background( "logo" ); m_userinterface->set_background( "logo" );
Application.set_title( Global.AppName + " (" + Global.SceneryFile + ")" ); Application.set_title( Global.AppName + " (" + Global.SceneryFile + ")" );
m_userinterface->set_progress(); m_userinterface->set_progress();
m_userinterface->set_progress(STR(ui_loading_scenery)); m_userinterface->set_progress(STR("Loading scenery"));
GfxRenderer.Render(); GfxRenderer.Render();
} }

1
stb/stb_image.h
View File

@@ -111,6 +111,7 @@ RECENT REVISION HISTORY:
#define STBI_INCLUDE_STB_IMAGE_H #define STBI_INCLUDE_STB_IMAGE_H
#define STBI_ONLY_JPEG #define STBI_ONLY_JPEG
#define STBI_ONLY_BMP
// DOCUMENTATION // DOCUMENTATION
// //

1
stdafx.h
View File

@@ -76,6 +76,7 @@
#include <bitset> #include <bitset>
#include <chrono> #include <chrono>
#include <optional> #include <optional>
#include <filesystem>
#include "glad/glad.h" #include "glad/glad.h"

766
translation.cpp
View File

@@ -16,563 +16,12 @@ http://mozilla.org/MPL/2.0/.
#include "Logs.h" #include "Logs.h"
#include "Globals.h" #include "Globals.h"
/*
// TODO: import localized strings from localization files
std::unordered_map<std::string, std::vector<std::string>> stringmap;
stringmap.insert(
{ "en",
{
"Driving Aid",
"Throttle: %2d+%d %c%s",
" Speed: %d km/h (limit %d km/h%s)%s",
", new limit: %d km/h in %.1f km",
" Grade: %.1f%%%%",
"Brakes: %4.1f+%-2.0f%c%s",
" Pressure: %.2f kPa (train pipe: %.2f kPa)",
"!ALERTER! ",
"!SHP!",
" Loading/unloading in progress (%d s left)",
" Another vehicle ahead (distance: %.1f m)",
"Scenario",
"Assignment",
"Current task:",
"Wait for orders",
"Start the engine",
"Shut down the engine",
"Change direction",
"Couple to consist ahead",
"Uncouple %s",
"the engine",
"the engine plus the next vehicle",
"the engine plus %d next vehicles",
"the engine plus %d next vehicles",
"Shunt according to signals",
"Loose shunt according to signals",
"Drive according to signals and timetable",
"Bank consist ahead",
"%-*.*s Time: %d:%02d:%02d", // HACK: some manual padding to account for longer 'time' equivalent in polish version
"Timetable",
"(no timetable)",
"Consist weight: %d t (specified) %d t (actual)\nConsist length: %d m",
"Transcripts",
"Simulation Paused",
"Resume",
"Quit",
"Name: %s%s\nLoad: %.0f %s\nStatus: %s%s\nCouplers:\n front: %s\n rear: %s",
", owned by: ",
"none",
"Devices: %c%c%c%c%c%c%c%c%c%c%c%c%c%c%s%s\nPower transfers: %.0f@%.0f%s%s%s%.0f@%.0f",
" radio: ",
" oil pressure: ",
"Controllers:\n master: %d(%d), secondary: %s\nEngine output: %.1f, current: %.0f\nRevolutions:\n engine: %.0f, motors: %.0f\n engine fans: %.0f, motor fans: %.0f+%.0f, cooling fans: %.0f+%.0f",
" (shunt mode)",
"\nTemperatures:\n engine: %.2f, oil: %.2f, water: %.2f%c%.2f",
"Brakes:\n train: %.2f, independent: %.2f, mode: %d, delay: %s, load flag: %d\nBrake cylinder pressures:\n train: %.2f, independent: %.2f, status: 0x%.2x\nPipe pressures:\n brake: %.2f (hat: %.2f), main: %.2f, control: %.2f\nTank pressures:\n auxiliary: %.2f, main: %.2f, control: %.2f",
" pantograph: %.2f%cMT",
"Forces:\n tractive: %.1f, brake: %.1f, friction: %.2f%s\nAcceleration:\n tangential: %.2f, normal: %.2f (path radius: %s)\nVelocity: %.2f, distance traveled: %.2f\nPosition: [%.2f, %.2f, %.2f]",
"expand",
"Loading",
"Loading scenery",
"Quit simulation?",
"Yes",
"No",
"General",
"Debug mode",
"Quit",
"Tools",
"Logging to log.txt",
"Screenshot",
"Windows",
"Log",
"Map",
"Mode windows",
"Time and environment",
"Time",
"Day in year",
"Visibility",
"Overcast and precipitation",
"Temperature",
"Apply",
"Straight |",
"Divert /",
"Open |",
"Close -",
"Insert obstacle:",
"Delete obstacle",
"Vehicle list",
"Vehicle parameters",
"Radiostop",
"Reset position",
"Stop and repair",
"Refill main tank",
"Rupture main pipe",
"Move +500m",
"Move -500m",
"Camera preview",
"master controller",
"master controller",
"second controller",
"shunt mode power",
"tempomat",
"reverser",
"train brake",
"independent brake",
"manual brake",
"emergency brake",
"brake acting speed",
"brake acting speed: cargo",
"brake acting speed: rapid",
"brake operation mode",
"motor overload relay threshold",
"water pump",
"water pump breaker",
"water heater",
"water heater breaker",
"water circuits link",
"fuel pump",
"oil pump",
"motor blowers A",
"motor blowers B",
"all motor blowers",
"cooling fans",
"line breaker",
"line breaker",
"alerter",
"independent brake releaser",
"sandbox",
"wheelspin brake",
"horn",
"low tone horn",
"high tone horn",
"whistle",
"motor overload relay reset",
"converter overload relay reset",
"motor connectors",
"left door (permit)",
"right door (permit)",
"door (permit)",
"left door",
"right door",
"left door (open)",
"right door (open)",
"left door (close)",
"right door (close)",
"all doors (open)",
"all doors (close)",
"doorstep",
"door control mode",
"departure signal",
"upper headlight",
"left headlight",
"right headlight",
"headlights dimmer",
"left marker light",
"right marker light",
"light pattern",
"rear upper headlight",
"rear left headlight",
"rear right headlight",
"rear left marker light",
"rear right marker light",
"compressor",
"local compressor",
"converter",
"local converter",
"converter",
"line breaker",
"radio",
"radio channel",
"radio channel",
"radio channel",
"radiostop test",
"radiostop",
"pantograph A",
"pantograph B",
"pantograph A",
"pantograph B",
"all pantographs",
"selected pantograph",
"selected pantograph",
"pantograph compressor",
"pantograph 3 way valve",
"heating",
"braking indicator",
"door locking",
"current indicator source",
"instrument light",
"dashboard light",
"timetable light",
"interior light",
"interior light dimmer",
"battery",
"interactive part",
"interactive part",
"interactive part",
"interactive part",
"interactive part",
"interactive part",
"interactive part",
"interactive part",
"interactive part",
"interactive part"
}
} );
stringmap.insert(
{ "pl",
{
u8"Pomocnik",
u8"Nastawnik: %2d+%d %c%s",
u8" Prędkość: %d km/h (limit %d km/h%s)%s",
u8", nowy limit: %d km/h za %.1f km",
u8" Nachylenie: %.1f%%%%",
u8"Hamulce: %4.1f+%-2.0f%c%s",
u8" Ciśnienie: %.2f kPa (przewód główny: %.2f kPa)",
u8"!CZUWAK! ",
u8"!SHP!",
u8" Wsiadanie/wysiadanie pasażerów (do zakończenia %d s)",
u8" Inny pojazd na drodze (odległość: %.1f m)",
u8"Scenariusz",
u8"Zlecenie",
u8"Bieżace zadanie:",
u8"Oczekiwać dalszych poleceń",
u8"Przygotować pojazd do jazdy",
u8"Wyłączyc pojazd",
u8"Zmienić kierunek jazdy",
u8"Sprząc się ze składem z przodu",
u8"Odpiąć %s",
u8"pojazd prowadzący",
u8"pojazd prowadzący plus kolejny",
u8"pojazd prowadzący plus %d kolejne",
u8"pojazd prowadzący plus %d kolejnych",
u8"Prowadzić manewry według sygnałów",
u8"Prowadzić manewry przetaczania odrzutem",
u8"Prowadzić skład według sygnałów i rozkładu",
u8"Popychać skład z przodu",
u8"%-*.*s Godzina: %d:%02d:%02d",
u8"Rozkład jazdy",
u8"(brak rozkładu)",
u8"Brutto: %d t (rozkładowe) %d t (rzeczywiste)\nDługość pociągu: %d m",
u8"Transkrypcje",
u8"Symulacja wstrzymana",
u8"Wznów",
u8"Zakończ",
u8"Nazwa: %s%s\nŁadunek: %.0f %s\nStatus: %s%s\nSprzęgi:\n przedni: %s\n tylny: %s",
u8", wlaściciel: ",
u8"wolny",
u8"Urządzenia: %c%c%c%c%c%c%c%c%c%c%c%c%c%c%s%s\nPrzepływ prądu: %.0f@%.0f%s%s%s%.0f@%.0f",
u8" radio: ",
u8" cisń. oleju: ",
u8"Nastawniki:\n glówny: %d(%d), dodatkowy: %s\nMoc silnika: %.1f, prąd silnika: %.0f\nObroty:\n silnik: %.0f, motory: %.0f, went.silnika: %.0f, went.chłodnicy: %.0f+%.0f",
u8" (tryb manewrowy)",
u8"\nTemperatury:\n silnik: %.2f, olej: %.2f, woda: %.2f%c%.2f",
u8"Hamulce:\n zespolony: %.2f, pomocniczy: %.2f, tryb: %d, nastawa: %s, ładunek: %d\nCiśnienie w cylindrach:\n zespolony: %.2f, pomocniczy: %.2f, status: 0x%.2x\nCiśnienia w przewodach:\n główny: %.2f (kapturek: %.2f), zasilający: %.2f, kontrolny: %.2f\nCiśnienia w zbiornikach:\n pomocniczy: %.2f, główny: %.2f, sterujący: %.2f",
u8" pantograf: %.2f%cZG",
u8"Siły:\n napędna: %.1f, hamowania: %.1f, tarcie: %.2f%s\nPrzyśpieszenia:\n styczne: %.2f, normalne: %.2f (promień: %s)\nPrędkość: %.2f, pokonana odleglość: %.2f\nPozycja: [%.2f, %.2f, %.2f]",
u8"rozszerz",
u8"Ładowanie",
u8"Wczytywanie scenerii",
u8"Zakończyć symulację?",
u8"Tak",
u8"Nie",
u8"Ogólne",
u8"Tryb debug",
u8"Wyjdź",
u8"Narzędzia",
u8"Logowanie do log.txt",
u8"Zrzut ekranu",
u8"Okna",
u8"Log",
u8"Mapa",
u8"Okna trybu",
u8"Czas i środowisko",
u8"Czas",
u8"Dzień w roku",
u8"Widoczność",
u8"Zachmurzenie i opady",
u8"Temperatura",
u8"Zastosuj",
u8"Prosto |",
u8"W bok /",
u8"Otwórz |",
u8"Zamknij -",
u8"Wstaw przeszkodę:",
u8"Usuń przeszkodę",
u8"Lista pojazdów",
u8"Parametry pojazdu",
u8"Radiostop",
u8"Zresetuj pozycję",
u8"Zatrzymaj i napraw",
u8"Napełnij ZG",
u8"Zerwij PG",
u8"Przesuń +500m",
u8"Przesuń -500m",
u8"Podgląd kamery",
u8"nastawnik jazdy",
u8"nastawnik jazdy",
u8"nastawnik dodatkowy",
u8"sterowanie analogowe",
u8"tempomat",
u8"nastawnik kierunku",
u8"hamulec zespolony",
u8"hamulec pomocniczy",
u8"hamulec ręczny",
u8"hamulec bezpieczeństwa",
u8"nastawa hamulca",
u8"nastawa hamulca: towarowy",
u8"nastawa hamulca: pośpieszny",
u8"tryb pracy hamulca",
u8"zakres prądu rozruchu",
u8"pompa wody",
u8"wyłącznik samoczynny pompy wody",
u8"podgrzewacz wody",
u8"wyłącznik samoczynny podgrzewacza wody",
u8"zawór połaczenia obiegow wody",
u8"pompa paliwa",
u8"pompa oleju",
u8"wentylatory silników trakcyjnych A",
u8"wentylatory silników trakcyjnych B",
u8"wszystkie wentylatory silników trakcyjnych",
u8"wentylatory oporów rozruchowych",
u8"wyłącznik szybki",
u8"wyłącznik szybki",
u8"czuwak",
u8"odluźniacz",
u8"piasecznica",
u8"hamulec przeciwpoślizgowy",
u8"syrena",
u8"syrena (ton niski)",
u8"syrena (ton wysoki)",
u8"gwizdawka",
u8"przekaźnik nadmiarowy silników trakcyjnych",
u8"przekaźnik nadmiarowy przetwornicy",
u8"styczniki liniowe",
u8"drzwi lewe (zezwól)",
u8"drzwi prawe (zezwól)",
u8"drzwi (zezwól)",
u8"drzwi lewe",
u8"drzwi prawe",
u8"drzwi lewe (otwórz)",
u8"drzwi prawe (otwórz)",
u8"drzwi lewe (zamknij)",
u8"drzwi prawe (zamknij)",
u8"drzwi (otwórz)",
u8"drzwi (zamknij)",
u8"stopień drzwi",
u8"tryb sterowania drzwiami",
u8"sygnal odjazdu",
u8"reflektor gorny",
u8"reflektor lewy",
u8"reflektor prawy",
u8"przyciemnienie reflektórow",
u8"sygnal lewy",
u8"sygnal prawy",
u8"programator świateł",
u8"tylny reflektor górny",
u8"tylny reflektor lewy",
u8"tylny reflektor prawy",
u8"tylny sygnal lewy",
u8"tylny sygnal prawy",
u8"sprężarka",
u8"sprężarka lokalna",
u8"przetwornica",
u8"przetwornica lokalna",
u8"przetwornica",
u8"wyłącznik szybki",
u8"radio",
u8"kanał radia",
u8"kanał radia",
u8"kanał radia",
u8"test radiostopu",
u8"radiostop",
u8"pantograf A",
u8"pantograf B",
u8"pantograf A",
u8"pantograf B",
u8"wszystkie pantografy",
u8"wybrany pantograf",
u8"wybrany pantograf",
u8"sprężarka pantografow",
u8"kurek trójdrogowy pantografow",
u8"ogrzewanie pociągu",
u8"sygnalizacja hamowania",
u8"blokada drzwi",
u8"prądy drugiego członu",
u8"oświetlenie przyrządow",
u8"oświetlenie pulpitu",
u8"oświetlenie rozkładu jazdy",
u8"oświetlenie kabiny",
u8"przyciemnienie oświetlenia kabiny",
u8"bateria",
u8"element ruchomy",
u8"element ruchomy",
u8"element ruchomy",
u8"element ruchomy",
u8"element ruchomy",
u8"element ruchomy",
u8"element ruchomy",
u8"element ruchomy",
u8"element ruchomy",
u8"element ruchomy"
}
} );
auto lookup { stringmap.find( Global.asLang ) };
if( lookup == stringmap.end() ) {
lookup = stringmap.find( "en" );
}
locale::strings = lookup->second;
// prepare cab controls translation table
{
std::vector<std::string> cabcontrols = {
"mainctrl:",
"jointctrl:",
"scndctrl:",
"shuntmodepower:",
"tempomat_sw:",
"dirkey:",
"brakectrl:",
"localbrake:",
"manualbrake:",
"alarmchain:",
"brakeprofile_sw:",
"brakeprofileg_sw:",
"brakeprofiler_sw:",
"brakeopmode_sw",
"maxcurrent_sw:",
"waterpump_sw:",
"waterpumpbreaker_sw:",
"waterheater_sw:",
"waterheaterbreaker_sw:",
"watercircuitslink_sw:",
"fuelpump_sw:",
"oilpump_sw:",
"motorblowersfront_sw:",
"motorblowersrear_sw:",
"motorblowersalloff_sw:",
"coolingfans_sw:",
"main_off_bt:",
"main_on_bt:",
"security_reset_bt:",
"releaser_bt:",
"sand_bt:",
"antislip_bt:",
"horn_bt:",
"hornlow_bt:",
"hornhigh_bt:",
"whistle_bt:",
"fuse_bt:",
"converterfuse_bt:",
"stlinoff_bt:",
"doorleftpermit_sw:",
"doorrightpermit_sw:",
"doorpermitpreset_sw:",
"door_left_sw:",
"door_right_sw:",
"doorlefton_sw:",
"doorrighton_sw:",
"doorleftoff_sw:",
"doorrightoff_sw:",
"doorallon_sw:",
"dooralloff_sw:",
"doorstep_sw:",
"doormode_sw",
"departure_signal_bt:",
"upperlight_sw:",
"leftlight_sw:",
"rightlight_sw:",
"dimheadlights_sw:",
"leftend_sw:",
"rightend_sw:",
"lights_sw:",
"rearupperlight_sw:",
"rearleftlight_sw:",
"rearrightlight_sw:",
"rearleftend_sw:",
"rearrightend_sw:",
"compressor_sw:",
"compressorlocal_sw:",
"converter_sw:",
"converterlocal_sw:",
"converteroff_sw:",
"main_sw:",
"radio_sw:",
"radiochannel_sw:",
"radiochannelprev_sw:",
"radiochannelnext_sw:",
"radiotest_sw:",
"radiostop_sw:",
"pantfront_sw:",
"pantrear_sw:",
"pantfrontoff_sw:",
"pantrearoff_sw:",
"pantalloff_sw:",
"pantselected_sw:",
"pantselectedoff_sw:",
"pantcompressor_sw:",
"pantcompressorvalve_sw:",
"trainheating_sw:",
"signalling_sw:",
"door_signalling_sw:",
"nextcurrent_sw:",
"instrumentlight_sw:",
"dashboardlight_sw:",
"timetablelight_sw:",
"cablight_sw:",
"cablightdim_sw:",
"battery_sw:",
"universal0:",
"universal1:",
"universal2:",
"universal3:",
"universal4:",
"universal5:",
"universal6:",
"universal7:",
"universal8:",
"universal9:"
};
std::size_t stringidx { string::cab_mainctrl };
for( auto const &cabcontrol : cabcontrols ) {
m_cabcontrols.insert( { cabcontrol, strings[ stringidx++ ] } );
}
}
*/
void locale::init() void locale::init()
{ {
std::fstream stream("lang/" + Global.asLang + ".po", std::ios_base::in | std::ios_base::binary); std::fstream stream("lang/" + Global.asLang + ".po", std::ios_base::in | std::ios_base::binary);
if (!stream.is_open()) { if (!stream.is_open()) {
WriteLog("translation: cannot open lang file: " + Global.asLang); WriteLog("translation: cannot open lang file: lang/" + Global.asLang + ".po");
return; return;
} }
@@ -651,6 +100,7 @@ bool locale::parse_translation(std::istream &stream)
} }
else { else {
if (!msgid.empty() && !msgstr.empty()) { if (!msgid.empty() && !msgstr.empty()) {
// TODO: context support is incomplete
if (!msgctxt.empty()) if (!msgctxt.empty())
lang_mapping.emplace(msgctxt + "\x1d" + msgid, msgstr); lang_mapping.emplace(msgctxt + "\x1d" + msgid, msgstr);
else else
@@ -719,112 +169,112 @@ std::string locale::label_cab_control(std::string const &Label)
if( Label.empty() ) { return ""; } if( Label.empty() ) { return ""; }
static std::unordered_map<std::string, std::string> cabcontrols_labels = { static std::unordered_map<std::string, std::string> cabcontrols_labels = {
{ "mainctrl:", "master controller" }, { "mainctrl:", STRN("master controller") },
{ "jointctrl:", "master controller" }, { "jointctrl:", STRN("master controller") },
{ "scndctrl:", "second controller" }, { "scndctrl:", STRN("second controller") },
{ "shuntmodepower:", "shunt mode power" }, { "shuntmodepower:", STRN("shunt mode power") },
{ "tempomat_sw:", "tempomat" }, { "tempomat_sw:", STRN("tempomat") },
{ "dirkey:", "reverser" }, { "dirkey:", STRN("reverser") },
{ "brakectrl:", "train brake" }, { "brakectrl:", STRN("train brake") },
{ "localbrake:", "independent brake" }, { "localbrake:", STRN("independent brake") },
{ "manualbrake:", "manual brake" }, { "manualbrake:", STRN("manual brake") },
{ "alarmchain:", "emergency brake" }, { "alarmchain:", STRN("emergency brake") },
{ "brakeprofile_sw:", "brake acting speed" }, { "brakeprofile_sw:", STRN("brake acting speed") },
{ "brakeprofileg_sw:", "brake acting speed: cargo" }, { "brakeprofileg_sw:", STRN("brake acting speed: cargo") },
{ "brakeprofiler_sw:", "brake acting speed: rapid" }, { "brakeprofiler_sw:", STRN("brake acting speed: rapid") },
{ "brakeopmode_sw", "brake operation mode" }, { "brakeopmode_sw", STRN("brake operation mode") },
{ "maxcurrent_sw:", "motor overload relay threshold" }, { "maxcurrent_sw:", STRN("motor overload relay threshold") },
{ "waterpump_sw:", "water pump" }, { "waterpump_sw:", STRN("water pump") },
{ "waterpumpbreaker_sw:", "water pump breaker" }, { "waterpumpbreaker_sw:", STRN("water pump breaker") },
{ "waterheater_sw:", "water heater" }, { "waterheater_sw:", STRN("water heater") },
{ "waterheaterbreaker_sw:", "water heater breaker" }, { "waterheaterbreaker_sw:", STRN("water heater breaker") },
{ "watercircuitslink_sw:", "water circuits link" }, { "watercircuitslink_sw:", STRN("water circuits link") },
{ "fuelpump_sw:", "fuel pump" }, { "fuelpump_sw:", STRN("fuel pump") },
{ "oilpump_sw:", "oil pump" }, { "oilpump_sw:", STRN("oil pump") },
{ "motorblowersfront_sw:", "motor blowers A" }, { "motorblowersfront_sw:", STRN("motor blowers A") },
{ "motorblowersrear_sw:", "motor blowers B" }, { "motorblowersrear_sw:", STRN("motor blowers B") },
{ "motorblowersalloff_sw:", "all motor blowers" }, { "motorblowersalloff_sw:", STRN("all motor blowers") },
{ "coolingfans_sw:", "cooling fans" }, { "coolingfans_sw:", STRN("cooling fans") },
{ "main_off_bt:", "line breaker" }, { "main_off_bt:", STRN("line breaker") },
{ "main_on_bt:", "line breaker" }, { "main_on_bt:", STRN("line breaker") },
{ "security_reset_bt:", "alerter" }, { "security_reset_bt:", STRN("alerter") },
{ "releaser_bt:", "independent brake releaser" }, { "releaser_bt:", STRN("independent brake releaser") },
{ "sand_bt:", "sandbox" }, { "sand_bt:", STRN("sandbox") },
{ "antislip_bt:", "wheelspin brake" }, { "antislip_bt:", STRN("wheelspin brake") },
{ "horn_bt:", "horn" }, { "horn_bt:", STRN("horn") },
{ "hornlow_bt:", "low tone horn" }, { "hornlow_bt:", STRN("low tone horn") },
{ "hornhigh_bt:", "high tone horn" }, { "hornhigh_bt:", STRN("high tone horn") },
{ "whistle_bt:", "whistle" }, { "whistle_bt:", STRN("whistle") },
{ "fuse_bt:", "motor overload relay reset" }, { "fuse_bt:", STRN("motor overload relay reset") },
{ "converterfuse_bt:", "converter overload relay reset" }, { "converterfuse_bt:", STRN("converter overload relay reset") },
{ "stlinoff_bt:", "motor connectors" }, { "stlinoff_bt:", STRN("motor connectors") },
{ "doorleftpermit_sw:", "left door (permit)" }, { "doorleftpermit_sw:", STRN("left door (permit)") },
{ "doorrightpermit_sw:", "right door (permit)" }, { "doorrightpermit_sw:", STRN("right door (permit)") },
{ "doorpermitpreset_sw:", "door (permit)" }, { "doorpermitpreset_sw:", STRN("door (permit)") },
{ "door_left_sw:", "left door" }, { "door_left_sw:", STRN("left door") },
{ "door_right_sw:", "right door" }, { "door_right_sw:", STRN("right door") },
{ "doorlefton_sw:", "left door (open)" }, { "doorlefton_sw:", STRN("left door (open)") },
{ "doorrighton_sw:", "right door (open)" }, { "doorrighton_sw:", STRN("right door (open)") },
{ "doorleftoff_sw:", "left door (close)" }, { "doorleftoff_sw:", STRN("left door (close)") },
{ "doorrightoff_sw:", "right door (close)" }, { "doorrightoff_sw:", STRN("right door (close)") },
{ "doorallon_sw:", "all doors (open)" }, { "doorallon_sw:", STRN("all doors (open)") },
{ "dooralloff_sw:", "all doors (close)" }, { "dooralloff_sw:", STRN("all doors (close)") },
{ "doorstep_sw:", "doorstep" }, { "doorstep_sw:", STRN("doorstep") },
{ "doormode_sw", "door control mode" }, { "doormode_sw", STRN("door control mode") },
{ "departure_signal_bt:", "departure signal" }, { "departure_signal_bt:", STRN("departure signal") },
{ "upperlight_sw:", "upper headlight" }, { "upperlight_sw:", STRN("upper headlight") },
{ "leftlight_sw:", "left headlight" }, { "leftlight_sw:", STRN("left headlight") },
{ "rightlight_sw:", "right headlight" }, { "rightlight_sw:", STRN("right headlight") },
{ "dimheadlights_sw:", "headlights dimmer" }, { "dimheadlights_sw:", STRN("headlights dimmer") },
{ "leftend_sw:", "left marker light" }, { "leftend_sw:", STRN("left marker light") },
{ "rightend_sw:", "right marker light" }, { "rightend_sw:", STRN("right marker light") },
{ "lights_sw:", "light pattern" }, { "lights_sw:", STRN("light pattern") },
{ "rearupperlight_sw:", "rear upper headlight" }, { "rearupperlight_sw:", STRN("rear upper headlight") },
{ "rearleftlight_sw:", "rear left headlight" }, { "rearleftlight_sw:", STRN("rear left headlight") },
{ "rearrightlight_sw:", "rear right headlight" }, { "rearrightlight_sw:", STRN("rear right headlight") },
{ "rearleftend_sw:", "rear left marker light" }, { "rearleftend_sw:", STRN("rear left marker light") },
{ "rearrightend_sw:", "rear right marker light" }, { "rearrightend_sw:", STRN("rear right marker light") },
{ "compressor_sw:", "compressor" }, { "compressor_sw:", STRN("compressor") },
{ "compressorlocal_sw:", "local compressor" }, { "compressorlocal_sw:", STRN("local compressor") },
{ "converter_sw:", "converter" }, { "converter_sw:", STRN("converter") },
{ "converterlocal_sw:", "local converter" }, { "converterlocal_sw:", STRN("local converter") },
{ "converteroff_sw:", "converter" }, { "converteroff_sw:", STRN("converter") },
{ "main_sw:", "line breaker" }, { "main_sw:", STRN("line breaker") },
{ "radio_sw:", "radio" }, { "radio_sw:", STRN("radio") },
{ "radiochannel_sw:", "radio channel" }, { "radiochannel_sw:", STRN("radio channel") },
{ "radiochannelprev_sw:", "radio channel" }, { "radiochannelprev_sw:", STRN("radio channel") },
{ "radiochannelnext_sw:", "radio channel" }, { "radiochannelnext_sw:", STRN("radio channel") },
{ "radiotest_sw:", "radiostop test" }, { "radiotest_sw:", STRN("radiostop test") },
{ "radiostop_sw:", "radiostop" }, { "radiostop_sw:", STRN("radiostop") },
{ "pantfront_sw:", "pantograph A" }, { "pantfront_sw:", STRN("pantograph A") },
{ "pantrear_sw:", "pantograph B" }, { "pantrear_sw:", STRN("pantograph B") },
{ "pantfrontoff_sw:", "pantograph A" }, { "pantfrontoff_sw:", STRN("pantograph A") },
{ "pantrearoff_sw:", "pantograph B" }, { "pantrearoff_sw:", STRN("pantograph B") },
{ "pantalloff_sw:", "all pantographs" }, { "pantalloff_sw:", STRN("all pantographs") },
{ "pantselected_sw:", "selected pantograph" }, { "pantselected_sw:", STRN("selected pantograph") },
{ "pantselectedoff_sw:", "selected pantograph" }, { "pantselectedoff_sw:", STRN("selected pantograph") },
{ "pantcompressor_sw:", "pantograph compressor" }, { "pantcompressor_sw:", STRN("pantograph compressor") },
{ "pantcompressorvalve_sw:", "pantograph 3 way valve" }, { "pantcompressorvalve_sw:", STRN("pantograph 3 way valve") },
{ "trainheating_sw:", "heating" }, { "trainheating_sw:", STRN("heating") },
{ "signalling_sw:", "braking indicator" }, { "signalling_sw:", STRN("braking indicator") },
{ "door_signalling_sw:", "door locking" }, { "door_signalling_sw:", STRN("door locking") },
{ "nextcurrent_sw:", "current indicator source" }, { "nextcurrent_sw:", STRN("current indicator source") },
{ "instrumentlight_sw:", "instrument light" }, { "instrumentlight_sw:", STRN("instrument light") },
{ "dashboardlight_sw:", "dashboard light" }, { "dashboardlight_sw:", STRN("dashboard light") },
{ "timetablelight_sw:", "timetable light" }, { "timetablelight_sw:", STRN("timetable light") },
{ "cablight_sw:", "interior light" }, { "cablight_sw:", STRN("interior light") },
{ "cablightdim_sw:", "interior light dimmer" }, { "cablightdim_sw:", STRN("interior light dimmer") },
{ "battery_sw:", "battery" }, { "battery_sw:", STRN("battery") },
{ "universal0:", "interactive part" }, { "universal0:", STRN("interactive part") },
{ "universal1:", "interactive part" }, { "universal1:", STRN("interactive part") },
{ "universal2:", "interactive part" }, { "universal2:", STRN("interactive part") },
{ "universal3:", "interactive part" }, { "universal3:", STRN("interactive part") },
{ "universal4:", "interactive part" }, { "universal4:", STRN("interactive part") },
{ "universal5:", "interactive part" }, { "universal5:", STRN("interactive part") },
{ "universal6:", "interactive part" }, { "universal6:", STRN("interactive part") },
{ "universal7:", "interactive part" }, { "universal7:", STRN("interactive part") },
{ "universal8:", "interactive part" }, { "universal8:", STRN("interactive part") },
{ "universal9:", "interactive part" } { "universal9:", STRN("interactive part") }
}; };
auto const it = cabcontrols_labels.find( Label ); auto const it = cabcontrols_labels.find( Label );

221
translation.h
View File

@@ -12,218 +12,6 @@ http://mozilla.org/MPL/2.0/.
#include <string> #include <string>
#include <unordered_map> #include <unordered_map>
/*
driver_aid_header,
driver_aid_throttle,
driver_aid_speedlimit,
driver_aid_nextlimit,
driver_aid_grade,
driver_aid_brakes,
driver_aid_pressures,
driver_aid_alerter,
driver_aid_shp,
driver_aid_loadinginprogress,
driver_aid_vehicleahead,
driver_scenario_header,
driver_scenario_assignment,
driver_scenario_currenttask,
driver_scenario_waitfororders,
driver_scenario_prepareengine,
driver_scenario_releaseengine,
driver_scenario_changedirection,
driver_scenario_connect,
driver_scenario_disconnect,
driver_scenario_allvehicles,
driver_scenario_onevehicle,
driver_scenario_fewvehicles,
driver_scenario_somevehicles,
driver_scenario_shunt,
driver_scenario_looseshunt,
driver_scenario_obeytrain,
driver_scenario_bank,
driver_timetable_header,
driver_timetable_name,
driver_timetable_notimetable,
driver_timetable_consistdata,
driver_transcripts_header,
driver_pause_header,
driver_pause_resume,
driver_pause_quit,
debug_vehicle_nameloadstatuscouplers,
debug_vehicle_owned,
debug_vehicle_none,
debug_vehicle_devicespower,
debug_vehicle_radio,
debug_vehicle_oilpressure,
debug_vehicle_controllersenginerevolutions,
debug_vehicle_shuntmode,
debug_vehicle_temperatures,
debug_vehicle_brakespressures,
debug_vehicle_pantograph,
debug_vehicle_forcesaccelerationvelocityposition,
ui_expand,
ui_loading,
ui_loading_scenery,
ui_quit_simulation_q,
ui_yes,
ui_no,
ui_general,
ui_debug_mode,
ui_quit,
ui_tools,
ui_logging_to_log,
ui_screenshot,
ui_windows,
ui_log,
ui_map,
ui_mode_windows,
time_window,
time_time,
time_yearday,
time_visibility,
time_weather,
time_temperature,
time_apply,
map_straight,
map_divert,
map_open,
map_close,
map_obstacle_insert,
map_obstacle_remove,
vehiclelist_window,
vehicleparams_window,
vehicleparams_radiostop,
vehicleparams_resetposition,
vehicleparams_reset,
vehicleparams_resetpipe,
vehicleparams_rupturepipe,
vehicleparams_move500f,
vehicleparams_move500b,
cameraview_window,
cab_mainctrl,
cab_jointctrl,
cab_scndctrl,
cab_shuntmodepower,
cab_tempomat,
cab_dirkey,
cab_brakectrl,
cab_localbrake,
cab_manualbrake,
cab_alarmchain,
cab_brakeprofile_sw,
cab_brakeprofileg_sw,
cab_brakeprofiler_sw,
cab_brakeopmode_sw,
cab_maxcurrent_sw,
cab_waterpump_sw,
cab_waterpumpbreaker_sw,
cab_waterheater_sw,
cab_waterheaterbreaker_sw,
cab_watercircuitslink_sw,
cab_fuelpump_sw,
cab_oilpump_sw,
cab_motorblowersfront_sw,
cab_motorblowersrear_sw,
cab_motorblowersalloff_sw,
cab_coolingfans_sw,
cab_main_off_bt,
cab_main_on_bt,
cab_security_reset_bt,
cab_releaser_bt,
cab_sand_bt,
cab_antislip_bt,
cab_horn_bt,
cab_hornlow_bt,
cab_hornhigh_bt,
cab_whistle_bt,
cab_fuse_bt,
cab_converterfuse_bt,
cab_stlinoff_bt,
cab_doorleftpermit_sw,
cab_doorrightpermit_sw,
cab_doorpermitpreset_sw,
cab_door_left_sw,
cab_door_right_sw,
cab_doorlefton_sw,
cab_doorrighton_sw,
cab_doorleftoff_sw,
cab_doorrightoff_sw,
cab_doorallon_sw,
cab_dooralloff_sw,
cab_doorstep_sw,
cab_doormode_sw,
cab_departure_signal_bt,
cab_upperlight_sw,
cab_leftlight_sw,
cab_rightlight_sw,
cab_dimheadlights_sw,
cab_leftend_sw,
cab_rightend_sw,
cab_lights_sw,
cab_rearupperlight_sw,
cab_rearleftlight_sw,
cab_rearrightlight_sw,
cab_rearleftend_sw,
cab_rearrightend_sw,
cab_compressor_sw,
cab_compressorlocal_sw,
cab_converter_sw,
cab_converterlocal_sw,
cab_converteroff_sw,
cab_main_sw,
cab_radio_sw,
cab_radiochannel_sw,
cab_radiochannelprev_sw,
cab_radiochannelnext_sw,
cab_radiotest_sw,
cab_radiostop_sw,
cab_pantfront_sw,
cab_pantrear_sw,
cab_pantfrontoff_sw,
cab_pantrearoff_sw,
cab_pantalloff_sw,
cab_pantselected_sw,
cab_pantselectedoff_sw,
cab_pantcompressor_sw,
cab_pantcompressorvalve_sw,
cab_trainheating_sw,
cab_signalling_sw,
cab_door_signalling_sw,
cab_nextcurrent_sw,
cab_instrumentlight_sw,
cab_dashboardlight_sw,
cab_timetablelight_sw,
cab_cablight_sw,
cab_cablightdim_sw,
cab_battery_sw,
cab_universal0,
cab_universal1,
cab_universal2,
cab_universal3,
cab_universal4,
cab_universal5,
cab_universal6,
cab_universal7,
cab_universal8,
cab_universal9,
string_count
*/
class locale { class locale {
public: public:
void init(); void init();
@@ -242,7 +30,8 @@ private:
extern locale Translations; extern locale Translations;
#define STR(x) Translations.lookup_s(#x, true) #define STR(x) Translations.lookup_s(x, true)
#define STR_C(x) Translations.lookup_c(#x, true) #define STR_C(x) Translations.lookup_c(x, true)
#define STRC(x, c) Translations.lookup_s(c "\x1d" #x, true) #define STRN(x) x
#define STRC_C(x, c) Translations.lookup_c(c "\x1d" #x, true)
//find . -name "*.cpp" | xargs xgettext --from-code="UTF-8" -k --keyword=STR --keyword=STR_C --keyword=STRN

32
uilayer.cpp
View File

@@ -77,7 +77,7 @@ void ui_panel::register_popup(std::unique_ptr<ui::popup> &&popup)
void ui_expandable_panel::render_contents() void ui_expandable_panel::render_contents()
{ {
ImGui::Checkbox(STR_C(ui_expand), &is_expanded); ImGui::Checkbox(STR_C("expand"), &is_expanded);
ui_panel::render_contents(); ui_panel::render_contents();
} }
@@ -269,14 +269,14 @@ void ui_layer::render_quit_widget()
return; return;
ImGui::SetNextWindowSize(ImVec2(0, 0)); ImGui::SetNextWindowSize(ImVec2(0, 0));
ImGui::Begin(STR_C(ui_quit), &m_quit_active, ImGuiWindowFlags_NoResize); ImGui::Begin(STR_C("Quit"), &m_quit_active, ImGuiWindowFlags_NoResize);
ImGui::TextUnformatted(STR_C(ui_quit_simulation_q)); ImGui::TextUnformatted(STR_C("Quit simulation?"));
if (ImGui::Button(STR_C(ui_yes))) { if (ImGui::Button(STR_C("Yes"))) {
command_relay relay; command_relay relay;
relay.post(user_command::quitsimulation, 0.0, 0.0, GLFW_PRESS, 0); relay.post(user_command::quitsimulation, 0.0, 0.0, GLFW_PRESS, 0);
} }
ImGui::SameLine(); ImGui::SameLine();
if (ImGui::Button(STR_C(ui_no))) if (ImGui::Button(STR_C("No")))
m_quit_active = false; m_quit_active = false;
ImGui::End(); ImGui::End();
} }
@@ -334,7 +334,7 @@ void ui_layer::render_progress()
ImGui::SetNextWindowPos(ImVec2(50, 50)); ImGui::SetNextWindowPos(ImVec2(50, 50));
ImGui::SetNextWindowSize(ImVec2(0, 0)); ImGui::SetNextWindowSize(ImVec2(0, 0));
ImGui::Begin(STR_C(ui_loading), nullptr, ImGuiWindowFlags_NoResize | ImGuiWindowFlags_NoCollapse); ImGui::Begin(STR_C("Loading"), nullptr, ImGuiWindowFlags_NoResize | ImGuiWindowFlags_NoCollapse);
if (!m_progresstext.empty()) if (!m_progresstext.empty())
ImGui::ProgressBar(m_progress, ImVec2(300, 0), m_progresstext.c_str()); ImGui::ProgressBar(m_progress, ImVec2(300, 0), m_progresstext.c_str());
else else
@@ -366,32 +366,32 @@ void ui_layer::render_tooltip()
void ui_layer::render_menu_contents() void ui_layer::render_menu_contents()
{ {
if (ImGui::BeginMenu(STR_C(ui_general))) if (ImGui::BeginMenu(STR_C("General")))
{ {
ImGui::MenuItem(STR_C(ui_debug_mode), nullptr, &DebugModeFlag); ImGui::MenuItem(STR_C("Debug mode"), nullptr, &DebugModeFlag);
ImGui::MenuItem(STR_C(ui_quit), "F10", &m_quit_active); ImGui::MenuItem(STR_C("Quit"), "F10", &m_quit_active);
ImGui::EndMenu(); ImGui::EndMenu();
} }
if (ImGui::BeginMenu(STR_C(ui_tools))) if (ImGui::BeginMenu(STR_C("Tools")))
{ {
static bool log = Global.iWriteLogEnabled & 1; static bool log = Global.iWriteLogEnabled & 1;
ImGui::MenuItem(STR_C(ui_logging_to_log), nullptr, &log); ImGui::MenuItem(STR_C("Logging to log.txt"), nullptr, &log);
if (log) if (log)
Global.iWriteLogEnabled |= 1; Global.iWriteLogEnabled |= 1;
else else
Global.iWriteLogEnabled &= ~1; Global.iWriteLogEnabled &= ~1;
if (ImGui::MenuItem(STR_C(ui_screenshot), "PrtScr")) if (ImGui::MenuItem(STR_C("Screenshot"), "PrtScr"))
Application.queue_screenshot(); Application.queue_screenshot();
ImGui::EndMenu(); ImGui::EndMenu();
} }
if (ImGui::BeginMenu(STR_C(ui_windows))) if (ImGui::BeginMenu(STR_C("Windows")))
{ {
ImGui::MenuItem(STR_C(ui_log), "F9", &m_logpanel.is_open); ImGui::MenuItem(STR_C("Log"), "F9", &m_logpanel.is_open);
if (DebugModeFlag) { if (DebugModeFlag) {
ImGui::MenuItem("ImGui Demo", nullptr, &m_imgui_demo); ImGui::MenuItem(STR_C("ImGui Demo"), nullptr, &m_imgui_demo);
ImGui::MenuItem("Headlight config", nullptr, &GfxRenderer.debug_ui_active); ImGui::MenuItem(STR_C("Headlight config"), nullptr, &GfxRenderer.debug_ui_active);
} }
ImGui::EndMenu(); ImGui::EndMenu();
} }

3
widgets/cameraview.cpp
View File

@@ -4,7 +4,7 @@
#include "Logs.h" #include "Logs.h"
ui::cameraview_panel::cameraview_panel() ui::cameraview_panel::cameraview_panel()
: ui_panel(STR_C(cameraview_window), false) : ui_panel(STR_C("Camera preview"), false)
{ {
size_min = { -2, -2 }; size_min = { -2, -2 };
} }
@@ -103,6 +103,7 @@ void ui::cameraview_panel::workthread_func()
if (buffer) { if (buffer) {
int w, h; int w, h;
stbi_set_flip_vertically_on_load(0);
uint8_t *image = stbi_load_from_memory(buffer, len, &w, &h, nullptr, 4); uint8_t *image = stbi_load_from_memory(buffer, len, &w, &h, nullptr, 4);
if (!image) if (!image)
ErrorLog(std::string(stbi_failure_reason())); ErrorLog(std::string(stbi_failure_reason()));

14
widgets/map.cpp
View File

@@ -8,7 +8,7 @@
#include "Driver.h" #include "Driver.h"
#include "AnimModel.h" #include "AnimModel.h"
ui::map_panel::map_panel() : ui_panel(STR_C(ui_map), false) ui::map_panel::map_panel() : ui_panel(STR_C("Map"), false)
{ {
size_min = {200, 200}; size_min = {200, 200};
size_max = {fb_size, fb_size}; size_max = {fb_size, fb_size};
@@ -445,13 +445,13 @@ void ui::launcher_window::render_content()
{ {
ImGui::TextUnformatted(m_switch->name.c_str()); ImGui::TextUnformatted(m_switch->name.c_str());
const std::string &open_label = STR( const std::string &open_label =
m_switch->type == map::launcher::track_switch m_switch->type == map::launcher::track_switch
? locale::string::map_straight : locale::string::map_open); ? STR("Straight |") : STR("Open |");
const std::string &close_label = STR( const std::string &close_label =
m_switch->type == map::launcher::track_switch m_switch->type == map::launcher::track_switch
? locale::string::map_divert : locale::string::map_close); ? STR("Divert /") : STR("Close -");
if (ImGui::Button(open_label.c_str())) if (ImGui::Button(open_label.c_str()))
{ {
@@ -495,7 +495,7 @@ void ui::obstacle_insert_window::render_content()
return; return;
} }
ImGui::TextUnformatted(STR_C(map_obstacle_insert)); ImGui::TextUnformatted(STR_C("Insert obstacle:"));
for (auto const &entry : m_obstacles) for (auto const &entry : m_obstacles)
{ {
if (ImGui::Button(entry.first.c_str())) if (ImGui::Button(entry.first.c_str()))
@@ -526,7 +526,7 @@ ui::obstacle_remove_window::obstacle_remove_window(ui_panel &panel, std::shared_
void ui::obstacle_remove_window::render_content() void ui::obstacle_remove_window::render_content()
{ {
if (ImGui::Button(STR_C(map_obstacle_remove))) { if (ImGui::Button(STR_C("Delete obstacle"))) {
m_relay.post(user_command::deletemodel, 0.0, 0.0, GLFW_PRESS, 0, glm::vec3(), &m_obstacle->model_name); m_relay.post(user_command::deletemodel, 0.0, 0.0, GLFW_PRESS, 0, glm::vec3(), &m_obstacle->model_name);
auto &entries = map::Objects.entries; auto &entries = map::Objects.entries;

6
widgets/perfgraphs.cpp
View File

@@ -3,13 +3,13 @@
#include "Timer.h" #include "Timer.h"
perfgraph_panel::perfgraph_panel() perfgraph_panel::perfgraph_panel()
: ui_panel("Perf", false) : ui_panel(STR("Performance"), false)
{ {
} }
void perfgraph_panel::render_contents() { void perfgraph_panel::render_contents() {
if (ImGui::BeginCombo("Timer", timer_label[current_timer].c_str())) // The second parameter is the label previewed before opening the combo. if (ImGui::BeginCombo(STR_C("Timer"), timer_label[current_timer].c_str())) // The second parameter is the label previewed before opening the combo.
{ {
for (size_t i = 0; i < (size_t)TIMER_MAX; i++) for (size_t i = 0; i < (size_t)TIMER_MAX; i++)
{ {
@@ -57,6 +57,6 @@ void perfgraph_panel::render_contents() {
if (pos >= history.size()) if (pos >= history.size())
pos = 0; pos = 0;
ImGui::SliderFloat("Range", &max, 0.1f, 250.0f); ImGui::SliderFloat(STR_C("Range"), &max, 0.1f, 250.0f);
ImGui::PlotLines("##timer", &history[0], history.size(), pos, label.c_str(), 0.0f, max, ImVec2(500, 200)); ImGui::PlotLines("##timer", &history[0], history.size(), pos, label.c_str(), 0.0f, max, ImVec2(500, 200));
} }

14
widgets/time.cpp
View File

@@ -3,20 +3,20 @@
#include "simulationtime.h" #include "simulationtime.h"
#include "Globals.h" #include "Globals.h"
ui::time_panel::time_panel() : ui_panel(STR_C(time_window), false) ui::time_panel::time_panel() : ui_panel(STR_C("Time and environment"), false)
{ {
size.x = 450; size.x = 450;
} }
void ui::time_panel::render_contents() void ui::time_panel::render_contents()
{ {
ImGui::SliderFloat(STR_C(time_time), &time, 0.0f, 24.0f, "%.1f"); ImGui::SliderFloat(STR_C("Time"), &time, 0.0f, 24.0f, "%.1f");
ImGui::SliderInt(STR_C(time_yearday), &yearday, 1, 365); ImGui::SliderInt(STR_C("Day in year"), &yearday, 1, 365);
ImGui::SliderFloat(STR_C(time_visibility), &fog, 50.0f, 3000.0f, "%.0f"); ImGui::SliderFloat(STR_C("Visibility"), &fog, 50.0f, 3000.0f, "%.0f");
ImGui::SliderFloat(STR_C(time_weather), &overcast, 0.0f, 2.0f, "%.1f"); ImGui::SliderFloat(STR_C("Overcast and precipitation"), &overcast, 0.0f, 2.0f, "%.1f");
ImGui::SliderFloat(STR_C(time_temperature), &temperature, -20.0f, 40.0f, "%.0f"); ImGui::SliderFloat(STR_C("Temperature"), &temperature, -20.0f, 40.0f, "%.0f");
if (ImGui::Button(STR_C(time_apply))) if (ImGui::Button(STR_C("Apply")))
{ {
m_relay.post(user_command::setdatetime, (double)yearday, time, 1, 0); m_relay.post(user_command::setdatetime, (double)yearday, time, 1, 0);
m_relay.post(user_command::setweather, fog, overcast, 1, 0); m_relay.post(user_command::setweather, fog, overcast, 1, 0);

2
widgets/vehiclelist.cpp
View File

@@ -5,7 +5,7 @@
#include "widgets/vehicleparams.h" #include "widgets/vehicleparams.h"
ui::vehiclelist_panel::vehiclelist_panel(ui_layer &parent) ui::vehiclelist_panel::vehiclelist_panel(ui_layer &parent)
: ui_panel(STR_C(vehiclelist_window), false), m_parent(parent) : ui_panel(STR_C("Vehicle list"), false), m_parent(parent)
{ {
} }

34
widgets/vehicleparams.cpp
View File

@@ -6,7 +6,7 @@
#include "Train.h" #include "Train.h"
ui::vehicleparams_panel::vehicleparams_panel(const std::string &vehicle) ui::vehicleparams_panel::vehicleparams_panel(const std::string &vehicle)
: ui_panel(std::string(STR(vehicleparams_window)) + ": " + vehicle, false), m_vehicle_name(vehicle) : ui_panel(std::string(STR("Vehicle parameters")) + ": " + vehicle, false), m_vehicle_name(vehicle)
{ {
} }
@@ -53,7 +53,7 @@ void ui::vehicleparams_panel::render_contents()
std::snprintf( std::snprintf(
buffer.data(), buffer.size(), buffer.data(), buffer.size(),
STR_C(debug_vehicle_devicespower), STR_C("Devices: %c%c%c%c%c%c%c%c%c%c%c%c%c%c%s%s\nPower transfers: %.0f@%.0f%s%s%s%.0f@%.0f"),
// devices // devices
( mover.Battery ? 'B' : '.' ), ( mover.Battery ? 'B' : '.' ),
( mover.Mains ? 'M' : '.' ), ( mover.Mains ? 'M' : '.' ),
@@ -70,7 +70,7 @@ void ui::vehicleparams_panel::render_contents()
( mover.CompressorFlag ? 'C' : ( false == mover.CompressorAllowLocal ? '-' : ( ( mover.CompressorAllow || mover.CompressorStart == start_t::automatic ) ? 'c' : '.' ) ) ), ( mover.CompressorFlag ? 'C' : ( false == mover.CompressorAllowLocal ? '-' : ( ( mover.CompressorAllow || mover.CompressorStart == start_t::automatic ) ? 'c' : '.' ) ) ),
( mover.CompressorGovernorLock ? '!' : '.' ), ( mover.CompressorGovernorLock ? '!' : '.' ),
"", "",
std::string( isdieselenginepowered ? STR(debug_vehicle_oilpressure) + to_string( mover.OilPump.pressure, 2 ) : "" ).c_str(), std::string( isdieselenginepowered ? STR(" oil pressure: ") + to_string( mover.OilPump.pressure, 2 ) : "" ).c_str(),
// power transfers // power transfers
mover.Couplers[ end::front ].power_high.voltage, mover.Couplers[ end::front ].power_high.voltage,
mover.Couplers[ end::front ].power_high.current, mover.Couplers[ end::front ].power_high.current,
@@ -84,11 +84,11 @@ void ui::vehicleparams_panel::render_contents()
std::snprintf( std::snprintf(
buffer.data(), buffer.size(), buffer.data(), buffer.size(),
STR_C(debug_vehicle_controllersenginerevolutions), STR_C("Controllers:\n master: %d(%d), secondary: %s\nEngine output: %.1f, current: %.0f\nRevolutions:\n engine: %.0f, motors: %.0f\n engine fans: %.0f, motor fans: %.0f+%.0f, cooling fans: %.0f+%.0f"),
// controllers // controllers
mover.MainCtrlPos, mover.MainCtrlPos,
mover.MainCtrlActualPos, mover.MainCtrlActualPos,
std::string( isdieselinshuntmode ? to_string( mover.AnPos, 2 ) + STR(debug_vehicle_shuntmode) : std::to_string( mover.ScndCtrlPos ) + "(" + std::to_string( mover.ScndCtrlActualPos ) + ")" ).c_str(), std::string( isdieselinshuntmode ? to_string( mover.AnPos, 2 ) + STR(" (shunt mode)") : std::to_string( mover.ScndCtrlPos ) + "(" + std::to_string( mover.ScndCtrlActualPos ) + ")" ).c_str(),
// engine // engine
mover.EnginePower, mover.EnginePower,
std::abs( mover.TrainType == dt_EZT ? mover.ShowCurrent( 0 ) : mover.Im ), std::abs( mover.TrainType == dt_EZT ? mover.ShowCurrent( 0 ) : mover.Im ),
@@ -106,7 +106,7 @@ void ui::vehicleparams_panel::render_contents()
if( isdieselenginepowered ) { if( isdieselenginepowered ) {
std::snprintf( std::snprintf(
buffer.data(), buffer.size(), buffer.data(), buffer.size(),
STR_C(debug_vehicle_temperatures), STR_C("\nTemperatures:\n engine: %.2f, oil: %.2f, water: %.2f%c%.2f"),
mover.dizel_heat.Ts, mover.dizel_heat.Ts,
mover.dizel_heat.To, mover.dizel_heat.To,
mover.dizel_heat.temperatura1, mover.dizel_heat.temperatura1,
@@ -132,7 +132,7 @@ void ui::vehicleparams_panel::render_contents()
std::snprintf( std::snprintf(
buffer.data(), buffer.size(), buffer.data(), buffer.size(),
STR_C(debug_vehicle_brakespressures), STR_C("Brakes:\n train: %.2f, independent: %.2f, mode: %d, delay: %s, load flag: %d\nBrake cylinder pressures:\n train: %.2f, independent: %.2f, status: 0x%.2x\nPipe pressures:\n brake: %.2f (hat: %.2f), main: %.2f, control: %.2f\nTank pressures:\n auxiliary: %.2f, main: %.2f, control: %.2f"),
// brakes // brakes
mover.fBrakeCtrlPos, mover.fBrakeCtrlPos,
mover.LocalBrakePosA, mover.LocalBrakePosA,
@@ -158,7 +158,7 @@ void ui::vehicleparams_panel::render_contents()
if( mover.EnginePowerSource.SourceType == TPowerSource::CurrentCollector ) { if( mover.EnginePowerSource.SourceType == TPowerSource::CurrentCollector ) {
std::snprintf( std::snprintf(
buffer.data(), buffer.size(), buffer.data(), buffer.size(),
STR_C(debug_vehicle_pantograph), STR_C(" pantograph: %.2f%cMT"),
mover.PantPress, mover.PantPress,
( mover.bPantKurek3 ? '-' : '|' ) ); ( mover.bPantKurek3 ? '-' : '|' ) );
ImGui::TextUnformatted(buffer.data()); ImGui::TextUnformatted(buffer.data());
@@ -166,7 +166,7 @@ void ui::vehicleparams_panel::render_contents()
std::snprintf( std::snprintf(
buffer.data(), buffer.size(), buffer.data(), buffer.size(),
STR_C(debug_vehicle_forcesaccelerationvelocityposition), STR_C("Forces:\n tractive: %.1f, brake: %.1f, friction: %.2f%s\nAcceleration:\n tangential: %.2f, normal: %.2f (path radius: %s)\nVelocity: %.2f, distance traveled: %.2f\nPosition: [%.2f, %.2f, %.2f]"),
// forces // forces
mover.Ft * 0.001f * ( mover.ActiveCab ? mover.ActiveCab : vehicle.ctOwner ? vehicle.ctOwner->Controlling()->ActiveCab : 1 ) + 0.001f, mover.Ft * 0.001f * ( mover.ActiveCab ? mover.ActiveCab : vehicle.ctOwner ? vehicle.ctOwner->Controlling()->ActiveCab : 1 ) + 0.001f,
mover.Fb * 0.001f, mover.Fb * 0.001f,
@@ -186,40 +186,40 @@ void ui::vehicleparams_panel::render_contents()
ImGui::TextUnformatted(buffer.data()); ImGui::TextUnformatted(buffer.data());
if (ImGui::Button(STR_C(vehicleparams_radiostop))) if (ImGui::Button(STR_C("Radiostop")))
m_relay.post(user_command::radiostop, 0.0, 0.0, GLFW_PRESS, 0, vehicle_ptr->GetPosition()); m_relay.post(user_command::radiostop, 0.0, 0.0, GLFW_PRESS, 0, vehicle_ptr->GetPosition());
ImGui::SameLine(); ImGui::SameLine();
if (ImGui::Button(STR_C(vehicleparams_reset))) if (ImGui::Button(STR_C("Stop and repair")))
m_relay.post(user_command::resetconsist, 0.0, 0.0, GLFW_PRESS, 0, glm::vec3(0.0f), &vehicle_ptr->name()); m_relay.post(user_command::resetconsist, 0.0, 0.0, GLFW_PRESS, 0, glm::vec3(0.0f), &vehicle_ptr->name());
ImGui::SameLine(); ImGui::SameLine();
if (ImGui::Button(STR_C(vehicleparams_resetposition))) { if (ImGui::Button(STR_C("Reset position"))) {
std::string payload = vehicle_ptr->name() + '%' + vehicle_ptr->initial_track->name(); std::string payload = vehicle_ptr->name() + '%' + vehicle_ptr->initial_track->name();
m_relay.post(user_command::consistteleport, 0.0, 0.0, GLFW_PRESS, 0, glm::vec3(0.0f), &payload); m_relay.post(user_command::consistteleport, 0.0, 0.0, GLFW_PRESS, 0, glm::vec3(0.0f), &payload);
m_relay.post(user_command::resetconsist, 0.0, 0.0, GLFW_PRESS, 0, glm::vec3(0.0f), &vehicle_ptr->name()); m_relay.post(user_command::resetconsist, 0.0, 0.0, GLFW_PRESS, 0, glm::vec3(0.0f), &vehicle_ptr->name());
} }
if (ImGui::Button(STR_C(vehicleparams_resetpipe))) if (ImGui::Button(STR_C("Refill main tank")))
m_relay.post(user_command::fillcompressor, 0.0, 0.0, GLFW_PRESS, 0, glm::vec3(0.0f), &vehicle_ptr->name()); m_relay.post(user_command::fillcompressor, 0.0, 0.0, GLFW_PRESS, 0, glm::vec3(0.0f), &vehicle_ptr->name());
ImGui::SameLine(); ImGui::SameLine();
if (ImGui::Button(STR_C(vehicleparams_rupturepipe))) if (ImGui::Button(STR_C("Rupture main pipe")))
m_relay.post(user_command::pullalarmchain, 0.0, 0.0, GLFW_PRESS, 0, glm::vec3(0.0f), &vehicle_ptr->name()); m_relay.post(user_command::pullalarmchain, 0.0, 0.0, GLFW_PRESS, 0, glm::vec3(0.0f), &vehicle_ptr->name());
ImGui::SameLine(); ImGui::SameLine();
ImGui::Button(STR_C(cab_releaser_bt)); ImGui::Button(STR_C("independent brake releaser"));
if (ImGui::IsItemClicked()) if (ImGui::IsItemClicked())
m_relay.post(user_command::consistreleaser, 0.0, 0.0, GLFW_PRESS, 0, glm::vec3(0.0f), &vehicle_ptr->name()); m_relay.post(user_command::consistreleaser, 0.0, 0.0, GLFW_PRESS, 0, glm::vec3(0.0f), &vehicle_ptr->name());
if (ImGui::IsItemDeactivated()) if (ImGui::IsItemDeactivated())
m_relay.post(user_command::consistreleaser, 0.0, 0.0, GLFW_RELEASE, 0, glm::vec3(0.0f), &vehicle_ptr->name()); m_relay.post(user_command::consistreleaser, 0.0, 0.0, GLFW_RELEASE, 0, glm::vec3(0.0f), &vehicle_ptr->name());
if (vehicle_ptr->MoverParameters->V < 0.01) { if (vehicle_ptr->MoverParameters->V < 0.01) {
if (ImGui::Button(STR_C(vehicleparams_move500f))) if (ImGui::Button(STR_C("Move +500m")))
m_relay.post(user_command::dynamicmove, 500.0, 0.0, GLFW_PRESS, 0, glm::vec3(0.0f), &vehicle_ptr->name()); m_relay.post(user_command::dynamicmove, 500.0, 0.0, GLFW_PRESS, 0, glm::vec3(0.0f), &vehicle_ptr->name());
ImGui::SameLine(); ImGui::SameLine();
if (ImGui::Button(STR_C(vehicleparams_move500b))) if (ImGui::Button(STR_C("Move -500m")))
m_relay.post(user_command::dynamicmove, -500.0, 0.0, GLFW_PRESS, 0, glm::vec3(0.0f), &vehicle_ptr->name()); m_relay.post(user_command::dynamicmove, -500.0, 0.0, GLFW_PRESS, 0, glm::vec3(0.0f), &vehicle_ptr->name());
} }
} }

34
winheaders.h
View File

@@ -38,40 +38,6 @@ typedef struct _SYSTEMTIME {
BI_CMYKRLE4 = 0x000D BI_CMYKRLE4 = 0x000D
} Compression; } Compression;
typedef struct tagBITMAPFILEHEADER {
WORD bfType;
DWORD bfSize;
WORD bfReserved1;
WORD bfReserved2;
DWORD bfOffBits;
} __attribute__((packed)) BITMAPFILEHEADER, *PBITMAPFILEHEADER;
typedef struct tagRGBQUAD {
BYTE rgbBlue;
BYTE rgbGreen;
BYTE rgbRed;
BYTE rgbReserved;
} __attribute__((packed)) RGBQUAD;
typedef struct tagBITMAPINFOHEADER {
DWORD biSize;
LONG biWidth;
LONG biHeight;
WORD biPlanes;
WORD biBitCount;
DWORD biCompression;
DWORD biSizeImage;
LONG biXPelsPerMeter;
LONG biYPelsPerMeter;
DWORD biClrUsed;
DWORD biClrImportant;
} __attribute__((packed)) BITMAPINFOHEADER, *PBITMAPINFOHEADER;
typedef struct tagBITMAPINFO {
BITMAPINFOHEADER bmiHeader;
RGBQUAD bmiColors[1];
} __attribute__((packed)) BITMAPINFO, *PBITMAPINFO;
#ifndef MAKEFOURCC #ifndef MAKEFOURCC
#define MAKEFOURCC(ch0, ch1, ch2, ch3) \ #define MAKEFOURCC(ch0, ch1, ch2, ch3) \
((DWORD)(BYTE)(ch0) | ((DWORD)(BYTE)(ch1) << 8) | \ ((DWORD)(BYTE)(ch0) | ((DWORD)(BYTE)(ch1) << 8) | \