From fe1c52027e26466680f452b0cf7d57ddfa28fa17 Mon Sep 17 00:00:00 2001 From: tmj-fstate Date: Fri, 27 Jan 2017 22:45:47 +0100 Subject: [PATCH] replaced the list of dynamic objects on tracks with stl-based version --- Driver.cpp | 32 +++++++++++ DynObj.cpp | 137 ++++++++++++++++++++++++++++++++++++++++++--- Ground.cpp | 54 +++++++++++++++++- McZapkie/MOVER.h | 2 +- McZapkie/Mover.cpp | 2 +- Track.cpp | 105 +++++++++++++++++++++++++++++++++- Track.h | 11 ++++ 7 files changed, 328 insertions(+), 15 deletions(-) diff --git a/Driver.cpp b/Driver.cpp index a4d90426..938d3e55 100644 --- a/Driver.cpp +++ b/Driver.cpp @@ -241,6 +241,7 @@ bool TSpeedPos::Update(vector3 *p, vector3 *dir, double &len) fVelNext = 30.0; // uzależnić prędkość od promienia; albo niech będzie // ograniczona w skrzyżowaniu (velocity z ujemną wartością) if ((iFlags & spElapsed) == 0) // jeśli nie wjechał +#ifdef EU07_USE_OLD_TTRACK_DYNAMICS_ARRAY if (trTrack->iNumDynamics > 0) // a skrzyżowanie zawiera pojazd { if (Global::iWriteLogEnabled & 8) @@ -248,6 +249,14 @@ bool TSpeedPos::Update(vector3 *p, vector3 *dir, double &len) fVelNext = 0.0; // to zabronić wjazdu (chyba że ten z przodu też jedzie prosto) } +#else + if( false == trTrack->Dynamics.empty() ) { + if( Global::iWriteLogEnabled & 8 ) { + WriteLog( "Tor " + trTrack->NameGet() + " zajety przed pojazdem. Num=" + std::to_string( trTrack->Dynamics.size() ) + "Dist= " + std::to_string( fDist ) ); + fVelNext = 0.0; // to zabronić wjazdu (chyba że ten z przodu też jedzie prosto) + } + } +#endif } if (iFlags & spSwitch) // jeśli odcinek zmienny { @@ -262,6 +271,7 @@ bool TSpeedPos::Update(vector3 *p, vector3 *dir, double &len) // na Mydelniczce potrafi skanować na wprost mimo pojechania na bok } // poniższe nie dotyczy trybu łączenia? +#ifdef EU07_USE_OLD_TTRACK_DYNAMICS_ARRAY if ((iFlags & spElapsed) ? false : trTrack->iNumDynamics > 0) // jeśli jeszcze nie wjechano na tor, a coś na nim jest @@ -273,6 +283,16 @@ bool TSpeedPos::Update(vector3 *p, vector3 *dir, double &len) // else if (fVelNext==0.0) //jeśli została wyzerowana // fVelNext=trTrack->VelocityGet(); //odczyt prędkości } +#else + if( ( ( iFlags & spElapsed ) == 0 ) + && ( false == trTrack->Dynamics.empty() ) ) { + // jeśli jeszcze nie wjechano na tor, a coś na nim jest + if( Global::iWriteLogEnabled & 8 ) { + WriteLog( "Rozjazd " + trTrack->NameGet() + " zajety przed pojazdem. Num=" + std::to_string( trTrack->Dynamics.size() ) + "Dist= " + std::to_string( fDist ) ); + } + fVelNext = 0.0; // to niech stanie w zwiększonej odległości + } +#endif } } } @@ -4927,6 +4947,7 @@ double TController::Distance(vector3 &p1,vector3 &n,vector3 &p2) bool TController::BackwardTrackBusy(TTrack *Track) { // najpierw sprawdzamy, czy na danym torze są pojazdy z innego składu +#ifdef EU07_USE_OLD_TTRACK_DYNAMICS_ARRAY if (Track->iNumDynamics) { // jeśli tylko z własnego składu, to tor jest wolny for (int i = 0; i < Track->iNumDynamics; ++i) @@ -4934,6 +4955,17 @@ bool TController::BackwardTrackBusy(TTrack *Track) return true; // to tor jest zajęty i skanowanie nie obowiązuje } return false; // wolny +#else + if( false == Track->Dynamics.empty() ) { + for( auto dynamic : Track->Dynamics ) { + if( dynamic->ctOwner != this ) { + // jeśli jest jakiś cudzy to tor jest zajęty i skanowanie nie obowiązuje + return true; + } + } + } + return false; // wolny +#endif }; TEvent * TController::CheckTrackEventBackward(double fDirection, TTrack *Track) diff --git a/DynObj.cpp b/DynObj.cpp index 68d26851..bcb8ec05 100644 --- a/DynObj.cpp +++ b/DynObj.cpp @@ -965,6 +965,7 @@ TDynamicObject * TDynamicObject::ABuFindNearestObject(TTrack *Track, // Uwaga! Jesli CouplNr==-2 to szukamy njblizszego obiektu, a nie sprzegu!!! +#ifdef EU07_USE_OLD_TTRACK_DYNAMICS_ARRAY if ((Track->iNumDynamics) > 0) { // o ile w ogóle jest co przeglądać na tym torze // vector3 poz; //pozycja pojazdu XYZ w scenerii @@ -1013,7 +1014,33 @@ TDynamicObject * TDynamicObject::ABuFindNearestObject(TTrack *Track, } return NULL; } - return NULL; +#else + for( auto dynamic : Track->Dynamics ) { + + if( CouplNr == -2 ) { + // wektor [kamera-obiekt] - poszukiwanie obiektu + if( LengthSquared3( Global::GetCameraPosition() - dynamic->vPosition ) < 100.0 ) { + // 10 metrów + return dynamic; + } + } + else { + // jeśli (CouplNr) inne niz -2, szukamy sprzęgu + if( LengthSquared3( Global::GetCameraPosition() - dynamic->vCoulpler[ 0 ] ) < 25.0 ) { + // 5 metrów + CouplNr = 0; + return dynamic; + } + if( LengthSquared3( Global::GetCameraPosition() - dynamic->vCoulpler[ 1 ] ) < 25.0 ) { + // 5 metrów + CouplNr = 1; + return dynamic; + } + } + } + // empty track or nothing found + return nullptr; +#endif } TDynamicObject * TDynamicObject::ABuScanNearestObject(TTrack *Track, double ScanDir, @@ -1135,14 +1162,22 @@ TDynamicObject * TDynamicObject::ABuFindObject(TTrack *Track, int ScanDir, // WY: wskaznik do znalezionego obiektu. // CouplFound - nr sprzegu znalezionego obiektu +#ifdef EU07_USE_OLD_TTRACK_DYNAMICS_ARRAY if (Track->iNumDynamics > 0) +#else + if( false == Track->Dynamics.empty() ) +#endif { // sens szukania na tym torze jest tylko, gdy są na nim pojazdy double ObjTranslation; // pozycja najblizszego obiektu na torze double MyTranslation; // pozycja szukającego na torze double MinDist = Track->Length(); // najmniejsza znaleziona odleglość // (zaczynamy od długości toru) double TestDist; // robocza odległość od kolejnych pojazdów na danym odcinku +#ifdef EU07_USE_OLD_TTRACK_DYNAMICS_ARRAY int iMinDist = -1; // indeks wykrytego obiektu +#else + TDynamicObject *collider = nullptr; +#endif // if (Track->iNumDynamics>1) // iMinDist+=0; //tymczasowo pułapka if (MyTrack == Track) // gdy szukanie na tym samym torze @@ -1154,7 +1189,8 @@ TDynamicObject * TDynamicObject::ABuFindObject(TTrack *Track, int ScanDir, MyTranslation = MinDist; // szukanie w kierunku Point1 (do zera) - jesteśmy w Point2 if (ScanDir >= 0) { // jeśli szukanie w kierunku Point2 - for (int i = 0; i < Track->iNumDynamics; i++) +#ifdef EU07_USE_OLD_TTRACK_DYNAMICS_ARRAY + for( int i = 0; i < Track->iNumDynamics; i++ ) { // pętla po pojazdach if (Track->Dynamics[i] != this) // szukający się nie liczy { @@ -1200,10 +1236,56 @@ TDynamicObject * TDynamicObject::ABuFindObject(TTrack *Track, int ScanDir, } } } +#else + for( auto dynamic : Track->Dynamics ) { + // pętla po pojazdach + if( dynamic == this ) { + // szukający się nie liczy + continue; + } + + TestDist = ( dynamic->RaTranslationGet() ) - MyTranslation; // odległogłość tamtego od szukającego + if( ( TestDist > 0 ) && ( TestDist <= MinDist ) ) { // gdy jest po właściwej stronie i bliżej + // niż jakiś wcześniejszy + CouplFound = ( dynamic->RaDirectionGet() > 0 ) ? 1 : 0; // to, bo (ScanDir>=0) + if( Track->iCategoryFlag & 254 ) { + // trajektoria innego typu niż tor kolejowy + // dla torów nie ma sensu tego sprawdzać, rzadko co jedzie po jednej szynie i się mija + // Ra: mijanie samochodów wcale nie jest proste + // Przesuniecie wzgledne pojazdow. Wyznaczane, zeby sprawdzic, + // czy pojazdy faktycznie sie zderzaja (moga byc przesuniete + // w/m siebie tak, ze nie zachodza na siebie i wtedy sie mijaja). + double RelOffsetH; // wzajemna odległość poprzeczna + if( CouplFound ) { + // my na tym torze byśmy byli w kierunku Point2 + // dla CouplFound=1 są zwroty zgodne - istotna różnica przesunięć + RelOffsetH = ( MoverParameters->OffsetTrackH - dynamic->MoverParameters->OffsetTrackH ); + } + else { + // dla CouplFound=0 są zwroty przeciwne - przesunięcia sumują się + RelOffsetH = ( MoverParameters->OffsetTrackH + dynamic->MoverParameters->OffsetTrackH ); + } + if( RelOffsetH < 0 ) { + RelOffsetH = -RelOffsetH; + } + if( RelOffsetH + RelOffsetH > MoverParameters->Dim.W + dynamic->MoverParameters->Dim.W ) { + // odległość większa od połowy sumy szerokości - kolizji nie będzie + continue; + } + // jeśli zahaczenie jest niewielkie, a jest miejsce na poboczu, to + // zjechać na pobocze + } + collider = dynamic; // potencjalna kolizja + MinDist = TestDist; // odleglość pomiędzy aktywnymi osiami pojazdów + } + + } +#endif } else //(ScanDir<0) { - for (int i = 0; i < Track->iNumDynamics; i++) +#ifdef EU07_USE_OLD_TTRACK_DYNAMICS_ARRAY + for( int i = 0; i < Track->iNumDynamics; i++ ) { if (Track->Dynamics[i] != this) { @@ -1247,15 +1329,54 @@ TDynamicObject * TDynamicObject::ABuFindObject(TTrack *Track, int ScanDir, } } } +#else + for( auto dynamic : Track->Dynamics ) { + + if( dynamic == this ) { continue; } + + TestDist = MyTranslation - ( dynamic->RaTranslationGet() ); //???-przesunięcie wózka względem Point1 toru + if( ( TestDist > 0 ) && ( TestDist < MinDist ) ) { + CouplFound = ( dynamic->RaDirectionGet() > 0 ) ? 0 : 1; // odwrotnie, bo (ScanDir<0) + if( Track->iCategoryFlag & 254 ) // trajektoria innego typu niż tor kolejowy + { // dla torów nie ma sensu tego sprawdzać, rzadko co jedzie po jednej szynie i się mija + // Ra: mijanie samochodów wcale nie jest proste + // Przesunięcie względne pojazdów. Wyznaczane, żeby sprawdzić, + // czy pojazdy faktycznie się zderzają (mogą być przesunięte + // w/m siebie tak, że nie zachodzą na siebie i wtedy sie mijają). + double RelOffsetH; // wzajemna odległość poprzeczna + if( CouplFound ) { + // my na tym torze byśmy byli w kierunku Point1 + // dla CouplFound=1 są zwroty zgodne - istotna różnica przesunięć + RelOffsetH = ( MoverParameters->OffsetTrackH - dynamic->MoverParameters->OffsetTrackH ); + } + else { + // dla CouplFound=0 są zwroty przeciwne - przesunięcia sumują się + RelOffsetH = ( MoverParameters->OffsetTrackH + dynamic->MoverParameters->OffsetTrackH ); + } + if( RelOffsetH < 0 ) { + RelOffsetH = -RelOffsetH; + } + if( RelOffsetH + RelOffsetH > MoverParameters->Dim.W + dynamic->MoverParameters->Dim.W ) { + // odległość większa od połowy sumy szerokości - kolizji nie będzie + continue; + } + } + collider = dynamic; // potencjalna kolizja + MinDist = TestDist; // odleglość pomiędzy aktywnymi osiami pojazdów + } + } +#endif } - dist += MinDist; // doliczenie odległości przeszkody albo długości odcinka - // do przeskanowanej - // odległości - return (iMinDist >= 0) ? Track->Dynamics[iMinDist] : NULL; + dist += MinDist; // doliczenie odległości przeszkody albo długości odcinka do przeskanowanej odległości +#ifdef EU07_USE_OLD_TTRACK_DYNAMICS_ARRAY + return ( iMinDist >= 0 ) ? Track->Dynamics[ iMinDist ] : NULL; +#else + return collider; +#endif } dist += Track->Length(); // doliczenie długości odcinka do przeskanowanej // odległości - return NULL; // nie ma pojazdów na torze, to jest NULL + return nullptr; // nie ma pojazdów na torze, to jest NULL } int TDynamicObject::DettachStatus(int dir) diff --git a/Ground.cpp b/Ground.cpp index c9850991..b25a5c54 100644 --- a/Ground.cpp +++ b/Ground.cpp @@ -3814,10 +3814,18 @@ bool TGround::AddToQuery(TEvent *Event, TDynamicObject *Node) if (Event->Params[6].asTrack) { // McZapkie-100302 - updatevalues oprocz zmiany wartosci robi putcommand dla // wszystkich 'dynamic' na danym torze +#ifdef EU07_USE_OLD_TTRACK_DYNAMICS_ARRAY for (int i = 0; i < Event->Params[6].asTrack->iNumDynamics; ++i) Event->Params[5].asMemCell->PutCommand( Event->Params[6].asTrack->Dynamics[i]->Mechanik, &Event->Params[4].nGroundNode->pCenter); +#else + for( auto dynamic : Event->Params[ 6 ].asTrack->Dynamics ) { + Event->Params[ 5 ].asMemCell->PutCommand( + dynamic->Mechanik, + &Event->Params[ 4 ].nGroundNode->pCenter ); + } +#endif //if (DebugModeFlag) WriteLog("EVENT EXECUTED: AddValues & Track command - " + std::string(Event->Params[0].asText) + " " + @@ -4006,10 +4014,18 @@ bool TGround::CheckQuery() if (tmpEvent->Params[6].asTrack) { // McZapkie-100302 - updatevalues oprocz zmiany wartosci robi putcommand dla // wszystkich 'dynamic' na danym torze +#ifdef EU07_USE_OLD_TTRACK_DYNAMICS_ARRAY for (int i = 0; i < tmpEvent->Params[6].asTrack->iNumDynamics; ++i) tmpEvent->Params[5].asMemCell->PutCommand( tmpEvent->Params[6].asTrack->Dynamics[i]->Mechanik, &tmpEvent->Params[4].nGroundNode->pCenter); +#else + for( auto dynamic : tmpEvent->Params[ 6 ].asTrack->Dynamics ) { + tmpEvent->Params[ 5 ].asMemCell->PutCommand( + dynamic->Mechanik, + &tmpEvent->Params[ 4 ].nGroundNode->pCenter ); + } +#endif //if (DebugModeFlag) WriteLog("Type: UpdateValues & Track command - " + std::string(tmpEvent->Params[0].asText) + " " + @@ -5038,7 +5054,8 @@ TDynamicObject * TGround::DynamicNearest(vector3 pPosition, double distance, boo if ((tmp = FastGetSubRect(i, j)) != NULL) for (node = tmp->nRootNode; node; node = node->nNext2) // następny z sektora if (node->iType == TP_TRACK) // Ra: przebudować na użycie tabeli torów? - for (k = 0; k < node->pTrack->iNumDynamics; k++) +#ifdef EU07_USE_OLD_TTRACK_DYNAMICS_ARRAY + for( k = 0; k < node->pTrack->iNumDynamics; k++ ) if (mech ? (node->pTrack->Dynamics[k]->Mechanik != NULL) : true) // czy ma mieć obsadę if ((sqd = SquareMagnitude( @@ -5048,6 +5065,17 @@ TDynamicObject * TGround::DynamicNearest(vector3 pPosition, double distance, boo sqm = sqd; // nowa odległość dyn = node->pTrack->Dynamics[k]; // nowy lider } +#else + for( auto dynamic : node->pTrack->Dynamics ) { + if( mech ? ( dynamic->Mechanik != nullptr ) : true ) { + // czy ma mieć obsadę + if( ( sqd = SquareMagnitude( dynamic->GetPosition() - pPosition ) ) < sqm ) { + sqm = sqd; // nowa odległość + dyn = dynamic; // nowy lider + } + } + } +#endif return dyn; }; TDynamicObject * TGround::CouplerNearest(vector3 pPosition, double distance, bool mech) @@ -5064,7 +5092,8 @@ TDynamicObject * TGround::CouplerNearest(vector3 pPosition, double distance, boo if ((tmp = FastGetSubRect(i, j)) != NULL) for (node = tmp->nRootNode; node; node = node->nNext2) // następny z sektora if (node->iType == TP_TRACK) // Ra: przebudować na użycie tabeli torów? - for (k = 0; k < node->pTrack->iNumDynamics; k++) +#ifdef EU07_USE_OLD_TTRACK_DYNAMICS_ARRAY + for( k = 0; k < node->pTrack->iNumDynamics; k++ ) if (mech ? (node->pTrack->Dynamics[k]->Mechanik != NULL) : true) // czy ma mieć obsadę { @@ -5083,6 +5112,21 @@ TDynamicObject * TGround::CouplerNearest(vector3 pPosition, double distance, boo dyn = node->pTrack->Dynamics[k]; // nowy lider } } +#else + for( auto dynamic : node->pTrack->Dynamics ) { + if( mech ? ( dynamic->Mechanik != nullptr ) : true ) { + // czy ma mieć obsadę + if( ( sqd = SquareMagnitude( dynamic->HeadPosition() - pPosition ) ) < sqm ) { + sqm = sqd; // nowa odległość + dyn = dynamic; // nowy lider + } + if( ( sqd = SquareMagnitude( dynamic->RearPosition() - pPosition ) ) < sqm ) { + sqm = sqd; // nowa odległość + dyn = dynamic; // nowy lider + } + } + } +#endif return dyn; }; //--------------------------------------------------------------------------- @@ -5221,7 +5265,11 @@ void TGround::TrackBusyList() TTrack *Track; for (Current = nRootOfType[TP_TRACK]; Current; Current = Current->nNext) if (!Current->asName.empty()) // musi być nazwa - if (Current->pTrack->iNumDynamics) // osi to chyba nie ma jak policzyć +#ifdef EU07_USE_OLD_TTRACK_DYNAMICS_ARRAY + if( Current->pTrack->iNumDynamics ) // osi to chyba nie ma jak policzyć +#else + if( false == Current->pTrack->Dynamics.empty() ) +#endif WyslijString(Current->asName, 8); // zajęty }; //--------------------------------------------------------------------------- diff --git a/McZapkie/MOVER.h b/McZapkie/MOVER.h index 1a388469..acf207b6 100644 --- a/McZapkie/MOVER.h +++ b/McZapkie/MOVER.h @@ -672,7 +672,7 @@ public: /*nastawniki:*/ int MainCtrlPosNo = 0; /*ilosc pozycji nastawnika*/ int ScndCtrlPosNo = 0; - int LightsPosNo = 1; + int LightsPosNo = 0; // NOTE: values higher than 0 seem to break the current code for light switches int LightsDefPos = 0; bool LightsWrap = false; int Lights[2][17]; // pozycje świateł, przód - tył, 1 .. 16 diff --git a/McZapkie/Mover.cpp b/McZapkie/Mover.cpp index 779152fc..62f89232 100644 --- a/McZapkie/Mover.cpp +++ b/McZapkie/Mover.cpp @@ -298,7 +298,7 @@ Name( NameInit ) } for (int b = 0; b < 2; ++b) - for (int k = 1; k <= 17; ++k) + for (int k = 0; k < 17; ++k) Lights[b][k] = 0; for (int b = -1; b <= MainBrakeMaxPos; ++b) diff --git a/Track.cpp b/Track.cpp index 284b3368..162f0847 100644 --- a/Track.cpp +++ b/Track.cpp @@ -145,7 +145,9 @@ void TIsolated::Modify(int i, TDynamicObject *o) TTrack::TTrack(TGroundNode *g) : pMyNode( g ) // Ra: proteza, żeby tor znał swoją nazwę TODO: odziedziczyć TTrack z TGroundNode { +#ifdef EU07_USE_OLD_TTRACK_DYNAMICS_ARRAY ::SecureZeroMemory( Dynamics, sizeof( Dynamics ) ); +#endif fRadiusTable[ 0 ] = 0.0; fRadiusTable[ 1 ] = 0.0; nFouling[ 0 ] = nullptr; @@ -997,6 +999,7 @@ bool TTrack::AddDynamicObject(TDynamicObject *Dynamic) Dynamic->MyTrack = NULL; // trzeba by to uzależnić od kierunku ruchu... return true; } +#ifdef EU07_USE_OLD_TTRACK_DYNAMICS_ARRAY if (Global::iMultiplayer) // jeśli multiplayer if (!iNumDynamics) // pierwszy zajmujący if (pMyNode->asName != "none") @@ -1016,6 +1019,25 @@ bool TTrack::AddDynamicObject(TDynamicObject *Dynamic) Error("Too many dynamics on track " + pMyNode->asName); return false; } +#else + if( Global::iMultiplayer ) { + // jeśli multiplayer + if( true == Dynamics.empty() ) { + // pierwszy zajmujący + if( pMyNode->asName != "none" ) { + // przekazanie informacji o zajętości toru + Global::pGround->WyslijString( pMyNode->asName, 8 ); + } + } + } + Dynamics.emplace_back( Dynamic ); + Dynamic->MyTrack = this; // ABu: na ktorym torze jesteśmy + if( Dynamic->iOverheadMask ) { + // jeśli ma pantografy + Dynamic->OverheadTrack( fOverhead ); // przekazanie informacji o jeździe bezprądowej na tym odcinku toru + } + return true; +#endif }; void TTrack::MoveMe(vector3 pPosition) @@ -1833,14 +1855,24 @@ void TTrack::Render() bool TTrack::CheckDynamicObject(TDynamicObject *Dynamic) { // sprawdzenie, czy pojazd jest przypisany do toru +#ifdef EU07_USE_OLD_TTRACK_DYNAMICS_ARRAY for (int i = 0; i < iNumDynamics; i++) if (Dynamic == Dynamics[i]) return true; return false; +#else + for( auto dynamic : Dynamics ) { + if( dynamic == Dynamic ) { + return true; + } + } + return false; +#endif }; bool TTrack::RemoveDynamicObject(TDynamicObject *Dynamic) { // usunięcie pojazdu z listy przypisanych do toru +#ifdef EU07_USE_OLD_TTRACK_DYNAMICS_ARRAY for (int i = 0; i < iNumDynamics; i++) { // sprawdzanie wszystkich po kolei if (Dynamic == Dynamics[i]) @@ -1858,6 +1890,41 @@ bool TTrack::RemoveDynamicObject(TDynamicObject *Dynamic) } Error("Cannot remove dynamic from track"); return false; +#else + bool result = false; + if( *Dynamics.begin() == Dynamic ) { + // most likely the object getting removed it's at the front... + Dynamics.pop_front(); + result = true; + } + else if( *( --Dynamics.end() ) == Dynamic ) { + // ...or the back of the queue... + Dynamics.pop_back(); + result = true; + } + else { + // ... if these fail, check all objects one by one, just in case + // TODO: check if this is ever needed, remove if it isn't. + for( auto idx = Dynamics.begin(); idx != Dynamics.end(); ++idx ) { + if( *idx == Dynamic ) { + Dynamics.erase( idx ); + result = true; + } + } + } + if( Global::iMultiplayer ) { + // jeśli multiplayer + if( true == Dynamics.empty() ) { + // jeśli już nie ma żadnego + if( pMyNode->asName != "none" ) { + // przekazanie informacji o zwolnieniu toru + Global::pGround->WyslijString( pMyNode->asName, 9 ); + } + } + } + + return result; +#endif } bool TTrack::InMovement() @@ -2551,28 +2618,48 @@ void TTrack::EnvironmentReset() void TTrack::RenderDyn() { // renderowanie nieprzezroczystych fragmentów pojazdów +#ifdef EU07_USE_OLD_TTRACK_DYNAMICS_ARRAY if (!iNumDynamics) return; // po co kombinować, jeśli nie ma pojazdów? // EnvironmentSet(); //Ra: pojazdy sobie same teraz liczą cienie for (int i = 0; i < iNumDynamics; i++) Dynamics[i]->Render(); // sam sprawdza, czy VBO; zmienia kontekst VBO! // EnvironmentReset(); +#else + for( auto dynamic : Dynamics ) { + // sam sprawdza, czy VBO; zmienia kontekst VBO! + dynamic->Render(); + } +#endif }; void TTrack::RenderDynAlpha() { // renderowanie przezroczystych fragmentów pojazdów +#ifdef EU07_USE_OLD_TTRACK_DYNAMICS_ARRAY if (!iNumDynamics) return; // po co kombinować, jeśli nie ma pojazdów? // EnvironmentSet(); //Ra: pojazdy sobie same teraz liczą cienie for (int i = 0; i < iNumDynamics; i++) Dynamics[i]->RenderAlpha(); // sam sprawdza, czy VBO; zmienia kontekst VBO! // EnvironmentReset(); +#else + for( auto dynamic : Dynamics ) { + // sam sprawdza, czy VBO; zmienia kontekst VBO! + dynamic->RenderAlpha(); + } +#endif }; void TTrack::RenderDynSounds() { // odtwarzanie dźwięków pojazdów jest niezależne od ich wyświetlania - for (int i = 0; i < iNumDynamics; i++) +#ifdef EU07_USE_OLD_TTRACK_DYNAMICS_ARRAY + for( int i = 0; i < iNumDynamics; i++ ) Dynamics[i]->RenderSounds(); +#else + for( auto dynamic : Dynamics ) { + dynamic->RenderSounds(); + } +#endif }; //--------------------------------------------------------------------------- bool TTrack::SetConnections(int i) @@ -2906,8 +2993,15 @@ TTrack * TTrack::RaAnimate() SwitchExtension->vTrans; // SwitchExtension->Segments[0]->FastGetPoint(0.5); Segment->Init(middle + vector3(sina, 0.0, cosa), middle - vector3(sina, 0.0, cosa), 5.0); // nowy odcinek - for (int i = 0; i < iNumDynamics; i++) +#ifdef EU07_USE_OLD_TTRACK_DYNAMICS_ARRAY + for( int i = 0; i < iNumDynamics; i++ ) Dynamics[i]->Move(0.000001); // minimalny ruch, aby przeliczyć pozycję i +#else + for( auto dynamic : Dynamics ) { + // minimalny ruch, aby przeliczyć pozycję + dynamic->Move( 0.000001 ); + } +#endif // kąty if (Global::bUseVBO) { // dla OpenGL 1.4 odświeży się cały sektor, w późniejszych poprawiamy fragment @@ -2939,8 +3033,15 @@ TTrack * TTrack::RaAnimate() //--------------------------------------------------------------------------- void TTrack::RadioStop() { // przekazanie pojazdom rozkazu zatrzymania +#ifdef EU07_USE_OLD_TTRACK_DYNAMICS_ARRAY for (int i = 0; i < iNumDynamics; i++) Dynamics[i]->RadioStop(); +#else + for( auto dynamic : Dynamics ) { + dynamic->RadioStop(); + } +#endif + }; double TTrack::WidthTotal() diff --git a/Track.h b/Track.h index 437aeabe..6382f0f0 100644 --- a/Track.h +++ b/Track.h @@ -94,7 +94,9 @@ class TSwitchExtension private: }; +#ifdef EU07_USE_OLD_TTRACK_DYNAMICS_ARRAY const int iMaxNumDynamics = 40; // McZapkie-100303 +#endif class TIsolated { // obiekt zbierający zajętości z kilku odcinków @@ -149,8 +151,13 @@ class TTrack : public Resource TGroundNode * pMyNode = nullptr; // Ra: proteza, żeby tor znał swoją nazwę TODO: odziedziczyć TTrack z TGroundNode public: +#ifdef EU07_USE_OLD_TTRACK_DYNAMICS_ARRAY int iNumDynamics = 0; TDynamicObject *Dynamics[iMaxNumDynamics]; +#else + typedef std::deque dynamics_sequence; + dynamics_sequence Dynamics; +#endif int iEvents = 0; // Ra: flaga informująca o obecności eventów TEvent *evEventall0 = nullptr; // McZapkie-140302: wyzwalany gdy pojazd stoi TEvent *evEventall1 = nullptr; @@ -196,7 +203,11 @@ class TTrack : public Resource TTrack * NullCreate(int dir); inline bool IsEmpty() { +#ifdef EU07_USE_OLD_TTRACK_DYNAMICS_ARRAY return (iNumDynamics <= 0); +#else + return Dynamics.empty(); +#endif }; void ConnectPrevPrev(TTrack *pNewPrev, int typ); void ConnectPrevNext(TTrack *pNewPrev, int typ);