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

Merge branch 'tmj-dev' into nogfx

Browse Source
This commit is contained in:
milek7
2017-08-21 13:16:36 +02:00
parent 5104d7f4fd 318dd9a0fe
commit 2829a8430c
13 changed files with 757 additions and 922 deletions
Download Patch File Download Diff File Expand all files Collapse all files

2
.gitignore vendored
View File

@@ -73,3 +73,5 @@ ref/
builds/build_*
builds/*.zip
builds/deps_*
CMakeLists.txt.user

965
Driver.cpp
View File

File diff suppressed because it is too large Load Diff

6
Driver.h
View File

@@ -144,7 +144,7 @@ class TSpeedPos
public:
void Clear();
bool Update(vector3 *p, vector3 *dir, double &len);
bool Update(vector3 *p, vector3 *dir, double &len, TOrders const &Orders );
bool Set(TEvent *e, double d, TOrders order = Wait_for_orders);
void Set(TTrack *t, double d, int f);
std::string TableText();
@@ -195,8 +195,8 @@ class TController
double fDriverBraking = 0.0; // po pomnożeniu przez v^2 [km/h] daje ~drogę hamowania [m]
double fDriverDist = 0.0; // dopuszczalna odległość podjechania do przeszkody
double fVelMax = -1.0; // maksymalna prędkość składu (sprawdzany każdy pojazd)
double fBrakeDist = 0.0; // przybliżona droga hamowania
public:
double fBrakeDist = 0.0; // przybliżona droga hamowania
double BrakeAccFactor();
double fBrakeReaction = 1.0; //opóźnienie zadziałania hamulca - czas w s / (km/h)
double fAccThreshold = 0.0; // próg opóźnienia dla zadziałania hamulca
@@ -270,8 +270,6 @@ class TController
OrderTop = 0; // rozkaz aktualny oraz wolne miejsce do wstawiania nowych
std::ofstream LogFile; // zapis parametrow fizycznych
std::ofstream AILogFile; // log AI
bool MaxVelFlag = false;
bool MinVelFlag = false; // Ra: to nie jest używane
int iDirection = 0; // kierunek jazdy względem sprzęgów pojazdu, w którym siedzi AI (1=przód,-1=tył)
int iDirectionOrder = 0; //żadany kierunek jazdy (służy do zmiany kierunku)
int iVehicleCount = -2; // wartość neutralna // ilość pojazdów do odłączenia albo zabrania ze składu (-1=wszystkie)

479
DynObj.cpp
View File

@@ -1127,51 +1127,69 @@ void TDynamicObject::ABuCheckMyTrack()
}
// Ra: w poniższej funkcji jest problem ze sprzęgami
TDynamicObject * TDynamicObject::ABuFindObject(TTrack *Track, int ScanDir,
BYTE &CouplFound, double &dist)
TDynamicObject *
TDynamicObject::ABuFindObject( int &Foundcoupler, double &Distance, TTrack *Track, int const Direction, int const Mycoupler )
{ // Zwraca wskaźnik najbliższego obiektu znajdującego się
// na torze w określonym kierunku, ale tylko wtedy, kiedy
// obiekty mogą się zderzyć, tzn. nie mijają się.
// WE:
// Track - tor, na ktorym odbywa sie poszukiwanie,
// Direction - kierunek szukania na torze (+1:w stronę Point2, -1:w stronę Point1)
// Mycoupler - nr sprzegu obiektu szukajacego;
// WY:
// wskaznik do znalezionego obiektu.
// Foundcoupler - nr sprzegu znalezionego obiektu
// Distance - distance to found object
// WE: Track - tor, na ktorym odbywa sie poszukiwanie,
// MyPointer - wskaznik do obiektu szukajacego. //Ra: zamieniłem na "this"
// ScanDir - kierunek szukania na torze (+1:w stronę Point2, -1:w stronę
// Point1)
// MyScanDir - kierunek szukania obiektu szukajacego (na jego torze); Ra:
// nie potrzebne
// MyCouplFound - nr sprzegu obiektu szukajacego; Ra: nie potrzebne
// WY: wskaznik do znalezionego obiektu.
// CouplFound - nr sprzegu znalezionego obiektu
if( false == Track->Dynamics.empty() )
{ // sens szukania na tym torze jest tylko, gdy są na nim pojazdy
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
TDynamicObject *collider = nullptr;
// if (Track->iNumDynamics>1)
// iMinDist+=0; //tymczasowo pułapka
if (MyTrack == Track) // gdy szukanie na tym samym torze
MyTranslation = RaTranslationGet(); // położenie wózka względem Point1 toru
else // gdy szukanie na innym torze
if (ScanDir > 0)
MyTranslation = 0; // szukanie w kierunku Point2 (od zera) - jesteśmy w Point1
else
MyTranslation = MinDist; // szukanie w kierunku Point1 (do zera) - jesteśmy w Point2
if (ScanDir >= 0)
{ // jeśli szukanie w kierunku Point2
for( auto dynamic : Track->Dynamics ) {
// pętla po pojazdach
if( dynamic == this ) {
// szukający się nie liczy
continue;
if( true == Track->Dynamics.empty() ) {
// sens szukania na tym torze jest tylko, gdy są na nim pojazdy
Distance += Track->Length(); // doliczenie długości odcinka do przeskanowanej odległości
return nullptr; // nie ma pojazdów na torze, to jest NULL
}
double distance = Track->Length(); // najmniejsza znaleziona odleglość (zaczynamy od długości toru)
double myposition; // pozycja szukającego na torze
TDynamicObject *foundobject = nullptr;
if( MyTrack == Track ) {
// gdy szukanie na tym samym torze
myposition = RaTranslationGet(); // położenie wózka względem Point1 toru
}
else {
// gdy szukanie na innym torze
if( Direction > 0 ) {
// szukanie w kierunku Point2 (od zera) - jesteśmy w Point1
myposition = 0;
}
else {
// szukanie w kierunku Point1 (do zera) - jesteśmy w Point2
myposition = distance;
}
}
double objectposition; // robocza odległość od kolejnych pojazdów na danym odcinku
for( auto dynamic : Track->Dynamics ) {
if( dynamic == this ) { continue; } // szukający się nie liczy
if( Direction > 0 ) {
// jeśli szukanie w kierunku Point2
objectposition = ( dynamic->RaTranslationGet() ) - myposition; // odległogłość tamtego od szukającego
if( ( objectposition > 0 )
&& ( objectposition < distance ) ) {
// gdy jest po właściwej stronie i bliżej niż jakiś wcześniejszy
Foundcoupler = ( dynamic->RaDirectionGet() > 0 ) ? 1 : 0; // to, bo (ScanDir>=0)
}
else { continue; }
}
else {
objectposition = myposition - ( dynamic->RaTranslationGet() ); //???-przesunięcie wózka względem Point1 toru
if( ( objectposition > 0 )
&& ( objectposition < distance ) ) {
Foundcoupler = ( dynamic->RaDirectionGet() > 0 ) ? 0 : 1; // odwrotnie, bo (ScanDir<0)
}
else { 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
@@ -1179,76 +1197,26 @@ TDynamicObject * TDynamicObject::ABuFindObject(TTrack *Track, int ScanDir,
// 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 );
double relativeoffset; // wzajemna odległość poprzeczna
if( Foundcoupler != Mycoupler ) {
// facing the same direction
relativeoffset = std::abs( MoverParameters->OffsetTrackH - dynamic->MoverParameters->OffsetTrackH );
}
else {
// dla CouplFound=0 są zwroty przeciwne - przesunięcia sumują się
RelOffsetH = ( MoverParameters->OffsetTrackH + dynamic->MoverParameters->OffsetTrackH );
relativeoffset = std::abs( MoverParameters->OffsetTrackH + dynamic->MoverParameters->OffsetTrackH );
}
if( RelOffsetH < 0 ) {
RelOffsetH = -RelOffsetH;
}
if( RelOffsetH + RelOffsetH > MoverParameters->Dim.W + dynamic->MoverParameters->Dim.W ) {
if( relativeoffset + relativeoffset > 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
// 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
foundobject = dynamic; // potencjalna kolizja
distance = objectposition; // odleglość pomiędzy aktywnymi osiami pojazdów
}
}
}
else //(ScanDir<0)
{
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
}
}
}
dist += MinDist; // doliczenie odległości przeszkody albo długości odcinka do przeskanowanej odległości
return collider;
}
dist += Track->Length(); // doliczenie długości odcinka do przeskanowanej
// odległości
return nullptr; // nie ma pojazdów na torze, to jest NULL
Distance += distance; // doliczenie odległości przeszkody albo długości odcinka do przeskanowanej odległości
return foundobject;
}
int TDynamicObject::DettachStatus(int dir)
@@ -1295,9 +1263,9 @@ void TDynamicObject::CouplersDettach(double MinDist, int MyScanDir)
{
if (PrevConnected) // pojazd od strony sprzęgu 0
{
if (MoverParameters->Couplers[0].CoupleDist >
MinDist) // sprzęgi wirtualne zawsze przekraczają
{
if (MoverParameters->Couplers[0].CoupleDist > MinDist) {
// sprzęgi wirtualne zawsze przekraczają
if ((PrevConnectedNo ? PrevConnected->NextConnected :
PrevConnected->PrevConnected) == this)
{ // Ra: nie rozłączamy znalezionego, jeżeli nie do nas
@@ -1315,10 +1283,11 @@ void TDynamicObject::CouplersDettach(double MinDist, int MyScanDir)
PrevConnected->NextConnected = NULL;
}
}
// za to zawsze odłączamy siebie
PrevConnected = NULL;
PrevConnectedNo = 2; // sprzęg 0 nie podłączony
MoverParameters->Couplers[0].Connected = NULL;
MoverParameters->Couplers[0].Connected = nullptr;
}
}
}
@@ -1326,9 +1295,9 @@ void TDynamicObject::CouplersDettach(double MinDist, int MyScanDir)
{
if (NextConnected) // pojazd od strony sprzęgu 1
{
if (MoverParameters->Couplers[1].CoupleDist >
MinDist) // sprzęgi wirtualne zawsze przekraczają
{
if (MoverParameters->Couplers[1].CoupleDist > MinDist) {
// sprzęgi wirtualne zawsze przekraczają
if ((NextConnectedNo ? NextConnected->NextConnected :
NextConnected->PrevConnected) == this)
{ // Ra: nie rozłączamy znalezionego, jeżeli nie do nas
@@ -1346,180 +1315,147 @@ void TDynamicObject::CouplersDettach(double MinDist, int MyScanDir)
NextConnected->NextConnected = NULL;
}
}
NextConnected = NULL;
NextConnectedNo = 2; // sprzęg 1 nie podłączony
MoverParameters->Couplers[1].Connected = NULL;
MoverParameters->Couplers[1].Connected = nullptr;
}
}
}
}
void TDynamicObject::ABuScanObjects(int ScanDir, double ScanDist)
void TDynamicObject::ABuScanObjects( int Direction, double Distance )
{ // skanowanie toru w poszukiwaniu kolidujących pojazdów
// ScanDir - określa kierunek poszukiwania zależnie od zwrotu prędkości
// pojazdu
// ScanDir=1 - od strony Coupler0, ScanDir=-1 - od strony Coupler1
int MyScanDir = ScanDir; // zapamiętanie kierunku poszukiwań na torze
// początkowym, względem sprzęgów
TTrackFollower *FirstAxle = (MyScanDir > 0 ? &Axle0 : &Axle1); // można by to trzymać w trainset
TTrack *Track = FirstAxle->GetTrack(); // tor na którym "stoi" skrajny wózek
int initialdirection = Direction; // zapamiętanie kierunku poszukiwań na torze początkowym, względem sprzęgów
TTrackFollower *firstaxle = (initialdirection > 0 ? &Axle0 : &Axle1); // można by to trzymać w trainset
TTrack *track = firstaxle->GetTrack(); // tor na którym "stoi" skrajny wózek
// (może być inny niż tor pojazdu)
if (FirstAxle->GetDirection() < 0) // czy oś jest ustawiona w stronę Point1?
ScanDir = -ScanDir; // jeśli tak, to kierunek szukania będzie przeciwny
if( firstaxle->GetDirection() < 0 ) {
// czy oś jest ustawiona w stronę Point1?
Direction = -Direction; // jeśli tak, to kierunek szukania będzie przeciwny
}
// (teraz względem
// toru)
BYTE MyCouplFound; // numer sprzęgu do podłączenia w obiekcie szukajacym
MyCouplFound = (MyScanDir < 0) ? 1 : 0;
BYTE CouplFound; // numer sprzęgu w znalezionym obiekcie (znaleziony wypełni)
TDynamicObject *FoundedObj; // znaleziony obiekt
double ActDist = 0; // przeskanowana odleglość; odległość do zawalidrogi
FoundedObj = ABuFindObject(Track, ScanDir, CouplFound,
ActDist); // zaczynamy szukać na tym samym torze
int const mycoupler = ( initialdirection < 0 ? 1 : 0 ); // numer sprzęgu do podłączenia w obiekcie szukajacym
int foundcoupler { -1 }; // numer sprzęgu w znalezionym obiekcie (znaleziony wypełni)
double distance = 0; // przeskanowana odleglość; odległość do zawalidrogi
TDynamicObject *foundobject = ABuFindObject( foundcoupler, distance, track, Direction, mycoupler ); // zaczynamy szukać na tym samym torze
/*
if (FoundedObj) //jak coś znajdzie, to śledzimy
{//powtórzenie wyszukiwania tylko do zastawiania pułepek podczas testów
if (ABuGetDirection()<0) ScanDir=ScanDir; //ustalenie kierunku względem toru
FoundedObj=ABuFindObject(Track,this,ScanDir,CouplFound);
}
*/
if (DebugModeFlag)
if (FoundedObj) // kod służący do logowania błędów
if (CouplFound == 0)
{
if (FoundedObj->PrevConnected)
if (FoundedObj->PrevConnected != this) // odświeżenie tego samego się nie liczy
WriteLog("0! Coupler warning on " + asName + ":" +
to_string(MyCouplFound) + " - " + FoundedObj->asName +
":0 connected to " + FoundedObj->PrevConnected->asName + ":" +
to_string(FoundedObj->PrevConnectedNo));
}
else
{
if (FoundedObj->NextConnected)
if (FoundedObj->NextConnected != this) // odświeżenie tego samego się nie liczy
WriteLog("0! Coupler warning on " + asName + ":" +
to_string(MyCouplFound) + " - " + FoundedObj->asName +
":1 connected to " + FoundedObj->NextConnected->asName + ":" +
to_string(FoundedObj->NextConnectedNo));
}
if (FoundedObj == NULL) // jeśli nie ma na tym samym, szukamy po okolicy
{ // szukanie najblizszego toru z jakims obiektem
if( foundobject == nullptr ) {
// jeśli nie ma na tym samym, szukamy po okolicy szukanie najblizszego toru z jakims obiektem
// praktycznie przeklejone z TraceRoute()...
// double CurrDist=0; //aktualna dlugosc toru
if (ScanDir >= 0) // uwzględniamy kawalek przeanalizowanego wcześniej toru
ActDist = Track->Length() - FirstAxle->GetTranslation(); // odległość osi od Point2 toru
if (Direction >= 0) // uwzględniamy kawalek przeanalizowanego wcześniej toru
distance = track->Length() - firstaxle->GetTranslation(); // odległość osi od Point2 toru
else
ActDist = FirstAxle->GetTranslation(); // odległość osi od Point1 toru
while (ActDist < ScanDist)
{
// ActDist+=CurrDist; //odległość już przeanalizowana
if (ScanDir > 0) // w kierunku Point2 toru
{
if (Track ? Track->iNextDirection :
false) // jeśli następny tor jest podpięty od Point2
ScanDir = -ScanDir; // to zmieniamy kierunek szukania na tym torze
Track = Track->CurrentNext(); // potem dopiero zmieniamy wskaźnik
distance = firstaxle->GetTranslation(); // odległość osi od Point1 toru
while (distance < Distance) {
if (Direction > 0) {
// w kierunku Point2 toru
if( track ?
track->iNextDirection :
false ) {
// jeśli następny tor jest podpięty od Point2
Direction = -Direction; // to zmieniamy kierunek szukania na tym torze
}
else // w kierunku Point1
{
if (Track ? !Track->iPrevDirection :
true) // jeśli poprzedni tor nie jest podpięty od Point2
ScanDir = -ScanDir; // to zmieniamy kierunek szukania na tym torze
Track = Track->CurrentPrev(); // potem dopiero zmieniamy wskaźnik
track = track->CurrentNext(); // potem dopiero zmieniamy wskaźnik
}
if (Track)
{ // jesli jest kolejny odcinek toru
// CurrDist=Track->Length(); //doliczenie tego toru do przejrzanego
// dystandu
FoundedObj = ABuFindObject(Track, ScanDir, CouplFound,
ActDist); // przejrzenie pojazdów tego toru
if (FoundedObj)
{
// ActDist=ScanDist; //wyjście z pętli poszukiwania
else {
// w kierunku Point1
if( track ?
!track->iPrevDirection :
true ) {
// jeśli poprzedni tor nie jest podpięty od Point2
Direction = -Direction; // to zmieniamy kierunek szukania na tym torze
}
track = track->CurrentPrev(); // potem dopiero zmieniamy wskaźnik
}
if (track) {
// jesli jest kolejny odcinek toru
foundobject = ABuFindObject(foundcoupler, distance, track, Direction, mycoupler); // przejrzenie pojazdów tego toru
if (foundobject) {
break;
}
}
else // jeśli toru nie ma, to wychodzimy
{
ActDist = ScanDist + 1.0; // koniec przeglądania torów
else {
// jeśli toru nie ma, to wychodzimy
distance = Distance + 1.0; // koniec przeglądania torów
break;
}
}
} // Koniec szukania najbliższego toru z jakimś obiektem.
// teraz odczepianie i jeśli coś się znalazło, doczepianie.
if (MyScanDir > 0 ? PrevConnected : NextConnected)
if ((MyScanDir > 0 ? PrevConnected : NextConnected) != FoundedObj)
CouplersDettach(1.0, MyScanDir); // odłączamy, jeśli dalej niż metr
// i łączenie sprzęgiem wirtualnym
if (FoundedObj)
{ // siebie można bezpiecznie podłączyć jednostronnie do
// znalezionego
MoverParameters->Attach(MyCouplFound, CouplFound, FoundedObj->MoverParameters,
ctrain_virtual);
// MoverParameters->Couplers[MyCouplFound].Render=false; //wirtualnego nie
// renderujemy
if (MyCouplFound == 0)
{
PrevConnected = FoundedObj; // pojazd od strony sprzęgu 0
PrevConnectedNo = CouplFound;
auto connectedobject = (
initialdirection > 0 ?
PrevConnected :
NextConnected );
if( ( connectedobject != nullptr )
&& ( connectedobject != foundobject ) ) {
// odłączamy, jeśli dalej niż metr i łączenie sprzęgiem wirtualnym
CouplersDettach( 1.0, initialdirection );
}
else
{
NextConnected = FoundedObj; // pojazd od strony sprzęgu 1
NextConnectedNo = CouplFound;
if (foundobject) {
// siebie można bezpiecznie podłączyć jednostronnie do znalezionego
MoverParameters->Attach( mycoupler, foundcoupler, foundobject->MoverParameters, coupling::faux );
// MoverParameters->Couplers[MyCouplFound].Render=false; //wirtualnego nie renderujemy
if( mycoupler == TMoverParameters::side::front ) {
PrevConnected = foundobject; // pojazd od strony sprzęgu 0
PrevConnectedNo = foundcoupler;
}
if (FoundedObj->MoverParameters->Couplers[CouplFound].CouplingFlag == ctrain_virtual)
{ // Ra: wpinamy się wirtualnym tylko jeśli znaleziony
// ma wirtualny sprzęg
FoundedObj->MoverParameters->Attach(CouplFound, MyCouplFound, this->MoverParameters,
ctrain_virtual);
if (CouplFound == 0) // jeśli widoczny sprzęg 0 znalezionego
{
if (DebugModeFlag)
if (FoundedObj->PrevConnected)
if (FoundedObj->PrevConnected != this)
WriteLog("1! Coupler warning on " + asName + ":" +
to_string(MyCouplFound) + " - " + FoundedObj->asName +
":0 connected to " + FoundedObj->PrevConnected->asName + ":" +
to_string(FoundedObj->PrevConnectedNo));
FoundedObj->PrevConnected = this;
FoundedObj->PrevConnectedNo = MyCouplFound;
else {
NextConnected = foundobject; // pojazd od strony sprzęgu 1
NextConnectedNo = foundcoupler;
}
else // jeśli widoczny sprzęg 1 znalezionego
{
if (DebugModeFlag)
if (FoundedObj->NextConnected)
if (FoundedObj->NextConnected != this)
WriteLog("1! Coupler warning on " + asName + ":" +
to_string(MyCouplFound) + " - " + FoundedObj->asName +
":1 connected to " + FoundedObj->NextConnected->asName + ":" +
to_string(FoundedObj->NextConnectedNo));
FoundedObj->NextConnected = this;
FoundedObj->NextConnectedNo = MyCouplFound;
if( foundobject->MoverParameters->Couplers[ foundcoupler ].CouplingFlag == coupling::faux ) {
// Ra: wpinamy się wirtualnym tylko jeśli znaleziony ma wirtualny sprzęg
foundobject->MoverParameters->Attach( foundcoupler, mycoupler, this->MoverParameters, coupling::faux );
if( foundcoupler == TMoverParameters::side::front ) {
// jeśli widoczny sprzęg 0 znalezionego
if( ( DebugModeFlag )
&& ( foundobject->PrevConnected )
&& ( foundobject->PrevConnected != this ) ) {
WriteLog( "ScanObjects(): formed virtual link between \"" + asName + "\" (coupler " + to_string( mycoupler ) + ") and \"" + foundobject->asName + "\" (coupler " + to_string( foundcoupler ) + ")" );
}
foundobject->PrevConnected = this;
foundobject->PrevConnectedNo = mycoupler;
}
else {
// jeśli widoczny sprzęg 1 znalezionego
if( ( DebugModeFlag )
&& ( foundobject->NextConnected )
&& ( foundobject->NextConnected != this ) ) {
WriteLog( "ScanObjects(): formed virtual link between \"" + asName + "\" (coupler " + to_string( mycoupler ) + ") and \"" + foundobject->asName + "\" (coupler " + to_string( foundcoupler ) + ")" );
}
foundobject->NextConnected = this;
foundobject->NextConnectedNo = mycoupler;
}
}
// Ra: jeśli dwa samochody się mijają na odcinku przed zawrotką, to
// odległość między nimi
// nie może być liczona w linii prostej!
fTrackBlock = MoverParameters->Couplers[MyCouplFound]
.CoupleDist; // odległość do najbliższego pojazdu w linii prostej
if (Track->iCategoryFlag > 1) // jeśli samochód
if (ActDist > MoverParameters->Dim.L +
FoundedObj->MoverParameters->Dim
.L) // przeskanowana odległość większa od długości pojazdów
// odległość do najbliższego pojazdu w linii prostej
// Ra: jeśli dwa samochody się mijają na odcinku przed zawrotką, to odległość między nimi nie może być liczona w linii prostej!
fTrackBlock = MoverParameters->Couplers[mycoupler].CoupleDist;
if( track->iCategoryFlag & 254 ) {
// jeśli samochód
if( distance > MoverParameters->Dim.L + foundobject->MoverParameters->Dim.L ) {
// przeskanowana odległość większa od długości pojazdów
// else if (ActDist<ScanDist) //dla samochodów musi być uwzględniona
// droga do
// zawrócenia
fTrackBlock = ActDist; // ta odległość jest wiecej warta
// if (fTrackBlock<500.0)
// WriteLog("Collision of "+AnsiString(fTrackBlock)+"m detected by
// "+asName+":"+AnsiString(MyCouplFound)+" with "+FoundedObj->asName);
fTrackBlock = distance; // ta odległość jest wiecej warta
}
else // nic nie znalezione, to nie ma przeszkód
}
}
else {
// nic nie znalezione, to nie ma przeszkód
fTrackBlock = 10000.0;
}
}
//----------ABu: koniec skanowania pojazdow
@@ -1541,7 +1477,6 @@ TDynamicObject::TDynamicObject()
bBrakeAcc = false;
NextConnected = PrevConnected = NULL;
NextConnectedNo = PrevConnectedNo = 2; // ABu: Numery sprzegow. 2=nie podłączony
CouplCounter = 50; // będzie sprawdzać na początku
asName = "";
bEnabled = true;
MyTrack = NULL;
@@ -1892,14 +1827,20 @@ TDynamicObject::Init(std::string Name, // nazwa pojazdu, np. "EU07-424"
if (MoverParameters->CategoryFlag & 2) // jeśli samochód
{ // ustawianie samochodow na poboczu albo na środku drogi
if (Track->fTrackWidth < 3.5) // jeśli droga wąska
if( Track->fTrackWidth < 3.5 ) // jeśli droga wąska
MoverParameters->OffsetTrackH = 0.0; // to stawiamy na środku, niezależnie od stanu
// ruchu
else if (driveractive) // od 3.5m do 8.0m jedzie po środku pasa, dla
else if( driveractive ) {// od 3.5m do 8.0m jedzie po środku pasa, dla
// szerszych w odległości
// 1.5m
MoverParameters->OffsetTrackH =
Track->fTrackWidth <= 8.0 ? -Track->fTrackWidth * 0.25 : -1.5;
auto const lanefreespace = 0.5 * Track->fTrackWidth - MoverParameters->Dim.W;
MoverParameters->OffsetTrackH = (
lanefreespace > 1.5 ?
-0.5 * MoverParameters->Dim.W - 0.75 : // wide road, keep near centre with safe margin
( lanefreespace > 0.1 ?
-0.25 * Track->fTrackWidth : // narrow fit, stay on the middle
-0.5 * MoverParameters->Dim.W - 0.075 ) ); // too narrow, just keep some minimal clearance
}
else // jak stoi, to kołem na poboczu i pobieramy szerokość razem z
// poboczem, ale nie z
// chodnikiem
@@ -3481,45 +3422,6 @@ bool TDynamicObject::Update(double dt, double dt1)
toggle_lights();
}
// ABu-160303 sledzenie toru przed obiektem: *******************************
// Z obserwacji: v>0 -> Coupler 0; v<0 ->coupler1 (Ra: prędkość jest związana
// z pojazdem)
// Rozroznienie jest tutaj, zeby niepotrzebnie nie skakac do funkcji. Nie jest
// uzaleznione
// od obecnosci AI, zeby uwzglednic np. jadace bez lokomotywy wagony.
// Ra: można by przenieść na poziom obiektu reprezentującego skład, aby nie
// sprawdzać środkowych
if (CouplCounter > 25) // licznik, aby nie robić za każdym razem
{ // poszukiwanie czegoś do zderzenia się
fTrackBlock = 10000.0; // na razie nie ma przeszkód (na wypadek nie
// uruchomienia skanowania)
// jeśli nie ma zwrotnicy po drodze, to tylko przeliczyć odległość?
if (MoverParameters->V > 0.03) //[m/s] jeśli jedzie do przodu (w kierunku Coupler 0)
{
if (MoverParameters->Couplers[0].CouplingFlag ==
ctrain_virtual) // brak pojazdu podpiętego?
{
ABuScanObjects(1, fScanDist); // szukanie czegoś do podłączenia
// WriteLog(asName+" - block 0: "+AnsiString(fTrackBlock));
}
}
else if (MoverParameters->V < -0.03) //[m/s] jeśli jedzie do tyłu (w kierunku Coupler 1)
if (MoverParameters->Couplers[1].CouplingFlag ==
ctrain_virtual) // brak pojazdu podpiętego?
{
ABuScanObjects(-1, fScanDist);
// WriteLog(asName+" - block 1: "+AnsiString(fTrackBlock));
}
CouplCounter = Random(20); // ponowne sprawdzenie po losowym czasie
}
if (MoverParameters->Vel > 0.1) //[km/h]
++CouplCounter; // jazda sprzyja poszukiwaniu połączenia
else
{
CouplCounter = 25; // a bezruch nie, ale trzeba zaktualizować odległość, bo
// zawalidroga może
// sobie pojechać
}
if (MoverParameters->DerailReason > 0)
{
switch (MoverParameters->DerailReason)
@@ -5138,7 +5040,6 @@ void TDynamicObject::RaLightsSet(int head, int rear)
int TDynamicObject::DirectionSet(int d)
{ // ustawienie kierunku w składzie (wykonuje AI)
iDirection = d > 0 ? 1 : 0; // d:1=zgodny,-1=przeciwny; iDirection:1=zgodny,0=przeciwny;
CouplCounter = 20; //żeby normalnie skanować kolizje, to musi ruszyć z miejsca
if (MyTrack)
{ // podczas wczytywania wstawiane jest AI, ale może jeszcze nie
// być toru

4
DynObj.h
View File

@@ -352,15 +352,13 @@ public: // modele składowe pojazdu
// TTrackFollower Axle2; //dwie osie z czterech (te są protected)
// TTrackFollower Axle3; //Ra: wyłączyłem, bo kąty są liczone w Segment.cpp
int iNumAxles; // ilość osi
int CouplCounter;
std::string asModel;
public:
void ABuScanObjects(int ScanDir, double ScanDist);
protected:
TDynamicObject * ABuFindObject(TTrack *Track, int ScanDir, BYTE &CouplFound,
double &dist);
TDynamicObject *ABuFindObject( int &Foundcoupler, double &Distance, TTrack *Track, int const Direction, int const Mycoupler );
void ABuCheckMyTrack();
public:

10
Globals.cpp
View File

@@ -86,6 +86,7 @@ int Global::DynamicLightCount = 7;
bool Global::ScaleSpecularValues = false;
float Global::BaseDrawRange { 2500.f };
bool Global::RenderShadows { false };
bool Global::BasicRenderer { false };
Global::shadowtune_t Global::shadowtune = { 2048, 250.f, 250.f, 500.f };
bool Global::bRollFix = true; // czy wykonać przeliczanie przechyłki
bool Global::bJoinEvents = false; // czy grupować eventy o tych samych nazwach
@@ -541,6 +542,13 @@ void Global::ConfigParse(cParser &Parser)
Parser.getTokens();
Parser >> Global::ScaleSpecularValues;
}
else if( token == "gfxrenderer" ) {
// shadow render toggle
std::string gfxrenderer;
Parser.getTokens();
Parser >> gfxrenderer;
Global::BasicRenderer = ( gfxrenderer == "simple" );
}
else if( token == "shadows" ) {
// shadow render toggle
Parser.getTokens();
@@ -1301,7 +1309,7 @@ double Global::Min0RSpeed(double vel1, double vel2)
{
vel2 = std::numeric_limits<double>::max();
}
return Min0R(vel1, vel2);
return std::min(vel1, vel2);
};
double Global::CutValueToRange(double min, double value, double max)

1
Globals.h
View File

@@ -227,6 +227,7 @@ class Global
static float BaseDrawRange;
static int DynamicLightCount;
static bool ScaleSpecularValues;
static bool BasicRenderer;
static bool RenderShadows;
static struct shadowtune_t {
unsigned int map_size;

6
McZapkie/Mover.cpp
View File

@@ -4008,17 +4008,17 @@ double TMoverParameters::CouplerForce(int CouplerN, double dt)
// blablabla
// ABu: proby znalezienia problemu ze zle odbijajacymi sie skladami
//***if (Couplers[CouplerN].CouplingFlag=ctrain_virtual) and (newdist>0) then
//if (Couplers[CouplerN].CouplingFlag=ctrain_virtual) and (newdist>0) then
if ((Couplers[CouplerN].CouplingFlag == ctrain_virtual) && (Couplers[CouplerN].CoupleDist > 0))
{
CF = 0; // kontrola zderzania sie - OK
ScanCounter++;
if ((newdist > MaxDist) || ((ScanCounter > MaxCount) && (newdist > MinDist)))
//***if (tempdist>MaxDist) or ((ScanCounter>MaxCount)and(tempdist>MinDist)) then
//if (tempdist>MaxDist) or ((ScanCounter>MaxCount)and(tempdist>MinDist)) then
{ // zerwij kontrolnie wirtualny sprzeg
// Connected.Couplers[CNext].Connected:=nil; //Ra: ten podłączony niekoniecznie jest
// wirtualny
Couplers[CouplerN].Connected = NULL;
// Couplers[CouplerN].Connected = NULL;
ScanCounter = static_cast<int>(Random(500.0)); // Q: TODO: cy dobrze przetlumaczone?
// WriteLog(FloatToStr(ScanCounter));
}

17
Model3d.cpp
View File

@@ -1135,23 +1135,6 @@ TSubModel::convert( TGroundNode &Groundnode ) const {
}
}
// NOTE: leftover from static distance factor adjustment.
// TODO: get rid of it, once we have the dynamic adjustment code in place
void TSubModel::AdjustDist()
{ // aktualizacja odległości faz LoD, zależna od
// rozdzielczości pionowej oraz multisamplingu
if (fSquareMaxDist > 0.0)
fSquareMaxDist *= Global::fDistanceFactor;
if (fSquareMinDist > 0.0)
fSquareMinDist /= Global::fDistanceFactor;
// if (fNearAttenStart>0.0) fNearAttenStart*=Global::fDistanceFactor;
// if (fNearAttenEnd>0.0) fNearAttenEnd*=Global::fDistanceFactor;
if (Child)
Child->AdjustDist();
if (Next)
Next->AdjustDist();
};
void TSubModel::ColorsSet( glm::vec3 const &Ambient, glm::vec3 const &Diffuse, glm::vec3 const &Specular )
{ // ustawienie kolorów dla modelu terenu
f4Ambient = glm::vec4( Ambient, 1.0f );

1
Model3d.h
View File

@@ -209,7 +209,6 @@ public:
return m_material; }
void ParentMatrix(float4x4 *m);
float MaxY( float4x4 const &m );
void AdjustDist();
void deserialize(std::istream&);
void serialize(std::ostream&,

17
World.cpp
View File

@@ -1453,12 +1453,18 @@ TWorld::Update_UI() {
uitextline1 +=
"; C0:" +
( tmp->PrevConnected ?
tmp->PrevConnected->GetName() + ":" + to_string( tmp->MoverParameters->Couplers[ 0 ].CouplingFlag ) :
tmp->PrevConnected->GetName() + ":" + to_string( tmp->MoverParameters->Couplers[ 0 ].CouplingFlag ) + (
tmp->MoverParameters->Couplers[ 0 ].CouplingFlag == 0 ?
" (" + to_string( tmp->MoverParameters->Couplers[ 0 ].CoupleDist, 1 ) + " m)" :
"" ) :
"none" );
uitextline1 +=
" C1:" +
( tmp->NextConnected ?
tmp->NextConnected->GetName() + ":" + to_string( tmp->MoverParameters->Couplers[ 1 ].CouplingFlag ) :
tmp->NextConnected->GetName() + ":" + to_string( tmp->MoverParameters->Couplers[ 1 ].CouplingFlag ) + (
tmp->MoverParameters->Couplers[ 1 ].CouplingFlag == 0 ?
" (" + to_string( tmp->MoverParameters->Couplers[ 1 ].CoupleDist, 1 ) + " m)" :
"" ) :
"none" );
// equipment flags
@@ -1565,9 +1571,10 @@ TWorld::Update_UI() {
uitextline4 +=
"Driver: Vd=" + to_string( tmp->Mechanik->VelDesired, 0 )
+ " Ad=" + to_string( tmp->Mechanik->AccDesired, 2 )
+ " Ah=" + to_string(tmp->Mechanik->fAccThreshold, 2)
+ "@" + to_string(tmp->Mechanik->fBrake_a0[0], 2)
+ "+" + to_string(tmp->Mechanik->fBrake_a1[0], 2)
+ " Ah=" + to_string( tmp->Mechanik->fAccThreshold, 2 )
+ "@" + to_string( tmp->Mechanik->fBrake_a0[0], 2 )
+ "+" + to_string( tmp->Mechanik->fBrake_a1[0], 2 )
+ " Bd=" + to_string( tmp->Mechanik->fBrakeDist, 0 )
+ " Pd=" + to_string( tmp->Mechanik->ActualProximityDist, 0 )
+ " Vn=" + to_string( tmp->Mechanik->VelNext, 0 )
+ " VSl=" + to_string( tmp->Mechanik->VelSignalLast, 0 )

37
renderer.cpp
View File

@@ -99,7 +99,10 @@ opengl_renderer::Init( GLFWwindow *Window ) {
glEnable( GL_CULL_FACE ); // Cull back-facing triangles
glShadeModel( GL_SMOOTH ); // Enable Smooth Shading
m_geometry.units().texture = std::vector<GLint>{ m_normaltextureunit, m_diffusetextureunit };
m_geometry.units().texture = (
Global::BasicRenderer ?
std::vector<GLint>{ m_diffusetextureunit } :
std::vector<GLint>{ m_normaltextureunit, m_diffusetextureunit } );
m_textures.assign_units( m_helpertextureunit, m_shadowtextureunit, m_normaltextureunit, m_diffusetextureunit ); // TODO: add reflections unit
UILayer.set_unit( m_diffusetextureunit );
Active_Texture( m_diffusetextureunit );
@@ -253,7 +256,8 @@ opengl_renderer::Init( GLFWwindow *Window ) {
::glBindFramebufferEXT( GL_FRAMEBUFFER_EXT, 0 ); // switch back to primary render target for now
}
// environment cube map resources
if( true == m_framebuffersupport ) {
if( ( false == Global::BasicRenderer )
&& ( true == m_framebuffersupport ) ) {
// texture:
::glGenTextures( 1, &m_environmentcubetexture );
::glBindTexture( GL_TEXTURE_CUBE_MAP, m_environmentcubetexture );
@@ -1006,6 +1010,7 @@ void
opengl_renderer::switch_units( bool const Diffuse, bool const Shadows, bool const Reflections ) {
// helper texture unit.
if( m_helpertextureunit >= 0 ) {
Active_Texture( m_helpertextureunit );
if( ( true == Reflections )
|| ( ( true == Global::RenderShadows )
@@ -1041,6 +1046,7 @@ opengl_renderer::switch_units( bool const Diffuse, bool const Shadows, bool cons
}
}
// normal/reflection texture unit
if( m_normaltextureunit >= 0 ) {
if( true == Reflections ) {
Active_Texture( m_normaltextureunit );
@@ -1050,6 +1056,7 @@ opengl_renderer::switch_units( bool const Diffuse, bool const Shadows, bool cons
Active_Texture( m_normaltextureunit );
::glDisable( GL_TEXTURE_2D );
}
}
// diffuse texture unit.
// NOTE: toggle actually disables diffuse texture mapping, unlike setup counterpart
if( true == Diffuse ) {
@@ -1283,7 +1290,9 @@ void
opengl_renderer::Bind_Material( material_handle const Material ) {
auto const &material = m_materials.material( Material );
if( false == Global::BasicRenderer ) {
m_textures.bind( textureunit::normals, material.texture2 );
}
m_textures.bind( textureunit::diffuse, material.texture1 );
}
@@ -2042,8 +2051,8 @@ void
opengl_renderer::Render( TSubModel *Submodel ) {
if( ( Submodel->iVisible )
&& ( TSubModel::fSquareDist >= ( Submodel->fSquareMinDist / Global::fDistanceFactor ) )
&& ( TSubModel::fSquareDist <= ( Submodel->fSquareMaxDist * Global::fDistanceFactor ) ) ) {
&& ( TSubModel::fSquareDist >= ( Submodel->fSquareMinDist / std::max( 1.f, Global::fDistanceFactor ) ) )
&& ( TSubModel::fSquareDist <= ( Submodel->fSquareMaxDist * std::max( 1.f, Global::fDistanceFactor ) ) ) ) {
if( Submodel->iFlags & 0xC000 ) {
::glPushMatrix();
@@ -2703,8 +2712,8 @@ void
opengl_renderer::Render_Alpha( TSubModel *Submodel ) {
// renderowanie przezroczystych przez DL
if( ( Submodel->iVisible )
&& ( TSubModel::fSquareDist >= ( Submodel->fSquareMinDist / Global::fDistanceFactor ) )
&& ( TSubModel::fSquareDist <= ( Submodel->fSquareMaxDist * Global::fDistanceFactor ) ) ) {
&& ( TSubModel::fSquareDist >= ( Submodel->fSquareMinDist / std::max( 1.f, Global::fDistanceFactor ) ) )
&& ( TSubModel::fSquareDist <= ( Submodel->fSquareMaxDist * std::max( 1.f, Global::fDistanceFactor ) ) ) ) {
if( Submodel->iFlags & 0xC000 ) {
::glPushMatrix();
@@ -3188,17 +3197,29 @@ opengl_renderer::Init_caps() {
Global::DynamicLightCount = std::min( Global::DynamicLightCount, maxlights - 1 );
WriteLog( "Dynamic light amount capped at " + std::to_string( Global::DynamicLightCount ) + " (" + std::to_string(maxlights) + " lights total supported by the gfx card)" );
}
{
// select renderer mode
if( true == Global::BasicRenderer ) {
WriteLog( "Basic renderer selected, shadow and reflection mapping will be disabled" );
Global::RenderShadows = false;
m_diffusetextureunit = GL_TEXTURE0;
m_helpertextureunit = -1;
m_shadowtextureunit = -1;
m_normaltextureunit = -1;
}
else {
GLint maxtextureunits;
::glGetIntegerv( GL_MAX_COMBINED_TEXTURE_IMAGE_UNITS, &maxtextureunits );
if( maxtextureunits < 4 ) {
WriteLog( "Less than 4 texture units, shadow and reflection mapping will be disabled" );
Global::BasicRenderer = true;
Global::RenderShadows = false;
m_diffusetextureunit = GL_TEXTURE0;
m_shadowtextureunit = -1;
m_helpertextureunit = -1;
m_shadowtextureunit = -1;
m_normaltextureunit = -1;
}
}
if( Global::iMultisampling ) {
WriteLog( "Using multisampling x" + std::to_string( 1 << Global::iMultisampling ) );
}

2
version.h
View File

@@ -1,5 +1,5 @@
#pragma once
#define VERSION_MAJOR 17
#define VERSION_MINOR 815
#define VERSION_MINOR 820
#define VERSION_REVISION 0