build 180404. optional scenario clock sync with current local time, keyboard input for the ui layer

2026-07-20 03:19:19 +02:00 · 2018-04-06 01:12:15 +02:00
parent 07f14381a8
commit 87f078925c
12 changed files with 898 additions and 796 deletions
--- a/uilayer.cpp
+++ b/uilayer.cpp
@@ -2,9 +2,18 @@

 #include "stdafx.h"
 #include "uilayer.h"
+#include "uitranscripts.h"
+
 #include "globals.h"
-#include "utilities.h"
+#include "translation.h"
+#include "simulation.h"
+#include "mtable.h"
+#include "train.h"
+#include "dynobj.h"
+#include "model3d.h"
 #include "renderer.h"
+#include "timer.h"
+#include "utilities.h"
 #include "logs.h"

 ui_layer UILayer;
@@ -25,6 +34,21 @@ ui_layer::~ui_layer() {
 bool
 ui_layer::init( GLFWwindow *Window ) {

+    clear_texts();
+
+    UIHeader = std::make_shared<ui_panel>( 20, 20 ); // header ui panel
+    UITable = std::make_shared<ui_panel>( 20, 100 ); // schedule or scan table
+    UITranscripts = std::make_shared<ui_panel>( 85, 600 ); // voice transcripts
+    // make 4 empty lines for the ui header, to cut down on work down the road
+    UIHeader->text_lines.emplace_back( "", Global.UITextColor );
+    UIHeader->text_lines.emplace_back( "", Global.UITextColor );
+    UIHeader->text_lines.emplace_back( "", Global.UITextColor );
+    UIHeader->text_lines.emplace_back( "", Global.UITextColor );
+    // bind the panels with ui object. maybe not the best place for this but, eh
+    push_back( UIHeader );
+    push_back( UITable );
+    push_back( UITranscripts );
+
    m_window = Window;
    HFONT font; // Windows Font ID
    m_fontbase = ::glGenLists(96); // storage for 96 characters
@@ -60,6 +84,792 @@ ui_layer::init( GLFWwindow *Window ) {
    }
 }

+// potentially processes provided input key. returns: true if key was processed, false otherwise
+bool
+ui_layer::on_key( int const Key, int const Action ) {
+    // TODO: pass the input first through an active ui element if there's any
+    // if the ui element shows no interest or we don't have one, try to interpret the input yourself:
+    // shared conditions
+    switch( Key ) {
+
+        case GLFW_KEY_F1:
+        case GLFW_KEY_F2:
+        case GLFW_KEY_F3:
+        case GLFW_KEY_F8:
+        case GLFW_KEY_F9:
+        case GLFW_KEY_F10:
+        case GLFW_KEY_F12: { // ui mode selectors
+
+            if( ( true == Global.ctrlState )
+             || ( true == Global.shiftState ) ) {
+                // only react to keys without modifiers
+                return false;
+            }
+
+            if( Action == GLFW_RELEASE ) { return true; } // recognized, but ignored
+        }
+
+        default: { // everything else
+            break;
+        }
+    }
+
+    switch (Key) {
+            
+        case GLFW_KEY_F1: {
+            // basic consist info
+            if( Global.iTextMode == Key ) { ++Global.iScreenMode[ Key - GLFW_KEY_F1 ]; }
+            if( Global.iScreenMode[ Key - GLFW_KEY_F1 ] > 1 ) {
+                // wyłączenie napisów
+                Global.iTextMode = 0;
+                Global.iScreenMode[ Key - GLFW_KEY_F1 ] = 0;
+            }
+            else {
+                Global.iTextMode = Key;
+            }
+            return true;
+        }
+
+        case GLFW_KEY_F2: {
+            // parametry pojazdu
+            if( Global.iTextMode == Key ) { ++Global.iScreenMode[ Key - GLFW_KEY_F1 ]; }
+            if( Global.iScreenMode[ Key - GLFW_KEY_F1 ] > 1 ) {
+                // wyłączenie napisów
+                Global.iTextMode = 0;
+                Global.iScreenMode[ Key - GLFW_KEY_F1 ] = 0;
+            }
+            else {
+                Global.iTextMode = Key;
+            }
+            return true;
+        }
+
+        case GLFW_KEY_F3: {
+            // timetable
+            if( Global.iTextMode == Key ) { ++Global.iScreenMode[ Key - GLFW_KEY_F1 ]; }
+            if( Global.iScreenMode[ Key - GLFW_KEY_F1 ] > 1 ) {
+                // wyłączenie napisów
+                Global.iTextMode = 0;
+                Global.iScreenMode[ Key - GLFW_KEY_F1 ] = 0;
+            }
+            else {
+                Global.iTextMode = Key;
+            }
+            return true;
+        }
+
+        case GLFW_KEY_F8: {
+            // renderer debug data
+            Global.iTextMode = Key;
+            return true;
+        }
+
+        case GLFW_KEY_F9: {
+            // wersja
+            Global.iTextMode = Key;
+            return true;
+        }
+
+        case GLFW_KEY_F10: {
+            // quit
+            if( Global.iTextMode == Key ) {
+                Global.iTextMode =
+                    ( Global.iPause && ( Key != GLFW_KEY_F1 ) ?
+                        GLFW_KEY_F1 :
+                        0 ); // wyłączenie napisów, chyba że pauza
+            }
+            else {
+                Global.iTextMode = Key;
+            }
+            return true;
+        }
+
+        case GLFW_KEY_F12: {
+            // coś tam jeszcze
+            Global.iTextMode = Key;
+            return true;
+        }
+
+        case GLFW_KEY_Y: {
+            // potentially quit
+            if( Global.iTextMode != GLFW_KEY_F10 ) { return false; } // not in quit mode
+
+            if( Action == GLFW_RELEASE ) { return true; } // recognized, but ignored
+
+            glfwSetWindowShouldClose( m_window, 1 );
+            return true;
+        }
+
+        default: {
+            break;
+        }
+    }
+
+    return false;
+}
+
+// updates state of UI elements
+void
+ui_layer::update() {
+
+    UITable->text_lines.clear();
+    std::string uitextline1, uitextline2, uitextline3, uitextline4;
+    UILayer.set_tooltip( "" );
+
+    auto const *train { ( Global.pWorld ? Global.pWorld->train() : nullptr ) };
+    auto const *controlled { ( Global.pWorld ? Global.pWorld->controlled() : nullptr ) };
+    auto const *camera { Global.pCamera };
+
+    if( ( train != nullptr ) && ( false == FreeFlyModeFlag ) ) {
+        if( false == DebugModeFlag ) {
+            // in regular mode show control functions, for defined controls
+            UILayer.set_tooltip( locale::label_cab_control( train->GetLabel( GfxRenderer.Pick_Control() ) ) );
+        }
+        else {
+            // in debug mode show names of submodels, to help with cab setup and/or debugging
+            auto const cabcontrol = GfxRenderer.Pick_Control();
+            UILayer.set_tooltip( ( cabcontrol ? cabcontrol->pName : "" ) );
+        }
+    }
+    if( ( true == Global.ControlPicking ) && ( true == FreeFlyModeFlag ) && ( true == DebugModeFlag ) ) {
+        auto const scenerynode = GfxRenderer.Pick_Node();
+        UILayer.set_tooltip(
+            ( scenerynode ?
+                scenerynode->name() :
+                "" ) );
+    }
+
+    switch( Global.iTextMode ) {
+
+        case( GLFW_KEY_F1 ) : {
+            // f1, default mode: current time and timetable excerpt
+            auto const &time = simulation::Time.data();
+            uitextline1 =
+                "Time: "
+                + to_string( time.wHour ) + ":"
+                + ( time.wMinute < 10 ? "0" : "" ) + to_string( time.wMinute ) + ":"
+                + ( time.wSecond < 10 ? "0" : "" ) + to_string( time.wSecond );
+            if( Global.iPause ) {
+                uitextline1 += " (paused)";
+            }
+
+            if( ( controlled != nullptr ) 
+             && ( controlled->Mechanik != nullptr ) ) {
+
+                auto const &mover = controlled->MoverParameters;
+                auto const &driver = controlled->Mechanik;
+
+                uitextline2 = "Throttle: " + to_string( driver->Controlling()->MainCtrlPos, 0, 2 ) + "+" + std::to_string( driver->Controlling()->ScndCtrlPos );
+                     if( mover->ActiveDir > 0 ) { uitextline2 += " D"; }
+                else if( mover->ActiveDir < 0 ) { uitextline2 += " R"; }
+                else                            { uitextline2 += " N"; }
+
+                uitextline3 = "Brakes:" + to_string( mover->fBrakeCtrlPos, 1, 5 ) + "+" + std::to_string( mover->LocalBrakePos ) + ( mover->SlippingWheels ? " !" : "  " );
+
+                uitextline4 = (
+                    true == TestFlag( mover->SecuritySystem.Status, s_aware ) ?
+                        "!ALERTER! " :
+                        "          " );
+                uitextline4 += (
+                    true == TestFlag( mover->SecuritySystem.Status, s_active ) ?
+                        "!SHP! " :
+                        "      " );
+
+                if( Global.iScreenMode[ Global.iTextMode - GLFW_KEY_F1 ] == 1 ) {
+                    // detail mode on second key press
+                    uitextline2 +=
+                        " Speed: " + std::to_string( static_cast<int>( std::floor( mover->Vel ) ) ) + " km/h"
+                        + " (limit: " + std::to_string( static_cast<int>( std::floor( driver->VelDesired ) ) ) + " km/h"
+                        + ", next limit: " + std::to_string( static_cast<int>( std::floor( controlled->Mechanik->VelNext ) ) ) + " km/h"
+                        + " in " + to_string( controlled->Mechanik->ActualProximityDist * 0.001, 1 ) + " km)";
+                    uitextline3 +=
+                        " Pressure: " + to_string( mover->BrakePress * 100.0, 2 ) + " kPa"
+                        + " (train pipe: " + to_string( mover->PipePress * 100.0, 2 ) + " kPa)";
+
+                    auto const stoptime { static_cast<int>( -1.0 * controlled->Mechanik->fStopTime ) };
+                    if( stoptime > 0 ) {
+                        uitextline4 += " Loading/unloading in progress (" + to_string( stoptime ) + ( stoptime > 1 ? " seconds" : " second" ) + " left)";
+                    }
+                    else {
+                        auto const trackblockdistance{ std::abs( controlled->Mechanik->TrackBlock() ) };
+                        if( trackblockdistance <= 75.0 ) {
+                            uitextline4 += " Another vehicle ahead (distance: " + to_string( trackblockdistance, 1 ) + " m)";
+                        }
+                    }
+                }
+            }
+
+            break;
+        }
+
+        case( GLFW_KEY_F2 ) : {
+            // timetable
+            auto *vehicle {
+                ( FreeFlyModeFlag ?
+                    std::get<TDynamicObject *>( simulation::Region->find_vehicle( camera->Pos, 20, false, false ) ) :
+                    controlled ) }; // w trybie latania lokalizujemy wg mapy
+
+            if( vehicle == nullptr ) { break; }
+            // if the nearest located vehicle doesn't have a direct driver, try to query its owner
+            auto const owner = (
+                ( ( vehicle->Mechanik != nullptr ) && ( vehicle->Mechanik->Primary() ) ) ?
+                    vehicle->Mechanik :
+                    vehicle->ctOwner );
+            if( owner == nullptr ){ break; }
+
+            auto const table = owner->Timetable();
+            if( table == nullptr ) { break; }
+
+            auto const &time = simulation::Time.data();
+            uitextline1 =
+                "Time: "
+                + to_string( time.wHour ) + ":"
+                + ( time.wMinute < 10 ? "0" : "" ) + to_string( time.wMinute ) + ":"
+                + ( time.wSecond < 10 ? "0" : "" ) + to_string( time.wSecond );
+            if( Global.iPause ) {
+                uitextline1 += " (paused)";
+            }
+
+            uitextline2 = Bezogonkow( owner->Relation(), true ) + " (" + Bezogonkow( owner->Timetable()->TrainName, true ) + ")";
+            auto const nextstation = Bezogonkow( owner->NextStop(), true );
+            if( !nextstation.empty() ) {
+                // jeśli jest podana relacja, to dodajemy punkt następnego zatrzymania
+                uitextline3 = " -> " + nextstation;
+            }
+
+            if( Global.iScreenMode[ Global.iTextMode - GLFW_KEY_F1 ] == 1 ) {
+
+                if( 0 == table->StationCount ) {
+                    // only bother if there's stations to list
+                    UITable->text_lines.emplace_back( "(no timetable)", Global.UITextColor );
+                } 
+                else {
+                    // header
+                    UITable->text_lines.emplace_back( "+----------------------------+-------+-------+-----+", Global.UITextColor );
+
+                    TMTableLine *tableline;
+                    for( int i = owner->iStationStart; i <= std::min( owner->iStationStart + 15, table->StationCount ); ++i ) {
+                        // wyświetlenie pozycji z rozkładu
+                        tableline = table->TimeTable + i; // linijka rozkładu
+
+                        std::string station =
+                            ( tableline->StationName + "                          " ).substr( 0, 26 );
+                        std::string arrival =
+                            ( tableline->Ah >= 0 ?
+                            to_string( int( 100 + tableline->Ah ) ).substr( 1, 2 ) + ":" + to_string( int( 100 + tableline->Am ) ).substr( 1, 2 ) :
+                            "     " );
+                        std::string departure =
+                            ( tableline->Dh >= 0 ?
+                            to_string( int( 100 + tableline->Dh ) ).substr( 1, 2 ) + ":" + to_string( int( 100 + tableline->Dm ) ).substr( 1, 2 ) :
+                            "     " );
+                        std::string vmax =
+                            "   "
+                            + to_string( tableline->vmax, 0 );
+                        vmax = vmax.substr( vmax.length() - 3, 3 ); // z wyrównaniem do prawej
+
+                        UITable->text_lines.emplace_back(
+                            Bezogonkow( "| " + station + " | " + arrival + " | " + departure + " | " + vmax + " | " + tableline->StationWare, true ),
+                            ( ( owner->iStationStart < table->StationIndex )
+                           && ( i < table->StationIndex )
+                           && ( ( time.wHour * 60 + time.wMinute ) >= ( tableline->Dh * 60 + tableline->Dm ) ) ?
+                                glm::vec4( 0.0f, 1.0f, 0.0f, 1.0f ) :// czas minął i odjazd był, to nazwa stacji będzie na zielono
+                                Global.UITextColor ) );
+                        // divider/footer
+                        UITable->text_lines.emplace_back( "+----------------------------+-------+-------+-----+", Global.UITextColor );
+                    }
+                }
+            }
+
+            break;
+        }
+
+        case( GLFW_KEY_F3 ) : {
+
+            auto *vehicle{
+                ( FreeFlyModeFlag ?
+                    std::get<TDynamicObject *>( simulation::Region->find_vehicle( camera->Pos, 20, false, false ) ) :
+                    controlled ) }; // w trybie latania lokalizujemy wg mapy
+
+            if( vehicle != nullptr ) {
+                // jeśli domyślny ekran po pierwszym naciśnięciu
+                uitextline1 = "Vehicle name: " + vehicle->MoverParameters->Name;
+
+                if( ( vehicle->Mechanik == nullptr ) && ( vehicle->ctOwner ) ) {
+                    // for cars other than leading unit indicate the leader
+                    uitextline1 += ", owned by " + vehicle->ctOwner->OwnerName();
+                }
+                uitextline1 += "; Status: " + vehicle->MoverParameters->EngineDescription( 0 );
+                // informacja o sprzęgach
+                uitextline1 +=
+                    "; C0:" +
+                    ( vehicle->PrevConnected ?
+                        vehicle->PrevConnected->name() + ":" + to_string( vehicle->MoverParameters->Couplers[ 0 ].CouplingFlag ) + (
+                            vehicle->MoverParameters->Couplers[ 0 ].CouplingFlag == 0 ?
+                                " (" + to_string( vehicle->MoverParameters->Couplers[ 0 ].CoupleDist, 1 ) + " m)" :
+                                "" ) :
+                        "none" );
+                uitextline1 +=
+                    " C1:" +
+                    ( vehicle->NextConnected ?
+                        vehicle->NextConnected->name() + ":" + to_string( vehicle->MoverParameters->Couplers[ 1 ].CouplingFlag ) + (
+                            vehicle->MoverParameters->Couplers[ 1 ].CouplingFlag == 0 ?
+                                " (" + to_string( vehicle->MoverParameters->Couplers[ 1 ].CoupleDist, 1 ) + " m)" :
+                                "" ) :
+                        "none" );
+
+                // equipment flags
+                uitextline2  = ( vehicle->MoverParameters->Battery ? "B" : "." );
+                uitextline2 += ( vehicle->MoverParameters->Mains ? "M" : "." );
+                uitextline2 += ( vehicle->MoverParameters->PantRearUp ? ( vehicle->MoverParameters->PantRearVolt > 0.0 ? "O" : "o" ) : "." );;
+                uitextline2 += ( vehicle->MoverParameters->PantFrontUp ? ( vehicle->MoverParameters->PantFrontVolt > 0.0 ? "P" : "p" ) : "." );;
+                uitextline2 += ( vehicle->MoverParameters->PantPressLockActive ? "!" : ( vehicle->MoverParameters->PantPressSwitchActive ? "*" : "." ) );
+                uitextline2 += ( vehicle->MoverParameters->FuelPump.is_enabled ? ( vehicle->MoverParameters->FuelPump.is_active ? "F" : "f" ) : "." );;
+                uitextline2 += ( false == vehicle->MoverParameters->ConverterAllowLocal ? "-" : ( vehicle->MoverParameters->ConverterAllow ? ( vehicle->MoverParameters->ConverterFlag ? "X" : "x" ) : "." ) );
+                uitextline2 += ( vehicle->MoverParameters->ConvOvldFlag ? "!" : "." );
+                uitextline2 += ( false == vehicle->MoverParameters->CompressorAllowLocal ? "-" : ( ( vehicle->MoverParameters->CompressorAllow || vehicle->MoverParameters->CompressorPower > 1 ) ? ( vehicle->MoverParameters->CompressorFlag ? "C" : "c" ) : "." ) );
+                uitextline2 += ( vehicle->MoverParameters->CompressorGovernorLock ? "!" : "." );
+
+                auto const train { Global.pWorld->train() };
+                if( ( train != nullptr ) && ( train->Dynamic() == vehicle ) ) {
+                    uitextline2 += " R: " + std::to_string( train->RadioChannel() );
+                }
+/*
+                uitextline2 +=
+                    " AnlgB: " + to_string( tmp->MoverParameters->AnPos, 1 )
+                    + "+"
+                    + to_string( tmp->MoverParameters->LocalBrakePosA, 1 )
+*/
+                uitextline2 += " Bdelay: ";
+                if( ( vehicle->MoverParameters->BrakeDelayFlag & bdelay_G ) == bdelay_G )
+                    uitextline2 += "G";
+                if( ( vehicle->MoverParameters->BrakeDelayFlag & bdelay_P ) == bdelay_P )
+                    uitextline2 += "P";
+                if( ( vehicle->MoverParameters->BrakeDelayFlag & bdelay_R ) == bdelay_R )
+                    uitextline2 += "R";
+                if( ( vehicle->MoverParameters->BrakeDelayFlag & bdelay_M ) == bdelay_M )
+                    uitextline2 += "+Mg";
+
+                uitextline2 += ", Load: " + to_string( vehicle->MoverParameters->Load, 0 ) + " (" + to_string( vehicle->MoverParameters->LoadFlag, 0 ) + ")";
+
+                uitextline2 +=
+                    "; Pant: "
+                    + to_string( vehicle->MoverParameters->PantPress, 2 )
+                    + ( vehicle->MoverParameters->bPantKurek3 ? "-ZG" : "|ZG" );
+
+                uitextline2 +=
+                    "; Ft: " + to_string(
+                        vehicle->MoverParameters->Ft * 0.001f * (
+                            vehicle->MoverParameters->ActiveCab ? vehicle->MoverParameters->ActiveCab :
+                            vehicle->ctOwner ? vehicle->ctOwner->Controlling()->ActiveCab :
+                            1 ), 1 )
+                    + ", Fb: " + to_string( vehicle->MoverParameters->Fb * 0.001f, 1 )
+                    + ", Fr: " + to_string( vehicle->MoverParameters->Adhesive( vehicle->MoverParameters->RunningTrack.friction ), 2 )
+                    + ( vehicle->MoverParameters->SlippingWheels ? " (!)" : "" );
+
+                if( vehicle->Mechanik ) {
+                    uitextline2 += "; Ag: " + to_string( vehicle->Mechanik->fAccGravity, 2 );
+                }
+
+                uitextline2 +=
+                    "; TC:"
+                    + to_string( vehicle->MoverParameters->TotalCurrent, 0 );
+                auto const frontcouplerhighvoltage =
+                    to_string( vehicle->MoverParameters->Couplers[ side::front ].power_high.voltage, 0 )
+                    + "@"
+                    + to_string( vehicle->MoverParameters->Couplers[ side::front ].power_high.current, 0 );
+                auto const rearcouplerhighvoltage =
+                    to_string( vehicle->MoverParameters->Couplers[ side::rear ].power_high.voltage, 0 )
+                    + "@"
+                    + to_string( vehicle->MoverParameters->Couplers[ side::rear ].power_high.current, 0 );
+                uitextline2 += ", HV: ";
+                if( vehicle->MoverParameters->Couplers[ side::front ].power_high.local == false ) {
+                    uitextline2 +=
+                            "(" + frontcouplerhighvoltage + ")-"
+                        + ":F" + ( vehicle->DirectionGet() ? "<<" : ">>" ) + "R:"
+                        + "-(" + rearcouplerhighvoltage + ")";
+                }
+                else {
+                    uitextline2 +=
+                            frontcouplerhighvoltage
+                        + ":F" + ( vehicle->DirectionGet() ? "<<" : ">>" ) + "R:"
+                        + rearcouplerhighvoltage;
+                }
+
+                uitextline3 +=
+                    "TrB: " + to_string( vehicle->MoverParameters->BrakePress, 2 )
+                    + ", " + to_hex_str( vehicle->MoverParameters->Hamulec->GetBrakeStatus(), 2 );
+
+                uitextline3 +=
+                    "; LcB: " + to_string( vehicle->MoverParameters->LocBrakePress, 2 )
+                    + "; hat: " + to_string( vehicle->MoverParameters->BrakeCtrlPos2, 2 )
+                    + "; pipes: " + to_string( vehicle->MoverParameters->PipePress, 2 )
+                    + "/" + to_string( vehicle->MoverParameters->ScndPipePress, 2 )
+                    + "/" + to_string( vehicle->MoverParameters->EqvtPipePress, 2 )
+                    + ", MT: " + to_string( vehicle->MoverParameters->CompressedVolume, 3 )
+                    + ", BT: " + to_string( vehicle->MoverParameters->Volume, 3 )
+                    + ", CtlP: " + to_string( vehicle->MoverParameters->CntrlPipePress, 3 )
+                    + ", CtlT: " + to_string( vehicle->MoverParameters->Hamulec->GetCRP(), 3 );
+
+                if( vehicle->MoverParameters->ManualBrakePos > 0 ) {
+
+                    uitextline3 += "; manual brake on";
+                }
+/*
+                if( tmp->MoverParameters->LocalBrakePos > 0 ) {
+
+                    uitextline3 += ", local brake on";
+                }
+                else {
+
+                    uitextline3 += ", local brake off";
+                }
+*/
+                if( vehicle->Mechanik ) {
+                    // o ile jest ktoś w środku
+                    std::string flags = "cpapcplhhndoiefgvdpseil "; // flagi AI (definicja w Driver.h)
+                    for( int i = 0, j = 1; i < 23; ++i, j <<= 1 )
+                        if( false == ( vehicle->Mechanik->DrivigFlags() & j ) ) // jak bit ustawiony
+                            flags[ i ] = '.';// std::toupper( flags[ i ] ); // ^= 0x20; // to zmiana na wielką literę
+
+                    uitextline4 = flags;
+
+                    uitextline4 +=
+                        "Driver: Vd=" + to_string( vehicle->Mechanik->VelDesired, 0 )
+                        + " Ad=" + to_string( vehicle->Mechanik->AccDesired, 2 )
+                        + " Ah=" + to_string( vehicle->Mechanik->fAccThreshold, 2 )
+                        + "@" + to_string( vehicle->Mechanik->fBrake_a0[ 0 ], 2 )
+                        + "+" + to_string( vehicle->Mechanik->fBrake_a1[ 0 ], 2 )
+                        + " Bd=" + to_string( vehicle->Mechanik->fBrakeDist, 0 )
+                        + " Pd=" + to_string( vehicle->Mechanik->ActualProximityDist, 0 )
+                        + " Vn=" + to_string( vehicle->Mechanik->VelNext, 0 )
+                        + " VSl=" + to_string( vehicle->Mechanik->VelSignalLast, 0 )
+                        + " VLl=" + to_string( vehicle->Mechanik->VelLimitLast, 0 )
+                        + " VRd=" + to_string( vehicle->Mechanik->VelRoad, 0 )
+                        + " VRst=" + to_string( vehicle->Mechanik->VelRestricted, 0 );
+
+                    if( ( vehicle->Mechanik->VelNext == 0.0 )
+                     && ( vehicle->Mechanik->eSignNext ) ) {
+                        // jeśli ma zapamiętany event semafora, nazwa eventu semafora
+                        uitextline4 += " (" + Bezogonkow( vehicle->Mechanik->eSignNext->asName ) + ")";
+                    }
+
+                    // biezaca komenda dla AI
+                    uitextline4 += ", command: " + vehicle->Mechanik->OrderCurrent();
+                }
+
+                if( Global.iScreenMode[ Global.iTextMode - GLFW_KEY_F1 ] == 1 ) {
+                    // f2 screen, track scan mode
+                    if( vehicle->Mechanik == nullptr ) {
+                        //żeby była tabelka, musi być AI
+                        break;
+                    }
+
+                    std::size_t i = 0; std::size_t const speedtablesize = clamp( static_cast<int>( vehicle->Mechanik->TableSize() ) - 1, 0, 30 );
+                    do {
+                        std::string scanline = vehicle->Mechanik->TableText( i );
+                        if( scanline.empty() ) { break; }
+                        UITable->text_lines.emplace_back( Bezogonkow( scanline ), Global.UITextColor );
+                        ++i;
+                    } while( i < speedtablesize ); // TController:iSpeedTableSize TODO: change when the table gets recoded
+                }
+            }
+            else {
+                // wyświetlenie współrzędnych w scenerii oraz kąta kamery, gdy nie mamy wskaźnika
+                uitextline1 =
+                    "Camera position: "
+                    + to_string( camera->Pos.x, 2 ) + " "
+                    + to_string( camera->Pos.y, 2 ) + " "
+                    + to_string( camera->Pos.z, 2 )
+                    + ", azimuth: "
+                    + to_string( 180.0 - glm::degrees( camera->Yaw ), 0 ) // ma być azymut, czyli 0 na północy i rośnie na wschód
+                    + " "
+                    + std::string( "S SEE NEN NWW SW" )
+                    .substr( 0 + 2 * floor( fmod( 8 + ( camera->Yaw + 0.5 * M_PI_4 ) / M_PI_4, 8 ) ), 2 );
+                // current luminance level
+                uitextline2 = "Light level: " + to_string( Global.fLuminance, 3 );
+                if( Global.FakeLight ) { uitextline2 += "(*)"; }
+            }
+
+            break;
+        }
+
+        case( GLFW_KEY_F8 ) : {
+            // gfx renderer data
+            uitextline1 =
+                "FoV: " + to_string( Global.FieldOfView / Global.ZoomFactor, 1 )
+                + ", Draw range x " + to_string( Global.fDistanceFactor, 1 )
+//                + "; sectors: " + std::to_string( GfxRenderer.m_drawcount )
+//                + ", FPS: " + to_string( Timer::GetFPS(), 2 );
+                + ", FPS: " + std::to_string( static_cast<int>(std::round(GfxRenderer.Framerate())) );
+            if( Global.iSlowMotion ) {
+                uitextline1 += " (slowmotion " + to_string( Global.iSlowMotion ) + ")";
+            }
+
+            uitextline2 =
+                std::string( "Rendering mode: " )
+                + ( Global.bUseVBO ?
+                    "VBO" :
+                    "Display Lists" )
+                + " ";
+            if( false == Global.LastGLError.empty() ) {
+                uitextline2 +=
+                    "Last openGL error: "
+                    + Global.LastGLError;
+            }
+            // renderer stats
+            uitextline3 = GfxRenderer.info_times();
+            uitextline4 = GfxRenderer.info_stats();
+
+            break;
+        }
+
+        case( GLFW_KEY_F9 ) : {
+            // informacja o wersji
+            uitextline1 = "MaSzyna " + Global.asVersion; // informacja o wersji
+            if( Global.iMultiplayer ) {
+                uitextline1 += " (multiplayer mode is active)";
+            }
+            uitextline3 =
+                  "vehicles: " + to_string( Timer::subsystem.sim_dynamics.average(), 2 ) + " msec"
+                + " update total: " + to_string( Timer::subsystem.sim_total.average(), 2 ) + " msec";
+
+            break;
+        }
+
+        case( GLFW_KEY_F10 ) : {
+
+            uitextline1 = ( "Press [Y] key to quit / Aby zakonczyc program, przycisnij klawisz [Y]." );
+
+            break;
+        }
+
+        case( GLFW_KEY_F12 ) : {
+            // opcje włączenia i wyłączenia logowania
+            uitextline1 = "[0] Debugmode " + std::string( DebugModeFlag ? "(on)" : "(off)" );
+            uitextline2 = "[1] log.txt " + std::string( ( Global.iWriteLogEnabled & 1 ) ? "(on)" : "(off)" );
+            uitextline3 = "[2] Console " + std::string( ( Global.iWriteLogEnabled & 2 ) ? "(on)" : "(off)" );
+
+            break;
+        }
+
+        default: {
+            // uncovered cases, nothing to do here...
+            // ... unless we're in debug mode
+            if( DebugModeFlag ) {
+
+                auto *vehicle {
+                    ( FreeFlyModeFlag ?
+                        std::get<TDynamicObject *>( simulation::Region->find_vehicle( camera->Pos, 20, false, false ) ) :
+                        controlled ) }; // w trybie latania lokalizujemy wg mapy
+                if( vehicle == nullptr ) {
+                    break;
+                }
+                uitextline1 =
+                    "vel: " + to_string( vehicle->GetVelocity(), 2 ) + "/" + to_string( vehicle->MoverParameters->nrot* M_PI * vehicle->MoverParameters->WheelDiameter * 3.6, 2 )
+                    + " km/h;" + ( vehicle->MoverParameters->SlippingWheels ? " (!)" : "    " )
+                    + " dist: " + to_string( vehicle->MoverParameters->DistCounter, 2 ) + " km"
+                    + "; pos: [" + to_string( vehicle->GetPosition().x, 2 ) + ", " + to_string( vehicle->GetPosition().y, 2 ) + ", " + to_string( vehicle->GetPosition().z, 2 ) + "]"
+                    + ", PM=" + to_string( vehicle->MoverParameters->WheelFlat, 1 )
+                    + " mm; enrot=" + to_string( vehicle->MoverParameters->enrot * 60, 0 )
+                    + " tmrot=" + to_string( std::abs( vehicle->MoverParameters->nrot ) * vehicle->MoverParameters->Transmision.Ratio * 60, 0 )
+                    + "; ventrot=" + to_string( vehicle->MoverParameters->RventRot * 60, 1 );
+
+                uitextline2 =
+                    "HamZ=" + to_string( vehicle->MoverParameters->fBrakeCtrlPos, 2 )
+                    + "; HamP=" + std::to_string( vehicle->MoverParameters->LocalBrakePos ) + "/" + to_string( vehicle->MoverParameters->LocalBrakePosA, 2 )
+                    + "; NasJ=" + std::to_string( vehicle->MoverParameters->MainCtrlPos ) + "(" + std::to_string( vehicle->MoverParameters->MainCtrlActualPos ) + ")"
+                    + ( vehicle->MoverParameters->ShuntMode ?
+                        "; NasB=" + to_string( vehicle->MoverParameters->AnPos, 2 ) :
+                        "; NasB=" + std::to_string( vehicle->MoverParameters->ScndCtrlPos ) + "(" + std::to_string( vehicle->MoverParameters->ScndCtrlActualPos ) + ")" )
+                    + "; I=" +
+                    ( vehicle->MoverParameters->TrainType == dt_EZT ?
+                        std::to_string( int( vehicle->MoverParameters->ShowCurrent( 0 ) ) ) :
+                       std::to_string( int( vehicle->MoverParameters->Im ) ) )
+                    + "; U=" + to_string( int( vehicle->MoverParameters->RunningTraction.TractionVoltage + 0.5 ) )
+                    + "; R=" +
+                    ( std::abs( vehicle->MoverParameters->RunningShape.R ) > 10000.0 ?
+                        "~0.0" :
+                        to_string( vehicle->MoverParameters->RunningShape.R, 1 ) )
+                    + " An=" + to_string( vehicle->MoverParameters->AccN, 2 ); // przyspieszenie poprzeczne
+
+                if( tprev != simulation::Time.data().wSecond ) {
+                    tprev = simulation::Time.data().wSecond;
+                    Acc = ( vehicle->MoverParameters->Vel - VelPrev ) / 3.6;
+                    VelPrev = vehicle->MoverParameters->Vel;
+                }
+                uitextline2 += "; As=" + to_string( Acc, 2 ); // przyspieszenie wzdłużne
+                uitextline2 += " eAngle=" + to_string( std::cos( vehicle->MoverParameters->eAngle ), 2 );
+
+                uitextline3 =
+                    "cyl.ham. " + to_string( vehicle->MoverParameters->BrakePress, 2 )
+                    + "; prz.gl. " + to_string( vehicle->MoverParameters->PipePress, 2 )
+                    + "; zb.gl. " + to_string( vehicle->MoverParameters->CompressedVolume, 2 )
+                    // youBy - drugi wezyk
+                    + "; p.zas. " + to_string( vehicle->MoverParameters->ScndPipePress, 2 );
+ 
+                // McZapkie: warto wiedziec w jakim stanie sa przelaczniki
+                if( vehicle->MoverParameters->ConvOvldFlag )
+                    uitextline3 += " C! ";
+                else if( vehicle->MoverParameters->FuseFlag )
+                    uitextline3 += " F! ";
+                else if( !vehicle->MoverParameters->Mains )
+                    uitextline3 += " () ";
+                else {
+                    switch(
+                        vehicle->MoverParameters->ActiveDir *
+                        ( vehicle->MoverParameters->Imin == vehicle->MoverParameters->IminLo ?
+                            1 :
+                            2 ) ) {
+                        case  2: { uitextline3 += " >> "; break; }
+                        case  1: { uitextline3 += " -> "; break; }
+                        case  0: { uitextline3 += " -- "; break; }
+                        case -1: { uitextline3 += " <- "; break; }
+                        case -2: { uitextline3 += " << "; break; }
+                    }
+                }
+                // McZapkie: predkosc szlakowa
+                if( vehicle->MoverParameters->RunningTrack.Velmax == -1 ) {
+                    uitextline3 += " Vtrack=Vmax";
+                }
+                else {
+                    uitextline3 += " Vtrack " + to_string( vehicle->MoverParameters->RunningTrack.Velmax, 2 );
+                }
+
+                if( ( vehicle->MoverParameters->EnginePowerSource.SourceType == CurrentCollector )
+                    || ( vehicle->MoverParameters->TrainType == dt_EZT ) ) {
+                    uitextline3 +=
+                        "; pant. " + to_string( vehicle->MoverParameters->PantPress, 2 )
+                        + ( vehicle->MoverParameters->bPantKurek3 ? "=" : "^" ) + "ZG";
+                }
+
+                // McZapkie: komenda i jej parametry
+                if( vehicle->MoverParameters->CommandIn.Command != ( "" ) ) {
+                    uitextline4 =
+                        "C:" + vehicle->MoverParameters->CommandIn.Command
+                        + " V1=" + to_string( vehicle->MoverParameters->CommandIn.Value1, 0 )
+                        + " V2=" + to_string( vehicle->MoverParameters->CommandIn.Value2, 0 );
+                }
+                if( ( vehicle->Mechanik )
+                 && ( vehicle->Mechanik->AIControllFlag == AIdriver ) ) {
+                    uitextline4 +=
+                        "AI: Vd=" + to_string( vehicle->Mechanik->VelDesired, 0 )
+                        + " ad=" + to_string(vehicle->Mechanik->AccDesired, 2)
+						+ "/" + to_string(vehicle->Mechanik->AccDesired*vehicle->Mechanik->BrakeAccFactor(), 2)
+						+ " atrain=" + to_string(vehicle->Mechanik->fBrake_a0[0], 2)
+						+ "+" + to_string(vehicle->Mechanik->fBrake_a1[0], 2)
+						+ " aS=" + to_string(vehicle->Mechanik->AbsAccS_pub, 2)
+                        + " Pd=" + to_string( vehicle->Mechanik->ActualProximityDist, 0 )
+                        + " Vn=" + to_string( vehicle->Mechanik->VelNext, 0 );
+                }
+
+                // induction motor data
+                if( vehicle->MoverParameters->EngineType == ElectricInductionMotor ) {
+
+                    UITable->text_lines.emplace_back( "      eimc:            eimv:            press:", Global.UITextColor );
+                    for( int i = 0; i <= 20; ++i ) {
+
+                        std::string parameters =
+                            vehicle->MoverParameters->eimc_labels[ i ] + to_string( vehicle->MoverParameters->eimc[ i ], 2, 9 )
+                            + " | "
+                            + vehicle->MoverParameters->eimv_labels[ i ] + to_string( vehicle->MoverParameters->eimv[ i ], 2, 9 );
+
+                        if( i < 10 ) {
+                            parameters += " | " + train->fPress_labels[i] + to_string( train->fPress[ i ][ 0 ], 2, 9 );
+                        }
+                        else if( i == 12 ) {
+                            parameters += "        med:";
+                        }
+                        else if( i >= 13 ) {
+                            parameters += " | " + vehicle->MED_labels[ i - 13 ] + to_string( vehicle->MED[ 0 ][ i - 13 ], 2, 9 );
+                        }
+
+                        UITable->text_lines.emplace_back( parameters, Global.UITextColor );
+                    }
+                }
+				if (vehicle->MoverParameters->EngineType == DieselEngine) {
+					std::string parameters = "param       value";
+					UITable->text_lines.emplace_back(parameters, Global.UITextColor);
+					parameters = "efill: " + to_string(vehicle->MoverParameters->dizel_fill, 2, 9);
+					UITable->text_lines.emplace_back(parameters, Global.UITextColor);
+					parameters = "etorq: " + to_string(vehicle->MoverParameters->dizel_Torque, 2, 9);
+					UITable->text_lines.emplace_back(parameters, Global.UITextColor);
+					parameters = "creal: " + to_string(vehicle->MoverParameters->dizel_engage, 2, 9);
+					UITable->text_lines.emplace_back(parameters, Global.UITextColor);
+					parameters = "cdesi: " + to_string(vehicle->MoverParameters->dizel_engagestate, 2, 9);
+					UITable->text_lines.emplace_back(parameters, Global.UITextColor);
+					parameters = "cdelt: " + to_string(vehicle->MoverParameters->dizel_engagedeltaomega, 2, 9);
+					UITable->text_lines.emplace_back(parameters, Global.UITextColor);
+					parameters = "gears: " + to_string(vehicle->MoverParameters->dizel_automaticgearstatus, 2, 9);
+					UITable->text_lines.emplace_back(parameters, Global.UITextColor);
+					parameters = "hydro      value";
+					UITable->text_lines.emplace_back(parameters, Global.UITextColor);
+					parameters = "hTCnI: " + to_string(vehicle->MoverParameters->hydro_TC_nIn, 2, 9);
+					UITable->text_lines.emplace_back(parameters, Global.UITextColor);
+					parameters = "hTCnO: " + to_string(vehicle->MoverParameters->hydro_TC_nOut, 2, 9);
+					UITable->text_lines.emplace_back(parameters, Global.UITextColor);
+					parameters = "hTCTM: " + to_string(vehicle->MoverParameters->hydro_TC_TMRatio, 2, 9);
+					UITable->text_lines.emplace_back(parameters, Global.UITextColor);
+					parameters = "hTCTI: " + to_string(vehicle->MoverParameters->hydro_TC_TorqueIn, 2, 9);
+					UITable->text_lines.emplace_back(parameters, Global.UITextColor);
+					parameters = "hTCTO: " + to_string(vehicle->MoverParameters->hydro_TC_TorqueOut, 2, 9);
+					UITable->text_lines.emplace_back(parameters, Global.UITextColor);
+					parameters = "hTCfl: " + to_string(vehicle->MoverParameters->hydro_TC_Fill, 2, 9);
+					UITable->text_lines.emplace_back(parameters, Global.UITextColor);
+					parameters = "hTCLR: " + to_string(vehicle->MoverParameters->hydro_TC_LockupRate, 2, 9);
+					UITable->text_lines.emplace_back(parameters, Global.UITextColor);
+					//parameters = "hTCXX: " + to_string(vehicle->MoverParameters->hydro_TC_nIn, 2, 9);
+					//UITable->text_lines.emplace_back(parameters, Global.UITextColor);
+				}
+
+            } // if( DebugModeFlag && Controlled )
+
+            break;
+        }
+    }
+
+#ifdef EU07_USE_OLD_UI_CODE
+    if( Controlled && DebugModeFlag && !Global.iTextMode ) {
+
+        uitextline1 +=
+            ( "; d_omega " ) + to_string( Controlled->MoverParameters->dizel_engagedeltaomega, 3 );
+
+        if( Controlled->MoverParameters->EngineType == ElectricInductionMotor ) {
+
+            for( int i = 0; i <= 8; i++ ) {
+                for( int j = 0; j <= 9; j++ ) {
+                    glRasterPos2f( 0.05f + 0.03f * i, 0.16f - 0.01f * j );
+                    uitextline4 = to_string( Train->fEIMParams[ i ][ j ], 2 );
+                }
+            }
+        }
+    }
+#endif
+
+    // update the ui header texts
+    auto &headerdata = UIHeader->text_lines;
+    headerdata[ 0 ].data = uitextline1;
+    headerdata[ 1 ].data = uitextline2;
+    headerdata[ 2 ].data = uitextline3;
+    headerdata[ 3 ].data = uitextline4;
+
+    // stenogramy dźwięków (ukryć, gdy tabelka skanowania lub rozkład?)
+    auto &transcripts = UITranscripts->text_lines;
+    transcripts.clear();
+    for( auto const &transcript : ui::Transcripts.aLines ) {
+
+        if( Global.fTimeAngleDeg >= transcript.fShow ) {
+
+            cParser parser( transcript.asText );
+            while( true == parser.getTokens( 1, false, "|" ) ) {
+
+                std::string transcriptline; parser >> transcriptline;
+                transcripts.emplace_back( transcriptline, glm::vec4( 1.0f, 1.0f, 0.0f, 1.0f ) );
+            }
+        }
+    }
+
+}
+
 void
 ui_layer::render() {