eu07/maszyna
16
0
Fork 0
mirror of https://github.com/MaSzyna-EU07/maszyna.git synced 2026-07-25 12:29:19 +02:00
Code Issues 123 Wiki Activity

Format source code using clang-format

Browse Source
This commit is contained in:
Zbigniew Mandziejewicz
2015-04-03 22:00:22 +08:00
parent 91470458b4
commit cb19354db4
99 changed files with 40728 additions and 36059 deletions
Download Patch File Download Diff File Expand all files Collapse all files

195
AdvSound.cpp
View File

@@ -11,171 +11,166 @@
__fastcall TAdvancedSound::TAdvancedSound() __fastcall TAdvancedSound::TAdvancedSound()
{ {
// SoundStart=SoundCommencing=SoundShut= NULL; // SoundStart=SoundCommencing=SoundShut= NULL;
State=ss_Off; State = ss_Off;
fTime=0; fTime = 0;
fStartLength=0; fStartLength = 0;
fShutLength=0; fShutLength = 0;
} }
__fastcall TAdvancedSound::~TAdvancedSound() __fastcall TAdvancedSound::~TAdvancedSound()
{//Ra: stopowanie siê sypie { // Ra: stopowanie siê sypie
//SoundStart.Stop(); // SoundStart.Stop();
//SoundCommencing.Stop(); // SoundCommencing.Stop();
//SoundShut.Stop(); // SoundShut.Stop();
} }
void __fastcall TAdvancedSound::Free() void __fastcall TAdvancedSound::Free() {}
{
}
void __fastcall TAdvancedSound::Init(char *NameOn, char *Name, char *NameOff, double DistanceAttenuation, vector3 pPosition) void __fastcall TAdvancedSound::Init(char *NameOn, char *Name, char *NameOff,
double DistanceAttenuation, vector3 pPosition)
{ {
SoundStart.Init(NameOn,DistanceAttenuation,pPosition.x,pPosition.y,pPosition.z,true); SoundStart.Init(NameOn, DistanceAttenuation, pPosition.x, pPosition.y, pPosition.z, true);
SoundCommencing.Init(Name,DistanceAttenuation,pPosition.x,pPosition.y,pPosition.z,true); SoundCommencing.Init(Name, DistanceAttenuation, pPosition.x, pPosition.y, pPosition.z, true);
SoundShut.Init(NameOff,DistanceAttenuation,pPosition.x,pPosition.y,pPosition.z,true); SoundShut.Init(NameOff, DistanceAttenuation, pPosition.x, pPosition.y, pPosition.z, true);
fStartLength=SoundStart.GetWaveTime(); fStartLength = SoundStart.GetWaveTime();
fShutLength=SoundShut.GetWaveTime(); fShutLength = SoundShut.GetWaveTime();
SoundStart.AM=1.0; SoundStart.AM = 1.0;
SoundStart.AA=0.0; SoundStart.AA = 0.0;
SoundStart.FM=1.0; SoundStart.FM = 1.0;
SoundStart.FA=0.0; SoundStart.FA = 0.0;
SoundCommencing.AM=1.0; SoundCommencing.AM = 1.0;
SoundCommencing.AA=0.0; SoundCommencing.AA = 0.0;
SoundCommencing.FM=1.0; SoundCommencing.FM = 1.0;
SoundCommencing.FA=0.0; SoundCommencing.FA = 0.0;
defAM=1.0; defAM = 1.0;
defFM=1.0; defFM = 1.0;
SoundShut.AM=1.0; SoundShut.AM = 1.0;
SoundShut.AA=0.0; SoundShut.AA = 0.0;
SoundShut.FM=1.0; SoundShut.FM = 1.0;
SoundShut.FA=0.0; SoundShut.FA = 0.0;
} }
void __fastcall TAdvancedSound::Load(TQueryParserComp *Parser, vector3 pPosition) void __fastcall TAdvancedSound::Load(TQueryParserComp *Parser, vector3 pPosition)
{ {
AnsiString NameOn= Parser->GetNextSymbol().LowerCase(); AnsiString NameOn = Parser->GetNextSymbol().LowerCase();
AnsiString Name= Parser->GetNextSymbol().LowerCase(); AnsiString Name = Parser->GetNextSymbol().LowerCase();
AnsiString NameOff= Parser->GetNextSymbol().LowerCase(); AnsiString NameOff = Parser->GetNextSymbol().LowerCase();
double DistanceAttenuation= Parser->GetNextSymbol().ToDouble(); double DistanceAttenuation = Parser->GetNextSymbol().ToDouble();
Init(NameOn.c_str(),Name.c_str(),NameOff.c_str(),DistanceAttenuation,pPosition); Init(NameOn.c_str(), Name.c_str(), NameOff.c_str(), DistanceAttenuation, pPosition);
} }
void __fastcall TAdvancedSound::TurnOn(bool ListenerInside, vector3 NewPosition) void __fastcall TAdvancedSound::TurnOn(bool ListenerInside, vector3 NewPosition)
{ {
//hunter-311211: nie trzeba czekac na ponowne odtworzenie dzwieku, az sie wylaczy // hunter-311211: nie trzeba czekac na ponowne odtworzenie dzwieku, az sie wylaczy
if ((State==ss_Off || State==ss_ShuttingDown) && (SoundStart.AM>0)) if ((State == ss_Off || State == ss_ShuttingDown) && (SoundStart.AM > 0))
{ {
SoundStart.ResetPosition(); SoundStart.ResetPosition();
SoundCommencing.ResetPosition(); SoundCommencing.ResetPosition();
SoundStart.Play(1,0,ListenerInside,NewPosition); SoundStart.Play(1, 0, ListenerInside, NewPosition);
// SoundStart->SetVolume(-10000); // SoundStart->SetVolume(-10000);
State= ss_Starting; State = ss_Starting;
fTime= 0; fTime = 0;
} }
} }
void __fastcall TAdvancedSound::TurnOff(bool ListenerInside, vector3 NewPosition) void __fastcall TAdvancedSound::TurnOff(bool ListenerInside, vector3 NewPosition)
{ {
if ((State==ss_Commencing || State==ss_Starting) && (SoundShut.AM>0)) if ((State == ss_Commencing || State == ss_Starting) && (SoundShut.AM > 0))
{ {
SoundStart.Stop(); SoundStart.Stop();
SoundCommencing.Stop(); SoundCommencing.Stop();
SoundShut.ResetPosition(); SoundShut.ResetPosition();
SoundShut.Play(1,0,ListenerInside,NewPosition); SoundShut.Play(1, 0, ListenerInside, NewPosition);
State= ss_ShuttingDown; State = ss_ShuttingDown;
fTime= fShutLength; fTime = fShutLength;
// SoundShut->SetVolume(0); // SoundShut->SetVolume(0);
} }
} }
void __fastcall TAdvancedSound::Update(bool ListenerInside, vector3 NewPosition) void __fastcall TAdvancedSound::Update(bool ListenerInside, vector3 NewPosition)
{ {
if ((State==ss_Commencing) && (SoundCommencing.AM>0)) if ((State == ss_Commencing) && (SoundCommencing.AM > 0))
{ {
// SoundCommencing->SetFrequency(); // SoundCommencing->SetFrequency();
SoundShut.Stop(); //hunter-311211 SoundShut.Stop(); // hunter-311211
SoundCommencing.Play(1,DSBPLAY_LOOPING,ListenerInside,NewPosition); SoundCommencing.Play(1, DSBPLAY_LOOPING, ListenerInside, NewPosition);
} }
else else if (State == ss_Starting)
if (State==ss_Starting)
{ {
fTime+= Timer::GetDeltaTime(); fTime += Timer::GetDeltaTime();
// SoundStart->SetVolume(-1000*(4-fTime)/4); // SoundStart->SetVolume(-1000*(4-fTime)/4);
if (fTime>=fStartLength) if (fTime >= fStartLength)
{ {
State= ss_Commencing; State = ss_Commencing;
SoundCommencing.ResetPosition(); SoundCommencing.ResetPosition();
SoundCommencing.Play(1,DSBPLAY_LOOPING,ListenerInside,NewPosition); SoundCommencing.Play(1, DSBPLAY_LOOPING, ListenerInside, NewPosition);
SoundStart.Stop(); SoundStart.Stop();
} }
else else
SoundStart.Play(1,0,ListenerInside,NewPosition); SoundStart.Play(1, 0, ListenerInside, NewPosition);
} }
else else if (State == ss_ShuttingDown)
if (State==ss_ShuttingDown)
{ {
fTime-= Timer::GetDeltaTime(); fTime -= Timer::GetDeltaTime();
// SoundShut->SetVolume(-1000*(4-fTime)/4); // SoundShut->SetVolume(-1000*(4-fTime)/4);
if (fTime<=0) if (fTime <= 0)
{ {
State= ss_Off; State = ss_Off;
SoundShut.Stop(); SoundShut.Stop();
} }
else else
SoundShut.Play(1,0,ListenerInside,NewPosition); SoundShut.Play(1, 0, ListenerInside, NewPosition);
} }
} }
void __fastcall TAdvancedSound::UpdateAF(double A, double F, bool ListenerInside, vector3 NewPosition) void __fastcall TAdvancedSound::UpdateAF(double A, double F, bool ListenerInside,
{ //update, ale z amplituda i czestotliwoscia vector3 NewPosition)
if ((State==ss_Commencing) && (SoundCommencing.AM>0)) { // update, ale z amplituda i czestotliwoscia
if ((State == ss_Commencing) && (SoundCommencing.AM > 0))
{ {
SoundShut.Stop(); //hunter-311211 SoundShut.Stop(); // hunter-311211
SoundCommencing.Play(A,DSBPLAY_LOOPING,ListenerInside,NewPosition); SoundCommencing.Play(A, DSBPLAY_LOOPING, ListenerInside, NewPosition);
} }
else else if (State == ss_Starting)
if (State==ss_Starting)
{ {
fTime+= Timer::GetDeltaTime(); fTime += Timer::GetDeltaTime();
// SoundStart->SetVolume(-1000*(4-fTime)/4); // SoundStart->SetVolume(-1000*(4-fTime)/4);
if (fTime>=fStartLength) if (fTime >= fStartLength)
{ {
State= ss_Commencing; State = ss_Commencing;
SoundCommencing.ResetPosition(); SoundCommencing.ResetPosition();
SoundCommencing.Play(A,DSBPLAY_LOOPING,ListenerInside,NewPosition); SoundCommencing.Play(A, DSBPLAY_LOOPING, ListenerInside, NewPosition);
SoundStart.Stop(); SoundStart.Stop();
} }
else else
SoundStart.Play(A,0,ListenerInside,NewPosition); SoundStart.Play(A, 0, ListenerInside, NewPosition);
} }
else else if (State == ss_ShuttingDown)
if (State==ss_ShuttingDown)
{ {
fTime-= Timer::GetDeltaTime(); fTime -= Timer::GetDeltaTime();
// SoundShut->SetVolume(-1000*(4-fTime)/4); // SoundShut->SetVolume(-1000*(4-fTime)/4);
if (fTime<=0) if (fTime <= 0)
{ {
State= ss_Off; State = ss_Off;
SoundShut.Stop(); SoundShut.Stop();
} }
else else
SoundShut.Play(A,0,ListenerInside,NewPosition); SoundShut.Play(A, 0, ListenerInside, NewPosition);
} }
SoundCommencing.AdjFreq(F,Timer::GetDeltaTime()); SoundCommencing.AdjFreq(F, Timer::GetDeltaTime());
} }
void __fastcall TAdvancedSound::CopyIfEmpty(TAdvancedSound &s) void __fastcall TAdvancedSound::CopyIfEmpty(TAdvancedSound &s)
{//skopiowanie, gdyby by³ potrzebny, a nie zosta³ wczytany { // skopiowanie, gdyby by³ potrzebny, a nie zosta³ wczytany
if ((fStartLength>0.0)||(fShutLength>0.0)) return; //coœ jest if ((fStartLength > 0.0) || (fShutLength > 0.0))
SoundStart=s.SoundStart; return; // coœ jest
SoundCommencing=s.SoundCommencing; SoundStart = s.SoundStart;
SoundShut=s.SoundShut; SoundCommencing = s.SoundCommencing;
State=s.State; SoundShut = s.SoundShut;
fStartLength=s.fStartLength; State = s.State;
fShutLength=s.fShutLength; fStartLength = s.fStartLength;
defAM=s.defAM; fShutLength = s.fShutLength;
defFM=s.defFM; defAM = s.defAM;
defFM = s.defFM;
}; };

15
AdvSound.h
View File

@@ -6,10 +6,16 @@
#include "RealSound.h" #include "RealSound.h"
#include "QueryParserComp.hpp" #include "QueryParserComp.hpp"
typedef enum {ss_Off, ss_Starting, ss_Commencing, ss_ShuttingDown} TSoundState; typedef enum
{
ss_Off,
ss_Starting,
ss_Commencing,
ss_ShuttingDown
} TSoundState;
class TAdvancedSound class TAdvancedSound
{//klasa dŸwiêków maj¹cych pocz¹tek, dowolnie d³ugi œrodek oraz zakoñczenie (np. Rp1) { // klasa dŸwiêków maj¹cych pocz¹tek, dowolnie d³ugi œrodek oraz zakoñczenie (np. Rp1)
TRealSound SoundStart; TRealSound SoundStart;
TRealSound SoundCommencing; TRealSound SoundCommencing;
TRealSound SoundShut; TRealSound SoundShut;
@@ -20,10 +26,11 @@ class TAdvancedSound
double defAM; double defAM;
double defFM; double defFM;
public: public:
__fastcall TAdvancedSound(); __fastcall TAdvancedSound();
__fastcall ~TAdvancedSound(); __fastcall ~TAdvancedSound();
void __fastcall Init(char *NameOn, char *Name, char *NameOff, double DistanceAttenuation, vector3 pPosition); void __fastcall Init(char *NameOn, char *Name, char *NameOff, double DistanceAttenuation,
vector3 pPosition);
void __fastcall Load(TQueryParserComp *Parser, vector3 pPosition); void __fastcall Load(TQueryParserComp *Parser, vector3 pPosition);
void __fastcall TurnOn(bool ListenerInside, vector3 NewPosition); void __fastcall TurnOn(bool ListenerInside, vector3 NewPosition);
void __fastcall TurnOff(bool ListenerInside, vector3 NewPosition); void __fastcall TurnOff(bool ListenerInside, vector3 NewPosition);

61
AirCoupler.cpp
View File

@@ -7,64 +7,61 @@
#include "AirCoupler.h" #include "AirCoupler.h"
#include "Timer.h" #include "Timer.h"
__fastcall TAirCoupler::TAirCoupler() __fastcall TAirCoupler::TAirCoupler() { Clear(); }
{
Clear();
}
__fastcall TAirCoupler::~TAirCoupler() __fastcall TAirCoupler::~TAirCoupler() {}
{
}
int __fastcall TAirCoupler::GetStatus() int __fastcall TAirCoupler::GetStatus()
{//zwraca 1, jeœli istnieje model prosty, 2 gdy skoœny { // zwraca 1, jeœli istnieje model prosty, 2 gdy skoœny
int x=0; int x = 0;
if (pModelOn) x=1; if (pModelOn)
if (pModelxOn) x=2; x = 1;
if (pModelxOn)
x = 2;
return x; return x;
} }
void __fastcall TAirCoupler::Clear() void __fastcall TAirCoupler::Clear()
{//zerowanie wskaŸników { // zerowanie wskaŸników
pModelOn=NULL; pModelOn = NULL;
pModelOff=NULL; pModelOff = NULL;
pModelxOn=NULL; pModelxOn = NULL;
bOn=false; bOn = false;
bxOn=false; bxOn = false;
} }
void __fastcall TAirCoupler::Init(AnsiString asName, TModel3d *pModel) void __fastcall TAirCoupler::Init(AnsiString asName, TModel3d *pModel)
{//wyszukanie submodeli { // wyszukanie submodeli
if (!pModel) return; //nie ma w czym szukaæ if (!pModel)
pModelOn=pModel->GetFromName(AnsiString(asName+"_on").c_str()); //po³¹czony na wprost return; // nie ma w czym szukaæ
pModelOff=pModel->GetFromName(AnsiString(asName+"_off").c_str()); //odwieszony pModelOn = pModel->GetFromName(AnsiString(asName + "_on").c_str()); // po³¹czony na wprost
pModelxOn=pModel->GetFromName(AnsiString(asName+"_xon").c_str()); //po³¹czony na skos pModelOff = pModel->GetFromName(AnsiString(asName + "_off").c_str()); // odwieszony
pModelxOn = pModel->GetFromName(AnsiString(asName + "_xon").c_str()); // po³¹czony na skos
} }
void __fastcall TAirCoupler::Load(TQueryParserComp *Parser, TModel3d *pModel) void __fastcall TAirCoupler::Load(TQueryParserComp *Parser, TModel3d *pModel)
{ {
AnsiString str=Parser->GetNextSymbol().LowerCase(); AnsiString str = Parser->GetNextSymbol().LowerCase();
if (pModel) if (pModel)
Init(str,pModel); Init(str, pModel);
else else
{ {
pModelOn=NULL; pModelOn = NULL;
pModelxOn=NULL; pModelxOn = NULL;
pModelOff=NULL; pModelOff = NULL;
} }
} }
void __fastcall TAirCoupler::Update() void __fastcall TAirCoupler::Update()
{ {
// if ((pModelOn!=NULL) && (pModelOn!=NULL)) // if ((pModelOn!=NULL) && (pModelOn!=NULL))
{ {
if (pModelOn) if (pModelOn)
pModelOn->iVisible=bOn; pModelOn->iVisible = bOn;
if (pModelOff) if (pModelOff)
pModelOff->iVisible=!(bOn||bxOn); pModelOff->iVisible = !(bOn || bxOn);
if (pModelxOn) if (pModelxOn)
pModelxOn->iVisible=bxOn; pModelxOn->iVisible = bxOn;
} }
} }

34
AirCoupler.h
View File

@@ -8,24 +8,40 @@
class TAirCoupler class TAirCoupler
{ {
private: private:
// TButtonType eType; // TButtonType eType;
TSubModel *pModelOn,*pModelOff,*pModelxOn; TSubModel *pModelOn, *pModelOff, *pModelxOn;
bool bOn; bool bOn;
bool bxOn; bool bxOn;
void __fastcall Update(); void __fastcall Update();
public:
public:
__fastcall TAirCoupler(); __fastcall TAirCoupler();
__fastcall ~TAirCoupler(); __fastcall ~TAirCoupler();
void __fastcall Clear(); void __fastcall Clear();
inline void TurnOn() { bOn=true; bxOn=false; Update(); }; inline void TurnOn()
inline void TurnOff() { bOn=false; bxOn=false; Update(); }; {
inline void TurnxOn() { bOn=false; bxOn=true; Update(); }; bOn = true;
// inline bool Active() { if ((pModelOn)||(pModelOff)) return true; return false;}; bxOn = false;
Update();
};
inline void TurnOff()
{
bOn = false;
bxOn = false;
Update();
};
inline void TurnxOn()
{
bOn = false;
bxOn = true;
Update();
};
// inline bool Active() { if ((pModelOn)||(pModelOff)) return true; return false;};
int __fastcall GetStatus(); int __fastcall GetStatus();
void __fastcall Init(AnsiString asName, TModel3d *pModel); void __fastcall Init(AnsiString asName, TModel3d *pModel);
void __fastcall Load(TQueryParserComp *Parser, TModel3d *pModel); void __fastcall Load(TQueryParserComp *Parser, TModel3d *pModel);
// bool __fastcall Render(); // bool __fastcall Render();
}; };
//--------------------------------------------------------------------------- //---------------------------------------------------------------------------

944
AnimModel.cpp
View File

File diff suppressed because it is too large Load Diff

178
AnimModel.h
View File

@@ -5,88 +5,101 @@
#include "Model3d.h" #include "Model3d.h"
const int iMaxNumLights=8; const int iMaxNumLights = 8;
//typy stanu œwiate³ // typy stanu œwiate³
typedef enum { typedef enum
ls_Off=0, //zgaszone {
ls_On=1, //zapalone ls_Off = 0, // zgaszone
ls_Blink=2, //migaj¹ce ls_On = 1, // zapalone
ls_Dark=3 //Ra: zapalajce siê automatycznie, gdy zrobi siê ciemno ls_Blink = 2, // migaj¹ce
ls_Dark = 3 // Ra: zapalajce siê automatycznie, gdy zrobi siê ciemno
} TLightState; } TLightState;
class TAnimVocaloidFrame class TAnimVocaloidFrame
{//ramka animacji typu Vocaloid Motion Data z programu MikuMikuDance { // ramka animacji typu Vocaloid Motion Data z programu MikuMikuDance
public: public:
char cBone[15]; //nazwa koœci, mo¿e byæ po japoñsku char cBone[15]; // nazwa koœci, mo¿e byæ po japoñsku
int iFrame; //numer ramki int iFrame; // numer ramki
float3 f3Vector; //przemieszczenie float3 f3Vector; // przemieszczenie
float4 qAngle; //kwaternion obrotu float4 qAngle; // kwaternion obrotu
char cBezier[64]; //krzywe Béziera do interpolacji dla x,y,z i obrotu char cBezier[64]; // krzywe Béziera do interpolacji dla x,y,z i obrotu
}; };
class TEvent; class TEvent;
class TAnimContainer class TAnimContainer
{//opakowanie submodelu, okreœlaj¹ce animacjê egzemplarza - obs³ugiwane jako lista { // opakowanie submodelu, okreœlaj¹ce animacjê egzemplarza - obs³ugiwane jako lista
friend class TAnimModel; friend class TAnimModel;
private:
vector3 vRotateAngles; //dla obrotów Eulera private:
vector3 vRotateAngles; // dla obrotów Eulera
vector3 vDesiredAngles; vector3 vDesiredAngles;
double fRotateSpeed; double fRotateSpeed;
vector3 vTranslation; vector3 vTranslation;
vector3 vTranslateTo; vector3 vTranslateTo;
double fTranslateSpeed; //mo¿e tu daæ wektor? double fTranslateSpeed; // mo¿e tu daæ wektor?
float4 qCurrent; //aktualny interpolowany float4 qCurrent; // aktualny interpolowany
float4 qStart; //pozycja pocz¹tkowa (0 dla interpolacji) float4 qStart; // pozycja pocz¹tkowa (0 dla interpolacji)
float4 qDesired; //pozycja koñcowa (1 dla interpolacji) float4 qDesired; // pozycja koñcowa (1 dla interpolacji)
float fAngleCurrent; //parametr interpolacyjny: 0=start, 1=docelowy float fAngleCurrent; // parametr interpolacyjny: 0=start, 1=docelowy
float fAngleSpeed; //zmiana parametru interpolacji w sekundach float fAngleSpeed; // zmiana parametru interpolacji w sekundach
TSubModel *pSubModel; TSubModel *pSubModel;
float4x4 *mAnim; //macierz do animacji kwaternionowych float4x4 *mAnim; // macierz do animacji kwaternionowych
//dla kinematyki odwróconej u¿ywane s¹ kwaterniony // dla kinematyki odwróconej u¿ywane s¹ kwaterniony
float fLength; //d³ugoœæ koœci dla IK float fLength; // d³ugoœæ koœci dla IK
int iAnim; //animacja: +1-obrót Eulera, +2-przesuw, +4-obrót kwaternionem, +8-IK int iAnim; // animacja: +1-obrót Eulera, +2-przesuw, +4-obrót kwaternionem, +8-IK
//+0x80000000: animacja z eventem, wykonywana poza wyœwietlaniem //+0x80000000: animacja z eventem, wykonywana poza wyœwietlaniem
//+0x100: pierwszy stopieñ IK - obróciæ w stronê pierwszego potomnego (dziecka) //+0x100: pierwszy stopieñ IK - obróciæ w stronê pierwszego potomnego (dziecka)
//+0x200: drugi stopieñ IK - dostosowaæ do pozycji potomnego potomnego (wnuka) //+0x200: drugi stopieñ IK - dostosowaæ do pozycji potomnego potomnego (wnuka)
union union
{//mog¹ byæ animacje klatkowe ró¿nego typu, wskaŸniki u¿ywa AnimModel { // mog¹ byæ animacje klatkowe ró¿nego typu, wskaŸniki u¿ywa AnimModel
TAnimVocaloidFrame *pMovementData; //wskaŸnik do klatki TAnimVocaloidFrame *pMovementData; // wskaŸnik do klatki
}; };
TEvent *evDone; //ewent wykonywany po zakoñczeniu animacji, np. zapór, obrotnicy TEvent *evDone; // ewent wykonywany po zakoñczeniu animacji, np. zapór, obrotnicy
public: public:
TAnimContainer *pNext; TAnimContainer *pNext;
TAnimContainer *acAnimNext; //lista animacji z eventem, które musz¹ byæ przeliczane równie¿ bez wyœwietlania TAnimContainer *acAnimNext; // lista animacji z eventem, które musz¹ byæ przeliczane równie¿ bez
// wyœwietlania
__fastcall TAnimContainer(); __fastcall TAnimContainer();
__fastcall ~TAnimContainer(); __fastcall ~TAnimContainer();
bool __fastcall Init(TSubModel *pNewSubModel); bool __fastcall Init(TSubModel *pNewSubModel);
//std::string inline __fastcall GetName() { return std::string(pSubModel?pSubModel->asName.c_str():""); }; // std::string inline __fastcall GetName() { return
//std::string inline __fastcall GetName() { return std::string(pSubModel?pSubModel->pName:""); }; // std::string(pSubModel?pSubModel->asName.c_str():""); };
char* __fastcall NameGet() {return (pSubModel?pSubModel->pName:NULL);}; // std::string inline __fastcall GetName() { return std::string(pSubModel?pSubModel->pName:"");
//void __fastcall SetRotateAnim(vector3 vNewRotateAxis, double fNewDesiredAngle, double fNewRotateSpeed, bool bResetAngle=false); // };
char *__fastcall NameGet() { return (pSubModel ? pSubModel->pName : NULL); };
// void __fastcall SetRotateAnim(vector3 vNewRotateAxis, double fNewDesiredAngle, double
// fNewRotateSpeed, bool bResetAngle=false);
void __fastcall SetRotateAnim(vector3 vNewRotateAngles, double fNewRotateSpeed); void __fastcall SetRotateAnim(vector3 vNewRotateAngles, double fNewRotateSpeed);
void __fastcall SetTranslateAnim(vector3 vNewTranslate, double fNewSpeed); void __fastcall SetTranslateAnim(vector3 vNewTranslate, double fNewSpeed);
void __fastcall AnimSetVMD(double fNewSpeed); void __fastcall AnimSetVMD(double fNewSpeed);
void __fastcall PrepareModel(); void __fastcall PrepareModel();
void __fastcall UpdateModel(); void __fastcall UpdateModel();
void __fastcall UpdateModelIK(); void __fastcall UpdateModelIK();
bool __fastcall InMovement(); //czy w trakcie animacji? bool __fastcall InMovement(); // czy w trakcie animacji?
double _fastcall AngleGet() {return vRotateAngles.z;}; //jednak ostatnia, T3D ma inny uk³ad double _fastcall AngleGet() { return vRotateAngles.z; }; // jednak ostatnia, T3D ma inny uk³ad
vector3 _fastcall TransGet() {return vector3(-vTranslation.x,vTranslation.z,vTranslation.y);}; //zmiana, bo T3D ma inny uk³ad vector3 _fastcall TransGet()
void __fastcall WillBeAnimated() {if (pSubModel) pSubModel->WillBeAnimated();}; {
return vector3(-vTranslation.x, vTranslation.z, vTranslation.y);
}; // zmiana, bo T3D ma inny uk³ad
void __fastcall WillBeAnimated()
{
if (pSubModel)
pSubModel->WillBeAnimated();
};
void __fastcall EventAssign(TEvent *ev); void __fastcall EventAssign(TEvent *ev);
TEvent* __fastcall Event() {return evDone;}; TEvent *__fastcall Event() { return evDone; };
}; };
class TAnimAdvanced class TAnimAdvanced
{//obiekt zaawansowanej animacji submodelu { // obiekt zaawansowanej animacji submodelu
public: public:
TAnimVocaloidFrame *pMovementData; TAnimVocaloidFrame *pMovementData;
unsigned char *pVocaloidMotionData; //plik animacyjny dla egzemplarza (z eventu) unsigned char *pVocaloidMotionData; // plik animacyjny dla egzemplarza (z eventu)
double fFrequency; //przeliczenie czasu rzeczywistego na klatki animacji double fFrequency; // przeliczenie czasu rzeczywistego na klatki animacji
double fCurrent; //klatka animacji wyœwietlona w poprzedniej klatce renderingu double fCurrent; // klatka animacji wyœwietlona w poprzedniej klatce renderingu
double fLast; //klatka koñcz¹ca animacjê double fLast; // klatka koñcz¹ca animacjê
int iMovements; int iMovements;
__fastcall TAnimAdvanced(); __fastcall TAnimAdvanced();
__fastcall ~TAnimAdvanced(); __fastcall ~TAnimAdvanced();
@@ -94,55 +107,60 @@ public:
}; };
class TAnimModel class TAnimModel
{//opakowanie modelu, okreœlaj¹ce stan egzemplarza { // opakowanie modelu, okreœlaj¹ce stan egzemplarza
private: private:
TAnimContainer *pRoot; //pojemniki steruj¹ce, tylko dla aniomowanych submodeli TAnimContainer *pRoot; // pojemniki steruj¹ce, tylko dla aniomowanych submodeli
TModel3d *pModel; TModel3d *pModel;
double fBlinkTimer; double fBlinkTimer;
int iNumLights; int iNumLights;
TSubModel *LightsOn[iMaxNumLights]; //Ra: te wskaŸniki powinny byæ w ramach TModel3d TSubModel *LightsOn[iMaxNumLights]; // Ra: te wskaŸniki powinny byæ w ramach TModel3d
TSubModel *LightsOff[iMaxNumLights]; TSubModel *LightsOff[iMaxNumLights];
vector3 vAngle; //bazowe obroty egzemplarza wzglêdem osi vector3 vAngle; // bazowe obroty egzemplarza wzglêdem osi
int iTexAlpha; //¿eby nie sprawdzaæ za ka¿dym razem, dla 4 wymiennych tekstur int iTexAlpha; //¿eby nie sprawdzaæ za ka¿dym razem, dla 4 wymiennych tekstur
AnsiString asText; //tekst dla wyœwietlacza znakowego AnsiString asText; // tekst dla wyœwietlacza znakowego
TAnimAdvanced *pAdvanced; TAnimAdvanced *pAdvanced;
void __fastcall Advanced(); void __fastcall Advanced();
TLightState lsLights[iMaxNumLights]; TLightState lsLights[iMaxNumLights];
float fDark; //poziom zapalanie œwiat³a (powinno byæ chyba powi¹zane z danym œwiat³em?) float fDark; // poziom zapalanie œwiat³a (powinno byæ chyba powi¹zane z danym œwiat³em?)
float fOnTime,fOffTime; //by³y sta³ymi, teraz mog¹ byæ zmienne dla ka¿dego egzemplarza float fOnTime, fOffTime; // by³y sta³ymi, teraz mog¹ byæ zmienne dla ka¿dego egzemplarza
private: private:
void __fastcall RaAnimate(); //przeliczenie animacji egzemplarza void __fastcall RaAnimate(); // przeliczenie animacji egzemplarza
void __fastcall RaPrepare(); //ustawienie animacji egzemplarza na wzorcu void __fastcall RaPrepare(); // ustawienie animacji egzemplarza na wzorcu
public: public:
GLuint ReplacableSkinId[5]; //McZapkie-020802: zmienialne skory GLuint ReplacableSkinId[5]; // McZapkie-020802: zmienialne skory
static TAnimContainer *acAnimList; //lista animacji z eventem, które musz¹ byæ przeliczane równie¿ bez wyœwietlania static TAnimContainer *acAnimList; // lista animacji z eventem, które musz¹ byæ przeliczane
// równie¿ bez wyœwietlania
__fastcall TAnimModel(); __fastcall TAnimModel();
__fastcall ~TAnimModel(); __fastcall ~TAnimModel();
bool __fastcall Init(TModel3d *pNewModel); bool __fastcall Init(TModel3d *pNewModel);
bool __fastcall Init(AnsiString asName,AnsiString asReplacableTexture); bool __fastcall Init(AnsiString asName, AnsiString asReplacableTexture);
bool __fastcall Load(cParser *parser, bool ter=false); bool __fastcall Load(cParser *parser, bool ter = false);
TAnimContainer* __fastcall AddContainer(char *pName); TAnimContainer *__fastcall AddContainer(char *pName);
TAnimContainer* __fastcall GetContainer(char *pName); TAnimContainer *__fastcall GetContainer(char *pName);
void __fastcall RenderDL(vector3 pPosition=vector3(0,0,0),double fAngle=0); void __fastcall RenderDL(vector3 pPosition = vector3(0, 0, 0), double fAngle = 0);
void __fastcall RenderAlphaDL(vector3 pPosition=vector3(0,0,0),double fAngle=0); void __fastcall RenderAlphaDL(vector3 pPosition = vector3(0, 0, 0), double fAngle = 0);
void __fastcall RenderVBO(vector3 pPosition=vector3(0,0,0),double fAngle=0); void __fastcall RenderVBO(vector3 pPosition = vector3(0, 0, 0), double fAngle = 0);
void __fastcall RenderAlphaVBO(vector3 pPosition=vector3(0,0,0),double fAngle=0); void __fastcall RenderAlphaVBO(vector3 pPosition = vector3(0, 0, 0), double fAngle = 0);
void __fastcall RenderDL(vector3* vPosition); void __fastcall RenderDL(vector3 *vPosition);
void __fastcall RenderAlphaDL(vector3* vPosition); void __fastcall RenderAlphaDL(vector3 *vPosition);
void __fastcall RenderVBO(vector3* vPosition); void __fastcall RenderVBO(vector3 *vPosition);
void __fastcall RenderAlphaVBO(vector3* vPosition); void __fastcall RenderAlphaVBO(vector3 *vPosition);
int __fastcall Flags(); int __fastcall Flags();
void __fastcall RaAnglesSet(double a,double b,double c) void __fastcall RaAnglesSet(double a, double b, double c)
{vAngle.x=a; vAngle.y=b; vAngle.z=c;}; {
vAngle.x = a;
vAngle.y = b;
vAngle.z = c;
};
bool __fastcall TerrainLoaded(); bool __fastcall TerrainLoaded();
int __fastcall TerrainCount(); int __fastcall TerrainCount();
TSubModel* __fastcall TerrainSquare(int n); TSubModel *__fastcall TerrainSquare(int n);
void __fastcall TerrainRenderVBO(int n); void __fastcall TerrainRenderVBO(int n);
void __fastcall AnimationVND(void* pData, double a, double b, double c, double d); void __fastcall AnimationVND(void *pData, double a, double b, double c, double d);
void __fastcall LightSet(int n,float v); void __fastcall LightSet(int n, float v);
static void __fastcall AnimUpdate(double dt); static void __fastcall AnimUpdate(double dt);
}; };
TAnimContainer *TAnimModel::acAnimList=NULL; TAnimContainer *TAnimModel::acAnimList = NULL;
//--------------------------------------------------------------------------- //---------------------------------------------------------------------------
#endif #endif

57
Button.cpp
View File

@@ -13,58 +13,61 @@
__fastcall TButton::TButton() __fastcall TButton::TButton()
{ {
iFeedbackBit=0; iFeedbackBit = 0;
Clear(); Clear();
}; };
__fastcall TButton::~TButton() __fastcall TButton::~TButton(){};
{
};
void __fastcall TButton::Clear(int i) void __fastcall TButton::Clear(int i)
{ {
pModelOn=NULL; pModelOn = NULL;
pModelOff=NULL; pModelOff = NULL;
bOn=false; bOn = false;
if (i>=0) FeedbackBitSet(i); if (i >= 0)
Update(); //kasowanie bitu Feedback, o ile jakiœ ustawiony FeedbackBitSet(i);
Update(); // kasowanie bitu Feedback, o ile jakiœ ustawiony
}; };
void __fastcall TButton::Init(AnsiString asName,TModel3d *pModel,bool bNewOn) void __fastcall TButton::Init(AnsiString asName, TModel3d *pModel, bool bNewOn)
{ {
if (!pModel) return; //nie ma w czym szukaæ if (!pModel)
pModelOn=pModel->GetFromName(AnsiString(asName+"_on").c_str()); return; // nie ma w czym szukaæ
pModelOff=pModel->GetFromName(AnsiString(asName+"_off").c_str()); pModelOn = pModel->GetFromName(AnsiString(asName + "_on").c_str());
bOn=bNewOn; pModelOff = pModel->GetFromName(AnsiString(asName + "_off").c_str());
bOn = bNewOn;
Update(); Update();
}; };
void __fastcall TButton::Load(TQueryParserComp *Parser,TModel3d *pModel1,TModel3d *pModel2) void __fastcall TButton::Load(TQueryParserComp *Parser, TModel3d *pModel1, TModel3d *pModel2)
{ {
AnsiString str=Parser->GetNextSymbol().LowerCase(); AnsiString str = Parser->GetNextSymbol().LowerCase();
if (pModel1) if (pModel1)
{//poszukiwanie submodeli w modelu { // poszukiwanie submodeli w modelu
Init(str,pModel1,false); Init(str, pModel1, false);
if (pModel2) if (pModel2)
if (!pModelOn&&!pModelOff) if (!pModelOn && !pModelOff)
Init(str,pModel2,false); //mo¿e w drugim bêdzie (jak nie w kabinie, to w zewnêtrznym) Init(str, pModel2,
false); // mo¿e w drugim bêdzie (jak nie w kabinie, to w zewnêtrznym)
} }
else else
{ {
pModelOn=NULL; pModelOn = NULL;
pModelOff=NULL; pModelOff = NULL;
} }
}; };
void __fastcall TButton::Update() void __fastcall TButton::Update()
{ {
if (pModelOn) pModelOn->iVisible=bOn; if (pModelOn)
if (pModelOff) pModelOff->iVisible=!bOn; pModelOn->iVisible = bOn;
if (iFeedbackBit) //je¿eli generuje informacjê zwrotn¹ if (pModelOff)
{if (bOn) //zapalenie pModelOff->iVisible = !bOn;
if (iFeedbackBit) // je¿eli generuje informacjê zwrotn¹
{
if (bOn) // zapalenie
Console::BitsSet(iFeedbackBit); Console::BitsSet(iFeedbackBit);
else else
Console::BitsClear(iFeedbackBit); Console::BitsClear(iFeedbackBit);
} }
}; };

45
Button.h
View File

@@ -7,24 +7,41 @@
#include "QueryParserComp.hpp" #include "QueryParserComp.hpp"
class TButton class TButton
{//animacja dwustanowa, w³¹cza jeden z dwóch submodeli (jednego z nich mo¿e nie byæ) { // animacja dwustanowa, w³¹cza jeden z dwóch submodeli (jednego z nich mo¿e nie byæ)
private: private:
TSubModel *pModelOn,*pModelOff; //submodel dla stanu za³¹czonego i wy³¹czonego TSubModel *pModelOn, *pModelOff; // submodel dla stanu za³¹czonego i wy³¹czonego
bool bOn; bool bOn;
int iFeedbackBit; //Ra: bit informacji zwrotnej, do wyprowadzenia na pulpit int iFeedbackBit; // Ra: bit informacji zwrotnej, do wyprowadzenia na pulpit
void __fastcall Update(); void __fastcall Update();
public:
public:
__fastcall TButton(); __fastcall TButton();
__fastcall ~TButton(); __fastcall ~TButton();
void __fastcall Clear(int i=-1); void __fastcall Clear(int i = -1);
inline void FeedbackBitSet(int i) {iFeedbackBit=1<<i;}; inline void FeedbackBitSet(int i) { iFeedbackBit = 1 << i; };
inline void Turn(bool to) { bOn=to; Update(); }; inline void Turn(bool to)
inline void TurnOn() { bOn=true; Update(); }; {
inline void TurnOff() { bOn=false; Update(); }; bOn = to;
inline void Switch() { bOn=!bOn; Update(); }; Update();
inline bool Active() { return (pModelOn)||(pModelOff);}; };
void __fastcall Init(AnsiString asName,TModel3d *pModel,bool bNewOn=false); inline void TurnOn()
void __fastcall Load(TQueryParserComp *Parser,TModel3d *pModel1,TModel3d *pModel2=NULL); {
bOn = true;
Update();
};
inline void TurnOff()
{
bOn = false;
Update();
};
inline void Switch()
{
bOn = !bOn;
Update();
};
inline bool Active() { return (pModelOn) || (pModelOff); };
void __fastcall Init(AnsiString asName, TModel3d *pModel, bool bNewOn = false);
void __fastcall Load(TQueryParserComp *Parser, TModel3d *pModel1, TModel3d *pModel2 = NULL);
}; };
//--------------------------------------------------------------------------- //---------------------------------------------------------------------------

206
Camera.cpp
View File

@@ -16,64 +16,66 @@
//--------------------------------------------------------------------------- //---------------------------------------------------------------------------
#pragma package(smart_init) #pragma package(smart_init)
//TViewPyramid TCamera::OrgViewPyramid; // TViewPyramid TCamera::OrgViewPyramid;
//={vector3(-1,1,1),vector3(1,1,1),vector3(-1,-1,1),vector3(1,-1,1),vector3(0,0,0)}; //={vector3(-1,1,1),vector3(1,1,1),vector3(-1,-1,1),vector3(1,-1,1),vector3(0,0,0)};
const vector3 OrgCrossPos= vector3(0,-10,0); const vector3 OrgCrossPos = vector3(0, -10, 0);
void __fastcall TCamera::Init(vector3 NPos, vector3 NAngle) void __fastcall TCamera::Init(vector3 NPos, vector3 NAngle)
{ {
pOffset= vector3(-0.0,0,0); pOffset = vector3(-0.0, 0, 0);
vUp= vector3(0,1,0); vUp = vector3(0, 1, 0);
// pOffset= vector3(-0.8,0,0); // pOffset= vector3(-0.8,0,0);
CrossPos= OrgCrossPos; CrossPos = OrgCrossPos;
CrossDist= 10; CrossDist = 10;
Velocity=vector3(0,0,0); Velocity = vector3(0, 0, 0);
OldVelocity= vector3(0,0,0); OldVelocity = vector3(0, 0, 0);
Pitch= NAngle.x; Pitch = NAngle.x;
Yaw= NAngle.y; Yaw = NAngle.y;
Roll= NAngle.z; Roll = NAngle.z;
Pos= NPos; Pos = NPos;
// Type= tp_Follow; // Type= tp_Follow;
Type= (Global::bFreeFly ? tp_Free : tp_Follow); Type = (Global::bFreeFly ? tp_Free : tp_Follow);
// Type= tp_Free; // Type= tp_Free;
}; };
void __fastcall TCamera::OnCursorMove(double x, double y) void __fastcall TCamera::OnCursorMove(double x, double y)
{ {
//McZapkie-170402: zeby mysz dzialala zawsze if (Type==tp_Follow) // McZapkie-170402: zeby mysz dzialala zawsze if (Type==tp_Follow)
Pitch+=y; Pitch += y;
Yaw+=-x; Yaw += -x;
if (Yaw>M_PI) if (Yaw > M_PI)
Yaw-=2*M_PI; Yaw -= 2 * M_PI;
else if (Yaw<-M_PI) else if (Yaw < -M_PI)
Yaw+=2*M_PI; Yaw += 2 * M_PI;
if (Type==tp_Follow) //je¿eli jazda z pojazdem if (Type == tp_Follow) // je¿eli jazda z pojazdem
{ {
Fix(Pitch,-M_PI_4,M_PI_4); //ograniczenie k¹ta spogl¹dania w dó³ i w górê Fix(Pitch, -M_PI_4, M_PI_4); // ograniczenie k¹ta spogl¹dania w dó³ i w górê
//Fix(Yaw,-M_PI,M_PI); // Fix(Yaw,-M_PI,M_PI);
} }
} }
void __fastcall TCamera::Update() void __fastcall TCamera::Update()
{ {
//ABu: zmiana i uniezaleznienie predkosci od FPS // ABu: zmiana i uniezaleznienie predkosci od FPS
double a= (Console::Pressed(VK_SHIFT)?5.00:1.00); double a = (Console::Pressed(VK_SHIFT) ? 5.00 : 1.00);
if (Console::Pressed(VK_CONTROL)) if (Console::Pressed(VK_CONTROL))
a=a*100; a = a * 100;
// OldVelocity=Velocity; // OldVelocity=Velocity;
if (FreeFlyModeFlag==true) if (FreeFlyModeFlag == true)
Type=tp_Free; Type = tp_Free;
else else
Type=tp_Follow; Type = tp_Follow;
if (Type==tp_Free) if (Type == tp_Free)
{ {
if (Console::Pressed(Global::Keys[k_MechUp])) Velocity.y+=a; if (Console::Pressed(Global::Keys[k_MechUp]))
if (Console::Pressed(Global::Keys[k_MechDown])) Velocity.y-=a; Velocity.y += a;
//McZapkie-170402: zeby nie bylo konfliktow if (Console::Pressed(Global::Keys[k_MechDown]))
/* Velocity.y -= a;
// McZapkie-170402: zeby nie bylo konfliktow
/*
if (Console::Pressed(VkKeyScan('d'))) if (Console::Pressed(VkKeyScan('d')))
Velocity.x+= a*Timer::GetDeltaTime(); Velocity.x+= a*Timer::GetDeltaTime();
if (Console::Pressed(VkKeyScan('a'))) if (Console::Pressed(VkKeyScan('a')))
@@ -83,16 +85,20 @@ void __fastcall TCamera::Update()
if (Console::Pressed(VkKeyScan('s'))) if (Console::Pressed(VkKeyScan('s')))
Velocity.z+= a*Timer::GetDeltaTime(); Velocity.z+= a*Timer::GetDeltaTime();
if (Console::Pressed(VK_NUMPAD4) || Console::Pressed(VK_NUMPAD7) || Console::Pressed(VK_NUMPAD1)) if (Console::Pressed(VK_NUMPAD4) || Console::Pressed(VK_NUMPAD7) ||
Console::Pressed(VK_NUMPAD1))
Yaw+= +1*M_PI*Timer::GetDeltaTime(); Yaw+= +1*M_PI*Timer::GetDeltaTime();
if (Console::Pressed(VK_NUMPAD6) || Console::Pressed(VK_NUMPAD9) || Console::Pressed(VK_NUMPAD3)) if (Console::Pressed(VK_NUMPAD6) || Console::Pressed(VK_NUMPAD9) ||
Console::Pressed(VK_NUMPAD3))
Yaw+= -1*M_PI*Timer::GetDeltaTime(); Yaw+= -1*M_PI*Timer::GetDeltaTime();
if (Pressed(VK_NUMPAD2) || Console::Pressed(VK_NUMPAD1) || Console::Pressed(VK_NUMPAD3)) if (Pressed(VK_NUMPAD2) || Console::Pressed(VK_NUMPAD1) ||
Console::Pressed(VK_NUMPAD3))
Pitch+= -1*M_PI*Timer::GetDeltaTime(); Pitch+= -1*M_PI*Timer::GetDeltaTime();
if (Console::Pressed(VK_NUMPAD8) || Console::Pressed(VK_NUMPAD7) || Console::Pressed(VK_NUMPAD9)) if (Console::Pressed(VK_NUMPAD8) || Console::Pressed(VK_NUMPAD7) ||
Console::Pressed(VK_NUMPAD9))
Pitch+= +1*M_PI*Timer::GetDeltaTime(); Pitch+= +1*M_PI*Timer::GetDeltaTime();
if (Console::Pressed(VkKeyScan('.'))) if (Console::Pressed(VkKeyScan('.')))
Roll+= -1*M_PI*Timer::GetDeltaTime(); Roll+= -1*M_PI*Timer::GetDeltaTime();
@@ -101,96 +107,98 @@ void __fastcall TCamera::Update()
if (Console::Pressed(VK_NUMPAD5)) if (Console::Pressed(VK_NUMPAD5))
Pitch=Roll= 0.0f; Pitch=Roll= 0.0f;
*/ */
//McZapkie-170402: poruszanie i rozgladanie we free takie samo jak w follow // McZapkie-170402: poruszanie i rozgladanie we free takie samo jak w follow
if (Console::Pressed(Global::Keys[k_MechRight])) Velocity.x+=a; if (Console::Pressed(Global::Keys[k_MechRight]))
if (Console::Pressed(Global::Keys[k_MechLeft])) Velocity.x-=a; Velocity.x += a;
if (Console::Pressed(Global::Keys[k_MechForward])) Velocity.z-=a; if (Console::Pressed(Global::Keys[k_MechLeft]))
if (Console::Pressed(Global::Keys[k_MechBackward])) Velocity.z+=a; Velocity.x -= a;
//gora-dol if (Console::Pressed(Global::Keys[k_MechForward]))
//if (Console::Pressed(VK_NUMPAD9)) Pos.y+=0.1; Velocity.z -= a;
//if (Console::Pressed(VK_NUMPAD3)) Pos.y-=0.1; if (Console::Pressed(Global::Keys[k_MechBackward]))
Velocity.z += a;
// gora-dol
// if (Console::Pressed(VK_NUMPAD9)) Pos.y+=0.1;
// if (Console::Pressed(VK_NUMPAD3)) Pos.y-=0.1;
//McZapkie: zeby nie hustalo przy malym FPS: // McZapkie: zeby nie hustalo przy malym FPS:
// Velocity= (Velocity+OldVelocity)/2; // Velocity= (Velocity+OldVelocity)/2;
// matrix4x4 mat; // matrix4x4 mat;
vector3 Vec=Velocity; vector3 Vec = Velocity;
Vec.RotateY(Yaw); Vec.RotateY(Yaw);
Pos=Pos+Vec*Timer::GetDeltaRenderTime(); //czas bez pauzy Pos = Pos + Vec * Timer::GetDeltaRenderTime(); // czas bez pauzy
Velocity=Velocity/2; //p³ynne hamowanie ruchu Velocity = Velocity / 2; // p³ynne hamowanie ruchu
// double tmp= 10*DeltaTime; // double tmp= 10*DeltaTime;
// Velocity+= -Velocity*10 * Timer::GetDeltaTime();//( tmp<1 ? tmp : 1 ); // Velocity+= -Velocity*10 * Timer::GetDeltaTime();//( tmp<1 ? tmp : 1 );
// Type= tp_Free; // Type= tp_Free;
} }
} }
vector3 __fastcall TCamera::GetDirection() vector3 __fastcall TCamera::GetDirection()
{ {
matrix4x4 mat; matrix4x4 mat;
vector3 Vec; vector3 Vec;
Vec= vector3(0,0,1); Vec = vector3(0, 0, 1);
Vec.RotateY(Yaw); Vec.RotateY(Yaw);
return (Normalize(Vec)); return (Normalize(Vec));
} }
//bool __fastcall TCamera::GetMatrix(matrix4x4 &Matrix) // bool __fastcall TCamera::GetMatrix(matrix4x4 &Matrix)
bool __fastcall TCamera::SetMatrix() bool __fastcall TCamera::SetMatrix()
{ {
glRotated(-Roll*180.0f/M_PI,0,0,1); //po wy³¹czeniu tego krêci siê pojazd, a sceneria nie glRotated(-Roll * 180.0f / M_PI, 0, 0, 1); // po wy³¹czeniu tego krêci siê pojazd, a sceneria
glRotated(-Pitch*180.0f/M_PI,1,0,0); // nie
glRotated(-Yaw*180.0f/M_PI,0,1,0); //w zewnêtrznym widoku: kierunek patrzenia glRotated(-Pitch * 180.0f / M_PI, 1, 0, 0);
glRotated(-Yaw * 180.0f / M_PI, 0, 1, 0); // w zewnêtrznym widoku: kierunek patrzenia
if (Type==tp_Follow) if (Type == tp_Follow)
{ {
// gluLookAt(Pos.x+pOffset.x,Pos.y+pOffset.y,Pos.z+pOffset.z, // gluLookAt(Pos.x+pOffset.x,Pos.y+pOffset.y,Pos.z+pOffset.z,
// LookAt.x+pOffset.x,LookAt.y+pOffset.y,LookAt.z+pOffset.z,vUp.x,vUp.y,vUp.z); // LookAt.x+pOffset.x,LookAt.y+pOffset.y,LookAt.z+pOffset.z,vUp.x,vUp.y,vUp.z);
// gluLookAt(Pos.x+pOffset.x,Pos.y+pOffset.y,Pos.z+pOffset.z, // gluLookAt(Pos.x+pOffset.x,Pos.y+pOffset.y,Pos.z+pOffset.z,
// LookAt.x+pOffset.x,LookAt.y+pOffset.y,LookAt.z+pOffset.z,vUp.x,vUp.y,vUp.z); // LookAt.x+pOffset.x,LookAt.y+pOffset.y,LookAt.z+pOffset.z,vUp.x,vUp.y,vUp.z);
gluLookAt(Pos.x,Pos.y,Pos.z,LookAt.x,LookAt.y,LookAt.z,vUp.x,vUp.y,vUp.z); //Ra: pOffset is zero gluLookAt(Pos.x, Pos.y, Pos.z, LookAt.x, LookAt.y, LookAt.z, vUp.x, vUp.y,
// gluLookAt(Pos.x,Pos.y,Pos.z,Pos.x+Velocity.x,Pos.y+Velocity.y,Pos.z+Velocity.z,0,1,0); vUp.z); // Ra: pOffset is zero
// return true; // gluLookAt(Pos.x,Pos.y,Pos.z,Pos.x+Velocity.x,Pos.y+Velocity.y,Pos.z+Velocity.z,0,1,0);
// return true;
} }
if (Type==tp_Satelite) if (Type == tp_Satelite)
Pitch= M_PI*0.5; Pitch = M_PI * 0.5;
if (Type!=tp_Follow) if (Type != tp_Follow)
{ {
glTranslated(-Pos.x,-Pos.y,-Pos.z); //nie zmienia kierunku patrzenia glTranslated(-Pos.x, -Pos.y, -Pos.z); // nie zmienia kierunku patrzenia
} }
Global::SetCameraPosition(Pos); //by³o +pOffset Global::SetCameraPosition(Pos); // by³o +pOffset
return true; return true;
} }
void __fastcall TCamera::SetCabMatrix(vector3 &p) void __fastcall TCamera::SetCabMatrix(vector3 &p)
{//ustawienie widoku z kamery bez przesuniêcia robionego przez OpenGL - nie powinno tak trz¹œæ { // ustawienie widoku z kamery bez przesuniêcia robionego przez OpenGL - nie powinno tak trz¹œæ
glRotated(-Roll*180.0f/M_PI,0,0,1); glRotated(-Roll * 180.0f / M_PI, 0, 0, 1);
glRotated(-Pitch*180.0f/M_PI,1,0,0); glRotated(-Pitch * 180.0f / M_PI, 1, 0, 0);
glRotated(-Yaw*180.0f/M_PI,0,1,0); //w zewnêtrznym widoku: kierunek patrzenia glRotated(-Yaw * 180.0f / M_PI, 0, 1, 0); // w zewnêtrznym widoku: kierunek patrzenia
if (Type==tp_Follow) if (Type == tp_Follow)
gluLookAt(Pos.x-p.x,Pos.y-p.y,Pos.z-p.z,LookAt.x-p.x,LookAt.y-p.y,LookAt.z-p.z,vUp.x,vUp.y,vUp.z); //Ra: pOffset is zero gluLookAt(Pos.x - p.x, Pos.y - p.y, Pos.z - p.z, LookAt.x - p.x, LookAt.y - p.y,
LookAt.z - p.z, vUp.x, vUp.y, vUp.z); // Ra: pOffset is zero
} }
void __fastcall TCamera::RaLook() void __fastcall TCamera::RaLook()
{//zmiana kierunku patrzenia - przelicza Yaw { // zmiana kierunku patrzenia - przelicza Yaw
vector3 where=LookAt-Pos+vector3(0,3,0); //trochê w górê od szyn vector3 where = LookAt - Pos + vector3(0, 3, 0); // trochê w górê od szyn
if ((where.x!=0.0)||(where.z!=0.0)) if ((where.x != 0.0) || (where.z != 0.0))
Yaw=atan2(-where.x,-where.z); //k¹t horyzontalny Yaw = atan2(-where.x, -where.z); // k¹t horyzontalny
double l=Length3(where); double l = Length3(where);
if (l>0.0) if (l > 0.0)
Pitch=asin(where.y/l); //k¹t w pionie Pitch = asin(where.y / l); // k¹t w pionie
}; };
void __fastcall TCamera::Stop() void __fastcall TCamera::Stop()
{//wy³¹cznie bezw³adnego ruchu po powrocie do kabiny { // wy³¹cznie bezw³adnego ruchu po powrocie do kabiny
Type=tp_Follow; Type = tp_Follow;
Velocity=vector3(0,0,0); Velocity = vector3(0, 0, 0);
}; };

29
Camera.h
View File

@@ -2,46 +2,45 @@
#ifndef CameraH #ifndef CameraH
#define CameraH #define CameraH
#include "dumb3d.h" #include "dumb3d.h"
using namespace Math3D; using namespace Math3D;
//--------------------------------------------------------------------------- //---------------------------------------------------------------------------
enum TCameraType enum TCameraType
{//tryby pracy kamery { // tryby pracy kamery
tp_Follow, //jazda z pojazdem tp_Follow, // jazda z pojazdem
tp_Free, //stoi na scenerii tp_Free, // stoi na scenerii
tp_Satelite //widok z góry (nie używany) tp_Satelite // widok z góry (nie używany)
}; };
class TCamera class TCamera
{ {
private: private:
vector3 pOffset; //nie używane (zerowe) vector3 pOffset; // nie używane (zerowe)
public: //McZapkie: potrzebuje do kiwania na boki public: // McZapkie: potrzebuje do kiwania na boki
double Pitch; double Pitch;
double Yaw; //w środku: 0=do przodu; na zewnątrz: 0=na południe double Yaw; // w środku: 0=do przodu; na zewnątrz: 0=na południe
double Roll; double Roll;
TCameraType Type; TCameraType Type;
vector3 Pos; //współrzędne obserwatora vector3 Pos; // współrzędne obserwatora
vector3 LookAt; //współrzędne punktu, na który ma patrzeć vector3 LookAt; // współrzędne punktu, na który ma patrzeć
vector3 vUp; vector3 vUp;
vector3 Velocity; vector3 Velocity;
vector3 OldVelocity; //lepiej usredniac zeby nie bylo rozbiezne przy malym FPS vector3 OldVelocity; // lepiej usredniac zeby nie bylo rozbiezne przy malym FPS
vector3 CrossPos; vector3 CrossPos;
double CrossDist; double CrossDist;
void __fastcall Init(vector3 NPos, vector3 NAngle); void __fastcall Init(vector3 NPos, vector3 NAngle);
void __fastcall Reset() { Pitch=Yaw=Roll= 0; }; void __fastcall Reset() { Pitch = Yaw = Roll = 0; };
void __fastcall OnCursorMove(double x, double y); void __fastcall OnCursorMove(double x, double y);
void __fastcall Update(); void __fastcall Update();
vector3 __fastcall GetDirection(); vector3 __fastcall GetDirection();
//vector3 inline __fastcall GetCrossPos() { return Pos+GetDirection()*CrossDist+CrossPos; }; // vector3 inline __fastcall GetCrossPos() { return Pos+GetDirection()*CrossDist+CrossPos; };
bool __fastcall SetMatrix(); bool __fastcall SetMatrix();
void __fastcall SetCabMatrix(vector3 &p); void __fastcall SetCabMatrix(vector3 &p);
void __fastcall RaLook(); void __fastcall RaLook();
void __fastcall Stop(); void __fastcall Stop();
//bool __fastcall GetMatrix(matrix4x4 &Matrix); // bool __fastcall GetMatrix(matrix4x4 &Matrix);
vector3 PtNext, PtPrev; vector3 PtNext, PtPrev;
}; };
#endif #endif

42
Classes.h
View File

@@ -3,24 +3,24 @@
#ifndef ClassesH #ifndef ClassesH
#define ClassesH #define ClassesH
//--------------------------------------------------------------------------- //---------------------------------------------------------------------------
//Ra: zestaw klas do robienia wskaźników, aby uporządkować nagłówki // Ra: zestaw klas do robienia wskaźników, aby uporządkować nagłówki
//--------------------------------------------------------------------------- //---------------------------------------------------------------------------
class TTrack; //odcinek trajektorii class TTrack; // odcinek trajektorii
class TEvent; class TEvent;
class TTrain; //pojazd sterowany class TTrain; // pojazd sterowany
class TDynamicObject; //pojazd w scenerii class TDynamicObject; // pojazd w scenerii
class TGroundNode; //statyczny obiekt scenerii class TGroundNode; // statyczny obiekt scenerii
class TAnimModel; //opakowanie egzemplarz modelu class TAnimModel; // opakowanie egzemplarz modelu
class TAnimContainer; //fragment opakowania egzemplarza modelu class TAnimContainer; // fragment opakowania egzemplarza modelu
//class TModel3d; //siatka modelu wspólna dla egzemplarzy // class TModel3d; //siatka modelu wspólna dla egzemplarzy
class TSubModel; //fragment modelu (tu do wyświetlania terenu) class TSubModel; // fragment modelu (tu do wyświetlania terenu)
class TMemCell; //komórka pamięci class TMemCell; // komórka pamięci
class cParser; class cParser;
class TRealSound; //dźwięk ze współrzędnymi XYZ class TRealSound; // dźwięk ze współrzędnymi XYZ
class TTextSound; //dźwięk ze stenogramem class TTextSound; // dźwięk ze stenogramem
class TEventLauncher; class TEventLauncher;
class TTraction; //drut class TTraction; // drut
class TTractionPowerSource; //zasilanie drutów class TTractionPowerSource; // zasilanie drutów
class TMoverParameters; class TMoverParameters;
namespace _mover namespace _mover
@@ -31,16 +31,16 @@ class TRotation;
namespace Mtable namespace Mtable
{ {
class TTrainParameters; //rozkład jazdy class TTrainParameters; // rozkład jazdy
}; };
class TController; //obiekt sterujący pociągiem (AI) class TController; // obiekt sterujący pociągiem (AI)
class TNames; //obiekt sortujący nazwy class TNames; // obiekt sortujący nazwy
typedef enum typedef enum
{//binarne odpowiedniki komend w komórce pamięci { // binarne odpowiedniki komend w komórce pamięci
cm_Unknown, //ciąg nierozpoznany (nie jest komendą) cm_Unknown, // ciąg nierozpoznany (nie jest komendą)
cm_Ready, //W4 zezwala na odjazd, ale semafor może zatrzymać cm_Ready, // W4 zezwala na odjazd, ale semafor może zatrzymać
cm_SetVelocity, cm_SetVelocity,
cm_ShuntVelocity, cm_ShuntVelocity,
cm_SetProximityVelocity, cm_SetProximityVelocity,
@@ -48,7 +48,7 @@ typedef enum
cm_PassengerStopPoint, cm_PassengerStopPoint,
cm_OutsideStation, cm_OutsideStation,
cm_Shunt, cm_Shunt,
cm_Command //komenda pobierana z komórki cm_Command // komenda pobierana z komórki
} TCommandType; } TCommandType;
#endif #endif

335
Console.cpp
View File

@@ -11,9 +11,9 @@
//--------------------------------------------------------------------------- //---------------------------------------------------------------------------
#pragma package(smart_init) #pragma package(smart_init)
//Ra: klasa statyczna gromadząca sygnały sterujące oraz informacje zwrotne // Ra: klasa statyczna gromadząca sygnały sterujące oraz informacje zwrotne
//Ra: stan wejścia zmieniany klawiaturą albo dedykowanym urządzeniem // Ra: stan wejścia zmieniany klawiaturą albo dedykowanym urządzeniem
//Ra: stan wyjścia zmieniany przez symulację (mierniki, kontrolki) // Ra: stan wyjścia zmieniany przez symulację (mierniki, kontrolki)
/******************************* /*******************************
Do klawisza klawiatury przypisana jest maska bitowa oraz numer wejścia. Do klawisza klawiatury przypisana jest maska bitowa oraz numer wejścia.
@@ -73,44 +73,44 @@ public static Int32 GetScreenSaverTimeout()
}; };
*/ */
//Ra: do poprawienia // Ra: do poprawienia
void SetLedState(char Code,bool bOn) void SetLedState(char Code, bool bOn)
{//Ra: bajer do migania LED-ami w klawiaturze { // Ra: bajer do migania LED-ami w klawiaturze
if (Win32Platform==VER_PLATFORM_WIN32_NT) if (Win32Platform == VER_PLATFORM_WIN32_NT)
{ {
//WriteLog(AnsiString(int(GetAsyncKeyState(Code)))); // WriteLog(AnsiString(int(GetAsyncKeyState(Code))));
if (bool(GetAsyncKeyState(Code))!=bOn) if (bool(GetAsyncKeyState(Code)) != bOn)
{ {
keybd_event(Code,MapVirtualKey(Code,0),KEYEVENTF_EXTENDEDKEY,0); keybd_event(Code, MapVirtualKey(Code, 0), KEYEVENTF_EXTENDEDKEY, 0);
keybd_event(Code,MapVirtualKey(Code,0),KEYEVENTF_EXTENDEDKEY|KEYEVENTF_KEYUP,0); keybd_event(Code, MapVirtualKey(Code, 0), KEYEVENTF_EXTENDEDKEY | KEYEVENTF_KEYUP, 0);
} }
} }
else else
{ {
TKeyboardState KBState; TKeyboardState KBState;
GetKeyboardState(KBState); GetKeyboardState(KBState);
KBState[Code]=bOn?1:0; KBState[Code] = bOn ? 1 : 0;
SetKeyboardState(KBState); SetKeyboardState(KBState);
}; };
}; };
//--------------------------------------------------------------------------- //---------------------------------------------------------------------------
int Console::iBits=0; //zmienna statyczna - obiekt Console jest jednen wspólny int Console::iBits = 0; // zmienna statyczna - obiekt Console jest jednen wspólny
int Console::iMode=0; int Console::iMode = 0;
int Console::iConfig=0; int Console::iConfig = 0;
TPoKeys55 *Console::PoKeys55[2]={NULL,NULL}; TPoKeys55 *Console::PoKeys55[2] = {NULL, NULL};
TLPT *Console::LPT=NULL; TLPT *Console::LPT = NULL;
int Console::iSwitch[8]; //bistabilne w kabinie, załączane z [Shift], wyłączane bez int Console::iSwitch[8]; // bistabilne w kabinie, załączane z [Shift], wyłączane bez
int Console::iButton[8]; //monostabilne w kabinie, załączane podczas trzymania klawisza int Console::iButton[8]; // monostabilne w kabinie, załączane podczas trzymania klawisza
__fastcall Console::Console() __fastcall Console::Console()
{ {
PoKeys55[0]=PoKeys55[1]=NULL; PoKeys55[0] = PoKeys55[1] = NULL;
for (int i=0;i<8;++i) for (int i = 0; i < 8; ++i)
{//zerowanie przełączników { // zerowanie przełączników
iSwitch[i]=0; //bity 0..127 - bez [Ctrl], 128..255 - z [Ctrl] iSwitch[i] = 0; // bity 0..127 - bez [Ctrl], 128..255 - z [Ctrl]
iButton[i]=0; //bity 0..127 - bez [Shift], 128..255 - z [Shift] iButton[i] = 0; // bity 0..127 - bez [Shift], 128..255 - z [Shift]
} }
}; };
@@ -120,44 +120,46 @@ __fastcall Console::~Console()
delete PoKeys55[1]; delete PoKeys55[1];
}; };
void __fastcall Console::ModeSet(int m,int h) void __fastcall Console::ModeSet(int m, int h)
{//ustawienie trybu pracy { // ustawienie trybu pracy
iMode=m; iMode = m;
iConfig=h; iConfig = h;
}; };
int __fastcall Console::On() int __fastcall Console::On()
{//załączenie konsoli (np. nawiązanie komunikacji) { // załączenie konsoli (np. nawiązanie komunikacji)
iSwitch[0]=iSwitch[1]=iSwitch[2]=iSwitch[3]=0; //bity 0..127 - bez [Ctrl] iSwitch[0] = iSwitch[1] = iSwitch[2] = iSwitch[3] = 0; // bity 0..127 - bez [Ctrl]
iSwitch[4]=iSwitch[5]=iSwitch[6]=iSwitch[7]=0; //bity 128..255 - z [Ctrl] iSwitch[4] = iSwitch[5] = iSwitch[6] = iSwitch[7] = 0; // bity 128..255 - z [Ctrl]
switch (iMode) switch (iMode)
{case 1: //kontrolki klawiatury {
case 2: //kontrolki klawiatury case 1: // kontrolki klawiatury
iConfig=0; //licznik użycia Scroll Lock case 2: // kontrolki klawiatury
iConfig = 0; // licznik użycia Scroll Lock
break; break;
case 3: //LPT case 3: // LPT
LPT=new TLPT(); //otwarcie inpout32.dll LPT = new TLPT(); // otwarcie inpout32.dll
if (LPT?LPT->Connect(iConfig):false) if (LPT ? LPT->Connect(iConfig) : false)
{//wysłać 0? { // wysłać 0?
BitsUpdate(-1); //aktualizacjia stanów, bo przy wczytywaniu mogło być nieaktywne BitsUpdate(-1); // aktualizacjia stanów, bo przy wczytywaniu mogło być nieaktywne
WriteLog("Feedback Mode 3: InpOut32.dll OK"); WriteLog("Feedback Mode 3: InpOut32.dll OK");
} }
else else
{//połączenie nie wyszło, ma być NULL { // połączenie nie wyszło, ma być NULL
delete LPT; delete LPT;
LPT=NULL; LPT = NULL;
} }
break; break;
case 4: //PoKeys case 4: // PoKeys
PoKeys55[0]=new TPoKeys55(); PoKeys55[0] = new TPoKeys55();
if (PoKeys55[0]?PoKeys55[0]->Connect():false) if (PoKeys55[0] ? PoKeys55[0]->Connect() : false)
{WriteLog("Found "+PoKeys55[0]->Version()); {
BitsUpdate(-1); //aktualizacjia stanów, bo przy wczytywaniu mogło być nieaktywne WriteLog("Found " + PoKeys55[0]->Version());
BitsUpdate(-1); // aktualizacjia stanów, bo przy wczytywaniu mogło być nieaktywne
} }
else else
{//połączenie nie wyszło, ma być NULL { // połączenie nie wyszło, ma być NULL
delete PoKeys55[0]; delete PoKeys55[0];
PoKeys55[0]=NULL; PoKeys55[0] = NULL;
} }
break; break;
} }
@@ -165,183 +167,184 @@ int __fastcall Console::On()
}; };
void __fastcall Console::Off() void __fastcall Console::Off()
{//wyłączenie informacji zwrotnych (reset pulpitu) { // wyłączenie informacji zwrotnych (reset pulpitu)
BitsClear(-1); BitsClear(-1);
if ((iMode==1)||(iMode==2)) if ((iMode == 1) || (iMode == 2))
if (iConfig&1) //licznik użycia Scroll Lock if (iConfig & 1) // licznik użycia Scroll Lock
{//bez sensu to jest, ale mi się samo włącza { // bez sensu to jest, ale mi się samo włącza
SetLedState(VK_SCROLL,true); //przyciśnięty SetLedState(VK_SCROLL, true); // przyciśnięty
SetLedState(VK_SCROLL,false); //zwolniony SetLedState(VK_SCROLL, false); // zwolniony
} }
delete PoKeys55[0]; PoKeys55[0]=NULL; delete PoKeys55[0];
delete PoKeys55[1]; PoKeys55[1]=NULL; PoKeys55[0] = NULL;
delete LPT; LPT=NULL; delete PoKeys55[1];
PoKeys55[1] = NULL;
delete LPT;
LPT = NULL;
}; };
void __fastcall Console::BitsSet(int mask,int entry) void __fastcall Console::BitsSet(int mask, int entry)
{//ustawienie bitów o podanej masce (mask) na wejściu (entry) { // ustawienie bitów o podanej masce (mask) na wejściu (entry)
if ((iBits&mask)!=mask) //jeżeli zmiana if ((iBits & mask) != mask) // jeżeli zmiana
{int old=iBits; //poprzednie stany {
iBits|=mask; int old = iBits; // poprzednie stany
BitsUpdate(old^iBits); //1 dla bitów zmienionych iBits |= mask;
BitsUpdate(old ^ iBits); // 1 dla bitów zmienionych
} }
}; };
void __fastcall Console::BitsClear(int mask,int entry) void __fastcall Console::BitsClear(int mask, int entry)
{//zerowanie bitów o podanej masce (mask) na wejściu (entry) { // zerowanie bitów o podanej masce (mask) na wejściu (entry)
if (iBits&mask) //jeżeli zmiana if (iBits & mask) // jeżeli zmiana
{int old=iBits; //poprzednie stany {
iBits&=~mask; int old = iBits; // poprzednie stany
BitsUpdate(old^iBits); //1 dla bitów zmienionych iBits &= ~mask;
BitsUpdate(old ^ iBits); // 1 dla bitów zmienionych
} }
}; };
void __fastcall Console::BitsUpdate(int mask) void __fastcall Console::BitsUpdate(int mask)
{//aktualizacja stanu interfejsu informacji zwrotnej; (mask) - zakres zmienianych bitów { // aktualizacja stanu interfejsu informacji zwrotnej; (mask) - zakres zmienianych bitów
switch (iMode) switch (iMode)
{case 1: //sterowanie światełkami klawiatury: CA/SHP+opory {
if (mask&3) //gdy SHP albo CA case 1: // sterowanie światełkami klawiatury: CA/SHP+opory
SetLedState(VK_CAPITAL,iBits&3); if (mask & 3) // gdy SHP albo CA
if (mask&4) //gdy jazda na oporach SetLedState(VK_CAPITAL, iBits & 3);
{//Scroll Lock ma jakoś dziwnie... zmiana stanu na przeciwny if (mask & 4) // gdy jazda na oporach
SetLedState(VK_SCROLL,true); //przyciśnięty { // Scroll Lock ma jakoś dziwnie... zmiana stanu na przeciwny
SetLedState(VK_SCROLL,false); //zwolniony SetLedState(VK_SCROLL, true); // przyciśnięty
++iConfig; //licznik użycia Scroll Lock SetLedState(VK_SCROLL, false); // zwolniony
++iConfig; // licznik użycia Scroll Lock
} }
break; break;
case 2: //sterowanie światełkami klawiatury: CA+SHP case 2: // sterowanie światełkami klawiatury: CA+SHP
if (mask&2) //gdy CA if (mask & 2) // gdy CA
SetLedState(VK_CAPITAL,iBits&2); SetLedState(VK_CAPITAL, iBits & 2);
if (mask&1) //gdy SHP if (mask & 1) // gdy SHP
{//Scroll Lock ma jakoś dziwnie... zmiana stanu na przeciwny { // Scroll Lock ma jakoś dziwnie... zmiana stanu na przeciwny
SetLedState(VK_SCROLL,true); //przyciśnięty SetLedState(VK_SCROLL, true); // przyciśnięty
SetLedState(VK_SCROLL,false); //zwolniony SetLedState(VK_SCROLL, false); // zwolniony
++iConfig; //licznik użycia Scroll Lock ++iConfig; // licznik użycia Scroll Lock
} }
break; break;
case 3: //LPT Marcela z modyfikacją (jazda na oporach zamiast brzęczyka) case 3: // LPT Marcela z modyfikacją (jazda na oporach zamiast brzęczyka)
if (LPT) if (LPT)
LPT->Out(iBits); LPT->Out(iBits);
break; break;
case 4: //PoKeys55 wg Marcela - wersja druga z końca 2012 case 4: // PoKeys55 wg Marcela - wersja druga z końca 2012
if (PoKeys55[0]) if (PoKeys55[0])
{//pewnie trzeba będzie to dodatkowo buforować i oczekiwać na potwierdzenie { // pewnie trzeba będzie to dodatkowo buforować i oczekiwać na potwierdzenie
if (mask&0x0001) //b0 gdy SHP if (mask & 0x0001) // b0 gdy SHP
PoKeys55[0]->Write(0x40,23-1,iBits&0x0001?1:0); PoKeys55[0]->Write(0x40, 23 - 1, iBits & 0x0001 ? 1 : 0);
if (mask&0x0002) //b1 gdy zmieniony CA if (mask & 0x0002) // b1 gdy zmieniony CA
PoKeys55[0]->Write(0x40,24-1,iBits&0x0002?1:0); PoKeys55[0]->Write(0x40, 24 - 1, iBits & 0x0002 ? 1 : 0);
if (mask&0x0004) //b2 gdy jazda na oporach if (mask & 0x0004) // b2 gdy jazda na oporach
PoKeys55[0]->Write(0x40,32-1,iBits&0x0004?1:0); PoKeys55[0]->Write(0x40, 32 - 1, iBits & 0x0004 ? 1 : 0);
if (mask&0x0008) //b3 Lampka WS (wyłącznika szybkiego) if (mask & 0x0008) // b3 Lampka WS (wyłącznika szybkiego)
PoKeys55[0]->Write(0x40,25-1,iBits&0x0008?1:0); PoKeys55[0]->Write(0x40, 25 - 1, iBits & 0x0008 ? 1 : 0);
if (mask&0x0010) //b4 Lampka przekaźnika nadmiarowego silników trakcyjnych if (mask & 0x0010) // b4 Lampka przekaźnika nadmiarowego silników trakcyjnych
PoKeys55[0]->Write(0x40,27-1,iBits&0x0010?1:0); PoKeys55[0]->Write(0x40, 27 - 1, iBits & 0x0010 ? 1 : 0);
if (mask&0x0020) //b5 Lampka styczników liniowych if (mask & 0x0020) // b5 Lampka styczników liniowych
PoKeys55[0]->Write(0x40,29-1,iBits&0x0020?1:0); PoKeys55[0]->Write(0x40, 29 - 1, iBits & 0x0020 ? 1 : 0);
if (mask&0x0040) //b6 Lampka poślizgu if (mask & 0x0040) // b6 Lampka poślizgu
PoKeys55[0]->Write(0x40,30-1,iBits&0x0040?1:0); PoKeys55[0]->Write(0x40, 30 - 1, iBits & 0x0040 ? 1 : 0);
if (mask&0x0080) //b7 Lampka "przetwornicy" if (mask & 0x0080) // b7 Lampka "przetwornicy"
PoKeys55[0]->Write(0x40,28-1,iBits&0x0080?1:0); PoKeys55[0]->Write(0x40, 28 - 1, iBits & 0x0080 ? 1 : 0);
if (mask&0x0100) //b8 Kontrolka przekaźnika nadmiarowego sprężarki if (mask & 0x0100) // b8 Kontrolka przekaźnika nadmiarowego sprężarki
PoKeys55[0]->Write(0x40,33-1,iBits&0x0100?1:0); PoKeys55[0]->Write(0x40, 33 - 1, iBits & 0x0100 ? 1 : 0);
if (mask&0x0200) //b9 Kontrolka sygnalizacji wentylatorów i oporów if (mask & 0x0200) // b9 Kontrolka sygnalizacji wentylatorów i oporów
PoKeys55[0]->Write(0x40,26-1,iBits&0x0200?1:0); PoKeys55[0]->Write(0x40, 26 - 1, iBits & 0x0200 ? 1 : 0);
if (mask&0x0400) //b10 Kontrolka wysokiego rozruchu if (mask & 0x0400) // b10 Kontrolka wysokiego rozruchu
PoKeys55[0]->Write(0x40,31-1,iBits&0x0400?1:0); PoKeys55[0]->Write(0x40, 31 - 1, iBits & 0x0400 ? 1 : 0);
if (mask&0x0800) //b11 Kontrolka ogrzewania pociągu if (mask & 0x0800) // b11 Kontrolka ogrzewania pociągu
PoKeys55[0]->Write(0x40,34-1,iBits&0x0800?1:0); PoKeys55[0]->Write(0x40, 34 - 1, iBits & 0x0800 ? 1 : 0);
if (mask&0x1000) //b12 Ciśnienie w cylindrach do odbijania w haslerze if (mask & 0x1000) // b12 Ciśnienie w cylindrach do odbijania w haslerze
PoKeys55[0]->Write(0x40,52-1,iBits&0x1000?1:0); PoKeys55[0]->Write(0x40, 52 - 1, iBits & 0x1000 ? 1 : 0);
if (mask&0x2000) //b13 Prąd na silnikach do odbijania w haslerze if (mask & 0x2000) // b13 Prąd na silnikach do odbijania w haslerze
PoKeys55[0]->Write(0x40,53-1,iBits&0x2000?1:0); PoKeys55[0]->Write(0x40, 53 - 1, iBits & 0x2000 ? 1 : 0);
} }
break; break;
} }
}; };
bool __fastcall Console::Pressed(int x) bool __fastcall Console::Pressed(int x) { // na razie tak - czyta się tylko klawiatura return Global::bActive && (GetKeyState(x) < 0); };
{//na razie tak - czyta się tylko klawiatura
return Global::bActive&&(GetKeyState(x)<0);
};
void __fastcall Console::ValueSet(int x,double y) void __fastcall Console::ValueSet(int x, double y)
{//ustawienie wartości (y) na kanale analogowym (x) { // ustawienie wartości (y) na kanale analogowym (x)
if (iMode==4) if (iMode == 4)
if (PoKeys55[0]) if (PoKeys55[0])
{ {
PoKeys55[0]->PWM(x,(((Global::fCalibrateOut[x][3]*y)+Global::fCalibrateOut[x][2])*y+Global::fCalibrateOut[x][1])*y+Global::fCalibrateOut[x][0]); //zakres <0;1> PoKeys55[0]->PWM(
x, (((Global::fCalibrateOut[x][3] * y) + Global::fCalibrateOut[x][2]) * y +
Global::fCalibrateOut[x][1]) *
y +
Global::fCalibrateOut[x][0]); // zakres <0;1>
} }
}; };
void __fastcall Console::Update() void __fastcall Console::Update()
{//funkcja powinna być wywoływana regularnie, np. raz w każdej ramce ekranowej { // funkcja powinna być wywoływana regularnie, np. raz w każdej ramce ekranowej
if (iMode==4) if (iMode == 4)
if (PoKeys55[0]) if (PoKeys55[0])
if (PoKeys55[0]->Update((Global::iPause&8)>0)) if (PoKeys55[0]->Update((Global::iPause & 8) > 0))
{//wykrycie przestawionych przełączników? { // wykrycie przestawionych przełączników?
Global::iPause&=~8; Global::iPause &= ~8;
} }
else else
{//błąd komunikacji - zapauzować symulację? { // błąd komunikacji - zapauzować symulację?
if (!(Global::iPause&8)) //jeśli jeszcze nie oflagowana if (!(Global::iPause & 8)) // jeśli jeszcze nie oflagowana
Global::iTextMode=VK_F1; //pokazanie czasu/pauzy Global::iTextMode = VK_F1; // pokazanie czasu/pauzy
Global::iPause|=8; //tak??? Global::iPause |= 8; // tak???
PoKeys55[0]->Connect(); //próba ponownego podłączenia PoKeys55[0]->Connect(); // próba ponownego podłączenia
} }
}; };
float __fastcall Console::AnalogGet(int x) float __fastcall Console::AnalogGet(int x)
{//pobranie wartości analogowej { // pobranie wartości analogowej
if (iMode==4) if (iMode == 4)
if (PoKeys55[0]) if (PoKeys55[0])
return PoKeys55[0]->fAnalog[x]; return PoKeys55[0]->fAnalog[x];
return -1.0; return -1.0;
}; };
unsigned char __fastcall Console::DigitalGet(int x) unsigned char __fastcall Console::DigitalGet(int x)
{//pobranie wartości cyfrowej { // pobranie wartości cyfrowej
if (iMode==4) if (iMode == 4)
if (PoKeys55[0]) if (PoKeys55[0])
return PoKeys55[0]->iInputs[x]; return PoKeys55[0]->iInputs[x];
return 0; return 0;
}; };
void __fastcall Console::OnKeyDown(int k) void __fastcall Console::OnKeyDown(int k)
{//naciśnięcie klawisza z powoduje wyłączenie, a { // naciśnięcie klawisza z powoduje wyłączenie, a
if (k&0x10000) //jeśli [Shift] if (k & 0x10000) // jeśli [Shift]
{//ustawienie bitu w tabeli przełączników bistabilnych { // ustawienie bitu w tabeli przełączników bistabilnych
if (k&0x20000) //jeśli [Ctrl], to zestaw dodatkowy if (k & 0x20000) // jeśli [Ctrl], to zestaw dodatkowy
iSwitch[4+(char(k)>>5)]|=1<<(k&31); //załącz bistabliny dodatkowy iSwitch[4 + (char(k) >> 5)] |= 1 << (k & 31); // załącz bistabliny dodatkowy
else else
{//z [Shift] włączenie bitu bistabilnego i dodatkowego monostabilnego { // z [Shift] włączenie bitu bistabilnego i dodatkowego monostabilnego
iSwitch[char(k)>>5]|=1<<(k&31); //załącz bistabliny podstawowy iSwitch[char(k) >> 5] |= 1 << (k & 31); // załącz bistabliny podstawowy
iButton[4+(char(k)>>5)]|=(1<<(k&31)); //załącz monostabilny dodatkowy iButton[4 + (char(k) >> 5)] |= (1 << (k & 31)); // załącz monostabilny dodatkowy
} }
} }
else else
{//zerowanie bitu w tabeli przełączników bistabilnych { // zerowanie bitu w tabeli przełączników bistabilnych
if (k&0x20000) //jeśli [Ctrl], to zestaw dodatkowy if (k & 0x20000) // jeśli [Ctrl], to zestaw dodatkowy
iSwitch[4+(char(k)>>5)]&=~(1<<(k&31)); //wyłącz bistabilny dodatkowy iSwitch[4 + (char(k) >> 5)] &= ~(1 << (k & 31)); // wyłącz bistabilny dodatkowy
else else
{iSwitch[char(k)>>5]&=~(1<<(k&31)); //wyłącz bistabilny podstawowy {
iButton[char(k)>>5]|=1<<(k&31); //załącz monostabilny podstawowy iSwitch[char(k) >> 5] &= ~(1 << (k & 31)); // wyłącz bistabilny podstawowy
iButton[char(k) >> 5] |= 1 << (k & 31); // załącz monostabilny podstawowy
} }
} }
}; };
void __fastcall Console::OnKeyUp(int k) void __fastcall Console::OnKeyUp(int k)
{//puszczenie klawisza w zasadzie nie ma znaczenia dla iSwitch, ale zeruje iButton { // puszczenie klawisza w zasadzie nie ma znaczenia dla iSwitch, ale zeruje iButton
if ((k&0x20000)==0) //monostabilne tylko bez [Ctrl] if ((k & 0x20000) == 0) // monostabilne tylko bez [Ctrl]
if (k&0x10000) //jeśli [Shift] if (k & 0x10000) // jeśli [Shift]
iButton[4+(char(k)>>5)]&=~(1<<(k&31)); //wyłącz monostabilny dodatkowy iButton[4 + (char(k) >> 5)] &= ~(1 << (k & 31)); // wyłącz monostabilny dodatkowy
else else
iButton[char(k)>>5]&=~(1<<(k&31)); //wyłącz monostabilny podstawowy iButton[char(k) >> 5] &= ~(1 << (k & 31)); // wyłącz monostabilny podstawowy
}; };
int __fastcall Console::KeyDownConvert(int k) int __fastcall Console::KeyDownConvert(int k) { return int(ktTable[k & 0x3FF].iDown); };
{ int __fastcall Console::KeyUpConvert(int k) { return int(ktTable[k & 0x3FF].iUp); };
return int(ktTable[k&0x3FF].iDown);
};
int __fastcall Console::KeyUpConvert(int k)
{
return int(ktTable[k&0x3FF].iUp);
};

51
Console.h
View File

@@ -3,45 +3,45 @@
#ifndef ConsoleH #ifndef ConsoleH
#define ConsoleH #define ConsoleH
//--------------------------------------------------------------------------- //---------------------------------------------------------------------------
class TConsoleDevice; //urządzenie podłączalne za pomocą DLL class TConsoleDevice; // urządzenie podłączalne za pomocą DLL
class TPoKeys55; class TPoKeys55;
class TLPT; class TLPT;
//klasy konwersji znaków wprowadzanych z klawiatury // klasy konwersji znaków wprowadzanych z klawiatury
class TKeyTrans class TKeyTrans
{//przekodowanie kodu naciśnięcia i zwolnienia klawisza { // przekodowanie kodu naciśnięcia i zwolnienia klawisza
public: public:
short int iDown,iUp; short int iDown, iUp;
}; };
class Console class Console
{//Ra: klasa statyczna gromadząca sygnały sterujące oraz informacje zwrotne { // Ra: klasa statyczna gromadząca sygnały sterujące oraz informacje zwrotne
//Ra: stan wejścia zmieniany klawiaturą albo dedykowanym urządzeniem // Ra: stan wejścia zmieniany klawiaturą albo dedykowanym urządzeniem
//Ra: stan wyjścia zmieniany przez symulację (mierniki, kontrolki) // Ra: stan wyjścia zmieniany przez symulację (mierniki, kontrolki)
private: private:
static int iMode; //tryb pracy static int iMode; // tryb pracy
static int iConfig; //dodatkowa informacja o sprzęcie (np. numer LPT) static int iConfig; // dodatkowa informacja o sprzęcie (np. numer LPT)
static int iBits; //podstawowy zestaw lampek static int iBits; // podstawowy zestaw lampek
static TPoKeys55 *PoKeys55[2]; //może ich być kilka static TPoKeys55 *PoKeys55[2]; // może ich być kilka
static TLPT *LPT; static TLPT *LPT;
static void __fastcall BitsUpdate(int mask); static void __fastcall BitsUpdate(int mask);
//zmienne dla trybu "jednokabinowego", potrzebne do współpracy z pulpitem (PoKeys) // zmienne dla trybu "jednokabinowego", potrzebne do współpracy z pulpitem (PoKeys)
//używając klawiatury, każdy pojazd powinien mieć własny stan przełączników // używając klawiatury, każdy pojazd powinien mieć własny stan przełączników
//bazowym sterowaniem jest wirtualny strumień klawiatury // bazowym sterowaniem jest wirtualny strumień klawiatury
//przy zmianie kabiny z PoKeys, do kabiny są wysyłane stany tych przycisków // przy zmianie kabiny z PoKeys, do kabiny są wysyłane stany tych przycisków
static int iSwitch[8]; //bistabilne w kabinie, załączane z [Shift], wyłączane bez static int iSwitch[8]; // bistabilne w kabinie, załączane z [Shift], wyłączane bez
static int iButton[8]; //monostabilne w kabinie, załączane podczas trzymania klawisza static int iButton[8]; // monostabilne w kabinie, załączane podczas trzymania klawisza
static TKeyTrans ktTable[4*256]; //tabela wczesnej konwersji klawiatury static TKeyTrans ktTable[4 * 256]; // tabela wczesnej konwersji klawiatury
public: public:
__fastcall Console(); __fastcall Console();
__fastcall ~Console(); __fastcall ~Console();
static void __fastcall ModeSet(int m,int h=0); static void __fastcall ModeSet(int m, int h = 0);
static void __fastcall BitsSet(int mask,int entry=0); static void __fastcall BitsSet(int mask, int entry = 0);
static void __fastcall BitsClear(int mask,int entry=0); static void __fastcall BitsClear(int mask, int entry = 0);
static int __fastcall On(); static int __fastcall On();
static void __fastcall Off(); static void __fastcall Off();
static bool __fastcall Pressed(int x); static bool __fastcall Pressed(int x);
static void __fastcall ValueSet(int x,double y); static void __fastcall ValueSet(int x, double y);
static void __fastcall Update(); static void __fastcall Update();
static float __fastcall AnalogGet(int x); static float __fastcall AnalogGet(int x);
static unsigned char __fastcall DigitalGet(int x); static unsigned char __fastcall DigitalGet(int x);
@@ -52,4 +52,3 @@ public:
}; };
#endif #endif

40
Console/LPT.cpp
View File

@@ -3,44 +3,42 @@
#include "LPT.h" #include "LPT.h"
#include <windows.h> #include <windows.h>
//LPT na USB: // LPT na USB:
//USB\VID_067B&PID_2305&REV_0200 // USB\VID_067B&PID_2305&REV_0200
//{9d7debbc-c85d-11d1-9eb4-006008c3a19a} //{9d7debbc-c85d-11d1-9eb4-006008c3a19a}
//USB\VID_067B&PID_2305\5&1E41AFF0&0&2 // USB\VID_067B&PID_2305\5&1E41AFF0&0&2
//IEEE-1284 Controller // IEEE-1284 Controller
HINSTANCE hDLL; HINSTANCE hDLL;
typedef USHORT (__stdcall *InPortType)(USHORT BasePort); typedef USHORT(__stdcall *InPortType)(USHORT BasePort);
typedef void (__stdcall *OutPortType)(USHORT BasePort, USHORT value); typedef void(__stdcall *OutPortType)(USHORT BasePort, USHORT value);
InPortType InPort; InPortType InPort;
OutPortType OutPort; OutPortType OutPort;
bool __fastcall TLPT::Connect(int port) bool __fastcall TLPT::Connect(int port)
{ {
//ladowanie dll-ki // ladowanie dll-ki
hDLL=LoadLibrary("inpout32.dll"); hDLL = LoadLibrary("inpout32.dll");
if (hDLL) if (hDLL)
{ {
InPort=(InPortType)GetProcAddress(hDLL,"Inp32"); InPort = (InPortType)GetProcAddress(hDLL, "Inp32");
OutPort=(OutPortType)GetProcAddress(hDLL,"Out32"); OutPort = (OutPortType)GetProcAddress(hDLL, "Out32");
} }
else else
return false; //MessageBox(NULL,"ERROR","B³¹d przy ³adowaniu pliku",MB_OK); return false; // MessageBox(NULL,"ERROR","B³¹d przy ³adowaniu pliku",MB_OK);
address=port; //&0xFFFFFC; //ostatnie 2 bity maj¹ byæ zerowe -> a niech sobie OUT-uj¹, gdzie chc¹ address =
switch (address) //nie dotyczy 0x3BC port; //&0xFFFFFC; //ostatnie 2 bity maj¹ byæ zerowe -> a niech sobie OUT-uj¹, gdzie chc¹
{case 0x0378: switch (address) // nie dotyczy 0x3BC
{
case 0x0378:
case 0x0278: case 0x0278:
OutPort(address+0x402,0); //SPP, czyli jednokierunkowe wyjœcie OutPort(address + 0x402, 0); // SPP, czyli jednokierunkowe wyjœcie
break; break;
case 0xBC00: case 0xBC00:
case 0xBD00: case 0xBD00:
OutPort(address+0x006,0); //0xBC06? czysta improwizacja OutPort(address + 0x006, 0); // 0xBC06? czysta improwizacja
} }
return bool(OutPort); return bool(OutPort);
}; };
void __fastcall TLPT::Out(int x) void __fastcall TLPT::Out(int x) { // wys³anie bajtu do portu OutPort(address, x); };
{//wys³anie bajtu do portu
OutPort(address,x);
};

5
Console/LPT.h
View File

@@ -6,9 +6,10 @@
class TLPT class TLPT
{ {
private: private:
int address; int address;
public:
public:
bool __fastcall Connect(int port); bool __fastcall Connect(int port);
void __fastcall Out(int x); void __fastcall Out(int x);
}; };

463
Console/PoKeys55.cpp
View File

@@ -6,311 +6,360 @@
#include "PoKeys55.h" #include "PoKeys55.h"
//--------------------------------------------------------------------------- //---------------------------------------------------------------------------
#pragma package(smart_init) #pragma package(smart_init)
//HIDscaner: http://forum.simflight.com/topic/68257-latest-lua-package-for-fsuipc-and-wideclient/ // HIDscaner: http://forum.simflight.com/topic/68257-latest-lua-package-for-fsuipc-and-wideclient/
//#define MY_DEVICE_ID "Vid_04d8&Pid_003F" //#define MY_DEVICE_ID "Vid_04d8&Pid_003F"
//#define MY_DEVICE_ID "Vid_1dc3&Pid_1001&Rev_1000&MI_01" //#define MY_DEVICE_ID "Vid_1dc3&Pid_1001&Rev_1000&MI_01"
//HID\Vid_1dc3&Pid_1001&Rev_1000&MI_01 - MI_01 to jest interfejs komunikacyjny (00-joystick, 02-klawiatura) // HID\Vid_1dc3&Pid_1001&Rev_1000&MI_01 - MI_01 to jest interfejs komunikacyjny (00-joystick,
// 02-klawiatura)
HANDLE WriteHandle=INVALID_HANDLE_VALUE; HANDLE WriteHandle = INVALID_HANDLE_VALUE;
HANDLE ReadHandle =INVALID_HANDLE_VALUE; HANDLE ReadHandle = INVALID_HANDLE_VALUE;
//GUID InterfaceClassGuid={0x4d1e55b2,0xf16f,0x11cf,0x88,0xcb,0x00,0x11,0x11,0x00,0x00,0x30}; // GUID InterfaceClassGuid={0x4d1e55b2,0xf16f,0x11cf,0x88,0xcb,0x00,0x11,0x11,0x00,0x00,0x30};
//{4d1e55b2-f16f-11cf-88cb-001111000030} //{4d1e55b2-f16f-11cf-88cb-001111000030}
__fastcall TPoKeys55::TPoKeys55() __fastcall TPoKeys55::TPoKeys55()
{ {
cRequest=0; cRequest = 0;
iPWMbits=1; iPWMbits = 1;
iFaza=0; iFaza = 0;
iLastCommand=0; iLastCommand = 0;
fAnalog[0]=fAnalog[1]=fAnalog[2]=fAnalog[3]=fAnalog[4]=fAnalog[5]=fAnalog[6]=-1.0; fAnalog[0] = fAnalog[1] = fAnalog[2] = fAnalog[3] = fAnalog[4] = fAnalog[5] = fAnalog[6] = -1.0;
iPWM[0]=iPWM[1]=iPWM[2]=iPWM[3]=iPWM[4]=iPWM[5]=iPWM[6]=0; iPWM[0] = iPWM[1] = iPWM[2] = iPWM[3] = iPWM[4] = iPWM[5] = iPWM[6] = 0;
iPWM[7]=4096; iPWM[7] = 4096;
iInputs[0]=0; //czy normalnie s¹ w stanie wysokim? iInputs[0] = 0; // czy normalnie s¹ w stanie wysokim?
iRepeats=0; iRepeats = 0;
bNoError=true; bNoError = true;
}; };
//--------------------------------------------------------------------------- //---------------------------------------------------------------------------
__fastcall TPoKeys55::~TPoKeys55() __fastcall TPoKeys55::~TPoKeys55() { Close(); };
{
Close();
};
//--------------------------------------------------------------------------- //---------------------------------------------------------------------------
bool __fastcall TPoKeys55::Close() bool __fastcall TPoKeys55::Close()
{//roz³¹czenie komunikacji { // roz³¹czenie komunikacji
if (WriteHandle!=INVALID_HANDLE_VALUE) if (WriteHandle != INVALID_HANDLE_VALUE)
CloseHandle(WriteHandle); CloseHandle(WriteHandle);
WriteHandle=INVALID_HANDLE_VALUE; WriteHandle = INVALID_HANDLE_VALUE;
if (ReadHandle!=INVALID_HANDLE_VALUE) if (ReadHandle != INVALID_HANDLE_VALUE)
CloseHandle(ReadHandle); CloseHandle(ReadHandle);
ReadHandle=INVALID_HANDLE_VALUE; ReadHandle = INVALID_HANDLE_VALUE;
}; };
//--------------------------------------------------------------------------- //---------------------------------------------------------------------------
bool __fastcall TPoKeys55::Connect() bool __fastcall TPoKeys55::Connect()
{//Ra: to jest do wyczyszcznia z niepotrzebnych zmiennych i komunikatów { // Ra: to jest do wyczyszcznia z niepotrzebnych zmiennych i komunikatów
Close(); Close();
GUID InterfaceClassGuid={0x4d1e55b2,0xf16f,0x11cf,0x88,0xcb,0x00,0x11,0x11,0x00,0x00,0x30}; //wszystkie HID tak maj¹ GUID InterfaceClassGuid = {0x4d1e55b2, 0xf16f, 0x11cf, 0x88, 0xcb, 0x00,
0x11, 0x11, 0x00, 0x00, 0x30}; // wszystkie HID tak maj¹
HDEVINFO DeviceInfoTable; HDEVINFO DeviceInfoTable;
PSP_DEVICE_INTERFACE_DATA InterfaceDataStructure=new SP_DEVICE_INTERFACE_DATA; PSP_DEVICE_INTERFACE_DATA InterfaceDataStructure = new SP_DEVICE_INTERFACE_DATA;
PSP_DEVICE_INTERFACE_DETAIL_DATA DetailedInterfaceDataStructure=new SP_DEVICE_INTERFACE_DETAIL_DATA; PSP_DEVICE_INTERFACE_DETAIL_DATA DetailedInterfaceDataStructure =
new SP_DEVICE_INTERFACE_DETAIL_DATA;
SP_DEVINFO_DATA DevInfoData; SP_DEVINFO_DATA DevInfoData;
DWORD InterfaceIndex=0; DWORD InterfaceIndex = 0;
//DWORD StatusLastError=0; // DWORD StatusLastError=0;
DWORD dwRegType; DWORD dwRegType;
DWORD dwRegSize; DWORD dwRegSize;
DWORD StructureSize=0; DWORD StructureSize = 0;
PBYTE PropertyValueBuffer; PBYTE PropertyValueBuffer;
bool MatchFound; bool MatchFound;
DWORD ErrorStatus; DWORD ErrorStatus;
HDEVINFO hDevInfo; HDEVINFO hDevInfo;
String DeviceIDFromRegistry; String DeviceIDFromRegistry;
String DeviceIDToFind="Vid_1dc3&Pid_1001&Rev_1000&MI_01"; String DeviceIDToFind = "Vid_1dc3&Pid_1001&Rev_1000&MI_01";
//First populate a list of plugged in devices (by specifying "DIGCF_PRESENT"), which are of the specified class GUID. // First populate a list of plugged in devices (by specifying "DIGCF_PRESENT"), which are of the
DeviceInfoTable=SetupDiGetClassDevs(&InterfaceClassGuid,NULL,NULL,DIGCF_PRESENT|DIGCF_DEVICEINTERFACE); // specified class GUID.
//Now look through the list we just populated. We are trying to see if any of them match our device. DeviceInfoTable =
SetupDiGetClassDevs(&InterfaceClassGuid, NULL, NULL, DIGCF_PRESENT | DIGCF_DEVICEINTERFACE);
// Now look through the list we just populated. We are trying to see if any of them match our
// device.
while (true) while (true)
{ {
InterfaceDataStructure->cbSize=sizeof(SP_DEVICE_INTERFACE_DATA); InterfaceDataStructure->cbSize = sizeof(SP_DEVICE_INTERFACE_DATA);
if (SetupDiEnumDeviceInterfaces(DeviceInfoTable, NULL, &InterfaceClassGuid, InterfaceIndex, InterfaceDataStructure)) if (SetupDiEnumDeviceInterfaces(DeviceInfoTable, NULL, &InterfaceClassGuid, InterfaceIndex,
InterfaceDataStructure))
{ {
ErrorStatus=GetLastError(); ErrorStatus = GetLastError();
if (ERROR_NO_MORE_ITEMS==ErrorStatus) //Did we reach the end of the list of matching devices in the DeviceInfoTable? if (ERROR_NO_MORE_ITEMS == ErrorStatus) // Did we reach the end of the list of matching
{//Cound not find the device. Must not have been attached. // devices in the DeviceInfoTable?
SetupDiDestroyDeviceInfoList(DeviceInfoTable); //Clean up the old structure we no longer need. { // Cound not find the device. Must not have been attached.
//ShowMessage("Erreur: Sortie1"); SetupDiDestroyDeviceInfoList(
DeviceInfoTable); // Clean up the old structure we no longer need.
// ShowMessage("Erreur: Sortie1");
return false; return false;
} }
} }
else //Else some other kind of unknown error ocurred... else // Else some other kind of unknown error ocurred...
{ {
ErrorStatus=GetLastError(); ErrorStatus = GetLastError();
SetupDiDestroyDeviceInfoList(DeviceInfoTable); //Clean up the old structure we no longer need. SetupDiDestroyDeviceInfoList(
//ShowMessage("Erreur: Sortie2"); DeviceInfoTable); // Clean up the old structure we no longer need.
// ShowMessage("Erreur: Sortie2");
return false; return false;
} }
//Now retrieve the hardware ID from the registry. The hardware ID contains the VID and PID, which we will then // Now retrieve the hardware ID from the registry. The hardware ID contains the VID and PID,
//check to see if it is the correct device or not. // which we will then
//Initialize an appropriate SP_DEVINFO_DATA structure. We need this structure for SetupDiGetDeviceRegistryProperty(). // check to see if it is the correct device or not.
DevInfoData.cbSize=sizeof(SP_DEVINFO_DATA); // Initialize an appropriate SP_DEVINFO_DATA structure. We need this structure for
SetupDiEnumDeviceInfo(DeviceInfoTable,InterfaceIndex,&DevInfoData); // SetupDiGetDeviceRegistryProperty().
//First query for the size of the hardware ID, so we can know how big a buffer to allocate for the data. DevInfoData.cbSize = sizeof(SP_DEVINFO_DATA);
SetupDiGetDeviceRegistryProperty(DeviceInfoTable,&DevInfoData,SPDRP_HARDWAREID,&dwRegType,NULL,0,&dwRegSize); SetupDiEnumDeviceInfo(DeviceInfoTable, InterfaceIndex, &DevInfoData);
//Allocate a buffer for the hardware ID. // First query for the size of the hardware ID, so we can know how big a buffer to allocate
//PropertyValueBuffer=(BYTE*)malloc(dwRegSize); // for the data.
PropertyValueBuffer=new char[dwRegSize]; SetupDiGetDeviceRegistryProperty(DeviceInfoTable, &DevInfoData, SPDRP_HARDWAREID,
if (PropertyValueBuffer==NULL) //if null,error,couldn't allocate enough memory &dwRegType, NULL, 0, &dwRegSize);
{//Can't really recover from this situation,just exit instead. // Allocate a buffer for the hardware ID.
//ShowMessage("Allocation PropertyValueBuffer impossible"); // PropertyValueBuffer=(BYTE*)malloc(dwRegSize);
SetupDiDestroyDeviceInfoList(DeviceInfoTable); //Clean up the old structure we no longer need. PropertyValueBuffer = new char[dwRegSize];
if (PropertyValueBuffer == NULL) // if null,error,couldn't allocate enough memory
{ // Can't really recover from this situation,just exit instead.
// ShowMessage("Allocation PropertyValueBuffer impossible");
SetupDiDestroyDeviceInfoList(
DeviceInfoTable); // Clean up the old structure we no longer need.
return false; return false;
} }
//Retrieve the hardware IDs for the current device we are looking at. PropertyValueBuffer gets filled with a // Retrieve the hardware IDs for the current device we are looking at. PropertyValueBuffer
//REG_MULTI_SZ (array of null terminated strings). To find a device,we only care about the very first string in the // gets filled with a
//buffer,which will be the "device ID". The device ID is a string which contains the VID and PID,in the example // REG_MULTI_SZ (array of null terminated strings). To find a device,we only care about the
//format "Vid_04d8&Pid_003f". // very first string in the
SetupDiGetDeviceRegistryProperty(DeviceInfoTable,&DevInfoData,SPDRP_HARDWAREID,&dwRegType,PropertyValueBuffer,dwRegSize,NULL); // buffer,which will be the "device ID". The device ID is a string which contains the VID
//Now check if the first string in the hardware ID matches the device ID of my USB device. // and PID,in the example
//ListBox1->Items->Add((char*)PropertyValueBuffer); // format "Vid_04d8&Pid_003f".
DeviceIDFromRegistry=StrPas((char*)PropertyValueBuffer); SetupDiGetDeviceRegistryProperty(DeviceInfoTable, &DevInfoData, SPDRP_HARDWAREID,
//free(PropertyValueBuffer); //No longer need the PropertyValueBuffer,free the memory to prevent potential memory leaks &dwRegType, PropertyValueBuffer, dwRegSize, NULL);
delete PropertyValueBuffer; //No longer need the PropertyValueBuffer,free the memory to prevent potential memory leaks // Now check if the first string in the hardware ID matches the device ID of my USB device.
//Convert both strings to lower case. This makes the code more robust/portable accross OS Versions // ListBox1->Items->Add((char*)PropertyValueBuffer);
DeviceIDFromRegistry=DeviceIDFromRegistry.LowerCase(); DeviceIDFromRegistry = StrPas((char *)PropertyValueBuffer);
DeviceIDToFind=DeviceIDToFind.LowerCase(); // free(PropertyValueBuffer); //No longer need the PropertyValueBuffer,free the memory to
//Now check if the hardware ID we are looking at contains the correct VID/PID // prevent potential memory leaks
MatchFound=(DeviceIDFromRegistry.AnsiPos(DeviceIDToFind)>0); delete PropertyValueBuffer; // No longer need the PropertyValueBuffer,free the memory to
if (MatchFound==true) // prevent potential memory leaks
// Convert both strings to lower case. This makes the code more robust/portable accross OS
// Versions
DeviceIDFromRegistry = DeviceIDFromRegistry.LowerCase();
DeviceIDToFind = DeviceIDToFind.LowerCase();
// Now check if the hardware ID we are looking at contains the correct VID/PID
MatchFound = (DeviceIDFromRegistry.AnsiPos(DeviceIDToFind) > 0);
if (MatchFound == true)
{ {
//Device must have been found. Open read and write handles. In order to do this,we will need the actual device path first. // Device must have been found. Open read and write handles. In order to do this,we
//We can get the path by calling SetupDiGetDeviceInterfaceDetail(),however,we have to call this function twice: The first // will need the actual device path first.
//time to get the size of the required structure/buffer to hold the detailed interface data,then a second time to actually // We can get the path by calling SetupDiGetDeviceInterfaceDetail(),however,we have to
//get the structure (after we have allocated enough memory for the structure.) // call this function twice: The first
DetailedInterfaceDataStructure->cbSize=sizeof(SP_DEVICE_INTERFACE_DETAIL_DATA); // time to get the size of the required structure/buffer to hold the detailed interface
//First call populates "StructureSize" with the correct value // data,then a second time to actually
SetupDiGetDeviceInterfaceDetail(DeviceInfoTable,InterfaceDataStructure,NULL,NULL,&StructureSize,NULL); // get the structure (after we have allocated enough memory for the structure.)
DetailedInterfaceDataStructure=(PSP_DEVICE_INTERFACE_DETAIL_DATA)(malloc(StructureSize)); //Allocate enough memory DetailedInterfaceDataStructure->cbSize = sizeof(SP_DEVICE_INTERFACE_DETAIL_DATA);
if (DetailedInterfaceDataStructure==NULL) //if null,error,couldn't allocate enough memory // First call populates "StructureSize" with the correct value
{//Can't really recover from this situation,just exit instead. SetupDiGetDeviceInterfaceDetail(DeviceInfoTable, InterfaceDataStructure, NULL, NULL,
SetupDiDestroyDeviceInfoList(DeviceInfoTable); //Clean up the old structure we no longer need. &StructureSize, NULL);
DetailedInterfaceDataStructure =
(PSP_DEVICE_INTERFACE_DETAIL_DATA)(malloc(StructureSize)); // Allocate enough memory
if (DetailedInterfaceDataStructure ==
NULL) // if null,error,couldn't allocate enough memory
{ // Can't really recover from this situation,just exit instead.
SetupDiDestroyDeviceInfoList(
DeviceInfoTable); // Clean up the old structure we no longer need.
return false; return false;
} }
DetailedInterfaceDataStructure->cbSize=sizeof(SP_DEVICE_INTERFACE_DETAIL_DATA); DetailedInterfaceDataStructure->cbSize = sizeof(SP_DEVICE_INTERFACE_DETAIL_DATA);
//Now call SetupDiGetDeviceInterfaceDetail() a second time to receive the goods. // Now call SetupDiGetDeviceInterfaceDetail() a second time to receive the goods.
SetupDiGetDeviceInterfaceDetail(DeviceInfoTable,InterfaceDataStructure,DetailedInterfaceDataStructure,StructureSize,NULL,NULL); SetupDiGetDeviceInterfaceDetail(DeviceInfoTable, InterfaceDataStructure,
//We now have the proper device path,and we can finally open read and write handles to the device. DetailedInterfaceDataStructure, StructureSize, NULL,
//We store the handles in the global variables "WriteHandle" and "ReadHandle",which we will use later to actually communicate. NULL);
WriteHandle=CreateFile((DetailedInterfaceDataStructure->DevicePath),GENERIC_WRITE,FILE_SHARE_READ|FILE_SHARE_WRITE,NULL,OPEN_EXISTING,0,0); // We now have the proper device path,and we can finally open read and write handles to
ErrorStatus=GetLastError(); // the device.
//if (ErrorStatus==ERROR_SUCCESS) // We store the handles in the global variables "WriteHandle" and "ReadHandle",which we
// will use later to actually communicate.
WriteHandle = CreateFile((DetailedInterfaceDataStructure->DevicePath), GENERIC_WRITE,
FILE_SHARE_READ | FILE_SHARE_WRITE, NULL, OPEN_EXISTING, 0, 0);
ErrorStatus = GetLastError();
// if (ErrorStatus==ERROR_SUCCESS)
// ToggleLedBtn->Enabled=true;//Make button no longer greyed out // ToggleLedBtn->Enabled=true;//Make button no longer greyed out
ReadHandle=CreateFile((DetailedInterfaceDataStructure->DevicePath),GENERIC_READ,FILE_SHARE_READ|FILE_SHARE_WRITE,NULL,OPEN_EXISTING,0,0); ReadHandle = CreateFile((DetailedInterfaceDataStructure->DevicePath), GENERIC_READ,
ErrorStatus=GetLastError(); FILE_SHARE_READ | FILE_SHARE_WRITE, NULL, OPEN_EXISTING, 0, 0);
if (ErrorStatus==ERROR_SUCCESS) ErrorStatus = GetLastError();
if (ErrorStatus == ERROR_SUCCESS)
{ {
//GetPushbuttonState->Enabled=true;//Make button no longer greyed out // GetPushbuttonState->Enabled=true;//Make button no longer greyed out
//StateLabel->Enabled=true;//Make label no longer greyed out // StateLabel->Enabled=true;//Make label no longer greyed out
} }
SetupDiDestroyDeviceInfoList(DeviceInfoTable); //Clean up the old structure we no longer need. SetupDiDestroyDeviceInfoList(
iRepeats=0; //nowe szanse na pod³¹czenie DeviceInfoTable); // Clean up the old structure we no longer need.
iRepeats = 0; // nowe szanse na pod³¹czenie
return true; return true;
} }
InterfaceIndex++; InterfaceIndex++;
//Keep looping until we either find a device with matching VID and PID,or until we run out of items. // Keep looping until we either find a device with matching VID and PID,or until we run out
}//end of while(true) // of items.
//ShowMessage("Sortie"); } // end of while(true)
// ShowMessage("Sortie");
return false; return false;
} }
//--------------------------------------------------------------------------- //---------------------------------------------------------------------------
bool __fastcall TPoKeys55::Write(unsigned char c,unsigned char b3,unsigned char b4,unsigned char b5) bool __fastcall TPoKeys55::Write(unsigned char c, unsigned char b3, unsigned char b4,
unsigned char b5)
{ {
DWORD BytesWritten=0; DWORD BytesWritten = 0;
OutputBuffer[0]=0; //The first byte is the "Report ID" and does not get transmitted over the USB bus. Always set=0. OutputBuffer[0] = 0; // The first byte is the "Report ID" and does not get transmitted over the
OutputBuffer[1]=0xBB; //0xBB - bajt rozpoznawczy dla PoKeys55 // USB bus. Always set=0.
OutputBuffer[2]=iLastCommand=c; //operacja: 0x31: blokowy odczyt wejϾ OutputBuffer[1] = 0xBB; // 0xBB - bajt rozpoznawczy dla PoKeys55
OutputBuffer[3]=b3; //np. numer pinu (o 1 mniej ni¿ numer na p³ytce) OutputBuffer[2] = iLastCommand = c; // operacja: 0x31: blokowy odczyt wejœæ
OutputBuffer[4]=b4; OutputBuffer[3] = b3; // np. numer pinu (o 1 mniej ni¿ numer na p³ytce)
OutputBuffer[5]=b5; OutputBuffer[4] = b4;
OutputBuffer[6]=0; OutputBuffer[5] = b5;
OutputBuffer[7]=++cRequest; //numer ¿¹dania OutputBuffer[6] = 0;
OutputBuffer[8]=0; OutputBuffer[7] = ++cRequest; // numer ¿¹dania
for (int i=0;i<8;++i) OutputBuffer[8] = 0;
OutputBuffer[8]+=OutputBuffer[i]; //czy sumowaæ te¿ od 9 do 64? for (int i = 0; i < 8; ++i)
//The basic Windows I/O functions WriteFile() and ReadFile() can be used to read and write to HID class USB devices OutputBuffer[8] += OutputBuffer[i]; // czy sumowaæ te¿ od 9 do 64?
// The basic Windows I/O functions WriteFile() and ReadFile() can be used to read and write to
// HID class USB devices
//(once we have the read and write handles to the device, which are obtained with CreateFile()). //(once we have the read and write handles to the device, which are obtained with CreateFile()).
//The following call to WriteFile() sends 64 bytes of data to the USB device. // The following call to WriteFile() sends 64 bytes of data to the USB device.
WriteFile(WriteHandle,&OutputBuffer,65,&BytesWritten,0); //Blocking function, unless an "overlapped" structure is used WriteFile(WriteHandle, &OutputBuffer, 65, &BytesWritten,
return (BytesWritten==65); 0); // Blocking function, unless an "overlapped" structure is used
//Read(); //odczyt trzeba zrobiæ inaczej - w tym miejscu bêdzie za szybko i nic siê nie odczyta return (BytesWritten == 65);
// Read(); //odczyt trzeba zrobiæ inaczej - w tym miejscu bêdzie za szybko i nic siê nie odczyta
} }
//--------------------------------------------------------------------------- //---------------------------------------------------------------------------
bool __fastcall TPoKeys55::Read() bool __fastcall TPoKeys55::Read()
{ {
DWORD BytesRead=0; DWORD BytesRead = 0;
InputBuffer[0]=0; //The first byte is the "Report ID" and does not get transmitted over the USB bus. Always set=0. InputBuffer[0] = 0; // The first byte is the "Report ID" and does not get transmitted over the
//Now get the response packet from the firmware. // USB bus. Always set=0.
//The following call to ReadFIle() retrieves 64 bytes of data from the USB device. // Now get the response packet from the firmware.
ReadFile(ReadHandle,&InputBuffer,65,&BytesRead,0); //Blocking function,unless an "overlapped" structure is used // The following call to ReadFIle() retrieves 64 bytes of data from the USB device.
//InputPacketBuffer[0] is the report ID, which we don't care about. ReadFile(ReadHandle, &InputBuffer, 65, &BytesRead,
//InputPacketBuffer[1] is an echo back of the command. 0); // Blocking function,unless an "overlapped" structure is used
//InputPacketBuffer[2] contains the I/O port pin value for the pushbutton. // InputPacketBuffer[0] is the report ID, which we don't care about.
return (BytesRead==65)?InputBuffer[7]==cRequest:false; // InputPacketBuffer[1] is an echo back of the command.
// InputPacketBuffer[2] contains the I/O port pin value for the pushbutton.
return (BytesRead == 65) ? InputBuffer[7] == cRequest : false;
} }
//--------------------------------------------------------------------------- //---------------------------------------------------------------------------
bool __fastcall TPoKeys55::ReadLoop(int i) bool __fastcall TPoKeys55::ReadLoop(int i)
{//próbuje odczytaæ (i) razy { // próbuje odczytaæ (i) razy
do do
{if (Read()) return true; {
Sleep(1); //trochê poczekaæ, a¿ odpowie if (Read())
} return true;
while (--i); Sleep(1); // trochê poczekaæ, a¿ odpowie
} while (--i);
return false; return false;
} }
//--------------------------------------------------------------------------- //---------------------------------------------------------------------------
AnsiString __fastcall TPoKeys55::Version() AnsiString __fastcall TPoKeys55::Version()
{//zwraca numer wersji, funkcja nieoptymalna czasowo (czeka na odpowiedŸ) { // zwraca numer wersji, funkcja nieoptymalna czasowo (czeka na odpowiedŸ)
if (!WriteHandle) return ""; if (!WriteHandle)
Write(0x00,0); //0x00 - Read serial number, version return "";
Write(0x00, 0); // 0x00 - Read serial number, version
if (ReadLoop(10)) if (ReadLoop(10))
{//3: serial MSB; 4: serial LSB; 5: software version (v(1+[4-7]).([0-3])); 6: revision number { // 3: serial MSB; 4: serial LSB; 5: software version (v(1+[4-7]).([0-3])); 6: revision number
AnsiString s="PoKeys55 #"+AnsiString((InputBuffer[3]<<8)+InputBuffer[4]); AnsiString s = "PoKeys55 #" + AnsiString((InputBuffer[3] << 8) + InputBuffer[4]);
s+=" v"+AnsiString(1+(InputBuffer[5]>>4))+"."+AnsiString(InputBuffer[5]&15)+"."+AnsiString(InputBuffer[6]); s += " v" + AnsiString(1 + (InputBuffer[5] >> 4)) + "." + AnsiString(InputBuffer[5] & 15) +
/* //Ra: pozyskiwanie daty mo¿na sobie darowaæ, jest poniek¹d bez sensu "." + AnsiString(InputBuffer[6]);
Write(0x04,0); //0x04 - Read build date: drugi argument zmieniaæ od 0 do 2, uzyskuj¹c kolejno po 4 znaki /* //Ra: pozyskiwanie daty mo¿na sobie darowaæ, jest poniek¹d bez sensu
Write(0x04,0); //0x04 - Read build date: drugi argument zmieniaæ od 0 do 2, uzyskuj¹c
kolejno po 4 znaki
if (ReadLoop(5)) if (ReadLoop(5))
{//2: 0x04; 3-6: char 1-4, 5-8, 9-11; (83-65-112-32-32-49-32-50-48-49-49-0=="Sep 1 2011") {//2: 0x04; 3-6: char 1-4, 5-8, 9-11; (83-65-112-32-32-49-32-50-48-49-49-0=="Sep 1 2011")
s+=" ("+AnsiString((char*)InputBuffer+3,4); s+=" ("+AnsiString((char*)InputBuffer+3,4);
Write(0x04,1); //0x04 - Read build date: drugi argument zmieniaæ od 0 do 2, uzyskuj¹c kolejno po 4 znaki Write(0x04,1); //0x04 - Read build date: drugi argument zmieniaæ od 0 do 2, uzyskuj¹c
kolejno po 4 znaki
if (ReadLoop(5)) if (ReadLoop(5))
{s+=AnsiString((char*)InputBuffer+3,4); {s+=AnsiString((char*)InputBuffer+3,4);
Write(0x04,2); //0x04 - Read build date: drugi argument zmieniaæ od 0 do 2, uzyskuj¹c kolejno po 4 znaki Write(0x04,2); //0x04 - Read build date: drugi argument zmieniaæ od 0 do 2, uzyskuj¹c
kolejno po 4 znaki
if (ReadLoop(5)) if (ReadLoop(5))
s+=AnsiString((char*)InputBuffer+3,3); s+=AnsiString((char*)InputBuffer+3,3);
} }
s+=")"; s+=")";
} }
*/ */
return s; return s;
} }
return ""; return "";
}; };
bool __fastcall TPoKeys55::PWM(int x,float y) bool __fastcall TPoKeys55::PWM(int x, float y)
{//ustawienie wskazanego PWM (@12Mhz: 12000=1ms=1000Hz) { // ustawienie wskazanego PWM (@12Mhz: 12000=1ms=1000Hz)
//iPWM[7]=1024; //1024==85333.3333333333ns=11718.75Hz // iPWM[7]=1024; //1024==85333.3333333333ns=11718.75Hz
iPWM[x]=int(0.5f+0x0FFF*y)&0x0FFF; //0x0FFF=4095 iPWM[x] = int(0.5f + 0x0FFF * y) & 0x0FFF; // 0x0FFF=4095
return true; return true;
} }
bool __fastcall TPoKeys55::Update(bool pause) bool __fastcall TPoKeys55::Update(bool pause)
{//funkcja powinna byæ wywo³ywana regularnie, np. raz w ka¿dej ramce ekranowej { // funkcja powinna byæ wywo³ywana regularnie, np. raz w ka¿dej ramce ekranowej
if (pause) if (pause)
{//specjalna procedura, jeœli utracone po³¹czenie spowodowa³o pauzê { // specjalna procedura, jeœli utracone po³¹czenie spowodowa³o pauzê
iLastCommand=0; //po³¹czenie zosta³o na nowo otwarte iLastCommand = 0; // po³¹czenie zosta³o na nowo otwarte
//iFaza=0; //jeden b³¹d i podtrzymanie pauzy jest kontynuowane // iFaza=0; //jeden b³¹d i podtrzymanie pauzy jest kontynuowane
} }
switch (iFaza) switch (iFaza)
{case 0: //uaktualnienie PWM raz na jakiœ czas {
OutputBuffer[9]=0x3F; //maska u¿ytych PWM case 0: // uaktualnienie PWM raz na jakiœ czas
*((int*)(OutputBuffer+10))=iPWM[0]; //PWM1 (pin 22) OutputBuffer[9] = 0x3F; // maska u¿ytych PWM
*((int*)(OutputBuffer+14))=iPWM[1]; //PWM2 (pin 21) *((int *)(OutputBuffer + 10)) = iPWM[0]; // PWM1 (pin 22)
*((int*)(OutputBuffer+18))=iPWM[2]; //PWM3 (pin 20) *((int *)(OutputBuffer + 14)) = iPWM[1]; // PWM2 (pin 21)
*((int*)(OutputBuffer+22))=iPWM[3]; //PWM4 (pin 19) *((int *)(OutputBuffer + 18)) = iPWM[2]; // PWM3 (pin 20)
*((int*)(OutputBuffer+26))=iPWM[4]; //PWM5 (pin 18) *((int *)(OutputBuffer + 22)) = iPWM[3]; // PWM4 (pin 19)
*((int*)(OutputBuffer+30))=iPWM[5]; //PWM6 (pin 17) *((int *)(OutputBuffer + 26)) = iPWM[4]; // PWM5 (pin 18)
*((int*)(OutputBuffer+34))=iPWM[7]; //PWM period *((int *)(OutputBuffer + 30)) = iPWM[5]; // PWM6 (pin 17)
if (Write(0xCB,1)) //wys³anie ustawieñ (1-ustaw, 0-odczyt) *((int *)(OutputBuffer + 34)) = iPWM[7]; // PWM period
iRepeats=0; //informacja, ¿e posz³o dobrze if (Write(0xCB, 1)) // wys³anie ustawieñ (1-ustaw, 0-odczyt)
++iFaza; //ta faza zosta³a zakoñczona iRepeats = 0; // informacja, ¿e posz³o dobrze
//iRepeats=0; ++iFaza; // ta faza zosta³a zakoñczona
// iRepeats=0;
break; break;
case 1: //odczyt wejϾ analogowych - komenda i przetwarzanie case 1: // odczyt wejϾ analogowych - komenda i przetwarzanie
if (iLastCommand!=0x3A) //asynchroniczne ustawienie kontrolki mo¿e namieszaæ if (iLastCommand != 0x3A) // asynchroniczne ustawienie kontrolki mo¿e namieszaæ
Write(0x3A,0); //0x3A - Analog inputs reading – all analog inputs in one command Write(0x3A, 0); // 0x3A - Analog inputs reading – all analog inputs in one command
else if (Read()) else if (Read())
{//jest odebrana ramka i zgodnoœæ numeru ¿¹dania { // jest odebrana ramka i zgodnoœæ numeru ¿¹dania
fAnalog[0]=((InputBuffer[21]<<8)+InputBuffer[22])/4095.0f; //pin 47 fAnalog[0] = ((InputBuffer[21] << 8) + InputBuffer[22]) / 4095.0f; // pin 47
fAnalog[1]=((InputBuffer[19]<<8)+InputBuffer[20])/4095.0f; //pin 46 fAnalog[1] = ((InputBuffer[19] << 8) + InputBuffer[20]) / 4095.0f; // pin 46
fAnalog[2]=((InputBuffer[17]<<8)+InputBuffer[18])/4095.0f; //pin 45 fAnalog[2] = ((InputBuffer[17] << 8) + InputBuffer[18]) / 4095.0f; // pin 45
fAnalog[3]=((InputBuffer[15]<<8)+InputBuffer[16])/4095.0f; //pin 44 fAnalog[3] = ((InputBuffer[15] << 8) + InputBuffer[16]) / 4095.0f; // pin 44
fAnalog[4]=((InputBuffer[13]<<8)+InputBuffer[14])/4095.0f; //pin 43 fAnalog[4] = ((InputBuffer[13] << 8) + InputBuffer[14]) / 4095.0f; // pin 43
fAnalog[5]=((InputBuffer[11]<<8)+InputBuffer[12])/4095.0f; //pin 42 fAnalog[5] = ((InputBuffer[11] << 8) + InputBuffer[12]) / 4095.0f; // pin 42
fAnalog[6]=((InputBuffer[ 9]<<8)+InputBuffer[10])/4095.0f; //pin 41 fAnalog[6] = ((InputBuffer[9] << 8) + InputBuffer[10]) / 4095.0f; // pin 41
++iFaza; //skoro odczytano, mo¿na przejœæ do kolejnej fazy ++iFaza; // skoro odczytano, mo¿na przejœæ do kolejnej fazy
iRepeats=0; //zerowanie licznika prób iRepeats = 0; // zerowanie licznika prób
} }
else ++iRepeats; //licznik nieudanych prób else
++iRepeats; // licznik nieudanych prób
break; break;
case 2: //odczyt wejϾ cyfrowych - komenda i przetwarzanie case 2: // odczyt wejϾ cyfrowych - komenda i przetwarzanie
if (iLastCommand!=0x31) //asynchroniczne ustawienie kontrolki mo¿e namieszaæ if (iLastCommand != 0x31) // asynchroniczne ustawienie kontrolki mo¿e namieszaæ
Write(0x31,0); //0x31: blokowy odczyt wejϾ Write(0x31, 0); // 0x31: blokowy odczyt wejϾ
else if (Read()) else if (Read())
{//jest odebrana ramka i zgodnoœæ numeru ¿¹dania { // jest odebrana ramka i zgodnoœæ numeru ¿¹dania
iInputs[0]=*((int*)(InputBuffer+3)); //odczyt 32 bitów iInputs[0] = *((int *)(InputBuffer + 3)); // odczyt 32 bitów
iFaza=3; //skoro odczytano, mo¿na kolejny cykl iFaza = 3; // skoro odczytano, mo¿na kolejny cykl
iRepeats=0; //zerowanie licznika prób iRepeats = 0; // zerowanie licznika prób
} }
else ++iRepeats; //licznik nieudanych prób else
++iRepeats; // licznik nieudanych prób
break; break;
case 3: //ustawienie wyjœæ analogowych, 0..4095 mapowaæ na 0..65520 (<<4) case 3: // ustawienie wyjœæ analogowych, 0..4095 mapowaæ na 0..65520 (<<4)
if (Write(0x41,43-1,(iPWM[6]>>4),(iPWM[6]<<4))) //wys³anie ustawieñ if (Write(0x41, 43 - 1, (iPWM[6] >> 4), (iPWM[6] << 4))) // wys³anie ustawieñ
iRepeats=0; //informacja, ¿e posz³o dobrze iRepeats = 0; // informacja, ¿e posz³o dobrze
iFaza=0; //++iFaza; //ta faza zosta³a zakoñczona iFaza = 0; //++iFaza; //ta faza zosta³a zakoñczona
//powinno jeszcze przyjϾ potwierdzenie o kodzie 0x41 // powinno jeszcze przyjϾ potwierdzenie o kodzie 0x41
break; break;
default: default:
iFaza=0; //na wypadek, gdyby zb³¹dzi³o po jakichœ zmianach w kodzie iFaza = 0; // na wypadek, gdyby zb³¹dzi³o po jakichœ zmianach w kodzie
//iRepeats=0; // iRepeats=0;
} }
if (!iRepeats) if (!iRepeats)
bNoError=true; //jest OK bNoError = true; // jest OK
else if (iRepeats>=10) //youBy 2014-07: przy 5 powtórzeniach sieje mi pauz¹ po 2 razy na sekundê, a przy 10 jest ok else if (iRepeats >= 10) // youBy 2014-07: przy 5 powtórzeniach sieje mi pauz¹ po 2 razy na
{//przekroczenie liczby prób wymusza kolejn¹ fazê // sekundê, a przy 10 jest ok
{ // przekroczenie liczby prób wymusza kolejn¹ fazê
++iFaza; ++iFaza;
iRepeats=1; //w nowej fazie nowe szanse, ale nie od 0! iRepeats = 1; // w nowej fazie nowe szanse, ale nie od 0!
bNoError=false; //zg³osiæ b³¹d bNoError = false; // zg³osiæ b³¹d
} }
return (bNoError); //true oznacza prawid³owe dzia³anie return (bNoError); // true oznacza prawid³owe dzia³anie
//czy w przypadku b³êdu komunikacji z PoKeys w³¹czaæ pauzê? // czy w przypadku b³êdu komunikacji z PoKeys w³¹czaæ pauzê?
//dopiero poprawne pod³¹czenie zeruje licznik prób // dopiero poprawne pod³¹czenie zeruje licznik prób
}; };

23
Console/PoKeys55.h
View File

@@ -3,28 +3,29 @@
#define PoKeys55H #define PoKeys55H
//--------------------------------------------------------------------------- //---------------------------------------------------------------------------
class TPoKeys55 class TPoKeys55
{//komunikacja z PoKeys bez okreœlania przeznaczenia pinów { // komunikacja z PoKeys bez okreœlania przeznaczenia pinów
unsigned char cRequest; //numer ¿¹dania do sprawdzania odpowiedzi unsigned char cRequest; // numer ¿¹dania do sprawdzania odpowiedzi
unsigned char OutputBuffer[65]; //Allocate a memory buffer equal to our endpoint size + 1 unsigned char OutputBuffer[65]; // Allocate a memory buffer equal to our endpoint size + 1
unsigned char InputBuffer[65]; //Allocate a memory buffer equal to our endpoint size + 1 unsigned char InputBuffer[65]; // Allocate a memory buffer equal to our endpoint size + 1
int iPWM[8]; //0-5:wyjœcia PWM,6:analogowe,7:czêstotliwoœc PWM int iPWM[8]; // 0-5:wyjœcia PWM,6:analogowe,7:czêstotliwoœc PWM
int iPWMbits; int iPWMbits;
int iLastCommand; int iLastCommand;
int iFaza; int iFaza;
int iRepeats; //liczba powtórzeñ int iRepeats; // liczba powtórzeñ
bool bNoError; //zerowany po przepe³nieniu licznika powtórzeñ, ustawiany po udanej operacji bool bNoError; // zerowany po przepe³nieniu licznika powtórzeñ, ustawiany po udanej operacji
public: public:
float fAnalog[7]; //wejœcia analogowe, stan <0.0,1.0> float fAnalog[7]; // wejœcia analogowe, stan <0.0,1.0>
int iInputs[8]; int iInputs[8];
__fastcall TPoKeys55(); __fastcall TPoKeys55();
__fastcall ~TPoKeys55(); __fastcall ~TPoKeys55();
bool __fastcall Connect(); bool __fastcall Connect();
bool __fastcall Close(); bool __fastcall Close();
bool __fastcall Write(unsigned char c,unsigned char b3,unsigned char b4=0,unsigned char b5=0); bool __fastcall Write(unsigned char c, unsigned char b3, unsigned char b4 = 0,
unsigned char b5 = 0);
bool __fastcall Read(); bool __fastcall Read();
bool __fastcall ReadLoop(int i); bool __fastcall ReadLoop(int i);
AnsiString __fastcall Version(); AnsiString __fastcall Version();
bool __fastcall PWM(int x,float y); bool __fastcall PWM(int x, float y);
bool __fastcall Update(bool pause); bool __fastcall Update(bool pause);
}; };
//--------------------------------------------------------------------------- //---------------------------------------------------------------------------

116
Curve.cpp
View File

@@ -6,105 +6,104 @@
#include "Curve.h" #include "Curve.h"
__fastcall TCurve::TCurve() __fastcall TCurve::TCurve()
{ {
Values= NULL; Values = NULL;
iNumValues= 0; iNumValues = 0;
iNumCols= 0; iNumCols = 0;
} }
__fastcall TCurve::~TCurve() __fastcall TCurve::~TCurve()
{ {
for (int i=0; i<iNumValues; i++) for (int i = 0; i < iNumValues; i++)
SafeDelete(Values[i]); SafeDelete(Values[i]);
SafeDelete(Values); SafeDelete(Values);
} }
bool __fastcall TCurve::Init(int n, int c) bool __fastcall TCurve::Init(int n, int c)
{ {
for (int i=0; i<iNumValues; i++) for (int i = 0; i < iNumValues; i++)
SafeDelete(Values[i]); SafeDelete(Values[i]);
SafeDelete(Values); SafeDelete(Values);
iNumValues= n; iNumValues = n;
iNumCols= c; iNumCols = c;
Values= new float*[iNumValues]; Values = new float *[iNumValues];
for (int i=0; i<iNumValues; i++) for (int i = 0; i < iNumValues; i++)
Values[i]= new float[iNumCols]; Values[i] = new float[iNumCols];
for (int i=0; i<iNumValues; i++) for (int i = 0; i < iNumValues; i++)
for (int j=0; j<iNumCols; j++) for (int j = 0; j < iNumCols; j++)
Values[i][j]= 0; Values[i][j] = 0;
} }
float __fastcall TCurve::GetValue(int c, float p) float __fastcall TCurve::GetValue(int c, float p)
{ {
int a= floor(p); int a = floor(p);
int b= ceil(p); int b = ceil(p);
if (a<0) if (a < 0)
return Values[0][c]; return Values[0][c];
if (b>=iNumValues) if (b >= iNumValues)
return Values[iNumValues-1][c]; return Values[iNumValues - 1][c];
p-= floor(p); p -= floor(p);
return Values[a][c]*(1.0f-p)+Values[b][c]*(p); return Values[a][c] * (1.0f - p) + Values[b][c] * (p);
} }
bool __fastcall TCurve::SetValue(int c, float p, float v) bool __fastcall TCurve::SetValue(int c, float p, float v)
{ {
int a= floor(p); int a = floor(p);
int b= ceil(p); int b = ceil(p);
if (a<0) if (a < 0)
return false; return false;
if (b>=iNumValues) if (b >= iNumValues)
return false; return false;
p-= floor(p); p -= floor(p);
if (p<0.5) if (p < 0.5)
Values[a][c]= v; Values[a][c] = v;
else else
Values[b][c]= v; Values[b][c] = v;
return true; return true;
} }
bool __fastcall TCurve::Load(TQueryParserComp *Parser) bool __fastcall TCurve::Load(TQueryParserComp *Parser)
{ {
DecimalSeparator= '.'; DecimalSeparator = '.';
AnsiString Token; AnsiString Token;
int n= Parser->GetNextSymbol().ToInt(); int n = Parser->GetNextSymbol().ToInt();
int c= Parser->GetNextSymbol().ToInt(); int c = Parser->GetNextSymbol().ToInt();
Init(n,c); Init(n, c);
n=0; n = 0;
int i; int i;
while (!Parser->EOF && n<iNumValues) while (!Parser->EOF && n < iNumValues)
{ {
for (i=0; i<iNumCols; i++) for (i = 0; i < iNumCols; i++)
Values[n][i]= Parser->GetNextSymbol().ToDouble(); Values[n][i] = Parser->GetNextSymbol().ToDouble();
n++; n++;
} }
DecimalSeparator= ','; DecimalSeparator = ',';
} }
bool __fastcall TCurve::LoadFromFile(AnsiString asName) bool __fastcall TCurve::LoadFromFile(AnsiString asName)
{ {
DecimalSeparator= '.'; DecimalSeparator = '.';
TFileStream *fs; TFileStream *fs;
fs= new TFileStream(asName, fmOpenRead | fmShareCompat ); fs = new TFileStream(asName, fmOpenRead | fmShareCompat);
AnsiString str= "xxx"; AnsiString str = "xxx";
int size= fs->Size; int size = fs->Size;
str.SetLength(size); str.SetLength(size);
fs->Read(str.c_str(),size); fs->Read(str.c_str(), size);
str+= ""; str += "";
delete fs; delete fs;
TQueryParserComp *Parser; TQueryParserComp *Parser;
Parser= new TQueryParserComp(NULL); Parser = new TQueryParserComp(NULL);
Parser->TextToParse= str; Parser->TextToParse = str;
Parser->First(); Parser->First();
Load(Parser); Load(Parser);
delete Parser; delete Parser;
DecimalSeparator= ','; DecimalSeparator = ',';
} }
#include <stdio.h> #include <stdio.h>
@@ -112,28 +111,27 @@ bool __fastcall TCurve::LoadFromFile(AnsiString asName)
bool __fastcall TCurve::SaveToFile(AnsiString asName) bool __fastcall TCurve::SaveToFile(AnsiString asName)
{ {
DecimalSeparator= '.'; DecimalSeparator = '.';
FILE *stream=NULL; FILE *stream = NULL;
stream = fopen(asName.c_str(), "w"); stream = fopen(asName.c_str(), "w");
AnsiString str; AnsiString str;
str= AnsiString(iNumValues); str = AnsiString(iNumValues);
fprintf(stream, str.c_str()); fprintf(stream, str.c_str());
fprintf(stream, "\n"); fprintf(stream, "\n");
for (int i=0; i<iNumValues; i++) for (int i = 0; i < iNumValues; i++)
{ {
str= ""; str = "";
if (i % 10==0) if (i % 10 == 0)
str+= "\n"; str += "\n";
for (int j=0; j<iNumCols; j++) for (int j = 0; j < iNumCols; j++)
str+= FloatToStrF(Values[i][j],ffFixed,6,2)+AnsiString(" "); str += FloatToStrF(Values[i][j], ffFixed, 6, 2) + AnsiString(" ");
str+= AnsiString("\n"); str += AnsiString("\n");
fprintf(stream, str.c_str()); fprintf(stream, str.c_str());
} }
fclose(stream); fclose(stream);
DecimalSeparator= ','; DecimalSeparator = ',';
} }
//--------------------------------------------------------------------------- //---------------------------------------------------------------------------

5
Curve.h
View File

@@ -8,7 +8,7 @@
class TCurve class TCurve
{ {
public: public:
__fastcall TCurve(); __fastcall TCurve();
__fastcall ~TCurve(); __fastcall ~TCurve();
bool __fastcall Init(int n, int c); bool __fastcall Init(int n, int c);
@@ -21,9 +21,8 @@ public:
int iNumValues; int iNumValues;
int iNumCols; int iNumCols;
private: private:
float **Values; float **Values;
}; };
//--------------------------------------------------------------------------- //---------------------------------------------------------------------------
#endif #endif

806
Data.h
View File

@@ -8,411 +8,409 @@
struct TDist struct TDist
{ {
int x,y; int x, y;
}; };
const TDist SectorOrder[]= const TDist SectorOrder[] = { // tabela wspó³rzêdnych sektorów, posortowana wg odleg³oœci
{//tabela wspó³rzêdnych sektorów, posortowana wg odleg³oœci {0, 0}, // 0.00
{ 0, 0}, // 0.00 {1, 0}, // 1.00
{ 1, 0}, // 1.00 {0, 1}, // 1.00
{ 0, 1}, // 1.00 {1, 1}, // 1.41
{ 1, 1}, // 1.41 {2, 0}, // 2.00
{ 2, 0}, // 2.00 {0, 2}, // 2.00
{ 0, 2}, // 2.00 {2, 1}, // 2.24
{ 2, 1}, // 2.24 {1, 2}, // 2.24
{ 1, 2}, // 2.24 {2, 2}, // 2.83 - 9 (566m)
{ 2, 2}, // 2.83 - 9 (566m) {3, 0}, // 3.00
{ 3, 0}, // 3.00 {0, 3}, // 3.00
{ 0, 3}, // 3.00 {3, 1}, // 3.16
{ 3, 1}, // 3.16 {1, 3}, // 3.16
{ 1, 3}, // 3.16 {3, 2}, // 3.61
{ 3, 2}, // 3.61 {2, 3}, // 3.61
{ 2, 3}, // 3.61 {4, 0}, // 4.00 - 16 (800m)
{ 4, 0}, // 4.00 - 16 (800m) {0, 4}, // 4.00
{ 0, 4}, // 4.00 {4, 1}, // 4.12
{ 4, 1}, // 4.12 {1, 4}, // 4.12
{ 1, 4}, // 4.12 {3, 3}, // 4.24 - 20
{ 3, 3}, // 4.24 - 20 {4, 2}, // 4.47
{ 4, 2}, // 4.47 {2, 4}, // 4.47
{ 2, 4}, // 4.47 {4, 3}, // 5.00
{ 4, 3}, // 5.00 {3, 4}, // 5.00
{ 3, 4}, // 5.00 {5, 0}, // 5.00 - 25
{ 5, 0}, // 5.00 - 25 {0, 5}, // 5.00
{ 0, 5}, // 5.00 {5, 1}, // 5.10
{ 5, 1}, // 5.10 {1, 5}, // 5.10 - 28
{ 1, 5}, // 5.10 - 28 {5, 2}, // 5.39
{ 5, 2}, // 5.39 {2, 5}, // 5.39
{ 2, 5}, // 5.39 {4, 4}, // 5.66
{ 4, 4}, // 5.66 {5, 3}, // 5.83
{ 5, 3}, // 5.83 {3, 5}, // 5.83
{ 3, 5}, // 5.83 {6, 0}, // 6.00
{ 6, 0}, // 6.00 {0, 6}, // 6.00
{ 0, 6}, // 6.00 {6, 1}, // 6.08 - 36
{ 6, 1}, // 6.08 - 36 {1, 6}, // 6.08
{ 1, 6}, // 6.08 {6, 2}, // 6.32
{ 6, 2}, // 6.32 {2, 6}, // 6.32
{ 2, 6}, // 6.32 {5, 4}, // 6.40
{ 5, 4}, // 6.40 {4, 5}, // 6.40
{ 4, 5}, // 6.40 {6, 3}, // 6.71
{ 6, 3}, // 6.71 {3, 6}, // 6.71
{ 3, 6}, // 6.71 {7, 0}, // 7.00
{ 7, 0}, // 7.00 {0, 7}, // 7.00
{ 0, 7}, // 7.00 {5, 5}, // 7.07
{ 5, 5}, // 7.07 {7, 1}, // 7.07
{ 7, 1}, // 7.07 {1, 7}, // 7.07
{ 1, 7}, // 7.07 {6, 4}, // 7.21
{ 6, 4}, // 7.21 {4, 6}, // 7.21
{ 4, 6}, // 7.21 {7, 2}, // 7.28
{ 7, 2}, // 7.28 {2, 7}, // 7.28
{ 2, 7}, // 7.28 {7, 3}, // 7.62
{ 7, 3}, // 7.62 {3, 7}, // 7.62
{ 3, 7}, // 7.62 {6, 5}, // 7.81
{ 6, 5}, // 7.81 {5, 6}, // 7.81
{ 5, 6}, // 7.81 {8, 0}, // 8.00
{ 8, 0}, // 8.00 {0, 8}, // 8.00
{ 0, 8}, // 8.00 {7, 4}, // 8.06
{ 7, 4}, // 8.06 {4, 7}, // 8.06
{ 4, 7}, // 8.06 {8, 1}, // 8.06
{ 8, 1}, // 8.06 {1, 8}, // 8.06
{ 1, 8}, // 8.06 {8, 2}, // 8.25
{ 8, 2}, // 8.25 {2, 8}, // 8.25
{ 2, 8}, // 8.25 {6, 6}, // 8.49
{ 6, 6}, // 8.49 {8, 3}, // 8.54
{ 8, 3}, // 8.54 {3, 8}, // 8.54
{ 3, 8}, // 8.54 {7, 5}, // 8.60
{ 7, 5}, // 8.60 {5, 7}, // 8.60
{ 5, 7}, // 8.60 {8, 4}, // 8.94
{ 8, 4}, // 8.94 {4, 8}, // 8.94
{ 4, 8}, // 8.94 {9, 0}, // 9.00
{ 9, 0}, // 9.00 {0, 9}, // 9.00
{ 0, 9}, // 9.00 {9, 1}, // 9.06
{ 9, 1}, // 9.06 {1, 9}, // 9.06
{ 1, 9}, // 9.06 {7, 6}, // 9.22
{ 7, 6}, // 9.22 {6, 7}, // 9.22
{ 6, 7}, // 9.22 {9, 2}, // 9.22
{ 9, 2}, // 9.22 {2, 9}, // 9.22
{ 2, 9}, // 9.22 {8, 5}, // 9.43
{ 8, 5}, // 9.43 {5, 8}, // 9.43
{ 5, 8}, // 9.43 {9, 3}, // 9.49
{ 9, 3}, // 9.49 {3, 9}, // 9.49
{ 3, 9}, // 9.49 {9, 4}, // 9.85
{ 9, 4}, // 9.85 {4, 9}, // 9.85
{ 4, 9}, // 9.85 {7, 7}, // 9.90
{ 7, 7}, // 9.90 {8, 6}, // 10.00
{ 8, 6}, //10.00 {6, 8}, // 10.00
{ 6, 8}, //10.00 {10, 0}, // 10.00
{10, 0}, //10.00 {0, 10}, // 10.00
{ 0,10}, //10.00 {10, 1}, // 10.05
{10, 1}, //10.05 {1, 10}, // 10.05
{ 1,10}, //10.05 {10, 2}, // 10.20
{10, 2}, //10.20 {2, 10}, // 10.20
{ 2,10}, //10.20 {9, 5}, // 10.30
{ 9, 5}, //10.30 {5, 9}, // 10.30
{ 5, 9}, //10.30 {10, 3}, // 10.44
{10, 3}, //10.44 {3, 10}, // 10.44
{ 3,10}, //10.44 {8, 7}, // 10.63
{ 8, 7}, //10.63 {7, 8}, // 10.63
{ 7, 8}, //10.63 {10, 4}, // 10.77
{10, 4}, //10.77 {4, 10}, // 10.77
{ 4,10}, //10.77 {9, 6}, // 10.82
{ 9, 6}, //10.82 {6, 9}, // 10.82
{ 6, 9}, //10.82 {11, 0}, // 11.00
{11, 0}, //11.00 {0, 11}, // 11.00
{ 0,11}, //11.00 {11, 1}, // 11.05
{11, 1}, //11.05 {1, 11}, // 11.05
{ 1,11}, //11.05 {10, 5}, // 11.18
{10, 5}, //11.18 {5, 10}, // 11.18
{ 5,10}, //11.18 {11, 2}, // 11.18
{11, 2}, //11.18 {2, 11}, // 11.18
{ 2,11}, //11.18 {8, 8}, // 11.31
{ 8, 8}, //11.31 {9, 7}, // 11.40
{ 9, 7}, //11.40 {7, 9}, // 11.40
{ 7, 9}, //11.40 {11, 3}, // 11.40
{11, 3}, //11.40 {3, 11}, // 11.40
{ 3,11}, //11.40 {10, 6}, // 11.66
{10, 6}, //11.66 {6, 10}, // 11.66
{ 6,10}, //11.66 {11, 4}, // 11.70
{11, 4}, //11.70 {4, 11}, // 11.70
{ 4,11}, //11.70 {12, 0}, // 12.00
{12, 0}, //12.00 {0, 12}, // 12.00
{ 0,12}, //12.00 {9, 8}, // 12.04
{ 9, 8}, //12.04 {8, 9}, // 12.04
{ 8, 9}, //12.04 {12, 1}, // 12.04
{12, 1}, //12.04 {1, 12}, // 12.04
{ 1,12}, //12.04 {11, 5}, // 12.08
{11, 5}, //12.08 {5, 11}, // 12.08
{ 5,11}, //12.08 {12, 2}, // 12.17
{12, 2}, //12.17 {2, 12}, // 12.17
{ 2,12}, //12.17 {10, 7}, // 12.21
{10, 7}, //12.21 {7, 10}, // 12.21
{ 7,10}, //12.21 {12, 3}, // 12.37
{12, 3}, //12.37 {3, 12}, // 12.37
{ 3,12}, //12.37 {11, 6}, // 12.53
{11, 6}, //12.53 {6, 11}, // 12.53
{ 6,11}, //12.53 {12, 4}, // 12.65
{12, 4}, //12.65 {4, 12}, // 12.65
{ 4,12}, //12.65 {9, 9}, // 12.73
{ 9, 9}, //12.73 {10, 8}, // 12.81
{10, 8}, //12.81 {8, 10}, // 12.81
{ 8,10}, //12.81 {12, 5}, // 13.00
{12, 5}, //13.00 {5, 12}, // 13.00
{ 5,12}, //13.00 {13, 0}, // 13.00
{13, 0}, //13.00 {0, 13}, // 13.00
{ 0,13}, //13.00 {11, 7}, // 13.04
{11, 7}, //13.04 {7, 11}, // 13.04
{ 7,11}, //13.04 {13, 1}, // 13.04
{13, 1}, //13.04 {1, 13}, // 13.04
{ 1,13}, //13.04 {13, 2}, // 13.15
{13, 2}, //13.15 {2, 13}, // 13.15
{ 2,13}, //13.15 {13, 3}, // 13.34
{13, 3}, //13.34 {3, 13}, // 13.34
{ 3,13}, //13.34 {12, 6}, // 13.42
{12, 6}, //13.42 {6, 12}, // 13.42
{ 6,12}, //13.42 {10, 9}, // 13.45
{10, 9}, //13.45 {9, 10}, // 13.45
{ 9,10}, //13.45 {11, 8}, // 13.60
{11, 8}, //13.60 {8, 11}, // 13.60
{ 8,11}, //13.60 {13, 4}, // 13.60
{13, 4}, //13.60 {4, 13}, // 13.60
{ 4,13}, //13.60 {12, 7}, // 13.89
{12, 7}, //13.89 {7, 12}, // 13.89
{ 7,12}, //13.89 {13, 5}, // 13.93
{13, 5}, //13.93 {5, 13}, // 13.93
{ 5,13}, //13.93 {14, 0}, // 14.00
{14, 0}, //14.00 {0, 14}, // 14.00
{ 0,14}, //14.00 {14, 1}, // 14.04
{14, 1}, //14.04 {1, 14}, // 14.04
{ 1,14}, //14.04 {10, 10}, // 14.14
{10,10}, //14.14 {14, 2}, // 14.14
{14, 2}, //14.14 {2, 14}, // 14.14
{ 2,14}, //14.14 {11, 9}, // 14.21
{11, 9}, //14.21 {9, 11}, // 14.21
{ 9,11}, //14.21 {13, 6}, // 14.32
{13, 6}, //14.32 {6, 13}, // 14.32
{ 6,13}, //14.32 {14, 3}, // 14.32
{14, 3}, //14.32 {3, 14}, // 14.32
{ 3,14}, //14.32 {12, 8}, // 14.42
{12, 8}, //14.42 {8, 12}, // 14.42
{ 8,12}, //14.42 {14, 4}, // 14.56
{14, 4}, //14.56 {4, 14}, // 14.56
{ 4,14}, //14.56 {13, 7}, // 14.76
{13, 7}, //14.76 {7, 13}, // 14.76
{ 7,13}, //14.76 {11, 10}, // 14.87
{11,10}, //14.87 {10, 11}, // 14.87
{10,11}, //14.87 {14, 5}, // 14.87
{14, 5}, //14.87 {5, 14}, // 14.87
{ 5,14}, //14.87 {12, 9}, // 15.00
{12, 9}, //15.00 {9, 12}, // 15.00
{ 9,12}, //15.00 {15, 0}, // 15.00
{15, 0}, //15.00 {0, 15}, // 15.00
{ 0,15}, //15.00 {15, 1}, // 15.03
{15, 1}, //15.03 {1, 15}, // 15.03
{ 1,15}, //15.03 {15, 2}, // 15.13
{15, 2}, //15.13 {2, 15}, // 15.13
{ 2,15}, //15.13 {14, 6}, // 15.23
{14, 6}, //15.23 {6, 14}, // 15.23
{ 6,14}, //15.23 {13, 8}, // 15.26
{13, 8}, //15.26 {8, 13}, // 15.26
{ 8,13}, //15.26 {15, 3}, // 15.30
{15, 3}, //15.30 {3, 15}, // 15.30
{ 3,15}, //15.30 {15, 4}, // 15.52
{15, 4}, //15.52 {4, 15}, // 15.52
{ 4,15}, //15.52 {11, 11}, // 15.56
{11,11}, //15.56 {12, 10}, // 15.62
{12,10}, //15.62 {10, 12}, // 15.62
{10,12}, //15.62 {14, 7}, // 15.65
{14, 7}, //15.65 {7, 14}, // 15.65
{ 7,14}, //15.65 {13, 9}, // 15.81
{13, 9}, //15.81 {9, 13}, // 15.81
{ 9,13}, //15.81 {15, 5}, // 15.81
{15, 5}, //15.81 {5, 15}, // 15.81
{ 5,15}, //15.81 {16, 0}, // 16.00
{16, 0}, //16.00 {0, 16}, // 16.00
{ 0,16}, //16.00 {16, 1}, // 16.03
{16, 1}, //16.03 {1, 16}, // 16.03
{ 1,16}, //16.03 {14, 8}, // 16.12
{14, 8}, //16.12 {8, 14}, // 16.12
{ 8,14}, //16.12 {16, 2}, // 16.12
{16, 2}, //16.12 {2, 16}, // 16.12
{ 2,16}, //16.12 {15, 6}, // 16.16
{15, 6}, //16.16 {6, 15}, // 16.16
{ 6,15}, //16.16 {12, 11}, // 16.28
{12,11}, //16.28 {11, 12}, // 16.28
{11,12}, //16.28 {16, 3}, // 16.28
{16, 3}, //16.28 {3, 16}, // 16.28
{ 3,16}, //16.28 {13, 10}, // 16.40
{13,10}, //16.40 {10, 13}, // 16.40
{10,13}, //16.40 {16, 4}, // 16.49
{16, 4}, //16.49 {4, 16}, // 16.49
{ 4,16}, //16.49 {15, 7}, // 16.55
{15, 7}, //16.55 {7, 15}, // 16.55
{ 7,15}, //16.55 {14, 9}, // 16.64
{14, 9}, //16.64 {9, 14}, // 16.64
{ 9,14}, //16.64 {16, 5}, // 16.76
{16, 5}, //16.76 {5, 16}, // 16.76
{ 5,16}, //16.76 {12, 12}, // 16.97
{12,12}, //16.97 {15, 8}, // 17.00
{15, 8}, //17.00 {8, 15}, // 17.00
{ 8,15}, //17.00 {17, 0}, // 17.00
{17, 0}, //17.00 {0, 17}, // 17.00
{ 0,17}, //17.00 {13, 11}, // 17.03
{13,11}, //17.03 {11, 13}, // 17.03
{11,13}, //17.03 {17, 1}, // 17.03
{17, 1}, //17.03 {1, 17}, // 17.03
{ 1,17}, //17.03 {16, 6}, // 17.09
{16, 6}, //17.09 {6, 16}, // 17.09
{ 6,16}, //17.09 {17, 2}, // 17.12
{17, 2}, //17.12 {2, 17}, // 17.12
{ 2,17}, //17.12 {14, 10}, // 17.20
{14,10}, //17.20 {10, 14}, // 17.20
{10,14}, //17.20 {17, 3}, // 17.26
{17, 3}, //17.26 {3, 17}, // 17.26
{ 3,17}, //17.26 {16, 7}, // 17.46
{16, 7}, //17.46 {7, 16}, // 17.46
{ 7,16}, //17.46 {17, 4}, // 17.46
{17, 4}, //17.46 {4, 17}, // 17.46
{ 4,17}, //17.46 {15, 9}, // 17.49
{15, 9}, //17.49 {9, 15}, // 17.49
{ 9,15}, //17.49 {13, 12}, // 17.69
{13,12}, //17.69 {12, 13}, // 17.69
{12,13}, //17.69 {17, 5}, // 17.72
{17, 5}, //17.72 {5, 17}, // 17.72
{ 5,17}, //17.72 {14, 11}, // 17.80
{14,11}, //17.80 {11, 14}, // 17.80
{11,14}, //17.80 {16, 8}, // 17.89
{16, 8}, //17.89 {8, 16}, // 17.89
{ 8,16}, //17.89 {18, 0}, // 18.00
{18, 0}, //18.00 {0, 18}, // 18.00
{ 0,18}, //18.00 {15, 10}, // 18.03
{15,10}, //18.03 {10, 15}, // 18.03
{10,15}, //18.03 {17, 6}, // 18.03
{17, 6}, //18.03 {6, 17}, // 18.03
{ 6,17}, //18.03 {18, 1}, // 18.03
{18, 1}, //18.03 {1, 18}, // 18.03
{ 1,18}, //18.03 {18, 2}, // 18.11
{18, 2}, //18.11 {2, 18}, // 18.11
{ 2,18}, //18.11 {18, 3}, // 18.25
{18, 3}, //18.25 {3, 18}, // 18.25
{ 3,18}, //18.25 {16, 9}, // 18.36
{16, 9}, //18.36 {9, 16}, // 18.36
{ 9,16}, //18.36 {13, 13}, // 18.38
{13,13}, //18.38 {17, 7}, // 18.38
{17, 7}, //18.38 {7, 17}, // 18.38
{ 7,17}, //18.38 {14, 12}, // 18.44
{14,12}, //18.44 {12, 14}, // 18.44
{12,14}, //18.44 {18, 4}, // 18.44
{18, 4}, //18.44 {4, 18}, // 18.44
{ 4,18}, //18.44 {15, 11}, // 18.60
{15,11}, //18.60 {11, 15}, // 18.60
{11,15}, //18.60 {18, 5}, // 18.68
{18, 5}, //18.68 {5, 18}, // 18.68
{ 5,18}, //18.68 {17, 8}, // 18.79
{17, 8}, //18.79 {8, 17}, // 18.79
{ 8,17}, //18.79 {16, 10}, // 18.87
{16,10}, //18.87 {10, 16}, // 18.87
{10,16}, //18.87 {18, 6}, // 18.97
{18, 6}, //18.97 {6, 18}, // 18.97
{ 6,18}, //18.97 {19, 0}, // 19.00
{19, 0}, //19.00 {0, 19}, // 19.00
{ 0,19}, //19.00 {19, 1}, // 19.03
{19, 1}, //19.03 {1, 19}, // 19.03
{ 1,19}, //19.03 {14, 13}, // 19.10
{14,13}, //19.10 {13, 14}, // 19.10
{13,14}, //19.10 {19, 2}, // 19.10
{19, 2}, //19.10 {2, 19}, // 19.10
{ 2,19}, //19.10 {15, 12}, // 19.21
{15,12}, //19.21 {12, 15}, // 19.21
{12,15}, //19.21 {17, 9}, // 19.24
{17, 9}, //19.24 {9, 17}, // 19.24
{ 9,17}, //19.24 {19, 3}, // 19.24
{19, 3}, //19.24 {3, 19}, // 19.24
{ 3,19}, //19.24 {18, 7}, // 19.31
{18, 7}, //19.31 {7, 18}, // 19.31
{ 7,18}, //19.31 {16, 11}, // 19.42
{16,11}, //19.42 {11, 16}, // 19.42
{11,16}, //19.42 {19, 4}, // 19.42
{19, 4}, //19.42 {4, 19}, // 19.42
{ 4,19}, //19.42 {19, 5}, // 19.65
{19, 5}, //19.65 {5, 19}, // 19.65
{ 5,19}, //19.65 {18, 8}, // 19.70
{18, 8}, //19.70 {8, 18}, // 19.70
{ 8,18}, //19.70 {17, 10}, // 19.72
{17,10}, //19.72 {10, 17}, // 19.72
{10,17}, //19.72 {14, 14}, // 19.80
{14,14}, //19.80 {15, 13}, // 19.85
{15,13}, //19.85 {13, 15}, // 19.85
{13,15}, //19.85 {19, 6}, // 19.92
{19, 6}, //19.92 {6, 19}, // 19.92
{ 6,19}, //19.92 {16, 12}, // 20.00
{16,12}, //20.00 {12, 16}, // 20.00
{12,16}, //20.00 {18, 9}, // 20.12
{18, 9}, //20.12 {9, 18}, // 20.12
{ 9,18}, //20.12 {17, 11}, // 20.25
{17,11}, //20.25 {11, 17}, // 20.25
{11,17}, //20.25 {19, 7}, // 20.25
{19, 7}, //20.25 {7, 19}, // 20.25
{ 7,19}, //20.25 {15, 14}, // 20.52
{15,14}, //20.52 {14, 15}, // 20.52
{14,15}, //20.52 {18, 10}, // 20.59
{18,10}, //20.59 {10, 18}, // 20.59
{10,18}, //20.59 {16, 13}, // 20.62
{16,13}, //20.62 {13, 16}, // 20.62
{13,16}, //20.62 {19, 8}, // 20.62
{19, 8}, //20.62 {8, 19}, // 20.62
{ 8,19}, //20.62 {17, 12}, // 20.81
{17,12}, //20.81 {12, 17}, // 20.81
{12,17}, //20.81 {19, 9}, // 21.02
{19, 9}, //21.02 {9, 19}, // 21.02
{ 9,19}, //21.02 {18, 11}, // 21.10
{18,11}, //21.10 {11, 18}, // 21.10
{11,18}, //21.10 {15, 15}, // 21.21
{15,15}, //21.21 {16, 14}, // 21.26
{16,14}, //21.26 {14, 16}, // 21.26
{14,16}, //21.26 {17, 13}, // 21.40
{17,13}, //21.40 {13, 17}, // 21.40
{13,17}, //21.40 {19, 10}, // 21.47
{19,10}, //21.47 {10, 19}, // 21.47
{10,19}, //21.47 {18, 12}, // 21.63
{18,12}, //21.63 {12, 18}, // 21.63
{12,18}, //21.63 {16, 15}, // 21.93
{16,15}, //21.93 {15, 16}, // 21.93
{15,16}, //21.93 {19, 11}, // 21.95
{19,11}, //21.95 {11, 19}, // 21.95
{11,19}, //21.95 {17, 14}, // 22.02
{17,14}, //22.02 {14, 17}, // 22.02
{14,17}, //22.02 {18, 13}, // 22.20
{18,13}, //22.20 {13, 18}, // 22.20
{13,18}, //22.20 {19, 12}, // 22.47
{19,12}, //22.47 {12, 19}, // 22.47
{12,19}, //22.47 {16, 16}, // 22.63
{16,16}, //22.63 {17, 15}, // 22.67
{17,15}, //22.67 {15, 17}, // 22.67
{15,17}, //22.67 {18, 14}, // 22.80
{18,14}, //22.80 {14, 18}, // 22.80
{14,18}, //22.80 {19, 13}, // 23.02
{19,13}, //23.02 {13, 19}, // 23.02
{13,19}, //23.02 {17, 16}, // 23.35
{17,16}, //23.35 {16, 17}, // 23.35
{16,17}, //23.35 {18, 15}, // 23.43
{18,15}, //23.43 {15, 18}, // 23.43
{15,18}, //23.43 {19, 14}, // 23.60
{19,14}, //23.60 {14, 19}, // 23.60
{14,19}, //23.60 {17, 17}, // 24.04
{17,17}, //24.04 {18, 16}, // 24.08
{18,16}, //24.08 {16, 18}, // 24.08
{16,18}, //24.08 {19, 15}, // 24.21
{19,15}, //24.21 {15, 19}, // 24.21
{15,19}, //24.21 {18, 17}, // 24.76
{18,17}, //24.76 {17, 18}, // 24.76
{17,18}, //24.76 {19, 16}, // 24.84
{19,16}, //24.84 {16, 19}, // 24.84
{16,19}, //24.84 {18, 18}, // 25.46
{18,18}, //25.46 {19, 17}, // 25.50
{19,17}, //25.50 {17, 19}, // 25.50
{17,19}, //25.50 {19, 18}, // 26.17
{19,18}, //26.17 {18, 19}, // 26.17
{18,19}, //26.17 {19, 19} // 26.87 - 400 (5374m)
{19,19} //26.87 - 400 (5374m)
}; };
#endif #endif

6522
Driver.cpp
View File

File diff suppressed because it is too large Load Diff

476
Driver.h
View File

@@ -9,294 +9,322 @@
using namespace Math3D; using namespace Math3D;
enum TOrders enum TOrders
{//rozkazy dla AI { // rozkazy dla AI
Wait_for_orders=0, //czekanie na dostarczenie następnych rozkazów Wait_for_orders = 0, // czekanie na dostarczenie następnych rozkazów
//operacje tymczasowe // operacje tymczasowe
Prepare_engine=1, //włączenie silnika Prepare_engine = 1, // włączenie silnika
Release_engine=2, //wyłączenie silnika Release_engine = 2, // wyłączenie silnika
Change_direction=4, //zmiana kierunku (bez skanowania sygnalizacji) Change_direction = 4, // zmiana kierunku (bez skanowania sygnalizacji)
Connect=8, //podłączanie wagonów (z częściowym skanowaniem sygnalizacji) Connect = 8, // podłączanie wagonów (z częściowym skanowaniem sygnalizacji)
Disconnect=0x10, //odłączanie wagonów (bez skanowania sygnalizacji) Disconnect = 0x10, // odłączanie wagonów (bez skanowania sygnalizacji)
//jazda // jazda
Shunt=0x20, //tryb manewrowy Shunt = 0x20, // tryb manewrowy
Obey_train=0x40, //tryb pociągowy Obey_train = 0x40, // tryb pociągowy
Jump_to_first_order=0x60 //zapęlenie do pierwszej pozycji (po co?) Jump_to_first_order = 0x60 // zapęlenie do pierwszej pozycji (po co?)
}; };
enum TMovementStatus enum TMovementStatus
{//flagi bitowe ruchu (iDrivigFlags) { // flagi bitowe ruchu (iDrivigFlags)
moveStopCloser=1, //podjechać blisko W4 (nie podjeżdżać na początku ani po zmianie czoła) moveStopCloser = 1, // podjechać blisko W4 (nie podjeżdżać na początku ani po zmianie czoła)
moveStopPoint=2, //stawać na W4 (wyłączone podczas zmiany czoła) moveStopPoint = 2, // stawać na W4 (wyłączone podczas zmiany czoła)
moveActive=4, //pojazd jest załączony i skanuje moveActive = 4, // pojazd jest załączony i skanuje
movePress=8, //dociskanie przy odłączeniu (zamiast zmiennej Prepare2press) movePress = 8, // dociskanie przy odłączeniu (zamiast zmiennej Prepare2press)
moveConnect=0x10, //jest blisko innego pojazdu i można próbować podłączyć moveConnect = 0x10, // jest blisko innego pojazdu i można próbować podłączyć
movePrimary=0x20, //ma priorytet w składzie (master) movePrimary = 0x20, // ma priorytet w składzie (master)
moveLate=0x40, //flaga spóźnienia, włączy bardziej moveLate = 0x40, // flaga spóźnienia, włączy bardziej
moveStopHere=0x80, //nie podjeżdżać do semafora, jeśli droga nie jest wolna moveStopHere = 0x80, // nie podjeżdżać do semafora, jeśli droga nie jest wolna
moveStartHorn=0x100, //podawaj sygnał po podaniu wolnej drogi moveStartHorn = 0x100, // podawaj sygnał po podaniu wolnej drogi
moveStartHornNow=0x200, //podaj sygnał po odhamowaniu moveStartHornNow = 0x200, // podaj sygnał po odhamowaniu
moveStartHornDone=0x400, //podano sygnał po podaniu wolnej drogi moveStartHornDone = 0x400, // podano sygnał po podaniu wolnej drogi
moveOerlikons=0x800, //skład wyłącznie z zaworami? Oerlikona moveOerlikons = 0x800, // skład wyłącznie z zaworami? Oerlikona
moveIncSpeed=0x1000, //załączenie jazdy (np. dla EZT) moveIncSpeed = 0x1000, // załączenie jazdy (np. dla EZT)
moveTrackEnd=0x2000, //dalsza jazda do przodu trwale ograniczona (W5, koniec toru) moveTrackEnd = 0x2000, // dalsza jazda do przodu trwale ograniczona (W5, koniec toru)
moveSwitchFound=0x4000, //na drodze skanowania do przodu jest rozjazd moveSwitchFound = 0x4000, // na drodze skanowania do przodu jest rozjazd
moveGuardSignal=0x8000, //sygnał od kierownika (minął czas postoju) moveGuardSignal = 0x8000, // sygnał od kierownika (minął czas postoju)
moveVisibility=0x10000, //jazda na widoczność po przejechaniu S1 na SBL moveVisibility = 0x10000, // jazda na widoczność po przejechaniu S1 na SBL
moveDoorOpened=0x20000, //drzwi zostały otwarte - doliczyć czas na zamknięcie moveDoorOpened = 0x20000, // drzwi zostały otwarte - doliczyć czas na zamknięcie
movePushPull=0x40000 //zmiana czoła przez zmianę kabiny - nie odczepiać przy zmianie kierunku movePushPull = 0x40000 // zmiana czoła przez zmianę kabiny - nie odczepiać przy zmianie kierunku
}; };
enum TStopReason enum TStopReason
{//powód zatrzymania, dodawany do SetVelocity 0 - w zasadzie do usunięcia { // powód zatrzymania, dodawany do SetVelocity 0 - w zasadzie do usunięcia
stopNone, //nie ma powodu - powinien jechać stopNone, // nie ma powodu - powinien jechać
stopSleep, //nie został odpalony, to nie pojedzie stopSleep, // nie został odpalony, to nie pojedzie
stopSem, //semafor zamknięty stopSem, // semafor zamknięty
stopTime, //czekanie na godzinę odjazdu stopTime, // czekanie na godzinę odjazdu
stopEnd, //brak dalszej części toru stopEnd, // brak dalszej części toru
stopDir, //trzeba stanąć, by zmienić kierunek jazdy stopDir, // trzeba stanąć, by zmienić kierunek jazdy
stopJoin, //stoi w celu połączenia wagonów stopJoin, // stoi w celu połączenia wagonów
stopBlock, //przeszkoda na drodze ruchu stopBlock, // przeszkoda na drodze ruchu
stopComm, //otrzymano taką komendę (niewiadomego pochodzenia) stopComm, // otrzymano taką komendę (niewiadomego pochodzenia)
stopOut, //komenda wyjazdu poza stację (raczej nie powinna zatrzymywać!) stopOut, // komenda wyjazdu poza stację (raczej nie powinna zatrzymywać!)
stopRadio, //komunikat przekazany radiem (Radiostop) stopRadio, // komunikat przekazany radiem (Radiostop)
stopExt, //komenda z zewnątrz stopExt, // komenda z zewnątrz
stopError //z powodu błędu w obliczeniu drogi hamowania stopError // z powodu błędu w obliczeniu drogi hamowania
}; };
enum TAction enum TAction
{//przechowanie aktualnego stanu AI od poprzedniego przebłysku świadomości { // przechowanie aktualnego stanu AI od poprzedniego przebłysku świadomości
actUnknown, //stan nieznany (domyślny na początku) actUnknown, // stan nieznany (domyślny na początku)
actPantUp, //podnieś pantograf (info dla użytkownika) actPantUp, // podnieś pantograf (info dla użytkownika)
actConv, //załącz przetwornicę (info dla użytkownika) actConv, // załącz przetwornicę (info dla użytkownika)
actCompr, //załącz sprężarkę (info dla użytkownika) actCompr, // załącz sprężarkę (info dla użytkownika)
actSleep, //śpi (wygaszony) actSleep, //śpi (wygaszony)
actDrive, //jazda actDrive, // jazda
actGo, //ruszanie z miejsca actGo, // ruszanie z miejsca
actSlow, //przyhamowanie przed ograniczeniem actSlow, // przyhamowanie przed ograniczeniem
sctStop, //hamowanie w celu precyzyjnego zatrzymania sctStop, // hamowanie w celu precyzyjnego zatrzymania
actIdle, //luzowanie składu przed odjazdem actIdle, // luzowanie składu przed odjazdem
actRelease, //luzowanie składu po zmniejszeniu prędkości actRelease, // luzowanie składu po zmniejszeniu prędkości
actConnect, //dojazd w celu podczepienia actConnect, // dojazd w celu podczepienia
actWait, //czekanie na przystanku actWait, // czekanie na przystanku
actReady, //zgłoszona gotowość do odjazdu od kierownika actReady, // zgłoszona gotowość do odjazdu od kierownika
actEmergency, //hamowanie awaryjne actEmergency, // hamowanie awaryjne
actGoUphill, //ruszanie pod górę actGoUphill, // ruszanie pod górę
actTest, //hamowanie kontrolne (podczas jazdy) actTest, // hamowanie kontrolne (podczas jazdy)
actTrial //próba hamulca (na postoju) actTrial // próba hamulca (na postoju)
}; };
class TSpeedPos class TSpeedPos
{//pozycja tabeli prędkości dla AI { // pozycja tabeli prędkości dla AI
public: public:
double fDist; //aktualna odległość (ujemna gdy minięte) double fDist; // aktualna odległość (ujemna gdy minięte)
double fVelNext; //prędkość obowiązująca od tego miejsca double fVelNext; // prędkość obowiązująca od tego miejsca
//double fAcc; // double fAcc;
int iFlags; int iFlags;
//1=istotny,2=tor,4=odwrotnie,8-zwrotnica (może się zmienić),16-stan zwrotnicy,32-minięty,64=koniec,128=łuk // 1=istotny,2=tor,4=odwrotnie,8-zwrotnica (może się zmienić),16-stan
//0x100=event,0x200=manewrowa,0x400=przystanek,0x800=SBL,0x1000=wysłana komenda,0x2000=W5 // zwrotnicy,32-minięty,64=koniec,128=łuk
//0x10000=zatkanie // 0x100=event,0x200=manewrowa,0x400=przystanek,0x800=SBL,0x1000=wysłana komenda,0x2000=W5
vector3 vPos; //współrzędne XYZ do liczenia odległości // 0x10000=zatkanie
vector3 vPos; // współrzędne XYZ do liczenia odległości
struct struct
{ {
TTrack *trTrack; //wskaźnik na tor o zmiennej prędkości (zwrotnica, obrotnica) TTrack *trTrack; // wskaźnik na tor o zmiennej prędkości (zwrotnica, obrotnica)
TEvent *evEvent; //połączenie z eventem albo komórką pamięci TEvent *evEvent; // połączenie z eventem albo komórką pamięci
}; };
void __fastcall CommandCheck(); void __fastcall CommandCheck();
public:
public:
void __fastcall Clear(); void __fastcall Clear();
bool __fastcall Update(vector3 *p,vector3 *dir,double &len); bool __fastcall Update(vector3 *p, vector3 *dir, double &len);
bool __fastcall Set(TEvent *e,double d); bool __fastcall Set(TEvent *e, double d);
void __fastcall Set(TTrack *t,double d,int f); void __fastcall Set(TTrack *t, double d, int f);
AnsiString __fastcall TableText(); AnsiString __fastcall TableText();
}; };
//---------------------------------------------------------------------------- //----------------------------------------------------------------------------
static const bool Aggressive=true; static const bool Aggressive = true;
static const bool Easyman=false; static const bool Easyman = false;
static const bool AIdriver=true; static const bool AIdriver = true;
static const bool Humandriver=false; static const bool Humandriver = false;
static const int maxorders=32; //ilość rozkazów w tabelce static const int maxorders = 32; // ilość rozkazów w tabelce
static const int maxdriverfails=4; //ile błędów może zrobić AI zanim zmieni nastawienie static const int maxdriverfails = 4; // ile błędów może zrobić AI zanim zmieni nastawienie
extern bool WriteLogFlag; //logowanie parametrów fizycznych extern bool WriteLogFlag; // logowanie parametrów fizycznych
//---------------------------------------------------------------------------- //----------------------------------------------------------------------------
class TController class TController
{ {
private: //obsługa tabelki prędkości (musi mieć możliwość odhaczania stacji w rozkładzie) private: // obsługa tabelki prędkości (musi mieć możliwość odhaczania stacji w rozkładzie)
TSpeedPos *sSpeedTable; //najbliższe zmiany prędkości TSpeedPos *sSpeedTable; // najbliższe zmiany prędkości
int iSpeedTableSize; //wielkość tabelki int iSpeedTableSize; // wielkość tabelki
int iFirst; //aktualna pozycja w tabeli (modulo iSpeedTableSize) int iFirst; // aktualna pozycja w tabeli (modulo iSpeedTableSize)
int iLast; //ostatnia wypełniona pozycja w tabeli <iFirst (modulo iSpeedTableSize) int iLast; // ostatnia wypełniona pozycja w tabeli <iFirst (modulo iSpeedTableSize)
int iTableDirection; //kierunek zapełnienia tabelki względem pojazdu z AI int iTableDirection; // kierunek zapełnienia tabelki względem pojazdu z AI
double fLastVel; //prędkość na poprzednio sprawdzonym torze double fLastVel; // prędkość na poprzednio sprawdzonym torze
TTrack *tLast; //ostatni analizowany tor TTrack *tLast; // ostatni analizowany tor
TEvent *eSignSkip; //można pominąć ten SBL po zatrzymaniu TEvent *eSignSkip; // można pominąć ten SBL po zatrzymaniu
private: //parametry aktualnego składu private: // parametry aktualnego składu
double fLength; //długość składu (do wyciągania z ograniczeń) double fLength; // długość składu (do wyciągania z ograniczeń)
double fMass; //całkowita masa do liczenia stycznej składowej grawitacji double fMass; // całkowita masa do liczenia stycznej składowej grawitacji
double fAccGravity; //przyspieszenie składowej stycznej grawitacji double fAccGravity; // przyspieszenie składowej stycznej grawitacji
public: public:
TEvent *eSignNext; //sygnał zmieniający prędkość, do pokazania na [F2] TEvent *eSignNext; // sygnał zmieniający prędkość, do pokazania na [F2]
AnsiString asNextStop; //nazwa następnego punktu zatrzymania wg rozkładu AnsiString asNextStop; // nazwa następnego punktu zatrzymania wg rozkładu
int iStationStart; //numer pierwszej stacji pokazywanej na podglądzie rozkładu int iStationStart; // numer pierwszej stacji pokazywanej na podglądzie rozkładu
private: //parametry sterowania pojazdem (stan, hamowanie) private: // parametry sterowania pojazdem (stan, hamowanie)
double fShuntVelocity; //maksymalna prędkość manewrowania, zależy m.in. od składu double fShuntVelocity; // maksymalna prędkość manewrowania, zależy m.in. od składu
int iVehicles; //ilość pojazdów w składzie int iVehicles; // ilość pojazdów w składzie
int iEngineActive; //ABu: Czy silnik byl juz zalaczony; Ra: postęp w załączaniu int iEngineActive; // ABu: Czy silnik byl juz zalaczony; Ra: postęp w załączaniu
//vector3 vMechLoc; //pozycja pojazdu do liczenia odległości od semafora (?) // vector3 vMechLoc; //pozycja pojazdu do liczenia odległości od semafora (?)
bool Psyche; bool Psyche;
int iDrivigFlags; //flagi bitowe ruchu int iDrivigFlags; // flagi bitowe ruchu
double fDriverBraking; //po pomnożeniu przez v^2 [km/h] daje ~drogę hamowania [m] double fDriverBraking; // po pomnożeniu przez v^2 [km/h] daje ~drogę hamowania [m]
double fDriverDist; //dopuszczalna odległość podjechania do przeszkody double fDriverDist; // dopuszczalna odległość podjechania do przeszkody
double fVelMax; //maksymalna prędkość składu (sprawdzany każdy pojazd) double fVelMax; // maksymalna prędkość składu (sprawdzany każdy pojazd)
double fBrakeDist; //przybliżona droga hamowania double fBrakeDist; // przybliżona droga hamowania
double fAccThreshold; //próg opóźnienia dla zadziałania hamulca double fAccThreshold; // próg opóźnienia dla zadziałania hamulca
public: public:
double fLastStopExpDist; //odległość wygasania ostateniego przystanku double fLastStopExpDist; // odległość wygasania ostateniego przystanku
double ReactionTime; //czas reakcji Ra: czego i na co? świadomości AI double ReactionTime; // czas reakcji Ra: czego i na co? świadomości AI
double fBrakeTime; //wpisana wartość jest zmniejszana do 0, gdy ujemna należy zmienić nastawę hamulca double fBrakeTime; // wpisana wartość jest zmniejszana do 0, gdy ujemna należy zmienić nastawę
private: // hamulca
double fReady; //poziom odhamowania wagonów private:
bool Ready; //ABu: stan gotowosci do odjazdu - sprawdzenie odhamowania wagonow double fReady; // poziom odhamowania wagonów
double LastUpdatedTime; //czas od ostatniego logu bool Ready; // ABu: stan gotowosci do odjazdu - sprawdzenie odhamowania wagonow
double ElapsedTime; //czas od poczatku logu double LastUpdatedTime; // czas od ostatniego logu
double deltalog; //przyrost czasu double ElapsedTime; // czas od poczatku logu
double deltalog; // przyrost czasu
double LastReactionTime; double LastReactionTime;
double fActionTime; //czas używany przy regulacji prędkości i zamykaniu drzwi double fActionTime; // czas używany przy regulacji prędkości i zamykaniu drzwi
TAction eAction; //aktualny stan TAction eAction; // aktualny stan
bool HelpMeFlag; //wystawiane True jesli cos niedobrego sie dzieje bool HelpMeFlag; // wystawiane True jesli cos niedobrego sie dzieje
public: public:
bool AIControllFlag; //rzeczywisty/wirtualny maszynista bool AIControllFlag; // rzeczywisty/wirtualny maszynista
int iRouteWanted; //oczekiwany kierunek jazdy (0-stop,1-lewo,2-prawo,3-prosto) np. odpala migacz lub czeka na stan zwrotnicy int iRouteWanted; // oczekiwany kierunek jazdy (0-stop,1-lewo,2-prawo,3-prosto) np. odpala
private: // migacz lub czeka na stan zwrotnicy
TDynamicObject *pVehicle; //pojazd w którym siedzi sterujący private:
TDynamicObject *pVehicles[2]; //skrajne pojazdy w składzie (niekoniecznie bezpośrednio sterowane) TDynamicObject *pVehicle; // pojazd w którym siedzi sterujący
TMoverParameters *mvControlling; //jakim pojazdem steruje (może silnikowym w EZT) TDynamicObject *
TMoverParameters *mvOccupied; //jakim pojazdem hamuje pVehicles[2]; // skrajne pojazdy w składzie (niekoniecznie bezpośrednio sterowane)
Mtable::TTrainParameters *TrainParams; //rozkład jazdy zawsze jest, nawet jeśli pusty TMoverParameters *mvControlling; // jakim pojazdem steruje (może silnikowym w EZT)
//int TrainNumber; //numer rozkladowy tego pociagu TMoverParameters *mvOccupied; // jakim pojazdem hamuje
//AnsiString OrderCommand; //komenda pobierana z pojazdu Mtable::TTrainParameters *TrainParams; // rozkład jazdy zawsze jest, nawet jeśli pusty
//double OrderValue; //argument komendy // int TrainNumber; //numer rozkladowy tego pociagu
int iRadioChannel; //numer aktualnego kanału radiowego // AnsiString OrderCommand; //komenda pobierana z pojazdu
TTextSound *tsGuardSignal; //komunikat od kierownika // double OrderValue; //argument komendy
int iGuardRadio; //numer kanału radiowego kierownika (0, gdy nie używa radia) int iRadioChannel; // numer aktualnego kanału radiowego
public: TTextSound *tsGuardSignal; // komunikat od kierownika
double AccPreferred; //preferowane przyspieszenie (wg psychiki kierującego, zmniejszana przy wykryciu kolizji) int iGuardRadio; // numer kanału radiowego kierownika (0, gdy nie używa radia)
double AccDesired; //przyspieszenie, jakie ma utrzymywać (<0:nie przyspieszaj,<-0.1:hamuj) public:
double VelDesired; //predkość, z jaką ma jechać, wynikająca z analizy tableki; <=VelSignal double AccPreferred; // preferowane przyspieszenie (wg psychiki kierującego, zmniejszana przy
double fAccDesiredAv; //uśrednione przyspieszenie z kolejnych przebłysków świadomości, żeby ograniczyć migotanie // wykryciu kolizji)
private: double AccDesired; // przyspieszenie, jakie ma utrzymywać (<0:nie przyspieszaj,<-0.1:hamuj)
double VelforDriver; //prędkość, używana przy zmianie kierunku (ograniczenie przy nieznajmości szlaku?) double VelDesired; // predkość, z jaką ma jechać, wynikająca z analizy tableki; <=VelSignal
double VelSignal; //predkość zadawana przez semafor (funkcją SetVelocity()) double fAccDesiredAv; // uśrednione przyspieszenie z kolejnych przebłysków świadomości, żeby
double VelLimit; //predkość zadawana przez event jednokierunkowego ograniczenia prędkości (PutValues albo komendą) // ograniczyć migotanie
public: private:
double VelNext; //prędkość, jaka ma być po przejechaniu długości ProximityDist double VelforDriver; // prędkość, używana przy zmianie kierunku (ograniczenie przy nieznajmości
private: // szlaku?)
//double fProximityDist; //odleglosc podawana w SetProximityVelocity(); >0:przeliczać do punktu, <0:podana wartość double VelSignal; // predkość zadawana przez semafor (funkcją SetVelocity())
public: double VelLimit; // predkość zadawana przez event jednokierunkowego ograniczenia prędkości
double ActualProximityDist; //odległość brana pod uwagę przy wyliczaniu prędkości i przyspieszenia // (PutValues albo komendą)
private: public:
vector3 vCommandLocation; //polozenie wskaznika, sygnalizatora lub innego obiektu do ktorego odnosi sie komenda double VelNext; // prędkość, jaka ma być po przejechaniu długości ProximityDist
TOrders OrderList[maxorders]; //lista rozkazów private:
int OrderPos,OrderTop; //rozkaz aktualny oraz wolne miejsce do wstawiania nowych // double fProximityDist; //odleglosc podawana w SetProximityVelocity(); >0:przeliczać do
std::ofstream LogFile; //zapis parametrow fizycznych // punktu, <0:podana wartość
std::ofstream AILogFile; //log AI public:
double
ActualProximityDist; // odległość brana pod uwagę przy wyliczaniu prędkości i przyspieszenia
private:
vector3 vCommandLocation; // polozenie wskaznika, sygnalizatora lub innego obiektu do ktorego
// odnosi sie komenda
TOrders OrderList[maxorders]; // lista rozkazów
int OrderPos, OrderTop; // rozkaz aktualny oraz wolne miejsce do wstawiania nowych
std::ofstream LogFile; // zapis parametrow fizycznych
std::ofstream AILogFile; // log AI
bool MaxVelFlag; bool MaxVelFlag;
bool MinVelFlag; bool MinVelFlag;
int iDirection; //kierunek jazdy względem sprzęgów pojazdu, w którym siedzi AI (1=przód,-1=tył) int iDirection; // kierunek jazdy względem sprzęgów pojazdu, w którym siedzi AI (1=przód,-1=tył)
int iDirectionOrder; //żadany kierunek jazdy (służy do zmiany kierunku) int iDirectionOrder; //żadany kierunek jazdy (służy do zmiany kierunku)
int iVehicleCount; //ilość pojazdów do odłączenia albo zabrania ze składu (-1=wszystkie) int iVehicleCount; // ilość pojazdów do odłączenia albo zabrania ze składu (-1=wszystkie)
int iCoupler; //maska sprzęgu, jaką należy użyć przy łączeniu (po osiągnięciu trybu Connect), 0 gdy jazda bez łączenia int iCoupler; // maska sprzęgu, jaką należy użyć przy łączeniu (po osiągnięciu trybu Connect), 0
int iDriverFailCount; //licznik błędów AI // gdy jazda bez łączenia
bool Need_TryAgain; //true, jeśli druga pozycja w elektryku nie załapała int iDriverFailCount; // licznik błędów AI
bool Need_TryAgain; // true, jeśli druga pozycja w elektryku nie załapała
bool Need_BrakeRelease; bool Need_BrakeRelease;
public:
double fMinProximityDist; //minimalna oległość do przeszkody, jaką należy zachować public:
double fOverhead1; //informacja o napięciu w sieci trakcyjnej (0=brak drutu, zatrzymaj!) double fMinProximityDist; // minimalna oległość do przeszkody, jaką należy zachować
double fOverhead2; //informacja o sposobie jazdy (-1=normalnie, 0=bez prądu, >0=z opuszczonym i ograniczeniem prędkości) double fOverhead1; // informacja o napięciu w sieci trakcyjnej (0=brak drutu, zatrzymaj!)
int iOverheadZero; //suma bitowa jezdy bezprądowej, bity ustawiane przez pojazdy z podniesionymi pantografami double fOverhead2; // informacja o sposobie jazdy (-1=normalnie, 0=bez prądu, >0=z opuszczonym i
int iOverheadDown; //suma bitowa opuszczenia pantografów, bity ustawiane przez pojazdy z podniesionymi pantografami // ograniczeniem prędkości)
double fVoltage; //uśrednione napięcie sieci: przy spadku poniżej wartości minimalnej opóźnić rozruch o losowy czas int iOverheadZero; // suma bitowa jezdy bezprądowej, bity ustawiane przez pojazdy z
private: // podniesionymi pantografami
double fMaxProximityDist; //akceptowalna odległość stanięcia przed przeszkodą int iOverheadDown; // suma bitowa opuszczenia pantografów, bity ustawiane przez pojazdy z
TStopReason eStopReason; //powód zatrzymania przy ustawieniu zerowej prędkości // podniesionymi pantografami
double fVoltage; // uśrednione napięcie sieci: przy spadku poniżej wartości minimalnej opóźnić
// rozruch o losowy czas
private:
double fMaxProximityDist; // akceptowalna odległość stanięcia przed przeszkodą
TStopReason eStopReason; // powód zatrzymania przy ustawieniu zerowej prędkości
AnsiString VehicleName; AnsiString VehicleName;
double fVelPlus; //dopuszczalne przekroczenie prędkości na ograniczeniu bez hamowania double fVelPlus; // dopuszczalne przekroczenie prędkości na ograniczeniu bez hamowania
double fVelMinus; //margines obniżenia prędkości, powodujący załączenie napędu double fVelMinus; // margines obniżenia prędkości, powodujący załączenie napędu
double fWarningDuration; //ile czasu jeszcze trąbić double fWarningDuration; // ile czasu jeszcze trąbić
double fStopTime; //czas postoju przed dalszą jazdą (np. na przystanku) double fStopTime; // czas postoju przed dalszą jazdą (np. na przystanku)
double WaitingTime; //zliczany czas oczekiwania do samoistnego ruszenia double WaitingTime; // zliczany czas oczekiwania do samoistnego ruszenia
double WaitingExpireTime; //maksymlany czas oczekiwania do samoistnego ruszenia double WaitingExpireTime; // maksymlany czas oczekiwania do samoistnego ruszenia
//TEvent* eSignLast; //ostatnio znaleziony sygnał, o ile nie minięty // TEvent* eSignLast; //ostatnio znaleziony sygnał, o ile nie minięty
private: //---//---//---//---// koniec zmiennych, poniżej metody //---//---//---//---// private: //---//---//---//---// koniec zmiennych, poniżej metody //---//---//---//---//
void __fastcall SetDriverPsyche(); void __fastcall SetDriverPsyche();
bool __fastcall PrepareEngine(); bool __fastcall PrepareEngine();
bool __fastcall ReleaseEngine(); bool __fastcall ReleaseEngine();
bool __fastcall IncBrake(); bool __fastcall IncBrake();
bool __fastcall DecBrake(); bool __fastcall DecBrake();
bool __fastcall IncSpeed(); bool __fastcall IncSpeed();
bool __fastcall DecSpeed(bool force=false); bool __fastcall DecSpeed(bool force = false);
void __fastcall SpeedSet(); void __fastcall SpeedSet();
void __fastcall Doors(bool what); void __fastcall Doors(bool what);
void __fastcall RecognizeCommand(); //odczytuje komende przekazana lokomotywie void __fastcall RecognizeCommand(); // odczytuje komende przekazana lokomotywie
void __fastcall Activation(); //umieszczenie obsady w odpowiednim członie void __fastcall Activation(); // umieszczenie obsady w odpowiednim członie
void __fastcall ControllingSet(); //znajduje człon do sterowania void __fastcall ControllingSet(); // znajduje człon do sterowania
void __fastcall AutoRewident(); //ustawia hamulce w składzie void __fastcall AutoRewident(); // ustawia hamulce w składzie
public: public:
Mtable::TTrainParameters* __fastcall Timetable() {return TrainParams;}; Mtable::TTrainParameters *__fastcall Timetable() { return TrainParams; };
void __fastcall PutCommand(AnsiString NewCommand,double NewValue1,double NewValue2,const _mover::TLocation &NewLocation,TStopReason reason=stopComm); void __fastcall PutCommand(AnsiString NewCommand, double NewValue1, double NewValue2,
bool __fastcall PutCommand(AnsiString NewCommand,double NewValue1,double NewValue2,const vector3 *NewLocation,TStopReason reason=stopComm); const _mover::TLocation &NewLocation, TStopReason reason = stopComm);
bool __fastcall UpdateSituation(double dt); //uruchamiac przynajmniej raz na sekundę bool __fastcall PutCommand(AnsiString NewCommand, double NewValue1, double NewValue2,
//procedury dotyczace rozkazow dla maszynisty const vector3 *NewLocation, TStopReason reason = stopComm);
void __fastcall SetVelocity(double NewVel,double NewVelNext,TStopReason r=stopNone); //uaktualnia informacje o prędkości bool __fastcall UpdateSituation(double dt); // uruchamiac przynajmniej raz na sekundę
bool __fastcall SetProximityVelocity(double NewDist,double NewVelNext); //uaktualnia informacje o prędkości przy nastepnym semaforze // procedury dotyczace rozkazow dla maszynisty
public: void __fastcall SetVelocity(double NewVel, double NewVelNext,
TStopReason r = stopNone); // uaktualnia informacje o prędkości
bool __fastcall SetProximityVelocity(
double NewDist,
double NewVelNext); // uaktualnia informacje o prędkości przy nastepnym semaforze
public:
void __fastcall JumpToNextOrder(); void __fastcall JumpToNextOrder();
void __fastcall JumpToFirstOrder(); void __fastcall JumpToFirstOrder();
void __fastcall OrderPush(TOrders NewOrder); void __fastcall OrderPush(TOrders NewOrder);
void __fastcall OrderNext(TOrders NewOrder); void __fastcall OrderNext(TOrders NewOrder);
TOrders __fastcall OrderCurrentGet(); TOrders __fastcall OrderCurrentGet();
TOrders __fastcall OrderNextGet(); TOrders __fastcall OrderNextGet();
bool __fastcall CheckVehicles(TOrders user=Wait_for_orders); bool __fastcall CheckVehicles(TOrders user = Wait_for_orders);
private:
private:
void __fastcall CloseLog(); void __fastcall CloseLog();
void __fastcall OrderCheck(); void __fastcall OrderCheck();
public:
public:
void __fastcall OrdersInit(double fVel); void __fastcall OrdersInit(double fVel);
void __fastcall OrdersClear(); void __fastcall OrdersClear();
void __fastcall OrdersDump(); void __fastcall OrdersDump();
__fastcall TController __fastcall TController(bool AI, TDynamicObject *NewControll, bool InitPsyche,
(bool AI, bool primary = true // czy ma aktywnie prowadzić?
TDynamicObject *NewControll,
bool InitPsyche,
bool primary=true //czy ma aktywnie prowadzić?
); );
AnsiString __fastcall OrderCurrent(); AnsiString __fastcall OrderCurrent();
void __fastcall WaitingSet(double Seconds); void __fastcall WaitingSet(double Seconds);
private:
private:
AnsiString __fastcall Order2Str(TOrders Order); AnsiString __fastcall Order2Str(TOrders Order);
void __fastcall DirectionForward(bool forward); void __fastcall DirectionForward(bool forward);
int __fastcall OrderDirectionChange(int newdir,TMoverParameters *Vehicle); int __fastcall OrderDirectionChange(int newdir, TMoverParameters *Vehicle);
void __fastcall Lights(int head,int rear); void __fastcall Lights(int head, int rear);
double __fastcall Distance(vector3 &p1,vector3 &n,vector3 &p2); double __fastcall Distance(vector3 &p1, vector3 &n, vector3 &p2);
private: //Ra: metody obsługujące skanowanie toru
TEvent* __fastcall CheckTrackEvent(double fDirection,TTrack *Track); private: // Ra: metody obsługujące skanowanie toru
TEvent *__fastcall CheckTrackEvent(double fDirection, TTrack *Track);
bool __fastcall TableCheckEvent(TEvent *e); bool __fastcall TableCheckEvent(TEvent *e);
bool __fastcall TableAddNew(); bool __fastcall TableAddNew();
bool __fastcall TableNotFound(TEvent *e); bool __fastcall TableNotFound(TEvent *e);
void __fastcall TableClear(); void __fastcall TableClear();
TEvent* __fastcall TableCheckTrackEvent(double fDirection,TTrack *Track); TEvent *__fastcall TableCheckTrackEvent(double fDirection, TTrack *Track);
void __fastcall TableTraceRoute(double fDistance,TDynamicObject *pVehicle=NULL); void __fastcall TableTraceRoute(double fDistance, TDynamicObject *pVehicle = NULL);
void __fastcall TableCheck(double fDistance); void __fastcall TableCheck(double fDistance);
TCommandType __fastcall TableUpdate(double &fVelDes,double &fDist,double &fNext,double &fAcc); TCommandType __fastcall TableUpdate(double &fVelDes, double &fDist, double &fNext,
double &fAcc);
void __fastcall TablePurger(); void __fastcall TablePurger();
private: //Ra: stare funkcje skanujące, używane do szukania sygnalizatora z tyłu
private: // Ra: stare funkcje skanujące, używane do szukania sygnalizatora z tyłu
bool __fastcall BackwardTrackBusy(TTrack *Track); bool __fastcall BackwardTrackBusy(TTrack *Track);
TEvent* __fastcall CheckTrackEventBackward(double fDirection,TTrack *Track); TEvent *__fastcall CheckTrackEventBackward(double fDirection, TTrack *Track);
TTrack* __fastcall BackwardTraceRoute(double &fDistance,double &fDirection,TTrack *Track,TEvent*&Event); TTrack *__fastcall BackwardTraceRoute(double &fDistance, double &fDirection, TTrack *Track,
void __fastcall SetProximityVelocity(double dist,double vel,const vector3 *pos); TEvent *&Event);
void __fastcall SetProximityVelocity(double dist, double vel, const vector3 *pos);
TCommandType __fastcall BackwardScan(); TCommandType __fastcall BackwardScan();
public:
public:
void __fastcall PhysicsLog(); void __fastcall PhysicsLog();
AnsiString __fastcall StopReasonText(); AnsiString __fastcall StopReasonText();
__fastcall ~TController(); __fastcall ~TController();
@@ -307,8 +335,8 @@ public:
int __fastcall StationCount(); int __fastcall StationCount();
int __fastcall StationIndex(); int __fastcall StationIndex();
bool __fastcall IsStop(); bool __fastcall IsStop();
bool __fastcall Primary() {return this?bool(iDrivigFlags&movePrimary):false;}; bool __fastcall Primary() { return this ? bool(iDrivigFlags & movePrimary) : false; };
int inline __fastcall DrivigFlags() {return iDrivigFlags;}; int inline __fastcall DrivigFlags() { return iDrivigFlags; };
void __fastcall MoveTo(TDynamicObject *to); void __fastcall MoveTo(TDynamicObject *to);
void __fastcall DirectionInitial(); void __fastcall DirectionInitial();
AnsiString __fastcall TableText(int i); AnsiString __fastcall TableText(int i);

6028
DynObj.cpp
View File

File diff suppressed because it is too large Load Diff

578
DynObj.h
View File

@@ -8,7 +8,7 @@
#include "QueryParserComp.hpp" #include "QueryParserComp.hpp"
#include "Mover.h" #include "Mover.h"
#include "TractionPower.h" #include "TractionPower.h"
//McZapkie: // McZapkie:
#include "MdlMngr.h" #include "MdlMngr.h"
#include "RealSound.h" #include "RealSound.h"
#include "AdvSound.h" #include "AdvSound.h"
@@ -17,22 +17,22 @@
//--------------------------------------------------------------------------- //---------------------------------------------------------------------------
//--------------------------------------------------------------------------- //---------------------------------------------------------------------------
//--------------------------------------------------------------------------- //---------------------------------------------------------------------------
const ANIM_TYPES=7; //Ra: ilość typów animacji const ANIM_TYPES = 7; // Ra: ilość typów animacji
const ANIM_WHEELS =0; //koła const ANIM_WHEELS = 0; // koła
const ANIM_DOORS =1; //drzwi const ANIM_DOORS = 1; // drzwi
const ANIM_LEVERS =2; //elementy obracane (wycieraczki, koła skrętne, przestawiacze, klocki ham.) const ANIM_LEVERS = 2; // elementy obracane (wycieraczki, koła skrętne, przestawiacze, klocki ham.)
const ANIM_BUFFERS=3; //elementy przesuwane (zderzaki) const ANIM_BUFFERS = 3; // elementy przesuwane (zderzaki)
const ANIM_BOOGIES=4; //wózki (są skręcane w dwóch osiach) const ANIM_BOOGIES = 4; // wózki (są skręcane w dwóch osiach)
const ANIM_PANTS =5; //pantografy const ANIM_PANTS = 5; // pantografy
const ANIM_STEAMS =6; //napęd parowozu const ANIM_STEAMS = 6; // napęd parowozu
class TAnim; class TAnim;
typedef void (__closure *TUpdate)(TAnim *pAnim); //typ funkcji aktualizującej położenie submodeli typedef void(__closure *TUpdate)(TAnim *pAnim); // typ funkcji aktualizującej położenie submodeli
//McZapkie-250202 // McZapkie-250202
const MaxAxles=16; //ABu 280105: zmienione z 8 na 16 const MaxAxles = 16; // ABu 280105: zmienione z 8 na 16
//const MaxAnimatedAxles=16; //i to tez. // const MaxAnimatedAxles=16; //i to tez.
//const MaxAnimatedDoors=16; //NBMX wrzesien 2003 // const MaxAnimatedDoors=16; //NBMX wrzesien 2003
/* /*
Ra: Utworzyć klasę wyposażenia opcjonalnego, z której będą dziedziczyć klasy drzwi, Ra: Utworzyć klasę wyposażenia opcjonalnego, z której będą dziedziczyć klasy drzwi,
pantografów, napędu parowozu i innych ruchomych części pojazdów. Klasy powinny być pantografów, napędu parowozu i innych ruchomych części pojazdów. Klasy powinny być
@@ -45,86 +45,89 @@ szczeg
modeli na stacjach na ogół przewaga jest tych nieruchomych). modeli na stacjach na ogół przewaga jest tych nieruchomych).
*/ */
class TAnimValveGear class TAnimValveGear
{//współczynniki do animacji parowozu (wartości przykładowe dla Pt47) { // współczynniki do animacji parowozu (wartości przykładowe dla Pt47)
int iValues; //ilość liczb (wersja): int iValues; // ilość liczb (wersja):
float fKorbowodR; //długość korby (pół skoku tłoka) [m]: 0.35 float fKorbowodR; // długość korby (pół skoku tłoka) [m]: 0.35
float fKorbowodL; //długość korbowodu [m]: 3.8 float fKorbowodL; // długość korbowodu [m]: 3.8
float fDrazekR; //promień mimośrodu (drążka) [m]: 0.18 float fDrazekR; // promień mimośrodu (drążka) [m]: 0.18
float fDrazekL; //dł. drążka mimośrodowego [m]: 2.55889 float fDrazekL; // dł. drążka mimośrodowego [m]: 2.55889
float fJarzmoV; //wysokość w pionie osi jarzma od osi koła [m]: 0.751 float fJarzmoV; // wysokość w pionie osi jarzma od osi koła [m]: 0.751
float fJarzmoH; //odległość w poziomie osi jarzma od osi koła [m]: 2.550 float fJarzmoH; // odległość w poziomie osi jarzma od osi koła [m]: 2.550
float fJarzmoR; //promień jarzma do styku z drążkiem [m]: 0.450 float fJarzmoR; // promień jarzma do styku z drążkiem [m]: 0.450
float fJarzmoA; //kąt mimośrodu względem kąta koła [°]: -96.77416667 float fJarzmoA; // kąt mimośrodu względem kąta koła [°]: -96.77416667
float fWdzidloL; //długość wodzidła [m]: 2.0 float fWdzidloL; // długość wodzidła [m]: 2.0
float fWahaczH; //długość wahacza (góra) [m]: 0.14 float fWahaczH; // długość wahacza (góra) [m]: 0.14
float fSuwakH; //wysokość osi suwaka ponad osią koła [m]: 0.62 float fSuwakH; // wysokość osi suwaka ponad osią koła [m]: 0.62
float fWahaczL; //długość wahacza (dół) [m]: 0.84 float fWahaczL; // długość wahacza (dół) [m]: 0.84
float fLacznikL; //długość łącznika wahacza [m]: 0.75072 float fLacznikL; // długość łącznika wahacza [m]: 0.75072
float fRamieL; //odległość ramienia krzyżulca od osi koła [m]: 0.192 float fRamieL; // odległość ramienia krzyżulca od osi koła [m]: 0.192
float fSuwakL; //odległość środka tłoka/suwaka od osi koła [m]: 5.650 float fSuwakL; // odległość środka tłoka/suwaka od osi koła [m]: 5.650
//dołożyć parametry drążka nastawnicy // dołożyć parametry drążka nastawnicy
//albo nawet zrobić dynamiczną tablicę float[] i w nią pakować wszelkie współczynniki, potem używać indeksów // albo nawet zrobić dynamiczną tablicę float[] i w nią pakować wszelkie współczynniki, potem
//współczynniki mogą być wspólne dla 2-4 tłoków, albo każdy tłok może mieć odrębne // używać indeksów
// współczynniki mogą być wspólne dla 2-4 tłoków, albo każdy tłok może mieć odrębne
}; };
class TAnimPant class TAnimPant
{//współczynniki do animacji pantografu { // współczynniki do animacji pantografu
public: public:
vector3 vPos; //Ra: współrzędne punktu zerowego pantografu (X dodatnie dla przedniego) vector3 vPos; // Ra: współrzędne punktu zerowego pantografu (X dodatnie dla przedniego)
double fLenL1; //długość dolnego ramienia 1, odczytana z modelu double fLenL1; // długość dolnego ramienia 1, odczytana z modelu
double fLenU1; //długość górnego ramienia 1, odczytana z modelu double fLenU1; // długość górnego ramienia 1, odczytana z modelu
double fLenL2; //długość dolnego ramienia 2, odczytana z modelu double fLenL2; // długość dolnego ramienia 2, odczytana z modelu
double fLenU2; //długość górnego ramienia 2, odczytana z modelu double fLenU2; // długość górnego ramienia 2, odczytana z modelu
double fHoriz; //przesunięcie ślizgu w długości pojazdu względem osi obrotu dolnego ramienia double fHoriz; // przesunięcie ślizgu w długości pojazdu względem osi obrotu dolnego ramienia
double fHeight; //wysokość ślizgu ponad oś obrotu, odejmowana od wysokości drutu double fHeight; // wysokość ślizgu ponad oś obrotu, odejmowana od wysokości drutu
double fWidth; //połowa szerokości roboczej ślizgu, do wykrycia ześlizgnięcia się drutu double fWidth; // połowa szerokości roboczej ślizgu, do wykrycia ześlizgnięcia się drutu
double fAngleL0; //Ra: początkowy kąt dolnego ramienia (odejmowany przy animacji) double fAngleL0; // Ra: początkowy kąt dolnego ramienia (odejmowany przy animacji)
double fAngleU0; //Ra: początkowy kąt górnego ramienia (odejmowany przy animacji) double fAngleU0; // Ra: początkowy kąt górnego ramienia (odejmowany przy animacji)
double PantTraction; //Winger 170204: wysokość drutu ponad punktem na wysokości vPos.y p.g.s. double PantTraction; // Winger 170204: wysokość drutu ponad punktem na wysokości vPos.y p.g.s.
double PantWys; //Ra: aktualna wysokość uniesienia ślizgu do porównania z wysokością drutu double PantWys; // Ra: aktualna wysokość uniesienia ślizgu do porównania z wysokością drutu
double fAngleL; //Winger 160204: aktualny kąt ramienia dolnego double fAngleL; // Winger 160204: aktualny kąt ramienia dolnego
double fAngleU; //Ra: aktualny kąt ramienia górnego double fAngleU; // Ra: aktualny kąt ramienia górnego
double NoVoltTime; //czas od utraty kontaktu z drutem double NoVoltTime; // czas od utraty kontaktu z drutem
TTraction *hvPowerWire; //aktualnie podczepione druty, na razie tu TTraction *hvPowerWire; // aktualnie podczepione druty, na razie tu
float fWidthExtra; //dodatkowy rozmiar poziomy poza część roboczą (fWidth) float fWidthExtra; // dodatkowy rozmiar poziomy poza część roboczą (fWidth)
float fHeightExtra[5]; //łamana symulująca kształt nabieżnika float fHeightExtra[5]; //łamana symulująca kształt nabieżnika
//double fHorizontal; //Ra 2015-01: położenie drutu względem osi pantografu // double fHorizontal; //Ra 2015-01: położenie drutu względem osi pantografu
void __fastcall AKP_4E(); void __fastcall AKP_4E();
}; };
class TAnim class TAnim
{//klasa animowanej części pojazdu (koła, drzwi, pantografy, burty, napęd parowozu, siłowniki itd.) { // klasa animowanej części pojazdu (koła, drzwi, pantografy, burty, napęd parowozu, siłowniki
public: // itd.)
public:
union union
{ {
TSubModel *smAnimated; //animowany submodel (jeśli tylko jeden, np. oś) TSubModel *smAnimated; // animowany submodel (jeśli tylko jeden, np. oś)
TSubModel **smElement; //jeśli animowanych elementów jest więcej (pantograf, napęd parowozu) TSubModel **smElement; // jeśli animowanych elementów jest więcej (pantograf, napęd
int iShift; //przesunięcie przed przydzieleniem wskaźnika // parowozu)
int iShift; // przesunięcie przed przydzieleniem wskaźnika
}; };
union union
{//parametry animacji { // parametry animacji
TAnimValveGear *pValveGear; //współczynniki do animacji parowozu TAnimValveGear *pValveGear; // współczynniki do animacji parowozu
double *dWheelAngle; //wskaźnik na kąt obrotu osi double *dWheelAngle; // wskaźnik na kąt obrotu osi
float *fParam; //różne parametry dla animacji float *fParam; // różne parametry dla animacji
TAnimPant *fParamPants; //różne parametry dla animacji TAnimPant *fParamPants; // różne parametry dla animacji
}; };
union union
{//wskaźnik na obiekt odniesienia { // wskaźnik na obiekt odniesienia
double *fDoubleBase; //jakiś double w fizyce double *fDoubleBase; // jakiś double w fizyce
float *fFloatBase; //jakiś float w fizyce float *fFloatBase; // jakiś float w fizyce
int *iIntBase; //jakiś int w fizyce int *iIntBase; // jakiś int w fizyce
}; };
//void _fastcall Update(); //wskaźnik do funkcji aktualizacji animacji // void _fastcall Update(); //wskaźnik do funkcji aktualizacji animacji
int iFlags; //flagi animacji int iFlags; // flagi animacji
float fMaxDist; //do jakiej odległości wykonywana jest animacja float fMaxDist; // do jakiej odległości wykonywana jest animacja
float fSpeed; //parametr szybkości animacji float fSpeed; // parametr szybkości animacji
int iNumber; //numer kolejny obiektu int iNumber; // numer kolejny obiektu
public: public:
__fastcall TAnim(); __fastcall TAnim();
__fastcall ~TAnim(); __fastcall ~TAnim();
TUpdate yUpdate; //metoda TDynamicObject aktualizująca animację TUpdate yUpdate; // metoda TDynamicObject aktualizująca animację
int __fastcall TypeSet(int i,int fl=0); //ustawienie typu int __fastcall TypeSet(int i, int fl = 0); // ustawienie typu
void __fastcall Parovoz(); //wykonanie obliczeń animacji void __fastcall Parovoz(); // wykonanie obliczeń animacji
}; };
//--------------------------------------------------------------------------- //---------------------------------------------------------------------------
@@ -132,149 +135,156 @@ public:
//--------------------------------------------------------------------------- //---------------------------------------------------------------------------
class TDynamicObject class TDynamicObject
{//klasa pojazdu { // klasa pojazdu
private: //położenie pojazdu w świecie oraz parametry ruchu private: // położenie pojazdu w świecie oraz parametry ruchu
vector3 vPosition; //Ra: pozycja pojazdu liczona zaraz po przesunięciu vector3 vPosition; // Ra: pozycja pojazdu liczona zaraz po przesunięciu
vector3 vCoulpler[2]; //współrzędne sprzęgów do liczenia zderzeń czołowych vector3 vCoulpler[2]; // współrzędne sprzęgów do liczenia zderzeń czołowych
vector3 vUp,vFront,vLeft; //wektory jednostkowe ustawienia pojazdu vector3 vUp, vFront, vLeft; // wektory jednostkowe ustawienia pojazdu
int iDirection; //kierunek pojazdu względem czoła składu (1=zgodny,0=przeciwny) int iDirection; // kierunek pojazdu względem czoła składu (1=zgodny,0=przeciwny)
TTrackShape ts; //parametry toru przekazywane do fizyki TTrackShape ts; // parametry toru przekazywane do fizyki
TTrackParam tp; //parametry toru przekazywane do fizyki TTrackParam tp; // parametry toru przekazywane do fizyki
TTrackFollower Axle0; //oś z przodu (od sprzęgu 0) TTrackFollower Axle0; // oś z przodu (od sprzęgu 0)
TTrackFollower Axle1; //oś z tyłu (od sprzęgu 1) TTrackFollower Axle1; // oś z tyłu (od sprzęgu 1)
int iAxleFirst; //numer pierwszej osi w kierunku ruchu (oś wiążąca pojazd z torem i wyzwalająca eventy) int iAxleFirst; // numer pierwszej osi w kierunku ruchu (oś wiążąca pojazd z torem i wyzwalająca
float fAxleDist; //rozstaw wózków albo osi do liczenia proporcji zacienienia // eventy)
vector3 modelRot; //obrot pudła względem świata - do przeanalizowania, czy potrzebne!!! float fAxleDist; // rozstaw wózków albo osi do liczenia proporcji zacienienia
//bool bCameraNear; //blisko kamer są potrzebne dodatkowe obliczenia szczegółów vector3 modelRot; // obrot pudła względem świata - do przeanalizowania, czy potrzebne!!!
TDynamicObject* __fastcall ABuFindNearestObject(TTrack *Track,TDynamicObject *MyPointer,int &CouplNr); // bool bCameraNear; //blisko kamer są potrzebne dodatkowe obliczenia szczegółów
public: //parametry położenia pojazdu dostępne publicznie TDynamicObject *__fastcall ABuFindNearestObject(TTrack *Track, TDynamicObject *MyPointer,
AnsiString asTrack; //nazwa toru początkowego; wywalić? int &CouplNr);
AnsiString asDestination; //dokąd pojazd ma być kierowany "(stacja):(tor)"
matrix4x4 mMatrix; //macierz przekształcenia do renderowania modeli
TMoverParameters *MoverParameters; //parametry fizyki ruchu oraz przeliczanie
//TMoverParameters *pControlled; //wskaźnik do sterowanego członu silnikowego
TDynamicObject *NextConnected; //pojazd podłączony od strony sprzęgu 1 (kabina -1)
TDynamicObject *PrevConnected; //pojazd podłączony od strony sprzęgu 0 (kabina 1)
int NextConnectedNo; //numer sprzęgu podłączonego z tyłu
int PrevConnectedNo; //numer sprzęgu podłączonego z przodu
double fScanDist; //odległość skanowania torów na obecność innych pojazdów
public: //modele składowe pojazdu public: // parametry położenia pojazdu dostępne publicznie
TModel3d *mdModel; //model pudła AnsiString asTrack; // nazwa toru początkowego; wywalić?
TModel3d *mdLoad; //model zmiennego ładunku AnsiString asDestination; // dokąd pojazd ma być kierowany "(stacja):(tor)"
TModel3d *mdPrzedsionek; //model przedsionków dla EZT - może użyć mdLoad zamiast? matrix4x4 mMatrix; // macierz przekształcenia do renderowania modeli
TModel3d *mdKabina; //model kabiny dla użytkownika; McZapkie-030303: to z train.h TMoverParameters *MoverParameters; // parametry fizyki ruchu oraz przeliczanie
TModel3d *mdLowPolyInt; //ABu 010305: wnetrze lowpoly // TMoverParameters *pControlled; //wskaźnik do sterowanego członu silnikowego
float fShade; //zacienienie: 0:normalnie, -1:w ciemności, +1:dodatkowe światło (brak koloru?) TDynamicObject *NextConnected; // pojazd podłączony od strony sprzęgu 1 (kabina -1)
TDynamicObject *PrevConnected; // pojazd podłączony od strony sprzęgu 0 (kabina 1)
int NextConnectedNo; // numer sprzęgu podłączonego z tyłu
int PrevConnectedNo; // numer sprzęgu podłączonego z przodu
double fScanDist; // odległość skanowania torów na obecność innych pojazdów
private: //zmienne i metody do animacji submodeli; Ra: sprzatam animacje w pojeździe public: // modele składowe pojazdu
public: //tymczasowo udostępnione do wyszukiwania drutu TModel3d *mdModel; // model pudła
int iAnimType[ANIM_TYPES]; //0-osie,1-drzwi,2-obracane,3-zderzaki,4-wózki,5-pantografy,6-tłoki TModel3d *mdLoad; // model zmiennego ładunku
private: TModel3d *mdPrzedsionek; // model przedsionków dla EZT - może użyć mdLoad zamiast?
int iAnimations; //liczba obiektów animujących TModel3d *mdKabina; // model kabiny dla użytkownika; McZapkie-030303: to z train.h
TAnim *pAnimations; //obiekty animujące (zawierają wskaźnik do funkcji wykonującej animację) TModel3d *mdLowPolyInt; // ABu 010305: wnetrze lowpoly
TSubModel **pAnimated; //lista animowanych submodeli (może być ich więcej niż obiektów animujących) float fShade; // zacienienie: 0:normalnie, -1:w ciemności, +1:dodatkowe światło (brak koloru?)
double dWheelAngle[3]; //kąty obrotu kół: 0=przednie toczne, 1=napędzające i wiązary, 2=tylne toczne
void UpdateNone(TAnim *pAnim) {}; //animacja pusta (funkcje ustawiania submodeli, gdy blisko kamery) private: // zmienne i metody do animacji submodeli; Ra: sprzatam animacje w pojeździe
void UpdateAxle(TAnim *pAnim); //animacja osi public: // tymczasowo udostępnione do wyszukiwania drutu
void UpdateBoogie(TAnim *pAnim); //animacja wózka int iAnimType[ANIM_TYPES]; // 0-osie,1-drzwi,2-obracane,3-zderzaki,4-wózki,5-pantografy,6-tłoki
void UpdateDoorTranslate(TAnim *pAnim); //animacja drzwi - przesuw private:
void UpdateDoorRotate(TAnim *pAnim); //animacja drzwi - obrót int iAnimations; // liczba obiektów animujących
void UpdateDoorFold(TAnim *pAnim); //animacja drzwi - składanie TAnim *pAnimations; // obiekty animujące (zawierają wskaźnik do funkcji wykonującej animację)
void UpdatePant(TAnim *pAnim); //animacja pantografu TSubModel **
void UpdateLeverDouble(TAnim *pAnim); //animacja gałki zależna od double pAnimated; // lista animowanych submodeli (może być ich więcej niż obiektów animujących)
void UpdateLeverFloat(TAnim *pAnim); //animacja gałki zależna od float double dWheelAngle[3]; // kąty obrotu kół: 0=przednie toczne, 1=napędzające i wiązary, 2=tylne
void UpdateLeverInt(TAnim *pAnim); //animacja gałki zależna od int (wartość) // toczne
void UpdateLeverEnum(TAnim *pAnim); //animacja gałki zależna od int (lista kątów) void
private: //Ra: ciąg dalszy animacji, dopiero do ogarnięcia UpdateNone(TAnim *pAnim){}; // animacja pusta (funkcje ustawiania submodeli, gdy blisko kamery)
//ABuWozki 060504 void UpdateAxle(TAnim *pAnim); // animacja osi
vector3 bogieRot[2]; //Obroty wozkow w/m korpusu void UpdateBoogie(TAnim *pAnim); // animacja wózka
TSubModel *smBogie[2]; //Wyszukiwanie max 2 wozkow void UpdateDoorTranslate(TAnim *pAnim); // animacja drzwi - przesuw
TSubModel *smWahacze[4]; //wahacze (np. nogi, dźwignia w drezynie) void UpdateDoorRotate(TAnim *pAnim); // animacja drzwi - obrót
TSubModel *smBrakeMode; //Ra 15-01: nastawa hamulca też void UpdateDoorFold(TAnim *pAnim); // animacja drzwi - składanie
TSubModel *smLoadMode; //Ra 15-01: nastawa próżny/ładowny void UpdatePant(TAnim *pAnim); // animacja pantografu
void UpdateLeverDouble(TAnim *pAnim); // animacja gałki zależna od double
void UpdateLeverFloat(TAnim *pAnim); // animacja gałki zależna od float
void UpdateLeverInt(TAnim *pAnim); // animacja gałki zależna od int (wartość)
void UpdateLeverEnum(TAnim *pAnim); // animacja gałki zależna od int (lista kątów)
private: // Ra: ciąg dalszy animacji, dopiero do ogarnięcia
// ABuWozki 060504
vector3 bogieRot[2]; // Obroty wozkow w/m korpusu
TSubModel *smBogie[2]; // Wyszukiwanie max 2 wozkow
TSubModel *smWahacze[4]; // wahacze (np. nogi, dźwignia w drezynie)
TSubModel *smBrakeMode; // Ra 15-01: nastawa hamulca też
TSubModel *smLoadMode; // Ra 15-01: nastawa próżny/ładowny
double fWahaczeAmp; double fWahaczeAmp;
//Winger 160204 - pantografy // Winger 160204 - pantografy
double pantspeedfactor; double pantspeedfactor;
//animacje typu przesuw // animacje typu przesuw
TSubModel *smBuforLewy[2]; TSubModel *smBuforLewy[2];
TSubModel *smBuforPrawy[2]; TSubModel *smBuforPrawy[2];
TAnimValveGear *pValveGear; TAnimValveGear *pValveGear;
vector3 vFloor; //podłoga dla ładunku vector3 vFloor; // podłoga dla ładunku
public: public:
TAnim *pants; //indeks obiektu animującego dla pantografu 0 TAnim *pants; // indeks obiektu animującego dla pantografu 0
double NoVoltTime; //czas od utraty zasilania double NoVoltTime; // czas od utraty zasilania
double dDoorMoveL; //NBMX double dDoorMoveL; // NBMX
double dDoorMoveR; //NBMX double dDoorMoveR; // NBMX
TSubModel *smBrakeSet; //nastawa hamulca (wajcha) TSubModel *smBrakeSet; // nastawa hamulca (wajcha)
TSubModel *smLoadSet; //nastawa ładunku (wajcha) TSubModel *smLoadSet; // nastawa ładunku (wajcha)
TSubModel *smWiper; //wycieraczka (poniekąd też wajcha) TSubModel *smWiper; // wycieraczka (poniekąd też wajcha)
//Ra: koneic animacji do ogarnięcia // Ra: koneic animacji do ogarnięcia
private: private:
void ABuLittleUpdate(double ObjSqrDist); void ABuLittleUpdate(double ObjSqrDist);
bool btnOn; //ABu: czy byly uzywane buttony, jesli tak, to po renderingu wylacz bool btnOn; // ABu: czy byly uzywane buttony, jesli tak, to po renderingu wylacz
//bo ten sam model moze byc jeszcze wykorzystany przez inny obiekt! // bo ten sam model moze byc jeszcze wykorzystany przez inny obiekt!
double __fastcall ComputeRadius(vector3 p1,vector3 p2,vector3 p3,vector3 p4); double __fastcall ComputeRadius(vector3 p1, vector3 p2, vector3 p3, vector3 p4);
TButton btCoupler1; //sprzegi TButton btCoupler1; // sprzegi
TButton btCoupler2; TButton btCoupler2;
TAirCoupler btCPneumatic1; //sprzegi powietrzne //yB - zmienione z Button na AirCoupler - krzyzyki TAirCoupler
btCPneumatic1; // sprzegi powietrzne //yB - zmienione z Button na AirCoupler - krzyzyki
TAirCoupler btCPneumatic2; TAirCoupler btCPneumatic2;
TAirCoupler btCPneumatic1r; //ABu: to zeby nie bylo problemow przy laczeniu wagonow, TAirCoupler btCPneumatic1r; // ABu: to zeby nie bylo problemow przy laczeniu wagonow,
TAirCoupler btCPneumatic2r; // jesli beda polaczone sprzegami 1<->1 lub 0<->0 TAirCoupler btCPneumatic2r; // jesli beda polaczone sprzegami 1<->1 lub 0<->0
TAirCoupler btPneumatic1; //ABu: sprzegi powietrzne zolte TAirCoupler btPneumatic1; // ABu: sprzegi powietrzne zolte
TAirCoupler btPneumatic2; TAirCoupler btPneumatic2;
TAirCoupler btPneumatic1r; //ABu: analogicznie jak 4 linijki wyzej TAirCoupler btPneumatic1r; // ABu: analogicznie jak 4 linijki wyzej
TAirCoupler btPneumatic2r; TAirCoupler btPneumatic2r;
TButton btCCtrl1; //sprzegi sterowania TButton btCCtrl1; // sprzegi sterowania
TButton btCCtrl2; TButton btCCtrl2;
TButton btCPass1; //mostki przejsciowe TButton btCPass1; // mostki przejsciowe
TButton btCPass2; TButton btCPass2;
char cp1, sp1, cp2, sp2; //ustawienia węży char cp1, sp1, cp2, sp2; // ustawienia węży
TButton btEndSignals11; //sygnalu konca pociagu TButton btEndSignals11; // sygnalu konca pociagu
TButton btEndSignals13; TButton btEndSignals13;
TButton btEndSignals21; TButton btEndSignals21;
TButton btEndSignals23; TButton btEndSignals23;
TButton btEndSignals1; //zeby bylo kompatybilne ze starymi modelami... TButton btEndSignals1; // zeby bylo kompatybilne ze starymi modelami...
TButton btEndSignals2; TButton btEndSignals2;
TButton btEndSignalsTab1; //sygnaly konca pociagu (blachy) TButton btEndSignalsTab1; // sygnaly konca pociagu (blachy)
TButton btEndSignalsTab2; TButton btEndSignalsTab2;
TButton btHeadSignals11; //oswietlenie czolowe - przod TButton btHeadSignals11; // oswietlenie czolowe - przod
TButton btHeadSignals12; TButton btHeadSignals12;
TButton btHeadSignals13; TButton btHeadSignals13;
TButton btHeadSignals21; //oswietlenie czolowe - tyl TButton btHeadSignals21; // oswietlenie czolowe - tyl
TButton btHeadSignals22; TButton btHeadSignals22;
TButton btHeadSignals23; TButton btHeadSignals23;
TSubModel *smMechanik0; //Ra: mechanik wbudowany w model jako submodel? TSubModel *smMechanik0; // Ra: mechanik wbudowany w model jako submodel?
TSubModel *smMechanik1; //mechanik od strony sprzęgu 1 TSubModel *smMechanik1; // mechanik od strony sprzęgu 1
double enginevolume; //MC: pomocnicze zeby gladziej silnik buczal double enginevolume; // MC: pomocnicze zeby gladziej silnik buczal
int iAxles; //McZapkie: to potem mozna skasowac i zastapic iNumAxles int iAxles; // McZapkie: to potem mozna skasowac i zastapic iNumAxles
double dRailLength; double dRailLength;
double dRailPosition[MaxAxles]; //licznik pozycji osi w/m szyny double dRailPosition[MaxAxles]; // licznik pozycji osi w/m szyny
double dWheelsPosition[MaxAxles]; //pozycja osi w/m srodka pojazdu double dWheelsPosition[MaxAxles]; // pozycja osi w/m srodka pojazdu
TRealSound rsStukot[MaxAxles]; //dzwieki poszczegolnych osi //McZapkie-270202 TRealSound rsStukot[MaxAxles]; // dzwieki poszczegolnych osi //McZapkie-270202
TRealSound rsSilnik; //McZapkie-010302 - silnik TRealSound rsSilnik; // McZapkie-010302 - silnik
TRealSound rsWentylator; //McZapkie-030302 TRealSound rsWentylator; // McZapkie-030302
TRealSound rsPisk; //McZapkie-260302 TRealSound rsPisk; // McZapkie-260302
TRealSound rsDerailment; //McZapkie-051202 TRealSound rsDerailment; // McZapkie-051202
TRealSound rsPrzekladnia; TRealSound rsPrzekladnia;
TAdvancedSound sHorn1; TAdvancedSound sHorn1;
TAdvancedSound sHorn2; TAdvancedSound sHorn2;
TAdvancedSound sCompressor; //NBMX wrzesien 2003 TAdvancedSound sCompressor; // NBMX wrzesien 2003
TAdvancedSound sConverter; TAdvancedSound sConverter;
TAdvancedSound sSmallCompressor; TAdvancedSound sSmallCompressor;
TAdvancedSound sDepartureSignal; TAdvancedSound sDepartureSignal;
TAdvancedSound sTurbo; TAdvancedSound sTurbo;
//Winger 010304 // Winger 010304
// TRealSound rsPanTup; //PSound sPantUp; // TRealSound rsPanTup; //PSound sPantUp;
TRealSound sPantUp; TRealSound sPantUp;
TRealSound sPantDown; TRealSound sPantDown;
TRealSound rsDoorOpen; //Ra: przeniesione z kabiny TRealSound rsDoorOpen; // Ra: przeniesione z kabiny
TRealSound rsDoorClose; TRealSound rsDoorClose;
double eng_vol_act; double eng_vol_act;
@@ -285,89 +295,90 @@ private:
void __fastcall ABuModelRoll(); void __fastcall ABuModelRoll();
vector3 modelShake; vector3 modelShake;
bool renderme; //yB - czy renderowac bool renderme; // yB - czy renderowac
//TRealSound sBrakeAcc; //dźwięk przyspieszacza // TRealSound sBrakeAcc; //dźwięk przyspieszacza
PSound sBrakeAcc; PSound sBrakeAcc;
bool bBrakeAcc; bool bBrakeAcc;
TRealSound rsUnbrake; //yB - odglos luzowania TRealSound rsUnbrake; // yB - odglos luzowania
float ModCamRot; float ModCamRot;
int iInventory; //flagi bitowe posiadanych submodeli (np. świateł) int iInventory; // flagi bitowe posiadanych submodeli (np. świateł)
void __fastcall TurnOff(); void __fastcall TurnOff();
public:
int iHornWarning; //numer syreny do użycia po otrzymaniu sygnału do jazdy
bool bEnabled; //Ra: wyjechał na portal i ma być usunięty
protected:
//TTrackFollower Axle2; //dwie osie z czterech (te są protected) public:
//TTrackFollower Axle3; //Ra: wyłączyłem, bo kąty są liczone w Segment.cpp int iHornWarning; // numer syreny do użycia po otrzymaniu sygnału do jazdy
int iNumAxles; //ilość osi bool bEnabled; // Ra: wyjechał na portal i ma być usunięty
protected:
// 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; int CouplCounter;
AnsiString asModel; AnsiString asModel;
public:
void ABuScanObjects(int ScanDir,double ScanDist); public:
protected: void ABuScanObjects(int ScanDir, double ScanDist);
TDynamicObject* __fastcall ABuFindObject(TTrack *Track,int ScanDir,Byte &CouplFound,double &dist);
protected:
TDynamicObject *__fastcall ABuFindObject(TTrack *Track, int ScanDir, Byte &CouplFound,
double &dist);
void __fastcall ABuCheckMyTrack(); void __fastcall ABuCheckMyTrack();
public: public:
int *iLights; //wskaźnik na bity zapalonych świateł (własne albo innego członu) int *iLights; // wskaźnik na bity zapalonych świateł (własne albo innego członu)
double fTrackBlock; //odległość do przeszkody do dalszego ruchu (wykrywanie kolizji z innym pojazdem) double fTrackBlock; // odległość do przeszkody do dalszego ruchu (wykrywanie kolizji z innym
TDynamicObject* __fastcall PrevAny(); // pojazdem)
TDynamicObject* __fastcall Prev(); TDynamicObject *__fastcall PrevAny();
TDynamicObject* __fastcall Next(); TDynamicObject *__fastcall Prev();
TDynamicObject* __fastcall NextC(int C); TDynamicObject *__fastcall Next();
double __fastcall NextDistance(double d=-1.0); TDynamicObject *__fastcall NextC(int C);
void __fastcall SetdMoveLen(double dMoveLen) {MoverParameters->dMoveLen=dMoveLen;} double __fastcall NextDistance(double d = -1.0);
void __fastcall ResetdMoveLen() {MoverParameters->dMoveLen=0;} void __fastcall SetdMoveLen(double dMoveLen) { MoverParameters->dMoveLen = dMoveLen; }
double __fastcall GetdMoveLen() {return MoverParameters->dMoveLen;} void __fastcall ResetdMoveLen() { MoverParameters->dMoveLen = 0; }
double __fastcall GetdMoveLen() { return MoverParameters->dMoveLen; }
int __fastcall GetPneumatic(bool front, bool red); int __fastcall GetPneumatic(bool front, bool red);
void __fastcall SetPneumatic(bool front, bool red); void __fastcall SetPneumatic(bool front, bool red);
AnsiString asName; AnsiString asName;
AnsiString __fastcall GetName() AnsiString __fastcall GetName() { return this ? asName : AnsiString(""); };
{
return this?asName:AnsiString("");
};
TRealSound rsDiesielInc; //youBy TRealSound rsDiesielInc; // youBy
TRealSound rscurve; //youBy TRealSound rscurve; // youBy
// std::ofstream PneuLogFile; //zapis parametrow pneumatycznych // std::ofstream PneuLogFile; //zapis parametrow pneumatycznych
//youBy - dym // youBy - dym
//TSmoke Smog; // TSmoke Smog;
//float EmR; // float EmR;
//vector3 smokeoffset; // vector3 smokeoffset;
TDynamicObject* __fastcall ABuScanNearestObject(TTrack *Track, double ScanDir, double ScanDist, int &CouplNr); TDynamicObject *__fastcall ABuScanNearestObject(TTrack *Track, double ScanDir, double ScanDist,
TDynamicObject* __fastcall GetFirstDynamic(int cpl_type); int &CouplNr);
//TDynamicObject* __fastcall GetFirstCabDynamic(int cpl_type); TDynamicObject *__fastcall GetFirstDynamic(int cpl_type);
// TDynamicObject* __fastcall GetFirstCabDynamic(int cpl_type);
void ABuSetModelShake(vector3 mShake); void ABuSetModelShake(vector3 mShake);
// McZapkie-010302
//McZapkie-010302
TController *Mechanik; TController *Mechanik;
TController *ctOwner; //wskażnik na obiekt zarządzający składem TController *ctOwner; // wskażnik na obiekt zarządzający składem
bool MechInside; bool MechInside;
//McZapkie-270202 // McZapkie-270202
bool Controller; bool Controller;
bool bDisplayCab; //czy wyswietlac kabine w train.cpp bool bDisplayCab; // czy wyswietlac kabine w train.cpp
int iCabs; //maski bitowe modeli kabin int iCabs; // maski bitowe modeli kabin
TTrack *MyTrack; //McZapkie-030303: tor na ktorym stoi, ABu TTrack *MyTrack; // McZapkie-030303: tor na ktorym stoi, ABu
AnsiString asBaseDir; AnsiString asBaseDir;
GLuint ReplacableSkinID[5]; //McZapkie:zmienialne nadwozie GLuint ReplacableSkinID[5]; // McZapkie:zmienialne nadwozie
int iAlpha; //maska przezroczystości tekstur int iAlpha; // maska przezroczystości tekstur
int iMultiTex; //<0 tekstury wskazane wpisem, >0 tekstury z przecinkami, =0 jedna int iMultiTex; //<0 tekstury wskazane wpisem, >0 tekstury z przecinkami, =0 jedna
int iOverheadMask; //maska przydzielana przez AI pojazdom posiadającym pantograf, aby wymuszały jazdę bezprądową int iOverheadMask; // maska przydzielana przez AI pojazdom posiadającym pantograf, aby wymuszały
// jazdę bezprądową
TTractionParam tmpTraction; TTractionParam tmpTraction;
double fAdjustment; //korekcja - docelowo przenieść do TrkFoll.cpp wraz z odległością od poprzedniego double fAdjustment; // korekcja - docelowo przenieść do TrkFoll.cpp wraz z odległością od
// poprzedniego
__fastcall TDynamicObject(); __fastcall TDynamicObject();
__fastcall ~TDynamicObject(); __fastcall ~TDynamicObject();
double __fastcall TDynamicObject::Init double __fastcall TDynamicObject::Init( // zwraca długość pojazdu albo 0, jeśli błąd
(//zwraca długość pojazdu albo 0, jeśli błąd
AnsiString Name, AnsiString BaseDir, AnsiString asReplacableSkin, AnsiString Type_Name, AnsiString Name, AnsiString BaseDir, AnsiString asReplacableSkin, AnsiString Type_Name,
TTrack *Track, double fDist, AnsiString DriverType, double fVel, AnsiString TrainName, TTrack *Track, double fDist, AnsiString DriverType, double fVel, AnsiString TrainName,
float Load, AnsiString LoadType,bool Reversed, AnsiString float Load, AnsiString LoadType, bool Reversed, AnsiString);
); void __fastcall AttachPrev(TDynamicObject *Object, int iType = 1);
void __fastcall AttachPrev(TDynamicObject *Object, int iType= 1);
bool __fastcall UpdateForce(double dt, double dt1, bool FullVer); bool __fastcall UpdateForce(double dt, double dt1, bool FullVer);
void __fastcall LoadUpdate(); void __fastcall LoadUpdate();
bool __fastcall Update(double dt, double dt1); bool __fastcall Update(double dt, double dt1);
@@ -377,64 +388,79 @@ public:
void __fastcall Render(); void __fastcall Render();
void __fastcall RenderAlpha(); void __fastcall RenderAlpha();
void __fastcall RenderSounds(); void __fastcall RenderSounds();
inline vector3 __fastcall GetPosition() {return vPosition;}; inline vector3 __fastcall GetPosition() { return vPosition; };
inline vector3 __fastcall HeadPosition() {return vCoulpler[iDirection^1];}; //pobranie współrzędnych czoła inline vector3 __fastcall HeadPosition()
inline vector3 __fastcall RearPosition() {return vCoulpler[iDirection];}; //pobranie współrzędnych tyłu {
inline vector3 __fastcall AxlePositionGet() {return iAxleFirst?Axle1.pPosition:Axle0.pPosition;}; return vCoulpler[iDirection ^ 1];
inline vector3 __fastcall VectorFront() {return vFront;}; }; // pobranie współrzędnych czoła
inline vector3 __fastcall VectorUp() {return vUp;}; inline vector3 __fastcall RearPosition()
inline vector3 __fastcall VectorLeft() {return vLeft;}; {
inline double* __fastcall Matrix() {return mMatrix.getArray();}; return vCoulpler[iDirection];
}; // pobranie współrzędnych tyłu
inline vector3 __fastcall AxlePositionGet()
{
return iAxleFirst ? Axle1.pPosition : Axle0.pPosition;
};
inline vector3 __fastcall VectorFront() { return vFront; };
inline vector3 __fastcall VectorUp() { return vUp; };
inline vector3 __fastcall VectorLeft() { return vLeft; };
inline double *__fastcall Matrix() { return mMatrix.getArray(); };
inline double __fastcall GetVelocity() { return MoverParameters->Vel; }; inline double __fastcall GetVelocity() { return MoverParameters->Vel; };
inline double __fastcall GetLength() { return MoverParameters->Dim.L; }; inline double __fastcall GetLength() { return MoverParameters->Dim.L; };
inline double __fastcall GetWidth() { return MoverParameters->Dim.W; }; inline double __fastcall GetWidth() { return MoverParameters->Dim.W; };
inline TTrack* __fastcall GetTrack() { return (iAxleFirst?Axle1.GetTrack():Axle0.GetTrack()); }; inline TTrack *__fastcall GetTrack()
//void __fastcall UpdatePos();
//McZapkie-260202
void __fastcall LoadMMediaFile(AnsiString BaseDir, AnsiString TypeName, AnsiString ReplacableSkin);
inline double __fastcall ABuGetDirection() //ABu.
{ {
return (Axle1.GetTrack()==MyTrack?Axle1.GetDirection():Axle0.GetDirection()); return (iAxleFirst ? Axle1.GetTrack() : Axle0.GetTrack());
}; };
// inline double __fastcall ABuGetTranslation() //ABu. // void __fastcall UpdatePos();
// {//zwraca przesunięcie wózka względem Point1 toru
// return (Axle1.GetTrack()==MyTrack?Axle1.GetTranslation():Axle0.GetTranslation()); // McZapkie-260202
// }; void __fastcall LoadMMediaFile(AnsiString BaseDir, AnsiString TypeName,
AnsiString ReplacableSkin);
inline double __fastcall ABuGetDirection() // ABu.
{
return (Axle1.GetTrack() == MyTrack ? Axle1.GetDirection() : Axle0.GetDirection());
};
// inline double __fastcall ABuGetTranslation() //ABu.
// {//zwraca przesunięcie wózka względem Point1 toru
// return (Axle1.GetTrack()==MyTrack?Axle1.GetTranslation():Axle0.GetTranslation());
// };
inline double __fastcall RaDirectionGet() inline double __fastcall RaDirectionGet()
{//zwraca kierunek pojazdu na torze z aktywną osą { // zwraca kierunek pojazdu na torze z aktywną osą
return iAxleFirst?Axle1.GetDirection():Axle0.GetDirection(); return iAxleFirst ? Axle1.GetDirection() : Axle0.GetDirection();
}; };
inline double __fastcall RaTranslationGet() inline double __fastcall RaTranslationGet()
{//zwraca przesunięcie wózka względem Point1 toru z aktywną osią { // zwraca przesunięcie wózka względem Point1 toru z aktywną osią
return iAxleFirst?Axle1.GetTranslation():Axle0.GetTranslation(); return iAxleFirst ? Axle1.GetTranslation() : Axle0.GetTranslation();
}; };
inline TTrack* __fastcall RaTrackGet() inline TTrack *__fastcall RaTrackGet()
{//zwraca tor z aktywną osią { // zwraca tor z aktywną osią
return iAxleFirst?Axle1.GetTrack():Axle0.GetTrack(); return iAxleFirst ? Axle1.GetTrack() : Axle0.GetTrack();
}; };
void CouplersDettach(double MinDist,int MyScanDir); void CouplersDettach(double MinDist, int MyScanDir);
void __fastcall RadioStop(); void __fastcall RadioStop();
void __fastcall RaLightsSet(int head,int rear); void __fastcall RaLightsSet(int head, int rear);
//void __fastcall RaAxleEvent(TEvent *e); // void __fastcall RaAxleEvent(TEvent *e);
TDynamicObject* __fastcall FirstFind(int &coupler_nr); TDynamicObject *__fastcall FirstFind(int &coupler_nr);
float __fastcall GetEPP(); //wyliczanie sredniego cisnienia w PG float __fastcall GetEPP(); // wyliczanie sredniego cisnienia w PG
int __fastcall DirectionSet(int d); //ustawienie kierunku w składzie int __fastcall DirectionSet(int d); // ustawienie kierunku w składzie
int __fastcall DirectionGet() {return iDirection+iDirection-1;}; //odczyt kierunku w składzie int __fastcall DirectionGet()
{
return iDirection + iDirection - 1;
}; // odczyt kierunku w składzie
int DettachStatus(int dir); int DettachStatus(int dir);
int Dettach(int dir); int Dettach(int dir);
TDynamicObject* __fastcall Neightbour(int &dir); TDynamicObject *__fastcall Neightbour(int &dir);
void __fastcall CoupleDist(); void __fastcall CoupleDist();
TDynamicObject* __fastcall ControlledFind(); TDynamicObject *__fastcall ControlledFind();
void __fastcall ParamSet(int what,int into); void __fastcall ParamSet(int what, int into);
int __fastcall RouteWish(TTrack *tr); //zapytanie do AI, po którym segmencie skrzyżowania jechać int __fastcall RouteWish(TTrack *tr); // zapytanie do AI, po którym segmencie skrzyżowania
// jechać
void __fastcall DestinationSet(AnsiString to); void __fastcall DestinationSet(AnsiString to);
AnsiString __fastcall TextureTest(AnsiString &name); AnsiString __fastcall TextureTest(AnsiString &name);
void __fastcall OverheadTrack(float o); void __fastcall OverheadTrack(float o);
}; };
//--------------------------------------------------------------------------- //---------------------------------------------------------------------------
#endif #endif

590
EU07.cpp
View File

@@ -76,18 +76,17 @@ USEUNIT("Console\LPT.cpp");
//--------------------------------------------------------------------------- //---------------------------------------------------------------------------
#include "World.h" #include "World.h"
HDC hDC=NULL; // Private GDI Device Context HDC hDC = NULL; // Private GDI Device Context
HGLRC hRC=NULL; // Permanent Rendering Context HGLRC hRC = NULL; // Permanent Rendering Context
HWND hWnd=NULL; // Holds Our Window Handle HWND hWnd = NULL; // Holds Our Window Handle
TWorld World; TWorld World;
// bool active=TRUE; //window active flag set to TRUE by default
//bool active=TRUE; //window active flag set to TRUE by default bool fullscreen = TRUE; // fullscreen flag set to fullscreen mode by default
bool fullscreen=TRUE; //fullscreen flag set to fullscreen mode by default int WindowWidth = 800;
int WindowWidth= 800; int WindowHeight = 600;
int WindowHeight= 600; int Bpp = 32;
int Bpp= 32;
LRESULT CALLBACK WndProc(HWND, UINT, WPARAM, LPARAM); // Declaration For WndProc LRESULT CALLBACK WndProc(HWND, UINT, WPARAM, LPARAM); // Declaration For WndProc
@@ -97,32 +96,32 @@ LRESULT CALLBACK WndProc(HWND, UINT, WPARAM, LPARAM); // Declaration For WndProc
int InitGL(GLvoid) // All Setup For OpenGL Goes Here int InitGL(GLvoid) // All Setup For OpenGL Goes Here
{ {
_clear87(); _clear87();
_control87(MCW_EM,MCW_EM); _control87(MCW_EM, MCW_EM);
glewInit(); glewInit();
//hunter-271211: przeniesione // hunter-271211: przeniesione
//AllocConsole(); // AllocConsole();
//SetConsoleTextAttribute(GetStdHandle(STD_OUTPUT_HANDLE),FOREGROUND_GREEN); // SetConsoleTextAttribute(GetStdHandle(STD_OUTPUT_HANDLE),FOREGROUND_GREEN);
// ShaXbee-121209: Wlaczenie obslugi tablic wierzcholkow // ShaXbee-121209: Wlaczenie obslugi tablic wierzcholkow
glEnableClientState(GL_VERTEX_ARRAY); glEnableClientState(GL_VERTEX_ARRAY);
glEnableClientState(GL_NORMAL_ARRAY); glEnableClientState(GL_NORMAL_ARRAY);
glEnableClientState(GL_TEXTURE_COORD_ARRAY); glEnableClientState(GL_TEXTURE_COORD_ARRAY);
Global::pWorld=&World; //Ra: wskaŸnik potrzebny do usuwania pojazdów Global::pWorld = &World; // Ra: wskaŸnik potrzebny do usuwania pojazdów
return World.Init(hWnd,hDC); //true jeœli wszystko pójdzie dobrze return World.Init(hWnd, hDC); // true jeœli wszystko pójdzie dobrze
} }
//--------------------------------------------------------------------------- //---------------------------------------------------------------------------
GLvoid ReSizeGLScene(GLsizei width,GLsizei height) // resize and initialize the GL Window GLvoid ReSizeGLScene(GLsizei width, GLsizei height) // resize and initialize the GL Window
{ {
WindowWidth=width; WindowWidth = width;
WindowHeight=height; WindowHeight = height;
if (height==0) // prevent a divide by zero by if (height == 0) // prevent a divide by zero by
height=1; // making height equal one height = 1; // making height equal one
glViewport(0,0,width,height); // Reset The Current Viewport glViewport(0, 0, width, height); // Reset The Current Viewport
glMatrixMode(GL_PROJECTION); // select the Projection Matrix glMatrixMode(GL_PROJECTION); // select the Projection Matrix
glLoadIdentity(); // reset the Projection Matrix glLoadIdentity(); // reset the Projection Matrix
//calculate the aspect ratio of the window // calculate the aspect ratio of the window
gluPerspective(45.0f,(GLdouble)width/(GLdouble)height,0.2f,2500.0f); gluPerspective(45.0f, (GLdouble)width / (GLdouble)height, 0.2f, 2500.0f);
glMatrixMode(GL_MODELVIEW); // select the Modelview Matrix glMatrixMode(GL_MODELVIEW); // select the Modelview Matrix
glLoadIdentity(); // reset the Modelview Matrix glLoadIdentity(); // reset the Modelview Matrix
} }
@@ -132,40 +131,43 @@ GLvoid KillGLWindow(GLvoid) // properly kill the window
{ {
if (hRC) // Do We Have A Rendering Context? if (hRC) // Do We Have A Rendering Context?
{ {
if (!wglMakeCurrent(NULL,NULL)) // are we able to release the DC and RC contexts? if (!wglMakeCurrent(NULL, NULL)) // are we able to release the DC and RC contexts?
{ {
ErrorLog("Fail: window releasing"); ErrorLog("Fail: window releasing");
MessageBox(NULL,"Release of DC and RC failed.","SHUTDOWN ERROR",MB_OK | MB_ICONINFORMATION); MessageBox(NULL, "Release of DC and RC failed.", "SHUTDOWN ERROR",
MB_OK | MB_ICONINFORMATION);
} }
if (!wglDeleteContext(hRC)) // are we able to delete the RC? if (!wglDeleteContext(hRC)) // are we able to delete the RC?
{ {
ErrorLog("Fail: rendering context releasing"); ErrorLog("Fail: rendering context releasing");
MessageBox(NULL,"Release rendering context failed.","SHUTDOWN ERROR",MB_OK | MB_ICONINFORMATION); MessageBox(NULL, "Release rendering context failed.", "SHUTDOWN ERROR",
MB_OK | MB_ICONINFORMATION);
} }
hRC=NULL; // set RC to NULL hRC = NULL; // set RC to NULL
} }
if (hDC && !ReleaseDC(hWnd,hDC)) // are we able to release the DC? if (hDC && !ReleaseDC(hWnd, hDC)) // are we able to release the DC?
{ {
ErrorLog("Fail: device context releasing"); ErrorLog("Fail: device context releasing");
MessageBox(NULL,"Release device context failed.","SHUTDOWN ERROR",MB_OK | MB_ICONINFORMATION); MessageBox(NULL, "Release device context failed.", "SHUTDOWN ERROR",
hDC=NULL; // set DC to NULL MB_OK | MB_ICONINFORMATION);
hDC = NULL; // set DC to NULL
} }
if (hWnd && !DestroyWindow(hWnd)) // are we able to destroy the window? if (hWnd && !DestroyWindow(hWnd)) // are we able to destroy the window?
{ {
ErrorLog("Fail: window destroying"); ErrorLog("Fail: window destroying");
MessageBox(NULL,"Could not release hWnd.","SHUTDOWN ERROR",MB_OK | MB_ICONINFORMATION); MessageBox(NULL, "Could not release hWnd.", "SHUTDOWN ERROR", MB_OK | MB_ICONINFORMATION);
hWnd=NULL; // set hWnd to NULL hWnd = NULL; // set hWnd to NULL
} }
if (fullscreen) // Are We In Fullscreen Mode? if (fullscreen) // Are We In Fullscreen Mode?
{ {
ChangeDisplaySettings(NULL,0); // if so switch back to the desktop ChangeDisplaySettings(NULL, 0); // if so switch back to the desktop
ShowCursor(TRUE); // show mouse pointer ShowCursor(TRUE); // show mouse pointer
} }
// KillFont(); // KillFont();
} }
/* This code creates our OpenGL Window. Parameters are: * /* This code creates our OpenGL Window. Parameters are: *
@@ -175,7 +177,7 @@ GLvoid KillGLWindow(GLvoid) // properly kill the window
* bits - number of bits to use for color (8/16/24/32) * * bits - number of bits to use for color (8/16/24/32) *
* fullscreenflag - use fullscreen mode (TRUE) or windowed mode (FALSE) */ * fullscreenflag - use fullscreen mode (TRUE) or windowed mode (FALSE) */
BOOL CreateGLWindow(char* title, int width, int height, int bits, bool fullscreenflag) BOOL CreateGLWindow(char *title, int width, int height, int bits, bool fullscreenflag)
{ {
GLuint PixelFormat; // holds the results after searching for a match GLuint PixelFormat; // holds the results after searching for a match
HINSTANCE hInstance; // holds the instance of the application HINSTANCE hInstance; // holds the instance of the application
@@ -183,76 +185,84 @@ BOOL CreateGLWindow(char* title, int width, int height, int bits, bool fullscree
DWORD dwExStyle; // window extended style DWORD dwExStyle; // window extended style
DWORD dwStyle; // window style DWORD dwStyle; // window style
RECT WindowRect; // grabs rectangle upper left / lower right values RECT WindowRect; // grabs rectangle upper left / lower right values
WindowRect.left=(long)0; // set left value to 0 WindowRect.left = (long)0; // set left value to 0
WindowRect.right=(long)width; // set right value to requested width WindowRect.right = (long)width; // set right value to requested width
WindowRect.top=(long)0; // set top value to 0 WindowRect.top = (long)0; // set top value to 0
WindowRect.bottom=(long)height; // set bottom value to requested height WindowRect.bottom = (long)height; // set bottom value to requested height
fullscreen=fullscreenflag; // set the global fullscreen flag fullscreen = fullscreenflag; // set the global fullscreen flag
hInstance =GetModuleHandle(NULL); // grab an instance for our window hInstance = GetModuleHandle(NULL); // grab an instance for our window
wc.style =CS_HREDRAW | CS_VREDRAW | CS_OWNDC; // redraw on size, and own DC for window. wc.style = CS_HREDRAW | CS_VREDRAW | CS_OWNDC; // redraw on size, and own DC for window.
wc.lpfnWndProc =(WNDPROC) WndProc; // wndproc handles messages wc.lpfnWndProc = (WNDPROC)WndProc; // wndproc handles messages
wc.cbClsExtra =0; // no extra window data wc.cbClsExtra = 0; // no extra window data
wc.cbWndExtra =0; // no extra window data wc.cbWndExtra = 0; // no extra window data
wc.hInstance =hInstance; // set the instance wc.hInstance = hInstance; // set the instance
wc.hIcon =LoadIcon(NULL, IDI_WINLOGO); // load the default icon wc.hIcon = LoadIcon(NULL, IDI_WINLOGO); // load the default icon
wc.hCursor =LoadCursor(NULL, IDC_ARROW); // load the arrow pointer wc.hCursor = LoadCursor(NULL, IDC_ARROW); // load the arrow pointer
wc.hbrBackground=NULL; // no background required for GL wc.hbrBackground = NULL; // no background required for GL
wc.lpszMenuName =NULL; // we don't want a menu wc.lpszMenuName = NULL; // we don't want a menu
wc.lpszClassName="EU07"; //nazwa okna do komunikacji zdalnej // Set The Class Name wc.lpszClassName = "EU07"; // nazwa okna do komunikacji zdalnej
// // Set The Class Name
if (!arbMultisampleSupported) //tylko dla pierwszego okna if (!arbMultisampleSupported) // tylko dla pierwszego okna
if (!RegisterClass(&wc)) // Attempt To Register The Window Class if (!RegisterClass(&wc)) // Attempt To Register The Window Class
{ {
ErrorLog("Fail: window class registeration"); ErrorLog("Fail: window class registeration");
MessageBox(NULL,"Failed to register the window class.","ERROR",MB_OK|MB_ICONEXCLAMATION); MessageBox(NULL, "Failed to register the window class.", "ERROR",
MB_OK | MB_ICONEXCLAMATION);
return FALSE; // Return FALSE return FALSE; // Return FALSE
} }
if (fullscreen) // Attempt Fullscreen Mode? if (fullscreen) // Attempt Fullscreen Mode?
{ {
DEVMODE dmScreenSettings; // device mode DEVMODE dmScreenSettings; // device mode
memset(&dmScreenSettings,0,sizeof(dmScreenSettings)); // makes sure memory's cleared memset(&dmScreenSettings, 0, sizeof(dmScreenSettings)); // makes sure memory's cleared
dmScreenSettings.dmSize=sizeof(dmScreenSettings); // size of the devmode structure dmScreenSettings.dmSize = sizeof(dmScreenSettings); // size of the devmode structure
//tolaris-240403: poprawka na odswiezanie monitora // tolaris-240403: poprawka na odswiezanie monitora
// locate primary monitor... // locate primary monitor...
if (Global::bAdjustScreenFreq) if (Global::bAdjustScreenFreq)
{ {
POINT point; point.x=0; point.y=0; POINT point;
MONITORINFOEX monitorinfo; monitorinfo.cbSize=sizeof(MONITORINFOEX); point.x = 0;
::GetMonitorInfo( ::MonitorFromPoint(point,MONITOR_DEFAULTTOPRIMARY),&monitorinfo); point.y = 0;
MONITORINFOEX monitorinfo;
monitorinfo.cbSize = sizeof(MONITORINFOEX);
::GetMonitorInfo(::MonitorFromPoint(point, MONITOR_DEFAULTTOPRIMARY), &monitorinfo);
// ..and query for highest supported refresh rate // ..and query for highest supported refresh rate
unsigned int refreshrate=0; unsigned int refreshrate = 0;
int i=0; int i = 0;
while (::EnumDisplaySettings(monitorinfo.szDevice,i,&dmScreenSettings)) while (::EnumDisplaySettings(monitorinfo.szDevice, i, &dmScreenSettings))
{ {
if (i>0) if (i > 0)
if (dmScreenSettings.dmPelsWidth==(unsigned int)width) if (dmScreenSettings.dmPelsWidth == (unsigned int)width)
if (dmScreenSettings.dmPelsHeight==(unsigned int)height) if (dmScreenSettings.dmPelsHeight == (unsigned int)height)
if (dmScreenSettings.dmBitsPerPel==(unsigned int)bits) if (dmScreenSettings.dmBitsPerPel == (unsigned int)bits)
if (dmScreenSettings.dmDisplayFrequency>refreshrate) if (dmScreenSettings.dmDisplayFrequency > refreshrate)
refreshrate=dmScreenSettings.dmDisplayFrequency; refreshrate = dmScreenSettings.dmDisplayFrequency;
++i; ++i;
} }
// fill refresh rate info for screen mode change // fill refresh rate info for screen mode change
dmScreenSettings.dmDisplayFrequency=refreshrate; dmScreenSettings.dmDisplayFrequency = refreshrate;
dmScreenSettings.dmFields=DM_DISPLAYFREQUENCY; dmScreenSettings.dmFields = DM_DISPLAYFREQUENCY;
} }
dmScreenSettings.dmPelsWidth =width; // selected screen width dmScreenSettings.dmPelsWidth = width; // selected screen width
dmScreenSettings.dmPelsHeight=height; // selected screen height dmScreenSettings.dmPelsHeight = height; // selected screen height
dmScreenSettings.dmBitsPerPel=bits; // selected bits per pixel dmScreenSettings.dmBitsPerPel = bits; // selected bits per pixel
dmScreenSettings.dmFields=dmScreenSettings.dmFields|DM_BITSPERPEL|DM_PELSWIDTH|DM_PELSHEIGHT; dmScreenSettings.dmFields =
dmScreenSettings.dmFields | DM_BITSPERPEL | DM_PELSWIDTH | DM_PELSHEIGHT;
// Try to set selected mode and get results. NOTE: CDS_FULLSCREEN gets rid of start bar. // Try to set selected mode and get results. NOTE: CDS_FULLSCREEN gets rid of start bar.
if (ChangeDisplaySettings(&dmScreenSettings,CDS_FULLSCREEN)!=DISP_CHANGE_SUCCESSFUL) if (ChangeDisplaySettings(&dmScreenSettings, CDS_FULLSCREEN) != DISP_CHANGE_SUCCESSFUL)
{ {
// If the mode fails, offer two options. Quit or use windowed mode. // If the mode fails, offer two options. Quit or use windowed mode.
ErrorLog("Fail: full screen"); ErrorLog("Fail: full screen");
if (MessageBox(NULL,"The requested fullscreen mode is not supported by\nyour video card. Use windowed mode instead?","EU07",MB_YESNO|MB_ICONEXCLAMATION)==IDYES) if (MessageBox(NULL, "The requested fullscreen mode is not supported by\nyour video "
"card. Use windowed mode instead?",
"EU07", MB_YESNO | MB_ICONEXCLAMATION) == IDYES)
{ {
fullscreen=FALSE; // Windowed Mode Selected. Fullscreen = FALSE fullscreen = FALSE; // Windowed Mode Selected. Fullscreen = FALSE
} }
else else
{ {
@@ -265,28 +275,31 @@ BOOL CreateGLWindow(char* title, int width, int height, int bits, bool fullscree
if (fullscreen) // Are We Still In Fullscreen Mode? if (fullscreen) // Are We Still In Fullscreen Mode?
{ {
dwExStyle=WS_EX_APPWINDOW; // Window Extended Style dwExStyle = WS_EX_APPWINDOW; // Window Extended Style
dwStyle=WS_POPUP | WS_CLIPSIBLINGS | WS_CLIPCHILDREN; // Windows Style dwStyle = WS_POPUP | WS_CLIPSIBLINGS | WS_CLIPCHILDREN; // Windows Style
ShowCursor(FALSE); // Hide Mouse Pointer ShowCursor(FALSE); // Hide Mouse Pointer
} }
else else
{ {
dwExStyle=WS_EX_APPWINDOW | WS_EX_WINDOWEDGE; // Window Extended Style dwExStyle = WS_EX_APPWINDOW | WS_EX_WINDOWEDGE; // Window Extended Style
dwStyle=WS_OVERLAPPEDWINDOW | WS_CLIPSIBLINGS | WS_CLIPCHILDREN; // Windows Style dwStyle = WS_OVERLAPPEDWINDOW | WS_CLIPSIBLINGS | WS_CLIPCHILDREN; // Windows Style
} }
AdjustWindowRectEx(&WindowRect,dwStyle,FALSE,dwExStyle); // Adjust Window To True Requested Size AdjustWindowRectEx(&WindowRect, dwStyle, FALSE,
dwExStyle); // Adjust Window To True Requested Size
// Create The Window // Create The Window
if (NULL==(hWnd=CreateWindowEx(dwExStyle, // Extended Style For The Window if (NULL ==
(hWnd = CreateWindowEx(dwExStyle, // Extended Style For The Window
"EU07", // Class Name "EU07", // Class Name
title, // Window Title title, // Window Title
dwStyle | // Defined Window Style dwStyle | // Defined Window Style
WS_CLIPSIBLINGS | // Required Window Style WS_CLIPSIBLINGS | // Required Window Style
WS_CLIPCHILDREN, // Required Window Style WS_CLIPCHILDREN, // Required Window Style
0, 0, // Window Position 0,
WindowRect.right-WindowRect.left, // Calculate Window Width 0, // Window Position
WindowRect.bottom-WindowRect.top, // Calculate Window Height WindowRect.right - WindowRect.left, // Calculate Window Width
WindowRect.bottom - WindowRect.top, // Calculate Window Height
NULL, // No Parent Window NULL, // No Parent Window
NULL, // No Menu NULL, // No Menu
hInstance, // Instance hInstance, // Instance
@@ -294,11 +307,11 @@ BOOL CreateGLWindow(char* title, int width, int height, int bits, bool fullscree
{ {
KillGLWindow(); // Reset The Display KillGLWindow(); // Reset The Display
ErrorLog("Fail: window creation"); ErrorLog("Fail: window creation");
MessageBox(NULL,"Window creation error.","ERROR",MB_OK|MB_ICONEXCLAMATION); MessageBox(NULL, "Window creation error.", "ERROR", MB_OK | MB_ICONEXCLAMATION);
return FALSE; // Return FALSE return FALSE; // Return FALSE
} }
static PIXELFORMATDESCRIPTOR pfd= // pfd Tells Windows How We Want Things To Be static PIXELFORMATDESCRIPTOR pfd = // pfd Tells Windows How We Want Things To Be
{ {
sizeof(PIXELFORMATDESCRIPTOR), // Size Of This Pixel Format Descriptor sizeof(PIXELFORMATDESCRIPTOR), // Size Of This Pixel Format Descriptor
1, // Version Number 1, // Version Number
@@ -307,7 +320,8 @@ BOOL CreateGLWindow(char* title, int width, int height, int bits, bool fullscree
PFD_DOUBLEBUFFER, // Must Support Double Buffering PFD_DOUBLEBUFFER, // Must Support Double Buffering
PFD_TYPE_RGBA, // Request An RGBA Format PFD_TYPE_RGBA, // Request An RGBA Format
bits, // Select Our Color Depth bits, // Select Our Color Depth
0, 0, 0, 0, 0, 0, // Color Bits Ignored 0,
0, 0, 0, 0, 0, // Color Bits Ignored
0, // No Alpha Buffer 0, // No Alpha Buffer
0, // Shift Bit Ignored 0, // Shift Bit Ignored
0, // No Accumulation Buffer 0, // No Accumulation Buffer
@@ -320,54 +334,58 @@ BOOL CreateGLWindow(char* title, int width, int height, int bits, bool fullscree
0, 0, 0 // Layer Masks Ignored 0, 0, 0 // Layer Masks Ignored
}; };
if (NULL==(hDC=GetDC(hWnd))) // Did We Get A Device Context? if (NULL == (hDC = GetDC(hWnd))) // Did We Get A Device Context?
{ {
KillGLWindow(); // Reset The Display KillGLWindow(); // Reset The Display
ErrorLog("Fail: device context"); ErrorLog("Fail: device context");
MessageBox(NULL,"Can't create a GL device context.","ERROR",MB_OK|MB_ICONEXCLAMATION); MessageBox(NULL, "Can't create a GL device context.", "ERROR", MB_OK | MB_ICONEXCLAMATION);
return FALSE; // Return FALSE return FALSE; // Return FALSE
} }
/* /*
Our first pass, Multisampling hasn't been created yet, so we create a window normally Our first pass, Multisampling hasn't been created yet, so we create a window normally
If it is supported, then we're on our second pass If it is supported, then we're on our second pass
that means we want to use our pixel format for sampling that means we want to use our pixel format for sampling
so set PixelFormat to arbMultiSampleformat instead so set PixelFormat to arbMultiSampleformat instead
*/ */
if (!arbMultisampleSupported) if (!arbMultisampleSupported)
{ {
if (NULL==(PixelFormat=ChoosePixelFormat(hDC,&pfd))) // Did Windows Find A Matching Pixel Format? if (NULL == (PixelFormat =
ChoosePixelFormat(hDC, &pfd))) // Did Windows Find A Matching Pixel Format?
{ {
KillGLWindow(); // Reset The Display KillGLWindow(); // Reset The Display
ErrorLog("Fail: pixelformat"); ErrorLog("Fail: pixelformat");
MessageBox(NULL,"Can't find a suitable pixelformat.","ERROR",MB_OK|MB_ICONEXCLAMATION); MessageBox(NULL, "Can't find a suitable pixelformat.", "ERROR",
MB_OK | MB_ICONEXCLAMATION);
return FALSE; // Return FALSE return FALSE; // Return FALSE
} }
} }
else else
PixelFormat=arbMultisampleFormat; PixelFormat = arbMultisampleFormat;
if (!SetPixelFormat(hDC,PixelFormat,&pfd)) // Are We Able To Set The Pixel Format? if (!SetPixelFormat(hDC, PixelFormat, &pfd)) // Are We Able To Set The Pixel Format?
{ {
KillGLWindow(); // Reset The Display KillGLWindow(); // Reset The Display
ErrorLog("Fail: pixelformat"); ErrorLog("Fail: pixelformat");
MessageBox(NULL,"Can't set the pixelformat.","ERROR",MB_OK|MB_ICONEXCLAMATION); MessageBox(NULL, "Can't set the pixelformat.", "ERROR", MB_OK | MB_ICONEXCLAMATION);
return FALSE; // Return FALSE return FALSE; // Return FALSE
} }
if (NULL==(hRC=wglCreateContext(hDC))) // Are We Able To Get A Rendering Context? if (NULL == (hRC = wglCreateContext(hDC))) // Are We Able To Get A Rendering Context?
{ {
KillGLWindow(); // Reset The Display KillGLWindow(); // Reset The Display
ErrorLog("Fail: OpenGL rendering context creation"); ErrorLog("Fail: OpenGL rendering context creation");
MessageBox(NULL,"Can't create a GL rendering context.","ERROR",MB_OK|MB_ICONEXCLAMATION); MessageBox(NULL, "Can't create a GL rendering context.", "ERROR",
MB_OK | MB_ICONEXCLAMATION);
return FALSE; // Return FALSE return FALSE; // Return FALSE
} }
if (!wglMakeCurrent(hDC,hRC)) // Try To Activate The Rendering Context if (!wglMakeCurrent(hDC, hRC)) // Try To Activate The Rendering Context
{ {
KillGLWindow(); // Reset The Display KillGLWindow(); // Reset The Display
ErrorLog("Fail: OpenGL rendering context activation"); ErrorLog("Fail: OpenGL rendering context activation");
MessageBox(NULL,"Can't activate the GL rendering context.","ERROR",MB_OK|MB_ICONEXCLAMATION); MessageBox(NULL, "Can't activate the GL rendering context.", "ERROR",
MB_OK | MB_ICONEXCLAMATION);
return FALSE; // Return FALSE return FALSE; // Return FALSE
} }
@@ -379,14 +397,16 @@ BOOL CreateGLWindow(char* title, int width, int height, int bits, bool fullscree
*/ */
if (Global::iMultisampling) if (Global::iMultisampling)
if (!arbMultisampleSupported) if (!arbMultisampleSupported)
if ((Global::iMultisampling=InitMultisample(hInstance,hWnd,pfd,1<<Global::iMultisampling))!=0) if ((Global::iMultisampling =
InitMultisample(hInstance, hWnd, pfd, 1 << Global::iMultisampling)) != 0)
{ {
//WriteConsoleOnly("Opening second window for multisampling of "+AnsiString(Global::iMultisampling)+" samples."); // WriteConsoleOnly("Opening second window for multisampling of
// "+AnsiString(Global::iMultisampling)+" samples.");
KillGLWindow(); // reset the display KillGLWindow(); // reset the display
return CreateGLWindow(title,width,height,bits,fullscreenflag); //rekurencja return CreateGLWindow(title, width, height, bits, fullscreenflag); // rekurencja
} }
ShowWindow(hWnd,SW_SHOW); // show the window ShowWindow(hWnd, SW_SHOW); // show the window
SetForegroundWindow(hWnd); // slightly higher priority SetForegroundWindow(hWnd); // slightly higher priority
SetFocus(hWnd); // sets keyboard focus to the window SetFocus(hWnd); // sets keyboard focus to the window
ReSizeGLScene(width, height); // set up our perspective GL screen ReSizeGLScene(width, height); // set up our perspective GL screen
@@ -395,127 +415,130 @@ BOOL CreateGLWindow(char* title, int width, int height, int bits, bool fullscree
{ {
KillGLWindow(); // reset the display KillGLWindow(); // reset the display
ErrorLog("Fail: OpenGL initialization"); ErrorLog("Fail: OpenGL initialization");
MessageBox(NULL,"Initialization Failed.","ERROR",MB_OK|MB_ICONEXCLAMATION); MessageBox(NULL, "Initialization Failed.", "ERROR", MB_OK | MB_ICONEXCLAMATION);
return FALSE; // return FALSE return FALSE; // return FALSE
} }
return TRUE; //success return TRUE; // success
} }
static int mx=0, my=0; static int mx = 0, my = 0;
static POINT mouse; static POINT mouse;
static int test= 0; static int test = 0;
/**/ /**/
// ************ Globals ************ // ************ Globals ************
// //
#define MYDISPLAY 1 #define MYDISPLAY 1
PCOPYDATASTRUCT pDane; PCOPYDATASTRUCT pDane;
LRESULT CALLBACK WndProc(HWND hWnd, //handle for this window LRESULT CALLBACK WndProc(HWND hWnd, // handle for this window
UINT uMsg, //message for this window UINT uMsg, // message for this window
WPARAM wParam, //additional message information WPARAM wParam, // additional message information
LPARAM lParam) //additional message information LPARAM lParam) // additional message information
{ {
TRect rect; TRect rect;
switch (uMsg) //check for windows messages switch (uMsg) // check for windows messages
{ {
case WM_PASTE: //[Ctrl]+[V] potrzebujemy do innych celów case WM_PASTE: //[Ctrl]+[V] potrzebujemy do innych celów
return 0; return 0;
case WM_COPYDATA: //obs³uga danych przes³anych przez program steruj¹cy case WM_COPYDATA: // obs³uga danych przes³anych przez program steruj¹cy
pDane=(PCOPYDATASTRUCT)lParam; pDane = (PCOPYDATASTRUCT)lParam;
if (pDane->dwData=='EU07') //sygnatura danych if (pDane->dwData == 'EU07') // sygnatura danych
World.OnCommandGet((DaneRozkaz*)(pDane->lpData)); World.OnCommandGet((DaneRozkaz *)(pDane->lpData));
break; break;
case WM_ACTIVATE: //watch for window activate message case WM_ACTIVATE: // watch for window activate message
//case WM_ACTIVATEAPP: // case WM_ACTIVATEAPP:
{//Ra: uzale¿nienie aktywnoœci od bycia na wierzchu { // Ra: uzale¿nienie aktywnoœci od bycia na wierzchu
Global::bActive=(LOWORD(wParam)!=WA_INACTIVE); Global::bActive = (LOWORD(wParam) != WA_INACTIVE);
if (Global::bInactivePause) //jeœli ma byæ pauzowanie okna w tle if (Global::bInactivePause) // jeœli ma byæ pauzowanie okna w tle
if (Global::bActive) if (Global::bActive)
Global::iPause&=~4; //odpauzowanie, gdy jest na pierwszym planie Global::iPause &= ~4; // odpauzowanie, gdy jest na pierwszym planie
else else
Global::iPause|=4; //w³¹czenie pauzy, gdy nieaktywy Global::iPause |= 4; // w³¹czenie pauzy, gdy nieaktywy
if (Global::bActive) if (Global::bActive)
SetCursorPos(mx,my); SetCursorPos(mx, my);
ShowCursor(!Global::bActive); ShowCursor(!Global::bActive);
/* /*
if (!HIWORD(wParam)) //check minimization state if (!HIWORD(wParam)) //check minimization state
active=TRUE; //program is active active=TRUE; //program is active
else else
active=FALSE; //program is no longer active active=FALSE; //program is no longer active
*/ */
return 0; // return to the message loop return 0; // return to the message loop
} }
case WM_SYSCOMMAND: //intercept system commands case WM_SYSCOMMAND: // intercept system commands
{ {
switch (wParam) //check system calls switch (wParam) // check system calls
{ {
case 61696: //F10 case 61696: // F10
World.OnKeyDown(VK_F10); World.OnKeyDown(VK_F10);
return 0; return 0;
case SC_SCREENSAVE: //screensaver trying to start? case SC_SCREENSAVE: // screensaver trying to start?
case SC_MONITORPOWER: //monitor trying to enter powersave? case SC_MONITORPOWER: // monitor trying to enter powersave?
return 0; //prevent from happening return 0; // prevent from happening
} }
break; //exit break; // exit
} }
case WM_CLOSE: // did we receive a close message? case WM_CLOSE: // did we receive a close message?
{ {
PostQuitMessage(0); //send a quit message [Alt]+[F4] PostQuitMessage(0); // send a quit message [Alt]+[F4]
return 0; //jump back return 0; // jump back
} }
case WM_MOUSEMOVE: case WM_MOUSEMOVE:
{ {
//mx= 100;//Global::iWindowWidth/2; // mx= 100;//Global::iWindowWidth/2;
//my= 100;//Global::iWindowHeight/2; // my= 100;//Global::iWindowHeight/2;
//SetCursorPos(Global::iWindowWidth/2,Global::iWindowHeight/2); // SetCursorPos(Global::iWindowWidth/2,Global::iWindowHeight/2);
//m_x= LOWORD(lParam); // m_x= LOWORD(lParam);
//m_y= HIWORD(lParam); // m_y= HIWORD(lParam);
GetCursorPos(&mouse); GetCursorPos(&mouse);
if (Global::bActive && ((mouse.x!=mx) || (mouse.y!=my))) if (Global::bActive && ((mouse.x != mx) || (mouse.y != my)))
{ {
World.OnMouseMove(double(mouse.x-mx)*0.005,double(mouse.y-my)*0.01); World.OnMouseMove(double(mouse.x - mx) * 0.005, double(mouse.y - my) * 0.01);
SetCursorPos(mx,my); SetCursorPos(mx, my);
} }
return 0; // jump back return 0; // jump back
} }
case WM_KEYUP : case WM_KEYUP:
if (Global::bActive) if (Global::bActive)
{ {
World.OnKeyUp(wParam); World.OnKeyUp(wParam);
return 0; return 0;
} }
case WM_KEYDOWN : case WM_KEYDOWN:
if (Global::bActive) if (Global::bActive)
{ {
if (wParam!=17) //bo naciœniêcia [Ctrl] nie ma po co przekazywaæ if (wParam != 17) // bo naciœniêcia [Ctrl] nie ma po co przekazywaæ
if (wParam!=145) //[Scroll Lock] te¿ nie if (wParam != 145) //[Scroll Lock] te¿ nie
World.OnKeyDown(wParam); World.OnKeyDown(wParam);
switch (wParam) switch (wParam)
{ {
case VK_ESCAPE: //[Esc] pauzuje tylko bez Debugmode case VK_ESCAPE: //[Esc] pauzuje tylko bez Debugmode
if (DebugModeFlag) break; if (DebugModeFlag)
break;
case 19: //[Pause] case 19: //[Pause]
if (Global::iPause&1) //jeœli pauza startowa if (Global::iPause & 1) // jeœli pauza startowa
Global::iPause&=~1; //odpauzowanie, gdy po wczytaniu mia³o nie startowaæ Global::iPause &= ~1; // odpauzowanie, gdy po wczytaniu mia³o nie startowaæ
else if (!(Global::iMultiplayer&2)) //w multiplayerze pauza nie ma sensu else if (!(Global::iMultiplayer & 2)) // w multiplayerze pauza nie ma sensu
if (!Console::Pressed(VK_CONTROL)) //z [Ctrl] to radiostop jest if (!Console::Pressed(VK_CONTROL)) // z [Ctrl] to radiostop jest
//Ra: poni¿sze nie ma sensu, bo brak komunikacji natychmiast zapauzuje ponownie // Ra: poni¿sze nie ma sensu, bo brak komunikacji natychmiast zapauzuje
//if (Global::iPause&8) //jeœli pauza zwi¹zana z brakiem komunikacji z PoKeys // ponownie
// Global::iPause&=~10; //odpauzowanie pauzy PoKeys (chyba nic nie da) i ewentualnie klawiszowej równie¿ // if (Global::iPause&8) //jeœli pauza zwi¹zana z brakiem komunikacji z
//else // PoKeys
Global::iPause^=2; //zmiana stanu zapauzowania // Global::iPause&=~10; //odpauzowanie pauzy PoKeys (chyba nic nie da) i
if (Global::iPause) //jak pauza // ewentualnie klawiszowej równie¿
Global::iTextMode=VK_F1; //to wyœwietliæ zegar i informacjê // else
Global::iPause ^= 2; // zmiana stanu zapauzowania
if (Global::iPause) // jak pauza
Global::iTextMode = VK_F1; // to wyœwietliæ zegar i informacjê
break; break;
case VK_F7: case VK_F7:
if (DebugModeFlag) if (DebugModeFlag)
{//siatki wyœwietlane tyko w trybie testowym { // siatki wyœwietlane tyko w trybie testowym
Global::bWireFrame=!Global::bWireFrame; Global::bWireFrame = !Global::bWireFrame;
++Global::iReCompile; //odœwie¿yæ siatki ++Global::iReCompile; // odœwie¿yæ siatki
//Ra: jeszcze usun¹æ siatki ze skompilowanych obiektów! // Ra: jeszcze usun¹æ siatki ze skompilowanych obiektów!
} }
break; break;
} }
@@ -523,7 +546,7 @@ LRESULT CALLBACK WndProc(HWND hWnd, //handle for this window
return 0; // jump back return 0; // jump back
case WM_CHAR: case WM_CHAR:
{ {
/* /*
switch ((TCHAR) wParam) switch ((TCHAR) wParam)
{ {
// case 'q': // case 'q':
@@ -533,193 +556,194 @@ LRESULT CALLBACK WndProc(HWND hWnd, //handle for this window
// DestroyWindow( hWnd ); // DestroyWindow( hWnd );
// break; // break;
}; };
*/ */
return 0; return 0;
} }
case WM_SIZE: //resize the OpenGL window case WM_SIZE: // resize the OpenGL window
{ {
ReSizeGLScene(LOWORD(lParam),HIWORD(lParam)); // LoWord=Width, HiWord=Height ReSizeGLScene(LOWORD(lParam), HIWORD(lParam)); // LoWord=Width, HiWord=Height
if (GetWindowRect(hWnd,&rect)) if (GetWindowRect(hWnd, &rect))
{//Ra: zmiana rozmiaru okna bez przesuwania myszy { // Ra: zmiana rozmiaru okna bez przesuwania myszy
//mx=WindowWidth/2+rect.left; // horizontal position // mx=WindowWidth/2+rect.left; // horizontal position
//my=WindowHeight/2+rect.top; // vertical position // my=WindowHeight/2+rect.top; // vertical position
//SetCursorPos(mx,my); // SetCursorPos(mx,my);
} }
return 0; //jump back return 0; // jump back
} }
case WM_MOVE: //przesuwanie okna? case WM_MOVE: // przesuwanie okna?
{ {
mx=WindowWidth/2+LOWORD(lParam); // horizontal position mx = WindowWidth / 2 + LOWORD(lParam); // horizontal position
my=WindowHeight/2+HIWORD(lParam); // vertical position my = WindowHeight / 2 + HIWORD(lParam); // vertical position
//SetCursorPos(mx,my); // SetCursorPos(mx,my);
break; break;
} }
case WM_PAINT: case WM_PAINT:
{//odrysowanie okna { // odrysowanie okna
break; break;
} }
//case WM_ERASEBKGND: //Process this message to keep Windows from erasing background. // case WM_ERASEBKGND: //Process this message to keep Windows from erasing background.
case MM_JOY1BUTTONDOWN: case MM_JOY1BUTTONDOWN:
{ {
//WriteLog("Joystick button "+AnsiString(wParam)); // WriteLog("Joystick button "+AnsiString(wParam));
break; break;
} }
case WM_CREATE: case WM_CREATE:
/* Capture the joystick. If this fails, beep and display /* Capture the joystick. If this fails, beep and display
* error, then quit. * error, then quit.
*/ */
if (joySetCapture(hWnd,JOYSTICKID1,0,FALSE)) if (joySetCapture(hWnd, JOYSTICKID1, 0, FALSE))
{ {
//MessageBeep(MB_ICONEXCLAMATION); // MessageBeep(MB_ICONEXCLAMATION);
//MessageBox(hWnd,"Couldn't capture the joystick",NULL,MB_OK|MB_ICONEXCLAMATION); // MessageBox(hWnd,"Couldn't capture the joystick",NULL,MB_OK|MB_ICONEXCLAMATION);
//return -1; // return -1;
} }
break; break;
} }
// pass all unhandled messages to DefWindowProc // pass all unhandled messages to DefWindowProc
return DefWindowProc(hWnd,uMsg,wParam,lParam); return DefWindowProc(hWnd, uMsg, wParam, lParam);
}; };
int WINAPI WinMain(HINSTANCE hInstance, // instance
HINSTANCE hPrevInstance, // previous instance
LPSTR lpCmdLine, // command line parameters
int WINAPI WinMain( HINSTANCE hInstance, //instance int nCmdShow) // window show state
HINSTANCE hPrevInstance, //previous instance
LPSTR lpCmdLine, //command line parameters
int nCmdShow) //window show state
{ {
MSG msg; //windows message structure MSG msg; // windows message structure
BOOL done=FALSE; //bool variable to exit loop BOOL done = FALSE; // bool variable to exit loop
fullscreen=true; fullscreen = true;
DecimalSeparator= '.'; DecimalSeparator = '.';
/* //Ra: tutaj to nie dzia³a - zwraca NULL /* //Ra: tutaj to nie dzia³a - zwraca NULL
//najpierw ustalmy wersjê OpenGL //najpierw ustalmy wersjê OpenGL
AnsiString glver=((char*)glGetString(GL_VERSION)); AnsiString glver=((char*)glGetString(GL_VERSION));
while (glver.LastDelimiter(".")>glver.Pos(".")) while (glver.LastDelimiter(".")>glver.Pos("."))
glver=glver.SubString(1,glver.LastDelimiter(".")-1); //obciêcie od drugiej kropki glver=glver.SubString(1,glver.LastDelimiter(".")-1); //obciêcie od drugiej kropki
try {Global::fOpenGL=glver.ToDouble();} catch (...) {Global::fOpenGL=0.0;} try {Global::fOpenGL=glver.ToDouble();} catch (...) {Global::fOpenGL=0.0;}
Global::bOpenGL_1_5=(Global::fOpenGL>=1.5); Global::bOpenGL_1_5=(Global::fOpenGL>=1.5);
*/ */
DeleteFile("errors.txt"); //usuniêcie starego DeleteFile("errors.txt"); // usuniêcie starego
Global::LoadIniFile("eu07.ini"); //teraz dopiero mo¿na przejrzeæ plik z ustawieniami Global::LoadIniFile("eu07.ini"); // teraz dopiero mo¿na przejrzeæ plik z ustawieniami
Global::InitKeys("keys.ini"); //wczytanie mapowania klawiszy - jest na sta³e Global::InitKeys("keys.ini"); // wczytanie mapowania klawiszy - jest na sta³e
//hunter-271211: ukrywanie konsoli // hunter-271211: ukrywanie konsoli
if (Global::iWriteLogEnabled&2) if (Global::iWriteLogEnabled & 2)
{ {
AllocConsole(); AllocConsole();
SetConsoleTextAttribute(GetStdHandle(STD_OUTPUT_HANDLE),FOREGROUND_GREEN); SetConsoleTextAttribute(GetStdHandle(STD_OUTPUT_HANDLE), FOREGROUND_GREEN);
} }
AnsiString str=lpCmdLine; //parametry uruchomienia AnsiString str = lpCmdLine; // parametry uruchomienia
if (!str.IsEmpty()) if (!str.IsEmpty())
{//analizowanie parametrów { // analizowanie parametrów
TQueryParserComp *Parser; TQueryParserComp *Parser;
Parser=new TQueryParserComp(NULL); Parser = new TQueryParserComp(NULL);
Parser->TextToParse=lpCmdLine; Parser->TextToParse = lpCmdLine;
Parser->First(); Parser->First();
while (!Parser->EndOfFile) while (!Parser->EndOfFile)
{ {
str=Parser->GetNextSymbol().LowerCase(); str = Parser->GetNextSymbol().LowerCase();
if (str==AnsiString("-s")) if (str == AnsiString("-s"))
{//nazwa scenerii { // nazwa scenerii
str=Parser->GetNextSymbol().LowerCase(); str = Parser->GetNextSymbol().LowerCase();
strcpy(Global::szSceneryFile,str.c_str()); strcpy(Global::szSceneryFile, str.c_str());
} }
else if (str==AnsiString("-v")) else if (str == AnsiString("-v"))
{//nazwa wybranego pojazdu { // nazwa wybranego pojazdu
str=Parser->GetNextSymbol().LowerCase(); str = Parser->GetNextSymbol().LowerCase();
Global::asHumanCtrlVehicle=str; Global::asHumanCtrlVehicle = str;
} }
else if (str==AnsiString("-modifytga")) else if (str == AnsiString("-modifytga"))
{//wykonanie modyfikacji wszystkich plików TGA { // wykonanie modyfikacji wszystkich plików TGA
Global::iModifyTGA=-1; //specjalny tryb wykonania totalnej modyfikacji Global::iModifyTGA = -1; // specjalny tryb wykonania totalnej modyfikacji
} }
else if (str==AnsiString("-e3d")) else if (str == AnsiString("-e3d"))
{//wygenerowanie wszystkich plików E3D { // wygenerowanie wszystkich plików E3D
if (Global::iConvertModels>0) if (Global::iConvertModels > 0)
Global::iConvertModels=-Global::iConvertModels; //specjalny tryb Global::iConvertModels = -Global::iConvertModels; // specjalny tryb
else else
Global::iConvertModels=-7; //z optymalizacj¹, bananami i prawid³owym Opacity Global::iConvertModels = -7; // z optymalizacj¹, bananami i prawid³owym Opacity
} }
else else
Error("Program usage: EU07 [-s sceneryfilepath] [-v vehiclename] [-modifytga] [-e3d]",!Global::iWriteLogEnabled); Error(
"Program usage: EU07 [-s sceneryfilepath] [-v vehiclename] [-modifytga] [-e3d]",
!Global::iWriteLogEnabled);
} }
delete Parser; //ABu 050205: tego wczesniej nie bylo delete Parser; // ABu 050205: tego wczesniej nie bylo
} }
/* MC: usunalem tymczasowo bo sie gryzlo z nowym parserem - 8.6.2003 /* MC: usunalem tymczasowo bo sie gryzlo z nowym parserem - 8.6.2003
AnsiString csp=AnsiString(Global::szSceneryFile); AnsiString csp=AnsiString(Global::szSceneryFile);
csp=csp.Delete(csp.Pos(AnsiString(strrchr(Global::szSceneryFile,'/')))+1,csp.Length()); csp=csp.Delete(csp.Pos(AnsiString(strrchr(Global::szSceneryFile,'/')))+1,csp.Length());
Global::asCurrentSceneryPath=csp; Global::asCurrentSceneryPath=csp;
*/ */
fullscreen=Global::bFullScreen; fullscreen = Global::bFullScreen;
WindowWidth=Global::iWindowWidth; WindowWidth = Global::iWindowWidth;
WindowHeight=Global::iWindowHeight; WindowHeight = Global::iWindowHeight;
Bpp=Global::iBpp; Bpp = Global::iBpp;
if (Bpp!=32) Bpp=16; if (Bpp != 32)
//create our OpenGL window Bpp = 16;
if (!CreateGLWindow(Global::asHumanCtrlVehicle.c_str(),WindowWidth,WindowHeight,Bpp,fullscreen)) // create our OpenGL window
return 0; //quit if window was not created if (!CreateGLWindow(Global::asHumanCtrlVehicle.c_str(), WindowWidth, WindowHeight, Bpp,
fullscreen))
return 0; // quit if window was not created
SetForegroundWindow(hWnd); SetForegroundWindow(hWnd);
//McZapkie: proba przeplukania klawiatury // McZapkie: proba przeplukania klawiatury
Console *pConsole=new Console(); //Ra: nie wiem, czy ma to sens, ale jakoœ zainicjowac trzeba Console *pConsole = new Console(); // Ra: nie wiem, czy ma to sens, ale jakoœ zainicjowac trzeba
while (Console::Pressed(VK_F10)) while (Console::Pressed(VK_F10))
Error("Keyboard buffer problem - press F10"); //na Windows 98 lubi siê to pojawiaæ Error("Keyboard buffer problem - press F10"); // na Windows 98 lubi siê to pojawiaæ
int iOldSpeed, iOldDelay; int iOldSpeed, iOldDelay;
SystemParametersInfo(SPI_GETKEYBOARDSPEED,0,&iOldSpeed,0); SystemParametersInfo(SPI_GETKEYBOARDSPEED, 0, &iOldSpeed, 0);
SystemParametersInfo(SPI_GETKEYBOARDDELAY,0,&iOldDelay,0); SystemParametersInfo(SPI_GETKEYBOARDDELAY, 0, &iOldDelay, 0);
SystemParametersInfo(SPI_SETKEYBOARDSPEED,20,NULL,0); SystemParametersInfo(SPI_SETKEYBOARDSPEED, 20, NULL, 0);
//SystemParametersInfo(SPI_SETKEYBOARDDELAY,10,NULL,0); // SystemParametersInfo(SPI_SETKEYBOARDDELAY,10,NULL,0);
if (!joyGetNumDevs()) if (!joyGetNumDevs())
WriteLog("No joystick"); WriteLog("No joystick");
if (Global::iModifyTGA<0) if (Global::iModifyTGA < 0)
{//tylko modyfikacja TGA, bez uruchamiania symulacji { // tylko modyfikacja TGA, bez uruchamiania symulacji
Global::iMaxTextureSize=64; //¿eby nie zamulaæ pamiêci Global::iMaxTextureSize = 64; //¿eby nie zamulaæ pamiêci
World.ModifyTGA(); //rekurencyjne przegl¹danie katalogów World.ModifyTGA(); // rekurencyjne przegl¹danie katalogów
} }
else else
{if (Global::iConvertModels<0) {
{Global::iConvertModels=-Global::iConvertModels; if (Global::iConvertModels < 0)
World.CreateE3D("models\\"); //rekurencyjne przegl¹danie katalogów {
World.CreateE3D("dynamic\\",true); Global::iConvertModels = -Global::iConvertModels;
} //po zrobieniu E3D odpalamy normalnie sceneriê, by j¹ zobaczyæ World.CreateE3D("models\\"); // rekurencyjne przegl¹danie katalogów
//else World.CreateE3D("dynamic\\", true);
} // po zrobieniu E3D odpalamy normalnie sceneriê, by j¹ zobaczyæ
// else
//{//g³ówna pêtla programu //{//g³ówna pêtla programu
Console::On(); //w³¹czenie konsoli Console::On(); // w³¹czenie konsoli
while (!done) //loop that runs while done=FALSE while (!done) // loop that runs while done=FALSE
{ {
if (PeekMessage(&msg,NULL,0,0,PM_REMOVE)) //is there a message waiting? if (PeekMessage(&msg, NULL, 0, 0, PM_REMOVE)) // is there a message waiting?
{ {
if (msg.message==WM_QUIT) //have we received a quit message? if (msg.message == WM_QUIT) // have we received a quit message?
done=TRUE; //if so done = TRUE; // if so
else //if not, deal with window messages else // if not, deal with window messages
{ {
//if (msg.message==WM_CHAR) // if (msg.message==WM_CHAR)
//World.OnKeyDown(msg.wParam); // World.OnKeyDown(msg.wParam);
TranslateMessage(&msg); //translate the message TranslateMessage(&msg); // translate the message
DispatchMessage(&msg); //dispatch the message DispatchMessage(&msg); // dispatch the message
} }
} }
else //if there are no messages else // if there are no messages
{ {
//draw the scene, watch for quit messages // draw the scene, watch for quit messages
//DrawGLScene() // DrawGLScene()
//if (!pause) // if (!pause)
//if (Global::bInactivePause?Global::bActive:true) //tak nie, bo spada z góry // if (Global::bInactivePause?Global::bActive:true) //tak nie, bo spada z góry
if (World.Update()) // Was There A Quit Received? if (World.Update()) // Was There A Quit Received?
SwapBuffers(hDC); // Swap Buffers (Double Buffering) SwapBuffers(hDC); // Swap Buffers (Double Buffering)
else else
done=true; //[F10] or DrawGLScene signalled a quit done = true; //[F10] or DrawGLScene signalled a quit
} }
} }
Console::Off(); //wy³¹czenie konsoli (komunikacji zwrotnej) Console::Off(); // wy³¹czenie konsoli (komunikacji zwrotnej)
} }
SystemParametersInfo(SPI_SETKEYBOARDSPEED,iOldSpeed,NULL,0); SystemParametersInfo(SPI_SETKEYBOARDSPEED, iOldSpeed, NULL, 0);
SystemParametersInfo(SPI_SETKEYBOARDDELAY,iOldDelay,NULL,0); SystemParametersInfo(SPI_SETKEYBOARDDELAY, iOldDelay, NULL, 0);
delete pConsole; //deaktywania sterownika delete pConsole; // deaktywania sterownika
//shutdown // shutdown
KillGLWindow(); //kill the window KillGLWindow(); // kill the window
return (msg.wParam); //exit the program return (msg.wParam); // exit the program
} }

179
EvLaunch.cpp
View File

@@ -20,162 +20,159 @@
#include "parser.h" #include "parser.h"
#include "Console.h" #include "Console.h"
//--------------------------------------------------------------------------- //---------------------------------------------------------------------------
__fastcall TEventLauncher::TEventLauncher() __fastcall TEventLauncher::TEventLauncher()
{//ustawienie pocz¹tkowych wartoœci dla wszystkich zmiennych { // ustawienie pocz¹tkowych wartoœci dla wszystkich zmiennych
iKey=0; iKey = 0;
DeltaTime=-1; DeltaTime = -1;
UpdatedTime=0; UpdatedTime = 0;
fVal1=fVal2=0; fVal1 = fVal2 = 0;
szText=NULL; szText = NULL;
iHour=iMinute=-1; //takiego czasu nigdy nie bêdzie iHour = iMinute = -1; // takiego czasu nigdy nie bêdzie
dRadius=0; dRadius = 0;
Event1=Event2=NULL; Event1 = Event2 = NULL;
MemCell=NULL; MemCell = NULL;
iCheckMask=0; iCheckMask = 0;
} }
__fastcall TEventLauncher::~TEventLauncher() __fastcall TEventLauncher::~TEventLauncher() { SafeDeleteArray(szText); }
{
SafeDeleteArray(szText);
}
void __fastcall TEventLauncher::Init() void __fastcall TEventLauncher::Init() {}
{
}
bool __fastcall TEventLauncher::Load(cParser *parser) bool __fastcall TEventLauncher::Load(cParser *parser)
{//wczytanie wyzwalacza zdarzeñ { // wczytanie wyzwalacza zdarzeñ
AnsiString str; AnsiString str;
std::string token; std::string token;
parser->getTokens(); parser->getTokens();
*parser >> dRadius; //promieñ dzia³ania *parser >> dRadius; // promieñ dzia³ania
if (dRadius>0.0) if (dRadius > 0.0)
dRadius*=dRadius; //do kwadratu, pod warunkiem, ¿e nie jest ujemne dRadius *= dRadius; // do kwadratu, pod warunkiem, ¿e nie jest ujemne
parser->getTokens(); //klawisz steruj¹cy parser->getTokens(); // klawisz steruj¹cy
*parser >> token; *parser >> token;
str=AnsiString(token.c_str()); str = AnsiString(token.c_str());
if (str!="none") if (str != "none")
{ {
if (str.Length()==1) if (str.Length() == 1)
iKey=VkKeyScan(str[1]); //jeden znak jest konwertowany na kod klawisza iKey = VkKeyScan(str[1]); // jeden znak jest konwertowany na kod klawisza
else else
iKey=str.ToIntDef(0); //a jak wiêcej, to jakby numer klawisza jest iKey = str.ToIntDef(0); // a jak wiêcej, to jakby numer klawisza jest
} }
parser->getTokens(); parser->getTokens();
*parser >> DeltaTime; *parser >> DeltaTime;
if (DeltaTime<0) if (DeltaTime < 0)
DeltaTime=-DeltaTime; //dla ujemnego zmieniamy na dodatni DeltaTime = -DeltaTime; // dla ujemnego zmieniamy na dodatni
else if (DeltaTime>0) else if (DeltaTime > 0)
{//wartoœæ dodatnia oznacza wyzwalanie o okreœlonej godzinie { // wartoœæ dodatnia oznacza wyzwalanie o okreœlonej godzinie
iMinute=int(DeltaTime)%100; //minuty s¹ najm³odszymi cyframi dziesietnymi iMinute = int(DeltaTime) % 100; // minuty s¹ najm³odszymi cyframi dziesietnymi
iHour=int(DeltaTime-iMinute)/100; //godzina to setki iHour = int(DeltaTime - iMinute) / 100; // godzina to setki
DeltaTime=0; //bez powtórzeñ DeltaTime = 0; // bez powtórzeñ
WriteLog("EventLauncher at "+IntToStr(iHour)+":"+IntToStr(iMinute)); //wyœwietlenie czasu WriteLog("EventLauncher at " + IntToStr(iHour) + ":" +
IntToStr(iMinute)); // wyœwietlenie czasu
} }
parser->getTokens(); parser->getTokens();
*parser >> token; *parser >> token;
asEvent1Name=AnsiString(token.c_str()); //pierwszy event asEvent1Name = AnsiString(token.c_str()); // pierwszy event
parser->getTokens(); parser->getTokens();
*parser >> token; *parser >> token;
asEvent2Name=AnsiString(token.c_str()); //drugi event asEvent2Name = AnsiString(token.c_str()); // drugi event
if ((asEvent2Name=="end")||(asEvent2Name=="condition")) if ((asEvent2Name == "end") || (asEvent2Name == "condition"))
{//drugiego eventu mo¿e nie byæ, bo s¹ z tym problemy, ale ciii... { // drugiego eventu mo¿e nie byæ, bo s¹ z tym problemy, ale ciii...
str=asEvent2Name; //rozpoznane s³owo idzie do dalszego przetwarzania str = asEvent2Name; // rozpoznane s³owo idzie do dalszego przetwarzania
asEvent2Name="none"; //a drugiego eventu nie ma asEvent2Name = "none"; // a drugiego eventu nie ma
} }
else else
{//gdy s¹ dwa eventy { // gdy s¹ dwa eventy
parser->getTokens(); parser->getTokens();
*parser >> token; *parser >> token;
str=AnsiString(token.c_str()); str = AnsiString(token.c_str());
} }
if (str==AnsiString("condition")) if (str == AnsiString("condition"))
{//obs³uga wyzwalania warunkowego { // obs³uga wyzwalania warunkowego
parser->getTokens(); parser->getTokens();
*parser >> token; *parser >> token;
asMemCellName=AnsiString(token.c_str()); asMemCellName = AnsiString(token.c_str());
parser->getTokens(); parser->getTokens();
*parser >> token; *parser >> token;
SafeDeleteArray(szText); SafeDeleteArray(szText);
szText=new char[256]; szText = new char[256];
strcpy(szText,token.c_str()); strcpy(szText, token.c_str());
if (token.compare("*")!=0) //*=nie braæ command pod uwagê if (token.compare("*") != 0) //*=nie braæ command pod uwagê
iCheckMask|=conditional_memstring; iCheckMask |= conditional_memstring;
parser->getTokens(); parser->getTokens();
*parser >> token; *parser >> token;
if (token.compare("*")!=0) //*=nie braæ wartoœci 1. pod uwagê if (token.compare("*") != 0) //*=nie braæ wartoœci 1. pod uwagê
{ {
iCheckMask|=conditional_memval1; iCheckMask |= conditional_memval1;
str=AnsiString(token.c_str()); str = AnsiString(token.c_str());
fVal1=str.ToDouble(); fVal1 = str.ToDouble();
} }
else fVal1=0; else
fVal1 = 0;
parser->getTokens(); parser->getTokens();
*parser >> token; *parser >> token;
if (token.compare("*")!=0) //*=nie braæ wartoœci 2. pod uwagê if (token.compare("*") != 0) //*=nie braæ wartoœci 2. pod uwagê
{ {
iCheckMask|=conditional_memval2; iCheckMask |= conditional_memval2;
str=AnsiString(token.c_str()); str = AnsiString(token.c_str());
fVal2=str.ToDouble(); fVal2 = str.ToDouble();
} }
else fVal2=0; else
parser->getTokens(); //s³owo zamykaj¹ce fVal2 = 0;
parser->getTokens(); // s³owo zamykaj¹ce
*parser >> token; *parser >> token;
} }
return true; return true;
}; };
bool __fastcall TEventLauncher::Render() bool __fastcall TEventLauncher::Render()
{//"renderowanie" wyzwalacza { //"renderowanie" wyzwalacza
bool bCond=false; bool bCond = false;
if (iKey!=0) if (iKey != 0)
{ {
if (Global::bActive) //tylko jeœli okno jest aktywne if (Global::bActive) // tylko jeœli okno jest aktywne
bCond=(Console::Pressed(iKey)); //czy klawisz wciœniêty bCond = (Console::Pressed(iKey)); // czy klawisz wciœniêty
} }
if (DeltaTime>0) if (DeltaTime > 0)
{ {
if (UpdatedTime>DeltaTime) if (UpdatedTime > DeltaTime)
{ {
UpdatedTime=0; //naliczanie od nowa UpdatedTime = 0; // naliczanie od nowa
bCond=true; bCond = true;
} }
else else
UpdatedTime+=Timer::GetDeltaTime(); //aktualizacja naliczania czasu UpdatedTime += Timer::GetDeltaTime(); // aktualizacja naliczania czasu
} }
else else
{//jeœli nie cykliczny, to sprawdziæ czas { // jeœli nie cykliczny, to sprawdziæ czas
if (GlobalTime->hh==iHour) if (GlobalTime->hh == iHour)
{if (GlobalTime->mm==iMinute)
{//zgodnoϾ czasu uruchomienia
if (UpdatedTime<10)
{ {
UpdatedTime=20; //czas do kolejnego wyzwolenia? if (GlobalTime->mm == iMinute)
bCond=true; { // zgodnoϾ czasu uruchomienia
if (UpdatedTime < 10)
{
UpdatedTime = 20; // czas do kolejnego wyzwolenia?
bCond = true;
} }
} }
} }
else else
UpdatedTime=1; UpdatedTime = 1;
} }
if (bCond) //jeœli spe³niony zosta³ warunek if (bCond) // jeœli spe³niony zosta³ warunek
{ {
if ((iCheckMask!=0)&&MemCell) //sprawdzanie warunku na komórce pamiêci if ((iCheckMask != 0) && MemCell) // sprawdzanie warunku na komórce pamiêci
bCond=MemCell->Compare(szText,fVal1,fVal2,iCheckMask); bCond = MemCell->Compare(szText, fVal1, fVal2, iCheckMask);
} }
return bCond; //sprawdzanie dRadius w Ground.cpp return bCond; // sprawdzanie dRadius w Ground.cpp
} }
bool __fastcall TEventLauncher::IsGlobal() bool __fastcall TEventLauncher::IsGlobal()
{//sprawdzenie, czy jest globalnym wyzwalaczem czasu { // sprawdzenie, czy jest globalnym wyzwalaczem czasu
if (DeltaTime==0) if (DeltaTime == 0)
if (iHour>=0) if (iHour >= 0)
if (iMinute>=0) if (iMinute >= 0)
if (dRadius<0.0) //bez ograniczenia zasiêgu if (dRadius < 0.0) // bez ograniczenia zasiêgu
return true; return true;
return false; return false;
}; };

6
EvLaunch.h
View File

@@ -7,15 +7,15 @@
class TEventLauncher class TEventLauncher
{ {
private: private:
int iKey; int iKey;
double DeltaTime; double DeltaTime;
double UpdatedTime; double UpdatedTime;
double fVal1; double fVal1;
double fVal2; double fVal2;
char *szText; char *szText;
int iHour,iMinute; //minuta uruchomienia int iHour, iMinute; // minuta uruchomienia
public: public:
double dRadius; double dRadius;
AnsiString asEvent1Name; AnsiString asEvent1Name;
AnsiString asEvent2Name; AnsiString asEvent2Name;

718
Event.cpp
View File

@@ -21,122 +21,129 @@
__fastcall TEvent::TEvent(AnsiString m) __fastcall TEvent::TEvent(AnsiString m)
{ {
//asName=""; //czy nazwa eventu jest niezbêdna w tym przypadku? chyba nie // asName=""; //czy nazwa eventu jest niezbêdna w tym przypadku? chyba nie
evNext=evNext2=NULL; evNext = evNext2 = NULL;
bEnabled=false; //false dla eventów u¿ywanych do skanowania sygna³ów (nie dodawane do kolejki) bEnabled = false; // false dla eventów u¿ywanych do skanowania sygna³ów (nie dodawane do
asNodeName=m; //nazwa obiektu powi¹zanego // kolejki)
iQueued=0; //nie zosta³ dodany do kolejki asNodeName = m; // nazwa obiektu powi¹zanego
//bIsHistory=false; iQueued = 0; // nie zosta³ dodany do kolejki
fDelay=0; // bIsHistory=false;
fStartTime=0; //0 nie ma sensu fDelay = 0;
Type=m.IsEmpty()?tp_Unknown:tp_GetValues; //utworzenie niejawnego odczytu komórki pamiêci w torze fStartTime = 0; // 0 nie ma sensu
for (int i=0;i<13;i++) Type = m.IsEmpty() ? tp_Unknown :
Params[i].asPointer=NULL; tp_GetValues; // utworzenie niejawnego odczytu komórki pamiêci w torze
evJoined=NULL; //nie ma kolejnego z t¹ sam¹ nazw¹, usuwane s¹ wg listy Next2 for (int i = 0; i < 13; i++)
Activator=NULL; Params[i].asPointer = NULL;
iFlags=0; evJoined = NULL; // nie ma kolejnego z t¹ sam¹ nazw¹, usuwane s¹ wg listy Next2
//event niejawny jest tworzony przed faz¹ InitEvents, która podmienia nazwê komórki pamiêci na wskaŸnik Activator = NULL;
//Current->Params[8].asGroundNode=m; //to siê ustawi w InitEvents iFlags = 0;
//Current->Params[9].asMemCell=m->MemCell; // event niejawny jest tworzony przed faz¹ InitEvents, która podmienia nazwê komórki pamiêci na
fRandomDelay=0.0; //standardowo nie bêdzie dodatkowego losowego opóŸnienia // wskaŸnik
// Current->Params[8].asGroundNode=m; //to siê ustawi w InitEvents
// Current->Params[9].asMemCell=m->MemCell;
fRandomDelay = 0.0; // standardowo nie bêdzie dodatkowego losowego opóŸnienia
}; };
__fastcall TEvent::~TEvent() __fastcall TEvent::~TEvent()
{ {
switch (Type) switch (Type)
{//sprz¹tanie { // sprz¹tanie
case tp_Multiple: case tp_Multiple:
//SafeDeleteArray(Params[9].asText); //nie usuwaæ - nazwa obiektu powi¹zanego zamieniana na wskaŸnik // SafeDeleteArray(Params[9].asText); //nie usuwaæ - nazwa obiektu powi¹zanego zamieniana na
if (iFlags&conditional_memstring) //o ile jest ³añcuch do porównania w memcompare // wskaŸnik
if (iFlags & conditional_memstring) // o ile jest ³añcuch do porównania w memcompare
SafeDeleteArray(Params[10].asText); SafeDeleteArray(Params[10].asText);
break; break;
case tp_UpdateValues: case tp_UpdateValues:
case tp_AddValues: case tp_AddValues:
SafeDeleteArray(Params[0].asText); SafeDeleteArray(Params[0].asText);
if (iFlags&conditional_memstring) //o ile jest ³añcuch do porównania w memcompare if (iFlags & conditional_memstring) // o ile jest ³añcuch do porównania w memcompare
SafeDeleteArray(Params[10].asText); SafeDeleteArray(Params[10].asText);
break; break;
case tp_Animation: //nic case tp_Animation: // nic
//SafeDeleteArray(Params[9].asText); //nie usuwaæ - nazwa jest zamieniana na wskaŸnik do submodelu // SafeDeleteArray(Params[9].asText); //nie usuwaæ - nazwa jest zamieniana na wskaŸnik do
if (Params[0].asInt==4) //jeœli z pliku VMD // submodelu
delete[] Params[8].asPointer; //zwolniæ obszar if (Params[0].asInt == 4) // jeœli z pliku VMD
case tp_GetValues: //nic delete[] Params[8].asPointer; // zwolniæ obszar
case tp_GetValues: // nic
break; break;
} }
evJoined=NULL; //nie usuwaæ podczepionych tutaj evJoined = NULL; // nie usuwaæ podczepionych tutaj
}; };
void __fastcall TEvent::Init() void __fastcall TEvent::Init(){
{
}; };
void __fastcall TEvent::Conditions(cParser* parser,AnsiString s) void __fastcall TEvent::Conditions(cParser *parser, AnsiString s)
{//przetwarzanie warunków, wspólne dla Multiple i UpdateValues { // przetwarzanie warunków, wspólne dla Multiple i UpdateValues
if (s=="condition") if (s == "condition")
{//jesli nie "endevent" { // jesli nie "endevent"
std::string token; std::string token;
AnsiString str; AnsiString str;
if (!asNodeName.IsEmpty()) if (!asNodeName.IsEmpty())
{//podczepienie ³añcucha, jeœli nie jest pusty { // podczepienie ³añcucha, jeœli nie jest pusty
Params[9].asText=new char[asNodeName.Length()+1]; //usuwane i zamieniane na wskaŸnik Params[9].asText = new char[asNodeName.Length() + 1]; // usuwane i zamieniane na
strcpy(Params[9].asText,asNodeName.c_str()); // wskaŸnik
strcpy(Params[9].asText, asNodeName.c_str());
} }
parser->getTokens(); parser->getTokens();
*parser >> token; *parser >> token;
str=AnsiString(token.c_str()); str = AnsiString(token.c_str());
if (str==AnsiString("trackoccupied")) if (str == AnsiString("trackoccupied"))
iFlags|=conditional_trackoccupied; iFlags |= conditional_trackoccupied;
else if (str==AnsiString("trackfree")) else if (str == AnsiString("trackfree"))
iFlags|=conditional_trackfree; iFlags |= conditional_trackfree;
else if (str==AnsiString("propability")) else if (str == AnsiString("propability"))
{ {
iFlags|=conditional_propability; iFlags |= conditional_propability;
parser->getTokens(); parser->getTokens();
*parser >> Params[10].asdouble; *parser >> Params[10].asdouble;
} }
else if (str==AnsiString("memcompare")) else if (str == AnsiString("memcompare"))
{ {
iFlags|=conditional_memcompare; iFlags |= conditional_memcompare;
parser->getTokens(1,false); //case sensitive parser->getTokens(1, false); // case sensitive
*parser >> token; *parser >> token;
str=AnsiString(token.c_str()); str = AnsiString(token.c_str());
if (str!="*") //"*" - nie brac command pod uwage if (str != "*") //"*" - nie brac command pod uwage
{//zapamiêtanie ³añcucha do porównania { // zapamiêtanie ³añcucha do porównania
Params[10].asText=new char[255]; Params[10].asText = new char[255];
strcpy(Params[10].asText,str.c_str()); strcpy(Params[10].asText, str.c_str());
iFlags|=conditional_memstring; iFlags |= conditional_memstring;
} }
parser->getTokens(); parser->getTokens();
*parser >> token; *parser >> token;
str=AnsiString(token.c_str()); str = AnsiString(token.c_str());
if (str!="*") //"*" - nie brac val1 pod uwage if (str != "*") //"*" - nie brac val1 pod uwage
{ {
Params[11].asdouble=str.ToDouble(); Params[11].asdouble = str.ToDouble();
iFlags|=conditional_memval1; iFlags |= conditional_memval1;
} }
parser->getTokens(); parser->getTokens();
*parser >> token; *parser >> token;
str=AnsiString(token.c_str()); str = AnsiString(token.c_str());
if (str!=AnsiString("*")) //"*" - nie brac val2 pod uwage if (str != AnsiString("*")) //"*" - nie brac val2 pod uwage
{ {
Params[12].asdouble=str.ToDouble(); Params[12].asdouble = str.ToDouble();
iFlags|=conditional_memval2; iFlags |= conditional_memval2;
} }
} }
parser->getTokens(); *parser >> token; parser->getTokens();
s=AnsiString(token.c_str()); //ewentualnie dalej losowe opóŸnienie *parser >> token;
s = AnsiString(token.c_str()); // ewentualnie dalej losowe opóŸnienie
} }
if (s=="randomdelay") if (s == "randomdelay")
{//losowe opóŸnienie { // losowe opóŸnienie
std::string token; std::string token;
parser->getTokens(); parser->getTokens();
*parser >> fRandomDelay; //Ra 2014-03-11 *parser >> fRandomDelay; // Ra 2014-03-11
parser->getTokens(); *parser >> token; //endevent parser->getTokens();
*parser >> token; // endevent
} }
}; };
void __fastcall TEvent::Load(cParser* parser,vector3 *org) void __fastcall TEvent::Load(cParser *parser, vector3 *org)
{ {
int i; int i;
int ti; int ti;
@@ -145,126 +152,128 @@ void __fastcall TEvent::Load(cParser* parser,vector3 *org)
AnsiString str; AnsiString str;
char *ptr; char *ptr;
bEnabled=true; //zmieniane na false dla eventów u¿ywanych do skanowania sygna³ów bEnabled = true; // zmieniane na false dla eventów u¿ywanych do skanowania sygna³ów
parser->getTokens(); parser->getTokens();
*parser >> token; *parser >> token;
asName=AnsiString(token.c_str()).LowerCase(); //u¿ycie parametrów mo¿e dawaæ wielkie asName = AnsiString(token.c_str()).LowerCase(); // u¿ycie parametrów mo¿e dawaæ wielkie
parser->getTokens(); parser->getTokens();
*parser >> token; *parser >> token;
str=AnsiString(token.c_str()); str = AnsiString(token.c_str());
if (str==AnsiString("exit")) if (str == AnsiString("exit"))
Type=tp_Exit; Type = tp_Exit;
else if (str==AnsiString("updatevalues")) else if (str == AnsiString("updatevalues"))
Type=tp_UpdateValues; Type = tp_UpdateValues;
else if (str==AnsiString("getvalues")) else if (str == AnsiString("getvalues"))
Type=tp_GetValues; Type = tp_GetValues;
else if (str==AnsiString("putvalues")) else if (str == AnsiString("putvalues"))
Type=tp_PutValues; Type = tp_PutValues;
else if (str==AnsiString("disable")) else if (str == AnsiString("disable"))
Type=tp_Disable; Type = tp_Disable;
else if (str==AnsiString("sound")) else if (str == AnsiString("sound"))
Type=tp_Sound; Type = tp_Sound;
else if (str==AnsiString("velocity")) else if (str == AnsiString("velocity"))
Type=tp_Velocity; Type = tp_Velocity;
else if (str==AnsiString("animation")) else if (str == AnsiString("animation"))
Type=tp_Animation; Type = tp_Animation;
else if (str==AnsiString("lights")) else if (str == AnsiString("lights"))
Type=tp_Lights; Type = tp_Lights;
else if (str==AnsiString("visible")) else if (str == AnsiString("visible"))
Type=tp_Visible; //zmiana wyœwietlania obiektu Type = tp_Visible; // zmiana wyœwietlania obiektu
else if (str==AnsiString("switch")) else if (str == AnsiString("switch"))
Type=tp_Switch; Type = tp_Switch;
else if (str==AnsiString("dynvel")) else if (str == AnsiString("dynvel"))
Type=tp_DynVel; Type = tp_DynVel;
else if (str==AnsiString("trackvel")) else if (str == AnsiString("trackvel"))
Type=tp_TrackVel; Type = tp_TrackVel;
else if (str==AnsiString("multiple")) else if (str == AnsiString("multiple"))
Type=tp_Multiple; Type = tp_Multiple;
else if (str==AnsiString("addvalues")) else if (str == AnsiString("addvalues"))
Type=tp_AddValues; Type = tp_AddValues;
else if (str==AnsiString("copyvalues")) else if (str == AnsiString("copyvalues"))
Type=tp_CopyValues; Type = tp_CopyValues;
else if (str==AnsiString("whois")) else if (str == AnsiString("whois"))
Type=tp_WhoIs; Type = tp_WhoIs;
else if (str==AnsiString("logvalues")) else if (str == AnsiString("logvalues"))
Type=tp_LogValues; Type = tp_LogValues;
else if (str==AnsiString("voltage")) else if (str == AnsiString("voltage"))
Type=tp_Voltage; //zmiana napiêcia w zasilaczu (TractionPowerSource) Type = tp_Voltage; // zmiana napiêcia w zasilaczu (TractionPowerSource)
else if (str==AnsiString("message")) else if (str == AnsiString("message"))
Type=tp_Message; //wyœwietlenie komunikatu Type = tp_Message; // wyœwietlenie komunikatu
else if (str==AnsiString("friction")) else if (str == AnsiString("friction"))
Type=tp_Friction; //zmiana tarcia na scenerii Type = tp_Friction; // zmiana tarcia na scenerii
else else
Type=tp_Unknown; Type = tp_Unknown;
parser->getTokens(); parser->getTokens();
*parser >> fDelay; *parser >> fDelay;
parser->getTokens(); parser->getTokens();
*parser >> token; *parser >> token;
str=AnsiString(token.c_str()); str = AnsiString(token.c_str());
if (str!="none") asNodeName=str; //nazwa obiektu powi¹zanego if (str != "none")
asNodeName = str; // nazwa obiektu powi¹zanego
if (asName.SubString(1,5)=="none_") if (asName.SubString(1, 5) == "none_")
Type=tp_Ignored; //Ra: takie s¹ ignorowane Type = tp_Ignored; // Ra: takie s¹ ignorowane
switch (Type) switch (Type)
{ {
case tp_AddValues: case tp_AddValues:
iFlags=update_memadd; //dodawanko iFlags = update_memadd; // dodawanko
case tp_UpdateValues: case tp_UpdateValues:
//if (Type==tp_UpdateValues) iFlags=0; //co modyfikowaæ // if (Type==tp_UpdateValues) iFlags=0; //co modyfikowaæ
parser->getTokens(1,false); //case sensitive parser->getTokens(1, false); // case sensitive
*parser >> token; *parser >> token;
str=AnsiString(token.c_str()); str = AnsiString(token.c_str());
Params[0].asText=new char[str.Length()+1]; Params[0].asText = new char[str.Length() + 1];
strcpy(Params[0].asText,str.c_str()); strcpy(Params[0].asText, str.c_str());
if (str!="*") //czy ma zostaæ bez zmian? if (str != "*") // czy ma zostaæ bez zmian?
iFlags|=update_memstring; iFlags |= update_memstring;
parser->getTokens(); parser->getTokens();
*parser >> token; *parser >> token;
str=AnsiString(token.c_str()); str = AnsiString(token.c_str());
if (str!="*") //czy ma zostaæ bez zmian? if (str != "*") // czy ma zostaæ bez zmian?
{ {
Params[1].asdouble=str.ToDouble(); Params[1].asdouble = str.ToDouble();
iFlags|=update_memval1; iFlags |= update_memval1;
} }
else else
Params[1].asdouble=0; Params[1].asdouble = 0;
parser->getTokens(); parser->getTokens();
*parser >> token; *parser >> token;
str=AnsiString(token.c_str()); str = AnsiString(token.c_str());
if (str!="*") //czy ma zostaæ bez zmian? if (str != "*") // czy ma zostaæ bez zmian?
{ {
Params[2].asdouble=str.ToDouble(); Params[2].asdouble = str.ToDouble();
iFlags|=update_memval2; iFlags |= update_memval2;
} }
else else
Params[2].asdouble=0; Params[2].asdouble = 0;
parser->getTokens(); parser->getTokens();
*parser >> token; *parser >> token;
Conditions(parser,token.c_str()); //sprawdzanie warunków Conditions(parser, token.c_str()); // sprawdzanie warunków
break; break;
case tp_CopyValues: case tp_CopyValues:
Params[9].asText=NULL; Params[9].asText = NULL;
iFlags=update_memstring|update_memval1|update_memval2; //normalanie trzy iFlags = update_memstring | update_memval1 | update_memval2; // normalanie trzy
i=0; i = 0;
parser->getTokens(); parser->getTokens();
*parser >> token; //nazwa drugiej komórki (Ÿród³owej) *parser >> token; // nazwa drugiej komórki (Ÿród³owej)
while (token.compare("endevent")!=0) while (token.compare("endevent") != 0)
{ {
switch (++i) switch (++i)
{//znaczenie kolejnych parametrów { // znaczenie kolejnych parametrów
case 1: //nazwa drugiej komórki (Ÿród³owej) case 1: // nazwa drugiej komórki (Ÿród³owej)
Params[9].asText=new char[token.length()+1]; //usuwane i zamieniane na wskaŸnik Params[9].asText = new char[token.length() + 1]; // usuwane i zamieniane na wskaŸnik
strcpy(Params[9].asText,token.c_str()); strcpy(Params[9].asText, token.c_str());
break; break;
case 2: //maska wartoœci case 2: // maska wartoœci
iFlags=AnsiString(token.c_str()).ToIntDef(update_memstring|update_memval1|update_memval2); iFlags = AnsiString(token.c_str())
.ToIntDef(update_memstring | update_memval1 | update_memval2);
break; break;
} }
parser->getTokens(); parser->getTokens();
@@ -272,16 +281,17 @@ void __fastcall TEvent::Load(cParser* parser,vector3 *org)
} }
break; break;
case tp_WhoIs: case tp_WhoIs:
iFlags=update_memstring|update_memval1|update_memval2; //normalanie trzy iFlags = update_memstring | update_memval1 | update_memval2; // normalanie trzy
i=0; i = 0;
parser->getTokens(); parser->getTokens();
*parser >> token; //nazwa drugiej komórki (Ÿród³owej) *parser >> token; // nazwa drugiej komórki (Ÿród³owej)
while (token.compare("endevent")!=0) while (token.compare("endevent") != 0)
{ {
switch (++i) switch (++i)
{//znaczenie kolejnych parametrów { // znaczenie kolejnych parametrów
case 1: //maska wartoœci case 1: // maska wartoœci
iFlags=AnsiString(token.c_str()).ToIntDef(update_memstring|update_memval1|update_memval2); iFlags = AnsiString(token.c_str())
.ToIntDef(update_memstring | update_memval1 | update_memval2);
break; break;
} }
parser->getTokens(); parser->getTokens();
@@ -295,332 +305,372 @@ void __fastcall TEvent::Load(cParser* parser,vector3 *org)
break; break;
case tp_PutValues: case tp_PutValues:
parser->getTokens(3); parser->getTokens(3);
*parser >> Params[3].asdouble >> Params[4].asdouble >> Params[5].asdouble; //po³o¿enie X,Y,Z *parser >> Params[3].asdouble >> Params[4].asdouble >> Params[5].asdouble; // po³o¿enie
// X,Y,Z
if (org) if (org)
{//przesuniêcie { // przesuniêcie
//tmp->pCenter.RotateY(aRotate.y/180.0*M_PI); //Ra 2014-11: uwzglêdnienie rotacji // tmp->pCenter.RotateY(aRotate.y/180.0*M_PI); //Ra 2014-11: uwzglêdnienie rotacji
Params[3].asdouble+=org->x; //wspó³rzêdne w scenerii Params[3].asdouble += org->x; // wspó³rzêdne w scenerii
Params[4].asdouble+=org->y; Params[4].asdouble += org->y;
Params[5].asdouble+=org->z; Params[5].asdouble += org->z;
} }
//Params[12].asInt=0; // Params[12].asInt=0;
parser->getTokens(1,false); //komendy 'case sensitive' parser->getTokens(1, false); // komendy 'case sensitive'
*parser >> token; *parser >> token;
str=AnsiString(token.c_str()); str = AnsiString(token.c_str());
if (str.SubString(1,19)=="PassengerStopPoint:") if (str.SubString(1, 19) == "PassengerStopPoint:")
{if (str.Pos("#")) str=str.SubString(1,str.Pos("#")-1); //obciêcie unikatowoœci {
bEnabled=false; //nie do kolejki (dla SetVelocity te¿, ale jak jest do toru dowi¹zany) if (str.Pos("#"))
Params[6].asCommand=cm_PassengerStopPoint; str = str.SubString(1, str.Pos("#") - 1); // obciêcie unikatowoœci
bEnabled = false; // nie do kolejki (dla SetVelocity te¿, ale jak jest do toru
// dowi¹zany)
Params[6].asCommand = cm_PassengerStopPoint;
} }
else if (str=="SetVelocity") else if (str == "SetVelocity")
{bEnabled=false; {
Params[6].asCommand=cm_SetVelocity; bEnabled = false;
Params[6].asCommand = cm_SetVelocity;
} }
else if (str=="ShuntVelocity") else if (str == "ShuntVelocity")
{bEnabled=false; {
Params[6].asCommand=cm_ShuntVelocity; bEnabled = false;
Params[6].asCommand = cm_ShuntVelocity;
} }
else if (str=="SetProximityVelocity") else if (str == "SetProximityVelocity")
{bEnabled=false; {
Params[6].asCommand=cm_SetProximityVelocity; bEnabled = false;
Params[6].asCommand = cm_SetProximityVelocity;
} }
else if (str=="OutsideStation") else if (str == "OutsideStation")
{bEnabled=false; //ma byæ skanowny, aby AI nie przekracza³o W5 {
Params[6].asCommand=cm_OutsideStation; bEnabled = false; // ma byæ skanowny, aby AI nie przekracza³o W5
Params[6].asCommand = cm_OutsideStation;
} }
else else
Params[6].asCommand=cm_Unknown; Params[6].asCommand = cm_Unknown;
Params[0].asText=new char[str.Length()+1]; Params[0].asText = new char[str.Length() + 1];
strcpy(Params[0].asText,str.c_str()); strcpy(Params[0].asText, str.c_str());
parser->getTokens(); parser->getTokens();
*parser >> token; *parser >> token;
str=AnsiString(token.c_str()); str = AnsiString(token.c_str());
if (str=="none") if (str == "none")
Params[1].asdouble=0.0; Params[1].asdouble = 0.0;
else else
try try
{Params[1].asdouble=str.ToDouble();} {
Params[1].asdouble = str.ToDouble();
}
catch (...) catch (...)
{Params[1].asdouble=0.0; {
WriteLog("Error: number expected in PutValues event, found: "+str); Params[1].asdouble = 0.0;
WriteLog("Error: number expected in PutValues event, found: " + str);
} }
parser->getTokens(); parser->getTokens();
*parser >> token; *parser >> token;
str=AnsiString(token.c_str()); str = AnsiString(token.c_str());
if (str=="none") if (str == "none")
Params[2].asdouble=0.0; Params[2].asdouble = 0.0;
else else
try try
{Params[2].asdouble=str.ToDouble();} {
Params[2].asdouble = str.ToDouble();
}
catch (...) catch (...)
{Params[2].asdouble=0.0; {
WriteLog("Error: number expected in PutValues event, found: "+str); Params[2].asdouble = 0.0;
WriteLog("Error: number expected in PutValues event, found: " + str);
} }
parser->getTokens(); parser->getTokens();
*parser >> token; *parser >> token;
break; break;
case tp_Lights: case tp_Lights:
i=0; i = 0;
do do
{ {
parser->getTokens(); parser->getTokens();
*parser >> token; *parser >> token;
if (token.compare("endevent")!=0) if (token.compare("endevent") != 0)
{ {
str=AnsiString(token.c_str()); str = AnsiString(token.c_str());
if (i<8) if (i < 8)
Params[i].asdouble=str.ToDouble(); //teraz mo¿e mieæ u³amek Params[i].asdouble = str.ToDouble(); // teraz mo¿e mieæ u³amek
i++; i++;
} }
} } while (token.compare("endevent") != 0);
while (token.compare("endevent")!=0);
break; break;
case tp_Visible: //zmiana wyœwietlania obiektu case tp_Visible: // zmiana wyœwietlania obiektu
parser->getTokens();
*parser >> token;
str = AnsiString(token.c_str());
Params[0].asInt = str.ToInt();
parser->getTokens(); parser->getTokens();
*parser >> token; *parser >> token;
str=AnsiString(token.c_str());
Params[0].asInt=str.ToInt();
parser->getTokens(); *parser >> token;
break; break;
case tp_Velocity: case tp_Velocity:
parser->getTokens(); parser->getTokens();
*parser >> token; *parser >> token;
str=AnsiString(token.c_str()); str = AnsiString(token.c_str());
Params[0].asdouble=str.ToDouble()*0.28; Params[0].asdouble = str.ToDouble() * 0.28;
parser->getTokens(); *parser >> token; parser->getTokens();
*parser >> token;
break; break;
case tp_Sound: case tp_Sound:
//Params[0].asRealSound->Init(asNodeName.c_str(),Parser->GetNextSymbol().ToDouble(),Parser->GetNextSymbol().ToDouble(),Parser->GetNextSymbol().ToDouble(),Parser->GetNextSymbol().ToDouble()); // Params[0].asRealSound->Init(asNodeName.c_str(),Parser->GetNextSymbol().ToDouble(),Parser->GetNextSymbol().ToDouble(),Parser->GetNextSymbol().ToDouble(),Parser->GetNextSymbol().ToDouble());
//McZapkie-070502: dzwiek przestrzenny (ale do poprawy) // McZapkie-070502: dzwiek przestrzenny (ale do poprawy)
//Params[1].asdouble=Parser->GetNextSymbol().ToDouble(); // Params[1].asdouble=Parser->GetNextSymbol().ToDouble();
//Params[2].asdouble=Parser->GetNextSymbol().ToDouble(); // Params[2].asdouble=Parser->GetNextSymbol().ToDouble();
//Params[3].asdouble=Parser->GetNextSymbol().ToDouble(); //polozenie X,Y,Z - do poprawy! // Params[3].asdouble=Parser->GetNextSymbol().ToDouble(); //polozenie X,Y,Z - do poprawy!
parser->getTokens(); parser->getTokens();
*parser >> Params[0].asInt; //0: wylaczyc, 1: wlaczyc; -1: wlaczyc zapetlone *parser >> Params[0].asInt; // 0: wylaczyc, 1: wlaczyc; -1: wlaczyc zapetlone
parser->getTokens(); *parser >> token; parser->getTokens();
*parser >> token;
break; break;
case tp_Exit: case tp_Exit:
while ((ptr=strchr(asNodeName.c_str(),'_'))!=NULL) while ((ptr = strchr(asNodeName.c_str(), '_')) != NULL)
*ptr=' '; *ptr = ' ';
parser->getTokens(); *parser >> token; parser->getTokens();
*parser >> token;
break; break;
case tp_Disable: case tp_Disable:
parser->getTokens(); *parser >> token; parser->getTokens();
*parser >> token;
break; break;
case tp_Animation: case tp_Animation:
parser->getTokens(); parser->getTokens();
*parser >> token; *parser >> token;
Params[0].asInt=0; //na razie nieznany typ Params[0].asInt = 0; // na razie nieznany typ
if (token.compare("rotate")==0) if (token.compare("rotate") == 0)
{//obrót wzglêdem osi { // obrót wzglêdem osi
parser->getTokens(); parser->getTokens();
*parser >> token; *parser >> token;
Params[9].asText=new char[255]; //nazwa submodelu Params[9].asText = new char[255]; // nazwa submodelu
strcpy(Params[9].asText,token.c_str()); strcpy(Params[9].asText, token.c_str());
Params[0].asInt=1; Params[0].asInt = 1;
parser->getTokens(4); parser->getTokens(4);
*parser >> Params[1].asdouble >> Params[2].asdouble >> Params[3].asdouble >> Params[4].asdouble; *parser >> Params[1].asdouble >> Params[2].asdouble >> Params[3].asdouble >>
Params[4].asdouble;
} }
else if (token.compare("translate")==0) else if (token.compare("translate") == 0)
{//przesuw o wektor { // przesuw o wektor
parser->getTokens(); parser->getTokens();
*parser >> token; *parser >> token;
Params[9].asText=new char[255]; //nazwa submodelu Params[9].asText = new char[255]; // nazwa submodelu
strcpy(Params[9].asText,token.c_str()); strcpy(Params[9].asText, token.c_str());
Params[0].asInt=2; Params[0].asInt = 2;
parser->getTokens(4); parser->getTokens(4);
*parser >> Params[1].asdouble >> Params[2].asdouble >> Params[3].asdouble >> Params[4].asdouble; *parser >> Params[1].asdouble >> Params[2].asdouble >> Params[3].asdouble >>
Params[4].asdouble;
} }
else if (token.compare("digital")==0) else if (token.compare("digital") == 0)
{//licznik cyfrowy { // licznik cyfrowy
parser->getTokens(); parser->getTokens();
*parser >> token; *parser >> token;
Params[9].asText=new char[255]; //nazwa submodelu Params[9].asText = new char[255]; // nazwa submodelu
strcpy(Params[9].asText,token.c_str()); strcpy(Params[9].asText, token.c_str());
Params[0].asInt=8; Params[0].asInt = 8;
parser->getTokens(4); //jaki ma byæ sens tych parametrów? parser->getTokens(4); // jaki ma byæ sens tych parametrów?
*parser >> Params[1].asdouble >> Params[2].asdouble >> Params[3].asdouble >> Params[4].asdouble; *parser >> Params[1].asdouble >> Params[2].asdouble >> Params[3].asdouble >>
Params[4].asdouble;
} }
else if (token.substr(token.length()-4,4)==".vmd") //na razie tu, mo¿e bêdzie inaczej else if (token.substr(token.length() - 4, 4) == ".vmd") // na razie tu, mo¿e bêdzie inaczej
{//animacja z pliku VMD { // animacja z pliku VMD
TFileStream *fs=new TFileStream("models\\"+AnsiString(token.c_str()),fmOpenRead); TFileStream *fs = new TFileStream("models\\" + AnsiString(token.c_str()), fmOpenRead);
Params[7].asInt=fs->Size; Params[7].asInt = fs->Size;
Params[8].asPointer=new char[fs->Size]; Params[8].asPointer = new char[fs->Size];
fs->Read(Params[8].asPointer,fs->Size); //wczytanie pliku fs->Read(Params[8].asPointer, fs->Size); // wczytanie pliku
delete fs; delete fs;
parser->getTokens(); parser->getTokens();
*parser >> token; *parser >> token;
Params[9].asText=new char[255]; //nazwa submodelu Params[9].asText = new char[255]; // nazwa submodelu
strcpy(Params[9].asText,token.c_str()); strcpy(Params[9].asText, token.c_str());
Params[0].asInt=4; //rodzaj animacji Params[0].asInt = 4; // rodzaj animacji
parser->getTokens(4); parser->getTokens(4);
*parser >> Params[1].asdouble >> Params[2].asdouble >> Params[3].asdouble >> Params[4].asdouble; *parser >> Params[1].asdouble >> Params[2].asdouble >> Params[3].asdouble >>
Params[4].asdouble;
} }
parser->getTokens(); *parser >> token; parser->getTokens();
*parser >> token;
break; break;
case tp_Switch: case tp_Switch:
parser->getTokens(); *parser >> Params[0].asInt; parser->getTokens();
parser->getTokens(); *parser >> token; *parser >> Params[0].asInt;
str=AnsiString(token.c_str()); parser->getTokens();
if (str!="endevent") *parser >> token;
{Params[1].asdouble=str.ToDouble(); //prêdkoœæ liniowa ruchu iglic str = AnsiString(token.c_str());
parser->getTokens(); *parser >> token; if (str != "endevent")
str=AnsiString(token.c_str()); {
Params[1].asdouble = str.ToDouble(); // prêdkoœæ liniowa ruchu iglic
parser->getTokens();
*parser >> token;
str = AnsiString(token.c_str());
} }
else else
Params[1].asdouble=-1.0; //u¿yæ domyœlnej Params[1].asdouble = -1.0; // u¿yæ domyœlnej
if (str!="endevent") if (str != "endevent")
{Params[2].asdouble=str.ToDouble(); //dodatkowy ruch drugiej iglicy (zamkniêcie nastawnicze) {
parser->getTokens(); *parser >> token; Params[2].asdouble =
str.ToDouble(); // dodatkowy ruch drugiej iglicy (zamkniêcie nastawnicze)
parser->getTokens();
*parser >> token;
} }
else else
Params[2].asdouble=-1.0; //u¿yæ domyœlnej Params[2].asdouble = -1.0; // u¿yæ domyœlnej
break; break;
case tp_DynVel: case tp_DynVel:
parser->getTokens(); parser->getTokens();
*parser >> Params[0].asdouble; //McZapkie-090302 *0.28; *parser >> Params[0].asdouble; // McZapkie-090302 *0.28;
parser->getTokens(); *parser >> token; parser->getTokens();
*parser >> token;
break; break;
case tp_TrackVel: case tp_TrackVel:
parser->getTokens(); parser->getTokens();
*parser >> Params[0].asdouble; //McZapkie-090302 *0.28; *parser >> Params[0].asdouble; // McZapkie-090302 *0.28;
parser->getTokens(); *parser >> token;
break;
case tp_Multiple:
i=0;
ti=0; //flaga dla else
parser->getTokens(); parser->getTokens();
*parser >> token; *parser >> token;
str=AnsiString(token.c_str()); break;
while (str!=AnsiString("endevent") && str!=AnsiString("condition") && str!=AnsiString("randomdelay")) case tp_Multiple:
i = 0;
ti = 0; // flaga dla else
parser->getTokens();
*parser >> token;
str = AnsiString(token.c_str());
while (str != AnsiString("endevent") && str != AnsiString("condition") &&
str != AnsiString("randomdelay"))
{ {
if ((str.SubString(1,5)!="none_")?(i<8):false) if ((str.SubString(1, 5) != "none_") ? (i < 8) : false)
{//eventy rozpoczynaj¹ce siê od "none_" s¹ ignorowane { // eventy rozpoczynaj¹ce siê od "none_" s¹ ignorowane
if (str!="else") if (str != "else")
{Params[i].asText=new char[255]; {
strcpy(Params[i].asText,str.c_str()); Params[i].asText = new char[255];
if (ti) iFlags|=conditional_else<<i; //oflagowanie dla eventów "else" strcpy(Params[i].asText, str.c_str());
if (ti)
iFlags |= conditional_else << i; // oflagowanie dla eventów "else"
i++; i++;
} }
else else
ti=!ti; //zmiana flagi dla s³owa "else" ti = !ti; // zmiana flagi dla s³owa "else"
} }
else if (i>=8) else if (i >= 8)
ErrorLog("Bad event: \""+str+"\" ignored in multiple \""+asName+"\"!"); ErrorLog("Bad event: \"" + str + "\" ignored in multiple \"" + asName + "\"!");
else else
WriteLog("Event \""+str+"\" ignored in multiple \""+asName+"\"!"); WriteLog("Event \"" + str + "\" ignored in multiple \"" + asName + "\"!");
parser->getTokens(); parser->getTokens();
*parser >> token; *parser >> token;
str=AnsiString(token.c_str()); str = AnsiString(token.c_str());
} }
Conditions(parser,str); //sprawdzanie warunków Conditions(parser, str); // sprawdzanie warunków
break; break;
case tp_Voltage: //zmiana napiêcia w zasilaczu (TractionPowerSource) case tp_Voltage: // zmiana napiêcia w zasilaczu (TractionPowerSource)
case tp_Friction: //zmiana przyczepnosci na scenerii case tp_Friction: // zmiana przyczepnosci na scenerii
parser->getTokens();
*parser >> Params[0].asdouble; // Ra 2014-01-27
parser->getTokens(); parser->getTokens();
*parser >> Params[0].asdouble; //Ra 2014-01-27
parser->getTokens(); *parser >> token;
break;
case tp_Message: //wyœwietlenie komunikatu
do
{parser->getTokens();
*parser >> token; *parser >> token;
str=AnsiString(token.c_str());
} while (str!="endevent");
break; break;
case tp_Ignored: //ignorowany case tp_Message: // wyœwietlenie komunikatu
case tp_Unknown: //nieznany
do do
{parser->getTokens(); {
parser->getTokens();
*parser >> token; *parser >> token;
str=AnsiString(token.c_str()); str = AnsiString(token.c_str());
} while (str!="endevent"); } while (str != "endevent");
WriteLog("Bad event: \""+asName+(Type==tp_Unknown?"\" has unknown type.":"\" is ignored.")); break;
case tp_Ignored: // ignorowany
case tp_Unknown: // nieznany
do
{
parser->getTokens();
*parser >> token;
str = AnsiString(token.c_str());
} while (str != "endevent");
WriteLog("Bad event: \"" + asName +
(Type == tp_Unknown ? "\" has unknown type." : "\" is ignored."));
break; break;
} }
}; };
void __fastcall TEvent::AddToQuery(TEvent *e) void __fastcall TEvent::AddToQuery(TEvent *e)
{//dodanie eventu do kolejki { // dodanie eventu do kolejki
if (evNext?(e->fStartTime>=evNext->fStartTime):false) if (evNext ? (e->fStartTime >= evNext->fStartTime) : false)
evNext->AddToQuery(e); //sortowanie wg czasu evNext->AddToQuery(e); // sortowanie wg czasu
else else
{//dodanie z przodu { // dodanie z przodu
e->evNext=evNext; e->evNext = evNext;
evNext=e; evNext = e;
} }
} }
//--------------------------------------------------------------------------- //---------------------------------------------------------------------------
AnsiString __fastcall TEvent::CommandGet() AnsiString __fastcall TEvent::CommandGet()
{//odczytanie komendy z eventu { // odczytanie komendy z eventu
switch (Type) switch (Type)
{//to siê wykonuje równie¿ sk³adu jad¹cego bez obs³ugi { // to siê wykonuje równie¿ sk³adu jad¹cego bez obs³ugi
case tp_GetValues: case tp_GetValues:
return String(Params[9].asMemCell->Text()); return String(Params[9].asMemCell->Text());
case tp_PutValues: case tp_PutValues:
return String(Params[0].asText); return String(Params[0].asText);
} }
return ""; //inne eventy siê nie licz¹ return ""; // inne eventy siê nie licz¹
}; };
TCommandType __fastcall TEvent::Command() TCommandType __fastcall TEvent::Command()
{//odczytanie komendy z eventu { // odczytanie komendy z eventu
switch (Type) switch (Type)
{//to siê wykonuje równie¿ dla sk³adu jad¹cego bez obs³ugi { // to siê wykonuje równie¿ dla sk³adu jad¹cego bez obs³ugi
case tp_GetValues: case tp_GetValues:
return Params[9].asMemCell->Command(); return Params[9].asMemCell->Command();
case tp_PutValues: case tp_PutValues:
return Params[6].asCommand; //komenda zakodowana binarnie return Params[6].asCommand; // komenda zakodowana binarnie
} }
return cm_Unknown; //inne eventy siê nie licz¹ return cm_Unknown; // inne eventy siê nie licz¹
}; };
double __fastcall TEvent::ValueGet(int n) double __fastcall TEvent::ValueGet(int n)
{//odczytanie komendy z eventu { // odczytanie komendy z eventu
n&=1; //tylko 1 albo 2 jest prawid³owy n &= 1; // tylko 1 albo 2 jest prawid³owy
switch (Type) switch (Type)
{//to siê wykonuje równie¿ sk³adu jad¹cego bez obs³ugi { // to siê wykonuje równie¿ sk³adu jad¹cego bez obs³ugi
case tp_GetValues: case tp_GetValues:
return n?Params[9].asMemCell->Value1():Params[9].asMemCell->Value2(); return n ? Params[9].asMemCell->Value1() : Params[9].asMemCell->Value2();
case tp_PutValues: case tp_PutValues:
return Params[2-n].asdouble; return Params[2 - n].asdouble;
} }
return 0.0; //inne eventy siê nie licz¹ return 0.0; // inne eventy siê nie licz¹
}; };
vector3 __fastcall TEvent::PositionGet() vector3 __fastcall TEvent::PositionGet()
{//pobranie wspó³rzêdnych eventu { // pobranie wspó³rzêdnych eventu
switch (Type) switch (Type)
{// { //
case tp_GetValues: case tp_GetValues:
return Params[9].asMemCell->Position(); //wspó³rzêdne pod³¹czonej komórki pamiêci return Params[9].asMemCell->Position(); // wspó³rzêdne pod³¹czonej komórki pamiêci
case tp_PutValues: case tp_PutValues:
return vector3(Params[3].asdouble,Params[4].asdouble,Params[5].asdouble); return vector3(Params[3].asdouble, Params[4].asdouble, Params[5].asdouble);
} }
return vector3(0,0,0); //inne eventy siê nie licz¹ return vector3(0, 0, 0); // inne eventy siê nie licz¹
}; };
bool __fastcall TEvent::StopCommand() bool __fastcall TEvent::StopCommand()
{// { //
if (Type==tp_GetValues) if (Type == tp_GetValues)
return Params[9].asMemCell->StopCommand(); //info o komendzie z komórki return Params[9].asMemCell->StopCommand(); // info o komendzie z komórki
return false; return false;
}; };
void __fastcall TEvent::StopCommandSent() void __fastcall TEvent::StopCommandSent()
{ {
if (Type==tp_GetValues) if (Type == tp_GetValues)
Params[9].asMemCell->StopCommandSent(); //komenda z komórki zosta³a wys³ana Params[9].asMemCell->StopCommandSent(); // komenda z komórki zosta³a wys³ana
}; };
void __fastcall TEvent::Append(TEvent *e) void __fastcall TEvent::Append(TEvent *e)
{//doczepienie kolejnych z t¹ sam¹ nazw¹ { // doczepienie kolejnych z t¹ sam¹ nazw¹
if (evJoined) if (evJoined)
evJoined->Append(e); //rekurencja! - góra kilkanaœcie eventów bêdzie potrzebne evJoined->Append(e); // rekurencja! - góra kilkanaœcie eventów bêdzie potrzebne
else else
{evJoined=e; {
e->bEnabled=true; //ten doczepiony mo¿e byæ tylko kolejkowany evJoined = e;
e->bEnabled = true; // ten doczepiony mo¿e byæ tylko kolejkowany
} }
}; };

100
Event.h
View File

@@ -7,30 +7,49 @@
#include "dumb3d.h" #include "dumb3d.h"
using namespace Math3D; using namespace Math3D;
typedef enum { tp_Unknown, tp_Sound, tp_SoundPos, tp_Exit, typedef enum
tp_Disable, tp_Velocity, tp_Animation, tp_Lights, {
tp_UpdateValues, tp_GetValues, tp_PutValues, tp_Unknown,
tp_Switch, tp_DynVel, tp_TrackVel, tp_Multiple, tp_Sound,
tp_AddValues, tp_Ignored, tp_CopyValues, tp_WhoIs, tp_SoundPos,
tp_LogValues, tp_Visible, tp_Exit,
tp_Voltage, tp_Message, tp_Friction tp_Disable,
} TEventType; tp_Velocity,
tp_Animation,
tp_Lights,
tp_UpdateValues,
tp_GetValues,
tp_PutValues,
tp_Switch,
tp_DynVel,
tp_TrackVel,
tp_Multiple,
tp_AddValues,
tp_Ignored,
tp_CopyValues,
tp_WhoIs,
tp_LogValues,
tp_Visible,
tp_Voltage,
tp_Message,
tp_Friction
} TEventType;
const int update_memstring =0x0000001; //zmodyfikowaæ tekst (UpdateValues) const int update_memstring = 0x0000001; // zmodyfikowaæ tekst (UpdateValues)
const int update_memval1 =0x0000002; //zmodyfikowaæ pierwsz¹ wartosæ const int update_memval1 = 0x0000002; // zmodyfikowaæ pierwsz¹ wartosæ
const int update_memval2 =0x0000004; //zmodyfikowaæ drug¹ wartosæ const int update_memval2 = 0x0000004; // zmodyfikowaæ drug¹ wartosæ
const int update_memadd =0x0000008; //dodaæ do poprzedniej zawartoœci const int update_memadd = 0x0000008; // dodaæ do poprzedniej zawartoœci
const int update_load =0x0000010; //odczytaæ ³adunek const int update_load = 0x0000010; // odczytaæ ³adunek
const int update_only =0x00000FF; //wartoϾ graniczna const int update_only = 0x00000FF; // wartoϾ graniczna
const int conditional_memstring =0x0000100; //porównanie tekstu const int conditional_memstring = 0x0000100; // porównanie tekstu
const int conditional_memval1 =0x0000200; //porównanie pierwszej wartoœci liczbowej const int conditional_memval1 = 0x0000200; // porównanie pierwszej wartoœci liczbowej
const int conditional_memval2 =0x0000400; //porównanie drugiej wartoœci const int conditional_memval2 = 0x0000400; // porównanie drugiej wartoœci
const int conditional_else =0x0010000; //flaga odwrócenia warunku (przesuwana bitowo) const int conditional_else = 0x0010000; // flaga odwrócenia warunku (przesuwana bitowo)
const int conditional_anyelse =0x0FF0000; //do sprawdzania, czy s¹ odwrócone warunki const int conditional_anyelse = 0x0FF0000; // do sprawdzania, czy s¹ odwrócone warunki
const int conditional_trackoccupied =0x1000000; //jeœli tor zajêty const int conditional_trackoccupied = 0x1000000; // jeœli tor zajêty
const int conditional_trackfree =0x2000000; //jeœli tor wolny const int conditional_trackfree = 0x2000000; // jeœli tor wolny
const int conditional_propability =0x4000000; //zale¿nie od generatora lizcb losowych const int conditional_propability = 0x4000000; // zale¿nie od generatora lizcb losowych
const int conditional_memcompare =0x8000000; //porównanie zawartoœci const int conditional_memcompare = 0x8000000; // porównanie zawartoœci
union TParam union TParam
{ {
@@ -52,31 +71,32 @@ union TParam
TTractionPowerSource *psPower; TTractionPowerSource *psPower;
}; };
class TEvent //zmienne: ev* class TEvent // zmienne: ev*
{//zdarzenie { // zdarzenie
private: private:
void __fastcall Conditions(cParser* parser,AnsiString s); void __fastcall Conditions(cParser *parser, AnsiString s);
public:
public:
AnsiString asName; AnsiString asName;
bool bEnabled; //false gdy ma nie byæ dodawany do kolejki (skanowanie sygna³ów) bool bEnabled; // false gdy ma nie byæ dodawany do kolejki (skanowanie sygna³ów)
int iQueued; //ile razy dodany do kolejki int iQueued; // ile razy dodany do kolejki
//bool bIsHistory; // bool bIsHistory;
TEvent *evNext; //nastêpny w kolejce TEvent *evNext; // nastêpny w kolejce
TEvent *evNext2; TEvent *evNext2;
TEventType Type; TEventType Type;
double fStartTime; double fStartTime;
double fDelay; double fDelay;
TDynamicObject *Activator; TDynamicObject *Activator;
TParam Params[13]; //McZapkie-070502 //Ra: zamieniæ to na union/struct TParam Params[13]; // McZapkie-070502 //Ra: zamieniæ to na union/struct
unsigned int iFlags; //zamiast Params[8] z flagami warunku unsigned int iFlags; // zamiast Params[8] z flagami warunku
AnsiString asNodeName; //McZapkie-100302 - dodalem zeby zapamietac nazwe toru AnsiString asNodeName; // McZapkie-100302 - dodalem zeby zapamietac nazwe toru
TEvent *evJoined; //kolejny event z t¹ sam¹ nazw¹ - od wersji 378 TEvent *evJoined; // kolejny event z t¹ sam¹ nazw¹ - od wersji 378
double fRandomDelay; //zakres dodatkowego opóŸnienia double fRandomDelay; // zakres dodatkowego opóŸnienia
public: //metody public: // metody
__fastcall TEvent(AnsiString m=""); __fastcall TEvent(AnsiString m = "");
__fastcall ~TEvent(); __fastcall ~TEvent();
void __fastcall Init(); void __fastcall Init();
void __fastcall Load(cParser* parser,vector3 *org); void __fastcall Load(cParser *parser, vector3 *org);
void __fastcall AddToQuery(TEvent *e); void __fastcall AddToQuery(TEvent *e);
AnsiString __fastcall CommandGet(); AnsiString __fastcall CommandGet();
TCommandType __fastcall Command(); TCommandType __fastcall Command();

83
FadeSound.cpp
View File

@@ -12,94 +12,79 @@
#include "Timer.h" #include "Timer.h"
#include "FadeSound.h" #include "FadeSound.h"
__fastcall TFadeSound::TFadeSound() __fastcall TFadeSound::TFadeSound()
{ {
Sound= NULL; Sound = NULL;
fFade= 0; fFade = 0;
dt= 0; dt = 0;
fTime= 0; fTime = 0;
} }
__fastcall TFadeSound::~TFadeSound() { Free(); }
__fastcall TFadeSound::~TFadeSound() void __fastcall TFadeSound::Free() {}
{
Free();
}
void __fastcall TFadeSound::Free()
{
}
void __fastcall TFadeSound::Init(char *Name, float fNewFade) void __fastcall TFadeSound::Init(char *Name, float fNewFade)
{ {
Sound= TSoundsManager::GetFromName(Name,false); Sound = TSoundsManager::GetFromName(Name, false);
if (Sound) if (Sound)
Sound->SetVolume(0); Sound->SetVolume(0);
fFade= fNewFade; fFade = fNewFade;
fTime= 0; fTime = 0;
} }
void __fastcall TFadeSound::TurnOn() void __fastcall TFadeSound::TurnOn()
{ {
State= ss_Starting; State = ss_Starting;
Sound->Play(0,0,DSBPLAY_LOOPING); Sound->Play(0, 0, DSBPLAY_LOOPING);
fTime= fFade; fTime = fFade;
} }
void __fastcall TFadeSound::TurnOff() void __fastcall TFadeSound::TurnOff() { State = ss_ShuttingDown; }
{
State= ss_ShuttingDown;
}
void __fastcall TFadeSound::Update() void __fastcall TFadeSound::Update()
{ {
if (State==ss_Starting) if (State == ss_Starting)
{ {
fTime+= Timer::GetDeltaTime(); fTime += Timer::GetDeltaTime();
// SoundStart->SetVolume(-1000*(4-fTime)/4); // SoundStart->SetVolume(-1000*(4-fTime)/4);
if (fTime>=fFade) if (fTime >= fFade)
{ {
fTime= fFade; fTime = fFade;
State= ss_Commencing; State = ss_Commencing;
Sound->SetVolume(-2000*(fFade-fTime)/fFade); Sound->SetVolume(-2000 * (fFade - fTime) / fFade);
Sound->SetFrequency(44100-500+500*(fTime)/fFade); Sound->SetFrequency(44100 - 500 + 500 * (fTime) / fFade);
} }
else else if (Timer::GetSoundTimer())
if (Timer::GetSoundTimer())
{ {
Sound->SetVolume(-2000*(fFade-fTime)/fFade); Sound->SetVolume(-2000 * (fFade - fTime) / fFade);
Sound->SetFrequency(44100-500+500*(fTime)/fFade); Sound->SetFrequency(44100 - 500 + 500 * (fTime) / fFade);
} }
} }
else else if (State == ss_ShuttingDown)
if (State==ss_ShuttingDown)
{ {
fTime-= Timer::GetDeltaTime(); fTime -= Timer::GetDeltaTime();
if (fTime<=0) if (fTime <= 0)
{ {
State= ss_Off; State = ss_Off;
fTime= 0; fTime = 0;
Sound->Stop(); Sound->Stop();
} }
if (Timer::GetSoundTimer()) if (Timer::GetSoundTimer())
{ //DSBVOLUME_MIN { // DSBVOLUME_MIN
Sound->SetVolume(-2000*(fFade-fTime)/fFade); Sound->SetVolume(-2000 * (fFade - fTime) / fFade);
Sound->SetFrequency(44100-500+500*fTime/fFade); Sound->SetFrequency(44100 - 500 + 500 * fTime / fFade);
} }
} }
} }
void __fastcall TFadeSound::Volume(long vol) void __fastcall TFadeSound::Volume(long vol)
{ {
float glos= 1; float glos = 1;
Sound->SetVolume(vol*glos); Sound->SetVolume(vol * glos);
} }
//--------------------------------------------------------------------------- //---------------------------------------------------------------------------
#pragma package(smart_init) #pragma package(smart_init)

8
FadeSound.h
View File

@@ -10,19 +10,19 @@ class TFadeSound
{ {
PSound Sound; PSound Sound;
float fFade; float fFade;
float dt,fTime; float dt, fTime;
TSoundState State; TSoundState State;
public:
public:
__fastcall TFadeSound(); __fastcall TFadeSound();
__fastcall ~TFadeSound(); __fastcall ~TFadeSound();
void __fastcall Init(char *Name, float fNewFade); void __fastcall Init(char *Name, float fNewFade);
void __fastcall TurnOn(); void __fastcall TurnOn();
void __fastcall TurnOff(); void __fastcall TurnOff();
bool __fastcall Playing() {return (State==ss_Commencing || State==ss_Starting); }; bool __fastcall Playing() { return (State == ss_Commencing || State == ss_Starting); };
void __fastcall Free(); void __fastcall Free();
void __fastcall Update(); void __fastcall Update();
void __fastcall Volume(long vol); void __fastcall Volume(long vol);
}; };
//--------------------------------------------------------------------------- //---------------------------------------------------------------------------

28
Float3d.cpp
View File

@@ -10,18 +10,18 @@
#pragma package(smart_init) #pragma package(smart_init)
void __fastcall float4x4::Quaternion(float4 *q) void __fastcall float4x4::Quaternion(float4 *q)
{//konwersja kwaternionu obrotu na macierz obrotu { // konwersja kwaternionu obrotu na macierz obrotu
float xx=q->x*q->x,yy=q->y*q->y,zz=q->z*q->z; float xx = q->x * q->x, yy = q->y * q->y, zz = q->z * q->z;
float xy=q->x*q->y,xz=q->x*q->z,yz=q->y*q->z; float xy = q->x * q->y, xz = q->x * q->z, yz = q->y * q->z;
float wx=q->w*q->x,wy=q->w*q->y,wz=q->w*q->z; float wx = q->w * q->x, wy = q->w * q->y, wz = q->w * q->z;
e[ 0]=1.0f-yy-yy-zz-zz; e[0] = 1.0f - yy - yy - zz - zz;
e[ 1]=xy+xy+wz+wz; e[1] = xy + xy + wz + wz;
e[ 2]=xz+xz-wy-wy; e[2] = xz + xz - wy - wy;
e[ 4]=xy+xy-wz-wz; e[4] = xy + xy - wz - wz;
e[ 5]=1.0f-xx-xx-zz-zz; e[5] = 1.0f - xx - xx - zz - zz;
e[ 6]=yz+yz+wx+wx; e[6] = yz + yz + wx + wx;
e[ 8]=xz+xz+wy+wy; e[8] = xz + xz + wy + wy;
e[ 9]=yz+yz-wx-wx; e[9] = yz + yz - wx - wx;
e[10]=1.0f-xx-xx-yy-yy; e[10] = 1.0f - xx - xx - yy - yy;
//czwartej kolumny i czwartego wiersza nie ruszamy // czwartej kolumny i czwartego wiersza nie ruszamy
}; };

364
Float3d.h
View File

@@ -6,196 +6,214 @@
//--------------------------------------------------------------------------- //---------------------------------------------------------------------------
class float3 class float3
{//wapó³rzêdne wiercho³ka 3D o pojedynczej precyzji { // wapó³rzêdne wiercho³ka 3D o pojedynczej precyzji
public: public:
float x,y,z; float x, y, z;
float3(void) {}; float3(void){};
__fastcall float3(float a,float b,float c) {x=a;y=b;z=c;}; __fastcall float3(float a, float b, float c)
{
x = a;
y = b;
z = c;
};
double inline __fastcall Length() const; double inline __fastcall Length() const;
}; };
inline bool operator==(const float3& v1,const float3& v2) inline bool operator==(const float3 &v1, const float3 &v2)
{return (v1.x==v2.x&&v1.y==v2.y&&v1.z==v2.z); {
return (v1.x == v2.x && v1.y == v2.y && v1.z == v2.z);
}; };
inline float3& operator+=(float3& v1,const float3& v2) inline float3 &operator+=(float3 &v1, const float3 &v2)
{v1.x+=v2.x; v1.y+=v2.y; v1.z+=v2.z; {
v1.x += v2.x;
v1.y += v2.y;
v1.z += v2.z;
return v1; return v1;
}; };
inline float3 operator-(const float3& v) inline float3 operator-(const float3 &v) { return float3(-v.x, -v.y, -v.z); };
{return float3(-v.x,-v.y,-v.z); inline float3 operator-(const float3 &v1, const float3 &v2)
{
return float3(v1.x - v2.x, v1.y - v2.y, v1.z - v2.z);
}; };
inline float3 operator-(const float3 &v1,const float3 &v2) inline float3 operator+(const float3 &v1, const float3 &v2)
{return float3(v1.x-v2.x,v1.y-v2.y,v1.z-v2.z); {
}; return float3(v1.x + v2.x, v1.y + v2.y, v1.z + v2.z);
inline float3 operator+(const float3 &v1,const float3 &v2)
{return float3(v1.x+v2.x,v1.y+v2.y,v1.z+v2.z);
};
double inline __fastcall float3::Length() const
{return sqrt(x*x+y*y+z*z);
};
inline float3 operator/(const float3& v, double k)
{return float3(v.x/k,v.y/k,v.z/k);
}; };
double inline __fastcall float3::Length() const { return sqrt(x * x + y * y + z * z); };
inline float3 operator/(const float3 &v, double k) { return float3(v.x / k, v.y / k, v.z / k); };
inline float3 SafeNormalize(const float3 &v) inline float3 SafeNormalize(const float3 &v)
{//bezpieczna normalizacja (wektor d³ugoœci 1.0) { // bezpieczna normalizacja (wektor d³ugoœci 1.0)
double l=v.Length(); double l = v.Length();
float3 retVal; float3 retVal;
if (l==0) if (l == 0)
retVal.x=retVal.y=retVal.z=0; retVal.x = retVal.y = retVal.z = 0;
else else
retVal=v/l; retVal = v / l;
return retVal; return retVal;
}; };
inline float3 CrossProduct(const float3& v1,const float3& v2) inline float3 CrossProduct(const float3 &v1, const float3 &v2)
{return float3(v1.y*v2.z-v1.z*v2.y,v2.x*v1.z-v2.z*v1.x,v1.x*v2.y-v1.y*v2.x); {
return float3(v1.y * v2.z - v1.z * v2.y, v2.x * v1.z - v2.z * v1.x, v1.x * v2.y - v1.y * v2.x);
} }
class float4 class float4
{//kwaternion obrotu { // kwaternion obrotu
public: public:
float x,y,z,w; float x, y, z, w;
__fastcall float4() {x=y=z=0.f;w=1.f;}; __fastcall float4()
__fastcall float4(float a,float b,float c,float d) {x=a;y=b;z=c;w=d;}; {
double inline float4::LengthSquared() const x = y = z = 0.f;
{return x*x+y*y+z*z+w*w;}; w = 1.f;
double inline float4::Length() const };
{return sqrt(x*x+y*y+z*z+w*w);}; __fastcall float4(float a, float b, float c, float d)
{
x = a;
y = b;
z = c;
w = d;
};
double inline float4::LengthSquared() const { return x * x + y * y + z * z + w * w; };
double inline float4::Length() const { return sqrt(x * x + y * y + z * z + w * w); };
}; };
inline float4 operator*(const float4 &q1,const float4 &q2) inline float4 operator*(const float4 &q1, const float4 &q2)
{//mno¿enie to prawie jak mno¿enie macierzy { // mno¿enie to prawie jak mno¿enie macierzy
return float4 return float4(q1.w * q2.x + q1.x * q2.w + q1.y * q2.z - q1.z * q2.y,
(q1.w*q2.x+q1.x*q2.w+q1.y*q2.z-q1.z*q2.y, q1.w * q2.y + q1.y * q2.w + q1.z * q2.x - q1.x * q2.z,
q1.w*q2.y+q1.y*q2.w+q1.z*q2.x-q1.x*q2.z, q1.w * q2.z + q1.z * q2.w + q1.x * q2.y - q1.y * q2.x,
q1.w*q2.z+q1.z*q2.w+q1.x*q2.y-q1.y*q2.x, q1.w * q2.w - q1.x * q2.x - q1.y * q2.y - q1.z * q2.z);
q1.w*q2.w-q1.x*q2.x-q1.y*q2.y-q1.z*q2.z
);
} }
inline float4 operator-(const float4& q) inline float4 operator-(const float4 &q) { // sprzê¿ony; odwrotny tylko dla znormalizowanych! return float4(-q.x, -q.y, -q.z, q.w); };
{//sprzê¿ony; odwrotny tylko dla znormalizowanych! inline float4 operator-(const float4 &q1, const float4 &q2)
return float4(-q.x,-q.y,-q.z,q.w); { // z odejmowaniem nie ma lekko
return (-q1) * q2; // inwersja tylko dla znormalizowanych!
}; };
inline float4 operator-(const float4 &q1,const float4 &q2) inline float4 operator+(const float4 &v1, const float4 &v2)
{//z odejmowaniem nie ma lekko {
return (-q1)*q2; //inwersja tylko dla znormalizowanych! return float4(v1.x + v2.x, v1.y + v2.y, v1.z + v2.z, v1.w + v2.w);
};
inline float4 operator/(const float4 &v, double k)
{
return float4(v.x / k, v.y / k, v.z / k, v.w / k);
}; };
inline float4 operator+(const float4 &v1,const float4 &v2)
{return float4(v1.x+v2.x,v1.y+v2.y,v1.z+v2.z,v1.w+v2.w);};
inline float4 operator/(const float4& v, double k)
{return float4(v.x/k,v.y/k,v.z/k,v.w/k);};
inline float4 Normalize(const float4 &v) inline float4 Normalize(const float4 &v)
{//bezpieczna normalizacja (wektor d³ugoœci 1.0) { // bezpieczna normalizacja (wektor d³ugoœci 1.0)
double l=v.LengthSquared(); double l = v.LengthSquared();
if (l==1.0) if (l == 1.0)
return v; return v;
if (l==0.0) if (l == 0.0)
return float4(); //wektor zerowy, w=1 return float4(); // wektor zerowy, w=1
else else
return v/sqrt(l); //pierwiastek liczony tylko jeœli trzeba wykonaæ dzielenia return v / sqrt(l); // pierwiastek liczony tylko jeœli trzeba wykonaæ dzielenia
}; };
float Dot(const float4 &q1,const float4 &q2) float Dot(const float4 &q1, const float4 &q2)
{//iloczyn skalarny { // iloczyn skalarny
return q1.x*q2.x+q1.y*q2.y+q1.z*q2.z+q1.w*q2.w; return q1.x * q2.x + q1.y * q2.y + q1.z * q2.z + q1.w * q2.w;
} }
inline float4& operator*=(float4& v1,double d) inline float4 &operator*=(float4 &v1, double d)
{//mno¿enie przez skalar, jaki ma sens? { // mno¿enie przez skalar, jaki ma sens?
v1.x*=d; v1.y*=d; v1.z*=d; v1.w*=d; v1.x *= d;
v1.y *= d;
v1.z *= d;
v1.w *= d;
return v1; return v1;
}; };
inline float4 Slerp(const float4 &q0,const float4 &q1,float t) inline float4 Slerp(const float4 &q0, const float4 &q1, float t)
//void Slerp(QUATERNION *Out, const QUATERNION &q0, const QUATERNION &q1, float t) // void Slerp(QUATERNION *Out, const QUATERNION &q0, const QUATERNION &q1, float t)
{//interpolacja sweryczna { // interpolacja sweryczna
float cosOmega=Dot(q0,q1); float cosOmega = Dot(q0, q1);
float4 new_q1(q1); float4 new_q1(q1);
if (cosOmega<0.0f) if (cosOmega < 0.0f)
{//je¿eli s¹ niezgodne kierunki, jeden z nich trzeba zanegowaæ { // je¿eli s¹ niezgodne kierunki, jeden z nich trzeba zanegowaæ
new_q1.x=-new_q1.x; new_q1.x = -new_q1.x;
new_q1.y=-new_q1.y; new_q1.y = -new_q1.y;
new_q1.z=-new_q1.z; new_q1.z = -new_q1.z;
new_q1.w=-new_q1.w; new_q1.w = -new_q1.w;
cosOmega=-cosOmega; cosOmega = -cosOmega;
} }
double k0,k1; double k0, k1;
if (cosOmega>0.9999f) if (cosOmega > 0.9999f)
{//jeœli jesteœmy z (t) na maksimum kosinusa, to tam prawie liniowo jest { // jeœli jesteœmy z (t) na maksimum kosinusa, to tam prawie liniowo jest
k0=1.0f-t; k0 = 1.0f - t;
k1=t; k1 = t;
} }
else else
{//a w ogólnym przypadku trzeba liczyæ na trygonometriê { // a w ogólnym przypadku trzeba liczyæ na trygonometriê
double sinOmega=sqrt(1.0f-cosOmega*cosOmega); //sinus z jedynki tryg. double sinOmega = sqrt(1.0f - cosOmega * cosOmega); // sinus z jedynki tryg.
double omega=atan2(sinOmega,cosOmega); //wyznaczenie k¹ta double omega = atan2(sinOmega, cosOmega); // wyznaczenie k¹ta
double oneOverSinOmega=1.0f/sinOmega; //odwrotnoϾ sinusa, bo sinus w mianowniku double oneOverSinOmega = 1.0f / sinOmega; // odwrotnoϾ sinusa, bo sinus w mianowniku
k0=sin((1.0f-t)*omega)*oneOverSinOmega; k0 = sin((1.0f - t) * omega) * oneOverSinOmega;
k1=sin(t*omega)*oneOverSinOmega; k1 = sin(t * omega) * oneOverSinOmega;
} }
return float4 return float4(q0.x * k0 + new_q1.x * k1, q0.y * k0 + new_q1.y * k1, q0.z * k0 + new_q1.z * k1,
(q0.x*k0+new_q1.x*k1, q0.w * k0 + new_q1.w * k1);
q0.y*k0+new_q1.y*k1,
q0.z*k0+new_q1.z*k1,
q0.w*k0+new_q1.w*k1
);
} }
struct float8 struct float8
{//wiercho³ek 3D z wektorem normalnym i mapowaniem, pojedyncza precyzja { // wiercho³ek 3D z wektorem normalnym i mapowaniem, pojedyncza precyzja
public: public:
float3 Point; float3 Point;
float3 Normal; float3 Normal;
float tu,tv; float tu, tv;
}; };
class float4x4 class float4x4
{//macierz transformacji pojedynczej precyzji { // macierz transformacji pojedynczej precyzji
float e[16]; float e[16];
public:
float4x4(void) {}; public:
float4x4(float f[16]) {for (int i=0;i<16;++i) e[i]=f[i];}; float4x4(void){};
float* __fastcall operator() (int i) { return &e[i<<2]; } float4x4(float f[16])
const float* __fastcall readArray(void) { return e; } {
for (int i = 0; i < 16; ++i)
e[i] = f[i];
};
float *__fastcall operator()(int i) { return &e[i << 2]; }
const float *__fastcall readArray(void) { return e; }
void __fastcall Identity() void __fastcall Identity()
{for (int i=0;i<16;++i) {
e[i]=0; for (int i = 0; i < 16; ++i)
e[0]=e[5]=e[10]=e[15]=1.0f; e[i] = 0;
e[0] = e[5] = e[10] = e[15] = 1.0f;
} }
const float* operator[](int i) const {return &e[i<<2];}; const float *operator[](int i) const { return &e[i << 2]; };
void __fastcall InitialRotate() void __fastcall InitialRotate()
{//taka specjalna rotacja, nie ma co ci¹gaæ trygonometrii { // taka specjalna rotacja, nie ma co ci¹gaæ trygonometrii
float f; float f;
for (int i=0;i<16;i+=4) for (int i = 0; i < 16; i += 4)
{e[i]=-e[i]; //zmiana znaku X {
f=e[i+1]; e[i+1]=e[i+2]; e[i+2]=f; //zamiana Y i Z e[i] = -e[i]; // zmiana znaku X
f = e[i + 1];
e[i + 1] = e[i + 2];
e[i + 2] = f; // zamiana Y i Z
} }
}; };
inline float4x4& Rotation(double angle,float3 axis); inline float4x4 &Rotation(double angle, float3 axis);
inline bool IdentityIs() inline bool IdentityIs()
{//sprawdzenie jednostkowoœci { // sprawdzenie jednostkowoœci
for (int i=0;i<16;++i) for (int i = 0; i < 16; ++i)
if (e[i]!=((i%5)?0.0:1.0)) //jedynki tylko na 0, 5, 10 i 15 if (e[i] != ((i % 5) ? 0.0 : 1.0)) // jedynki tylko na 0, 5, 10 i 15
return false; return false;
return true; return true;
} }
void __fastcall Quaternion(float4 *q); void __fastcall Quaternion(float4 *q);
inline float3* TranslationGet() inline float3 *TranslationGet() { return (float3 *)(e + 12); }
{return (float3*)(e+12);}
}; };
inline float3 operator*(const float4x4& m,const float3& v) inline float3 operator*(const float4x4 &m, const float3 &v)
{//mno¿enie wektora przez macierz { // mno¿enie wektora przez macierz
return float3( return float3(v.x * m[0][0] + v.y * m[1][0] + v.z * m[2][0] + m[3][0],
v.x*m[0][0]+v.y*m[1][0]+v.z*m[2][0]+m[3][0], v.x * m[0][1] + v.y * m[1][1] + v.z * m[2][1] + m[3][1],
v.x*m[0][1]+v.y*m[1][1]+v.z*m[2][1]+m[3][1], v.x * m[0][2] + v.y * m[1][2] + v.z * m[2][2] + m[3][2]);
v.x*m[0][2]+v.y*m[1][2]+v.z*m[2][2]+m[3][2]
);
} }
inline float4x4& float4x4::Rotation(double angle,float3 axis) inline float4x4 &float4x4::Rotation(double angle, float3 axis)
{ {
double c=cos(angle); double c = cos(angle);
double s=sin(angle); double s = sin(angle);
// One minus c (short name for legibility of formulai) // One minus c (short name for legibility of formulai)
double omc=(1-c); double omc = (1 - c);
if (axis.Length()!=1.0f) axis=SafeNormalize(axis); if (axis.Length() != 1.0f)
axis = SafeNormalize(axis);
double x = axis.x; double x = axis.x;
double y = axis.y; double y = axis.y;
double z = axis.z; double z = axis.z;
@@ -205,65 +223,57 @@ inline float4x4& float4x4::Rotation(double angle,float3 axis)
double xyomc = x * y * omc; double xyomc = x * y * omc;
double xzomc = x * z * omc; double xzomc = x * z * omc;
double yzomc = y * z * omc; double yzomc = y * z * omc;
e[0] =x*x*omc+c; e[0] = x * x * omc + c;
e[1] =xyomc+zs; e[1] = xyomc + zs;
e[2] =xzomc-ys; e[2] = xzomc - ys;
e[3] =0; e[3] = 0;
e[4] =xyomc-zs; e[4] = xyomc - zs;
e[5] =y*y*omc+c; e[5] = y * y * omc + c;
e[6] =yzomc+xs; e[6] = yzomc + xs;
e[7] =0; e[7] = 0;
e[8] =xzomc+ys; e[8] = xzomc + ys;
e[9] =yzomc-xs; e[9] = yzomc - xs;
e[10]=z*z*omc+c; e[10] = z * z * omc + c;
e[11]=0; e[11] = 0;
e[12]=0; e[12] = 0;
e[13]=0; e[13] = 0;
e[14]=0; e[14] = 0;
e[15]=1; e[15] = 1;
return *this; return *this;
}; };
inline float4x4 operator*(const float4x4& m1, const float4x4& m2) inline float4x4 operator*(const float4x4 &m1, const float4x4 &m2)
{//iloczyn macierzy { // iloczyn macierzy
float4x4 retVal; float4x4 retVal;
for (int x=0;x<4;++x) for (int x = 0; x < 4; ++x)
for (int y=0;y<4;++y) for (int y = 0; y < 4; ++y)
{ {
retVal(x)[y]=0; retVal(x)[y] = 0;
for (int i=0;i<4;++i) for (int i = 0; i < 4; ++i)
retVal(x)[y]+=m1[i][y]*m2[x][i]; retVal(x)[y] += m1[i][y] * m2[x][i];
} }
return retVal; return retVal;
}; };
// From code in Graphics Gems; p. 766 // From code in Graphics Gems; p. 766
inline float Det2x2(float a,float b,float c,float d) inline float Det2x2(float a, float b, float c, float d) { // obliczenie wyznacznika macierzy 2×2 return a * d - b * c; };
{//obliczenie wyznacznika macierzy 2×2
return a*d-b*c;
};
inline float Det3x3(float a1,float a2,float a3, inline float Det3x3(float a1, float a2, float a3, float b1, float b2, float b3, float c1, float c2,
float b1,float b2,float b3, float c3)
float c1,float c2,float c3) { // obliczenie wyznacznika macierzy 3×3
{//obliczenie wyznacznika macierzy 3×3 return +a1 * Det2x2(b2, b3, c2, c3) - b1 * Det2x2(a2, a3, c2, c3) + c1 * Det2x2(a2, a3, b2, b3);
return
+a1*Det2x2(b2,b3,c2,c3)
-b1*Det2x2(a2,a3,c2,c3)
+c1*Det2x2(a2,a3,b2,b3);
}; };
float Det(const float4x4 &m) float Det(const float4x4 &m)
{//obliczenie wyznacznika macierzy 4×4 { // obliczenie wyznacznika macierzy 4×4
float a1=m[0][0],a2=m[1][0],a3=m[2][0],a4=m[3][0]; float a1 = m[0][0], a2 = m[1][0], a3 = m[2][0], a4 = m[3][0];
float b1=m[0][1],b2=m[1][1],b3=m[2][1],b4=m[3][1]; float b1 = m[0][1], b2 = m[1][1], b3 = m[2][1], b4 = m[3][1];
float c1=m[0][2],c2=m[1][2],c3=m[2][2],c4=m[3][2]; float c1 = m[0][2], c2 = m[1][2], c3 = m[2][2], c4 = m[3][2];
float d1=m[0][3],d2=m[1][3],d3=m[2][3],d4=m[3][3]; float d1 = m[0][3], d2 = m[1][3], d3 = m[2][3], d4 = m[3][3];
return return +a1 * Det3x3(b2, b3, b4, c2, c3, c4, d2, d3, d4) -
+a1*Det3x3(b2,b3,b4,c2,c3,c4,d2,d3,d4) b1 * Det3x3(a2, a3, a4, c2, c3, c4, d2, d3, d4) +
-b1*Det3x3(a2,a3,a4,c2,c3,c4,d2,d3,d4) c1 * Det3x3(a2, a3, a4, b2, b3, b4, d2, d3, d4) -
+c1*Det3x3(a2,a3,a4,b2,b3,b4,d2,d3,d4) d1 * Det3x3(a2, a3, a4, b2, b3, b4, c2, c3, c4);
-d1*Det3x3(a2,a3,a4,b2,b3,b4,c2,c3,c4);
}; };
#endif #endif

2
Forth.h
View File

@@ -5,6 +5,6 @@
//--------------------------------------------------------------------------- //---------------------------------------------------------------------------
class Forth class Forth
{//klasa obs³ugi jêzyka { // klasa obs³ugi jêzyka
}; };
#endif #endif

223
Gauge.cpp
View File

@@ -18,200 +18,199 @@
__fastcall TGauge::TGauge() __fastcall TGauge::TGauge()
{ {
eType=gt_Unknown; eType = gt_Unknown;
fFriction=0.0; fFriction = 0.0;
fDesiredValue=0.0; fDesiredValue = 0.0;
fValue=0.0; fValue = 0.0;
fOffset=0.0; fOffset = 0.0;
fScale=1.0; fScale = 1.0;
fStepSize=5; fStepSize = 5;
//iChannel=-1; //kana³ analogowej komunikacji zwrotnej // iChannel=-1; //kana³ analogowej komunikacji zwrotnej
SubModel=NULL; SubModel = NULL;
}; };
__fastcall TGauge::~TGauge() __fastcall TGauge::~TGauge(){};
{
};
void __fastcall TGauge::Clear() void __fastcall TGauge::Clear()
{ {
SubModel=NULL; SubModel = NULL;
eType=gt_Unknown; eType = gt_Unknown;
fValue=0; fValue = 0;
fDesiredValue=0; fDesiredValue = 0;
}; };
void __fastcall TGauge::Init(TSubModel *NewSubModel,TGaugeType eNewType,double fNewScale,double fNewOffset,double fNewFriction,double fNewValue) void __fastcall TGauge::Init(TSubModel *NewSubModel, TGaugeType eNewType, double fNewScale,
{//ustawienie parametrów animacji submodelu double fNewOffset, double fNewFriction, double fNewValue)
{ // ustawienie parametrów animacji submodelu
if (NewSubModel) if (NewSubModel)
{//warunek na wszelki wypadek, gdyby siê submodel nie pod³¹czy³ { // warunek na wszelki wypadek, gdyby siê submodel nie pod³¹czy³
fFriction=fNewFriction; fFriction = fNewFriction;
fValue=fNewValue; fValue = fNewValue;
fOffset=fNewOffset; fOffset = fNewOffset;
fScale=fNewScale; fScale = fNewScale;
SubModel=NewSubModel; SubModel = NewSubModel;
eType=eNewType; eType = eNewType;
if (eType==gt_Digital) if (eType == gt_Digital)
{ {
TSubModel *sm=SubModel->ChildGet(); TSubModel *sm = SubModel->ChildGet();
do do
{//pêtla po submodelach potomnych i obracanie ich o k¹t zale¿y od cyfry w (fValue) { // pêtla po submodelach potomnych i obracanie ich o k¹t zale¿y od cyfry w (fValue)
if (sm->pName) if (sm->pName)
{//musi mieæ niepust¹ nazwê { // musi mieæ niepust¹ nazwê
if ((*sm->pName)>='0') if ((*sm->pName) >= '0')
if ((*sm->pName)<='9') if ((*sm->pName) <= '9')
sm->WillBeAnimated(); //wy³¹czenie optymalizacji sm->WillBeAnimated(); // wy³¹czenie optymalizacji
} }
sm=sm->NextGet(); sm = sm->NextGet();
} while (sm); } while (sm);
} }
else //a banan mo¿e byæ z optymalizacj¹? else // a banan mo¿e byæ z optymalizacj¹?
NewSubModel->WillBeAnimated(); //wy³¹czenie ignowania jedynkowego transformu NewSubModel->WillBeAnimated(); // wy³¹czenie ignowania jedynkowego transformu
} }
}; };
bool __fastcall TGauge::Load(TQueryParserComp *Parser,TModel3d *md1,TModel3d *md2,double mul) bool __fastcall TGauge::Load(TQueryParserComp *Parser, TModel3d *md1, TModel3d *md2, double mul)
{ {
AnsiString str1=Parser->GetNextSymbol(); AnsiString str1 = Parser->GetNextSymbol();
AnsiString str2=Parser->GetNextSymbol().LowerCase(); AnsiString str2 = Parser->GetNextSymbol().LowerCase();
double val3=Parser->GetNextSymbol().ToDouble()*mul; double val3 = Parser->GetNextSymbol().ToDouble() * mul;
double val4=Parser->GetNextSymbol().ToDouble(); double val4 = Parser->GetNextSymbol().ToDouble();
double val5=Parser->GetNextSymbol().ToDouble(); double val5 = Parser->GetNextSymbol().ToDouble();
TSubModel *sm=md1->GetFromName(str1.c_str()); TSubModel *sm = md1->GetFromName(str1.c_str());
if (sm) //jeœli nie znaleziony if (sm) // jeœli nie znaleziony
md2=NULL; //informacja, ¿e znaleziony md2 = NULL; // informacja, ¿e znaleziony
else if (md2) // a jest podany drugi model (np. zewnêtrzny)
sm = md2->GetFromName(str1.c_str()); // to mo¿e tam bêdzie, co za ró¿nica gdzie
if (str2 == "mov")
Init(sm, gt_Move, val3, val4, val5);
else if (str2 == "wip")
Init(sm, gt_Wiper, val3, val4, val5);
else if (str2 == "dgt")
Init(sm, gt_Digital, val3, val4, val5);
else else
if (md2) //a jest podany drugi model (np. zewnêtrzny) Init(sm, gt_Rotate, val3, val4, val5);
sm=md2->GetFromName(str1.c_str()); //to mo¿e tam bêdzie, co za ró¿nica gdzie return (md2); // true, gdy podany model zewnêtrzny, a w kabinie nie by³o
if (str2=="mov")
Init(sm,gt_Move,val3,val4,val5);
else if (str2=="wip")
Init(sm,gt_Wiper,val3,val4,val5);
else if (str2=="dgt")
Init(sm,gt_Digital,val3,val4,val5);
else
Init(sm,gt_Rotate,val3,val4,val5);
return (md2); //true, gdy podany model zewnêtrzny, a w kabinie nie by³o
}; };
void __fastcall TGauge::PermIncValue(double fNewDesired) void __fastcall TGauge::PermIncValue(double fNewDesired)
{ {
fDesiredValue=fDesiredValue+fNewDesired*fScale+fOffset; fDesiredValue = fDesiredValue + fNewDesired * fScale + fOffset;
if (fDesiredValue-fOffset>360/fScale) if (fDesiredValue - fOffset > 360 / fScale)
{ {
fDesiredValue=fDesiredValue-(360/fScale); fDesiredValue = fDesiredValue - (360 / fScale);
fValue=fValue-(360/fScale); fValue = fValue - (360 / fScale);
} }
}; };
void __fastcall TGauge::IncValue(double fNewDesired) void __fastcall TGauge::IncValue(double fNewDesired)
{//u¿ywane tylko dla uniwersali { // u¿ywane tylko dla uniwersali
fDesiredValue=fDesiredValue+fNewDesired*fScale+fOffset; fDesiredValue = fDesiredValue + fNewDesired * fScale + fOffset;
if (fDesiredValue>fScale+fOffset) if (fDesiredValue > fScale + fOffset)
fDesiredValue=fScale+fOffset; fDesiredValue = fScale + fOffset;
}; };
void __fastcall TGauge::DecValue(double fNewDesired) void __fastcall TGauge::DecValue(double fNewDesired)
{//u¿ywane tylko dla uniwersali { // u¿ywane tylko dla uniwersali
fDesiredValue=fDesiredValue-fNewDesired*fScale+fOffset; fDesiredValue = fDesiredValue - fNewDesired * fScale + fOffset;
if (fDesiredValue<0) fDesiredValue=0; if (fDesiredValue < 0)
fDesiredValue = 0;
}; };
void __fastcall TGauge::UpdateValue(double fNewDesired) void __fastcall TGauge::UpdateValue(double fNewDesired)
{//ustawienie wartoœci docelowej { // ustawienie wartoœci docelowej
fDesiredValue=fNewDesired*fScale+fOffset; fDesiredValue = fNewDesired * fScale + fOffset;
}; };
void __fastcall TGauge::PutValue(double fNewDesired) void __fastcall TGauge::PutValue(double fNewDesired)
{//McZapkie-281102: natychmiastowe wpisanie wartosci { // McZapkie-281102: natychmiastowe wpisanie wartosci
fDesiredValue=fNewDesired*fScale+fOffset; fDesiredValue = fNewDesired * fScale + fOffset;
fValue=fDesiredValue; fValue = fDesiredValue;
}; };
void __fastcall TGauge::Update() void __fastcall TGauge::Update()
{ {
float dt=Timer::GetDeltaTime(); float dt = Timer::GetDeltaTime();
if ((fFriction>0)&&(dt<0.5*fFriction)) //McZapkie-281102: zabezpieczenie przed oscylacjami dla dlugich czasow if ((fFriction > 0) &&
fValue+=dt*(fDesiredValue-fValue)/fFriction; (dt <
0.5 * fFriction)) // McZapkie-281102: zabezpieczenie przed oscylacjami dla dlugich czasow
fValue += dt * (fDesiredValue - fValue) / fFriction;
else else
fValue=fDesiredValue; fValue = fDesiredValue;
if (SubModel) if (SubModel)
{//warunek na wszelki wypadek, gdyby siê submodel nie pod³¹czy³ { // warunek na wszelki wypadek, gdyby siê submodel nie pod³¹czy³
TSubModel *sm; TSubModel *sm;
switch (eType) switch (eType)
{ {
case gt_Rotate: case gt_Rotate:
SubModel->SetRotate(float3(0,1,0),fValue*360.0); SubModel->SetRotate(float3(0, 1, 0), fValue * 360.0);
break; break;
case gt_Move: case gt_Move:
SubModel->SetTranslate(float3(0,0,fValue)); SubModel->SetTranslate(float3(0, 0, fValue));
break; break;
case gt_Wiper: case gt_Wiper:
SubModel->SetRotate(float3(0,1,0),fValue*360.0); SubModel->SetRotate(float3(0, 1, 0), fValue * 360.0);
sm=SubModel->ChildGet(); sm = SubModel->ChildGet();
if (sm) if (sm)
{sm->SetRotate(float3(0,1,0),fValue*360.0); {
sm=sm->ChildGet(); sm->SetRotate(float3(0, 1, 0), fValue * 360.0);
sm = sm->ChildGet();
if (sm) if (sm)
sm->SetRotate(float3(0,1,0),fValue*360.0); sm->SetRotate(float3(0, 1, 0), fValue * 360.0);
} }
break; break;
case gt_Digital: //Ra 2014-07: licznik cyfrowy case gt_Digital: // Ra 2014-07: licznik cyfrowy
sm=SubModel->ChildGet(); sm = SubModel->ChildGet();
AnsiString n=FormatFloat("0000000000",floor(fValue)); //na razie tak trochê bez sensu AnsiString n = FormatFloat("0000000000", floor(fValue)); // na razie tak trochê bez
// sensu
do do
{//pêtla po submodelach potomnych i obracanie ich o k¹t zale¿y od cyfry w (fValue) { // pêtla po submodelach potomnych i obracanie ich o k¹t zale¿y od cyfry w (fValue)
if (sm->pName) if (sm->pName)
{//musi mieæ niepust¹ nazwê { // musi mieæ niepust¹ nazwê
if ((*sm->pName)>='0') if ((*sm->pName) >= '0')
if ((*sm->pName)<='9') if ((*sm->pName) <= '9')
sm->SetRotate(float3(0,1,0),-36.0*(n['0'+10-(*sm->pName)]-'0')); sm->SetRotate(float3(0, 1, 0),
-36.0 * (n['0' + 10 - (*sm->pName)] - '0'));
} }
sm=sm->NextGet(); sm = sm->NextGet();
} while (sm); } while (sm);
break; break;
} }
} }
}; };
void __fastcall TGauge::Render() void __fastcall TGauge::Render(){};
{
};
void __fastcall TGauge::AssignFloat(float* fValue) void __fastcall TGauge::AssignFloat(float *fValue)
{ {
cDataType='f'; cDataType = 'f';
fData=fValue; fData = fValue;
}; };
void __fastcall TGauge::AssignDouble(double* dValue) void __fastcall TGauge::AssignDouble(double *dValue)
{ {
cDataType='d'; cDataType = 'd';
dData=dValue; dData = dValue;
}; };
void __fastcall TGauge::AssignInt(int* iValue) void __fastcall TGauge::AssignInt(int *iValue)
{ {
cDataType='i'; cDataType = 'i';
iData=iValue; iData = iValue;
}; };
void __fastcall TGauge::UpdateValue() void __fastcall TGauge::UpdateValue()
{//ustawienie wartoœci docelowej z parametru { // ustawienie wartoœci docelowej z parametru
switch (cDataType) switch (cDataType)
{//to nie jest zbyt optymalne, mo¿na by zrobiæ osobne funkcje { // to nie jest zbyt optymalne, mo¿na by zrobiæ osobne funkcje
case 'f': case 'f':
fDesiredValue=(*fData)*fScale+fOffset; fDesiredValue = (*fData) * fScale + fOffset;
break; break;
case 'd': case 'd':
fDesiredValue=(*dData)*fScale+fOffset; fDesiredValue = (*dData) * fScale + fOffset;
break; break;
case 'i': case 'i':
fDesiredValue=(*iData)*fScale+fOffset; fDesiredValue = (*iData) * fScale + fOffset;
break; break;
} }
}; };
//--------------------------------------------------------------------------- //---------------------------------------------------------------------------
#pragma package(smart_init) #pragma package(smart_init)

65
Gauge.h
View File

@@ -5,57 +5,60 @@
//#include "Classes.h" //#include "Classes.h"
#include "QueryParserComp.hpp" #include "QueryParserComp.hpp"
//class Queryparsercomp::TQueryParserComp; // class Queryparsercomp::TQueryParserComp;
class TSubModel; class TSubModel;
class TModel3d; class TModel3d;
typedef enum typedef enum
{//typ ruchu { // typ ruchu
gt_Unknown, //na razie nie znany gt_Unknown, // na razie nie znany
gt_Rotate, //obrót gt_Rotate, // obrót
gt_Move, //przesuniêcie równoleg³e gt_Move, // przesuniêcie równoleg³e
gt_Wiper, //obrót trzech kolejnych submodeli o ten sam k¹t (np. wycieraczka, drzwi harmonijkowe) gt_Wiper, // obrót trzech kolejnych submodeli o ten sam k¹t (np. wycieraczka, drzwi
gt_Digital //licznik cyfrowy, np. kilometrów // harmonijkowe)
gt_Digital // licznik cyfrowy, np. kilometrów
} TGaugeType; } TGaugeType;
class TGauge //zmienne "gg" class TGauge // zmienne "gg"
{//animowany wskaŸnik, mog¹cy przyjmowaæ wiele stanów poœrednich { // animowany wskaŸnik, mog¹cy przyjmowaæ wiele stanów poœrednich
private: private:
TGaugeType eType; //typ ruchu TGaugeType eType; // typ ruchu
double fFriction; //hamowanie przy zli¿aniu siê do zadanej wartoœci double fFriction; // hamowanie przy zli¿aniu siê do zadanej wartoœci
double fDesiredValue; //wartoϾ docelowa double fDesiredValue; // wartoϾ docelowa
double fValue; //wartoϾ obecna double fValue; // wartoϾ obecna
double fOffset; //wartoœæ pocz¹tkowa ("0") double fOffset; // wartoœæ pocz¹tkowa ("0")
double fScale; //wartoœæ koñcowa ("1") double fScale; // wartoœæ koñcowa ("1")
double fStepSize; //nie u¿ywane double fStepSize; // nie u¿ywane
char cDataType; //typ zmiennej parametru: f-float, d-double, i-int char cDataType; // typ zmiennej parametru: f-float, d-double, i-int
union union
{//wskaŸnik na parametr pokazywany przez animacjê { // wskaŸnik na parametr pokazywany przez animacjê
float* fData; float *fData;
double* dData; double *dData;
int* iData; int *iData;
}; };
public:
public:
__fastcall TGauge(); __fastcall TGauge();
__fastcall ~TGauge(); __fastcall ~TGauge();
void __fastcall Clear(); void __fastcall Clear();
void __fastcall Init(TSubModel *NewSubModel,TGaugeType eNewTyp,double fNewScale=1,double fNewOffset=0,double fNewFriction=0,double fNewValue=0); void __fastcall Init(TSubModel *NewSubModel, TGaugeType eNewTyp, double fNewScale = 1,
bool __fastcall Load(TQueryParserComp *Parser,TModel3d *md1,TModel3d *md2=NULL,double mul=1.0); double fNewOffset = 0, double fNewFriction = 0, double fNewValue = 0);
bool __fastcall Load(TQueryParserComp *Parser, TModel3d *md1, TModel3d *md2 = NULL,
double mul = 1.0);
void __fastcall PermIncValue(double fNewDesired); void __fastcall PermIncValue(double fNewDesired);
void __fastcall IncValue(double fNewDesired); void __fastcall IncValue(double fNewDesired);
void __fastcall DecValue(double fNewDesired); void __fastcall DecValue(double fNewDesired);
void __fastcall UpdateValue(double fNewDesired); void __fastcall UpdateValue(double fNewDesired);
void __fastcall PutValue(double fNewDesired); void __fastcall PutValue(double fNewDesired);
float GetValue() {return fValue;}; float GetValue() { return fValue; };
void __fastcall Update(); void __fastcall Update();
void __fastcall Render(); void __fastcall Render();
void __fastcall AssignFloat(float* fValue); void __fastcall AssignFloat(float *fValue);
void __fastcall AssignDouble(double* dValue); void __fastcall AssignDouble(double *dValue);
void __fastcall AssignInt(int* iValue); void __fastcall AssignInt(int *iValue);
void __fastcall UpdateValue(); void __fastcall UpdateValue();
TSubModel *SubModel; //McZapkie-310302: zeby mozna bylo sprawdzac czy zainicjowany poprawnie TSubModel *SubModel; // McZapkie-310302: zeby mozna bylo sprawdzac czy zainicjowany poprawnie
}; };
//--------------------------------------------------------------------------- //---------------------------------------------------------------------------
#endif #endif

137
Geom.cpp
View File

@@ -12,108 +12,101 @@
#include "Globals.h" #include "Globals.h"
#include "Geom.h" #include "Geom.h"
__fastcall TGeometry::TGeometry() {}
__fastcall TGeometry::TGeometry() __fastcall TGeometry::~TGeometry() {}
{
}
__fastcall TGeometry::~TGeometry()
{
}
bool __fastcall TGeometry::Init()
{
}
bool __fastcall TGeometry::Init() {}
vector3 __fastcall TGeometry::Load(TQueryParserComp *Parser) vector3 __fastcall TGeometry::Load(TQueryParserComp *Parser)
{ {
str= Parser->GetNextSymbol().LowerCase(); str = Parser->GetNextSymbol().LowerCase();
tmp->TextureID= TTexturesManager::GetTextureID(str.c_str()); tmp->TextureID = TTexturesManager::GetTextureID(str.c_str());
i=0; i = 0;
do do
{ {
tf= Parser->GetNextSymbol().ToDouble(); tf = Parser->GetNextSymbol().ToDouble();
TempVerts[i].Point.x= tf; TempVerts[i].Point.x = tf;
tf= Parser->GetNextSymbol().ToDouble(); tf = Parser->GetNextSymbol().ToDouble();
TempVerts[i].Point.y= tf; TempVerts[i].Point.y = tf;
tf= Parser->GetNextSymbol().ToDouble(); tf = Parser->GetNextSymbol().ToDouble();
TempVerts[i].Point.z= tf; TempVerts[i].Point.z = tf;
tf= Parser->GetNextSymbol().ToDouble(); tf = Parser->GetNextSymbol().ToDouble();
TempVerts[i].Normal.x= tf; TempVerts[i].Normal.x = tf;
tf= Parser->GetNextSymbol().ToDouble(); tf = Parser->GetNextSymbol().ToDouble();
TempVerts[i].Normal.y= tf; TempVerts[i].Normal.y = tf;
tf= Parser->GetNextSymbol().ToDouble(); tf = Parser->GetNextSymbol().ToDouble();
TempVerts[i].Normal.z= tf; TempVerts[i].Normal.z = tf;
str= Parser->GetNextSymbol().LowerCase(); str = Parser->GetNextSymbol().LowerCase();
if (str=="x") if (str == "x")
TempVerts[i].tu= (TempVerts[i].Point.x+Parser->GetNextSymbol().ToDouble())/Parser->GetNextSymbol().ToDouble(); TempVerts[i].tu = (TempVerts[i].Point.x + Parser->GetNextSymbol().ToDouble()) /
Parser->GetNextSymbol().ToDouble();
else if (str == "y")
TempVerts[i].tu = (TempVerts[i].Point.y + Parser->GetNextSymbol().ToDouble()) /
Parser->GetNextSymbol().ToDouble();
else if (str == "z")
TempVerts[i].tu = (TempVerts[i].Point.z + Parser->GetNextSymbol().ToDouble()) /
Parser->GetNextSymbol().ToDouble();
else else
if (str=="y") TempVerts[i].tu = str.ToDouble();
TempVerts[i].tu= (TempVerts[i].Point.y+Parser->GetNextSymbol().ToDouble())/Parser->GetNextSymbol().ToDouble(); ;
else
if (str=="z")
TempVerts[i].tu= (TempVerts[i].Point.z+Parser->GetNextSymbol().ToDouble())/Parser->GetNextSymbol().ToDouble();
else
TempVerts[i].tu= str.ToDouble();;
str= Parser->GetNextSymbol().LowerCase(); str = Parser->GetNextSymbol().LowerCase();
if (str=="x") if (str == "x")
TempVerts[i].tv= (TempVerts[i].Point.x+Parser->GetNextSymbol().ToDouble())/Parser->GetNextSymbol().ToDouble(); TempVerts[i].tv = (TempVerts[i].Point.x + Parser->GetNextSymbol().ToDouble()) /
Parser->GetNextSymbol().ToDouble();
else if (str == "y")
TempVerts[i].tv = (TempVerts[i].Point.y + Parser->GetNextSymbol().ToDouble()) /
Parser->GetNextSymbol().ToDouble();
else if (str == "z")
TempVerts[i].tv = (TempVerts[i].Point.z + Parser->GetNextSymbol().ToDouble()) /
Parser->GetNextSymbol().ToDouble();
else else
if (str=="y") TempVerts[i].tv = str.ToDouble();
TempVerts[i].tv= (TempVerts[i].Point.y+Parser->GetNextSymbol().ToDouble())/Parser->GetNextSymbol().ToDouble(); ;
else
if (str=="z")
TempVerts[i].tv= (TempVerts[i].Point.z+Parser->GetNextSymbol().ToDouble())/Parser->GetNextSymbol().ToDouble();
else
TempVerts[i].tv= str.ToDouble();;
// tf= Parser->GetNextSymbol().ToDouble(); // tf= Parser->GetNextSymbol().ToDouble();
// TempVerts[i].tu= tf; // TempVerts[i].tu= tf;
// tf= Parser->GetNextSymbol().ToDouble(); // tf= Parser->GetNextSymbol().ToDouble();
// TempVerts[i].tv= tf; // TempVerts[i].tv= tf;
TempVerts[i].Point.RotateZ(aRotate.z/180*M_PI); TempVerts[i].Point.RotateZ(aRotate.z / 180 * M_PI);
TempVerts[i].Point.RotateX(aRotate.x/180*M_PI); TempVerts[i].Point.RotateX(aRotate.x / 180 * M_PI);
TempVerts[i].Point.RotateY(aRotate.y/180*M_PI); TempVerts[i].Point.RotateY(aRotate.y / 180 * M_PI);
TempVerts[i].Normal.RotateZ(aRotate.z/180*M_PI); TempVerts[i].Normal.RotateZ(aRotate.z / 180 * M_PI);
TempVerts[i].Normal.RotateX(aRotate.x/180*M_PI); TempVerts[i].Normal.RotateX(aRotate.x / 180 * M_PI);
TempVerts[i].Normal.RotateY(aRotate.y/180*M_PI); TempVerts[i].Normal.RotateY(aRotate.y / 180 * M_PI);
TempVerts[i].Point+= pOrigin; TempVerts[i].Point += pOrigin;
tmp->pCenter+= TempVerts[i].Point; tmp->pCenter += TempVerts[i].Point;
i++; i++;
// } // }
} while ( Parser->GetNextSymbol().LowerCase()!="endtri" ); } while (Parser->GetNextSymbol().LowerCase() != "endtri");
nv= i; nv = i;
tmp->Init(nv); tmp->Init(nv);
tmp->pCenter/= (nv>0?nv:1); tmp->pCenter /= (nv > 0 ? nv : 1);
// memcpy(tmp->Vertices,TempVerts,nv*sizeof(TGroundVertex)); // memcpy(tmp->Vertices,TempVerts,nv*sizeof(TGroundVertex));
r= 0; r = 0;
for (int i=0; i<nv; i++) for (int i = 0; i < nv; i++)
{ {
tmp->Vertices[i]= TempVerts[i]; tmp->Vertices[i] = TempVerts[i];
tf= SquareMagnitude(tmp->Vertices[i].Point-tmp->pCenter); tf = SquareMagnitude(tmp->Vertices[i].Point - tmp->pCenter);
if (tf>r) if (tf > r)
r= tf; r = tf;
} }
// tmp->fSquareRadius= 2000*2000+r; // tmp->fSquareRadius= 2000*2000+r;
tmp->fSquareRadius+= r; tmp->fSquareRadius += r;
} }
bool __fastcall TGeometry::Render() bool __fastcall TGeometry::Render() {}
{
}
//--------------------------------------------------------------------------- //---------------------------------------------------------------------------
#pragma package(smart_init) #pragma package(smart_init)

7
Geom.h
View File

@@ -10,12 +10,12 @@ struct TGeomVertex
{ {
vector3 Point; vector3 Point;
vector3 Normal; vector3 Normal;
double tu,tv; double tu, tv;
}; };
class TGeometry class TGeometry
{ {
private: private:
GLuint iType; GLuint iType;
union union
{ {
@@ -26,7 +26,8 @@ private:
TMaterialColor Ambient; TMaterialColor Ambient;
TMaterialColor Diffuse; TMaterialColor Diffuse;
TMaterialColor Specular; TMaterialColor Specular;
public:
public:
__fastcall TGeometry(); __fastcall TGeometry();
__fastcall ~TGeometry(); __fastcall ~TGeometry();
bool __fastcall Init(); bool __fastcall Init();

1195
Globals.cpp
View File

File diff suppressed because it is too large Load Diff

377
Globals.h
View File

@@ -11,152 +11,155 @@
using namespace Math3D; using namespace Math3D;
//definicje klawiszy // definicje klawiszy
const int k_IncMainCtrl= 0; //[Num+] const int k_IncMainCtrl = 0; //[Num+]
const int k_IncMainCtrlFAST= 1; //[Num+] [Shift] const int k_IncMainCtrlFAST = 1; //[Num+] [Shift]
const int k_DecMainCtrl= 2; //[Num-] const int k_DecMainCtrl = 2; //[Num-]
const int k_DecMainCtrlFAST= 3; //[Num-] [Shift] const int k_DecMainCtrlFAST = 3; //[Num-] [Shift]
const int k_IncScndCtrl= 4; //[Num/] const int k_IncScndCtrl = 4; //[Num/]
const int k_IncScndCtrlFAST= 5; const int k_IncScndCtrlFAST = 5;
const int k_DecScndCtrl= 6; const int k_DecScndCtrl = 6;
const int k_DecScndCtrlFAST= 7; const int k_DecScndCtrlFAST = 7;
const int k_IncLocalBrakeLevel= 8; const int k_IncLocalBrakeLevel = 8;
const int k_IncLocalBrakeLevelFAST= 9; const int k_IncLocalBrakeLevelFAST = 9;
const int k_DecLocalBrakeLevel=10 ; const int k_DecLocalBrakeLevel = 10;
const int k_DecLocalBrakeLevelFAST= 11; const int k_DecLocalBrakeLevelFAST = 11;
const int k_IncBrakeLevel= 12; const int k_IncBrakeLevel = 12;
const int k_DecBrakeLevel= 13; const int k_DecBrakeLevel = 13;
const int k_Releaser= 14; const int k_Releaser = 14;
const int k_EmergencyBrake= 15; const int k_EmergencyBrake = 15;
const int k_Brake3= 16; const int k_Brake3 = 16;
const int k_Brake2= 17; const int k_Brake2 = 17;
const int k_Brake1= 18; const int k_Brake1 = 18;
const int k_Brake0= 19; const int k_Brake0 = 19;
const int k_WaveBrake= 20; const int k_WaveBrake = 20;
const int k_AntiSlipping= 21; const int k_AntiSlipping = 21;
const int k_Sand= 22; const int k_Sand = 22;
const int k_Main= 23; const int k_Main = 23;
const int k_DirectionForward= 24; const int k_DirectionForward = 24;
const int k_DirectionBackward= 25; const int k_DirectionBackward = 25;
const int k_Fuse= 26; const int k_Fuse = 26;
const int k_Compressor= 27; const int k_Compressor = 27;
const int k_Converter= 28; const int k_Converter = 28;
const int k_MaxCurrent= 29; const int k_MaxCurrent = 29;
const int k_CurrentAutoRelay= 30; const int k_CurrentAutoRelay = 30;
const int k_BrakeProfile= 31; const int k_BrakeProfile = 31;
const int k_Czuwak= 32; const int k_Czuwak = 32;
const int k_Horn= 33; const int k_Horn = 33;
const int k_Horn2= 34; const int k_Horn2 = 34;
const int k_FailedEngineCutOff= 35; const int k_FailedEngineCutOff = 35;
const int k_MechUp= 36; const int k_MechUp = 36;
const int k_MechDown= 37; const int k_MechDown = 37;
const int k_MechLeft= 38; const int k_MechLeft = 38;
const int k_MechRight= 39; const int k_MechRight = 39;
const int k_MechForward= 40; const int k_MechForward = 40;
const int k_MechBackward= 41; const int k_MechBackward = 41;
const int k_CabForward= 42; const int k_CabForward = 42;
const int k_CabBackward= 43; const int k_CabBackward = 43;
const int k_Couple= 44; const int k_Couple = 44;
const int k_DeCouple= 45; const int k_DeCouple = 45;
const int k_ProgramQuit= 46; const int k_ProgramQuit = 46;
//const int k_ProgramPause= 47; // const int k_ProgramPause= 47;
const int k_ProgramHelp= 48; const int k_ProgramHelp = 48;
//NBMX // NBMX
const int k_OpenLeft= 49; const int k_OpenLeft = 49;
const int k_OpenRight= 50; const int k_OpenRight = 50;
const int k_CloseLeft= 51; const int k_CloseLeft = 51;
const int k_CloseRight= 52; const int k_CloseRight = 52;
const int k_DepartureSignal= 53; const int k_DepartureSignal = 53;
//NBMX // NBMX
const int k_PantFrontUp= 54; const int k_PantFrontUp = 54;
const int k_PantRearUp= 55; const int k_PantRearUp = 55;
const int k_PantFrontDown= 56; const int k_PantFrontDown = 56;
const int k_PantRearDown= 57; const int k_PantRearDown = 57;
const int k_Heating= 58; const int k_Heating = 58;
//const int k_FreeFlyMode= 59; // const int k_FreeFlyMode= 59;
const int k_LeftSign = 60; const int k_LeftSign = 60;
const int k_UpperSign= 61; const int k_UpperSign = 61;
const int k_RightSign= 62; const int k_RightSign = 62;
const int k_SmallCompressor= 63; const int k_SmallCompressor = 63;
const int k_StLinOff= 64; const int k_StLinOff = 64;
const int k_CurrentNext=65; const int k_CurrentNext = 65;
const int k_Univ1=66; const int k_Univ1 = 66;
const int k_Univ2=67; const int k_Univ2 = 67;
const int k_Univ3=68; const int k_Univ3 = 68;
const int k_Univ4=69; const int k_Univ4 = 69;
const int k_EndSign=70; const int k_EndSign = 70;
const int k_Active=71; const int k_Active = 71;
//Winger 020304 // Winger 020304
const int k_Battery=72; const int k_Battery = 72;
const int k_WalkMode=73; const int k_WalkMode = 73;
const int MaxKeys= 74; const int MaxKeys = 74;
//klasy dla wskaŸników globalnych // klasy dla wskaŸników globalnych
class TGround; class TGround;
class TWorld; class TWorld;
class TCamera; class TCamera;
class TDynamicObject; class TDynamicObject;
class TAnimModel; //obiekt terenu class TAnimModel; // obiekt terenu
namespace Queryparsercomp namespace Queryparsercomp
{ {
class TQueryParserComp; //stary(?) parser class TQueryParserComp; // stary(?) parser
} }
class cParser; //nowy (powolny!) parser class cParser; // nowy (powolny!) parser
class TEvent; class TEvent;
class TTextSound; class TTextSound;
class TTranscript class TTranscript
{//klasa obs³uguj¹ca linijkê napisu do dŸwiêku { // klasa obs³uguj¹ca linijkê napisu do dŸwiêku
public: public:
float fShow; //czas pokazania float fShow; // czas pokazania
float fHide; //czas ukrycia/usuniêcia float fHide; // czas ukrycia/usuniêcia
AnsiString asText; //tekst gotowy do wyœwietlenia (usuniête znaczniki czasu) AnsiString asText; // tekst gotowy do wyœwietlenia (usuniête znaczniki czasu)
bool bItalic; //czy kursywa (dŸwiêk nieistotny dla prowadz¹cego) bool bItalic; // czy kursywa (dŸwiêk nieistotny dla prowadz¹cego)
int iNext; //nastêpna u¿ywana linijka, ¿eby nie przestawiaæ fizycznie tabeli int iNext; // nastêpna u¿ywana linijka, ¿eby nie przestawiaæ fizycznie tabeli
}; };
#define MAX_TRANSCRIPTS 30 #define MAX_TRANSCRIPTS 30
class TTranscripts class TTranscripts
{//klasa obs³uguj¹ca napisy do dŸwiêków { // klasa obs³uguj¹ca napisy do dŸwiêków
TTranscript aLines[MAX_TRANSCRIPTS]; //pozycje na napisy do wyœwietlenia TTranscript aLines[MAX_TRANSCRIPTS]; // pozycje na napisy do wyœwietlenia
int iCount; //liczba zajêtych pozycji int iCount; // liczba zajêtych pozycji
int iStart; //pierwsza istotna pozycja w tabeli, ¿eby sortowaæ przestawiaj¹c numerki int iStart; // pierwsza istotna pozycja w tabeli, ¿eby sortowaæ przestawiaj¹c numerki
float fRefreshTime; float fRefreshTime;
public:
public:
__fastcall TTranscripts(); __fastcall TTranscripts();
__fastcall ~TTranscripts(); __fastcall ~TTranscripts();
void __fastcall AddLine(char *txt,float show,float hide,bool it); void __fastcall AddLine(char *txt, float show, float hide, bool it);
void __fastcall Add(char *txt,float len,bool backgorund=false); //dodanie tekstów, d³ugoœæ dŸwiêku, czy istotne void __fastcall Add(char *txt, float len,
void __fastcall Update(); //usuwanie niepotrzebnych (ok. 10 razy na sekundê) bool backgorund = false); // dodanie tekstów, d³ugoœæ dŸwiêku, czy istotne
void __fastcall Update(); // usuwanie niepotrzebnych (ok. 10 razy na sekundê)
}; };
class Global class Global
{ {
private: private:
static GLuint iTextureId; //ostatnio u¿yta tekstura 2D static GLuint iTextureId; // ostatnio u¿yta tekstura 2D
public: public:
//double Global::tSinceStart; // double Global::tSinceStart;
static int Keys[MaxKeys]; static int Keys[MaxKeys];
static vector3 pCameraPosition; //pozycja kamery w œwiecie static vector3 pCameraPosition; // pozycja kamery w œwiecie
static double pCameraRotation; //kierunek bezwzglêdny kamery w œwiecie: 0=pó³noc, 90°=zachód (-azymut) static double
static double pCameraRotationDeg; //w stopniach, dla animacji billboard pCameraRotation; // kierunek bezwzglêdny kamery w œwiecie: 0=pó³noc, 90°=zachód (-azymut)
static vector3 pFreeCameraInit[10]; //pozycje kamery static double pCameraRotationDeg; // w stopniach, dla animacji billboard
static vector3 pFreeCameraInit[10]; // pozycje kamery
static vector3 pFreeCameraInitAngle[10]; static vector3 pFreeCameraInitAngle[10];
static int iWindowWidth; static int iWindowWidth;
static int iWindowHeight; static int iWindowHeight;
@@ -164,11 +167,11 @@ public:
static int iBpp; static int iBpp;
static bool bFullScreen; static bool bFullScreen;
static bool bFreeFly; static bool bFreeFly;
//float RunningTime; // float RunningTime;
static bool bWireFrame; static bool bWireFrame;
static bool bSoundEnabled; static bool bSoundEnabled;
//McZapkie-131202 // McZapkie-131202
//static bool bRenderAlpha; // static bool bRenderAlpha;
static bool bAdjustScreenFreq; static bool bAdjustScreenFreq;
static bool bEnableTraction; static bool bEnableTraction;
static bool bLoadTraction; static bool bLoadTraction;
@@ -182,7 +185,7 @@ public:
static double fFogStart; static double fFogStart;
static double fFogEnd; static double fFogEnd;
static TGround *pGround; static TGround *pGround;
static char** szDefaultExt; static char **szDefaultExt;
static char szSceneryFile[256]; static char szSceneryFile[256];
static char CreatorName1[20]; static char CreatorName1[20];
static char CreatorName2[20]; static char CreatorName2[20];
@@ -192,19 +195,18 @@ public:
static AnsiString asCurrentSceneryPath; static AnsiString asCurrentSceneryPath;
static AnsiString asCurrentTexturePath; static AnsiString asCurrentTexturePath;
static AnsiString asCurrentDynamicPath; static AnsiString asCurrentDynamicPath;
//McZapkie-170602: zewnetrzna definicja pojazdu uzytkownika // McZapkie-170602: zewnetrzna definicja pojazdu uzytkownika
static AnsiString asHumanCtrlVehicle; static AnsiString asHumanCtrlVehicle;
static void __fastcall LoadIniFile(AnsiString asFileName); static void __fastcall LoadIniFile(AnsiString asFileName);
static void __fastcall InitKeys(AnsiString asFileName); static void __fastcall InitKeys(AnsiString asFileName);
inline static vector3 __fastcall GetCameraPosition() inline static vector3 __fastcall GetCameraPosition() { return pCameraPosition; };
{return pCameraPosition;};
static void __fastcall SetCameraPosition(vector3 pNewCameraPosition); static void __fastcall SetCameraPosition(vector3 pNewCameraPosition);
static void __fastcall SetCameraRotation(double Yaw); static void __fastcall SetCameraRotation(double Yaw);
static int iWriteLogEnabled; //maska bitowa: 1-zapis do pliku, 2-okienko static int iWriteLogEnabled; // maska bitowa: 1-zapis do pliku, 2-okienko
//McZapkie-221002: definicja swiatla dziennego // McZapkie-221002: definicja swiatla dziennego
static GLfloat AtmoColor[]; static GLfloat AtmoColor[];
static GLfloat FogColor[]; static GLfloat FogColor[];
//static bool bTimeChange; // static bool bTimeChange;
static GLfloat ambientDayLight[]; static GLfloat ambientDayLight[];
static GLfloat diffuseDayLight[]; static GLfloat diffuseDayLight[];
static GLfloat specularDayLight[]; static GLfloat specularDayLight[];
@@ -221,85 +223,86 @@ public:
static bool detonatoryOK; static bool detonatoryOK;
static AnsiString asSky; static AnsiString asSky;
static bool bnewAirCouplers; static bool bnewAirCouplers;
//Ra: nowe zmienne globalne // Ra: nowe zmienne globalne
static int iDefaultFiltering; //domyœlne rozmywanie tekstur TGA static int iDefaultFiltering; // domyœlne rozmywanie tekstur TGA
static int iBallastFiltering; //domyœlne rozmywanie tekstury podsypki static int iBallastFiltering; // domyœlne rozmywanie tekstury podsypki
static int iRailProFiltering; //domyœlne rozmywanie tekstury szyn static int iRailProFiltering; // domyœlne rozmywanie tekstury szyn
static int iDynamicFiltering; //domyœlne rozmywanie tekstur pojazdów static int iDynamicFiltering; // domyœlne rozmywanie tekstur pojazdów
static int iReCompile; //zwiêkszany, gdy trzeba odœwie¿yæ siatki static int iReCompile; // zwiêkszany, gdy trzeba odœwie¿yæ siatki
static bool bUseVBO; //czy jest VBO w karcie graficznej static bool bUseVBO; // czy jest VBO w karcie graficznej
static int iFeedbackMode; //tryb pracy informacji zwrotnej static int iFeedbackMode; // tryb pracy informacji zwrotnej
static int iFeedbackPort; //dodatkowy adres dla informacji zwrotnych static int iFeedbackPort; // dodatkowy adres dla informacji zwrotnych
static double fOpenGL; //wersja OpenGL - przyda siê static double fOpenGL; // wersja OpenGL - przyda siê
static bool bOpenGL_1_5; //czy s¹ dostêpne funkcje OpenGL 1.5 static bool bOpenGL_1_5; // czy s¹ dostêpne funkcje OpenGL 1.5
static double fLuminance; //jasnoœæ œwiat³a do automatycznego zapalania static double fLuminance; // jasnoœæ œwiat³a do automatycznego zapalania
static int iMultiplayer; //blokada dzia³ania niektórych eventów na rzecz kominikacji static int iMultiplayer; // blokada dzia³ania niektórych eventów na rzecz kominikacji
static HWND hWnd; //uchwyt okna static HWND hWnd; // uchwyt okna
static int iCameraLast; static int iCameraLast;
static AnsiString asRelease; //numer static AnsiString asRelease; // numer
static AnsiString asVersion; //z opisem static AnsiString asVersion; // z opisem
static int iViewMode; //co aktualnie widaæ: 0-kabina, 1-latanie, 2-sprzêgi, 3-dokumenty, 4-obwody static int
static GLint iMaxTextureSize; //maksymalny rozmiar tekstury iViewMode; // co aktualnie widaæ: 0-kabina, 1-latanie, 2-sprzêgi, 3-dokumenty, 4-obwody
static int iTextMode; //tryb pracy wyœwietlacza tekstowego static GLint iMaxTextureSize; // maksymalny rozmiar tekstury
static int iScreenMode[12]; //numer ekranu wyœwietlacza tekstowego static int iTextMode; // tryb pracy wyœwietlacza tekstowego
static bool bDoubleAmbient; //podwójna jasnoœæ ambient static int iScreenMode[12]; // numer ekranu wyœwietlacza tekstowego
static double fMoveLight; //numer dnia w roku albo -1 static bool bDoubleAmbient; // podwójna jasnoœæ ambient
static bool bSmoothTraction; //wyg³adzanie drutów static double fMoveLight; // numer dnia w roku albo -1
static double fSunDeclination; //deklinacja S³oñca static bool bSmoothTraction; // wyg³adzanie drutów
static double fTimeSpeed; //przyspieszenie czasu, zmienna do testów static double fSunDeclination; // deklinacja S³oñca
static double fTimeAngleDeg; //godzina w postaci k¹ta static double fTimeSpeed; // przyspieszenie czasu, zmienna do testów
static float fClockAngleDeg[6]; //k¹ty obrotu cylindrów dla zegara cyfrowego static double fTimeAngleDeg; // godzina w postaci k¹ta
static double fLatitudeDeg; //szerokoœæ geograficzna static float fClockAngleDeg[6]; // k¹ty obrotu cylindrów dla zegara cyfrowego
static char* szTexturesTGA[4]; //lista tekstur od TGA static double fLatitudeDeg; // szerokoϾ geograficzna
static char* szTexturesDDS[4]; //lista tekstur od DDS static char *szTexturesTGA[4]; // lista tekstur od TGA
static int iMultisampling; //tryb antyaliasingu: 0=brak,1=2px,2=4px,3=8px,4=16px static char *szTexturesDDS[4]; // lista tekstur od DDS
static bool bGlutFont; //tekst generowany przez GLUT static int iMultisampling; // tryb antyaliasingu: 0=brak,1=2px,2=4px,3=8px,4=16px
static int iKeyLast; //ostatnio naciœniêty klawisz w celu logowania static bool bGlutFont; // tekst generowany przez GLUT
static int iPause; //globalna pauza ruchu: b0=start,b1=klawisz,b2=t³o,b3=lagi,b4=wczytywanie static int iKeyLast; // ostatnio naciœniêty klawisz w celu logowania
static bool bActive; //czy jest aktywnym oknem static int iPause; // globalna pauza ruchu: b0=start,b1=klawisz,b2=t³o,b3=lagi,b4=wczytywanie
static bool bActive; // czy jest aktywnym oknem
static void __fastcall BindTexture(GLuint t); static void __fastcall BindTexture(GLuint t);
static int iConvertModels; //tworzenie plików binarnych static int iConvertModels; // tworzenie plików binarnych
static int iErorrCounter; //licznik sprawdzañ do œledzenia b³êdów OpenGL static int iErorrCounter; // licznik sprawdzañ do œledzenia b³êdów OpenGL
static bool bInactivePause; //automatyczna pauza, gdy okno nieaktywne static bool bInactivePause; // automatyczna pauza, gdy okno nieaktywne
static int iTextures; //licznik u¿ytych tekstur static int iTextures; // licznik u¿ytych tekstur
static int iSlowMotionMask; //maska wy³¹czanych w³aœciwoœci static int iSlowMotionMask; // maska wy³¹czanych w³aœciwoœci
static int iModifyTGA; //czy korygowaæ pliki TGA dla szybszego wczytywania static int iModifyTGA; // czy korygowaæ pliki TGA dla szybszego wczytywania
static bool bHideConsole; //hunter-271211: ukrywanie konsoli static bool bHideConsole; // hunter-271211: ukrywanie konsoli
static TWorld *pWorld; //wskaŸnik na œwiat do usuwania pojazdów static TWorld *pWorld; // wskaŸnik na œwiat do usuwania pojazdów
static TAnimModel *pTerrainCompact; //obiekt terenu do ewentualnego zapisania w pliku static TAnimModel *pTerrainCompact; // obiekt terenu do ewentualnego zapisania w pliku
static AnsiString asTerrainModel; //nazwa obiektu terenu do zapisania w pliku static AnsiString asTerrainModel; // nazwa obiektu terenu do zapisania w pliku
static bool bRollFix; //czy wykonaæ przeliczanie przechy³ki static bool bRollFix; // czy wykonaæ przeliczanie przechy³ki
static Queryparsercomp::TQueryParserComp *qParser; static Queryparsercomp::TQueryParserComp *qParser;
static cParser *pParser; static cParser *pParser;
static int iSegmentsRendered; //iloœæ segmentów do regulacji wydajnoœci static int iSegmentsRendered; // iloœæ segmentów do regulacji wydajnoœci
static double fFpsAverage; //oczekiwana wartosæ FPS static double fFpsAverage; // oczekiwana wartosæ FPS
static double fFpsDeviation; //odchylenie standardowe FPS static double fFpsDeviation; // odchylenie standardowe FPS
static double fFpsMin; //dolna granica FPS, przy której promieñ scenerii bêdzie zmniejszany static double fFpsMin; // dolna granica FPS, przy której promieñ scenerii bêdzie zmniejszany
static double fFpsMax; //górna granica FPS, przy której promieñ scenerii bêdzie zwiêkszany static double fFpsMax; // górna granica FPS, przy której promieñ scenerii bêdzie zwiêkszany
static double fFpsRadiusMax; //maksymalny promieñ renderowania static double fFpsRadiusMax; // maksymalny promieñ renderowania
static int iFpsRadiusMax; //maksymalny promieñ renderowania w rozmiarze tabeli sektorów static int iFpsRadiusMax; // maksymalny promieñ renderowania w rozmiarze tabeli sektorów
static double fRadiusFactor; //wspó³czynnik zmiany promienia static double fRadiusFactor; // wspó³czynnik zmiany promienia
static TCamera *pCamera; //parametry kamery static TCamera *pCamera; // parametry kamery
static TDynamicObject *pUserDynamic; //pojazd u¿ytkownika, renderowany bez trzêsienia static TDynamicObject *pUserDynamic; // pojazd u¿ytkownika, renderowany bez trzêsienia
static double fCalibrateIn[6][4]; //parametry kalibracyjne wejϾ z pulpitu static double fCalibrateIn[6][4]; // parametry kalibracyjne wejϾ z pulpitu
static double fCalibrateOut[7][4]; //parametry kalibracyjne wyjϾ dla pulpitu static double fCalibrateOut[7][4]; // parametry kalibracyjne wyjϾ dla pulpitu
static double fBrakeStep; //krok zmiany hamulca dla klawiszy [Num3] i [Num9] static double fBrakeStep; // krok zmiany hamulca dla klawiszy [Num3] i [Num9]
static bool bJoinEvents; //czy grupowaæ eventy o tych samych nazwach static bool bJoinEvents; // czy grupowaæ eventy o tych samych nazwach
static bool bSmudge; //czy wyœwietlaæ smugê, a pojazd u¿ytkownika na koñcu static bool bSmudge; // czy wyœwietlaæ smugê, a pojazd u¿ytkownika na koñcu
static AnsiString asTranscript[5]; //napisy na ekranie (widoczne) static AnsiString asTranscript[5]; // napisy na ekranie (widoczne)
static TTranscripts tranTexts; //obiekt obs³uguj¹cy stenogramy dŸwiêków na ekranie static TTranscripts tranTexts; // obiekt obs³uguj¹cy stenogramy dŸwiêków na ekranie
static AnsiString asLang; //domyœlny jêzyk - http://tools.ietf.org/html/bcp47 static AnsiString asLang; // domyœlny jêzyk - http://tools.ietf.org/html/bcp47
static int iHiddenEvents; //czy ³¹czyæ eventy z torami poprzez nazwê toru static int iHiddenEvents; // czy ³¹czyæ eventy z torami poprzez nazwê toru
static TTextSound *tsRadioBusy[10]; //zajêtoœæ kana³ów radiowych (wskaŸnik na odgrywany dŸwiêk) static TTextSound *tsRadioBusy[10]; // zajêtoœæ kana³ów radiowych (wskaŸnik na odgrywany dŸwiêk)
//metody // metody
static void __fastcall TrainDelete(TDynamicObject *d); static void __fastcall TrainDelete(TDynamicObject *d);
static void __fastcall ConfigParse(Queryparsercomp::TQueryParserComp *qp,cParser *cp=NULL); static void __fastcall ConfigParse(Queryparsercomp::TQueryParserComp *qp, cParser *cp = NULL);
static AnsiString __fastcall GetNextSymbol(); static AnsiString __fastcall GetNextSymbol();
static TDynamicObject* __fastcall DynamicNearest(); static TDynamicObject *__fastcall DynamicNearest();
static TDynamicObject* __fastcall CouplerNearest(); static TDynamicObject *__fastcall CouplerNearest();
static bool __fastcall AddToQuery(TEvent *event,TDynamicObject *who); static bool __fastcall AddToQuery(TEvent *event, TDynamicObject *who);
static bool __fastcall DoEvents(); static bool __fastcall DoEvents();
static AnsiString __fastcall Bezogonkow(AnsiString str, bool _=false); static AnsiString __fastcall Bezogonkow(AnsiString str, bool _ = false);
}; };
//--------------------------------------------------------------------------- //---------------------------------------------------------------------------

5788
Ground.cpp
View File

File diff suppressed because it is too large Load Diff

479
Ground.h
View File

@@ -10,284 +10,291 @@
using namespace Math3D; using namespace Math3D;
//Ra: zmniejszone liczby, aby zrobić tabelkę i zoptymalizować wyszukiwanie // Ra: zmniejszone liczby, aby zrobić tabelkę i zoptymalizować wyszukiwanie
const int TP_MODEL=10; const int TP_MODEL = 10;
const int TP_MESH=11; //Ra: specjalny obiekt grupojący siatki dla tekstury const int TP_MESH = 11; // Ra: specjalny obiekt grupojący siatki dla tekstury
const int TP_DUMMYTRACK=12; //Ra: zdublowanie obiektu toru dla rozdzielenia tekstur const int TP_DUMMYTRACK = 12; // Ra: zdublowanie obiektu toru dla rozdzielenia tekstur
const int TP_TERRAIN=13; //Ra: specjalny model dla terenu const int TP_TERRAIN = 13; // Ra: specjalny model dla terenu
const int TP_DYNAMIC=14; const int TP_DYNAMIC = 14;
const int TP_SOUND=15; const int TP_SOUND = 15;
const int TP_TRACK=16; const int TP_TRACK = 16;
//const int TP_GEOMETRY=17; // const int TP_GEOMETRY=17;
const int TP_MEMCELL=18; const int TP_MEMCELL = 18;
const int TP_EVLAUNCH=19; //MC const int TP_EVLAUNCH = 19; // MC
const int TP_TRACTION=20; const int TP_TRACTION = 20;
const int TP_TRACTIONPOWERSOURCE=21; //MC const int TP_TRACTIONPOWERSOURCE = 21; // MC
//const int TP_ISOLATED=22; //Ra // const int TP_ISOLATED=22; //Ra
const int TP_SUBMODEL=22; //Ra: submodele terenu const int TP_SUBMODEL = 22; // Ra: submodele terenu
const int TP_LAST=25; //rozmiar tablicy const int TP_LAST = 25; // rozmiar tablicy
struct DaneRozkaz struct DaneRozkaz
{//struktura komunikacji z EU07.EXE { // struktura komunikacji z EU07.EXE
int iSygn; //sygnatura 'EU07' int iSygn; // sygnatura 'EU07'
int iComm; //rozkaz/status (kod ramki) int iComm; // rozkaz/status (kod ramki)
union union
{float fPar[62]; {
float fPar[62];
int iPar[62]; int iPar[62];
char cString[248]; //upakowane stringi char cString[248]; // upakowane stringi
}; };
}; };
typedef int TGroundNodeType; typedef int TGroundNodeType;
struct TGroundVertex struct TGroundVertex
{ {
vector3 Point; vector3 Point;
vector3 Normal; vector3 Normal;
float tu,tv; float tu, tv;
void HalfSet(const TGroundVertex &v1,const TGroundVertex &v2) void HalfSet(const TGroundVertex &v1, const TGroundVertex &v2)
{//wyliczenie współrzędnych i mapowania punktu na środku odcinka v1<->v2 { // wyliczenie współrzędnych i mapowania punktu na środku odcinka v1<->v2
Point=0.5*(v1.Point+v2.Point); Point = 0.5 * (v1.Point + v2.Point);
Normal=0.5*(v1.Normal+v2.Normal); Normal = 0.5 * (v1.Normal + v2.Normal);
tu=0.5*(v1.tu+v2.tu); tu = 0.5 * (v1.tu + v2.tu);
tv=0.5*(v1.tv+v2.tv); tv = 0.5 * (v1.tv + v2.tv);
} }
void SetByX(const TGroundVertex &v1,const TGroundVertex &v2,double x) void SetByX(const TGroundVertex &v1, const TGroundVertex &v2, double x)
{//wyliczenie współrzędnych i mapowania punktu na odcinku v1<->v2 { // wyliczenie współrzędnych i mapowania punktu na odcinku v1<->v2
double i=(x-v1.Point.x)/(v2.Point.x-v1.Point.x); //parametr równania double i = (x - v1.Point.x) / (v2.Point.x - v1.Point.x); // parametr równania
double j=1.0-i; double j = 1.0 - i;
Point=j*v1.Point+i*v2.Point; Point = j * v1.Point + i * v2.Point;
Normal=j*v1.Normal+i*v2.Normal; Normal = j * v1.Normal + i * v2.Normal;
tu=j*v1.tu+i*v2.tu; tu = j * v1.tu + i * v2.tu;
tv=j*v1.tv+i*v2.tv; tv = j * v1.tv + i * v2.tv;
} }
void SetByZ(const TGroundVertex &v1,const TGroundVertex &v2,double z) void SetByZ(const TGroundVertex &v1, const TGroundVertex &v2, double z)
{//wyliczenie współrzędnych i mapowania punktu na odcinku v1<->v2 { // wyliczenie współrzędnych i mapowania punktu na odcinku v1<->v2
double i=(z-v1.Point.z)/(v2.Point.z-v1.Point.z); //parametr równania double i = (z - v1.Point.z) / (v2.Point.z - v1.Point.z); // parametr równania
double j=1.0-i; double j = 1.0 - i;
Point=j*v1.Point+i*v2.Point; Point = j * v1.Point + i * v2.Point;
Normal=j*v1.Normal+i*v2.Normal; Normal = j * v1.Normal + i * v2.Normal;
tu=j*v1.tu+i*v2.tu; tu = j * v1.tu + i * v2.tu;
tv=j*v1.tv+i*v2.tv; tv = j * v1.tv + i * v2.tv;
} }
}; };
class TSubRect; //sektor (aktualnie 200m×200m, ale może być zmieniony) class TSubRect; // sektor (aktualnie 200m×200m, ale może być zmieniony)
class TGroundNode : public Resource class TGroundNode : public Resource
{//obiekt scenerii { // obiekt scenerii
private: private:
public: public:
TGroundNodeType iType; //typ obiektu TGroundNodeType iType; // typ obiektu
union union
{//Ra: wskażniki zależne od typu - zrobić klasy dziedziczone zamiast { // Ra: wskażniki zależne od typu - zrobić klasy dziedziczone zamiast
void *Pointer; //do przypisywania NULL void *Pointer; // do przypisywania NULL
TSubModel *smTerrain; //modele terenu (kwadratow kilometrowych) TSubModel *smTerrain; // modele terenu (kwadratow kilometrowych)
TAnimModel *Model; //model z animacjami TAnimModel *Model; // model z animacjami
TDynamicObject *DynamicObject; //pojazd TDynamicObject *DynamicObject; // pojazd
vector3 *Points; //punkty dla linii vector3 *Points; // punkty dla linii
TTrack *pTrack; //trajektoria ruchu TTrack *pTrack; // trajektoria ruchu
TGroundVertex *Vertices; //wierzchołki dla trójkątów TGroundVertex *Vertices; // wierzchołki dla trójkątów
TMemCell *MemCell; //komórka pamięci TMemCell *MemCell; // komórka pamięci
TEventLauncher *EvLaunch; //wyzwalacz zdarzeń TEventLauncher *EvLaunch; // wyzwalacz zdarzeń
TTraction *hvTraction; //drut zasilający TTraction *hvTraction; // drut zasilający
TTractionPowerSource *psTractionPowerSource; //zasilanie drutu (zaniedbane w sceneriach) TTractionPowerSource *psTractionPowerSource; // zasilanie drutu (zaniedbane w sceneriach)
TTextSound *tsStaticSound; //dźwięk przestrzenny TTextSound *tsStaticSound; // dźwięk przestrzenny
TGroundNode *nNode; //obiekt renderujący grupowo ma tu wskaźnik na listę obiektów TGroundNode *nNode; // obiekt renderujący grupowo ma tu wskaźnik na listę obiektów
}; };
AnsiString asName; //nazwa (nie zawsze ma znaczenie) AnsiString asName; // nazwa (nie zawsze ma znaczenie)
union union
{ {
int iNumVerts; //dla trójkątów int iNumVerts; // dla trójkątów
int iNumPts; //dla linii int iNumPts; // dla linii
int iCount; //dla terenu int iCount; // dla terenu
//int iState; //Ra: nie używane - dźwięki zapętlone // int iState; //Ra: nie używane - dźwięki zapętlone
}; };
vector3 pCenter; //współrzędne środka do przydzielenia sektora vector3 pCenter; // współrzędne środka do przydzielenia sektora
union union
{ {
//double fAngle; //kąt obrotu dla modelu // double fAngle; //kąt obrotu dla modelu
double fLineThickness; //McZapkie-120702: grubosc linii double fLineThickness; // McZapkie-120702: grubosc linii
//int Status; //McZapkie-170303: status dzwieku // int Status; //McZapkie-170303: status dzwieku
}; };
double fSquareRadius; //kwadrat widoczności do double fSquareRadius; // kwadrat widoczności do
double fSquareMinRadius; //kwadrat widoczności od double fSquareMinRadius; // kwadrat widoczności od
//TGroundNode *nMeshGroup; //Ra: obiekt grupujący trójkąty w TSubRect dla tekstury // TGroundNode *nMeshGroup; //Ra: obiekt grupujący trójkąty w TSubRect dla tekstury
int iVersion; //wersja siatki (do wykonania rekompilacji) int iVersion; // wersja siatki (do wykonania rekompilacji)
//union ? // union ?
GLuint DisplayListID; //numer siatki DisplayLists GLuint DisplayListID; // numer siatki DisplayLists
bool PROBLEND; bool PROBLEND;
int iVboPtr; //indeks w buforze VBO int iVboPtr; // indeks w buforze VBO
GLuint TextureID; //główna (jedna) tekstura obiektu GLuint TextureID; // główna (jedna) tekstura obiektu
int iFlags; //tryb przezroczystości: 0x10-nieprz.,0x20-przezroczysty,0x30-mieszany int iFlags; // tryb przezroczystości: 0x10-nieprz.,0x20-przezroczysty,0x30-mieszany
int Ambient[4],Diffuse[4],Specular[4]; //oświetlenie int Ambient[4], Diffuse[4], Specular[4]; // oświetlenie
bool bVisible; bool bVisible;
TGroundNode *nNext; //lista wszystkich w scenerii, ostatni na początku TGroundNode *nNext; // lista wszystkich w scenerii, ostatni na początku
TGroundNode *nNext2; //lista obiektów w sektorze TGroundNode *nNext2; // lista obiektów w sektorze
TGroundNode *nNext3; //lista obiektów renderowanych we wspólnym cyklu TGroundNode *nNext3; // lista obiektów renderowanych we wspólnym cyklu
__fastcall TGroundNode(); __fastcall TGroundNode();
__fastcall TGroundNode(TGroundNodeType t,int n=0); __fastcall TGroundNode(TGroundNodeType t, int n = 0);
__fastcall ~TGroundNode(); __fastcall ~TGroundNode();
void __fastcall Init(int n); void __fastcall Init(int n);
void __fastcall InitCenter(); //obliczenie współrzędnych środka void __fastcall InitCenter(); // obliczenie współrzędnych środka
void __fastcall InitNormals(); void __fastcall InitNormals();
void __fastcall MoveMe(vector3 pPosition); //przesuwanie (nie działa) void __fastcall MoveMe(vector3 pPosition); // przesuwanie (nie działa)
//bool __fastcall Disable(); // bool __fastcall Disable();
inline TGroundNode* __fastcall Find(const AnsiString &asNameToFind,TGroundNodeType iNodeType) inline TGroundNode *__fastcall Find(const AnsiString &asNameToFind, TGroundNodeType iNodeType)
{//wyszukiwanie czołgowe z typem { // wyszukiwanie czołgowe z typem
if ((iNodeType==iType)&&(asNameToFind==asName)) if ((iNodeType == iType) && (asNameToFind == asName))
return this; return this;
else else if (nNext)
if (nNext) return nNext->Find(asNameToFind,iNodeType); return nNext->Find(asNameToFind, iNodeType);
return NULL; return NULL;
}; };
void __fastcall Compile(bool many=false); void __fastcall Compile(bool many = false);
void Release(); void Release();
bool __fastcall GetTraction(); bool __fastcall GetTraction();
void __fastcall RenderHidden(); //obsługa dźwięków i wyzwalaczy zdarzeń void __fastcall RenderHidden(); // obsługa dźwięków i wyzwalaczy zdarzeń
void __fastcall RenderDL(); //renderowanie nieprzezroczystych w Display Lists void __fastcall RenderDL(); // renderowanie nieprzezroczystych w Display Lists
void __fastcall RenderAlphaDL(); //renderowanie przezroczystych w Display Lists (McZapkie-131202) void __fastcall RenderAlphaDL(); // renderowanie przezroczystych w Display Lists
void __fastcall RaRenderVBO(); //renderowanie (nieprzezroczystych) ze wspólnego VBO // (McZapkie-131202)
void __fastcall RenderVBO(); //renderowanie nieprzezroczystych z własnego VBO void __fastcall RaRenderVBO(); // renderowanie (nieprzezroczystych) ze wspólnego VBO
void __fastcall RenderAlphaVBO(); //renderowanie przezroczystych z (własnego) VBO void __fastcall RenderVBO(); // renderowanie nieprzezroczystych z własnego VBO
void __fastcall RenderAlphaVBO(); // renderowanie przezroczystych z (własnego) VBO
}; };
class TSubRect : public Resource, public CMesh class TSubRect : public Resource, public CMesh
{//sektor składowy kwadratu kilometrowego { // sektor składowy kwadratu kilometrowego
public: public:
int iTracks; //ilość torów w (tTracks) int iTracks; // ilość torów w (tTracks)
TTrack **tTracks; //tory do renderowania pojazdów TTrack **tTracks; // tory do renderowania pojazdów
protected: protected:
TTrack *tTrackAnim; //obiekty do przeliczenia animacji TTrack *tTrackAnim; // obiekty do przeliczenia animacji
TGroundNode *nRootMesh; //obiekty renderujące wg tekstury (wtórne, lista po nNext2) TGroundNode *nRootMesh; // obiekty renderujące wg tekstury (wtórne, lista po nNext2)
TGroundNode *nMeshed; //lista obiektów dla których istnieją obiekty renderujące grupowo TGroundNode *nMeshed; // lista obiektów dla których istnieją obiekty renderujące grupowo
public: public:
TGroundNode *nRootNode; //wszystkie obiekty w sektorze, z wyjątkiem renderujących i pojazdów (nNext2) TGroundNode *
TGroundNode *nRenderHidden; //lista obiektów niewidocznych, "renderowanych" również z tyłu (nNext3) nRootNode; // wszystkie obiekty w sektorze, z wyjątkiem renderujących i pojazdów (nNext2)
TGroundNode *nRenderRect; //z poziomu sektora - nieprzezroczyste (nNext3) TGroundNode *
TGroundNode *nRenderRectAlpha; //z poziomu sektora - przezroczyste (nNext3) nRenderHidden; // lista obiektów niewidocznych, "renderowanych" również z tyłu (nNext3)
TGroundNode *nRenderWires; //z poziomu sektora - druty i inne linie (nNext3) TGroundNode *nRenderRect; // z poziomu sektora - nieprzezroczyste (nNext3)
TGroundNode *nRender; //indywidualnie - nieprzezroczyste (nNext3) TGroundNode *nRenderRectAlpha; // z poziomu sektora - przezroczyste (nNext3)
TGroundNode *nRenderMixed; //indywidualnie - nieprzezroczyste i przezroczyste (nNext3) TGroundNode *nRenderWires; // z poziomu sektora - druty i inne linie (nNext3)
TGroundNode *nRenderAlpha; //indywidualnie - przezroczyste (nNext3) TGroundNode *nRender; // indywidualnie - nieprzezroczyste (nNext3)
int iNodeCount; //licznik obiektów, do pomijania pustych sektorów TGroundNode *nRenderMixed; // indywidualnie - nieprzezroczyste i przezroczyste (nNext3)
public: TGroundNode *nRenderAlpha; // indywidualnie - przezroczyste (nNext3)
void __fastcall LoadNodes(); //utworzenie VBO sektora int iNodeCount; // licznik obiektów, do pomijania pustych sektorów
public: public:
void __fastcall LoadNodes(); // utworzenie VBO sektora
public:
__fastcall TSubRect(); __fastcall TSubRect();
virtual __fastcall ~TSubRect(); virtual __fastcall ~TSubRect();
virtual void Release(); //zwalnianie VBO sektora virtual void Release(); // zwalnianie VBO sektora
void __fastcall NodeAdd(TGroundNode *Node); //dodanie obiektu do sektora na etapie rozdzielania na sektory void __fastcall NodeAdd(
void __fastcall RaNodeAdd(TGroundNode *Node); //dodanie obiektu do listy renderowania TGroundNode *Node); // dodanie obiektu do sektora na etapie rozdzielania na sektory
void __fastcall Sort(); //optymalizacja obiektów w sektorze (sortowanie wg tekstur) void __fastcall RaNodeAdd(TGroundNode *Node); // dodanie obiektu do listy renderowania
TTrack* __fastcall FindTrack(vector3 *Point,int &iConnection,TTrack *Exclude); void __fastcall Sort(); // optymalizacja obiektów w sektorze (sortowanie wg tekstur)
TTraction* __fastcall FindTraction(vector3 *Point,int &iConnection,TTraction *Exclude); TTrack *__fastcall FindTrack(vector3 *Point, int &iConnection, TTrack *Exclude);
bool __fastcall StartVBO(); //ustwienie VBO sektora dla (nRenderRect), (nRenderRectAlpha) i (nRenderWires) TTraction *__fastcall FindTraction(vector3 *Point, int &iConnection, TTraction *Exclude);
bool __fastcall RaTrackAnimAdd(TTrack *t); //zgłoszenie toru do animacji bool __fastcall StartVBO(); // ustwienie VBO sektora dla (nRenderRect), (nRenderRectAlpha) i
void __fastcall RaAnimate(); //przeliczenie animacji torów // (nRenderWires)
void __fastcall RenderDL(); //renderowanie nieprzezroczystych w Display Lists bool __fastcall RaTrackAnimAdd(TTrack *t); // zgłoszenie toru do animacji
void __fastcall RenderAlphaDL(); //renderowanie przezroczystych w Display Lists (McZapkie-131202) void __fastcall RaAnimate(); // przeliczenie animacji torów
void __fastcall RenderVBO(); //renderowanie nieprzezroczystych z własnego VBO void __fastcall RenderDL(); // renderowanie nieprzezroczystych w Display Lists
void __fastcall RenderAlphaVBO(); //renderowanie przezroczystych z (własnego) VBO void __fastcall RenderAlphaDL(); // renderowanie przezroczystych w Display Lists
void __fastcall RenderSounds(); //dźwięki pojazdów z niewidocznych sektorów // (McZapkie-131202)
void __fastcall RenderVBO(); // renderowanie nieprzezroczystych z własnego VBO
void __fastcall RenderAlphaVBO(); // renderowanie przezroczystych z (własnego) VBO
void __fastcall RenderSounds(); // dźwięki pojazdów z niewidocznych sektorów
}; };
//Ra: trzeba sprawdzić wydajność siatki // Ra: trzeba sprawdzić wydajność siatki
const int iNumSubRects=5; //na ile dzielimy kilometr const int iNumSubRects = 5; // na ile dzielimy kilometr
const int iNumRects=500; const int iNumRects = 500;
//const double fHalfNumRects=iNumRects/2.0; //połowa do wyznaczenia środka // const double fHalfNumRects=iNumRects/2.0; //połowa do wyznaczenia środka
const int iTotalNumSubRects=iNumRects*iNumSubRects; const int iTotalNumSubRects = iNumRects * iNumSubRects;
const double fHalfTotalNumSubRects=iTotalNumSubRects/2.0; const double fHalfTotalNumSubRects = iTotalNumSubRects / 2.0;
const double fSubRectSize=1000.0/iNumSubRects; const double fSubRectSize = 1000.0 / iNumSubRects;
const double fRectSize=fSubRectSize*iNumSubRects; const double fRectSize = fSubRectSize * iNumSubRects;
class TGroundRect : public TSubRect class TGroundRect : public TSubRect
{//kwadrat kilometrowy { // kwadrat kilometrowy
//obiekty o niewielkiej ilości wierzchołków będą renderowane stąd // obiekty o niewielkiej ilości wierzchołków będą renderowane stąd
//Ra: 2012-02 doszły submodele terenu // Ra: 2012-02 doszły submodele terenu
private: private:
int iLastDisplay; //numer klatki w której był ostatnio wyświetlany int iLastDisplay; // numer klatki w której był ostatnio wyświetlany
TSubRect *pSubRects; TSubRect *pSubRects;
void __fastcall Init() { pSubRects=new TSubRect[iNumSubRects*iNumSubRects]; }; void __fastcall Init() { pSubRects = new TSubRect[iNumSubRects * iNumSubRects]; };
public:
static int iFrameNumber; //numer kolejny wyświetlanej klatki public:
TGroundNode *nTerrain; //model terenu z E3D - użyć nRootMesh? static int iFrameNumber; // numer kolejny wyświetlanej klatki
TGroundNode *nTerrain; // model terenu z E3D - użyć nRootMesh?
__fastcall TGroundRect(); __fastcall TGroundRect();
virtual __fastcall ~TGroundRect(); virtual __fastcall ~TGroundRect();
TSubRect* __fastcall SafeGetRect(int iCol,int iRow) TSubRect *__fastcall SafeGetRect(int iCol, int iRow)
{//pobranie wskaźnika do małego kwadratu, utworzenie jeśli trzeba { // pobranie wskaźnika do małego kwadratu, utworzenie jeśli trzeba
if (!pSubRects) Init(); //utworzenie małych kwadratów if (!pSubRects)
return pSubRects+iRow*iNumSubRects+iCol; //zwrócenie właściwego Init(); // utworzenie małych kwadratów
return pSubRects + iRow * iNumSubRects + iCol; // zwrócenie właściwego
}; };
TSubRect* __fastcall FastGetRect(int iCol,int iRow) TSubRect *__fastcall FastGetRect(int iCol, int iRow)
{//pobranie wskaźnika do małego kwadratu, bez tworzenia jeśli nie ma { // pobranie wskaźnika do małego kwadratu, bez tworzenia jeśli nie ma
return (pSubRects?pSubRects+iRow*iNumSubRects+iCol:NULL); return (pSubRects ? pSubRects + iRow * iNumSubRects + iCol : NULL);
}; };
void __fastcall Optimize() void __fastcall Optimize()
{//optymalizacja obiektów w sektorach { // optymalizacja obiektów w sektorach
if (pSubRects) if (pSubRects)
for (int i=iNumSubRects*iNumSubRects-1;i>=0;--i) for (int i = iNumSubRects * iNumSubRects - 1; i >= 0; --i)
pSubRects[i].Sort(); //optymalizacja obiektów w sektorach pSubRects[i].Sort(); // optymalizacja obiektów w sektorach
}; };
void __fastcall RenderDL(); void __fastcall RenderDL();
void __fastcall RenderVBO(); void __fastcall RenderVBO();
}; };
class TGround class TGround
{ {
vector3 CameraDirection; //zmienna robocza przy renderowaniu vector3 CameraDirection; // zmienna robocza przy renderowaniu
int const *iRange; //tabela widoczności int const *iRange; // tabela widoczności
//TGroundNode *nRootNode; //lista wszystkich węzłów // TGroundNode *nRootNode; //lista wszystkich węzłów
TGroundNode *nRootDynamic; //lista pojazdów TGroundNode *nRootDynamic; // lista pojazdów
TGroundRect Rects[iNumRects][iNumRects]; //mapa kwadratów kilometrowych TGroundRect Rects[iNumRects][iNumRects]; // mapa kwadratów kilometrowych
TEvent *RootEvent; //lista zdarzeń TEvent *RootEvent; // lista zdarzeń
TEvent *QueryRootEvent,*tmpEvent,*tmp2Event,*OldQRE; TEvent *QueryRootEvent, *tmpEvent, *tmp2Event, *OldQRE;
TSubRect *pRendered[1500]; //lista renderowanych sektorów TSubRect *pRendered[1500]; // lista renderowanych sektorów
int iNumNodes; int iNumNodes;
vector3 pOrigin; vector3 pOrigin;
vector3 aRotate; vector3 aRotate;
bool bInitDone; bool bInitDone;
TGroundNode *nRootOfType[TP_LAST]; //tablica grupująca obiekty, przyspiesza szukanie TGroundNode *nRootOfType[TP_LAST]; // tablica grupująca obiekty, przyspiesza szukanie
//TGroundNode *nLastOfType[TP_LAST]; //ostatnia // TGroundNode *nLastOfType[TP_LAST]; //ostatnia
TSubRect srGlobal; //zawiera obiekty globalne (na razie wyzwalacze czasowe) TSubRect srGlobal; // zawiera obiekty globalne (na razie wyzwalacze czasowe)
int hh,mm,srh,srm,ssh,ssm; //ustawienia czasu int hh, mm, srh, srm, ssh, ssm; // ustawienia czasu
//int tracks,tracksfar; //liczniki torów // int tracks,tracksfar; //liczniki torów
TNames *sTracks; //posortowane nazwy torów i eventów TNames *sTracks; // posortowane nazwy torów i eventów
private: //metody prywatne private: // metody prywatne
bool __fastcall EventConditon(TEvent *e); bool __fastcall EventConditon(TEvent *e);
public:
bool bDynamicRemove; //czy uruchomić procedurę usuwania pojazdów public:
TDynamicObject *LastDyn; //ABu: paskudnie, ale na bardzo szybko moze jakos przejdzie... bool bDynamicRemove; // czy uruchomić procedurę usuwania pojazdów
//TTrain *pTrain; TDynamicObject *LastDyn; // ABu: paskudnie, ale na bardzo szybko moze jakos przejdzie...
//double fVDozwolona; // TTrain *pTrain;
//bool bTrabil; // double fVDozwolona;
// bool bTrabil;
__fastcall TGround(); __fastcall TGround();
__fastcall ~TGround(); __fastcall ~TGround();
void __fastcall Free(); void __fastcall Free();
bool __fastcall Init(AnsiString asFile,HDC hDC); bool __fastcall Init(AnsiString asFile, HDC hDC);
void __fastcall FirstInit(); void __fastcall FirstInit();
void __fastcall InitTracks(); void __fastcall InitTracks();
void __fastcall InitTraction(); void __fastcall InitTraction();
bool __fastcall InitEvents(); bool __fastcall InitEvents();
bool __fastcall InitLaunchers(); bool __fastcall InitLaunchers();
TTrack* __fastcall FindTrack(vector3 Point,int &iConnection,TGroundNode *Exclude); TTrack *__fastcall FindTrack(vector3 Point, int &iConnection, TGroundNode *Exclude);
TTraction* __fastcall FindTraction(vector3 *Point,int &iConnection,TGroundNode *Exclude); TTraction *__fastcall FindTraction(vector3 *Point, int &iConnection, TGroundNode *Exclude);
TTraction* __fastcall TractionNearestFind(vector3 &p,int dir,TGroundNode *n); TTraction *__fastcall TractionNearestFind(vector3 &p, int dir, TGroundNode *n);
//TGroundNode* __fastcall CreateGroundNode(); // TGroundNode* __fastcall CreateGroundNode();
TGroundNode* __fastcall AddGroundNode(cParser* parser); TGroundNode *__fastcall AddGroundNode(cParser *parser);
bool __fastcall AddGroundNode(double x,double z,TGroundNode *Node) bool __fastcall AddGroundNode(double x, double z, TGroundNode *Node)
{ {
TSubRect *tmp=GetSubRect(x,z); TSubRect *tmp = GetSubRect(x, z);
if (tmp) if (tmp)
{ {
tmp->NodeAdd(Node); tmp->NodeAdd(Node);
@@ -296,13 +303,13 @@ public:
else else
return false; return false;
}; };
// bool __fastcall Include(TQueryParserComp *Parser); // bool __fastcall Include(TQueryParserComp *Parser);
//TGroundNode* __fastcall GetVisible(AnsiString asName); // TGroundNode* __fastcall GetVisible(AnsiString asName);
TGroundNode* __fastcall GetNode(AnsiString asName); TGroundNode *__fastcall GetNode(AnsiString asName);
bool __fastcall AddDynamic(TGroundNode *Node); bool __fastcall AddDynamic(TGroundNode *Node);
void __fastcall MoveGroundNode(vector3 pPosition); void __fastcall MoveGroundNode(vector3 pPosition);
void __fastcall UpdatePhys(double dt,int iter); //aktualizacja fizyki stałym krokiem void __fastcall UpdatePhys(double dt, int iter); // aktualizacja fizyki stałym krokiem
bool __fastcall Update(double dt,int iter); //aktualizacja przesunięć zgodna z FPS bool __fastcall Update(double dt, int iter); // aktualizacja przesunięć zgodna z FPS
bool __fastcall AddToQuery(TEvent *Event, TDynamicObject *Node); bool __fastcall AddToQuery(TEvent *Event, TDynamicObject *Node);
bool __fastcall GetTraction(TDynamicObject *model); bool __fastcall GetTraction(TDynamicObject *model);
bool __fastcall RenderDL(vector3 pPosition); bool __fastcall RenderDL(vector3 pPosition);
@@ -310,14 +317,15 @@ public:
bool __fastcall RenderVBO(vector3 pPosition); bool __fastcall RenderVBO(vector3 pPosition);
bool __fastcall RenderAlphaVBO(vector3 pPosition); bool __fastcall RenderAlphaVBO(vector3 pPosition);
bool __fastcall CheckQuery(); bool __fastcall CheckQuery();
// __fastcall GetRect(double x, double z) { return &(Rects[int(x/fSubRectSize+fHalfNumRects)][int(z/fSubRectSize+fHalfNumRects)]); }; // __fastcall GetRect(double x, double z) { return
/* // &(Rects[int(x/fSubRectSize+fHalfNumRects)][int(z/fSubRectSize+fHalfNumRects)]); };
/*
int __fastcall GetRowFromZ(double z) { return (z/fRectSize+fHalfNumRects); }; int __fastcall GetRowFromZ(double z) { return (z/fRectSize+fHalfNumRects); };
int __fastcall GetColFromX(double x) { return (x/fRectSize+fHalfNumRects); }; int __fastcall GetColFromX(double x) { return (x/fRectSize+fHalfNumRects); };
int __fastcall GetSubRowFromZ(double z) { return (z/fSubRectSize+fHalfNumSubRects); }; int __fastcall GetSubRowFromZ(double z) { return (z/fSubRectSize+fHalfNumSubRects); };
int __fastcall GetSubColFromX(double x) { return (x/fSubRectSize+fHalfNumSubRects); }; int __fastcall GetSubColFromX(double x) { return (x/fSubRectSize+fHalfNumSubRects); };
*/ */
/* /*
inline TGroundNode* __fastcall FindGroundNode(const AnsiString &asNameToFind ) inline TGroundNode* __fastcall FindGroundNode(const AnsiString &asNameToFind )
{ {
if (RootNode) if (RootNode)
@@ -325,37 +333,50 @@ public:
else else
return NULL; return NULL;
} }
*/ */
TGroundNode* __fastcall DynamicFindAny(AnsiString asNameToFind); TGroundNode *__fastcall DynamicFindAny(AnsiString asNameToFind);
TGroundNode* __fastcall DynamicFind(AnsiString asNameToFind); TGroundNode *__fastcall DynamicFind(AnsiString asNameToFind);
void __fastcall DynamicList(bool all=false); void __fastcall DynamicList(bool all = false);
TGroundNode* __fastcall FindGroundNode(AnsiString asNameToFind,TGroundNodeType iNodeType); TGroundNode *__fastcall FindGroundNode(AnsiString asNameToFind, TGroundNodeType iNodeType);
TGroundRect* __fastcall GetRect(double x, double z) { return &Rects[GetColFromX(x)/iNumSubRects][GetRowFromZ(z)/iNumSubRects]; }; TGroundRect *__fastcall GetRect(double x, double z)
TSubRect* __fastcall GetSubRect(double x, double z) { return GetSubRect(GetColFromX(x),GetRowFromZ(z)); }; {
TSubRect* __fastcall FastGetSubRect(double x, double z) { return FastGetSubRect(GetColFromX(x),GetRowFromZ(z)); }; return &Rects[GetColFromX(x) / iNumSubRects][GetRowFromZ(z) / iNumSubRects];
TSubRect* __fastcall GetSubRect(int iCol, int iRow); };
TSubRect* __fastcall FastGetSubRect(int iCol, int iRow); TSubRect *__fastcall GetSubRect(double x, double z)
int __fastcall GetRowFromZ(double z) { return (z/fSubRectSize+fHalfTotalNumSubRects); }; {
int __fastcall GetColFromX(double x) { return (x/fSubRectSize+fHalfTotalNumSubRects); }; return GetSubRect(GetColFromX(x), GetRowFromZ(z));
TEvent* __fastcall FindEvent(const AnsiString &asEventName); };
TEvent* __fastcall FindEventScan(const AnsiString &asEventName); TSubRect *__fastcall FastGetSubRect(double x, double z)
{
return FastGetSubRect(GetColFromX(x), GetRowFromZ(z));
};
TSubRect *__fastcall GetSubRect(int iCol, int iRow);
TSubRect *__fastcall FastGetSubRect(int iCol, int iRow);
int __fastcall GetRowFromZ(double z) { return (z / fSubRectSize + fHalfTotalNumSubRects); };
int __fastcall GetColFromX(double x) { return (x / fSubRectSize + fHalfTotalNumSubRects); };
TEvent *__fastcall FindEvent(const AnsiString &asEventName);
TEvent *__fastcall FindEventScan(const AnsiString &asEventName);
void __fastcall TrackJoin(TGroundNode *Current); void __fastcall TrackJoin(TGroundNode *Current);
private:
private:
void __fastcall OpenGLUpdate(HDC hDC); void __fastcall OpenGLUpdate(HDC hDC);
void __fastcall RaTriangleDivider(TGroundNode* node); void __fastcall RaTriangleDivider(TGroundNode *node);
void __fastcall Navigate(String ClassName,UINT Msg,WPARAM wParam,LPARAM lParam); void __fastcall Navigate(String ClassName, UINT Msg, WPARAM wParam, LPARAM lParam);
bool PROBLEND; bool PROBLEND;
public:
void __fastcall WyslijEvent(const AnsiString &e,const AnsiString &d); public:
int iRendered; //ilość renderowanych sektorów, pobierana przy pokazywniu FPS void __fastcall WyslijEvent(const AnsiString &e, const AnsiString &d);
void __fastcall WyslijString(const AnsiString &t,int n); int iRendered; // ilość renderowanych sektorów, pobierana przy pokazywniu FPS
void __fastcall WyslijString(const AnsiString &t, int n);
void __fastcall WyslijWolny(const AnsiString &t); void __fastcall WyslijWolny(const AnsiString &t);
void __fastcall WyslijNamiary(TGroundNode* t); void __fastcall WyslijNamiary(TGroundNode *t);
void __fastcall WyslijParam(int nr,int fl); void __fastcall WyslijParam(int nr, int fl);
void __fastcall RadioStop(vector3 pPosition); void __fastcall RadioStop(vector3 pPosition);
TDynamicObject* __fastcall DynamicNearest(vector3 pPosition,double distance=20.0,bool mech=false); TDynamicObject *__fastcall DynamicNearest(vector3 pPosition, double distance = 20.0,
TDynamicObject* __fastcall CouplerNearest(vector3 pPosition,double distance=20.0,bool mech=false); bool mech = false);
void __fastcall DynamicRemove(TDynamicObject* dyn); TDynamicObject *__fastcall CouplerNearest(vector3 pPosition, double distance = 20.0,
bool mech = false);
void __fastcall DynamicRemove(TDynamicObject *dyn);
void __fastcall TerrainRead(const AnsiString &f); void __fastcall TerrainRead(const AnsiString &f);
void __fastcall TerrainWrite(); void __fastcall TerrainWrite();
void __fastcall TrackBusyList(); void __fastcall TrackBusyList();

73
Logs.cpp
View File

@@ -11,84 +11,85 @@
#include <iostream> #include <iostream>
#include <fstream> #include <fstream>
std::ofstream output; //standardowy "log.txt", mo¿na go wy³¹czyæ std::ofstream output; // standardowy "log.txt", mo¿na go wy³¹czyæ
std::ofstream errors; //lista b³êdów "errors.txt", zawsze dzia³a std::ofstream errors; // lista b³êdów "errors.txt", zawsze dzia³a
char endstring[10]="\n"; char endstring[10] = "\n";
void __fastcall WriteConsoleOnly(const char* str, double value) void __fastcall WriteConsoleOnly(const char *str, double value)
{ {
char buf[255]; char buf[255];
sprintf(buf,"%s %f \n",str,value); sprintf(buf, "%s %f \n", str, value);
//stdout= GetStdHandle(STD_OUTPUT_HANDLE); // stdout= GetStdHandle(STD_OUTPUT_HANDLE);
DWORD wr= 0; DWORD wr = 0;
WriteConsole(GetStdHandle(STD_OUTPUT_HANDLE),buf,strlen(buf),&wr,NULL); WriteConsole(GetStdHandle(STD_OUTPUT_HANDLE), buf, strlen(buf), &wr, NULL);
//WriteConsole(GetStdHandle(STD_OUTPUT_HANDLE),endstring,strlen(endstring),&wr,NULL); // WriteConsole(GetStdHandle(STD_OUTPUT_HANDLE),endstring,strlen(endstring),&wr,NULL);
} }
void __fastcall WriteConsoleOnly(const char* str) void __fastcall WriteConsoleOnly(const char *str)
{ {
//printf("%n ffafaf /n",str); // printf("%n ffafaf /n",str);
SetConsoleTextAttribute(GetStdHandle(STD_OUTPUT_HANDLE),FOREGROUND_GREEN|FOREGROUND_INTENSITY); SetConsoleTextAttribute(GetStdHandle(STD_OUTPUT_HANDLE),
DWORD wr= 0; FOREGROUND_GREEN | FOREGROUND_INTENSITY);
WriteConsole(GetStdHandle(STD_OUTPUT_HANDLE),str,strlen(str),&wr,NULL); DWORD wr = 0;
WriteConsole(GetStdHandle(STD_OUTPUT_HANDLE),endstring,strlen(endstring),&wr,NULL); WriteConsole(GetStdHandle(STD_OUTPUT_HANDLE), str, strlen(str), &wr, NULL);
WriteConsole(GetStdHandle(STD_OUTPUT_HANDLE), endstring, strlen(endstring), &wr, NULL);
} }
void __fastcall WriteLog(const char* str, double value) void __fastcall WriteLog(const char *str, double value)
{ {
if (Global::iWriteLogEnabled) if (Global::iWriteLogEnabled)
{ {
if (str) if (str)
{ {
char buf[255]; char buf[255];
sprintf(buf,"%s %f",str,value); sprintf(buf, "%s %f", str, value);
WriteLog(buf); WriteLog(buf);
} }
} }
}; };
void __fastcall WriteLog(const char* str) void __fastcall WriteLog(const char *str)
{ {
if (str) if (str)
{ {
if (Global::iWriteLogEnabled&1) if (Global::iWriteLogEnabled & 1)
{if (!output.is_open()) {
output.open("log.txt",std::ios::trunc); if (!output.is_open())
output.open("log.txt", std::ios::trunc);
output << str << "\n"; output << str << "\n";
output.flush(); output.flush();
} }
//hunter-271211: pisanie do konsoli tylko, gdy nie jest ukrywana // hunter-271211: pisanie do konsoli tylko, gdy nie jest ukrywana
if (Global::iWriteLogEnabled&2) if (Global::iWriteLogEnabled & 2)
WriteConsoleOnly(str); WriteConsoleOnly(str);
} }
}; };
void __fastcall ErrorLog(const char* str) void __fastcall ErrorLog(const char *str)
{//Ra: bezwarunkowa rejestracja powa¿nych b³êdów { // Ra: bezwarunkowa rejestracja powa¿nych b³êdów
if (!errors.is_open()) if (!errors.is_open())
{errors.open("errors.txt",std::ios::trunc); {
errors << AnsiString("EU07.EXE "+Global::asRelease).c_str() << "\n"; errors.open("errors.txt", std::ios::trunc);
errors << AnsiString("EU07.EXE " + Global::asRelease).c_str() << "\n";
} }
if (str) errors << str; if (str)
errors << str;
errors << "\n"; errors << "\n";
errors.flush(); errors.flush();
}; };
void __fastcall Error(const AnsiString &asMessage,bool box) void __fastcall Error(const AnsiString &asMessage, bool box)
{ {
if (box) if (box)
MessageBox(NULL,asMessage.c_str(),AnsiString("EU07 "+Global::asRelease).c_str(),MB_OK); MessageBox(NULL, asMessage.c_str(), AnsiString("EU07 " + Global::asRelease).c_str(), MB_OK);
WriteLog(asMessage.c_str()); WriteLog(asMessage.c_str());
} }
void __fastcall ErrorLog(const AnsiString &asMessage) void __fastcall ErrorLog(const AnsiString &asMessage)
{//zapisywanie b³êdów "errors.txt" { // zapisywanie b³êdów "errors.txt"
ErrorLog(asMessage.c_str()); ErrorLog(asMessage.c_str());
WriteLog(asMessage.c_str()); //do "log.txt" ewentualnie te¿ WriteLog(asMessage.c_str()); // do "log.txt" ewentualnie te¿
} }
void __fastcall WriteLog(const AnsiString &str) void __fastcall WriteLog(const AnsiString &str) { // Ra: wersja z AnsiString jest zamienna z Error() WriteLog(str.c_str()); };
{//Ra: wersja z AnsiString jest zamienna z Error()
WriteLog(str.c_str());
};
//--------------------------------------------------------------------------- //---------------------------------------------------------------------------
#pragma package(smart_init) #pragma package(smart_init)

2
Logs.h
View File

@@ -8,7 +8,7 @@ void __fastcall WriteConsoleOnly(const char *str, double value);
void __fastcall WriteConsoleOnly(const char *str); void __fastcall WriteConsoleOnly(const char *str);
void __fastcall WriteLog(const char *str, double value); void __fastcall WriteLog(const char *str, double value);
void __fastcall WriteLog(const char *str); void __fastcall WriteLog(const char *str);
void __fastcall Error(const AnsiString &asMessage,bool box=true); void __fastcall Error(const AnsiString &asMessage, bool box = true);
void __fastcall ErrorLog(const AnsiString &asMessage); void __fastcall ErrorLog(const AnsiString &asMessage);
void __fastcall WriteLog(const AnsiString &str); void __fastcall WriteLog(const AnsiString &str);
//--------------------------------------------------------------------------- //---------------------------------------------------------------------------

82
Machajka.cpp
View File

@@ -4,20 +4,13 @@
#include "classes.hpp" #include "classes.hpp"
#pragma hdrstop #pragma hdrstop
#include "Machajka.h" #include "Machajka.h"
#include "Timer.h" #include "Timer.h"
#include "Globals.h" #include "Globals.h"
__fastcall TMachajka::TMachajka():TTrain() __fastcall TMachajka::TMachajka() : TTrain() { TTrain::TTrain(); }
{
TTrain::TTrain();
}
__fastcall TMachajka::~TMachajka() __fastcall TMachajka::~TMachajka() {}
{
}
bool __fastcall TMachajka::Init(TDynamicObject *NewDynamicObject) bool __fastcall TMachajka::Init(TDynamicObject *NewDynamicObject)
{ {
@@ -27,68 +20,47 @@ bool __fastcall TMachajka::Init(TDynamicObject *NewDynamicObject)
void __fastcall TMachajka::OnKeyPress(int cKey) void __fastcall TMachajka::OnKeyPress(int cKey)
{ {
if (!GetAsyncKeyState(VK_SHIFT)<0) //bez shifta if (!GetAsyncKeyState(VK_SHIFT) < 0) // bez shifta
{ {
if (cKey==Global::Keys[k_IncMainCtrl]) if (cKey == Global::Keys[k_IncMainCtrl])
(DynamicObject->MoverParameters->AddPulseForce(1)); (DynamicObject->MoverParameters->AddPulseForce(1));
else else if (cKey == Global::Keys[k_DecMainCtrl])
if (cKey==Global::Keys[k_DecMainCtrl])
(DynamicObject->MoverParameters->AddPulseForce(-1)); (DynamicObject->MoverParameters->AddPulseForce(-1));
else else if (cKey == Global::Keys[k_IncLocalBrakeLevel])
if (cKey==Global::Keys[k_IncLocalBrakeLevel])
(DynamicObject->MoverParameters->IncLocalBrakeLevel(1)); (DynamicObject->MoverParameters->IncLocalBrakeLevel(1));
else else if (cKey == Global::Keys[k_DecLocalBrakeLevel])
if (cKey==Global::Keys[k_DecLocalBrakeLevel])
(DynamicObject->MoverParameters->DecLocalBrakeLevel(1)); (DynamicObject->MoverParameters->DecLocalBrakeLevel(1));
else else if (cKey == Global::Keys[k_MechLeft])
if (cKey==Global::Keys[k_MechLeft]) vMechMovement.x += fMechCroach;
vMechMovement.x+=fMechCroach; else if (cKey == Global::Keys[k_MechRight])
else vMechMovement.x -= fMechCroach;
if (cKey==Global::Keys[k_MechRight]) else if (cKey == Global::Keys[k_MechBackward])
vMechMovement.x-=fMechCroach; vMechMovement.z -= fMechCroach;
else else if (cKey == Global::Keys[k_MechForward])
if (cKey==Global::Keys[k_MechBackward]) vMechMovement.z += fMechCroach;
vMechMovement.z-=fMechCroach; else if (cKey == Global::Keys[k_MechUp])
else pMechOffset.y += 0.3; // McZapkie-120302 - wstawanie
if (cKey==Global::Keys[k_MechForward]) else if (cKey == Global::Keys[k_MechDown])
vMechMovement.z+=fMechCroach; pMechOffset.y -= 0.3; // McZapkie-120302 - siadanie, kucanie itp
else
if (cKey==Global::Keys[k_MechUp])
pMechOffset.y+=0.3; //McZapkie-120302 - wstawanie
else
if (cKey==Global::Keys[k_MechDown])
pMechOffset.y-=0.3; //McZapkie-120302 - siadanie, kucanie itp
} }
else //z shiftem else // z shiftem
{ {
if (cKey==Global::Keys[k_IncMainCtrlFAST]) if (cKey == Global::Keys[k_IncMainCtrlFAST])
(DynamicObject->MoverParameters->AddPulseForce(2)); (DynamicObject->MoverParameters->AddPulseForce(2));
else else if (cKey == Global::Keys[k_DecMainCtrlFAST])
if (cKey==Global::Keys[k_DecMainCtrlFAST])
(DynamicObject->MoverParameters->AddPulseForce(-2)); (DynamicObject->MoverParameters->AddPulseForce(-2));
else else if (cKey == Global::Keys[k_IncLocalBrakeLevelFAST])
if (cKey==Global::Keys[k_IncLocalBrakeLevelFAST])
(DynamicObject->MoverParameters->IncLocalBrakeLevel(2)); (DynamicObject->MoverParameters->IncLocalBrakeLevel(2));
else else if (cKey == Global::Keys[k_DecLocalBrakeLevelFAST])
if (cKey==Global::Keys[k_DecLocalBrakeLevelFAST])
(DynamicObject->MoverParameters->DecLocalBrakeLevel(2)); (DynamicObject->MoverParameters->DecLocalBrakeLevel(2));
} }
} }
bool __fastcall TMachajka::Update(double dt) bool __fastcall TMachajka::Update(double dt) { TTrain::Update(dt); }
{
TTrain::Update(dt);
}
bool __fastcall TMachajka::UpdateMechPosition() bool __fastcall TMachajka::UpdateMechPosition() { TTrain::UpdateMechPosition(); }
{
TTrain::UpdateMechPosition();
}
bool __fastcall TMachajka::Render() bool __fastcall TMachajka::Render() { TTrain::Render(); }
{
TTrain::Render();
}
//--------------------------------------------------------------------------- //---------------------------------------------------------------------------
#pragma package(smart_init) #pragma package(smart_init)

19
Machajka.h
View File

@@ -5,17 +5,17 @@
#include "Train.h" #include "Train.h"
class TMachajka:public TTrain class TMachajka : public TTrain
{ {
public: public:
TSubModel *wajcha; TSubModel *wajcha;
// double v; // double v;
// double m; // double m;
// double a; // double a;
// double f; // double f;
// bool enter; // bool enter;
// bool space; // bool space;
// double wa,wv; // double wa,wv;
__fastcall TMachajka(); __fastcall TMachajka();
virtual __fastcall ~TMachajka(); virtual __fastcall ~TMachajka();
virtual bool __fastcall Init(TDynamicObject *NewDynamicObject); virtual bool __fastcall Init(TDynamicObject *NewDynamicObject);
@@ -25,6 +25,5 @@ public:
virtual bool __fastcall Render(); virtual bool __fastcall Render();
}; };
//--------------------------------------------------------------------------- //---------------------------------------------------------------------------
#endif #endif

109
MdlMngr.cpp
View File

@@ -16,26 +16,26 @@
#define SeekFiles AnsiString("*.t3d") #define SeekFiles AnsiString("*.t3d")
TModel3d* __fastcall TMdlContainer::LoadModel(char *newName,bool dynamic) TModel3d *__fastcall TMdlContainer::LoadModel(char *newName, bool dynamic)
{//wczytanie modelu do kontenerka { // wczytanie modelu do kontenerka
SafeDeleteArray(Name); SafeDeleteArray(Name);
SafeDelete(Model); SafeDelete(Model);
Name=new char[strlen(newName)+1]; Name = new char[strlen(newName) + 1];
strcpy(Name,newName); strcpy(Name, newName);
Model=new TModel3d(); Model = new TModel3d();
if (!Model->LoadFromFile(Name,dynamic)) //np. "models\\pkp/head1-y.t3d" if (!Model->LoadFromFile(Name, dynamic)) // np. "models\\pkp/head1-y.t3d"
SafeDelete(Model); SafeDelete(Model);
return Model; return Model;
}; };
TMdlContainer *TModelsManager::Models; TMdlContainer *TModelsManager::Models;
int TModelsManager::Count; int TModelsManager::Count;
const MAX_MODELS=1000; const MAX_MODELS = 1000;
void __fastcall TModelsManager::Init() void __fastcall TModelsManager::Init()
{ {
Models=new TMdlContainer[MAX_MODELS]; Models = new TMdlContainer[MAX_MODELS];
Count=0; Count = 0;
} }
/* /*
__fastcall TModelsManager::TModelsManager() __fastcall TModelsManager::TModelsManager()
@@ -50,34 +50,36 @@ __fastcall TModelsManager::~TModelsManager()
Free(); Free();
}; };
*/ */
void __fastcall TModelsManager::Free() void __fastcall TModelsManager::Free() { SafeDeleteArray(Models); }
{
SafeDeleteArray(Models);
}
TModel3d *__fastcall TModelsManager::LoadModel(char *Name, bool dynamic)
TModel3d* __fastcall TModelsManager::LoadModel(char *Name,bool dynamic) { // wczytanie modelu do tablicy
{//wczytanie modelu do tablicy TModel3d *mdl = NULL;
TModel3d *mdl=NULL; if (Count >= MAX_MODELS)
if (Count>=MAX_MODELS)
Error("FIXME: Too many models, program will now crash :)"); Error("FIXME: Too many models, program will now crash :)");
else else
{ {
mdl=Models[Count].LoadModel(Name,dynamic); mdl = Models[Count].LoadModel(Name, dynamic);
if (mdl) Count++; //jeśli błąd wczytania modelu, to go nie wliczamy if (mdl)
Count++; // jeśli błąd wczytania modelu, to go nie wliczamy
} }
return mdl; return mdl;
} }
TModel3d* __fastcall TModelsManager::GetModel(const char *Name,bool dynamic) TModel3d *__fastcall TModelsManager::GetModel(const char *Name, bool dynamic)
{//model może być we wpisie "node...model" albo "node...dynamic", a także być dodatkowym w dynamic (kabina, wnętrze, ładunek) { // model może być we wpisie "node...model" albo "node...dynamic", a także być dodatkowym w dynamic
//dla "node...dynamic" mamy podaną ścieżkę w "\dynamic\" i musi być co najmniej 1 poziom, zwkle są 2 // (kabina, wnętrze, ładunek)
//dla "node...model" może być typowy model statyczny ze ścieżką, domyślnie w "\scenery\" albo "\models" // dla "node...dynamic" mamy podaną ścieżkę w "\dynamic\" i musi być co najmniej 1 poziom, zwkle
//albo może być model z "\dynamic\", jeśli potrzebujemy wstawić auto czy wagon nieruchomo // są 2
// - ze ścieżki z której jest wywołany, np. dir="scenery\bud\" albo dir="dynamic\pkp\st44_v1\" plus name="model.t3d" // dla "node...model" może być typowy model statyczny ze ścieżką, domyślnie w "\scenery\" albo
// - z domyślnej ścieżki dla modeli, np. "scenery\" albo "models\" plus name="bud\dombale.t3d" (dir="") // "\models"
// albo może być model z "\dynamic\", jeśli potrzebujemy wstawić auto czy wagon nieruchomo
// - ze ścieżki z której jest wywołany, np. dir="scenery\bud\" albo dir="dynamic\pkp\st44_v1\"
// plus name="model.t3d"
// - z domyślnej ścieżki dla modeli, np. "scenery\" albo "models\" plus name="bud\dombale.t3d"
// (dir="")
// - konkretnie podanej ścieżki np. name="\scenery\bud\dombale.t3d" (dir="") // - konkretnie podanej ścieżki np. name="\scenery\bud\dombale.t3d" (dir="")
//wywołania: // wywołania:
// - konwersja wszystkiego do E3D, podawana dokładna ścieżka, tekstury tam, gdzie plik // - konwersja wszystkiego do E3D, podawana dokładna ścieżka, tekstury tam, gdzie plik
// - wczytanie kabiny, dokładna ścieżka, tekstury z katalogu modelu // - wczytanie kabiny, dokładna ścieżka, tekstury z katalogu modelu
// - wczytanie ładunku, ścieżka dokładna, tekstury z katalogu modelu // - wczytanie ładunku, ścieżka dokładna, tekstury z katalogu modelu
@@ -87,9 +89,10 @@ TModel3d* __fastcall TModelsManager::GetModel(const char *Name,bool dynamic)
// - niebo animowane, ścieżka brana ze wpisu, tekstury nieokreślone // - niebo animowane, ścieżka brana ze wpisu, tekstury nieokreślone
// - wczytanie modelu animowanego - Init() - sprawdzić // - wczytanie modelu animowanego - Init() - sprawdzić
char buf[255]; char buf[255];
AnsiString buftp=Global::asCurrentTexturePath; //zapamiętanie aktualnej ścieżki do tekstur, bo będzie tyczmasowo zmieniana AnsiString buftp = Global::asCurrentTexturePath; // zapamiętanie aktualnej ścieżki do tekstur,
/* // bo będzie tyczmasowo zmieniana
// Ra: niby tak jest lepiej, ale działa gorzej, więc przywrócone jest oryginalne /*
// Ra: niby tak jest lepiej, ale działa gorzej, więc przywrócone jest oryginalne
//nawet jeśli model będzie pobrany z tablicy, to trzeba ustalić ścieżkę dla tekstur //nawet jeśli model będzie pobrany z tablicy, to trzeba ustalić ścieżkę dla tekstur
if (dynamic) //na razie tak, bo nie wiadomo, jaki może mieć wpływ na pozostałe modele if (dynamic) //na razie tak, bo nie wiadomo, jaki może mieć wpływ na pozostałe modele
{//dla pojazdów podana jest zawsze pełna ścieżka do modelu {//dla pojazdów podana jest zawsze pełna ścieżka do modelu
@@ -103,7 +106,8 @@ TModel3d* __fastcall TModelsManager::GetModel(const char *Name,bool dynamic)
else else
{//dla modeli scenerii trzeba ustalić ścieżkę {//dla modeli scenerii trzeba ustalić ścieżkę
if (strchr(Name,'\\')==NULL) if (strchr(Name,'\\')==NULL)
{//jeśli nie ma lewego ukośnika w ścieżce, a jest prawy, to zmienić ścieżkę dla tekstur na tę z modelem {//jeśli nie ma lewego ukośnika w ścieżce, a jest prawy, to zmienić ścieżkę dla tekstur na tę
z modelem
strcpy(buf,"models\\"); //Ra: było by lepiej katalog dodać w parserze strcpy(buf,"models\\"); //Ra: było by lepiej katalog dodać w parserze
//strcpy(buf,"scenery\\"); //Ra: było by lepiej katalog dodać w parserze //strcpy(buf,"scenery\\"); //Ra: było by lepiej katalog dodać w parserze
strcat(buf,Name); strcat(buf,Name);
@@ -127,38 +131,41 @@ TModel3d* __fastcall TModelsManager::GetModel(const char *Name,bool dynamic)
return (Models[i].Model); //model znaleziony return (Models[i].Model); //model znaleziony
} }
}; };
*/ */
if (strchr(Name,'\\')==NULL) if (strchr(Name, '\\') == NULL)
{ {
strcpy(buf,"models\\"); //Ra: było by lepiej katalog dodać w parserze strcpy(buf, "models\\"); // Ra: było by lepiej katalog dodać w parserze
strcat(buf,Name); strcat(buf, Name);
if (strchr(Name,'/')!=NULL) if (strchr(Name, '/') != NULL)
{ {
Global::asCurrentTexturePath= Global::asCurrentTexturePath+AnsiString(Name); Global::asCurrentTexturePath = Global::asCurrentTexturePath + AnsiString(Name);
Global::asCurrentTexturePath.Delete(Global::asCurrentTexturePath.Pos("/")+1,Global::asCurrentTexturePath.Length()); Global::asCurrentTexturePath.Delete(Global::asCurrentTexturePath.Pos("/") + 1,
Global::asCurrentTexturePath.Length());
} }
} }
else else
{strcpy(buf,Name); {
if (dynamic) //na razie tak, bo nie wiadomo, jaki może mieć wpływ na pozostałe modele strcpy(buf, Name);
if (strchr(Name,'/')!=NULL) if (dynamic) // na razie tak, bo nie wiadomo, jaki może mieć wpływ na pozostałe modele
{//pobieranie tekstur z katalogu, w którym jest model if (strchr(Name, '/') != NULL)
Global::asCurrentTexturePath= Global::asCurrentTexturePath+AnsiString(Name); { // pobieranie tekstur z katalogu, w którym jest model
Global::asCurrentTexturePath.Delete(Global::asCurrentTexturePath.Pos("/")+1,Global::asCurrentTexturePath.Length()); Global::asCurrentTexturePath = Global::asCurrentTexturePath + AnsiString(Name);
Global::asCurrentTexturePath.Delete(Global::asCurrentTexturePath.Pos("/") + 1,
Global::asCurrentTexturePath.Length());
} }
} }
StrLower(buf); StrLower(buf);
for (int i=0; i<Count; i++) for (int i = 0; i < Count; i++)
{ {
if (strcmp(buf,Models[i].Name)==0) if (strcmp(buf, Models[i].Name) == 0)
{ {
Global::asCurrentTexturePath= buftp; Global::asCurrentTexturePath = buftp;
return (Models[i].Model); return (Models[i].Model);
} }
}; };
TModel3d* tmpModel=LoadModel(buf,dynamic); //model nie znaleziony, to wczytać TModel3d *tmpModel = LoadModel(buf, dynamic); // model nie znaleziony, to wczytać
Global::asCurrentTexturePath=buftp; //odtworzenie ścieżki do tekstur Global::asCurrentTexturePath = buftp; // odtworzenie ścieżki do tekstur
return (tmpModel); //NULL jeśli błąd return (tmpModel); // NULL jeśli błąd
}; };
/* /*

32
MdlMngr.h
View File

@@ -2,33 +2,41 @@
#ifndef MdlMngrH #ifndef MdlMngrH
#define MdlMngrH #define MdlMngrH
#include "Model3d.h" #include "Model3d.h"
#include "usefull.h" #include "usefull.h"
class TMdlContainer class TMdlContainer
{ {
friend class TModelsManager; friend class TModelsManager;
__fastcall TMdlContainer() { Name= NULL; Model= NULL; }; __fastcall TMdlContainer()
__fastcall ~TMdlContainer() { SafeDeleteArray(Name); SafeDelete(Model); }; {
TModel3d* __fastcall LoadModel(char *newName,bool dynamic); Name = NULL;
Model = NULL;
};
__fastcall ~TMdlContainer()
{
SafeDeleteArray(Name);
SafeDelete(Model);
};
TModel3d *__fastcall LoadModel(char *newName, bool dynamic);
TModel3d *Model; TModel3d *Model;
char *Name; char *Name;
}; };
class TModelsManager class TModelsManager
{//klasa statyczna, nie ma obiektu { // klasa statyczna, nie ma obiektu
private: private:
static TMdlContainer *Models; static TMdlContainer *Models;
static int Count; static int Count;
static TModel3d* __fastcall LoadModel(char *Name,bool dynamic); static TModel3d *__fastcall LoadModel(char *Name, bool dynamic);
public:
// __fastcall TModelsManager(); public:
// __fastcall ~TModelsManager(); // __fastcall TModelsManager();
// __fastcall ~TModelsManager();
static void __fastcall Init(); static void __fastcall Init();
static void __fastcall Free(); static void __fastcall Free();
//McZapkie: dodalem sciezke, notabene Path!=Patch :) // McZapkie: dodalem sciezke, notabene Path!=Patch :)
static TModel3d* __fastcall GetModel(const char *Name,bool dynamic=false); static TModel3d *__fastcall GetModel(const char *Name, bool dynamic = false);
}; };
//--------------------------------------------------------------------------- //---------------------------------------------------------------------------
#endif #endif

183
MemCell.cpp
View File

@@ -6,7 +6,6 @@
*/ */
#include "system.hpp" #include "system.hpp"
#include "classes.hpp" #include "classes.hpp"
#pragma hdrstop #pragma hdrstop
@@ -26,75 +25,80 @@
__fastcall TMemCell::TMemCell(vector3 *p) __fastcall TMemCell::TMemCell(vector3 *p)
{ {
fValue1=fValue2=0; fValue1 = fValue2 = 0;
szText=new char[256]; //musi byæ dla automatycznie tworzonych komórek dla odcinków izolowanych szText = new char[256]; // musi byæ dla automatycznie tworzonych komórek dla odcinków
vPosition=p?*p:vector3(0,0,0); //ustawienie wspó³rzêdnych, bo do TGroundNode nie ma dostêpu // izolowanych
bCommand=false; //komenda wys³ana vPosition =
OnSent=NULL; p ? *p : vector3(0, 0, 0); // ustawienie wspó³rzêdnych, bo do TGroundNode nie ma dostêpu
bCommand = false; // komenda wys³ana
OnSent = NULL;
} }
__fastcall TMemCell::~TMemCell() __fastcall TMemCell::~TMemCell() { SafeDeleteArray(szText); }
{
SafeDeleteArray(szText);
}
void __fastcall TMemCell::Init() void __fastcall TMemCell::Init() {}
{
}
void __fastcall TMemCell::UpdateValues(char *szNewText, double fNewValue1, double fNewValue2, int CheckMask) void __fastcall TMemCell::UpdateValues(char *szNewText, double fNewValue1, double fNewValue2,
int CheckMask)
{ {
if (CheckMask&update_memadd) if (CheckMask & update_memadd)
{//dodawanie wartoœci { // dodawanie wartoœci
if (TestFlag(CheckMask,update_memstring)) if (TestFlag(CheckMask, update_memstring))
strcat(szText,szNewText); strcat(szText, szNewText);
if (TestFlag(CheckMask,update_memval1)) if (TestFlag(CheckMask, update_memval1))
fValue1+=fNewValue1; fValue1 += fNewValue1;
if (TestFlag(CheckMask,update_memval2)) if (TestFlag(CheckMask, update_memval2))
fValue2+=fNewValue2; fValue2 += fNewValue2;
} }
else else
{ {
if (TestFlag(CheckMask,update_memstring)) if (TestFlag(CheckMask, update_memstring))
strcpy(szText,szNewText); strcpy(szText, szNewText);
if (TestFlag(CheckMask,update_memval1)) if (TestFlag(CheckMask, update_memval1))
fValue1=fNewValue1; fValue1 = fNewValue1;
if (TestFlag(CheckMask,update_memval2)) if (TestFlag(CheckMask, update_memval2))
fValue2=fNewValue2; fValue2 = fNewValue2;
} }
if (TestFlag(CheckMask,update_memstring)) if (TestFlag(CheckMask, update_memstring))
CommandCheck();//jeœli zmieniony tekst, próbujemy rozpoznaæ komendê CommandCheck(); // jeœli zmieniony tekst, próbujemy rozpoznaæ komendê
} }
TCommandType __fastcall TMemCell::CommandCheck() TCommandType __fastcall TMemCell::CommandCheck()
{//rozpoznanie komendy { // rozpoznanie komendy
if (strcmp(szText,"SetVelocity")==0) //najpopularniejsze if (strcmp(szText, "SetVelocity") == 0) // najpopularniejsze
{eCommand=cm_SetVelocity; {
bCommand=false; //ta komenda nie jest wysy³ana eCommand = cm_SetVelocity;
bCommand = false; // ta komenda nie jest wysy³ana
} }
else if (strcmp(szText,"ShuntVelocity")==0) //w tarczach manewrowych else if (strcmp(szText, "ShuntVelocity") == 0) // w tarczach manewrowych
{eCommand=cm_ShuntVelocity; {
bCommand=false; //ta komenda nie jest wysy³ana eCommand = cm_ShuntVelocity;
bCommand = false; // ta komenda nie jest wysy³ana
} }
else if (strcmp(szText,"Change_direction")==0) //zdarza siê else if (strcmp(szText, "Change_direction") == 0) // zdarza siê
{eCommand=cm_ChangeDirection; {
bCommand=true; //do wys³ania eCommand = cm_ChangeDirection;
bCommand = true; // do wys³ania
} }
else if (strcmp(szText,"OutsideStation")==0) //zdarza siê else if (strcmp(szText, "OutsideStation") == 0) // zdarza siê
{eCommand=cm_OutsideStation; {
bCommand=false; //tego nie powinno byæ w komórce eCommand = cm_OutsideStation;
bCommand = false; // tego nie powinno byæ w komórce
} }
else if (strncmp(szText,"PassengerStopPoint:",19)==0) //porównanie pocz¹tków else if (strncmp(szText, "PassengerStopPoint:", 19) == 0) // porównanie pocz¹tków
{eCommand=cm_PassengerStopPoint; {
bCommand=false; //tego nie powinno byæ w komórce eCommand = cm_PassengerStopPoint;
bCommand = false; // tego nie powinno byæ w komórce
} }
else if (strcmp(szText,"SetProximityVelocity")==0) //nie powinno tego byæ else if (strcmp(szText, "SetProximityVelocity") == 0) // nie powinno tego byæ
{eCommand=cm_SetProximityVelocity; {
bCommand=false; //ta komenda nie jest wysy³ana eCommand = cm_SetProximityVelocity;
bCommand = false; // ta komenda nie jest wysy³ana
} }
else else
{eCommand=cm_Unknown; //ci¹g nierozpoznany (nie jest komend¹) {
bCommand=true; //do wys³ania eCommand = cm_Unknown; // ci¹g nierozpoznany (nie jest komend¹)
bCommand = true; // do wys³ania
} }
return eCommand; return eCommand;
} }
@@ -102,75 +106,72 @@ TCommandType __fastcall TMemCell::CommandCheck()
bool __fastcall TMemCell::Load(cParser *parser) bool __fastcall TMemCell::Load(cParser *parser)
{ {
std::string token; std::string token;
parser->getTokens(1,false); //case sensitive parser->getTokens(1, false); // case sensitive
*parser >> token; *parser >> token;
SafeDeleteArray(szText); SafeDeleteArray(szText);
szText=new char[256]; //musi byæ bufor do ³¹czenia tekstów szText = new char[256]; // musi byæ bufor do ³¹czenia tekstów
strcpy(szText,token.c_str()); strcpy(szText, token.c_str());
parser->getTokens(); parser->getTokens();
*parser >> fValue1; *parser >> fValue1;
parser->getTokens(); parser->getTokens();
*parser >> fValue2; *parser >> fValue2;
parser->getTokens(); parser->getTokens();
*parser >> token; *parser >> token;
if (token.compare("none")!=0) //gdy ró¿ne od "none" if (token.compare("none") != 0) // gdy ró¿ne od "none"
asTrackName=AnsiString(token.c_str()); //sprawdzane przez IsEmpty() asTrackName = AnsiString(token.c_str()); // sprawdzane przez IsEmpty()
parser->getTokens(); parser->getTokens();
*parser >> token; *parser >> token;
if (token.compare("endmemcell")!=0) if (token.compare("endmemcell") != 0)
Error("endmemcell statement missing"); Error("endmemcell statement missing");
CommandCheck(); CommandCheck();
return true; return true;
} }
void __fastcall TMemCell::PutCommand(TController *Mech, vector3 *Loc) void __fastcall TMemCell::PutCommand(TController *Mech, vector3 *Loc)
{//wys³anie zawartoœci komórki do AI { // wys³anie zawartoœci komórki do AI
if (Mech) if (Mech)
Mech->PutCommand(szText,fValue1,fValue2,Loc); Mech->PutCommand(szText, fValue1, fValue2, Loc);
} }
bool __fastcall TMemCell::Compare(char *szTestText,double fTestValue1,double fTestValue2,int CheckMask) bool __fastcall TMemCell::Compare(char *szTestText, double fTestValue1, double fTestValue2,
{//porównanie zawartoœci komórki pamiêci z podanymi wartoœciami int CheckMask)
if (TestFlag(CheckMask,conditional_memstring)) { // porównanie zawartoœci komórki pamiêci z podanymi wartoœciami
{//porównaæ teksty if (TestFlag(CheckMask, conditional_memstring))
char *pos=StrPos(szTestText,"*"); //zwraca wskaŸnik na pozycjê albo NULL { // porównaæ teksty
char *pos = StrPos(szTestText, "*"); // zwraca wskaŸnik na pozycjê albo NULL
if (pos) if (pos)
{//porównanie fragmentu ³añcucha { // porównanie fragmentu ³añcucha
int i=pos-szTestText; //iloœæ porównywanych znaków int i = pos - szTestText; // iloœæ porównywanych znaków
if (i) //jeœli nie jest pierwszym znakiem if (i) // jeœli nie jest pierwszym znakiem
if (AnsiString(szTestText,i)!=AnsiString(szText,i)) if (AnsiString(szTestText, i) != AnsiString(szText, i))
return false; //pocz¹tki o d³ugoœci (i) s¹ ró¿ne return false; // pocz¹tki o d³ugoœci (i) s¹ ró¿ne
} }
else else if (AnsiString(szTestText) != AnsiString(szText))
if (AnsiString(szTestText)!=AnsiString(szText))
return false; //³¹ñcuchy s¹ ró¿ne return false; //³¹ñcuchy s¹ ró¿ne
} }
//tekst zgodny, porównaæ resztê // tekst zgodny, porównaæ resztê
return ((!TestFlag(CheckMask,conditional_memval1) || (fValue1==fTestValue1)) && return ((!TestFlag(CheckMask, conditional_memval1) || (fValue1 == fTestValue1)) &&
(!TestFlag(CheckMask,conditional_memval2) || (fValue2==fTestValue2))); (!TestFlag(CheckMask, conditional_memval2) || (fValue2 == fTestValue2)));
}; };
bool __fastcall TMemCell::Render() bool __fastcall TMemCell::Render() { return true; }
{
return true;
}
bool __fastcall TMemCell::IsVelocity() bool __fastcall TMemCell::IsVelocity()
{//sprawdzenie, czy event odczytu tej komórki ma byæ do skanowania, czy do kolejkowania { // sprawdzenie, czy event odczytu tej komórki ma byæ do skanowania, czy do kolejkowania
if (eCommand==cm_SetVelocity) return true; if (eCommand == cm_SetVelocity)
if (eCommand==cm_ShuntVelocity) return true; return true;
return (eCommand==cm_SetProximityVelocity); if (eCommand == cm_ShuntVelocity)
return true;
return (eCommand == cm_SetProximityVelocity);
}; };
void __fastcall TMemCell::StopCommandSent() void __fastcall TMemCell::StopCommandSent()
{// { //
if (!bCommand) return; if (!bCommand)
bCommand=false; return;
if (OnSent) //jeœli jest event bCommand = false;
Global::AddToQuery(OnSent,NULL); if (OnSent) // jeœli jest event
Global::AddToQuery(OnSent, NULL);
}; };
void __fastcall TMemCell::AssignEvents(TEvent *e) void __fastcall TMemCell::AssignEvents(TEvent *e) { // powi¹zanie eventu OnSent = e; };
{//powi¹zanie eventu
OnSent=e;
};

29
MemCell.h
View File

@@ -9,30 +9,33 @@ using namespace Math3D;
class TMemCell class TMemCell
{ {
private: private:
vector3 vPosition; vector3 vPosition;
char *szText; char *szText;
double fValue1; double fValue1;
double fValue2; double fValue2;
TCommandType eCommand; TCommandType eCommand;
bool bCommand; //czy zawiera komendê dla zatrzymanego AI bool bCommand; // czy zawiera komendê dla zatrzymanego AI
TEvent *OnSent; //event dodawany do kolejki po wys³aniu komendy zatrzymuj¹cej sk³ad TEvent *OnSent; // event dodawany do kolejki po wys³aniu komendy zatrzymuj¹cej sk³ad
public: public:
AnsiString asTrackName; //McZapkie-100302 - zeby nazwe toru na ktory jest Putcommand wysylane pamietac AnsiString
asTrackName; // McZapkie-100302 - zeby nazwe toru na ktory jest Putcommand wysylane pamietac
__fastcall TMemCell(vector3 *p); __fastcall TMemCell(vector3 *p);
__fastcall ~TMemCell(); __fastcall ~TMemCell();
void __fastcall Init(); void __fastcall Init();
void __fastcall UpdateValues(char *szNewText, double fNewValue1, double fNewValue2, int CheckMask); void __fastcall UpdateValues(char *szNewText, double fNewValue1, double fNewValue2,
int CheckMask);
bool __fastcall Load(cParser *parser); bool __fastcall Load(cParser *parser);
void __fastcall PutCommand(TController *Mech, vector3 *Loc); void __fastcall PutCommand(TController *Mech, vector3 *Loc);
bool __fastcall Compare(char *szTestText, double fTestValue1, double fTestValue2, int CheckMask); bool __fastcall Compare(char *szTestText, double fTestValue1, double fTestValue2,
int CheckMask);
bool __fastcall Render(); bool __fastcall Render();
inline char* __fastcall Text() {return szText;}; inline char *__fastcall Text() { return szText; };
inline double __fastcall Value1() {return fValue1;}; inline double __fastcall Value1() { return fValue1; };
inline double __fastcall Value2() {return fValue2;}; inline double __fastcall Value2() { return fValue2; };
inline vector3 __fastcall Position() {return vPosition;}; inline vector3 __fastcall Position() { return vPosition; };
inline TCommandType __fastcall Command() {return eCommand;}; inline TCommandType __fastcall Command() { return eCommand; };
inline bool __fastcall StopCommand() {return bCommand;}; inline bool __fastcall StopCommand() { return bCommand; };
void __fastcall StopCommandSent(); void __fastcall StopCommandSent();
TCommandType __fastcall CommandCheck(); TCommandType __fastcall CommandCheck();
bool __fastcall IsVelocity(); bool __fastcall IsVelocity();

2662
Model3d.cpp
View File

File diff suppressed because it is too large Load Diff

443
Model3d.h
View File

@@ -13,7 +13,7 @@ struct GLVERTEX
{ {
vector3 Point; vector3 Point;
vector3 Normal; vector3 Normal;
float tu,tv; float tu, tv;
}; };
class TStringPack class TStringPack
@@ -26,29 +26,32 @@ class TStringPack
//+0 - 4 bajty: typ kromki //+0 - 4 bajty: typ kromki
//+4 - 4 bajty: długość łącznie z nagłówkiem //+4 - 4 bajty: długość łącznie z nagłówkiem
//+8 - tabela indeksów //+8 - tabela indeksów
public: public:
char* String(int n); char *String(int n);
char* StringAt(int n) {return data+9+n;}; char *StringAt(int n) { return data + 9 + n; };
__fastcall TStringPack() {data=NULL; index=NULL;}; __fastcall TStringPack()
void __fastcall Init(char *d) {data=d;}; {
void __fastcall InitIndex(int *i) {index=i;}; data = NULL;
index = NULL;
};
void __fastcall Init(char *d) { data = d; };
void __fastcall InitIndex(int *i) { index = i; };
}; };
class TMaterialColor class TMaterialColor
{ {
public: public:
__fastcall TMaterialColor() {}; __fastcall TMaterialColor(){};
__fastcall TMaterialColor(char V) __fastcall TMaterialColor(char V) { r = g = b = V; };
{
r=g=b=V;
};
// __fastcall TMaterialColor(double R, double G, double B) // __fastcall TMaterialColor(double R, double G, double B)
__fastcall TMaterialColor(char R, char G, char B) __fastcall TMaterialColor(char R, char G, char B)
{ {
r=R; g=G; b=B; r = R;
g = G;
b = B;
}; };
char r,g,b; char r, g, b;
}; };
/* /*
@@ -56,7 +59,8 @@ struct TMaterial
{ {
int ID; int ID;
AnsiString Name; AnsiString Name;
//McZapkie-240702: lepiej uzywac wartosci float do opisu koloru bo funkcje opengl chyba tego na ogol uzywaja //McZapkie-240702: lepiej uzywac wartosci float do opisu koloru bo funkcje opengl chyba tego na ogol
uzywaja
float Ambient[4]; float Ambient[4];
float Diffuse[4]; float Diffuse[4];
float Specular[4]; float Specular[4];
@@ -100,264 +104,297 @@ typedef enum
smt_Stars //wiele punktów świetlnych smt_Stars //wiele punktów świetlnych
} TSubModelType; } TSubModelType;
*/ */
//Ra: specjalne typy submodeli, poza tym GL_TRIANGLES itp. // Ra: specjalne typy submodeli, poza tym GL_TRIANGLES itp.
const int TP_ROTATOR=256; const int TP_ROTATOR = 256;
const int TP_FREESPOTLIGHT=257; const int TP_FREESPOTLIGHT = 257;
const int TP_STARS=258; const int TP_STARS = 258;
const int TP_TEXT=259; const int TP_TEXT = 259;
enum TAnimType //rodzaj animacji enum TAnimType // rodzaj animacji
{at_None, //brak {
at_Rotate, //obrót względem wektora o kąt at_None, // brak
at_RotateXYZ, //obrót względem osi o kąty at_Rotate, // obrót względem wektora o kąt
at_Translate, //przesunięcie at_RotateXYZ, // obrót względem osi o kąty
at_SecondsJump, //sekundy z przeskokiem at_Translate, // przesunięcie
at_MinutesJump, //minuty z przeskokiem at_SecondsJump, // sekundy z przeskokiem
at_HoursJump, //godziny z przeskokiem 12h/360° at_MinutesJump, // minuty z przeskokiem
at_Hours24Jump, //godziny z przeskokiem 24h/360° at_HoursJump, // godziny z przeskokiem 12h/360°
at_Seconds, //sekundy płynnie at_Hours24Jump, // godziny z przeskokiem 24h/360°
at_Minutes, //minuty płynnie at_Seconds, // sekundy płynnie
at_Hours, //godziny płynnie 12h/360° at_Minutes, // minuty płynnie
at_Hours24, //godziny płynnie 24h/360° at_Hours, // godziny płynnie 12h/360°
at_Billboard, //obrót w pionie do kamery at_Hours24, // godziny płynnie 24h/360°
at_Wind, //ruch pod wpływem wiatru at_Billboard, // obrót w pionie do kamery
at_Sky, //animacja nieba at_Wind, // ruch pod wpływem wiatru
at_IK=0x100, //odwrotna kinematyka - submodel sterujący (np. staw skokowy) at_Sky, // animacja nieba
at_IK11=0x101, //odwrotna kinematyka - submodel nadrzędny do sterowango (np. stopa) at_IK = 0x100, // odwrotna kinematyka - submodel sterujący (np. staw skokowy)
at_IK21=0x102, //odwrotna kinematyka - submodel nadrzędny do sterowango (np. podudzie) at_IK11 = 0x101, // odwrotna kinematyka - submodel nadrzędny do sterowango (np. stopa)
at_IK22=0x103, //odwrotna kinematyka - submodel nadrzędny do nadrzędnego sterowango (np. udo) at_IK21 = 0x102, // odwrotna kinematyka - submodel nadrzędny do sterowango (np. podudzie)
at_Digital=0x200, //dziesięciocyfrowy licznik mechaniczny (z cylindrami) at_IK22 = 0x103, // odwrotna kinematyka - submodel nadrzędny do nadrzędnego sterowango (np. udo)
at_DigiClk=0x201, //zegar cyfrowy jako licznik na dziesięciościanach at_Digital = 0x200, // dziesięciocyfrowy licznik mechaniczny (z cylindrami)
at_Undefined=0x800000FF //animacja chwilowo nieokreślona at_DigiClk = 0x201, // zegar cyfrowy jako licznik na dziesięciościanach
at_Undefined = 0x800000FF // animacja chwilowo nieokreślona
}; };
class TModel3d; class TModel3d;
class TSubModelInfo; class TSubModelInfo;
class TSubModel class TSubModel
{//klasa submodelu - pojedyncza siatka, punkt świetlny albo grupa punktów { // klasa submodelu - pojedyncza siatka, punkt świetlny albo grupa punktów
//Ra: ta klasa ma mieć wielkość 256 bajtów, aby pokryła się z formatem binarnym // Ra: ta klasa ma mieć wielkość 256 bajtów, aby pokryła się z formatem binarnym
//Ra: nie przestawiać zmiennych, bo wczytują się z pliku binarnego! // Ra: nie przestawiać zmiennych, bo wczytują się z pliku binarnego!
private: private:
TSubModel *Next; TSubModel *Next;
TSubModel *Child; TSubModel *Child;
int eType; //Ra: modele binarne dają więcej możliwości niż mesh złożony z trójkątów int eType; // Ra: modele binarne dają więcej możliwości niż mesh złożony z trójkątów
int iName; //numer łańcucha z nazwą submodelu, albo -1 gdy anonimowy int iName; // numer łańcucha z nazwą submodelu, albo -1 gdy anonimowy
public: //chwilowo public: // chwilowo
TAnimType b_Anim; TAnimType b_Anim;
private:
int iFlags; //flagi informacyjne: private:
//bit 0: =1 faza rysowania zależy od wymiennej tekstury 0 int iFlags; // flagi informacyjne:
//bit 1: =1 faza rysowania zależy od wymiennej tekstury 1 // bit 0: =1 faza rysowania zależy od wymiennej tekstury 0
//bit 2: =1 faza rysowania zależy od wymiennej tekstury 2 // bit 1: =1 faza rysowania zależy od wymiennej tekstury 1
//bit 3: =1 faza rysowania zależy od wymiennej tekstury 3 // bit 2: =1 faza rysowania zależy od wymiennej tekstury 2
//bit 4: =1 rysowany w fazie nieprzezroczystych (stała tekstura albo brak) // bit 3: =1 faza rysowania zależy od wymiennej tekstury 3
//bit 5: =1 rysowany w fazie przezroczystych (stała tekstura) // bit 4: =1 rysowany w fazie nieprzezroczystych (stała tekstura albo brak)
//bit 7: =1 ta sama tekstura, co poprzedni albo nadrzędny // bit 5: =1 rysowany w fazie przezroczystych (stała tekstura)
//bit 8: =1 wierzchołki wyświetlane z indeksów // bit 7: =1 ta sama tekstura, co poprzedni albo nadrzędny
//bit 9: =1 wczytano z pliku tekstowego (jest właścicielem tablic) // bit 8: =1 wierzchołki wyświetlane z indeksów
//bit 13: =1 wystarczy przesunięcie zamiast mnożenia macierzy (trzy jedynki) // bit 9: =1 wczytano z pliku tekstowego (jest właścicielem tablic)
//bit 14: =1 wymagane przechowanie macierzy (animacje) // bit 13: =1 wystarczy przesunięcie zamiast mnożenia macierzy (trzy jedynki)
//bit 15: =1 wymagane przechowanie macierzy (transform niejedynkowy) // bit 14: =1 wymagane przechowanie macierzy (animacje)
// bit 15: =1 wymagane przechowanie macierzy (transform niejedynkowy)
union union
{//transform, nie każdy submodel musi mieć { // transform, nie każdy submodel musi mieć
float4x4 *fMatrix; //pojedyncza precyzja wystarcza float4x4 *fMatrix; // pojedyncza precyzja wystarcza
//matrix4x4 *dMatrix; //do testu macierz podwójnej precyzji // matrix4x4 *dMatrix; //do testu macierz podwójnej precyzji
int iMatrix; //w pliku binarnym jest numer matrycy int iMatrix; // w pliku binarnym jest numer matrycy
}; };
int iNumVerts; //ilość wierzchołków (1 dla FreeSpotLight) int iNumVerts; // ilość wierzchołków (1 dla FreeSpotLight)
int iVboPtr; //początek na liście wierzchołków albo indeksów int iVboPtr; // początek na liście wierzchołków albo indeksów
int iTexture; //numer nazwy tekstury, -1 wymienna, 0 brak int iTexture; // numer nazwy tekstury, -1 wymienna, 0 brak
float fVisible; //próg jasności światła do załączenia submodelu float fVisible; // próg jasności światła do załączenia submodelu
float fLight; //próg jasności światła do zadziałania selfillum float fLight; // próg jasności światła do zadziałania selfillum
float f4Ambient[4]; float f4Ambient[4];
float f4Diffuse[4]; //float ze względu na glMaterialfv() float f4Diffuse[4]; // float ze względu na glMaterialfv()
float f4Specular[4]; float f4Specular[4];
float f4Emision[4]; float f4Emision[4];
float fWireSize; //nie używane, ale wczytywane float fWireSize; // nie używane, ale wczytywane
float fSquareMaxDist; float fSquareMaxDist;
float fSquareMinDist; float fSquareMinDist;
//McZapkie-050702: parametry dla swiatla: // McZapkie-050702: parametry dla swiatla:
float fNearAttenStart; float fNearAttenStart;
float fNearAttenEnd; float fNearAttenEnd;
int bUseNearAtten; //te 3 zmienne okreslaja rysowanie aureoli wokol zrodla swiatla int bUseNearAtten; // te 3 zmienne okreslaja rysowanie aureoli wokol zrodla swiatla
int iFarAttenDecay; //ta zmienna okresla typ zaniku natezenia swiatla (0:brak, 1,2: potega 1/R) int iFarAttenDecay; // ta zmienna okresla typ zaniku natezenia swiatla (0:brak, 1,2: potega 1/R)
float fFarDecayRadius; //normalizacja j.w. float fFarDecayRadius; // normalizacja j.w.
float fCosFalloffAngle; //cosinus kąta stożka pod którym widać światło float fCosFalloffAngle; // cosinus kąta stożka pod którym widać światło
float fCosHotspotAngle; //cosinus kąta stożka pod którym widać aureolę i zwiększone natężenie światła float fCosHotspotAngle; // cosinus kąta stożka pod którym widać aureolę i zwiększone natężenie
float fCosViewAngle; //cos kata pod jakim sie teraz patrzy // światła
//Ra: dalej są zmienne robocze, można je przestawiać z zachowaniem rozmiaru klasy float fCosViewAngle; // cos kata pod jakim sie teraz patrzy
int TextureID; //numer tekstury, -1 wymienna, 0 brak // Ra: dalej są zmienne robocze, można je przestawiać z zachowaniem rozmiaru klasy
int bWire; //nie używane, ale wczytywane int TextureID; // numer tekstury, -1 wymienna, 0 brak
//short TexAlpha; //Ra: nie używane już int bWire; // nie używane, ale wczytywane
GLuint uiDisplayList; //roboczy numer listy wyświetlania // short TexAlpha; //Ra: nie używane już
float Opacity; //nie używane, ale wczytywane GLuint uiDisplayList; // roboczy numer listy wyświetlania
//ABu: te same zmienne, ale zdublowane dla Render i RenderAlpha, float Opacity; // nie używane, ale wczytywane
//bo sie chrzanilo przemieszczanie obiektow. // ABu: te same zmienne, ale zdublowane dla Render i RenderAlpha,
//Ra: już się nie chrzani // bo sie chrzanilo przemieszczanie obiektow.
// Ra: już się nie chrzani
float f_Angle; float f_Angle;
float3 v_RotateAxis; float3 v_RotateAxis;
float3 v_Angles; float3 v_Angles;
public: //chwilowo
public: // chwilowo
float3 v_TransVector; float3 v_TransVector;
float8 *Vertices; //roboczy wskaźnik - wczytanie T3D do VBO float8 *Vertices; // roboczy wskaźnik - wczytanie T3D do VBO
int iAnimOwner; //roboczy numer egzemplarza, który ustawił animację int iAnimOwner; // roboczy numer egzemplarza, który ustawił animację
TAnimType b_aAnim; //kody animacji oddzielnie, bo zerowane TAnimType b_aAnim; // kody animacji oddzielnie, bo zerowane
public: public:
float4x4 *mAnimMatrix; //macierz do animacji kwaternionowych (należy do AnimContainer) float4x4 *mAnimMatrix; // macierz do animacji kwaternionowych (należy do AnimContainer)
char space[8]; //wolne miejsce na przyszłe zmienne (zmniejszyć w miarę potrzeby) char space[8]; // wolne miejsce na przyszłe zmienne (zmniejszyć w miarę potrzeby)
public: public:
TSubModel **smLetter; //wskaźnik na tablicę submdeli do generoania tekstu (docelowo zapisać do E3D) TSubModel **
TSubModel *Parent; //nadrzędny, np. do wymnażania macierzy smLetter; // wskaźnik na tablicę submdeli do generoania tekstu (docelowo zapisać do E3D)
int iVisible; //roboczy stan widoczności TSubModel *Parent; // nadrzędny, np. do wymnażania macierzy
//AnsiString asTexture; //robocza nazwa tekstury do zapisania w pliku binarnym int iVisible; // roboczy stan widoczności
//AnsiString asName; //robocza nazwa // AnsiString asTexture; //robocza nazwa tekstury do zapisania w pliku binarnym
char *pTexture; //robocza nazwa tekstury do zapisania w pliku binarnym // AnsiString asName; //robocza nazwa
char *pName; //robocza nazwa char *pTexture; // robocza nazwa tekstury do zapisania w pliku binarnym
private: char *pName; // robocza nazwa
//int __fastcall SeekFaceNormal(DWORD *Masks, int f,DWORD dwMask,vector3 *pt,GLVERTEX *Vertices); private:
int __fastcall SeekFaceNormal(DWORD *Masks,int f,DWORD dwMask,float3 *pt,float8 *Vertices); // int __fastcall SeekFaceNormal(DWORD *Masks, int f,DWORD dwMask,vector3 *pt,GLVERTEX
// *Vertices);
int __fastcall SeekFaceNormal(DWORD *Masks, int f, DWORD dwMask, float3 *pt, float8 *Vertices);
void __fastcall RaAnimation(TAnimType a); void __fastcall RaAnimation(TAnimType a);
public:
static int iInstance; //identyfikator egzemplarza, który aktualnie renderuje model public:
static int iInstance; // identyfikator egzemplarza, który aktualnie renderuje model
static GLuint *ReplacableSkinId; static GLuint *ReplacableSkinId;
static int iAlpha; //maska bitowa dla danego przebiegu static int iAlpha; // maska bitowa dla danego przebiegu
static double fSquareDist; static double fSquareDist;
static TModel3d* pRoot; static TModel3d *pRoot;
static AnsiString* pasText; //tekst dla wyświetlacza (!!!! do przemyślenia) static AnsiString *pasText; // tekst dla wyświetlacza (!!!! do przemyślenia)
__fastcall TSubModel(); __fastcall TSubModel();
__fastcall ~TSubModel(); __fastcall ~TSubModel();
void __fastcall FirstInit(); void __fastcall FirstInit();
int __fastcall Load(cParser& Parser, TModel3d *Model,int Pos,bool dynamic); int __fastcall Load(cParser &Parser, TModel3d *Model, int Pos, bool dynamic);
void __fastcall ChildAdd(TSubModel *SubModel); void __fastcall ChildAdd(TSubModel *SubModel);
void __fastcall NextAdd(TSubModel *SubModel); void __fastcall NextAdd(TSubModel *SubModel);
TSubModel* __fastcall NextGet() {return Next;}; TSubModel *__fastcall NextGet() { return Next; };
TSubModel* __fastcall ChildGet() {return Child;}; TSubModel *__fastcall ChildGet() { return Child; };
int __fastcall TriangleAdd(TModel3d *m,int tex,int tri); int __fastcall TriangleAdd(TModel3d *m, int tex, int tri);
float8* __fastcall TrianglePtr(int tex,int pos,int *la,int *ld,int*ls); float8 *__fastcall TrianglePtr(int tex, int pos, int *la, int *ld, int *ls);
//float8* __fastcall TrianglePtr(const char *tex,int tri); // float8* __fastcall TrianglePtr(const char *tex,int tri);
//void __fastcall SetRotate(vector3 vNewRotateAxis,float fNewAngle); // void __fastcall SetRotate(vector3 vNewRotateAxis,float fNewAngle);
void __fastcall SetRotate(float3 vNewRotateAxis,float fNewAngle); void __fastcall SetRotate(float3 vNewRotateAxis, float fNewAngle);
void __fastcall SetRotateXYZ(vector3 vNewAngles); void __fastcall SetRotateXYZ(vector3 vNewAngles);
void __fastcall SetRotateXYZ(float3 vNewAngles); void __fastcall SetRotateXYZ(float3 vNewAngles);
void __fastcall SetTranslate(vector3 vNewTransVector); void __fastcall SetTranslate(vector3 vNewTransVector);
void __fastcall SetTranslate(float3 vNewTransVector); void __fastcall SetTranslate(float3 vNewTransVector);
void __fastcall SetRotateIK1(float3 vNewAngles); void __fastcall SetRotateIK1(float3 vNewAngles);
TSubModel* __fastcall GetFromName(AnsiString search,bool i=true); TSubModel *__fastcall GetFromName(AnsiString search, bool i = true);
TSubModel* __fastcall GetFromName(char *search,bool i=true); TSubModel *__fastcall GetFromName(char *search, bool i = true);
void __fastcall RenderDL(); void __fastcall RenderDL();
void __fastcall RenderAlphaDL(); void __fastcall RenderAlphaDL();
void __fastcall RenderVBO(); void __fastcall RenderVBO();
void __fastcall RenderAlphaVBO(); void __fastcall RenderAlphaVBO();
//inline matrix4x4* __fastcall GetMatrix() {return dMatrix;}; // inline matrix4x4* __fastcall GetMatrix() {return dMatrix;};
inline float4x4* __fastcall GetMatrix() {return fMatrix;}; inline float4x4 *__fastcall GetMatrix() { return fMatrix; };
//matrix4x4* __fastcall GetTransform() {return Matrix;}; // matrix4x4* __fastcall GetTransform() {return Matrix;};
inline void __fastcall Hide() {iVisible=0;}; inline void __fastcall Hide() { iVisible = 0; };
void __fastcall RaArrayFill(CVertNormTex *Vert); void __fastcall RaArrayFill(CVertNormTex *Vert);
//void __fastcall Render(); // void __fastcall Render();
int __fastcall FlagsCheck(); int __fastcall FlagsCheck();
void __fastcall WillBeAnimated() {if (this) iFlags|=0x4000;}; void __fastcall WillBeAnimated()
{
if (this)
iFlags |= 0x4000;
};
void __fastcall InitialRotate(bool doit); void __fastcall InitialRotate(bool doit);
void __fastcall DisplayLists(); void __fastcall DisplayLists();
void __fastcall Info(); void __fastcall Info();
void __fastcall InfoSet(TSubModelInfo *info); void __fastcall InfoSet(TSubModelInfo *info);
void __fastcall BinInit(TSubModel *s,float4x4 *m,float8 *v,TStringPack *t,TStringPack *n=NULL,bool dynamic=false); void __fastcall BinInit(TSubModel *s, float4x4 *m, float8 *v, TStringPack *t,
void __fastcall ReplacableSet(GLuint *r,int a) TStringPack *n = NULL, bool dynamic = false);
{ReplacableSkinId=r; iAlpha=a;}; void __fastcall ReplacableSet(GLuint *r, int a)
{
ReplacableSkinId = r;
iAlpha = a;
};
void __fastcall TextureNameSet(const char *n); void __fastcall TextureNameSet(const char *n);
void __fastcall NameSet(const char *n); void __fastcall NameSet(const char *n);
//Ra: funkcje do budowania terenu z E3D // Ra: funkcje do budowania terenu z E3D
int __fastcall Flags() {return iFlags;}; int __fastcall Flags() { return iFlags; };
void __fastcall UnFlagNext() {iFlags&=0x00FFFFFF;}; void __fastcall UnFlagNext() { iFlags &= 0x00FFFFFF; };
void __fastcall ColorsSet(int *a,int *d,int*s); void __fastcall ColorsSet(int *a, int *d, int *s);
inline float3 Translation1Get() inline float3 Translation1Get()
{return fMatrix?*(fMatrix->TranslationGet())+v_TransVector:v_TransVector;} {
return fMatrix ? *(fMatrix->TranslationGet()) + v_TransVector : v_TransVector;
}
inline float3 Translation2Get() inline float3 Translation2Get()
{return *(fMatrix->TranslationGet())+Child->Translation1Get();} {
return *(fMatrix->TranslationGet()) + Child->Translation1Get();
}
void __fastcall ParentMatrix(float4x4 *m); void __fastcall ParentMatrix(float4x4 *m);
float __fastcall MaxY(const float4x4 &m); float __fastcall MaxY(const float4x4 &m);
void __fastcall AdjustDist(); void __fastcall AdjustDist();
}; };
class TSubModelInfo class TSubModelInfo
{//klasa z informacjami o submodelach, do tworzenia pliku binarnego { // klasa z informacjami o submodelach, do tworzenia pliku binarnego
public: public:
TSubModel *pSubModel; //wskaźnik na submodel TSubModel *pSubModel; // wskaźnik na submodel
int iTransform; //numer transformu (-1 gdy brak) int iTransform; // numer transformu (-1 gdy brak)
int iName; //numer nazwy int iName; // numer nazwy
int iTexture; //numer tekstury int iTexture; // numer tekstury
int iNameLen; //długość nazwy int iNameLen; // długość nazwy
int iTextureLen; //długość tekstury int iTextureLen; // długość tekstury
int iNext,iChild; //numer następnego i potomnego int iNext, iChild; // numer następnego i potomnego
static int iTotalTransforms; //ilość transformów static int iTotalTransforms; // ilość transformów
static int iTotalNames; //ilość nazw static int iTotalNames; // ilość nazw
static int iTotalTextures; //ilość tekstur static int iTotalTextures; // ilość tekstur
static int iCurrent; //aktualny obiekt static int iCurrent; // aktualny obiekt
static TSubModelInfo* pTable; //tabele obiektów pomocniczych static TSubModelInfo *pTable; // tabele obiektów pomocniczych
__fastcall TSubModelInfo() __fastcall TSubModelInfo()
{pSubModel=NULL; {
iTransform=iName=iTexture=iNext=iChild=-1; //nie ma pSubModel = NULL;
iNameLen=iTextureLen=0; iTransform = iName = iTexture = iNext = iChild = -1; // nie ma
iNameLen = iTextureLen = 0;
} }
void __fastcall Reset() void __fastcall Reset()
{pTable=this; //ustawienie wskaźnika tabeli obiektów {
iTotalTransforms=iTotalNames=iTotalTextures=iCurrent=0; //zerowanie liczników pTable = this; // ustawienie wskaźnika tabeli obiektów
iTotalTransforms = iTotalNames = iTotalTextures = iCurrent = 0; // zerowanie liczników
} }
__fastcall ~TSubModelInfo() {}; __fastcall ~TSubModelInfo(){};
}; };
class TModel3d : public CMesh class TModel3d : public CMesh
{ {
private: private:
//TMaterial *Materials; // TMaterial *Materials;
//int MaterialsCount; //Ra: nie używane // int MaterialsCount; //Ra: nie używane
//bool TractionPart; //Ra: nie używane // bool TractionPart; //Ra: nie używane
TSubModel *Root; //drzewo submodeli TSubModel *Root; // drzewo submodeli
int iFlags; //Ra: czy submodele mają przezroczyste tekstury int iFlags; // Ra: czy submodele mają przezroczyste tekstury
public: //Ra: tymczasowo public: // Ra: tymczasowo
int iNumVerts; //ilość wierzchołków (gdy nie ma VBO, to m_nVertexCount=0) int iNumVerts; // ilość wierzchołków (gdy nie ma VBO, to m_nVertexCount=0)
private: private:
TStringPack Textures; //nazwy tekstur TStringPack Textures; // nazwy tekstur
TStringPack Names; //nazwy submodeli TStringPack Names; // nazwy submodeli
int *iModel; //zawartość pliku binarnego int *iModel; // zawartość pliku binarnego
int iSubModelsCount; //Ra: używane do tworzenia binarnych int iSubModelsCount; // Ra: używane do tworzenia binarnych
AnsiString asBinary; //nazwa pod którą zapisać model binarny AnsiString asBinary; // nazwa pod którą zapisać model binarny
public: public:
inline TSubModel* __fastcall GetSMRoot() {return(Root);}; inline TSubModel *__fastcall GetSMRoot() { return (Root); };
//double Radius; //Ra: nie używane // double Radius; //Ra: nie używane
__fastcall TModel3d(); __fastcall TModel3d();
__fastcall TModel3d(char *FileName); __fastcall TModel3d(char *FileName);
__fastcall ~TModel3d(); __fastcall ~TModel3d();
TSubModel* __fastcall GetFromName(const char *sName); TSubModel *__fastcall GetFromName(const char *sName);
//TMaterial* __fastcall GetMaterialFromName(char *sName); // TMaterial* __fastcall GetMaterialFromName(char *sName);
TSubModel* __fastcall AddToNamed(const char *Name, TSubModel *SubModel); TSubModel *__fastcall AddToNamed(const char *Name, TSubModel *SubModel);
void __fastcall AddTo(TSubModel *tmp,TSubModel *SubModel); void __fastcall AddTo(TSubModel *tmp, TSubModel *SubModel);
void __fastcall LoadFromTextFile(char *FileName,bool dynamic); void __fastcall LoadFromTextFile(char *FileName, bool dynamic);
void __fastcall LoadFromBinFile(char *FileName,bool dynamic); void __fastcall LoadFromBinFile(char *FileName, bool dynamic);
bool __fastcall LoadFromFile(char *FileName,bool dynamic); bool __fastcall LoadFromFile(char *FileName, bool dynamic);
void __fastcall SaveToBinFile(char *FileName); void __fastcall SaveToBinFile(char *FileName);
void __fastcall BreakHierarhy(); void __fastcall BreakHierarhy();
//renderowanie specjalne // renderowanie specjalne
void __fastcall Render(double fSquareDistance,GLuint *ReplacableSkinId=NULL,int iAlpha=0x30300030); void __fastcall Render(double fSquareDistance, GLuint *ReplacableSkinId = NULL,
void __fastcall RenderAlpha(double fSquareDistance,GLuint *ReplacableSkinId=NULL,int iAlpha=0x30300030); int iAlpha = 0x30300030);
void __fastcall RaRender(double fSquareDistance,GLuint *ReplacableSkinId=NULL,int iAlpha=0x30300030); void __fastcall RenderAlpha(double fSquareDistance, GLuint *ReplacableSkinId = NULL,
void __fastcall RaRenderAlpha(double fSquareDistance,GLuint *ReplacableSkinId=NULL,int iAlpha=0x30300030); int iAlpha = 0x30300030);
//jeden kąt obrotu void __fastcall RaRender(double fSquareDistance, GLuint *ReplacableSkinId = NULL,
void __fastcall Render(vector3 pPosition,double fAngle=0,GLuint *ReplacableSkinId=NULL,int iAlpha=0x30300030); int iAlpha = 0x30300030);
void __fastcall RenderAlpha(vector3 pPosition,double fAngle=0,GLuint *ReplacableSkinId=NULL,int iAlpha=0x30300030); void __fastcall RaRenderAlpha(double fSquareDistance, GLuint *ReplacableSkinId = NULL,
void __fastcall RaRender(vector3 pPosition,double fAngle=0,GLuint *ReplacableSkinId=NULL,int iAlpha=0x30300030); int iAlpha = 0x30300030);
void __fastcall RaRenderAlpha(vector3 pPosition,double fAngle=0,GLuint *ReplacableSkinId=NULL,int iAlpha=0x30300030); // jeden kąt obrotu
//trzy kąty obrotu void __fastcall Render(vector3 pPosition, double fAngle = 0, GLuint *ReplacableSkinId = NULL,
void __fastcall Render(vector3* vPosition,vector3* vAngle,GLuint *ReplacableSkinId=NULL,int iAlpha=0x30300030); int iAlpha = 0x30300030);
void __fastcall RenderAlpha(vector3* vPosition,vector3* vAngle,GLuint *ReplacableSkinId=NULL,int iAlpha=0x30300030); void __fastcall RenderAlpha(vector3 pPosition, double fAngle = 0,
void __fastcall RaRender(vector3* vPosition,vector3* vAngle,GLuint *ReplacableSkinId=NULL,int iAlpha=0x30300030); GLuint *ReplacableSkinId = NULL, int iAlpha = 0x30300030);
void __fastcall RaRenderAlpha(vector3* vPosition,vector3* vAngle,GLuint *ReplacableSkinId=NULL,int iAlpha=0x30300030); void __fastcall RaRender(vector3 pPosition, double fAngle = 0, GLuint *ReplacableSkinId = NULL,
//inline int __fastcall GetSubModelsCount() { return (SubModelsCount); }; int iAlpha = 0x30300030);
int __fastcall Flags() {return iFlags;}; void __fastcall RaRenderAlpha(vector3 pPosition, double fAngle = 0,
GLuint *ReplacableSkinId = NULL, int iAlpha = 0x30300030);
// trzy kąty obrotu
void __fastcall Render(vector3 *vPosition, vector3 *vAngle, GLuint *ReplacableSkinId = NULL,
int iAlpha = 0x30300030);
void __fastcall RenderAlpha(vector3 *vPosition, vector3 *vAngle,
GLuint *ReplacableSkinId = NULL, int iAlpha = 0x30300030);
void __fastcall RaRender(vector3 *vPosition, vector3 *vAngle, GLuint *ReplacableSkinId = NULL,
int iAlpha = 0x30300030);
void __fastcall RaRenderAlpha(vector3 *vPosition, vector3 *vAngle,
GLuint *ReplacableSkinId = NULL, int iAlpha = 0x30300030);
// inline int __fastcall GetSubModelsCount() { return (SubModelsCount); };
int __fastcall Flags() { return iFlags; };
void __fastcall Init(); void __fastcall Init();
char* __fastcall NameGet() {return Root?Root->pName:NULL;}; char *__fastcall NameGet() { return Root ? Root->pName : NULL; };
int __fastcall TerrainCount(); int __fastcall TerrainCount();
TSubModel* __fastcall TerrainSquare(int n); TSubModel *__fastcall TerrainSquare(int n);
void __fastcall TerrainRenderVBO(int n); void __fastcall TerrainRenderVBO(int n);
}; };

697
Mover.cpp
View File

@@ -7,143 +7,170 @@
// Jeœli jakieœ zmienne nie s¹ u¿ywane w mover.pas, te¿ mo¿na je przenosiæ. // Jeœli jakieœ zmienne nie s¹ u¿ywane w mover.pas, te¿ mo¿na je przenosiæ.
// Przeniesienie wszystkiego na raz zrobi³o by zbyt wielki chaos do ogarniêcia. // Przeniesienie wszystkiego na raz zrobi³o by zbyt wielki chaos do ogarniêcia.
const dEpsilon=0.01; //1cm (zale¿y od typu sprzêgu...) const dEpsilon = 0.01; // 1cm (zale¿y od typu sprzêgu...)
__fastcall TMoverParameters::TMoverParameters(double VelInitial,AnsiString TypeNameInit,AnsiString NameInit, __fastcall TMoverParameters::TMoverParameters(double VelInitial, AnsiString TypeNameInit,
int LoadInitial,AnsiString LoadTypeInitial,int Cab) AnsiString NameInit, int LoadInitial,
: T_MoverParameters(VelInitial,TypeNameInit,NameInit,LoadInitial,LoadTypeInitial,Cab) AnsiString LoadTypeInitial, int Cab)
{//g³ówny konstruktor : T_MoverParameters(VelInitial, TypeNameInit, NameInit, LoadInitial, LoadTypeInitial, Cab)
DimHalf.x=0.5*Dim.W; //po³owa szerokoœci, OX jest w bok? { // g³ówny konstruktor
DimHalf.y=0.5*Dim.L; //po³owa d³ugoœci, OY jest do przodu? DimHalf.x = 0.5 * Dim.W; // po³owa szerokoœci, OX jest w bok?
DimHalf.z=0.5*Dim.H; //po³owa wysokoœci, OZ jest w górê? DimHalf.y = 0.5 * Dim.L; // po³owa d³ugoœci, OY jest do przodu?
//BrakeLevelSet(-2); //Pascal ustawia na 0, przestawimy na odciêcie (CHK jest jeszcze nie wczytane!) DimHalf.z = 0.5 * Dim.H; // po³owa wysokoœci, OZ jest w górê?
bPantKurek3=true; //domyœlnie zbiornik pantografu po³¹czony jest ze zbiornikiem g³ównym // BrakeLevelSet(-2); //Pascal ustawia na 0, przestawimy na odciêcie (CHK jest jeszcze nie
iProblem=0; //pojazd w pe³ni gotowy do ruchu // wczytane!)
iLights[0]=iLights[1]=0; //œwiat³a zgaszone bPantKurek3 = true; // domyœlnie zbiornik pantografu po³¹czony jest ze zbiornikiem g³ównym
iProblem = 0; // pojazd w pe³ni gotowy do ruchu
iLights[0] = iLights[1] = 0; //œwiat³a zgaszone
}; };
double __fastcall TMoverParameters::Distance(const TLocation &Loc1, const TLocation &Loc2,
double __fastcall TMoverParameters::Distance(const TLocation &Loc1,const TLocation &Loc2,const TDimension &Dim1,const TDimension &Dim2) const TDimension &Dim1, const TDimension &Dim2)
{//zwraca odleg³oœæ pomiêdzy pojazdami (Loc1) i (Loc2) z uwzglêdnieneim ich d³ugoœci (kule!) { // zwraca odleg³oœæ pomiêdzy pojazdami (Loc1) i (Loc2) z uwzglêdnieneim ich d³ugoœci (kule!)
return hypot(Loc2.X-Loc1.X,Loc1.Y-Loc2.Y)-0.5*(Dim2.L+Dim1.L); return hypot(Loc2.X - Loc1.X, Loc1.Y - Loc2.Y) - 0.5 * (Dim2.L + Dim1.L);
}; };
double __fastcall TMoverParameters::Distance(const vector3 &s1, const vector3 &s2, const vector3 &d1, const vector3 &d2) double __fastcall TMoverParameters::Distance(const vector3 &s1, const vector3 &s2,
{//obliczenie odleg³oœci prostopad³oœcianów o œrodkach (s1) i (s2) i wymiarach (d1) i (d2) const vector3 &d1, const vector3 &d2){
//return 0.0; //bêdzie zg³aszaæ warning - funkcja do usuniêcia, chyba ¿e siê przyda... // obliczenie odleg³oœci prostopad³oœcianów o œrodkach (s1) i (s2) i wymiarach (d1) i (d2)
// return 0.0; //bêdzie zg³aszaæ warning - funkcja do usuniêcia, chyba ¿e siê przyda...
}; };
double __fastcall TMoverParameters::CouplerDist(Byte Coupler) double __fastcall TMoverParameters::CouplerDist(Byte Coupler)
{//obliczenie odleg³oœci pomiêdzy sprzêgami (kula!) { // obliczenie odleg³oœci pomiêdzy sprzêgami (kula!)
return Couplers[Coupler].CoupleDist=Distance(Loc,Couplers[Coupler].Connected->Loc,Dim,Couplers[Coupler].Connected->Dim); //odleg³oœæ pomiêdzy sprzêgami (kula!) return Couplers[Coupler].CoupleDist =
Distance(Loc, Couplers[Coupler].Connected->Loc, Dim,
Couplers[Coupler].Connected->Dim); // odleg³oœæ pomiêdzy sprzêgami (kula!)
}; };
bool __fastcall TMoverParameters::Attach(Byte ConnectNo,Byte ConnectToNr,TMoverParameters *ConnectTo,Byte CouplingType,bool Forced) bool __fastcall TMoverParameters::Attach(Byte ConnectNo, Byte ConnectToNr,
{//³¹czenie do swojego sprzêgu (ConnectNo) pojazdu (ConnectTo) stron¹ (ConnectToNr) TMoverParameters *ConnectTo, Byte CouplingType,
//Ra: zwykle wykonywane dwukrotnie, dla ka¿dego pojazdu oddzielnie bool Forced)
//Ra: trzeba by odró¿niæ wymóg dociœniêcia od uszkodzenia sprzêgu przy podczepianiu AI do sk³adu { //³¹czenie do swojego sprzêgu (ConnectNo) pojazdu (ConnectTo) stron¹ (ConnectToNr)
if (ConnectTo) //jeœli nie pusty // Ra: zwykle wykonywane dwukrotnie, dla ka¿dego pojazdu oddzielnie
// Ra: trzeba by odró¿niæ wymóg dociœniêcia od uszkodzenia sprzêgu przy podczepianiu AI do
// sk³adu
if (ConnectTo) // jeœli nie pusty
{ {
if (ConnectToNr!=2) Couplers[ConnectNo].ConnectedNr=ConnectToNr; //2=nic nie pod³¹czone if (ConnectToNr != 2)
TCouplerType ct=ConnectTo->Couplers[Couplers[ConnectNo].ConnectedNr].CouplerType; //typ sprzêgu pod³¹czanego pojazdu Couplers[ConnectNo].ConnectedNr = ConnectToNr; // 2=nic nie pod³¹czone
Couplers[ConnectNo].Connected=ConnectTo; //tak podpi¹æ (do siebie) zawsze mo¿na, najwy¿ej bêdzie wirtualny TCouplerType ct = ConnectTo->Couplers[Couplers[ConnectNo].ConnectedNr]
CouplerDist(ConnectNo); //przeliczenie odleg³oœci pomiêdzy sprzêgami .CouplerType; // typ sprzêgu pod³¹czanego pojazdu
if (CouplingType==ctrain_virtual) return false; //wirtualny wiêcej nic nie robi Couplers[ConnectNo].Connected =
if (Forced?true:((Couplers[ConnectNo].CoupleDist<=dEpsilon)&&(Couplers[ConnectNo].CouplerType!=NoCoupler)&&(Couplers[ConnectNo].CouplerType==ct))) ConnectTo; // tak podpi¹æ (do siebie) zawsze mo¿na, najwy¿ej bêdzie wirtualny
{//stykaja sie zderzaki i kompatybilne typy sprzegow, chyba ¿e ³¹czenie na starcie CouplerDist(ConnectNo); // przeliczenie odleg³oœci pomiêdzy sprzêgami
if (Couplers[ConnectNo].CouplingFlag==ctrain_virtual) //jeœli wczeœniej nie by³o po³¹czone if (CouplingType == ctrain_virtual)
{//ustalenie z której strony rysowaæ sprzêg return false; // wirtualny wiêcej nic nie robi
Couplers[ConnectNo].Render=true; //tego rysowaæ if (Forced ? true : ((Couplers[ConnectNo].CoupleDist <= dEpsilon) &&
ConnectTo->Couplers[Couplers[ConnectNo].ConnectedNr].Render=false; //a tego nie (Couplers[ConnectNo].CouplerType != NoCoupler) &&
(Couplers[ConnectNo].CouplerType == ct)))
{ // stykaja sie zderzaki i kompatybilne typy sprzegow, chyba ¿e ³¹czenie na starcie
if (Couplers[ConnectNo].CouplingFlag ==
ctrain_virtual) // jeœli wczeœniej nie by³o po³¹czone
{ // ustalenie z której strony rysowaæ sprzêg
Couplers[ConnectNo].Render = true; // tego rysowaæ
ConnectTo->Couplers[Couplers[ConnectNo].ConnectedNr].Render = false; // a tego nie
}; };
Couplers[ConnectNo].CouplingFlag=CouplingType; //ustawienie typu sprzêgu Couplers[ConnectNo].CouplingFlag = CouplingType; // ustawienie typu sprzêgu
//if (CouplingType!=ctrain_virtual) //Ra: wirtualnego nie ³¹czymy zwrotnie! // if (CouplingType!=ctrain_virtual) //Ra: wirtualnego nie ³¹czymy zwrotnie!
//{//jeœli ³¹czenie sprzêgiem niewirtualnym, ustawiamy po³¹czenie zwrotne //{//jeœli ³¹czenie sprzêgiem niewirtualnym, ustawiamy po³¹czenie zwrotne
ConnectTo->Couplers[Couplers[ConnectNo].ConnectedNr].CouplingFlag=CouplingType; ConnectTo->Couplers[Couplers[ConnectNo].ConnectedNr].CouplingFlag = CouplingType;
ConnectTo->Couplers[Couplers[ConnectNo].ConnectedNr].Connected=this; ConnectTo->Couplers[Couplers[ConnectNo].ConnectedNr].Connected = this;
ConnectTo->Couplers[Couplers[ConnectNo].ConnectedNr].CoupleDist=Couplers[ConnectNo].CoupleDist; ConnectTo->Couplers[Couplers[ConnectNo].ConnectedNr].CoupleDist =
Couplers[ConnectNo].CoupleDist;
return true; return true;
//} //}
//pod³¹czenie nie uda³o siê - jest wirtualne // pod³¹czenie nie uda³o siê - jest wirtualne
} }
} }
return false; //brak pod³¹czanego pojazdu, zbyt du¿a odleg³oœæ, niezgodny typ sprzêgu, brak sprzêgu, brak haka return false; // brak pod³¹czanego pojazdu, zbyt du¿a odleg³oœæ, niezgodny typ sprzêgu, brak
// sprzêgu, brak haka
}; };
bool __fastcall TMoverParameters::Attach(Byte ConnectNo,Byte ConnectToNr,T_MoverParameters *ConnectTo,Byte CouplingType,bool Forced) bool __fastcall TMoverParameters::Attach(Byte ConnectNo, Byte ConnectToNr,
{//³¹czenie do (ConnectNo) pojazdu (ConnectTo) stron¹ (ConnectToNr) T_MoverParameters *ConnectTo, Byte CouplingType,
return Attach(ConnectNo,ConnectToNr,(TMoverParameters*)ConnectTo,CouplingType,Forced); bool Forced)
{ //³¹czenie do (ConnectNo) pojazdu (ConnectTo) stron¹ (ConnectToNr)
return Attach(ConnectNo, ConnectToNr, (TMoverParameters *)ConnectTo, CouplingType, Forced);
}; };
int __fastcall TMoverParameters::DettachStatus(Byte ConnectNo) int __fastcall TMoverParameters::DettachStatus(Byte ConnectNo)
{//Ra: sprawdzenie, czy odleg³oœæ jest dobra do roz³¹czania { // Ra: sprawdzenie, czy odleg³oœæ jest dobra do roz³¹czania
//powinny byæ 3 informacje: =0 sprzêg ju¿ roz³¹czony, <0 da siê roz³¹czyæ. >0 nie da siê roz³¹czyæ // powinny byæ 3 informacje: =0 sprzêg ju¿ roz³¹czony, <0 da siê roz³¹czyæ. >0 nie da siê
// roz³¹czyæ
if (!Couplers[ConnectNo].Connected) if (!Couplers[ConnectNo].Connected)
return 0; //nie ma nic, to roz³¹czanie jest OK return 0; // nie ma nic, to roz³¹czanie jest OK
if ((Couplers[ConnectNo].CouplingFlag&ctrain_coupler)==0) if ((Couplers[ConnectNo].CouplingFlag & ctrain_coupler) == 0)
return -Couplers[ConnectNo].CouplingFlag; //hak nie po³¹czony - roz³¹czanie jest OK return -Couplers[ConnectNo].CouplingFlag; // hak nie po³¹czony - roz³¹czanie jest OK
if (TestFlag(DamageFlag,dtrain_coupling)) if (TestFlag(DamageFlag, dtrain_coupling))
return -Couplers[ConnectNo].CouplingFlag; //hak urwany - roz³¹czanie jest OK return -Couplers[ConnectNo].CouplingFlag; // hak urwany - roz³¹czanie jest OK
//ABu021104: zakomentowane 'and (CouplerType<>Articulated)' w warunku, nie wiem co to bylo, ale za to teraz dziala odczepianie... :) } // ABu021104: zakomentowane 'and (CouplerType<>Articulated)' w warunku, nie wiem co to bylo, ale
//if (CouplerType==Articulated) return false; //sprzêg nie do rozpiêcia - mo¿e byæ tylko urwany // za to teraz dziala odczepianie... :) }
//Couplers[ConnectNo].CoupleDist=Distance(Loc,Couplers[ConnectNo].Connected->Loc,Dim,Couplers[ConnectNo].Connected->Dim); // if (CouplerType==Articulated) return false; //sprzêg nie do rozpiêcia - mo¿e byæ tylko urwany
// Couplers[ConnectNo].CoupleDist=Distance(Loc,Couplers[ConnectNo].Connected->Loc,Dim,Couplers[ConnectNo].Connected->Dim);
CouplerDist(ConnectNo); CouplerDist(ConnectNo);
if (Couplers[ConnectNo].CouplerType==Screw?Couplers[ConnectNo].CoupleDist<0.0:true) if (Couplers[ConnectNo].CouplerType == Screw ? Couplers[ConnectNo].CoupleDist < 0.0 : true)
return -Couplers[ConnectNo].CouplingFlag; //mo¿na roz³¹czaæ, jeœli dociœniêty return -Couplers[ConnectNo].CouplingFlag; // mo¿na roz³¹czaæ, jeœli dociœniêty
return (Couplers[ConnectNo].CoupleDist>0.2)?-Couplers[ConnectNo].CouplingFlag:Couplers[ConnectNo].CouplingFlag; return (Couplers[ConnectNo].CoupleDist > 0.2) ? -Couplers[ConnectNo].CouplingFlag :
Couplers[ConnectNo].CouplingFlag;
}; };
bool __fastcall TMoverParameters::Dettach(Byte ConnectNo) bool __fastcall TMoverParameters::Dettach(Byte ConnectNo)
{//rozlaczanie { // rozlaczanie
if (!Couplers[ConnectNo].Connected) return true; //nie ma nic, to odczepiono if (!Couplers[ConnectNo].Connected)
//with Couplers[ConnectNo] do return true; // nie ma nic, to odczepiono
int i=DettachStatus(ConnectNo); //stan sprzêgu // with Couplers[ConnectNo] do
if (i<0) int i = DettachStatus(ConnectNo); // stan sprzêgu
{//gdy scisniete zderzaki, chyba ze zerwany sprzeg (wirtualnego nie odpinamy z drugiej strony) if (i < 0)
//Couplers[ConnectNo].Connected=NULL; //lepiej zostawic bo przeciez trzeba kontrolowac zderzenia odczepionych { // gdy scisniete zderzaki, chyba ze zerwany sprzeg (wirtualnego nie odpinamy z drugiej strony)
Couplers[ConnectNo].Connected->Couplers[Couplers[ConnectNo].ConnectedNr].CouplingFlag=0; //pozostaje sprzêg wirtualny // Couplers[ConnectNo].Connected=NULL; //lepiej zostawic bo przeciez trzeba kontrolowac
Couplers[ConnectNo].CouplingFlag=0; //pozostaje sprzêg wirtualny // zderzenia odczepionych
Couplers[ConnectNo].Connected->Couplers[Couplers[ConnectNo].ConnectedNr].CouplingFlag =
0; // pozostaje sprzêg wirtualny
Couplers[ConnectNo].CouplingFlag = 0; // pozostaje sprzêg wirtualny
return true; return true;
} }
else if (i>0) else if (i > 0)
{//od³¹czamy wê¿e i resztê, pozostaje sprzêg fizyczny, który wymaga dociœniêcia (z wirtualnym nic) { // od³¹czamy wê¿e i resztê, pozostaje sprzêg fizyczny, który wymaga dociœniêcia (z wirtualnym
Couplers[ConnectNo].CouplingFlag&=ctrain_coupler; // nic)
Couplers[ConnectNo].Connected->Couplers[Couplers[ConnectNo].ConnectedNr].CouplingFlag=Couplers[ConnectNo].CouplingFlag; Couplers[ConnectNo].CouplingFlag &= ctrain_coupler;
Couplers[ConnectNo].Connected->Couplers[Couplers[ConnectNo].ConnectedNr].CouplingFlag =
Couplers[ConnectNo].CouplingFlag;
} }
return false; //jeszcze nie roz³¹czony return false; // jeszcze nie roz³¹czony
}; };
void __fastcall TMoverParameters::SetCoupleDist() void __fastcall TMoverParameters::SetCoupleDist()
{//przeliczenie odleg³oœci sprzêgów { // przeliczenie odleg³oœci sprzêgów
if (Couplers[0].Connected) if (Couplers[0].Connected)
{ {
CouplerDist(0); CouplerDist(0);
if (CategoryFlag&2) if (CategoryFlag & 2)
{//Ra: dla samochodów zderzanie kul to za ma³o { // Ra: dla samochodów zderzanie kul to za ma³o
} }
} }
if (Couplers[1].Connected) if (Couplers[1].Connected)
{ {
CouplerDist(1); CouplerDist(1);
if (CategoryFlag&2) if (CategoryFlag & 2)
{//Ra: dla samochodów zderzanie kul to za ma³o { // Ra: dla samochodów zderzanie kul to za ma³o
} }
} }
}; };
bool __fastcall TMoverParameters::DirectionForward() bool __fastcall TMoverParameters::DirectionForward()
{ {
if ((MainCtrlPosNo>0)&&(ActiveDir<1)&&(MainCtrlPos==0)) if ((MainCtrlPosNo > 0) && (ActiveDir < 1) && (MainCtrlPos == 0))
{ {
++ActiveDir; ++ActiveDir;
DirAbsolute=ActiveDir*CabNo; DirAbsolute = ActiveDir * CabNo;
if (DirAbsolute) if (DirAbsolute)
if (Battery) //jeœli bateria jest ju¿ za³¹czona if (Battery) // jeœli bateria jest ju¿ za³¹czona
BatterySwitch(true); //to w ten oto durny sposób aktywuje siê CA/SHP BatterySwitch(true); // to w ten oto durny sposób aktywuje siê CA/SHP
SendCtrlToNext("Direction",ActiveDir,CabNo); SendCtrlToNext("Direction", ActiveDir, CabNo);
return true; return true;
} }
else if ((ActiveDir==1)&&(MainCtrlPos==0)&&(TrainType==dt_EZT)) else if ((ActiveDir == 1) && (MainCtrlPos == 0) && (TrainType == dt_EZT))
return MinCurrentSwitch(true); //"wysoki rozruch" EN57 return MinCurrentSwitch(true); //"wysoki rozruch" EN57
return false; return false;
}; };
@@ -151,26 +178,30 @@ bool __fastcall TMoverParameters::DirectionForward()
// Nastawianie hamulców // Nastawianie hamulców
void __fastcall TMoverParameters::BrakeLevelSet(double b) void __fastcall TMoverParameters::BrakeLevelSet(double b)
{//ustawienie pozycji hamulca na wartoϾ (b) w zakresie od -2 do BrakeCtrlPosNo { // ustawienie pozycji hamulca na wartoϾ (b) w zakresie od -2 do BrakeCtrlPosNo
//jedyny dopuszczalny sposób przestawienia hamulca zasadniczego // jedyny dopuszczalny sposób przestawienia hamulca zasadniczego
if (fBrakeCtrlPos==b) return; //nie przeliczaæ, jak nie ma zmiany if (fBrakeCtrlPos == b)
fBrakeCtrlPos=b; return; // nie przeliczaæ, jak nie ma zmiany
BrakeCtrlPosR=b; fBrakeCtrlPos = b;
if (fBrakeCtrlPos<Handle->GetPos(bh_MIN)) BrakeCtrlPosR = b;
fBrakeCtrlPos=Handle->GetPos(bh_MIN); //odciêcie if (fBrakeCtrlPos < Handle->GetPos(bh_MIN))
else fBrakeCtrlPos = Handle->GetPos(bh_MIN); // odciêcie
if (fBrakeCtrlPos>Handle->GetPos(bh_MAX)) else if (fBrakeCtrlPos > Handle->GetPos(bh_MAX))
fBrakeCtrlPos=Handle->GetPos(bh_MAX); fBrakeCtrlPos = Handle->GetPos(bh_MAX);
int x=floor(fBrakeCtrlPos); //jeœli odwo³ujemy siê do BrakeCtrlPos w poœrednich, to musi byæ obciête a nie zaokr¹gone int x = floor(fBrakeCtrlPos); // jeœli odwo³ujemy siê do BrakeCtrlPos w poœrednich, to musi byæ
while ((x>BrakeCtrlPos)&&(BrakeCtrlPos<BrakeCtrlPosNo)) //jeœli zwiêkszy³o siê o 1 // obciête a nie zaokr¹gone
if (!T_MoverParameters::IncBrakeLevelOld()) break; //wyjœcie awaryjne while ((x > BrakeCtrlPos) && (BrakeCtrlPos < BrakeCtrlPosNo)) // jeœli zwiêkszy³o siê o 1
while ((x<BrakeCtrlPos)&&(BrakeCtrlPos>=-1)) //jeœli zmniejszy³o siê o 1 if (!T_MoverParameters::IncBrakeLevelOld())
if (!T_MoverParameters::DecBrakeLevelOld()) break; break; // wyjœcie awaryjne
BrakePressureActual=BrakePressureTable[BrakeCtrlPos+2]; //skopiowanie pozycji while ((x < BrakeCtrlPos) && (BrakeCtrlPos >= -1)) // jeœli zmniejszy³o siê o 1
/* if (!T_MoverParameters::DecBrakeLevelOld())
//youBy: obawiam sie, ze tutaj to nie dziala :P break;
//Ra 2014-03: by³o tak zrobione, ¿e dzia³a³o - po ka¿dej zmianie pozycji by³a wywo³ywana ta funkcja BrakePressureActual = BrakePressureTable[BrakeCtrlPos + 2]; // skopiowanie pozycji
// if (BrakeSystem==Pneumatic?BrakeSubsystem==Oerlikon:false) //tylko Oerlikon akceptuje u³amki /*
//youBy: obawiam sie, ze tutaj to nie dziala :P
//Ra 2014-03: by³o tak zrobione, ¿e dzia³a³o - po ka¿dej zmianie pozycji by³a wywo³ywana ta
funkcja
// if (BrakeSystem==Pneumatic?BrakeSubsystem==Oerlikon:false) //tylko Oerlikon akceptuje u³amki
if(false) if(false)
if (fBrakeCtrlPos>0.0) if (fBrakeCtrlPos>0.0)
{//wartoœci poœrednie wyliczamy tylko dla hamowania {//wartoœci poœrednie wyliczamy tylko dla hamowania
@@ -178,196 +209,223 @@ void __fastcall TMoverParameters::BrakeLevelSet(double b)
if (u>0.0) if (u>0.0)
{//wyliczamy wartoœci wa¿one {//wyliczamy wartoœci wa¿one
BrakePressureActual.PipePressureVal+=-u*BrakePressureActual.PipePressureVal+u*BrakePressureTable[BrakeCtrlPos+1+2].PipePressureVal; BrakePressureActual.PipePressureVal+=-u*BrakePressureActual.PipePressureVal+u*BrakePressureTable[BrakeCtrlPos+1+2].PipePressureVal;
//BrakePressureActual.BrakePressureVal+=-u*BrakePressureActual.BrakePressureVal+u*BrakePressureTable[BrakeCtrlPos+1].BrakePressureVal; //to chyba nie bêdzie tak dzia³aæ, zw³aszcza w EN57 //BrakePressureActual.BrakePressureVal+=-u*BrakePressureActual.BrakePressureVal+u*BrakePressureTable[BrakeCtrlPos+1].BrakePressureVal;
//to chyba nie bêdzie tak dzia³aæ, zw³aszcza w EN57
BrakePressureActual.FlowSpeedVal+=-u*BrakePressureActual.FlowSpeedVal+u*BrakePressureTable[BrakeCtrlPos+1+2].FlowSpeedVal; BrakePressureActual.FlowSpeedVal+=-u*BrakePressureActual.FlowSpeedVal+u*BrakePressureTable[BrakeCtrlPos+1+2].FlowSpeedVal;
} }
} }
*/ */
}; };
bool __fastcall TMoverParameters::BrakeLevelAdd(double b) bool __fastcall TMoverParameters::BrakeLevelAdd(double b)
{//dodanie wartoœci (b) do pozycji hamulca (w tym ujemnej) { // dodanie wartoœci (b) do pozycji hamulca (w tym ujemnej)
//zwraca false, gdy po dodaniu by³o by poza zakresem // zwraca false, gdy po dodaniu by³o by poza zakresem
BrakeLevelSet(fBrakeCtrlPos+b); BrakeLevelSet(fBrakeCtrlPos + b);
return b>0.0?(fBrakeCtrlPos<BrakeCtrlPosNo):(BrakeCtrlPos>-1.0); //true, jeœli mo¿na kontynuowaæ return b > 0.0 ? (fBrakeCtrlPos < BrakeCtrlPosNo) :
(BrakeCtrlPos > -1.0); // true, jeœli mo¿na kontynuowaæ
}; };
bool __fastcall TMoverParameters::IncBrakeLevel() bool __fastcall TMoverParameters::IncBrakeLevel()
{//nowa wersja na u¿ytek AI, false gdy osi¹gniêto pozycjê BrakeCtrlPosNo { // nowa wersja na u¿ytek AI, false gdy osi¹gniêto pozycjê BrakeCtrlPosNo
return BrakeLevelAdd(1.0); return BrakeLevelAdd(1.0); };
};
bool __fastcall TMoverParameters::DecBrakeLevel() bool __fastcall TMoverParameters::DecBrakeLevel()
{//nowa wersja na u¿ytek AI, false gdy osi¹gniêto pozycjê -1 { // nowa wersja na u¿ytek AI, false gdy osi¹gniêto pozycjê -1 return BrakeLevelAdd(-1.0); };
return BrakeLevelAdd(-1.0);
};
bool __fastcall TMoverParameters::ChangeCab(int direction) bool __fastcall TMoverParameters::ChangeCab(int direction)
{//zmiana kabiny i resetowanie ustawien { // zmiana kabiny i resetowanie ustawien
if (abs(ActiveCab+direction)<2) if (abs(ActiveCab + direction) < 2)
{ {
// if (ActiveCab+direction=0) then LastCab:=ActiveCab; // if (ActiveCab+direction=0) then LastCab:=ActiveCab;
ActiveCab=ActiveCab+direction; ActiveCab = ActiveCab + direction;
if ((BrakeSystem==Pneumatic)&&(BrakeCtrlPosNo>0)) if ((BrakeSystem == Pneumatic) && (BrakeCtrlPosNo > 0))
{ {
// if (BrakeHandle==FV4a) //!!!POBIERAÆ WARTOŒÆ Z KLASY ZAWORU!!! // if (BrakeHandle==FV4a) //!!!POBIERAÆ WARTOŒÆ Z KLASY ZAWORU!!!
// BrakeLevelSet(-2); //BrakeCtrlPos=-2; // BrakeLevelSet(-2); //BrakeCtrlPos=-2;
// else if ((BrakeHandle==FVel6)||(BrakeHandle==St113)) // else if ((BrakeHandle==FVel6)||(BrakeHandle==St113))
// BrakeLevelSet(2); // BrakeLevelSet(2);
// else // else
// BrakeLevelSet(1); // BrakeLevelSet(1);
BrakeLevelSet(Handle->GetPos(bh_NP)); BrakeLevelSet(Handle->GetPos(bh_NP));
LimPipePress=PipePress; LimPipePress = PipePress;
ActFlowSpeed=0; ActFlowSpeed = 0;
} }
else else
//if (TrainType=dt_EZT) and (BrakeCtrlPosNo>0) then // if (TrainType=dt_EZT) and (BrakeCtrlPosNo>0) then
// BrakeCtrlPos:=5; //z Megapacka // BrakeCtrlPos:=5; //z Megapacka
//else // else
// BrakeLevelSet(0); //BrakeCtrlPos=0; // BrakeLevelSet(0); //BrakeCtrlPos=0;
BrakeLevelSet(Handle->GetPos(bh_NP)); BrakeLevelSet(Handle->GetPos(bh_NP));
// if not TestFlag(BrakeStatus,b_dmg) then // if not TestFlag(BrakeStatus,b_dmg) then
// BrakeStatus:=b_off; //z Megapacka // BrakeStatus:=b_off; //z Megapacka
MainCtrlPos=0; MainCtrlPos = 0;
ScndCtrlPos=0; ScndCtrlPos = 0;
//Ra: to poni¿ej jest bez sensu - mo¿na przejœæ nie wy³¹czaj¹c // Ra: to poni¿ej jest bez sensu - mo¿na przejœæ nie wy³¹czaj¹c
//if ((EngineType!=DieselEngine)&&(EngineType!=DieselElectric)) // if ((EngineType!=DieselEngine)&&(EngineType!=DieselElectric))
//{ //{
// Mains=false; // Mains=false;
// CompressorAllow=false; // CompressorAllow=false;
// ConverterAllow=false; // ConverterAllow=false;
//} //}
//ActiveDir=0; // ActiveDir=0;
//DirAbsolute=0; // DirAbsolute=0;
return true; return true;
} }
return false; return false;
}; };
bool __fastcall TMoverParameters::CurrentSwitch(int direction) bool __fastcall TMoverParameters::CurrentSwitch(int direction)
{//rozruch wysoki (true) albo niski (false) { // rozruch wysoki (true) albo niski (false)
//Ra: przenios³em z Train.cpp, nie wiem czy ma to sens // Ra: przenios³em z Train.cpp, nie wiem czy ma to sens
if (MaxCurrentSwitch(direction)) if (MaxCurrentSwitch(direction))
{if (TrainType!=dt_EZT) {
if (TrainType != dt_EZT)
return (MinCurrentSwitch(direction)); return (MinCurrentSwitch(direction));
} }
if (EngineType==DieselEngine) //dla 2Ls150 if (EngineType == DieselEngine) // dla 2Ls150
if (ShuntModeAllow) if (ShuntModeAllow)
if (ActiveDir==0) //przed ustawieniem kierunku if (ActiveDir == 0) // przed ustawieniem kierunku
ShuntMode=direction; ShuntMode = direction;
return false; return false;
}; };
void __fastcall TMoverParameters::UpdatePantVolume(double dt) void __fastcall TMoverParameters::UpdatePantVolume(double dt)
{//KURS90 - sprê¿arka pantografów; Ra 2014-07: teraz jest to zbiornik rozrz¹du, chocia¿ to jeszcze nie tak { // KURS90 - sprê¿arka pantografów; Ra 2014-07: teraz jest to zbiornik rozrz¹du, chocia¿ to jeszcze
if (EnginePowerSource.SourceType==CurrentCollector) //tylko jeœli pantografuj¹cy // nie tak
if (EnginePowerSource.SourceType == CurrentCollector) // tylko jeœli pantografuj¹cy
{ {
//Ra 2014-07: zasadniczo, to istnieje zbiornik rozrz¹du i zbiornik pantografów - na razie mamy razem // Ra 2014-07: zasadniczo, to istnieje zbiornik rozrz¹du i zbiornik pantografów - na razie
//Ra 2014-07: kurek trójdrogowy ³¹czy spr.pom. z pantografami i wy³¹cznikiem ciœnieniowym WS // mamy razem
//Ra 2014-07: zbiornika rozrz¹du nie pompuje siê tu, tylko pantografy; potem mo¿na zamkn¹æ WS i odpaliæ resztê // Ra 2014-07: kurek trójdrogowy ³¹czy spr.pom. z pantografami i wy³¹cznikiem ciœnieniowym
if ((TrainType==dt_EZT)?(PantPress<ScndPipePress):bPantKurek3) //kurek zamyka po³¹czenie z ZG // WS
{//zbiornik pantografu po³¹czony ze zbiornikiem g³ównym - ma³¹ sprê¿ark¹ siê tego nie napompuje // Ra 2014-07: zbiornika rozrz¹du nie pompuje siê tu, tylko pantografy; potem mo¿na zamkn¹æ
//Ra 2013-12: Niebugoc³aw mówi, ¿e w EZT nie ma potrzeby odcinaæ kurkiem // WS i odpaliæ resztê
PantPress=EnginePowerSource.CollectorParameters.MaxPress; //ograniczenie ciœnienia do MaxPress (tylko w pantografach!) if ((TrainType == dt_EZT) ? (PantPress < ScndPipePress) :
if (PantPress>ScndPipePress) PantPress=ScndPipePress; //oraz do ScndPipePress bPantKurek3) // kurek zamyka po³¹czenie z ZG
PantVolume=(PantPress+1)*0.1; //objêtoœæ, na wypadek odciêcia kurkiem { // zbiornik pantografu po³¹czony ze zbiornikiem g³ównym - ma³¹ sprê¿ark¹ siê tego nie
// napompuje
// Ra 2013-12: Niebugoc³aw mówi, ¿e w EZT nie ma potrzeby odcinaæ kurkiem
PantPress = EnginePowerSource.CollectorParameters
.MaxPress; // ograniczenie ciœnienia do MaxPress (tylko w pantografach!)
if (PantPress > ScndPipePress)
PantPress = ScndPipePress; // oraz do ScndPipePress
PantVolume = (PantPress + 1) * 0.1; // objêtoœæ, na wypadek odciêcia kurkiem
} }
else else
{//zbiornik g³ówny odciêty, mo¿na pompowaæ pantografy { // zbiornik g³ówny odciêty, mo¿na pompowaæ pantografy
if (PantCompFlag&&Battery) //w³¹czona bateria i ma³a sprê¿arka if (PantCompFlag && Battery) // w³¹czona bateria i ma³a sprê¿arka
PantVolume+=dt*(TrainType==dt_EZT?0.003:0.005)*(2*0.45-((0.1/PantVolume/10)-0.1))/0.45; //nape³nianie zbiornika pantografów PantVolume += dt * (TrainType == dt_EZT ? 0.003 : 0.005) *
//Ra 2013-12: Niebugoc³aw mówi, ¿e w EZT nabija 1.5 raz wolniej ni¿ jak by³o 0.005 (2 * 0.45 - ((0.1 / PantVolume / 10) - 0.1)) /
PantPress=(10.0*PantVolume)-1.0; //tu by siê przyda³a objêtoœæ zbiornika 0.45; // nape³nianie zbiornika pantografów
// Ra 2013-12: Niebugoc³aw mówi, ¿e w EZT nabija 1.5 raz wolniej ni¿ jak by³o 0.005
PantPress = (10.0 * PantVolume) - 1.0; // tu by siê przyda³a objêtoœæ zbiornika
} }
if (!PantCompFlag&&(PantVolume>0.1)) if (!PantCompFlag && (PantVolume > 0.1))
PantVolume-=dt*0.0003; //nieszczelnoœci: 0.0003=0.3l/s PantVolume -= dt * 0.0003; // nieszczelnoœci: 0.0003=0.3l/s
if (Mains) //nie wchodziæ w funkcjê bez potrzeby if (Mains) // nie wchodziæ w funkcjê bez potrzeby
if (EngineType==ElectricSeriesMotor) //nie dotyczy... czego w³aœciwie? if (EngineType == ElectricSeriesMotor) // nie dotyczy... czego w³aœciwie?
if (PantPress<EnginePowerSource.CollectorParameters.MinPress) if (PantPress < EnginePowerSource.CollectorParameters.MinPress)
if ((TrainType&(dt_EZT|dt_ET40|dt_ET41|dt_ET42))?(GetTrainsetVoltage()<EnginePowerSource.CollectorParameters.MinV):true) //to jest trochê proteza; zasilanie cz³onu mo¿e byæ przez sprzêg WN if ((TrainType & (dt_EZT | dt_ET40 | dt_ET41 | dt_ET42)) ?
(GetTrainsetVoltage() < EnginePowerSource.CollectorParameters.MinV) :
true) // to jest trochê proteza; zasilanie cz³onu mo¿e byæ przez sprzêg
// WN
if (MainSwitch(false)) if (MainSwitch(false))
EventFlag=true; //wywalenie szybkiego z powodu niskiego ciœnienia EventFlag = true; // wywalenie szybkiego z powodu niskiego ciœnienia
if (TrainType!=dt_EZT) //w EN57 pompuje siê tylko w silnikowym if (TrainType != dt_EZT) // w EN57 pompuje siê tylko w silnikowym
//pierwotnie w CHK pantografy mia³y równie¿ rozrz¹dcze EZT // pierwotnie w CHK pantografy mia³y równie¿ rozrz¹dcze EZT
for (int b=0;b<=1;++b) for (int b = 0; b <= 1; ++b)
if (TestFlag(Couplers[b].CouplingFlag,ctrain_controll)) if (TestFlag(Couplers[b].CouplingFlag, ctrain_controll))
if (Couplers[b].Connected->PantVolume<PantVolume) //bo inaczej trzeba w obydwu cz³onach przestawiaæ if (Couplers[b].Connected->PantVolume <
Couplers[b].Connected->PantVolume=PantVolume; //przekazanie ciœnienia do s¹siedniego cz³onu PantVolume) // bo inaczej trzeba w obydwu cz³onach przestawiaæ
//czy np. w ET40, ET41, ET42 pantografy cz³onów maj¹ po³¹czenie pneumatyczne? Couplers[b].Connected->PantVolume =
//Ra 2014-07: raczej nie - najpierw siê za³¹cza jeden cz³on, a potem mo¿na podnieœæ w drugim PantVolume; // przekazanie ciœnienia do s¹siedniego cz³onu
// czy np. w ET40, ET41, ET42 pantografy cz³onów maj¹ po³¹czenie pneumatyczne?
// Ra 2014-07: raczej nie - najpierw siê za³¹cza jeden cz³on, a potem mo¿na podnieœæ w
// drugim
} }
else else
{//a tu coœ dla SM42 i SM31, aby pokazywaæ na manometrze { // a tu coœ dla SM42 i SM31, aby pokazywaæ na manometrze
PantPress=CntrlPipePress; PantPress = CntrlPipePress;
} }
}; };
void __fastcall TMoverParameters::UpdateBatteryVoltage(double dt) void __fastcall TMoverParameters::UpdateBatteryVoltage(double dt)
{//przeliczenie obci¹¿enia baterii { // przeliczenie obci¹¿enia baterii
double sn1,sn2,sn3,sn4,sn5; //Ra: zrobiæ z tego amperomierz NN double sn1, sn2, sn3, sn4, sn5; // Ra: zrobiæ z tego amperomierz NN
if ((BatteryVoltage>0)&&(EngineType!=DieselEngine)&&(EngineType!=WheelsDriven)&&(NominalBatteryVoltage>0)) if ((BatteryVoltage > 0) && (EngineType != DieselEngine) && (EngineType != WheelsDriven) &&
(NominalBatteryVoltage > 0))
{ {
if ((NominalBatteryVoltage/BatteryVoltage<1.22)&&Battery) if ((NominalBatteryVoltage / BatteryVoltage < 1.22) && Battery)
{//110V { // 110V
if (!ConverterFlag) if (!ConverterFlag)
sn1=(dt*2.0); //szybki spadek do ok 90V sn1 = (dt * 2.0); // szybki spadek do ok 90V
else sn1=0; else
sn1 = 0;
if (ConverterFlag) if (ConverterFlag)
sn2=-(dt*2.0); //szybki wzrost do 110V sn2 = -(dt * 2.0); // szybki wzrost do 110V
else sn2=0; else
sn2 = 0;
if (Mains) if (Mains)
sn3=(dt*0.05); sn3 = (dt * 0.05);
else sn3=0; else
if (iLights[0]&63) //64=blachy, nie ci¹gn¹ pr¹du //rozpisaæ na poszczególne ¿arówki... sn3 = 0;
sn4=dt*0.003; if (iLights[0] & 63) // 64=blachy, nie ci¹gn¹ pr¹du //rozpisaæ na poszczególne
else sn4=0; // ¿arówki...
if (iLights[1]&63) //64=blachy, nie ci¹gn¹ pr¹du sn4 = dt * 0.003;
sn5=dt*0.001; else
else sn5=0; sn4 = 0;
if (iLights[1] & 63) // 64=blachy, nie ci¹gn¹ pr¹du
sn5 = dt * 0.001;
else
sn5 = 0;
}; };
if ((NominalBatteryVoltage/BatteryVoltage>=1.22)&&Battery) if ((NominalBatteryVoltage / BatteryVoltage >= 1.22) && Battery)
{//90V { // 90V
if (PantCompFlag) if (PantCompFlag)
sn1=(dt*0.0046); sn1 = (dt * 0.0046);
else sn1=0; else
sn1 = 0;
if (ConverterFlag) if (ConverterFlag)
sn2=-(dt*50); //szybki wzrost do 110V sn2 = -(dt * 50); // szybki wzrost do 110V
else sn2=0; else
sn2 = 0;
if (Mains) if (Mains)
sn3=(dt*0.001); sn3 = (dt * 0.001);
else sn3=0; else
if (iLights[0]&63) //64=blachy, nie ci¹gn¹ pr¹du sn3 = 0;
sn4=(dt*0.0030); if (iLights[0] & 63) // 64=blachy, nie ci¹gn¹ pr¹du
else sn4=0; sn4 = (dt * 0.0030);
if (iLights[1]&63) //64=blachy, nie ci¹gn¹ pr¹du else
sn5=(dt*0.0010); sn4 = 0;
else sn5=0; if (iLights[1] & 63) // 64=blachy, nie ci¹gn¹ pr¹du
sn5 = (dt * 0.0010);
else
sn5 = 0;
}; };
if (!Battery) if (!Battery)
{ {
if (NominalBatteryVoltage/BatteryVoltage<1.22) if (NominalBatteryVoltage / BatteryVoltage < 1.22)
sn1=dt*50; sn1 = dt * 50;
else else
sn1=0; sn1 = 0;
sn2=dt*0.000001; sn2 = dt * 0.000001;
sn3=dt*0.000001; sn3 = dt * 0.000001;
sn4=dt*0.000001; sn4 = dt * 0.000001;
sn5=dt*0.000001; //bardzo powolny spadek przy wy³¹czonych bateriach sn5 = dt * 0.000001; // bardzo powolny spadek przy wy³¹czonych bateriach
}; };
BatteryVoltage-=(sn1+sn2+sn3+sn4+sn5); BatteryVoltage -= (sn1 + sn2 + sn3 + sn4 + sn5);
if (NominalBatteryVoltage/BatteryVoltage>1.57) if (NominalBatteryVoltage / BatteryVoltage > 1.57)
if (MainSwitch(false)&&(EngineType!=DieselEngine)&&(EngineType!=WheelsDriven)) if (MainSwitch(false) && (EngineType != DieselEngine) && (EngineType != WheelsDriven))
EventFlag=true; //wywalanie szybkiego z powodu zbyt niskiego napiecia EventFlag = true; // wywalanie szybkiego z powodu zbyt niskiego napiecia
if (BatteryVoltage>NominalBatteryVoltage) if (BatteryVoltage > NominalBatteryVoltage)
BatteryVoltage=NominalBatteryVoltage; //wstrzymanie ³adowania pow. 110V BatteryVoltage = NominalBatteryVoltage; // wstrzymanie ³adowania pow. 110V
if (BatteryVoltage<0.01) if (BatteryVoltage < 0.01)
BatteryVoltage=0.01; BatteryVoltage = 0.01;
} }
else if (NominalBatteryVoltage == 0)
BatteryVoltage = 0;
else else
if (NominalBatteryVoltage==0) BatteryVoltage = 90;
BatteryVoltage=0;
else
BatteryVoltage=90;
}; };
/* Ukrotnienie EN57: /* Ukrotnienie EN57:
@@ -409,35 +467,34 @@ void __fastcall TMoverParameters::UpdateBatteryVoltage(double dt)
ZN //masa ZN //masa
*/ */
double __fastcall TMoverParameters::ComputeMovement double __fastcall TMoverParameters::ComputeMovement(double dt, double dt1, const TTrackShape &Shape,
(double dt,double dt1, TTrackParam &Track,
const TTrackShape &Shape,TTrackParam &Track,TTractionParam &ElectricTraction, TTractionParam &ElectricTraction,
const TLocation &NewLoc,TRotation &NewRot const TLocation &NewLoc, TRotation &NewRot)
) { // trzeba po ma³u przenosiæ tu tê funkcjê
{//trzeba po ma³u przenosiæ tu tê funkcjê
double d; double d;
T_MoverParameters::ComputeMovement(dt,dt1,Shape,Track,ElectricTraction,NewLoc,NewRot); T_MoverParameters::ComputeMovement(dt, dt1, Shape, Track, ElectricTraction, NewLoc, NewRot);
if (Power>1.0) //w rozrz¹dczym nie (jest b³¹d w FIZ!) - Ra 2014-07: teraz we wszystkich if (Power > 1.0) // w rozrz¹dczym nie (jest b³¹d w FIZ!) - Ra 2014-07: teraz we wszystkich
UpdatePantVolume(dt); //Ra 2014-07: obs³uga zbiornika rozrz¹du oraz pantografów UpdatePantVolume(dt); // Ra 2014-07: obs³uga zbiornika rozrz¹du oraz pantografów
if (EngineType==WheelsDriven) if (EngineType == WheelsDriven)
d=CabNo*dL; //na chwile dla testu d = CabNo * dL; // na chwile dla testu
else else
d=dL; d = dL;
DistCounter=DistCounter+fabs(dL)/1000.0; DistCounter = DistCounter + fabs(dL) / 1000.0;
dL=0; dL = 0;
//koniec procedury, tu nastepuja dodatkowe procedury pomocnicze // koniec procedury, tu nastepuja dodatkowe procedury pomocnicze
//sprawdzanie i ewentualnie wykonywanie->kasowanie poleceñ // sprawdzanie i ewentualnie wykonywanie->kasowanie poleceñ
if (LoadStatus>0) //czas doliczamy tylko jeœli trwa (roz)³adowanie if (LoadStatus > 0) // czas doliczamy tylko jeœli trwa (roz)³adowanie
LastLoadChangeTime=LastLoadChangeTime+dt; //czas (roz)³adunku LastLoadChangeTime = LastLoadChangeTime + dt; // czas (roz)³adunku
RunInternalCommand(); RunInternalCommand();
//automatyczny rozruch // automatyczny rozruch
if (EngineType==ElectricSeriesMotor) if (EngineType == ElectricSeriesMotor)
if (AutoRelayCheck()) if (AutoRelayCheck())
SetFlag(SoundFlag,sound_relay); SetFlag(SoundFlag, sound_relay);
/* /*
else {McZapkie-041003: aby slychac bylo przelaczniki w sterowniczym} else {McZapkie-041003: aby slychac bylo przelaczniki w sterowniczym}
if (EngineType=None) and (MainCtrlPosNo>0) then if (EngineType=None) and (MainCtrlPosNo>0) then
for b:=0 to 1 do for b:=0 to 1 do
@@ -445,32 +502,32 @@ double __fastcall TMoverParameters::ComputeMovement
if TestFlag(CouplingFlag,ctrain_controll) then if TestFlag(CouplingFlag,ctrain_controll) then
if Connected^.Power>0.01 then if Connected^.Power>0.01 then
SoundFlag:=SoundFlag or Connected^.SoundFlag; SoundFlag:=SoundFlag or Connected^.SoundFlag;
*/ */
if (EngineType==DieselEngine) if (EngineType == DieselEngine)
if (dizel_Update(dt)) if (dizel_Update(dt))
SetFlag(SoundFlag,sound_relay); SetFlag(SoundFlag, sound_relay);
//uklady hamulcowe: // uklady hamulcowe:
if (VeselVolume>0) if (VeselVolume > 0)
Compressor=CompressedVolume/VeselVolume; Compressor = CompressedVolume / VeselVolume;
else else
{ {
Compressor=0; Compressor = 0;
CompressorFlag=false; CompressorFlag = false;
}; };
ConverterCheck(); ConverterCheck();
if (CompressorSpeed>0.0) //sprê¿arka musi mieæ jak¹œ niezerow¹ wydajnoœæ if (CompressorSpeed > 0.0) // sprê¿arka musi mieæ jak¹œ niezerow¹ wydajnoœæ
CompressorCheck(dt); //¿eby rozwa¿aæ jej za³¹czenie i pracê CompressorCheck(dt); //¿eby rozwa¿aæ jej za³¹czenie i pracê
UpdateBrakePressure(dt); UpdateBrakePressure(dt);
UpdatePipePressure(dt); UpdatePipePressure(dt);
UpdateBatteryVoltage(dt); UpdateBatteryVoltage(dt);
UpdateScndPipePressure(dt); // druga rurka, youBy UpdateScndPipePressure(dt); // druga rurka, youBy
//hamulec antypoœlizgowy - wy³¹czanie // hamulec antypoœlizgowy - wy³¹czanie
if ((BrakeSlippingTimer>0.8)&&(ASBType!=128)) //ASBSpeed=0.8 if ((BrakeSlippingTimer > 0.8) && (ASBType != 128)) // ASBSpeed=0.8
Hamulec->ASB(0); Hamulec->ASB(0);
//SetFlag(BrakeStatus,-b_antislip); // SetFlag(BrakeStatus,-b_antislip);
BrakeSlippingTimer=BrakeSlippingTimer+dt; BrakeSlippingTimer = BrakeSlippingTimer + dt;
//sypanie piasku - wy³¹czone i piasek siê nie koñczy - b³êdy AI // sypanie piasku - wy³¹czone i piasek siê nie koñczy - b³êdy AI
//if AIControllFlag then // if AIControllFlag then
// if SandDose then // if SandDose then
// if Sand>0 then // if Sand>0 then
// begin // begin
@@ -482,80 +539,78 @@ double __fastcall TMoverParameters::ComputeMovement
// SandDose:=false; // SandDose:=false;
// Sand:=0; // Sand:=0;
// end; // end;
//czuwak/SHP // czuwak/SHP
//if (Vel>10) and (not DebugmodeFlag) then // if (Vel>10) and (not DebugmodeFlag) then
if (!DebugModeFlag) if (!DebugModeFlag)
SecuritySystemCheck(dt1); SecuritySystemCheck(dt1);
return d; return d;
}; };
double __fastcall TMoverParameters::FastComputeMovement double __fastcall TMoverParameters::FastComputeMovement(double dt, const TTrackShape &Shape,
(double dt, TTrackParam &Track, const TLocation &NewLoc,
const TTrackShape &Shape,TTrackParam &Track, TRotation &NewRot)
const TLocation &NewLoc,TRotation &NewRot { // trzeba po ma³u przenosiæ tu tê funkcjê
)
{//trzeba po ma³u przenosiæ tu tê funkcjê
double d; double d;
T_MoverParameters::FastComputeMovement(dt,Shape,Track,NewLoc,NewRot); T_MoverParameters::FastComputeMovement(dt, Shape, Track, NewLoc, NewRot);
if (Power>1.0) //w rozrz¹dczym nie (jest b³¹d w FIZ!) if (Power > 1.0) // w rozrz¹dczym nie (jest b³¹d w FIZ!)
UpdatePantVolume(dt); //Ra 2014-07: obs³uga zbiornika rozrz¹du oraz pantografów UpdatePantVolume(dt); // Ra 2014-07: obs³uga zbiornika rozrz¹du oraz pantografów
if (EngineType==WheelsDriven) if (EngineType == WheelsDriven)
d=CabNo*dL; //na chwile dla testu d = CabNo * dL; // na chwile dla testu
else else
d=dL; d = dL;
DistCounter=DistCounter+fabs(dL)/1000.0; DistCounter = DistCounter + fabs(dL) / 1000.0;
dL=0; dL = 0;
//koniec procedury, tu nastepuja dodatkowe procedury pomocnicze // koniec procedury, tu nastepuja dodatkowe procedury pomocnicze
//sprawdzanie i ewentualnie wykonywanie->kasowanie poleceñ // sprawdzanie i ewentualnie wykonywanie->kasowanie poleceñ
if (LoadStatus>0) //czas doliczamy tylko jeœli trwa (roz)³adowanie if (LoadStatus > 0) // czas doliczamy tylko jeœli trwa (roz)³adowanie
LastLoadChangeTime=LastLoadChangeTime+dt; //czas (roz)³adunku LastLoadChangeTime = LastLoadChangeTime + dt; // czas (roz)³adunku
RunInternalCommand(); RunInternalCommand();
if (EngineType==DieselEngine) if (EngineType == DieselEngine)
if (dizel_Update(dt)) if (dizel_Update(dt))
SetFlag(SoundFlag,sound_relay); SetFlag(SoundFlag, sound_relay);
//uklady hamulcowe: // uklady hamulcowe:
if (VeselVolume>0) if (VeselVolume > 0)
Compressor=CompressedVolume/VeselVolume; Compressor = CompressedVolume / VeselVolume;
else else
{ {
Compressor=0; Compressor = 0;
CompressorFlag=false; CompressorFlag = false;
}; };
ConverterCheck(); ConverterCheck();
if (CompressorSpeed>0.0) //sprê¿arka musi mieæ jak¹œ niezerow¹ wydajnoœæ if (CompressorSpeed > 0.0) // sprê¿arka musi mieæ jak¹œ niezerow¹ wydajnoœæ
CompressorCheck(dt); //¿eby rozwa¿aæ jej za³¹czenie i pracê CompressorCheck(dt); //¿eby rozwa¿aæ jej za³¹czenie i pracê
UpdateBrakePressure(dt); UpdateBrakePressure(dt);
UpdatePipePressure(dt); UpdatePipePressure(dt);
UpdateScndPipePressure(dt); // druga rurka, youBy UpdateScndPipePressure(dt); // druga rurka, youBy
UpdateBatteryVoltage(dt); UpdateBatteryVoltage(dt);
//hamulec antyposlizgowy - wy³¹czanie // hamulec antyposlizgowy - wy³¹czanie
if ((BrakeSlippingTimer>0.8)&&(ASBType!=128)) //ASBSpeed=0.8 if ((BrakeSlippingTimer > 0.8) && (ASBType != 128)) // ASBSpeed=0.8
Hamulec->ASB(0); Hamulec->ASB(0);
BrakeSlippingTimer=BrakeSlippingTimer+dt; BrakeSlippingTimer = BrakeSlippingTimer + dt;
return d; return d;
}; };
double __fastcall TMoverParameters::ShowEngineRotation(int VehN) double __fastcall TMoverParameters::ShowEngineRotation(int VehN)
{//pokazywanie obrotów silnika, równie¿ dwóch dalszych pojazdów (3×SN61) { // pokazywanie obrotów silnika, równie¿ dwóch dalszych pojazdów (3×SN61)
int b; int b;
switch (VehN) switch (VehN)
{//numer obrotomierza { // numer obrotomierza
case 1: case 1:
return fabs(enrot); return fabs(enrot);
case 2: case 2:
for (b=0;b<=1;++b) for (b = 0; b <= 1; ++b)
if (TestFlag(Couplers[b].CouplingFlag,ctrain_controll)) if (TestFlag(Couplers[b].CouplingFlag, ctrain_controll))
if (Couplers[b].Connected->Power>0.01) if (Couplers[b].Connected->Power > 0.01)
return fabs(Couplers[b].Connected->enrot); return fabs(Couplers[b].Connected->enrot);
break; break;
case 3: //to nie uwzglêdnia ewentualnego odwrócenia pojazdu w œrodku case 3: // to nie uwzglêdnia ewentualnego odwrócenia pojazdu w œrodku
for (b=0;b<=1;++b) for (b = 0; b <= 1; ++b)
if (TestFlag(Couplers[b].CouplingFlag,ctrain_controll)) if (TestFlag(Couplers[b].CouplingFlag, ctrain_controll))
if (Couplers[b].Connected->Power>0.01) if (Couplers[b].Connected->Power > 0.01)
if (TestFlag(Couplers[b].Connected->Couplers[b].CouplingFlag,ctrain_controll)) if (TestFlag(Couplers[b].Connected->Couplers[b].CouplingFlag, ctrain_controll))
if (Couplers[b].Connected->Couplers[b].Connected->Power>0.01) if (Couplers[b].Connected->Couplers[b].Connected->Power > 0.01)
return fabs(Couplers[b].Connected->Couplers[b].Connected->enrot); return fabs(Couplers[b].Connected->Couplers[b].Connected->enrot);
break; break;
}; };
@@ -563,22 +618,26 @@ double __fastcall TMoverParameters::ShowEngineRotation(int VehN)
}; };
void __fastcall TMoverParameters::ConverterCheck() void __fastcall TMoverParameters::ConverterCheck()
{//sprawdzanie przetwornicy { // sprawdzanie przetwornicy
if (ConverterAllow&&Mains) if (ConverterAllow && Mains)
ConverterFlag=true; ConverterFlag = true;
else else
ConverterFlag=false; ConverterFlag = false;
}; };
int __fastcall TMoverParameters::ShowCurrent(Byte AmpN) int __fastcall TMoverParameters::ShowCurrent(Byte AmpN)
{//odczyt ampera¿u { // odczyt ampera¿u
switch (EngineType) switch (EngineType)
{case ElectricInductionMotor: {
case ElectricInductionMotor:
switch (AmpN) switch (AmpN)
{//do asynchronicznych { // do asynchronicznych
case 1: return WindingRes*Mm/Vadd; case 1:
case 2: return dizel_fill*WindingRes; return WindingRes * Mm / Vadd;
default: return T_MoverParameters::ShowCurrent(AmpN); case 2:
return dizel_fill * WindingRes;
default:
return T_MoverParameters::ShowCurrent(AmpN);
} }
break; break;
case DieselElectric: case DieselElectric:

270
Mover.h
View File

@@ -13,160 +13,166 @@
#include "dumb3d.h" #include "dumb3d.h"
using namespace Math3D; using namespace Math3D;
enum TProblem //lista problemów taboru, które uniemo¿liwiaj¹ jazdê enum TProblem // lista problemów taboru, które uniemo¿liwiaj¹ jazdê
{//flagi bitowe { // flagi bitowe
pr_Hamuje=1, //pojazd ma za³¹czony hamulec lub zatarte osie pr_Hamuje = 1, // pojazd ma za³¹czony hamulec lub zatarte osie
pr_Pantografy=2, //pojazd wymaga napompowania pantografów pr_Pantografy = 2, // pojazd wymaga napompowania pantografów
pr_Ostatni=0x80000000 //ostatnia flaga bitowa pr_Ostatni = 0x80000000 // ostatnia flaga bitowa
}; };
class TMoverParameters : public T_MoverParameters class TMoverParameters : public T_MoverParameters
{//Ra: wrapper na kod pascalowy, przejmuj¹cy jego funkcje { // Ra: wrapper na kod pascalowy, przejmuj¹cy jego funkcje
public: public:
vector3 vCoulpler[2]; //powtórzenie wspó³rzêdnych sprzêgów z DynObj :/ vector3 vCoulpler[2]; // powtórzenie wspó³rzêdnych sprzêgów z DynObj :/
vector3 DimHalf; //po³owy rozmiarów do obliczeñ geometrycznych vector3 DimHalf; // po³owy rozmiarów do obliczeñ geometrycznych
//int WarningSignal; //0: nie trabi, 1,2: trabi syren¹ o podanym numerze // int WarningSignal; //0: nie trabi, 1,2: trabi syren¹ o podanym numerze
unsigned char WarningSignal; //tymczasowo 8bit, ze wzglêdu na funkcje w MTools unsigned char WarningSignal; // tymczasowo 8bit, ze wzglêdu na funkcje w MTools
double fBrakeCtrlPos; //p³ynna nastawa hamulca zespolonego double fBrakeCtrlPos; // p³ynna nastawa hamulca zespolonego
bool bPantKurek3; //kurek trójdrogowy (pantografu): true=po³¹czenie z ZG, false=po³¹czenie z ma³¹ sprê¿ark¹ bool bPantKurek3; // kurek trójdrogowy (pantografu): true=po³¹czenie z ZG, false=po³¹czenie z
int iProblem; //flagi problemów z taborem, aby AI nie musia³o porównywaæ; 0=mo¿e jechaæ // ma³¹ sprê¿ark¹
int iLights[2]; //bity zapalonych œwiate³ tutaj, ¿eby da³o siê liczyæ pobór pr¹du int iProblem; // flagi problemów z taborem, aby AI nie musia³o porównywaæ; 0=mo¿e jechaæ
private: int iLights[2]; // bity zapalonych œwiate³ tutaj, ¿eby da³o siê liczyæ pobór pr¹du
private:
double __fastcall CouplerDist(Byte Coupler); double __fastcall CouplerDist(Byte Coupler);
public:
__fastcall TMoverParameters(double VelInitial,AnsiString TypeNameInit,AnsiString NameInit, public:
int LoadInitial,AnsiString LoadTypeInitial,int Cab); __fastcall TMoverParameters(double VelInitial, AnsiString TypeNameInit, AnsiString NameInit,
//obs³uga sprzêgów int LoadInitial, AnsiString LoadTypeInitial, int Cab);
double __fastcall Distance(const TLocation &Loc1,const TLocation &Loc2,const TDimension &Dim1,const TDimension &Dim2); // obs³uga sprzêgów
double __fastcall Distance(const vector3 &Loc1,const vector3 &Loc2,const vector3 &Dim1,const vector3 &Dim2); double __fastcall Distance(const TLocation &Loc1, const TLocation &Loc2, const TDimension &Dim1,
bool __fastcall Attach(Byte ConnectNo,Byte ConnectToNr,TMoverParameters *ConnectTo,Byte CouplingType,bool Forced=false); const TDimension &Dim2);
bool __fastcall Attach(Byte ConnectNo,Byte ConnectToNr,T_MoverParameters *ConnectTo,Byte CouplingType,bool Forced=false); double __fastcall Distance(const vector3 &Loc1, const vector3 &Loc2, const vector3 &Dim1,
const vector3 &Dim2);
bool __fastcall Attach(Byte ConnectNo, Byte ConnectToNr, TMoverParameters *ConnectTo,
Byte CouplingType, bool Forced = false);
bool __fastcall Attach(Byte ConnectNo, Byte ConnectToNr, T_MoverParameters *ConnectTo,
Byte CouplingType, bool Forced = false);
int __fastcall DettachStatus(Byte ConnectNo); int __fastcall DettachStatus(Byte ConnectNo);
bool __fastcall Dettach(Byte ConnectNo); bool __fastcall Dettach(Byte ConnectNo);
void __fastcall SetCoupleDist(); void __fastcall SetCoupleDist();
bool __fastcall DirectionForward(); bool __fastcall DirectionForward();
void __fastcall BrakeLevelSet(double b); void __fastcall BrakeLevelSet(double b);
bool __fastcall BrakeLevelAdd(double b); bool __fastcall BrakeLevelAdd(double b);
bool __fastcall IncBrakeLevel(); //wersja na u¿ytek AI bool __fastcall IncBrakeLevel(); // wersja na u¿ytek AI
bool __fastcall DecBrakeLevel(); bool __fastcall DecBrakeLevel();
bool __fastcall ChangeCab(int direction); bool __fastcall ChangeCab(int direction);
bool __fastcall CurrentSwitch(int direction); bool __fastcall CurrentSwitch(int direction);
void __fastcall UpdateBatteryVoltage(double dt); void __fastcall UpdateBatteryVoltage(double dt);
double __fastcall ComputeMovement double __fastcall ComputeMovement(double dt, double dt1, const TTrackShape &Shape,
(double dt,double dt1, TTrackParam &Track, TTractionParam &ElectricTraction,
const TTrackShape &Shape,TTrackParam &Track,TTractionParam &ElectricTraction, const TLocation &NewLoc, TRotation &NewRot);
const TLocation &NewLoc,TRotation &NewRot double __fastcall FastComputeMovement(double dt, const TTrackShape &Shape, TTrackParam &Track,
); const TLocation &NewLoc, TRotation &NewRot);
double __fastcall FastComputeMovement
(double dt,
const TTrackShape &Shape,TTrackParam &Track,
const TLocation &NewLoc,TRotation &NewRot
);
double __fastcall ShowEngineRotation(int VehN); double __fastcall ShowEngineRotation(int VehN);
//double __fastcall GetTrainsetVoltage(void); // double __fastcall GetTrainsetVoltage(void);
//bool __fastcall Physic_ReActivation(void); // bool __fastcall Physic_ReActivation(void);
//double __fastcall LocalBrakeRatio(void); // double __fastcall LocalBrakeRatio(void);
//double __fastcall ManualBrakeRatio(void); // double __fastcall ManualBrakeRatio(void);
//double __fastcall PipeRatio(void); // double __fastcall PipeRatio(void);
//double __fastcall RealPipeRatio(void); // double __fastcall RealPipeRatio(void);
//double __fastcall BrakeVP(void); // double __fastcall BrakeVP(void);
//bool __fastcall DynamicBrakeSwitch(bool Switch); // bool __fastcall DynamicBrakeSwitch(bool Switch);
//bool __fastcall SendCtrlBroadcast(AnsiString CtrlCommand, double ctrlvalue); // bool __fastcall SendCtrlBroadcast(AnsiString CtrlCommand, double ctrlvalue);
//bool __fastcall SendCtrlToNext(AnsiString CtrlCommand, double ctrlvalue, double dir); // bool __fastcall SendCtrlToNext(AnsiString CtrlCommand, double ctrlvalue, double dir);
//bool __fastcall CabActivisation(void); // bool __fastcall CabActivisation(void);
//bool __fastcall CabDeactivisation(void); // bool __fastcall CabDeactivisation(void);
//bool __fastcall IncMainCtrl(int CtrlSpeed); // bool __fastcall IncMainCtrl(int CtrlSpeed);
//bool __fastcall DecMainCtrl(int CtrlSpeed); // bool __fastcall DecMainCtrl(int CtrlSpeed);
//bool __fastcall IncScndCtrl(int CtrlSpeed); // bool __fastcall IncScndCtrl(int CtrlSpeed);
//bool __fastcall DecScndCtrl(int CtrlSpeed); // bool __fastcall DecScndCtrl(int CtrlSpeed);
//bool __fastcall AddPulseForce(int Multipler); // bool __fastcall AddPulseForce(int Multipler);
//bool __fastcall SandDoseOn(void); // bool __fastcall SandDoseOn(void);
//bool __fastcall SecuritySystemReset(void); // bool __fastcall SecuritySystemReset(void);
//void __fastcall SecuritySystemCheck(double dt); // void __fastcall SecuritySystemCheck(double dt);
//bool __fastcall BatterySwitch(bool State); // bool __fastcall BatterySwitch(bool State);
//bool __fastcall EpFuseSwitch(bool State); // bool __fastcall EpFuseSwitch(bool State);
//bool __fastcall IncBrakeLevelOld(void); // bool __fastcall IncBrakeLevelOld(void);
//bool __fastcall DecBrakeLevelOld(void); // bool __fastcall DecBrakeLevelOld(void);
//bool __fastcall IncLocalBrakeLevel(Byte CtrlSpeed); // bool __fastcall IncLocalBrakeLevel(Byte CtrlSpeed);
//bool __fastcall DecLocalBrakeLevel(Byte CtrlSpeed); // bool __fastcall DecLocalBrakeLevel(Byte CtrlSpeed);
//bool __fastcall IncLocalBrakeLevelFAST(void); // bool __fastcall IncLocalBrakeLevelFAST(void);
//bool __fastcall DecLocalBrakeLevelFAST(void); // bool __fastcall DecLocalBrakeLevelFAST(void);
//bool __fastcall IncManualBrakeLevel(Byte CtrlSpeed); // bool __fastcall IncManualBrakeLevel(Byte CtrlSpeed);
//bool __fastcall DecManualBrakeLevel(Byte CtrlSpeed); // bool __fastcall DecManualBrakeLevel(Byte CtrlSpeed);
//bool __fastcall EmergencyBrakeSwitch(bool Switch); // bool __fastcall EmergencyBrakeSwitch(bool Switch);
//bool __fastcall AntiSlippingBrake(void); // bool __fastcall AntiSlippingBrake(void);
//bool __fastcall BrakeReleaser(Byte state); // bool __fastcall BrakeReleaser(Byte state);
//bool __fastcall SwitchEPBrake(Byte state); // bool __fastcall SwitchEPBrake(Byte state);
//bool __fastcall AntiSlippingButton(void); // bool __fastcall AntiSlippingButton(void);
//bool __fastcall IncBrakePress(double &brake, double PressLimit, double dp); // bool __fastcall IncBrakePress(double &brake, double PressLimit, double dp);
//bool __fastcall DecBrakePress(double &brake, double PressLimit, double dp); // bool __fastcall DecBrakePress(double &brake, double PressLimit, double dp);
//bool __fastcall BrakeDelaySwitch(Byte BDS); // bool __fastcall BrakeDelaySwitch(Byte BDS);
//bool __fastcall IncBrakeMult(void); // bool __fastcall IncBrakeMult(void);
//bool __fastcall DecBrakeMult(void); // bool __fastcall DecBrakeMult(void);
//void __fastcall UpdateBrakePressure(double dt); // void __fastcall UpdateBrakePressure(double dt);
//void __fastcall UpdatePipePressure(double dt); // void __fastcall UpdatePipePressure(double dt);
//void __fastcall CompressorCheck(double dt); // void __fastcall CompressorCheck(double dt);
void __fastcall UpdatePantVolume(double dt); void __fastcall UpdatePantVolume(double dt);
//void __fastcall UpdateScndPipePressure(double dt); // void __fastcall UpdateScndPipePressure(double dt);
//void __fastcall UpdateBatteryVoltage(double dt); // void __fastcall UpdateBatteryVoltage(double dt);
//double __fastcall GetDVc(double dt); // double __fastcall GetDVc(double dt);
//void __fastcall ComputeConstans(void); // void __fastcall ComputeConstans(void);
//double __fastcall ComputeMass(void); // double __fastcall ComputeMass(void);
//double __fastcall Adhesive(double staticfriction); // double __fastcall Adhesive(double staticfriction);
//double __fastcall TractionForce(double dt); // double __fastcall TractionForce(double dt);
//double __fastcall FrictionForce(double R, Byte TDamage); // double __fastcall FrictionForce(double R, Byte TDamage);
//double __fastcall BrakeForce(const TTrackParam &Track); // double __fastcall BrakeForce(const TTrackParam &Track);
//double __fastcall CouplerForce(Byte CouplerN, double dt); // double __fastcall CouplerForce(Byte CouplerN, double dt);
//void __fastcall CollisionDetect(Byte CouplerN, double dt); // void __fastcall CollisionDetect(Byte CouplerN, double dt);
//double __fastcall ComputeRotatingWheel(double WForce, double dt, double n); // double __fastcall ComputeRotatingWheel(double WForce, double dt, double n);
//bool __fastcall SetInternalCommand(AnsiString NewCommand, double NewValue1, double NewValue2); // bool __fastcall SetInternalCommand(AnsiString NewCommand, double NewValue1, double
//double __fastcall GetExternalCommand(AnsiString &Command); // NewValue2);
//bool __fastcall RunCommand(AnsiString command, double CValue1, double CValue2); // double __fastcall GetExternalCommand(AnsiString &Command);
//bool __fastcall RunInternalCommand(void); // bool __fastcall RunCommand(AnsiString command, double CValue1, double CValue2);
//void __fastcall PutCommand(AnsiString NewCommand, double NewValue1, double NewValue2, const TLocation // bool __fastcall RunInternalCommand(void);
// void __fastcall PutCommand(AnsiString NewCommand, double NewValue1, double NewValue2, const
// TLocation
// &NewLocation); // &NewLocation);
//bool __fastcall DirectionBackward(void); // bool __fastcall DirectionBackward(void);
//bool __fastcall MainSwitch(bool State); // bool __fastcall MainSwitch(bool State);
//bool __fastcall ConverterSwitch(bool State); // bool __fastcall ConverterSwitch(bool State);
//bool __fastcall CompressorSwitch(bool State); // bool __fastcall CompressorSwitch(bool State);
void __fastcall ConverterCheck(); void __fastcall ConverterCheck();
//bool __fastcall FuseOn(void); // bool __fastcall FuseOn(void);
//bool __fastcall FuseFlagCheck(void); // bool __fastcall FuseFlagCheck(void);
//void __fastcall FuseOff(void); // void __fastcall FuseOff(void);
int __fastcall ShowCurrent(Byte AmpN); int __fastcall ShowCurrent(Byte AmpN);
//double __fastcall v2n(void); // double __fastcall v2n(void);
//double __fastcall current(double n, double U); // double __fastcall current(double n, double U);
//double __fastcall Momentum(double I); // double __fastcall Momentum(double I);
//double __fastcall MomentumF(double I, double Iw, Byte SCP); // double __fastcall MomentumF(double I, double Iw, Byte SCP);
//bool __fastcall CutOffEngine(void); // bool __fastcall CutOffEngine(void);
//bool __fastcall MaxCurrentSwitch(bool State); // bool __fastcall MaxCurrentSwitch(bool State);
//bool __fastcall ResistorsFlagCheck(void); // bool __fastcall ResistorsFlagCheck(void);
//bool __fastcall MinCurrentSwitch(bool State); // bool __fastcall MinCurrentSwitch(bool State);
//bool __fastcall AutoRelaySwitch(bool State); // bool __fastcall AutoRelaySwitch(bool State);
//bool __fastcall AutoRelayCheck(void); // bool __fastcall AutoRelayCheck(void);
//bool __fastcall dizel_EngageSwitch(double state); // bool __fastcall dizel_EngageSwitch(double state);
//bool __fastcall dizel_EngageChange(double dt); // bool __fastcall dizel_EngageChange(double dt);
//bool __fastcall dizel_AutoGearCheck(void); // bool __fastcall dizel_AutoGearCheck(void);
//double __fastcall dizel_fillcheck(Byte mcp); // double __fastcall dizel_fillcheck(Byte mcp);
//double __fastcall dizel_Momentum(double dizel_fill, double n, double dt); // double __fastcall dizel_Momentum(double dizel_fill, double n, double dt);
//bool __fastcall dizel_Update(double dt); // bool __fastcall dizel_Update(double dt);
//bool __fastcall LoadingDone(double LSpeed, AnsiString LoadInit); // bool __fastcall LoadingDone(double LSpeed, AnsiString LoadInit);
//void __fastcall ComputeTotalForce(double dt, double dt1, bool FullVer); // void __fastcall ComputeTotalForce(double dt, double dt1, bool FullVer);
//double __fastcall ComputeMovement(double dt, double dt1, const TTrackShape &Shape, TTrackParam &Track // double __fastcall ComputeMovement(double dt, double dt1, const TTrackShape &Shape,
// TTrackParam &Track
// , TTractionParam &ElectricTraction, const TLocation &NewLoc, TRotation &NewRot); // , TTractionParam &ElectricTraction, const TLocation &NewLoc, TRotation &NewRot);
//double __fastcall FastComputeMovement(double dt, const TTrackShape &Shape, TTrackParam &Track, const // double __fastcall FastComputeMovement(double dt, const TTrackShape &Shape, TTrackParam
// &Track, const
// TLocation &NewLoc, TRotation &NewRot); // TLocation &NewLoc, TRotation &NewRot);
//bool __fastcall ChangeOffsetH(double DeltaOffset); // bool __fastcall ChangeOffsetH(double DeltaOffset);
//__fastcall T_MoverParameters(double VelInitial, AnsiString TypeNameInit, AnsiString NameInit, int LoadInitial //__fastcall T_MoverParameters(double VelInitial, AnsiString TypeNameInit, AnsiString NameInit,
//int LoadInitial
// , AnsiString LoadTypeInitial, int Cab); // , AnsiString LoadTypeInitial, int Cab);
//bool __fastcall LoadChkFile(AnsiString chkpath); // bool __fastcall LoadChkFile(AnsiString chkpath);
//bool __fastcall CheckLocomotiveParameters(bool ReadyFlag, int Dir); // bool __fastcall CheckLocomotiveParameters(bool ReadyFlag, int Dir);
//AnsiString __fastcall EngineDescription(int what); // AnsiString __fastcall EngineDescription(int what);
//bool __fastcall DoorLeft(bool State); // bool __fastcall DoorLeft(bool State);
//bool __fastcall DoorRight(bool State); // bool __fastcall DoorRight(bool State);
//bool __fastcall DoorBlockedFlag(void); // bool __fastcall DoorBlockedFlag(void);
//bool __fastcall PantFront(bool State); // bool __fastcall PantFront(bool State);
//bool __fastcall PantRear(bool State); // bool __fastcall PantRear(bool State);
// //
}; };

181
Names.cpp
View File

@@ -31,137 +31,146 @@ Obiekty sortowane wg nazw, mo
*/ */
void __fastcall ItemRecord::TreeAdd(ItemRecord *r,int c) void __fastcall ItemRecord::TreeAdd(ItemRecord *r, int c)
{//dodanie rekordu do drzewa - ustalenie w której gałęzi { // dodanie rekordu do drzewa - ustalenie w której gałęzi
//zapisać w (iFlags) ile znaków jest zgodnych z nadrzędnym, żeby nie sprawdzać wszystkich od zera // zapisać w (iFlags) ile znaków jest zgodnych z nadrzędnym, żeby nie sprawdzać wszystkich od
if ((cName[c]&&r->cName[c])?cName[c]==r->cName[c]:false) // zera
TreeAdd(r,c+1); //ustawić wg kolejnego znaku, chyba że zero if ((cName[c] && r->cName[c]) ? cName[c] == r->cName[c] : false)
TreeAdd(r, c + 1); // ustawić wg kolejnego znaku, chyba że zero
else if ((unsigned char)(cName[c]) < (unsigned char)(r->cName[c]))
{ // zero jest najmniejsze - doczepiamy jako (rNext)
if (!rNext)
rNext = r;
else else
if ((unsigned char)(cName[c])<(unsigned char)(r->cName[c])) rNext->TreeAdd(r, 0); // doczepić do tej gałęzi
{//zero jest najmniejsze - doczepiamy jako (rNext)
if (!rNext) rNext=r;
else rNext->TreeAdd(r,0); //doczepić do tej gałęzi
} }
else else
{ {
if (!rPrev) rPrev=r; if (!rPrev)
else rPrev->TreeAdd(r,0); //doczepić do tej gałęzi rPrev = r;
else
rPrev->TreeAdd(r, 0); // doczepić do tej gałęzi
} }
}; };
void __fastcall ItemRecord::ListGet(ItemRecord *r,int*&n) void __fastcall ItemRecord::ListGet(ItemRecord *r, int *&n)
{//rekurencyjne wypełnianie posortowanej listy na podstawie drzewa { // rekurencyjne wypełnianie posortowanej listy na podstawie drzewa
if (rPrev) rPrev->ListGet(r,n); //dodanie wszystkich wcześniejszych if (rPrev)
*n++=this-r; //dodanie swojego indeksu do tabeli rPrev->ListGet(r, n); // dodanie wszystkich wcześniejszych
if (rNext) rNext->ListGet(r,n); //dodanie wszystkich późniejszych *n++ = this - r; // dodanie swojego indeksu do tabeli
if (rNext)
rNext->ListGet(r, n); // dodanie wszystkich późniejszych
}; };
void* __fastcall ItemRecord::TreeFind(const char *n) void *__fastcall ItemRecord::TreeFind(const char *n)
{//wyszukanie ciągu (n) { // wyszukanie ciągu (n)
ItemRecord *r=TreeFindRecord(n); ItemRecord *r = TreeFindRecord(n);
return r?r->pData:NULL; return r ? r->pData : NULL;
}; };
ItemRecord* __fastcall ItemRecord::TreeFindRecord(const char *n) ItemRecord *__fastcall ItemRecord::TreeFindRecord(const char *n)
{//wyszukanie ciągu (n) { // wyszukanie ciągu (n)
ItemRecord *r=this; //żeby nie robić rekurencji ItemRecord *r = this; //żeby nie robić rekurencji
int i=0; int i = 0;
do do
{ {
if (!n[i]) if (!r->cName[i]) return r; //znaleziony if (!n[i])
if (n[i]==r->cName[i]) if (!r->cName[i])
++i; //porównać kolejny znak return r; // znaleziony
else if (n[i] == r->cName[i])
if ((unsigned char)(n[i])<(unsigned char)(r->cName[i])) ++i; // porównać kolejny znak
else if ((unsigned char)(n[i]) < (unsigned char)(r->cName[i]))
{ {
i=0; //porównywać od nowa i = 0; // porównywać od nowa
r=r->rPrev; //wcześniejsza gałąź drzewa r = r->rPrev; // wcześniejsza gałąź drzewa
} }
else else
{ {
i=0; //porównywać od nowa i = 0; // porównywać od nowa
r=r->rNext; //późniejsza gałąź drzewa r = r->rNext; // późniejsza gałąź drzewa
} }
} while (r); } while (r);
return NULL; return NULL;
}; };
__fastcall TNames::TNames() __fastcall TNames::TNames()
{//tworzenie bufora { // tworzenie bufora
iSize=16*1024*1024; //rozmiar bufora w bajtach iSize = 16 * 1024 * 1024; // rozmiar bufora w bajtach
cBuffer=new char[iSize]; cBuffer = new char[iSize];
ZeroMemory(cBuffer,iSize); //nie trzymać jakiś starych śmieci ZeroMemory(cBuffer, iSize); // nie trzymać jakiś starych śmieci
rRecords=(ItemRecord*)cBuffer; rRecords = (ItemRecord *)cBuffer;
cLast=cBuffer+iSize; //bajt za buforem cLast = cBuffer + iSize; // bajt za buforem
iLast=-1; iLast = -1;
ZeroMemory(rTypes,20*sizeof(ItemRecord*)); ZeroMemory(rTypes, 20 * sizeof(ItemRecord *));
}; };
int __fastcall TNames::Add(int t,const char *n) int __fastcall TNames::Add(int t, const char *n)
{//dodanie obiektu typu (t) o nazwie (n) { // dodanie obiektu typu (t) o nazwie (n)
int len=strlen(n)+1; //ze znacznikiem końca int len = strlen(n) + 1; // ze znacznikiem końca
cLast-=len; //rezerwacja miejsca cLast -= len; // rezerwacja miejsca
memcpy(cLast,n,len); //przekopiowanie tekstu do bufora memcpy(cLast, n, len); // przekopiowanie tekstu do bufora
//cLast[len-1]='\0'; // cLast[len-1]='\0';
rRecords[++iLast].cName=cLast; //połączenie nazwy z rekordem rRecords[++iLast].cName = cLast; // połączenie nazwy z rekordem
rRecords[iLast].iFlags=t; rRecords[iLast].iFlags = t;
if (!rTypes[t]) if (!rTypes[t])
rTypes[t]=rRecords+iLast; //korzeń drzewa, bo nie było wcześniej rTypes[t] = rRecords + iLast; // korzeń drzewa, bo nie było wcześniej
else else
rTypes[t]->TreeAdd(rRecords+iLast,0); //doczepienie jako gałąź rTypes[t]->TreeAdd(rRecords + iLast, 0); // doczepienie jako gałąź
//rTypes[t]=Sort(t); //sortowanie uruchamiać ręcznie // rTypes[t]=Sort(t); //sortowanie uruchamiać ręcznie
if ((iLast&0x3F)==0) //nie za często, bo sortowania zajmą więcej czasu niż wyszukiwania if ((iLast & 0x3F) == 0) // nie za często, bo sortowania zajmą więcej czasu niż wyszukiwania
Sort(t); //optymalizacja drzewa co jakiś czas Sort(t); // optymalizacja drzewa co jakiś czas
return iLast; return iLast;
} }
int __fastcall TNames::Add(int t,const char *n,void *d) int __fastcall TNames::Add(int t, const char *n, void *d)
{ {
int i=Add(t,n); int i = Add(t, n);
rRecords[iLast].pData=d; rRecords[iLast].pData = d;
return i; return i;
}; };
bool __fastcall TNames::Update(int t,const char *n,void *d) bool __fastcall TNames::Update(int t, const char *n, void *d)
{//dodanie jeśli nie ma, wymiana (d), gdy jest { // dodanie jeśli nie ma, wymiana (d), gdy jest
ItemRecord *r=FindRecord(t,n); //najpierw sprawdzić, czy już jest ItemRecord *r = FindRecord(t, n); // najpierw sprawdzić, czy już jest
if (r) if (r)
{//przy zdublowaniu nazwy podmieniać w drzewku na późniejszy { // przy zdublowaniu nazwy podmieniać w drzewku na późniejszy
r->pData=d; r->pData = d;
return true; //duplikat return true; // duplikat
} }
//Add(t,n,d); //nazwa unikalna // Add(t,n,d); //nazwa unikalna
return false; //został dodany nowy return false; // został dodany nowy
}; };
ItemRecord* __fastcall TNames::TreeSet(int *n,int d,int u) ItemRecord *__fastcall TNames::TreeSet(int *n, int d, int u)
{//rekurencyjne wypełnianie drzewa pozycjami od (d) do (u) { // rekurencyjne wypełnianie drzewa pozycjami od (d) do (u)
if (d==u) if (d == u)
{ {
rRecords[n[d]].rPrev=rRecords[n[d]].rNext=NULL; rRecords[n[d]].rPrev = rRecords[n[d]].rNext = NULL;
return rRecords+n[d]; //tej gałęzi nie ma return rRecords + n[d]; // tej gałęzi nie ma
} }
else if (d>u) return NULL; else if (d > u)
int p=(u+d)>>1; //połowa return NULL;
rRecords[n[p]].rPrev=TreeSet(n,d,p-1); //zapisanie wcześniejszych gałęzi int p = (u + d) >> 1; // połowa
rRecords[n[p]].rNext=TreeSet(n,p+1,u); //zapisanie późniejszych gałęzi rRecords[n[p]].rPrev = TreeSet(n, d, p - 1); // zapisanie wcześniejszych gałęzi
return rRecords+n[p]; rRecords[n[p]].rNext = TreeSet(n, p + 1, u); // zapisanie późniejszych gałęzi
return rRecords + n[p];
}; };
void __fastcall TNames::Sort(int t) void __fastcall TNames::Sort(int t)
{//przebudowa drzewa typu (t), zwraca wierzchołek drzewa { // przebudowa drzewa typu (t), zwraca wierzchołek drzewa
if (iLast<3) return; //jak jest mało, to nie ma sensu sortować if (iLast < 3)
if (rTypes[t]) //jeśli jest jakiś rekord danego typu return; // jak jest mało, to nie ma sensu sortować
{int *r=new int[iLast+1]; //robocza tablica indeksów - numery posortowanych rekordów if (rTypes[t]) // jeśli jest jakiś rekord danego typu
int *q=r; //wskaźnik roboczy, przekazywany przez referencję {
rTypes[t]->ListGet(rRecords,q); //drzewo jest już posortowane - zamienić je na listę int *r = new int[iLast + 1]; // robocza tablica indeksów - numery posortowanych rekordów
rTypes[t]=TreeSet(r,0,(q-r)-1); int *q = r; // wskaźnik roboczy, przekazywany przez referencję
rTypes[t]->ListGet(rRecords, q); // drzewo jest już posortowane - zamienić je na listę
rTypes[t] = TreeSet(r, 0, (q - r) - 1);
delete[] r; delete[] r;
} }
return; return;
}; };
ItemRecord* __fastcall TNames::FindRecord(const int t,const char *n) ItemRecord *__fastcall TNames::FindRecord(const int t, const char *n)
{//poszukiwanie rekordu w celu np. zmiany wskaźnika { // poszukiwanie rekordu w celu np. zmiany wskaźnika
return rTypes[t]?rTypes[t]->TreeFindRecord(n):NULL; return rTypes[t] ? rTypes[t]->TreeFindRecord(n) : NULL;
}; };

73
Names.h
View File

@@ -4,50 +4,53 @@
#define NamesH #define NamesH
//--------------------------------------------------------------------------- //---------------------------------------------------------------------------
class ItemRecord class ItemRecord
{//rekord opisuj¹cy obiekt; raz utworzony nie przemieszcza siê { // rekord opisuj¹cy obiekt; raz utworzony nie przemieszcza siê
//rozmiar rekordu mo¿na zmieniæ w razie potrzeby // rozmiar rekordu mo¿na zmieniæ w razie potrzeby
public: public:
char *cName; //wskaŸnik do nazwy umieszczonej w buforze char *cName; // wskaŸnik do nazwy umieszczonej w buforze
int iFlags; //flagi bitowe int iFlags; // flagi bitowe
ItemRecord *rPrev,*rNext; //posortowane drzewo (przebudowywane w razie potrzeby) ItemRecord *rPrev, *rNext; // posortowane drzewo (przebudowywane w razie potrzeby)
union union
{void *pData; //wskaŸnik do obiektu {
int iData; //albo numer obiektu (tekstury) void *pData; // wskaŸnik do obiektu
int iData; // albo numer obiektu (tekstury)
unsigned int uData; unsigned int uData;
}; };
//typedef // typedef
void __fastcall ListGet(ItemRecord *r,int*&n); void __fastcall ListGet(ItemRecord *r, int *&n);
void __fastcall TreeAdd(ItemRecord *r,int c); void __fastcall TreeAdd(ItemRecord *r, int c);
template <typename TOut> inline TOut* DataGet() {return (TOut*)pData;}; template <typename TOut> inline TOut *DataGet() { return (TOut *)pData; };
template <typename TOut> inline void DataSet(TOut *x) {pData=(void*)x;}; template <typename TOut> inline void DataSet(TOut *x) { pData = (void *)x; };
void* __fastcall TreeFind(const char *n); void *__fastcall TreeFind(const char *n);
ItemRecord* __fastcall TreeFindRecord(const char *n); ItemRecord *__fastcall TreeFindRecord(const char *n);
}; };
class TNames class TNames
{ {
public: public:
int iSize; //rozmiar bufora int iSize; // rozmiar bufora
char *cBuffer; //bufor dla rekordów (na pocz¹tku) i nazw (na koñcu) char *cBuffer; // bufor dla rekordów (na pocz¹tku) i nazw (na koñcu)
ItemRecord *rRecords; //rekordy na pocz¹tku bufora ItemRecord *rRecords; // rekordy na pocz¹tku bufora
char *cLast; //ostatni u¿yty bajt na nazwy char *cLast; // ostatni u¿yty bajt na nazwy
ItemRecord *rTypes[20]; //ro¿ne typy obiektów (pocz¹tek drzewa) ItemRecord *rTypes[20]; // ro¿ne typy obiektów (pocz¹tek drzewa)
int iLast; //ostatnio u¿yty rekord int iLast; // ostatnio u¿yty rekord
public: public:
__fastcall TNames(); __fastcall TNames();
int __fastcall Add(int t,const char *n); //dodanie obiektu typu (t) int __fastcall Add(int t, const char *n); // dodanie obiektu typu (t)
int __fastcall Add(int t,const char *n,void *d); //dodanie obiektu z wskaŸnikiem int __fastcall Add(int t, const char *n, void *d); // dodanie obiektu z wskaŸnikiem
int __fastcall Add(int t,const char *n,int d); //dodanie obiektu z numerem int __fastcall Add(int t, const char *n, int d); // dodanie obiektu z numerem
bool __fastcall Update(int t,const char *n,void *d); //dodanie jeœli nie ma, wymiana (d), gdy jest bool __fastcall Update(int t, const char *n,
void *d); // dodanie jeœli nie ma, wymiana (d), gdy jest
void __fastcall TreeSet(); void __fastcall TreeSet();
ItemRecord* __fastcall TreeSet(int *n,int d,int u); ItemRecord *__fastcall TreeSet(int *n, int d, int u);
void __fastcall Sort(int t); //przebudowa drzewa typu (t) void __fastcall Sort(int t); // przebudowa drzewa typu (t)
ItemRecord* __fastcall Item(int n); //rekord o numerze (n) ItemRecord *__fastcall Item(int n); // rekord o numerze (n)
inline void* Find(const int t,const char *n) inline void *Find(const int t, const char *n)
{return rTypes[t]?rTypes[t]->TreeFind(n):NULL;}; {
ItemRecord* __fastcall FindRecord(const int t,const char *n); return rTypes[t] ? rTypes[t]->TreeFind(n) : NULL;
//template <typename TOut> inline TOut* Find(const int t,const char *n) };
ItemRecord *__fastcall FindRecord(const int t, const char *n);
// template <typename TOut> inline TOut* Find(const int t,const char *n)
//{return (TOut*)(rTypes[t]->TreeFind(n));}; //{return (TOut*)(rTypes[t]->TreeFind(n));};
}; };
#endif #endif

291
RealSound.cpp
View File

@@ -18,141 +18,150 @@
__fastcall TRealSound::TRealSound() __fastcall TRealSound::TRealSound()
{ {
pSound=NULL; pSound = NULL;
dSoundAtt=-1; dSoundAtt = -1;
AM=0.0; AM = 0.0;
AA=0.0; AA = 0.0;
FM=0.0; FM = 0.0;
FA=0.0; FA = 0.0;
vSoundPosition.x=0; vSoundPosition.x = 0;
vSoundPosition.y=0; vSoundPosition.y = 0;
vSoundPosition.z=0; vSoundPosition.z = 0;
fDistance=fPreviousDistance=0.0; fDistance = fPreviousDistance = 0.0;
fFrequency=22050.0; //częstotliwość samplowania pliku fFrequency = 22050.0; // częstotliwość samplowania pliku
iDoppler=0; //normlanie jest załączony; !=0 - modyfikacje iDoppler = 0; // normlanie jest załączony; !=0 - modyfikacje
bLoopPlay=false; //dźwięk wyłączony bLoopPlay = false; // dźwięk wyłączony
} }
__fastcall TRealSound::~TRealSound() __fastcall TRealSound::~TRealSound()
{ {
//if (this) if (pSound) pSound->Stop(); // if (this) if (pSound) pSound->Stop();
} }
void __fastcall TRealSound::Free() void __fastcall TRealSound::Free() {}
{
}
void __fastcall TRealSound::Init(char *SoundName, double DistanceAttenuation, double X, double Y, double Z,bool Dynamic,bool freqmod,double rmin) void __fastcall TRealSound::Init(char *SoundName, double DistanceAttenuation, double X, double Y,
double Z, bool Dynamic, bool freqmod, double rmin)
{ {
//Nazwa=SoundName; //to tak raczej nie zadziała, (SoundName) jest tymczasowe // Nazwa=SoundName; //to tak raczej nie zadziała, (SoundName) jest tymczasowe
pSound=TSoundsManager::GetFromName(SoundName,Dynamic,&fFrequency); pSound = TSoundsManager::GetFromName(SoundName, Dynamic, &fFrequency);
if (pSound) if (pSound)
{ {
if (freqmod) if (freqmod)
if (fFrequency!=22050.0) if (fFrequency != 22050.0)
{//dla modulowanych nie może być zmiany mnożnika, bo częstotliwość w nagłówku byłą ignorowana, a mogła być inna niż 22050 { // dla modulowanych nie może być zmiany mnożnika, bo częstotliwość w nagłówku byłą
fFrequency=22050.0; // ignorowana, a mogła być inna niż 22050
ErrorLog("Bad sound: "+AnsiString(SoundName)+", as modulated, should have 22.05kHz in header"); fFrequency = 22050.0;
ErrorLog("Bad sound: " + AnsiString(SoundName) +
", as modulated, should have 22.05kHz in header");
} }
AM=1.0; AM = 1.0;
pSound->SetVolume(DSBVOLUME_MIN); pSound->SetVolume(DSBVOLUME_MIN);
} }
else else
{//nie ma dźwięku, to jest wysyp { // nie ma dźwięku, to jest wysyp
AM=0; AM = 0;
ErrorLog("Missed sound: "+AnsiString(SoundName)); ErrorLog("Missed sound: " + AnsiString(SoundName));
} }
if (DistanceAttenuation>0.0) if (DistanceAttenuation > 0.0)
{ {
dSoundAtt=DistanceAttenuation*DistanceAttenuation; dSoundAtt = DistanceAttenuation * DistanceAttenuation;
vSoundPosition.x=X; vSoundPosition.x = X;
vSoundPosition.y=Y; vSoundPosition.y = Y;
vSoundPosition.z=Z; vSoundPosition.z = Z;
if (rmin<0) iDoppler=1; //wyłączenie efektu Dopplera, np. dla dźwięku ptaków if (rmin < 0)
iDoppler = 1; // wyłączenie efektu Dopplera, np. dla dźwięku ptaków
} }
else else
dSoundAtt=-1; dSoundAtt = -1;
}; };
double __fastcall TRealSound::ListenerDistance(vector3 ListenerPosition) double __fastcall TRealSound::ListenerDistance(vector3 ListenerPosition)
{ {
if (dSoundAtt==-1) if (dSoundAtt == -1)
{ return 0.0; } {
return 0.0;
}
else else
{ return SquareMagnitude(ListenerPosition-vSoundPosition); } {
return SquareMagnitude(ListenerPosition - vSoundPosition);
}
} }
void __fastcall TRealSound::Play(double Volume, int Looping, bool ListenerInside, vector3 NewPosition) void __fastcall TRealSound::Play(double Volume, int Looping, bool ListenerInside,
vector3 NewPosition)
{ {
if (!pSound) return; if (!pSound)
return;
long int vol; long int vol;
double dS; double dS;
// double Distance; // double Distance;
DWORD stat; DWORD stat;
if ((Global::bSoundEnabled)&&(AM!=0)) if ((Global::bSoundEnabled) && (AM != 0))
{ {
if (Volume>1.0) if (Volume > 1.0)
Volume=1.0; Volume = 1.0;
fPreviousDistance=fDistance; fPreviousDistance = fDistance;
fDistance=0.0; //?? fDistance = 0.0; //??
if (dSoundAtt>0.0) if (dSoundAtt > 0.0)
{ {
vSoundPosition=NewPosition; vSoundPosition = NewPosition;
dS=dSoundAtt; //*dSoundAtt; //bo odleglosc podawana w kwadracie dS = dSoundAtt; //*dSoundAtt; //bo odleglosc podawana w kwadracie
fDistance=ListenerDistance(Global::pCameraPosition); fDistance = ListenerDistance(Global::pCameraPosition);
if (ListenerInside) //osłabianie dźwięków z odległością if (ListenerInside) // osłabianie dźwięków z odległością
Volume=Volume*dS/(dS+fDistance); Volume = Volume * dS / (dS + fDistance);
else else
Volume=Volume*dS/(dS+2*fDistance); //podwójne dla ListenerInside=false Volume = Volume * dS / (dS + 2 * fDistance); // podwójne dla ListenerInside=false
} }
if (iDoppler) // if (iDoppler) //
{//Ra 2014-07: efekt Dopplera nie zawsze jest wskazany { // Ra 2014-07: efekt Dopplera nie zawsze jest wskazany
//if (FreeFlyModeFlag) //gdy swobodne latanie - nie sprawdza się to // if (FreeFlyModeFlag) //gdy swobodne latanie - nie sprawdza się to
fPreviousDistance=fDistance; //to efektu Dopplera nie będzie fPreviousDistance = fDistance; // to efektu Dopplera nie będzie
} }
if (Looping) //dźwięk zapętlony można wyłączyć i zostanie włączony w miarę potrzeby if (Looping) // dźwięk zapętlony można wyłączyć i zostanie włączony w miarę potrzeby
bLoopPlay=true; //dźwięk wyłączony bLoopPlay = true; // dźwięk wyłączony
//McZapkie-010302 - babranie tylko z niezbyt odleglymi dźwiękami // McZapkie-010302 - babranie tylko z niezbyt odleglymi dźwiękami
if ((dSoundAtt==-1)||(fDistance<20.0*dS)) if ((dSoundAtt == -1) || (fDistance < 20.0 * dS))
{ {
// vol=2*Volume+1; // vol=2*Volume+1;
// if (vol<1) vol=1; // if (vol<1) vol=1;
// vol=10000*(log(vol)-1); // vol=10000*(log(vol)-1);
// vol=10000*(vol-1); // vol=10000*(vol-1);
//int glos=1; // int glos=1;
//Volume=Volume*glos; //Ra: whatta hella is this // Volume=Volume*glos; //Ra: whatta hella is this
if (Volume<0.0) Volume=0.0; if (Volume < 0.0)
vol=-5000.0+5000.0*Volume; Volume = 0.0;
if (vol>=0) vol = -5000.0 + 5000.0 * Volume;
vol=-1; if (vol >= 0)
if (Timer::GetSoundTimer()||!Looping) //Ra: po co to jest? vol = -1;
pSound->SetVolume(vol); //Attenuation, in hundredths of a decibel (dB). if (Timer::GetSoundTimer() || !Looping) // Ra: po co to jest?
pSound->SetVolume(vol); // Attenuation, in hundredths of a decibel (dB).
pSound->GetStatus(&stat); pSound->GetStatus(&stat);
if (!(stat&DSBSTATUS_PLAYING)) if (!(stat & DSBSTATUS_PLAYING))
pSound->Play(0,0,Looping); pSound->Play(0, 0, Looping);
} }
else //wylacz dzwiek bo daleko else // wylacz dzwiek bo daleko
{//Ra 2014-09: oddalanie się nie może być powodem do wyłączenie dźwięku { // Ra 2014-09: oddalanie się nie może być powodem do wyłączenie dźwięku
/* /*
// Ra: stara wersja, ale podobno lepsza // Ra: stara wersja, ale podobno lepsza
pSound->GetStatus(&stat); pSound->GetStatus(&stat);
if (bLoopPlay) //jeśli zapętlony, to zostanie ponownie włączony, o ile znajdzie się bliżej if (bLoopPlay) //jeśli zapętlony, to zostanie ponownie włączony, o ile znajdzie się
bliżej
if (stat&DSBSTATUS_PLAYING) if (stat&DSBSTATUS_PLAYING)
pSound->Stop(); pSound->Stop();
// Ra: wyłączyłem, bo podobno jest gorzej niż wcześniej // Ra: wyłączyłem, bo podobno jest gorzej niż wcześniej
//ZiomalCl: dźwięk po wyłączeniu sam się nie włączy, gdy wrócimy w rejon odtwarzania //ZiomalCl: dźwięk po wyłączeniu sam się nie włączy, gdy wrócimy w rejon odtwarzania
pSound->SetVolume(DSBVOLUME_MIN); //dlatego lepiej go wyciszyć na czas oddalenia się pSound->SetVolume(DSBVOLUME_MIN); //dlatego lepiej go wyciszyć na czas oddalenia się
pSound->GetStatus(&stat); pSound->GetStatus(&stat);
if (!(stat&DSBSTATUS_PLAYING)) if (!(stat&DSBSTATUS_PLAYING))
pSound->Play(0,0,Looping); //ZiomalCl: włączenie odtwarzania rownież i tu, gdyż jesli uruchamiamy dźwięk poza promieniem, nie uruchomi się on w ogóle pSound->Play(0,0,Looping); //ZiomalCl: włączenie odtwarzania rownież i tu, gdyż
*/ jesli uruchamiamy dźwięk poza promieniem, nie uruchomi się on w ogóle
*/
} }
} }
}; };
void __fastcall TRealSound::Start() void __fastcall TRealSound::Start(){// włączenie dźwięku
{//włączenie dźwięku
}; };
@@ -160,57 +169,59 @@ void __fastcall TRealSound::Stop()
{ {
DWORD stat; DWORD stat;
if (pSound) if (pSound)
if ((Global::bSoundEnabled)&&(AM!=0)) if ((Global::bSoundEnabled) && (AM != 0))
{ {
bLoopPlay=false; //dźwięk wyłączony bLoopPlay = false; // dźwięk wyłączony
pSound->GetStatus(&stat); pSound->GetStatus(&stat);
if (stat&DSBSTATUS_PLAYING) if (stat & DSBSTATUS_PLAYING)
pSound->Stop(); pSound->Stop();
} }
}; };
void __fastcall TRealSound::AdjFreq(double Freq, double dt) //McZapkie TODO: dorobic tu efekt Dopplera void __fastcall TRealSound::AdjFreq(double Freq,
//Freq moze byc liczba dodatnia mniejsza od 1 lub wieksza od 1 double dt) // McZapkie TODO: dorobic tu efekt Dopplera
// Freq moze byc liczba dodatnia mniejsza od 1 lub wieksza od 1
{ {
float df, Vlist, Vsrc; float df, Vlist, Vsrc;
if ((Global::bSoundEnabled) && (AM!=0)) if ((Global::bSoundEnabled) && (AM != 0))
{ {
if (dt>0) if (dt > 0)
//efekt Dopplera // efekt Dopplera
{ {
Vlist=(sqrt(fPreviousDistance)-sqrt(fDistance))/dt; Vlist = (sqrt(fPreviousDistance) - sqrt(fDistance)) / dt;
df= Freq*(1+Vlist/299.8); df = Freq * (1 + Vlist / 299.8);
} }
else else
df=Freq; df = Freq;
if (Timer::GetSoundTimer()) if (Timer::GetSoundTimer())
{ {
df=fFrequency*df; //TODO - brac czestotliwosc probkowania z wav df = fFrequency * df; // TODO - brac czestotliwosc probkowania z wav
pSound->SetFrequency(( df<DSBFREQUENCY_MIN ? DSBFREQUENCY_MIN : (df>DSBFREQUENCY_MAX ? DSBFREQUENCY_MAX : df) ) ); pSound->SetFrequency((df < DSBFREQUENCY_MIN ?
DSBFREQUENCY_MIN :
(df > DSBFREQUENCY_MAX ? DSBFREQUENCY_MAX : df)));
} }
} }
} }
double TRealSound::GetWaveTime() //McZapkie: na razie tylko dla 22KHz/8bps double TRealSound::GetWaveTime() // McZapkie: na razie tylko dla 22KHz/8bps
{//używana do pomiaru czasu dla dźwięków z początkiem i końcem { // używana do pomiaru czasu dla dźwięków z początkiem i końcem
if (!pSound) return 0.0; if (!pSound)
return 0.0;
double WaveTime; double WaveTime;
DSBCAPS caps; DSBCAPS caps;
caps.dwSize=sizeof(caps); caps.dwSize = sizeof(caps);
pSound->GetCaps(&caps); pSound->GetCaps(&caps);
WaveTime=caps.dwBufferBytes; WaveTime = caps.dwBufferBytes;
return WaveTime/fFrequency; //(pSound->); // wielkosc w bajtach przez czestotliwosc probkowania return WaveTime /
fFrequency; //(pSound->); // wielkosc w bajtach przez czestotliwosc probkowania
} }
void __fastcall TRealSound::SetPan(int Pan) void __fastcall TRealSound::SetPan(int Pan) { pSound->SetPan(Pan); }
{
pSound->SetPan(Pan);
}
int TRealSound::GetStatus() int TRealSound::GetStatus()
{ {
DWORD stat; DWORD stat;
if ((Global::bSoundEnabled) && (AM!=0)) if ((Global::bSoundEnabled) && (AM != 0))
{ {
pSound->GetStatus(&stat); pSound->GetStatus(&stat);
return stat; return stat;
@@ -221,57 +232,59 @@ DWORD stat;
void __fastcall TRealSound::ResetPosition() void __fastcall TRealSound::ResetPosition()
{ {
if (pSound) //Ra: znowu jakiś badziew! if (pSound) // Ra: znowu jakiś badziew!
pSound->SetCurrentPosition(0); pSound->SetCurrentPosition(0);
} }
void __fastcall TTextSound::Init(char *SoundName,double SoundAttenuation,double X,double Y,double Z,bool Dynamic,bool freqmod,double rmin) void __fastcall TTextSound::Init(char *SoundName, double SoundAttenuation, double X, double Y,
{//dodatkowo doczytuje plik tekstowy double Z, bool Dynamic, bool freqmod, double rmin)
TRealSound::Init(SoundName,SoundAttenuation,X,Y,Z,Dynamic,freqmod,rmin); { // dodatkowo doczytuje plik tekstowy
fTime=GetWaveTime(); TRealSound::Init(SoundName, SoundAttenuation, X, Y, Z, Dynamic, freqmod, rmin);
AnsiString txt=AnsiString(SoundName); fTime = GetWaveTime();
txt.Delete(txt.Length()-3,4); //obcięcie rozszerzenia AnsiString txt = AnsiString(SoundName);
for (int i=txt.Length();i>0;--i) txt.Delete(txt.Length() - 3, 4); // obcięcie rozszerzenia
if (txt[i]=='/') txt[i]='\\'; //bo nie rozumi for (int i = txt.Length(); i > 0; --i)
txt+="-"+Global::asLang+".txt"; //już może być w różnych językach if (txt[i] == '/')
txt[i] = '\\'; // bo nie rozumi
txt += "-" + Global::asLang + ".txt"; // już może być w różnych językach
if (!FileExists(txt)) if (!FileExists(txt))
txt="sounds\\"+txt; //ścieżka może nie być podana txt = "sounds\\" + txt; //ścieżka może nie być podana
if (FileExists(txt)) if (FileExists(txt))
{//wczytanie { // wczytanie
TFileStream *ts=new TFileStream(txt,fmOpenRead); TFileStream *ts = new TFileStream(txt, fmOpenRead);
asText=AnsiString::StringOfChar(' ',ts->Size); asText = AnsiString::StringOfChar(' ', ts->Size);
ts->Read(asText.c_str(),ts->Size); ts->Read(asText.c_str(), ts->Size);
delete ts; delete ts;
} }
}; };
void __fastcall TTextSound::Play(double Volume,int Looping,bool ListenerInside,vector3 NewPosition) void __fastcall TTextSound::Play(double Volume, int Looping, bool ListenerInside,
vector3 NewPosition)
{ {
if (!asText.IsEmpty()) if (!asText.IsEmpty())
{//jeśli ma powiązany tekst { // jeśli ma powiązany tekst
DWORD stat; DWORD stat;
pSound->GetStatus(&stat); pSound->GetStatus(&stat);
if (!(stat&DSBSTATUS_PLAYING)) //jeśli nie jest aktualnie odgrywany if (!(stat & DSBSTATUS_PLAYING)) // jeśli nie jest aktualnie odgrywany
{ {
int i; int i;
AnsiString t=asText; AnsiString t = asText;
do do
{//na razie zrobione jakkolwiek, docelowo przenieść teksty do tablicy nazw { // na razie zrobione jakkolwiek, docelowo przenieść teksty do tablicy nazw
i=t.Pos("\r"); //znak nowej linii i = t.Pos("\r"); // znak nowej linii
if (!i) if (!i)
Global::tranTexts.Add(t.c_str(),fTime,true); Global::tranTexts.Add(t.c_str(), fTime, true);
else else
{ {
Global::tranTexts.Add(t.SubString(1,i-1).c_str(),fTime,true); Global::tranTexts.Add(t.SubString(1, i - 1).c_str(), fTime, true);
t.Delete(1,i); t.Delete(1, i);
while (t.IsEmpty()?false:(unsigned char)(t[1])<33) while (t.IsEmpty() ? false : (unsigned char)(t[1]) < 33)
t.Delete(1,1); t.Delete(1, 1);
} }
} while (i>0); } while (i > 0);
} }
} }
TRealSound::Play(Volume,Looping,ListenerInside,NewPosition); TRealSound::Play(Volume, Looping, ListenerInside, NewPosition);
}; };
//--------------------------------------------------------------------------- //---------------------------------------------------------------------------
#pragma package(smart_init) #pragma package(smart_init)

74
RealSound.h
View File

@@ -7,60 +7,62 @@
class TRealSound class TRealSound
{ {
protected: protected:
PSound pSound; PSound pSound;
char* Nazwa; //dla celow odwszawiania char *Nazwa; // dla celow odwszawiania
double fDistance,fPreviousDistance; //dla liczenia Dopplera double fDistance, fPreviousDistance; // dla liczenia Dopplera
float fFrequency; //częstotliwość samplowania pliku float fFrequency; // częstotliwość samplowania pliku
int iDoppler; //Ra 2014-07: możliwość wyłączenia efektu Dopplera np. dla śpiewu ptaków int iDoppler; // Ra 2014-07: możliwość wyłączenia efektu Dopplera np. dla śpiewu ptaków
public: public:
vector3 vSoundPosition; //polozenie zrodla dzwieku vector3 vSoundPosition; // polozenie zrodla dzwieku
double dSoundAtt; //odleglosc polowicznego zaniku dzwieku double dSoundAtt; // odleglosc polowicznego zaniku dzwieku
double AM; //mnoznik amplitudy double AM; // mnoznik amplitudy
double AA; //offset amplitudy double AA; // offset amplitudy
double FM; //mnoznik czestotliwosci double FM; // mnoznik czestotliwosci
double FA; //offset czestotliwosci double FA; // offset czestotliwosci
bool bLoopPlay; //czy zapętlony dźwięk jest odtwarzany bool bLoopPlay; // czy zapętlony dźwięk jest odtwarzany
__fastcall TRealSound(); __fastcall TRealSound();
__fastcall ~TRealSound(); __fastcall ~TRealSound();
void __fastcall Free(); void __fastcall Free();
void __fastcall Init(char *SoundName,double SoundAttenuation,double X,double Y,double Z,bool Dynamic,bool freqmod=false,double rmin=0.0); void __fastcall Init(char *SoundName, double SoundAttenuation, double X, double Y, double Z,
bool Dynamic, bool freqmod = false, double rmin = 0.0);
double __fastcall ListenerDistance(vector3 ListenerPosition); double __fastcall ListenerDistance(vector3 ListenerPosition);
void __fastcall Play(double Volume,int Looping,bool ListenerInside,vector3 NewPosition); void __fastcall Play(double Volume, int Looping, bool ListenerInside, vector3 NewPosition);
void __fastcall Start(); void __fastcall Start();
void __fastcall Stop(); void __fastcall Stop();
void __fastcall AdjFreq(double Freq,double dt); void __fastcall AdjFreq(double Freq, double dt);
void __fastcall SetPan(int Pan); void __fastcall SetPan(int Pan);
double GetWaveTime(); //McZapkie TODO: dorobic dla roznych bps double GetWaveTime(); // McZapkie TODO: dorobic dla roznych bps
int GetStatus(); int GetStatus();
void __fastcall ResetPosition(); void __fastcall ResetPosition();
//void __fastcall FreqReset(float f=22050.0) {fFrequency=f;}; // void __fastcall FreqReset(float f=22050.0) {fFrequency=f;};
}; };
class TTextSound : public TRealSound class TTextSound : public TRealSound
{//dźwięk ze stenogramem { // dźwięk ze stenogramem
AnsiString asText; AnsiString asText;
float fTime; //czas trwania float fTime; // czas trwania
public: public:
void __fastcall Init(char *SoundName,double SoundAttenuation,double X,double Y,double Z,bool Dynamic,bool freqmod=false,double rmin=0.0); void __fastcall Init(char *SoundName, double SoundAttenuation, double X, double Y, double Z,
void __fastcall Play(double Volume,int Looping,bool ListenerInside,vector3 NewPosition); bool Dynamic, bool freqmod = false, double rmin = 0.0);
void __fastcall Play(double Volume, int Looping, bool ListenerInside, vector3 NewPosition);
}; };
class TSynthSound class TSynthSound
{//klasa generująca sygnał odjazdu (Rp12, Rp13), potem rozbudować o pracę manewrowego... { // klasa generująca sygnał odjazdu (Rp12, Rp13), potem rozbudować o pracę manewrowego...
int iIndex[44]; //indeksy początkowe, gdy mamy kilka wariantów dźwięków składowych int iIndex[44]; // indeksy początkowe, gdy mamy kilka wariantów dźwięków składowych
//0..9 - cyfry 0..9 // 0..9 - cyfry 0..9
//10..19 - liczby 10..19 // 10..19 - liczby 10..19
//21..29 - dziesiątki (*21==*10?) // 21..29 - dziesiątki (*21==*10?)
//31..39 - setki 100,200,...,800,900 // 31..39 - setki 100,200,...,800,900
//40 - "tysiąc" // 40 - "tysiąc"
//41 - "tysiące" // 41 - "tysiące"
//42 - indeksy początkowe dla "odjazd" // 42 - indeksy początkowe dla "odjazd"
//43 - indeksy początkowe dla "gotów" // 43 - indeksy początkowe dla "gotów"
PSound *sSound; //posortowana tablica dźwięków, rozmiar zależny od liczby znalezionych plików PSound *sSound; // posortowana tablica dźwięków, rozmiar zależny od liczby znalezionych plików
//a może zamiast wielu plików/dźwięków zrobić jeden połączony plik i posługiwać się czasem od..do? // a może zamiast wielu plików/dźwięków zrobić jeden połączony plik i posługiwać się czasem
// od..do?
}; };
//--------------------------------------------------------------------------- //---------------------------------------------------------------------------
#endif #endif

34
ResourceManager.cpp
View File

@@ -8,16 +8,13 @@ double ResourceManager::_expiry = 5.0f;
double ResourceManager::_lastUpdate = 0.0f; double ResourceManager::_lastUpdate = 0.0f;
double ResourceManager::_lastReport = 0.0f; double ResourceManager::_lastReport = 0.0f;
void ResourceManager::Register(Resource* resource) void ResourceManager::Register(Resource *resource) { _resources.push_back(resource); };
{
_resources.push_back(resource);
};
void ResourceManager::Unregister(Resource* resource) void ResourceManager::Unregister(Resource *resource)
{ {
Resources::iterator iter = std::find(_resources.begin(), _resources.end(), resource); Resources::iterator iter = std::find(_resources.begin(), _resources.end(), resource);
if(iter != _resources.end()) if (iter != _resources.end())
_resources.erase(iter); _resources.erase(iter);
resource->Release(); resource->Release();
@@ -25,35 +22,33 @@ void ResourceManager::Unregister(Resource* resource)
class ResourceExpired class ResourceExpired
{ {
public: public:
ResourceExpired(double time): _time(time) { }; ResourceExpired(double time) : _time(time){};
bool operator()(Resource* resource) bool operator()(Resource *resource) { return (resource->GetLastUsage() < _time); }
{
return (resource->GetLastUsage() < _time);
}
private: private:
double _time; double _time;
}; };
void ResourceManager::Sweep(double currentTime) void ResourceManager::Sweep(double currentTime)
{ {
if(currentTime - _lastUpdate < _expiry) if (currentTime - _lastUpdate < _expiry)
return; return;
Resources::iterator begin = std::remove_if(_resources.begin(), _resources.end(), ResourceExpired(currentTime - _expiry)); Resources::iterator begin = std::remove_if(_resources.begin(), _resources.end(),
ResourceExpired(currentTime - _expiry));
#ifdef RESOURCE_REPORTING #ifdef RESOURCE_REPORTING
if(begin != _resources.end()) if (begin != _resources.end())
WriteLog("Releasing resources"); WriteLog("Releasing resources");
#endif #endif
for(Resources::iterator iter = begin; iter != _resources.end(); iter++) for (Resources::iterator iter = begin; iter != _resources.end(); iter++)
(*iter)->Release(); (*iter)->Release();
#ifdef RESOURCE_REPORTING #ifdef RESOURCE_REPORTING
if(begin != _resources.end()) if (begin != _resources.end())
{ {
std::ostringstream msg; std::ostringstream msg;
msg << "Released " << (_resources.end() - begin) << " resources"; msg << "Released " << (_resources.end() - begin) << " resources";
@@ -64,7 +59,7 @@ void ResourceManager::Sweep(double currentTime)
_resources.erase(begin, _resources.end()); _resources.erase(begin, _resources.end());
#ifdef RESOURCE_REPORTING #ifdef RESOURCE_REPORTING
if(currentTime - _lastReport > 30.0f) if (currentTime - _lastReport > 30.0f)
{ {
std::ostringstream msg; std::ostringstream msg;
msg << "Resources count: " << _resources.size(); msg << "Resources count: " << _resources.size();
@@ -74,5 +69,4 @@ void ResourceManager::Sweep(double currentTime)
#endif #endif
_lastUpdate = currentTime; _lastUpdate = currentTime;
}; };

18
ResourceManager.h
View File

@@ -9,37 +9,35 @@
class Resource class Resource
{ {
public: public:
virtual void Release() = 0; virtual void Release() = 0;
double GetLastUsage() const { return _lastUsage; } double GetLastUsage() const { return _lastUsage; }
protected: protected:
void SetLastUsage(double lastUsage) { _lastUsage = lastUsage; } void SetLastUsage(double lastUsage) { _lastUsage = lastUsage; }
private: private:
double _lastUsage; double _lastUsage;
}; };
class ResourceManager class ResourceManager
{ {
public: public:
static void Register(Resource* resource); static void Register(Resource *resource);
static void Unregister(Resource* resource); static void Unregister(Resource *resource);
static void Sweep(double currentTime); static void Sweep(double currentTime);
static void SetExpiry(double expiry) { _expiry = expiry; } static void SetExpiry(double expiry) { _expiry = expiry; }
private: private:
typedef std::vector<Resource*> Resources; typedef std::vector<Resource *> Resources;
static double _expiry; static double _expiry;
static double _lastUpdate; static double _lastUpdate;
static double _lastReport; static double _lastReport;
static Resources _resources; static Resources _resources;
}; };
#endif #endif

1304
Segment.cpp
View File

File diff suppressed because it is too large Load Diff

145
Segment.h
View File

@@ -9,95 +9,120 @@
using namespace Math3D; using namespace Math3D;
//110405 Ra: klasa punktów przekroju z normalnymi // 110405 Ra: klasa punktów przekroju z normalnymi
class vector6 : public vector3 class vector6 : public vector3
{//punkt przekroju wraz z wektorem normalnym { // punkt przekroju wraz z wektorem normalnym
public: public:
vector3 n; vector3 n;
__fastcall vector6() __fastcall vector6()
{x=y=z=n.x=n.z=0.0; n.y=1.0;}; {
__fastcall vector6(double a,double b,double c,double d,double e,double f) x = y = z = n.x = n.z = 0.0;
n.y = 1.0;
};
__fastcall vector6(double a, double b, double c, double d, double e, double f)
//{x=a; y=b; z=c; n.x=d; n.y=e; n.z=f;}; //{x=a; y=b; z=c; n.x=d; n.y=e; n.z=f;};
{x=a; y=b; z=c; n.x=0.0; n.y=1.0; n.z=0.0;}; //Ra: bo na razie s¹ z tym problemy {
__fastcall vector6(double a,double b,double c) x = a;
{x=a; y=b; z=c; n.x=0.0; n.y=1.0; n.z=0.0;}; y = b;
z = c;
n.x = 0.0;
n.y = 1.0;
n.z = 0.0;
}; // Ra: bo na razie s¹ z tym problemy
__fastcall vector6(double a, double b, double c)
{
x = a;
y = b;
z = c;
n.x = 0.0;
n.y = 1.0;
n.z = 0.0;
};
}; };
class TSegment class TSegment
{//aproksymacja toru (zwrotnica ma dwa takie, jeden z nich jest aktywny) { // aproksymacja toru (zwrotnica ma dwa takie, jeden z nich jest aktywny)
private: private:
vector3 Point1,CPointOut,CPointIn,Point2; vector3 Point1, CPointOut, CPointIn, Point2;
double fRoll1,fRoll2; //przechy³ka na koñcach double fRoll1, fRoll2; // przechy³ka na koñcach
double fLength; //d³ugoœæ policzona double fLength; // d³ugoœæ policzona
double *fTsBuffer; //wartoœci parametru krzywej dla równych odcinków double *fTsBuffer; // wartoœci parametru krzywej dla równych odcinków
double fStep; double fStep;
int iSegCount; //iloœæ odcinków do rysowania krzywej int iSegCount; // iloœæ odcinków do rysowania krzywej
double fDirection; //Ra: k¹t prostego w planie; dla ³uku k¹t od Point1 double fDirection; // Ra: k¹t prostego w planie; dla ³uku k¹t od Point1
double fStoop; //Ra: k¹t wzniesienia; dla ³uku od Point1 double fStoop; // Ra: k¹t wzniesienia; dla ³uku od Point1
vector3 vA,vB,vC; //wspó³czynniki wielomianów trzeciego stopnia vD==Point1 vector3 vA, vB, vC; // wspó³czynniki wielomianów trzeciego stopnia vD==Point1
//TSegment *pPrev; //odcinek od strony punktu 1 - w segmencie, ¿eby nie skakaæ na zwrotnicach // TSegment *pPrev; //odcinek od strony punktu 1 - w segmencie, ¿eby nie skakaæ na zwrotnicach
//TSegment *pNext; //odcinek od strony punktu 2 // TSegment *pNext; //odcinek od strony punktu 2
TTrack *pOwner; //wskaŸnik na w³aœciciela TTrack *pOwner; // wskaŸnik na w³aœciciela
double fAngle[2]; //k¹ty zakoñczenia drogi na przejazdach double fAngle[2]; // k¹ty zakoñczenia drogi na przejazdach
vector3 __fastcall GetFirstDerivative(double fTime); vector3 __fastcall GetFirstDerivative(double fTime);
double __fastcall RombergIntegral(double fA, double fB); double __fastcall RombergIntegral(double fA, double fB);
double __fastcall GetTFromS(double s); double __fastcall GetTFromS(double s);
vector3 __fastcall RaInterpolate(double t); vector3 __fastcall RaInterpolate(double t);
vector3 __fastcall RaInterpolate0(double t); vector3 __fastcall RaInterpolate0(double t);
//TSegment *segNeightbour[2]; //s¹siednie odcinki - musi byæ przeniesione z Track // TSegment *segNeightbour[2]; //s¹siednie odcinki - musi byæ przeniesione z Track
//int iNeightbour[2]; //do którego koñca doczepiony // int iNeightbour[2]; //do którego koñca doczepiony
public: public:
bool bCurve; bool bCurve;
//int iShape; //Ra: flagi kszta³tu dadz¹ wiêcej mo¿liwoœci optymalizacji (0-Bezier,1-prosty,2/3-³uk w lewo/prawo,6/7-przejœciowa w lewo/prawo) // int iShape; //Ra: flagi kszta³tu dadz¹ wiêcej mo¿liwoœci optymalizacji
// (0-Bezier,1-prosty,2/3-³uk w lewo/prawo,6/7-przejœciowa w lewo/prawo)
__fastcall TSegment(TTrack *owner); __fastcall TSegment(TTrack *owner);
__fastcall ~TSegment(); __fastcall ~TSegment();
bool __fastcall Init(vector3 NewPoint1,vector3 NewPoint2,double fNewStep, bool __fastcall Init(vector3 NewPoint1, vector3 NewPoint2, double fNewStep,
double fNewRoll1=0,double fNewRoll2=0); double fNewRoll1 = 0, double fNewRoll2 = 0);
bool __fastcall Init(vector3 &NewPoint1,vector3 NewCPointOut, bool __fastcall Init(vector3 &NewPoint1, vector3 NewCPointOut, vector3 NewCPointIn,
vector3 NewCPointIn,vector3 &NewPoint2,double fNewStep, vector3 &NewPoint2, double fNewStep, double fNewRoll1 = 0,
double fNewRoll1=0,double fNewRoll2=0,bool bIsCurve=true); double fNewRoll2 = 0, bool bIsCurve = true);
inline double __fastcall ComputeLength(); //McZapkie-150503 inline double __fastcall ComputeLength(); // McZapkie-150503
inline vector3 __fastcall GetDirection1() {return bCurve?CPointOut-Point1:CPointOut;}; inline vector3 __fastcall GetDirection1() { return bCurve ? CPointOut - Point1 : CPointOut; };
inline vector3 __fastcall GetDirection2() {return bCurve?CPointIn-Point2:CPointIn;}; inline vector3 __fastcall GetDirection2() { return bCurve ? CPointIn - Point2 : CPointIn; };
vector3 __fastcall GetDirection(double fDistance); vector3 __fastcall GetDirection(double fDistance);
vector3 __fastcall GetDirection() {return CPointOut;}; vector3 __fastcall GetDirection() { return CPointOut; };
vector3 __fastcall FastGetDirection(double fDistance,double fOffset); vector3 __fastcall FastGetDirection(double fDistance, double fOffset);
vector3 __fastcall GetPoint(double fDistance); vector3 __fastcall GetPoint(double fDistance);
void __fastcall RaPositionGet(double fDistance,vector3 &p,vector3 &a); void __fastcall RaPositionGet(double fDistance, vector3 &p, vector3 &a);
vector3 __fastcall FastGetPoint(double t); vector3 __fastcall FastGetPoint(double t);
inline vector3 __fastcall FastGetPoint_0() {return Point1;}; inline vector3 __fastcall FastGetPoint_0() { return Point1; };
inline vector3 __fastcall FastGetPoint_1() {return Point2;}; inline vector3 __fastcall FastGetPoint_1() { return Point2; };
inline double __fastcall GetRoll(double s) inline double __fastcall GetRoll(double s)
{ {
s/=fLength; s /= fLength;
return ((1.0-s)*fRoll1+s*fRoll2); return ((1.0 - s) * fRoll1 + s * fRoll2);
} }
void __fastcall GetRolls(double &r1,double &r2) void __fastcall GetRolls(double &r1, double &r2)
{//pobranie przechy³ek (do generowania trójk¹tów) { // pobranie przechy³ek (do generowania trójk¹tów)
r1=fRoll1; r2=fRoll2; r1 = fRoll1;
r2 = fRoll2;
} }
void __fastcall RenderLoft(const vector6 *ShapePoints,int iNumShapePoints, void __fastcall RenderLoft(const vector6 *ShapePoints, int iNumShapePoints,
double fTextureLength,int iSkip=0,int iQualityFactor=1,vector3 **p=NULL,bool bRender=true); double fTextureLength, int iSkip = 0, int iQualityFactor = 1,
void __fastcall RenderSwitchRail(const vector6 *ShapePoints1,const vector6 *ShapePoints2, vector3 **p = NULL, bool bRender = true);
int iNumShapePoints,double fTextureLength,int iSkip=0,double fOffsetX=0.0f); void __fastcall RenderSwitchRail(const vector6 *ShapePoints1, const vector6 *ShapePoints2,
int iNumShapePoints, double fTextureLength, int iSkip = 0,
double fOffsetX = 0.0f);
void __fastcall Render(); void __fastcall Render();
inline double __fastcall GetLength() {return fLength;}; inline double __fastcall GetLength() { return fLength; };
void __fastcall MoveMe(vector3 pPosition) void __fastcall MoveMe(vector3 pPosition)
{Point1+=pPosition; {
Point2+=pPosition; Point1 += pPosition;
Point2 += pPosition;
if (bCurve) if (bCurve)
{CPointIn+=pPosition; {
CPointOut+=pPosition; CPointIn += pPosition;
CPointOut += pPosition;
} }
} }
int __fastcall RaSegCount() {return fTsBuffer?iSegCount:1;}; int __fastcall RaSegCount() { return fTsBuffer ? iSegCount : 1; };
void __fastcall RaRenderLoft(CVertNormTex* &Vert,const vector6 *ShapePoints,int iNumShapePoints, void __fastcall RaRenderLoft(CVertNormTex *&Vert, const vector6 *ShapePoints,
double fTextureLength,int iSkip=0,int iEnd=0,double fOffsetX=0.0); int iNumShapePoints, double fTextureLength, int iSkip = 0,
void __fastcall RaAnimate(CVertNormTex* &Vert,const vector6 *ShapePoints,int iNumShapePoints, int iEnd = 0, double fOffsetX = 0.0);
double fTextureLength,int iSkip=0,int iEnd=0,double fOffsetX=0.0); void __fastcall RaAnimate(CVertNormTex *&Vert, const vector6 *ShapePoints, int iNumShapePoints,
void __fastcall AngleSet(int i,double a) {fAngle[i]=a;}; double fTextureLength, int iSkip = 0, int iEnd = 0,
void __fastcall Rollment(double w1,double w2); //poprawianie przechy³ki double fOffsetX = 0.0);
void __fastcall AngleSet(int i, double a) { fAngle[i] = a; };
void __fastcall Rollment(double w1, double w2); // poprawianie przechy³ki
}; };
//--------------------------------------------------------------------------- //---------------------------------------------------------------------------

279
Sound.cpp
View File

@@ -9,68 +9,74 @@
#include "Usefull.h" #include "Usefull.h"
#include "Globals.h" #include "Globals.h"
//#define SAFE_DELETE(p) { if(p) { delete (p); (p)=NULL; } } //#define SAFE_DELETE(p) { if(p) { delete (p); (p)=NULL; } }
#define SAFE_RELEASE(p) { if(p) { (p)->Release(); (p)=NULL; } } #define SAFE_RELEASE(p) \
{ \
if (p) \
{ \
(p)->Release(); \
(p) = NULL; \
} \
}
char Directory[]= "sounds\\"; char Directory[] = "sounds\\";
LPDIRECTSOUND TSoundsManager::pDS; LPDIRECTSOUND TSoundsManager::pDS;
LPDIRECTSOUNDNOTIFY TSoundsManager::pDSNotify; LPDIRECTSOUNDNOTIFY TSoundsManager::pDSNotify;
int TSoundsManager::Count= 0; int TSoundsManager::Count = 0;
TSoundContainer *TSoundsManager::First=NULL; TSoundContainer *TSoundsManager::First = NULL;
__fastcall TSoundContainer::TSoundContainer(LPDIRECTSOUND pDS, char *Directory, char *strFileName,
int NConcurrent)
{ // wczytanie pliku dŸwiêkowego
int hr = 111;
DSBuffer = NULL; // na pocz¹tek, gdyby uruchomiæ dŸwiêków siê nie uda³o
__fastcall TSoundContainer::TSoundContainer( LPDIRECTSOUND pDS, char *Directory, char *strFileName, int NConcurrent) Concurrent = NConcurrent;
{//wczytanie pliku dŸwiêkowego
int hr= 111;
DSBuffer=NULL; //na pocz¹tek, gdyby uruchomiæ dŸwiêków siê nie uda³o
Concurrent= NConcurrent; Oldest = 0;
// strcpy(Name, strFileName);
Oldest= 0; strcpy(Name, Directory);
// strcpy(Name, strFileName); strcat(Name, strFileName);
strcpy(Name,Directory);
strcat(Name,strFileName);
CWaveSoundRead* pWaveSoundRead;
CWaveSoundRead *pWaveSoundRead;
// Create a new wave file class // Create a new wave file class
pWaveSoundRead = new CWaveSoundRead(); pWaveSoundRead = new CWaveSoundRead();
// Load the wave file // Load the wave file
if (FAILED(pWaveSoundRead->Open(Name))) if (FAILED(pWaveSoundRead->Open(Name)))
if(FAILED(pWaveSoundRead->Open(strFileName))) if (FAILED(pWaveSoundRead->Open(strFileName)))
{ {
// SetFileUI( hDlg, TEXT("Bad wave file.") ); // SetFileUI( hDlg, TEXT("Bad wave file.") );
return; return;
ErrorLog("Missed sound: "+AnsiString(strFileName)); ErrorLog("Missed sound: " + AnsiString(strFileName));
} }
strcpy(Name,AnsiString(strFileName).LowerCase().c_str()); strcpy(Name, AnsiString(strFileName).LowerCase().c_str());
// Set up the direct sound buffer, and only request the flags needed // Set up the direct sound buffer, and only request the flags needed
// since each requires some overhead and limits if the buffer can // since each requires some overhead and limits if the buffer can
// be hardware accelerated // be hardware accelerated
DSBUFFERDESC dsbd; DSBUFFERDESC dsbd;
ZeroMemory( &dsbd, sizeof(DSBUFFERDESC) ); ZeroMemory(&dsbd, sizeof(DSBUFFERDESC));
dsbd.dwSize = sizeof(DSBUFFERDESC); dsbd.dwSize = sizeof(DSBUFFERDESC);
dsbd.dwFlags = DSBCAPS_STATIC | DSBCAPS_CTRLPAN | DSBCAPS_CTRLVOLUME | DSBCAPS_CTRLFREQUENCY; dsbd.dwFlags = DSBCAPS_STATIC | DSBCAPS_CTRLPAN | DSBCAPS_CTRLVOLUME | DSBCAPS_CTRLFREQUENCY;
if (!Global::bInactivePause) //jeœli prze³¹czony w t³o ma nadal dzia³aæ if (!Global::bInactivePause) // jeœli prze³¹czony w t³o ma nadal dzia³aæ
dsbd.dwFlags|=DSBCAPS_GLOBALFOCUS; //to dŸwiêki maj¹ byæ równie¿ s³yszalne dsbd.dwFlags |= DSBCAPS_GLOBALFOCUS; // to dŸwiêki maj¹ byæ równie¿ s³yszalne
dsbd.dwBufferBytes = pWaveSoundRead->m_ckIn.cksize; dsbd.dwBufferBytes = pWaveSoundRead->m_ckIn.cksize;
dsbd.lpwfxFormat = pWaveSoundRead->m_pwfx; dsbd.lpwfxFormat = pWaveSoundRead->m_pwfx;
fSamplingRate=pWaveSoundRead->m_pwfx->nSamplesPerSec; fSamplingRate = pWaveSoundRead->m_pwfx->nSamplesPerSec;
iBitsPerSample=pWaveSoundRead->m_pwfx->wBitsPerSample; iBitsPerSample = pWaveSoundRead->m_pwfx->wBitsPerSample;
// pDSBuffer= (LPDIRECTSOUNDBUFFER*) malloc(Concurrent*sizeof(LPDIRECTSOUNDBUFFER)); // pDSBuffer= (LPDIRECTSOUNDBUFFER*) malloc(Concurrent*sizeof(LPDIRECTSOUNDBUFFER));
// for (int i=0; i<Concurrent; i++) // for (int i=0; i<Concurrent; i++)
// pDSBuffer[i]= NULL; // pDSBuffer[i]= NULL;
// Create the static DirectSound buffer // Create the static DirectSound buffer
if( FAILED( hr = pDS->CreateSoundBuffer( &dsbd, &(DSBuffer), NULL ) ) ) if (FAILED(hr = pDS->CreateSoundBuffer(&dsbd, &(DSBuffer), NULL)))
//if (FAILED(pDS->CreateSoundBuffer(&dsbd,&(DSBuffer),NULL))) // if (FAILED(pDS->CreateSoundBuffer(&dsbd,&(DSBuffer),NULL)))
return; return;
// Remember how big the buffer is // Remember how big the buffer is
@@ -78,14 +84,12 @@ __fastcall TSoundContainer::TSoundContainer( LPDIRECTSOUND pDS, char *Directory,
dwBufferBytes = dsbd.dwBufferBytes; dwBufferBytes = dsbd.dwBufferBytes;
//---------------------------------------------------------- //----------------------------------------------------------
BYTE *pbWavData; // Pointer to actual wav data
BYTE* pbWavData; // Pointer to actual wav data
UINT cbWavSize; // Size of data UINT cbWavSize; // Size of data
VOID* pbData = NULL; VOID *pbData = NULL;
VOID* pbData2 = NULL; VOID *pbData2 = NULL;
DWORD dwLength; DWORD dwLength;
DWORD dwLength2; DWORD dwLength2;
@@ -93,30 +97,27 @@ __fastcall TSoundContainer::TSoundContainer( LPDIRECTSOUND pDS, char *Directory,
INT nWaveFileSize = pWaveSoundRead->m_ckIn.cksize; INT nWaveFileSize = pWaveSoundRead->m_ckIn.cksize;
// Allocate that buffer. // Allocate that buffer.
pbWavData = new BYTE[ nWaveFileSize ]; pbWavData = new BYTE[nWaveFileSize];
if( NULL == pbWavData ) if (NULL == pbWavData)
return ;//E_OUTOFMEMORY; return; // E_OUTOFMEMORY;
//if (FAILED(hr=pWaveSoundRead->Read( nWaveFileSize,pbWavData,&cbWavSize))) // if (FAILED(hr=pWaveSoundRead->Read( nWaveFileSize,pbWavData,&cbWavSize)))
if( FAILED( hr = pWaveSoundRead->Read( nWaveFileSize, if (FAILED(hr = pWaveSoundRead->Read(nWaveFileSize, pbWavData, &cbWavSize)))
pbWavData, return;
&cbWavSize ) ) )
return ;
// Reset the file to the beginning // Reset the file to the beginning
pWaveSoundRead->Reset(); pWaveSoundRead->Reset();
// Lock the buffer down // Lock the buffer down
//if (FAILED(hr=DSBuffer->Lock(0,dwBufferBytes,&pbData,&dwLength,&pbData2,&dwLength2,0))) // if (FAILED(hr=DSBuffer->Lock(0,dwBufferBytes,&pbData,&dwLength,&pbData2,&dwLength2,0)))
if( FAILED( hr = DSBuffer->Lock( 0, dwBufferBytes, &pbData, &dwLength, if (FAILED(hr = DSBuffer->Lock(0, dwBufferBytes, &pbData, &dwLength, &pbData2, &dwLength2, 0L)))
&pbData2, &dwLength2, 0L ) ) ) return;
return ;
// Copy the memory to it. // Copy the memory to it.
memcpy( pbData, pbWavData, dwBufferBytes ); memcpy(pbData, pbWavData, dwBufferBytes);
// Unlock the buffer, we don't need it anymore. // Unlock the buffer, we don't need it anymore.
DSBuffer->Unlock( pbData, dwBufferBytes, NULL, 0 ); DSBuffer->Unlock(pbData, dwBufferBytes, NULL, 0);
pbData = NULL; pbData = NULL;
// We dont need the wav file data buffer anymore, so delete it // We dont need the wav file data buffer anymore, so delete it
@@ -126,7 +127,7 @@ __fastcall TSoundContainer::TSoundContainer( LPDIRECTSOUND pDS, char *Directory,
DSBuffers.push(DSBuffer); DSBuffers.push(DSBuffer);
/* /*
for (int i=1; i<Concurrent; i++) for (int i=1; i<Concurrent; i++)
{ {
if( FAILED( hr= pDS->DuplicateSoundBuffer(pDSBuffer[0],&(pDSBuffer[i])))) if( FAILED( hr= pDS->DuplicateSoundBuffer(pDSBuffer[0],&(pDSBuffer[i]))))
@@ -137,88 +138,83 @@ __fastcall TSoundContainer::TSoundContainer( LPDIRECTSOUND pDS, char *Directory,
};*/ };*/
}; };
__fastcall TSoundContainer::~TSoundContainer() __fastcall TSoundContainer::~TSoundContainer()
{ {
// for (int i=Concurrent-1; i>=0; i--) // for (int i=Concurrent-1; i>=0; i--)
// SAFE_RELEASE( pDSBuffer[i] ); // SAFE_RELEASE( pDSBuffer[i] );
// free(pDSBuffer); // free(pDSBuffer);
while (!DSBuffers.empty()) while (!DSBuffers.empty())
{ {
SAFE_RELEASE(DSBuffers.top()); SAFE_RELEASE(DSBuffers.top());
DSBuffers.pop(); DSBuffers.pop();
} }
SafeDelete( Next ); SafeDelete(Next);
}; };
LPDIRECTSOUNDBUFFER __fastcall TSoundContainer::GetUnique(LPDIRECTSOUND pDS) LPDIRECTSOUNDBUFFER __fastcall TSoundContainer::GetUnique(LPDIRECTSOUND pDS)
{ {
if (!DSBuffer) return NULL; if (!DSBuffer)
//jeœli siê dobrze zainicjowa³o return NULL;
// jeœli siê dobrze zainicjowa³o
LPDIRECTSOUNDBUFFER buff; LPDIRECTSOUNDBUFFER buff;
pDS->DuplicateSoundBuffer(DSBuffer,&buff); pDS->DuplicateSoundBuffer(DSBuffer, &buff);
if (buff) DSBuffers.push(buff); if (buff)
DSBuffers.push(buff);
return DSBuffers.top(); return DSBuffers.top();
}; };
__fastcall TSoundsManager::~TSoundsManager() { Free(); };
__fastcall TSoundsManager::~TSoundsManager()
{
Free();
};
void __fastcall TSoundsManager::Free() void __fastcall TSoundsManager::Free()
{ {
SafeDelete( First ); SafeDelete(First);
SAFE_RELEASE( pDS ); SAFE_RELEASE(pDS);
}; };
TSoundContainer *__fastcall TSoundsManager::LoadFromFile(char *Dir, char *Name, int Concurrent)
TSoundContainer* __fastcall TSoundsManager::LoadFromFile(char *Dir,char *Name,int Concurrent)
{ {
TSoundContainer *Tmp=First; TSoundContainer *Tmp = First;
First=new TSoundContainer(pDS,Dir,Name,Concurrent); First = new TSoundContainer(pDS, Dir, Name, Concurrent);
First->Next=Tmp; First->Next = Tmp;
Count++; Count++;
return First; //albo NULL, jak nie wyjdzie (na razie zawsze wychodzi) return First; // albo NULL, jak nie wyjdzie (na razie zawsze wychodzi)
}; };
void __fastcall TSoundsManager::LoadSounds(char *Directory) void __fastcall TSoundsManager::LoadSounds(char *Directory)
{//wczytanie wszystkich plików z katalogu - ma³o elastyczne { // wczytanie wszystkich plików z katalogu - ma³o elastyczne
WIN32_FIND_DATA FindFileData; WIN32_FIND_DATA FindFileData;
HANDLE handle=FindFirstFile("sounds\\*.wav",&FindFileData); HANDLE handle = FindFirstFile("sounds\\*.wav", &FindFileData);
if (handle!=INVALID_HANDLE_VALUE) if (handle != INVALID_HANDLE_VALUE)
do do
{ {
LoadFromFile(Directory,FindFileData.cFileName,1); LoadFromFile(Directory, FindFileData.cFileName, 1);
} while (FindNextFile(handle,&FindFileData)); } while (FindNextFile(handle, &FindFileData));
FindClose(handle); FindClose(handle);
}; };
LPDIRECTSOUNDBUFFER __fastcall TSoundsManager::GetFromName(char *Name,bool Dynamic,float *fSamplingRate) LPDIRECTSOUNDBUFFER __fastcall TSoundsManager::GetFromName(char *Name, bool Dynamic,
{//wyszukanie dŸwiêku w pamiêci albo wczytanie z pliku float *fSamplingRate)
{ // wyszukanie dŸwiêku w pamiêci albo wczytanie z pliku
AnsiString file; AnsiString file;
if (Dynamic) if (Dynamic)
{//próba wczytania z katalogu pojazdu { // próba wczytania z katalogu pojazdu
file=Global::asCurrentDynamicPath+AnsiString(Name); file = Global::asCurrentDynamicPath + AnsiString(Name);
if (FileExists(file)) if (FileExists(file))
Name=file.c_str(); //nowa nazwa Name = file.c_str(); // nowa nazwa
else else
Dynamic=false; //wczytanie z "sounds/" Dynamic = false; // wczytanie z "sounds/"
} }
TSoundContainer *Next=First; TSoundContainer *Next = First;
DWORD dwStatus; DWORD dwStatus;
for (int i=0;i<Count;i++) for (int i = 0; i < Count; i++)
{ {
if (strcmp(Name,Next->Name)==0) if (strcmp(Name, Next->Name) == 0)
{ {
if (fSamplingRate) if (fSamplingRate)
*fSamplingRate=Next->fSamplingRate; //czêstotliwoœæ *fSamplingRate = Next->fSamplingRate; // czêstotliwoœæ
return (Next->GetUnique(pDS)); return (Next->GetUnique(pDS));
// DSBuffers. // DSBuffers.
/* /*
Next->pDSBuffer[Next->Oldest]->Stop(); Next->pDSBuffer[Next->Oldest]->Stop();
Next->pDSBuffer[Next->Oldest]->SetCurrentPosition(0); Next->pDSBuffer[Next->Oldest]->SetCurrentPosition(0);
@@ -233,7 +229,7 @@ LPDIRECTSOUNDBUFFER __fastcall TSoundsManager::GetFromName(char *Name,bool Dynam
return (Next->pDSBuffer[Next->Concurrent-1]); return (Next->pDSBuffer[Next->Concurrent-1]);
}; };
/* for (int j=0; j<Next->Concurrent; j++) /* for (int j=0; j<Next->Concurrent; j++)
{ {
Next->pDSBuffer[j]->GetStatus(&dwStatus); Next->pDSBuffer[j]->GetStatus(&dwStatus);
@@ -242,38 +238,38 @@ LPDIRECTSOUNDBUFFER __fastcall TSoundsManager::GetFromName(char *Name,bool Dynam
} */ } */
} }
else else
Next=Next->Next; Next = Next->Next;
}; };
if (Dynamic) //wczytanie z katalogu pojazdu if (Dynamic) // wczytanie z katalogu pojazdu
Next=LoadFromFile("",Name,1); Next = LoadFromFile("", Name, 1);
else else
Next=LoadFromFile(Directory,Name,1); Next = LoadFromFile(Directory, Name, 1);
if (Next) if (Next)
{// { //
if (fSamplingRate) if (fSamplingRate)
*fSamplingRate=Next->fSamplingRate; //czêstotliwoœæ *fSamplingRate = Next->fSamplingRate; // czêstotliwoœæ
return Next->GetUnique(pDS); return Next->GetUnique(pDS);
} }
ErrorLog("Missed sound: "+AnsiString(Name)); ErrorLog("Missed sound: " + AnsiString(Name));
return (NULL); return (NULL);
}; };
void __fastcall TSoundsManager::RestoreAll() void __fastcall TSoundsManager::RestoreAll()
{ {
TSoundContainer *Next= First; TSoundContainer *Next = First;
HRESULT hr; HRESULT hr;
DWORD dwStatus; DWORD dwStatus;
for (int i=0; i<Count; i++) for (int i = 0; i < Count; i++)
{ {
if (FAILED(hr = Next->DSBuffer->GetStatus(&dwStatus)))
if( FAILED( hr = Next->DSBuffer->GetStatus( &dwStatus ) ) ); ;
// return hr; // return hr;
if( dwStatus & DSBSTATUS_BUFFERLOST ) if (dwStatus & DSBSTATUS_BUFFERLOST)
{ {
// Since the app could have just been activated, then // Since the app could have just been activated, then
// DirectSound may not be giving us control yet, so // DirectSound may not be giving us control yet, so
@@ -282,82 +278,79 @@ void __fastcall TSoundsManager::RestoreAll()
do do
{ {
hr = Next->DSBuffer->Restore(); hr = Next->DSBuffer->Restore();
if( hr == DSERR_BUFFERLOST ) if (hr == DSERR_BUFFERLOST)
Sleep( 10 ); Sleep(10);
} } while ((hr = Next->DSBuffer->Restore()) != NULL);
while ((hr=Next->DSBuffer->Restore())!=NULL);
// char *Name= Next->Name; // char *Name= Next->Name;
// int cc= Next->Concurrent; // int cc= Next->Concurrent;
// delete Next; // delete Next;
// Next= new TSoundContainer(pDS, Directory, Name, cc); // Next= new TSoundContainer(pDS, Directory, Name, cc);
// if( FAILED( hr = FillBuffer() ) ); // if( FAILED( hr = FillBuffer() ) );
// return hr; // return hr;
}; };
Next= Next->Next; Next = Next->Next;
}; };
}; };
// void __fastcall TSoundsManager::Init(char *Name, int Concurrent)
//void __fastcall TSoundsManager::Init(char *Name, int Concurrent)
//__fastcall TSoundsManager::TSoundsManager(HWND hWnd) //__fastcall TSoundsManager::TSoundsManager(HWND hWnd)
//void __fastcall TSoundsManager::Init(HWND hWnd, char *NDirectory) // void __fastcall TSoundsManager::Init(HWND hWnd, char *NDirectory)
void __fastcall TSoundsManager::Init(HWND hWnd) void __fastcall TSoundsManager::Init(HWND hWnd)
{ {
First= NULL; First = NULL;
Count= 0; Count = 0;
pDS= NULL; pDS = NULL;
pDSNotify= NULL; pDSNotify = NULL;
HRESULT hr; //=222; HRESULT hr; //=222;
LPDIRECTSOUNDBUFFER pDSBPrimary = NULL; LPDIRECTSOUNDBUFFER pDSBPrimary = NULL;
// strcpy(Directory, NDirectory); // strcpy(Directory, NDirectory);
// Create IDirectSound using the primary sound device // Create IDirectSound using the primary sound device
hr = DirectSoundCreate( NULL, &pDS, NULL ); hr = DirectSoundCreate(NULL, &pDS, NULL);
if( hr!=DS_OK ) if (hr != DS_OK)
{ {
if (hr==DSERR_ALLOCATED) if (hr == DSERR_ALLOCATED)
return; return;
if (hr==DSERR_INVALIDPARAM) if (hr == DSERR_INVALIDPARAM)
return; return;
if (hr==DSERR_NOAGGREGATION) if (hr == DSERR_NOAGGREGATION)
return; return;
if (hr==DSERR_NODRIVER) if (hr == DSERR_NODRIVER)
return; return;
if (hr==DSERR_OUTOFMEMORY) if (hr == DSERR_OUTOFMEMORY)
return; return;
// hr=0; // hr=0;
}; };
// return ; // return ;
// Set coop level to DSSCL_PRIORITY // Set coop level to DSSCL_PRIORITY
// if( FAILED( hr = pDS->SetCooperativeLevel( hWnd, DSSCL_PRIORITY ) ) ); // if( FAILED( hr = pDS->SetCooperativeLevel( hWnd, DSSCL_PRIORITY ) ) );
// return ; // return ;
pDS->SetCooperativeLevel( hWnd, DSSCL_PRIORITY ); pDS->SetCooperativeLevel(hWnd, DSSCL_PRIORITY);
// Get the primary buffer // Get the primary buffer
DSBUFFERDESC dsbd; DSBUFFERDESC dsbd;
ZeroMemory( &dsbd, sizeof(DSBUFFERDESC) ); ZeroMemory(&dsbd, sizeof(DSBUFFERDESC));
dsbd.dwSize = sizeof(DSBUFFERDESC); dsbd.dwSize = sizeof(DSBUFFERDESC);
dsbd.dwFlags = DSBCAPS_PRIMARYBUFFER; dsbd.dwFlags = DSBCAPS_PRIMARYBUFFER;
if (!Global::bInactivePause) //jeœli prze³¹czony w t³o ma nadal dzia³aæ if (!Global::bInactivePause) // jeœli prze³¹czony w t³o ma nadal dzia³aæ
dsbd.dwFlags|=DSBCAPS_GLOBALFOCUS; //to dŸwiêki maj¹ byæ równie¿ s³yszalne dsbd.dwFlags |= DSBCAPS_GLOBALFOCUS; // to dŸwiêki maj¹ byæ równie¿ s³yszalne
dsbd.dwBufferBytes = 0; dsbd.dwBufferBytes = 0;
dsbd.lpwfxFormat = NULL; dsbd.lpwfxFormat = NULL;
if( FAILED( hr = pDS->CreateSoundBuffer( &dsbd, &pDSBPrimary, NULL ) ) ) if (FAILED(hr = pDS->CreateSoundBuffer(&dsbd, &pDSBPrimary, NULL)))
return ; return;
// Set primary buffer format to 22kHz and 16-bit output. // Set primary buffer format to 22kHz and 16-bit output.
WAVEFORMATEX wfx; WAVEFORMATEX wfx;
ZeroMemory( &wfx, sizeof(WAVEFORMATEX) ); ZeroMemory(&wfx, sizeof(WAVEFORMATEX));
wfx.wFormatTag = WAVE_FORMAT_PCM; wfx.wFormatTag = WAVE_FORMAT_PCM;
wfx.nChannels = 2; wfx.nChannels = 2;
wfx.nSamplesPerSec = 44100; wfx.nSamplesPerSec = 44100;
@@ -365,13 +358,11 @@ if (hr==DSERR_OUTOFMEMORY)
wfx.nBlockAlign = wfx.wBitsPerSample / 8 * wfx.nChannels; wfx.nBlockAlign = wfx.wBitsPerSample / 8 * wfx.nChannels;
wfx.nAvgBytesPerSec = wfx.nSamplesPerSec * wfx.nBlockAlign; wfx.nAvgBytesPerSec = wfx.nSamplesPerSec * wfx.nBlockAlign;
if( FAILED( hr = pDSBPrimary->SetFormat(&wfx) ) ) if (FAILED(hr = pDSBPrimary->SetFormat(&wfx)))
return ; return;
SAFE_RELEASE( pDSBPrimary );
SAFE_RELEASE(pDSBPrimary);
}; };
//--------------------------------------------------------------------------- //---------------------------------------------------------------------------
#pragma package(smart_init) #pragma package(smart_init)

30
Sound.h
View File

@@ -14,46 +14,48 @@
typedef LPDIRECTSOUNDBUFFER PSound; typedef LPDIRECTSOUNDBUFFER PSound;
//inline __fastcall Playing(PSound Sound) // inline __fastcall Playing(PSound Sound)
//{ //{
//} //}
class TSoundContainer class TSoundContainer
{ {
public: public:
int Concurrent; int Concurrent;
int Oldest; int Oldest;
char Name[80]; char Name[80];
LPDIRECTSOUNDBUFFER DSBuffer; LPDIRECTSOUNDBUFFER DSBuffer;
float fSamplingRate; //czêstotliwoœæ odczytana z pliku float fSamplingRate; // czêstotliwoœæ odczytana z pliku
int iBitsPerSample; //ile bitów na próbkê int iBitsPerSample; // ile bitów na próbkê
TSoundContainer *Next; TSoundContainer *Next;
std::stack< LPDIRECTSOUNDBUFFER > DSBuffers; std::stack<LPDIRECTSOUNDBUFFER> DSBuffers;
LPDIRECTSOUNDBUFFER __fastcall GetUnique(LPDIRECTSOUND pDS); LPDIRECTSOUNDBUFFER __fastcall GetUnique(LPDIRECTSOUND pDS);
__fastcall TSoundContainer(LPDIRECTSOUND pDS, char *Directory, char *strFileName, int NConcurrent); __fastcall TSoundContainer(LPDIRECTSOUND pDS, char *Directory, char *strFileName,
int NConcurrent);
__fastcall ~TSoundContainer(); __fastcall ~TSoundContainer();
}; };
class TSoundsManager class TSoundsManager
{ {
private: private:
static LPDIRECTSOUND pDS; static LPDIRECTSOUND pDS;
static LPDIRECTSOUNDNOTIFY pDSNotify; static LPDIRECTSOUNDNOTIFY pDSNotify;
// static char Directory[80]; // static char Directory[80];
static int Count; static int Count;
static TSoundContainer *First; static TSoundContainer *First;
static TSoundContainer* __fastcall LoadFromFile(char *Dir,char *Name,int Concurrent); static TSoundContainer *__fastcall LoadFromFile(char *Dir, char *Name, int Concurrent);
public:
// __fastcall TSoundsManager(HWND hWnd); public:
// static void __fastcall Init(HWND hWnd, char *NDirectory); // __fastcall TSoundsManager(HWND hWnd);
// static void __fastcall Init(HWND hWnd, char *NDirectory);
static void __fastcall Init(HWND hWnd); static void __fastcall Init(HWND hWnd);
__fastcall ~TSoundsManager(); __fastcall ~TSoundsManager();
static void __fastcall Free(); static void __fastcall Free();
static void __fastcall Init(char *Name, int Concurrent); static void __fastcall Init(char *Name, int Concurrent);
static void __fastcall LoadSounds(char *Directory); static void __fastcall LoadSounds(char *Directory);
static LPDIRECTSOUNDBUFFER __fastcall GetFromName(char *Name,bool Dynamic,float *fSamplingRate=NULL); static LPDIRECTSOUNDBUFFER __fastcall GetFromName(char *Name, bool Dynamic,
float *fSamplingRate = NULL);
static void __fastcall RestoreAll(); static void __fastcall RestoreAll();
}; };

364
Spline.cpp
View File

@@ -11,13 +11,12 @@
//#define asSplinesPatch AnsiString("Scenery\\") //#define asSplinesPatch AnsiString("Scenery\\")
bool __fastcall Connect(TKnot *k1, TKnot *k2) bool __fastcall Connect(TKnot *k1, TKnot *k2)
{ {
if (k1 && k2) if (k1 && k2)
{ {
k1->Next= k2; k1->Next = k2;
k2->Prev= k1; k2->Prev = k1;
k1->InitLength(); k1->InitLength();
return true; return true;
} }
@@ -28,140 +27,142 @@ bool __fastcall Connect(TKnot *k1, TKnot *k2)
#define Precision 10000 #define Precision 10000
float __fastcall CurveLength(vector3 p1, vector3 cp1, vector3 cp2, vector3 p2) float __fastcall CurveLength(vector3 p1, vector3 cp1, vector3 cp2, vector3 p2)
{ {
float t,l=0; float t, l = 0;
vector3 tmp,last= p1; vector3 tmp, last = p1;
for (int i=1; i<=Precision; i++) for (int i = 1; i <= Precision; i++)
{ {
t= float(i)/float(Precision); t = float(i) / float(Precision);
tmp= Interpolate(t,p1,cp1,cp2,p2); tmp = Interpolate(t, p1, cp1, cp2, p2);
t= vector3(tmp-last).Length(); t = vector3(tmp - last).Length();
l+= t; l += t;
last= tmp; last = tmp;
} }
return (l); return (l);
} }
__fastcall TKnot::TKnot() __fastcall TKnot::TKnot()
{ {
Next=Prev= NULL; Next = Prev = NULL;
Length= -1; Length = -1;
IsCurve= false; IsCurve = false;
fLengthIn=fLengthOut= 0; fLengthIn = fLengthOut = 0;
fRoll= 0; fRoll = 0;
bSwitchDirectionForward= false; bSwitchDirectionForward = false;
bSwitchDirectionBackward= false; bSwitchDirectionBackward = false;
} }
__fastcall TKnot::TKnot(int n) __fastcall TKnot::TKnot(int n)
{ {
bSwitchDirectionForward= false; bSwitchDirectionForward = false;
bSwitchDirectionBackward= false; bSwitchDirectionBackward = false;
Next=Prev= NULL; Next = Prev = NULL;
Length= -1; Length = -1;
IsCurve= false; IsCurve = false;
fLengthIn=fLengthOut= 0; fLengthIn = fLengthOut = 0;
if (n>0) if (n > 0)
{ {
Next= new TKnot(n-1); Next = new TKnot(n - 1);
Next->Prev= this; Next->Prev = this;
} }
} }
__fastcall TKnot::~TKnot() __fastcall TKnot::~TKnot() {}
{
}
vector3 __fastcall TKnot::GetDirection(float t) vector3 __fastcall TKnot::GetDirection(float t)
{ {
if (IsCurve) if (IsCurve)
{ {
vector3 v1= CPointOut-Point; vector3 v1 = CPointOut - Point;
vector3 v2= Next->Point-Next->CPointIn; //BUGBUG vector3 v2 = Next->Point - Next->CPointIn; // BUGBUG
return v1*(1-t)+v2*(t); return v1 * (1 - t) + v2 * (t);
} }
else else
return (Next->Point-Point);//Spline->Knots[KnotIndex].Point-Spline->Knots[KnotIndex].Point); return (Next->Point -
Point); // Spline->Knots[KnotIndex].Point-Spline->Knots[KnotIndex].Point);
} }
float __fastcall TKnot::GetTFromS(float s) float __fastcall TKnot::GetTFromS(float s)
{ {
// initial guess for Newton's method // initial guess for Newton's method
int it=0; int it = 0;
float fTolerance= 0.001; float fTolerance = 0.001;
float fRatio = s/RombergIntegral(0,1); float fRatio = s / RombergIntegral(0, 1);
float fOmRatio = 1.0 - fRatio; float fOmRatio = 1.0 - fRatio;
float fTime = fOmRatio*0 + fRatio*1; float fTime = fOmRatio * 0 + fRatio * 1;
// for (int i = 0; i < iIterations; i++) // for (int i = 0; i < iIterations; i++)
while (true) while (true)
{ {
it++; it++;
if (it>10) if (it > 10)
MessageBox(0,"Too many iterations","TSpline->GetTFromS",MB_OK); MessageBox(0, "Too many iterations", "TSpline->GetTFromS", MB_OK);
float fDifference = RombergIntegral(0,fTime) - s; float fDifference = RombergIntegral(0, fTime) - s;
if ( ( fDifference>0 ? fDifference : -fDifference) < fTolerance ) if ((fDifference > 0 ? fDifference : -fDifference) < fTolerance)
return fTime; return fTime;
fTime -= fDifference/GetFirstDerivative(fTime).Length(); fTime -= fDifference / GetFirstDerivative(fTime).Length();
} }
// Newton's method failed. If this happens, increase iterations or // Newton's method failed. If this happens, increase iterations or
// tolerance or integration accuracy. // tolerance or integration accuracy.
return -1; return -1;
} }
bool __fastcall TKnot::Init(TKnot *NNext, TKnot *NPrev) bool __fastcall TKnot::Init(TKnot *NNext, TKnot *NPrev)
{ {
if (NNext!=NULL) if (NNext != NULL)
{ {
Next= NNext; Next = NNext;
Next->Prev= this; Next->Prev = this;
} }
if (NPrev!=NULL) if (NPrev != NULL)
{ {
Prev= NPrev; Prev = NPrev;
Prev->Next= this; Prev->Next = this;
} }
} }
bool __fastcall TKnot::InitCPoints() bool __fastcall TKnot::InitCPoints()
{ {
if (Prev!=NULL) if (Prev != NULL)
if (Prev->IsCurve) if (Prev->IsCurve)
if (Next!=NULL) if (Next != NULL)
{ {
if (!IsCurve) if (!IsCurve)
{ {
CPointIn= Point-fLengthIn*Normalize(Next->Point-Point); CPointIn = Point - fLengthIn * Normalize(Next->Point - Point);
} }
else else
CPointIn= Point-fLengthIn*(Normalize(Normalize(Next->Point-Point)+Normalize(Point-Prev->Point))); CPointIn = Point -
fLengthIn * (Normalize(Normalize(Next->Point - Point) +
Normalize(Point - Prev->Point)));
} }
else else
CPointIn= Point-fLengthIn*Normalize(Point-Prev->Point); CPointIn = Point - fLengthIn * Normalize(Point - Prev->Point);
else else
CPointIn= Prev->Point; CPointIn = Prev->Point;
if (Next!=NULL) if (Next != NULL)
if (IsCurve) if (IsCurve)
if (Prev!=NULL) if (Prev != NULL)
{ {
if (!Prev->IsCurve) if (!Prev->IsCurve)
{ {
CPointOut= Point-fLengthOut*Normalize(Prev->Point-Point); CPointOut = Point - fLengthOut * Normalize(Prev->Point - Point);
} }
else else
CPointOut= Point-fLengthOut*(Normalize(Normalize(Prev->Point-Point)+Normalize(Point-Next->Point))); CPointOut = Point -
fLengthOut * (Normalize(Normalize(Prev->Point - Point) +
Normalize(Point - Next->Point)));
} }
else;
// CPointOut= -fLengthOut*Normalize(Next->Point-Point);
else else
CPointOut= Next->Point; ;
// CPointOut= -fLengthOut*Normalize(Next->Point-Point);
else else
CPointOut= Point-fLengthOut*Normalize(Prev->Point-Point); CPointOut = Next->Point;
else
CPointOut = Point - fLengthOut * Normalize(Prev->Point - Point);
} }
bool __fastcall TKnot::InitLength() bool __fastcall TKnot::InitLength()
@@ -169,15 +170,13 @@ bool __fastcall TKnot::InitLength()
if (IsCurve) if (IsCurve)
if (Next) if (Next)
Length= RombergIntegral(0,1); Length = RombergIntegral(0, 1);
else;
else else
if (Next) ;
Length= (Point-Next->Point).Length(); else if (Next)
Length = (Point - Next->Point).Length();
return true; return true;
} }
vector3 TKnot::GetFirstDerivative(float fTime) vector3 TKnot::GetFirstDerivative(float fTime)
@@ -185,15 +184,15 @@ vector3 TKnot::GetFirstDerivative(float fTime)
float fOmTime = 1.0 - fTime; float fOmTime = 1.0 - fTime;
float fPowTime = fTime; float fPowTime = fTime;
vector3 kResult = fOmTime*(CPointOut-Point); vector3 kResult = fOmTime * (CPointOut - Point);
int iDegreeM1 = 3 - 1; int iDegreeM1 = 3 - 1;
float fCoeff = 2*fPowTime; float fCoeff = 2 * fPowTime;
kResult = (kResult+fCoeff*(Next->CPointIn-CPointOut))*fOmTime; kResult = (kResult + fCoeff * (Next->CPointIn - CPointOut)) * fOmTime;
fPowTime *= fTime; fPowTime *= fTime;
kResult += fPowTime*(Next->Point-Next->CPointIn); kResult += fPowTime * (Next->Point - Next->CPointIn);
kResult *= 3; kResult *= 3;
return kResult; return kResult;
@@ -203,83 +202,80 @@ float TKnot::RombergIntegral(float fA, float fB)
{ {
float fH = fB - fA; float fH = fB - fA;
const int ms_iOrder= 5; const int ms_iOrder = 5;
float ms_apfRom[2][ms_iOrder]; float ms_apfRom[2][ms_iOrder];
ms_apfRom[0][0] = 0.5*fH*((GetFirstDerivative(fA).Length())+(GetFirstDerivative(fB).Length())); ms_apfRom[0][0] =
0.5 * fH * ((GetFirstDerivative(fA).Length()) + (GetFirstDerivative(fB).Length()));
for (int i0 = 2, iP0 = 1; i0 <= ms_iOrder; i0++, iP0 *= 2, fH *= 0.5) for (int i0 = 2, iP0 = 1; i0 <= ms_iOrder; i0++, iP0 *= 2, fH *= 0.5)
{ {
// approximations via the trapezoid rule // approximations via the trapezoid rule
float fSum = 0.0; float fSum = 0.0;
int i1; int i1;
for (i1 = 1; i1 <= iP0; i1++) for (i1 = 1; i1 <= iP0; i1++)
fSum += (GetFirstDerivative(fA + fH*(i1-0.5)).Length()); fSum += (GetFirstDerivative(fA + fH * (i1 - 0.5)).Length());
// Richardson extrapolation // Richardson extrapolation
ms_apfRom[1][0] = 0.5*(ms_apfRom[0][0] + fH*fSum); ms_apfRom[1][0] = 0.5 * (ms_apfRom[0][0] + fH * fSum);
for (int i2 = 1, iP2 = 4; i2 < i0; i2++, iP2 *= 4) for (int i2 = 1, iP2 = 4; i2 < i0; i2++, iP2 *= 4)
{ {
ms_apfRom[1][i2] = ms_apfRom[1][i2] = (iP2 * ms_apfRom[1][i2 - 1] - ms_apfRom[0][i2 - 1]) / (iP2 - 1);
(iP2*ms_apfRom[1][i2-1] - ms_apfRom[0][i2-1])/(iP2-1);
} }
for (i1 = 0; i1 < i0; i1++) for (i1 = 0; i1 < i0; i1++)
ms_apfRom[0][i1] = ms_apfRom[1][i1]; ms_apfRom[0][i1] = ms_apfRom[1][i1];
} }
return ms_apfRom[0][ms_iOrder-1]; return ms_apfRom[0][ms_iOrder - 1];
} }
//----------------------------------------------------------------------------// //----------------------------------------------------------------------------//
__fastcall TSpline::TSpline() __fastcall TSpline::TSpline()
{ {
// Closed= true; // Closed= true;
// asName= "foo"; // asName= "foo";
// Knots= NULL; // Knots= NULL;
RootKnot= NULL; RootKnot = NULL;
iNumKnots= 0; iNumKnots = 0;
KnotsAllocated= false; KnotsAllocated = false;
// Next=Prev= this; // Next=Prev= this;
} }
__fastcall TSpline::TSpline(AnsiString asNName) __fastcall TSpline::TSpline(AnsiString asNName)
{ {
// Closed= true; // Closed= true;
// asName= asNName; // asName= asNName;
// Knots= NULL; // Knots= NULL;
RootKnot= NULL; RootKnot = NULL;
iNumKnots= 0; iNumKnots = 0;
KnotsAllocated= false; KnotsAllocated = false;
// Next=Prev= this; // Next=Prev= this;
} }
__fastcall TSpline::~TSpline() __fastcall TSpline::~TSpline()
{ {
// if (KnotsAllocated) // if (KnotsAllocated)
// SafeDeleteArray(Knots); // SafeDeleteArray(Knots);
// SafeDelete(RootKnot); // SafeDelete(RootKnot);
TKnot *ck,*tk; TKnot *ck, *tk;
ck= RootKnot; ck = RootKnot;
for (int i=0; i<iNumKnots; i++) for (int i = 0; i < iNumKnots; i++)
{ {
tk= ck; tk = ck;
ck= ck->Next; ck = ck->Next;
SafeDelete(tk); SafeDelete(tk);
} }
} }
bool __fastcall TSpline::Create( int n, AnsiString asNName ) bool __fastcall TSpline::Create(int n, AnsiString asNName)
{ {
/* /*
// asName= asNName; // asName= asNName;
iNumKnots= n; iNumKnots= n;
Knots= new TKnot[iNumKnots]; Knots= new TKnot[iNumKnots];
KnotsAllocated= true; KnotsAllocated= true;
@@ -290,18 +286,17 @@ bool __fastcall TSpline::Create( int n, AnsiString asNName )
*/ */
} }
bool __fastcall TSpline::AssignKnots( TKnot *FirstKnot, int n ) bool __fastcall TSpline::AssignKnots(TKnot *FirstKnot, int n)
{ {
// iNumKnots= n; // iNumKnots= n;
// Knots= FirstKnot; // Knots= FirstKnot;
// KnotsAllocated= false; // KnotsAllocated= false;
} }
int __fastcall TSpline::LoadFromFile( AnsiString FileName, TKnot *FirstKnot ) int __fastcall TSpline::LoadFromFile(AnsiString FileName, TKnot *FirstKnot)
{ {
return false; return false;
/* /*
int i; int i;
iNumKnots= -1; iNumKnots= -1;
@@ -323,7 +318,7 @@ int __fastcall TSpline::LoadFromFile( AnsiString FileName, TKnot *FirstKnot )
else else
AssignKnots(FirstKnot,buf.ToInt()); AssignKnots(FirstKnot,buf.ToInt());
TKnot *CurrentKnot= Knots; TKnot *CurrentKnot= Knots;
// iNumKnots= buf.ToInt(); // iNumKnots= buf.ToInt();
// Knots= new TKnot[iNumKnots];// malloc(*sizeof(TKnot)); // Knots= new TKnot[iNumKnots];// malloc(*sizeof(TKnot));
DecimalSeparator= '.'; DecimalSeparator= '.';
@@ -341,7 +336,7 @@ int __fastcall TSpline::LoadFromFile( AnsiString FileName, TKnot *FirstKnot )
tf->ReadLn(buf); CurrentKnot->CPointOut.y= buf.ToDouble(); tf->ReadLn(buf); CurrentKnot->CPointOut.y= buf.ToDouble();
tf->ReadLn(buf); tf->ReadLn(buf);
// buf.Trim(); // buf.Trim();
Knots[i].IsCurve= (buf!="#line "); Knots[i].IsCurve= (buf!="#line ");
CurrentKnot= CurrentKnot->Next; CurrentKnot= CurrentKnot->Next;
@@ -353,11 +348,12 @@ int __fastcall TSpline::LoadFromFile( AnsiString FileName, TKnot *FirstKnot )
for (i=0; i<iNumKnots-1; i++) for (i=0; i<iNumKnots-1; i++)
{ {
// Knots[i].InitLength(); // Knots[i].InitLength();
if (CurrentKnot->IsCurve) if (CurrentKnot->IsCurve)
{ {
CurrentKnot->Length= CurveLength(CurrentKnot->Point,CurrentKnot->CPointOut,CurrentKnot->Next->CPointIn,CurrentKnot->Next->Point); CurrentKnot->Length=
CurveLength(CurrentKnot->Point,CurrentKnot->CPointOut,CurrentKnot->Next->CPointIn,CurrentKnot->Next->Point);
} }
else else
{ {
@@ -380,125 +376,124 @@ int __fastcall TSpline::LoadFromFile( AnsiString FileName, TKnot *FirstKnot )
*/ */
} }
int __fastcall TSpline::Load( TQueryParserComp *Parser, AnsiString asEndString ) int __fastcall TSpline::Load(TQueryParserComp *Parser, AnsiString asEndString)
{ {
TKnot *LastKnot= NULL;; TKnot *LastKnot = NULL;
if (RootKnot!=NULL) ;
for (LastKnot= RootKnot; LastKnot->Next!=NULL; LastKnot= LastKnot->Next); if (RootKnot != NULL)
for (LastKnot = RootKnot; LastKnot->Next != NULL; LastKnot = LastKnot->Next)
;
TKnot *tmp; TKnot *tmp;
tmp= new TKnot(0); tmp = new TKnot(0);
tmp->Prev= LastKnot; tmp->Prev = LastKnot;
if (LastKnot!=NULL) if (LastKnot != NULL)
LastKnot->Next= tmp; LastKnot->Next = tmp;
else else
RootKnot= tmp; RootKnot = tmp;
LastKnot= tmp; LastKnot = tmp;
float tf,r,pr; float tf, r, pr;
vector3 dir; vector3 dir;
// asName= Parser->GetNextSymbol(); // asName= Parser->GetNextSymbol();
iNumKnots= 0; iNumKnots = 0;
do do
{ {
LastKnot->fLengthIn= Parser->GetNextSymbol().ToDouble(); LastKnot->fLengthIn = Parser->GetNextSymbol().ToDouble();
tf= Parser->GetNextSymbol().ToDouble(); tf = Parser->GetNextSymbol().ToDouble();
LastKnot->Point.x= tf; LastKnot->Point.x = tf;
tf= Parser->GetNextSymbol().ToDouble(); tf = Parser->GetNextSymbol().ToDouble();
LastKnot->Point.y= tf; LastKnot->Point.y = tf;
tf= Parser->GetNextSymbol().ToDouble(); tf = Parser->GetNextSymbol().ToDouble();
LastKnot->Point.z= tf; LastKnot->Point.z = tf;
tf= Parser->GetNextSymbol().ToDouble(); tf = Parser->GetNextSymbol().ToDouble();
LastKnot->fRoll= tf/180*M_PI; LastKnot->fRoll = tf / 180 * M_PI;
LastKnot->fLengthOut= Parser->GetNextSymbol().ToDouble(); LastKnot->fLengthOut = Parser->GetNextSymbol().ToDouble();
LastKnot->IsCurve= (LastKnot->fLengthOut!=0); LastKnot->IsCurve = (LastKnot->fLengthOut != 0);
LastKnot->Next= new TKnot(0); LastKnot->Next = new TKnot(0);
LastKnot->Next->Prev= LastKnot; LastKnot->Next->Prev = LastKnot;
LastKnot= LastKnot->Next; LastKnot = LastKnot->Next;
iNumKnots++; iNumKnots++;
} while (Parser->GetNextSymbol().LowerCase() != asEndString && !Parser->EOF);
} while (Parser->GetNextSymbol().LowerCase()!=asEndString && !Parser->EOF); LastKnot->Prev->Next = NULL;
LastKnot->Prev->Next= NULL;
delete LastKnot; delete LastKnot;
if (RootKnot!=NULL) if (RootKnot != NULL)
for (LastKnot= RootKnot; LastKnot!=NULL; LastKnot= LastKnot->Next) for (LastKnot = RootKnot; LastKnot != NULL; LastKnot = LastKnot->Next)
LastKnot->InitCPoints(); LastKnot->InitCPoints();
if (RootKnot!=NULL) if (RootKnot != NULL)
for (LastKnot= RootKnot; LastKnot!=NULL; LastKnot= LastKnot->Next) for (LastKnot = RootKnot; LastKnot != NULL; LastKnot = LastKnot->Next)
LastKnot->InitLength(); LastKnot->InitLength();
} }
float __fastcall TSpline::GetLength() float __fastcall TSpline::GetLength()
{ {
TKnot *tmp= RootKnot; TKnot *tmp = RootKnot;
float l= 0; float l = 0;
for (int i=0; i<iNumKnots; i++) for (int i = 0; i < iNumKnots; i++)
{ {
l+= tmp->Length; l += tmp->Length;
tmp= tmp->Next; tmp = tmp->Next;
} }
return l; return l;
} }
vector3 __fastcall TSpline::GetCenter() vector3 __fastcall TSpline::GetCenter()
{ {
TKnot *ck,*tk; TKnot *ck, *tk;
ck= RootKnot; ck = RootKnot;
vector3 pt= vector3(0,0,0); vector3 pt = vector3(0, 0, 0);
for (int i=0; i<iNumKnots; i++) for (int i = 0; i < iNumKnots; i++)
{ {
pt+= ck->Point; pt += ck->Point;
ck= ck->Next; ck = ck->Next;
} }
if (iNumKnots>0) if (iNumKnots > 0)
pt/= iNumKnots; pt /= iNumKnots;
} }
TKnot* __fastcall TSpline::GetLastKnot() TKnot *__fastcall TSpline::GetLastKnot()
{ {
TKnot *ck; TKnot *ck;
ck= RootKnot; ck = RootKnot;
for (int i=0; i<iNumKnots-1; i++) for (int i = 0; i < iNumKnots - 1; i++)
{ {
ck= ck->Next; ck = ck->Next;
} }
return ck; return ck;
} }
bool __fastcall TSpline::Render() bool __fastcall TSpline::Render()
{ {
TKnot *LastKnot= NULL;; TKnot *LastKnot = NULL;
;
// if (RootKnot==NULL) // if (RootKnot==NULL)
// RootKnot= Knots; // RootKnot= Knots;
if (RootKnot!=NULL) if (RootKnot != NULL)
{ {
glBindTexture(GL_TEXTURE_2D, 0); glBindTexture(GL_TEXTURE_2D, 0);
glBegin(GL_LINE_STRIP); glBegin(GL_LINE_STRIP);
int i=0; int i = 0;
for (LastKnot= RootKnot; LastKnot!=NULL && i<iNumKnots; LastKnot= LastKnot->Next, i++) for (LastKnot = RootKnot; LastKnot != NULL && i < iNumKnots; LastKnot = LastKnot->Next, i++)
// for (LastKnot= RootKnot; LastKnot!=NULL; LastKnot= LastKnot->Next) // for (LastKnot= RootKnot; LastKnot!=NULL; LastKnot= LastKnot->Next)
glVertex3f(LastKnot->Point.x,LastKnot->Point.y,LastKnot->Point.z); glVertex3f(LastKnot->Point.x, LastKnot->Point.y, LastKnot->Point.z);
glEnd(); glEnd();
/* /*
if (RootKnot->Prev!=NULL) if (RootKnot->Prev!=NULL)
{ {
glBindTexture(GL_TEXTURE_2D, 0); glBindTexture(GL_TEXTURE_2D, 0);
@@ -507,12 +502,9 @@ bool __fastcall TSpline::Render()
glVertex3f(RootKnot->Prev->Point.x,RootKnot->Prev->Point.y,RootKnot->Prev->Point.z); glVertex3f(RootKnot->Prev->Point.x,RootKnot->Prev->Point.y,RootKnot->Prev->Point.z);
glEnd(); glEnd();
}*/ }*/
} }
} }
//--------------------------------------------------------------------------- //---------------------------------------------------------------------------
#pragma package(smart_init) #pragma package(smart_init)

74
Spline.h
View File

@@ -6,17 +6,17 @@
#include "QueryParserComp.hpp" #include "QueryParserComp.hpp"
using namespace Math3D; using namespace Math3D;
#define B1(t) (t*t*t) #define B1(t) (t * t * t)
#define B2(t) (3*t*t*(1-t)) #define B2(t) (3 * t * t * (1 - t))
#define B3(t) (3*t*(1-t)*(1-t)) #define B3(t) (3 * t * (1 - t) * (1 - t))
#define B4(t) ((1-t)*(1-t)*(1-t)) #define B4(t) ((1 - t) * (1 - t) * (1 - t))
#define Interpolate(t,p1,cp1,cp2,p2) (B4(t)*p1+B3(t)*cp1+B2(t)*cp2+B1(t)*p2) #define Interpolate(t, p1, cp1, cp2, p2) (B4(t) * p1 + B3(t) * cp1 + B2(t) * cp2 + B1(t) * p2)
class TKnot class TKnot
{ {
public: public:
// inline bool __fastcall IsCurve() { return (!(Point==CPointIn)); }; // inline bool __fastcall IsCurve() { return (!(Point==CPointIn)); };
// inline vector3 __fastcall GetDirection() { return (CPointOut-Point); }; // inline vector3 __fastcall GetDirection() { return (CPointOut-Point); };
__fastcall TKnot(); __fastcall TKnot();
__fastcall TKnot(int n); __fastcall TKnot(int n);
__fastcall ~TKnot(); __fastcall ~TKnot();
@@ -24,63 +24,69 @@ public:
{ {
if (Next) if (Next)
{ {
s/= Length; s /= Length;
return ((1-s)*fRoll+(s)*Next->fRoll); return ((1 - s) * fRoll + (s)*Next->fRoll);
} }
else else
return fRoll; return fRoll;
// (Length-s) (s-Length) // (Length-s) (s-Length)
} }
vector3 __fastcall GetDirection(float t= 0); vector3 __fastcall GetDirection(float t = 0);
inline vector3 __fastcall InterpolateSegm(float t) { return (Interpolate(t,Point,CPointOut,Next->CPointIn,Next->Point) ); }; inline vector3 __fastcall InterpolateSegm(float t)
{
return (Interpolate(t, Point, CPointOut, Next->CPointIn, Next->Point));
};
float __fastcall GetTFromS(float s); float __fastcall GetTFromS(float s);
bool __fastcall Init(TKnot *NNext, TKnot *NPrev); bool __fastcall Init(TKnot *NNext, TKnot *NPrev);
bool __fastcall InitCPoints(); bool __fastcall InitCPoints();
bool __fastcall InitLength(); bool __fastcall InitLength();
vector3 Point,CPointIn,CPointOut; vector3 Point, CPointIn, CPointOut;
float fRoll; float fRoll;
bool IsCurve; bool IsCurve;
float Length; float Length;
TKnot *Next,*Prev; TKnot *Next, *Prev;
float fLengthIn,fLengthOut; float fLengthIn, fLengthOut;
bool bSwitchDirectionForward; bool bSwitchDirectionForward;
bool bSwitchDirectionBackward; bool bSwitchDirectionBackward;
private: private:
vector3 GetFirstDerivative(float fTime); vector3 GetFirstDerivative(float fTime);
float RombergIntegral (float fA, float fB); float RombergIntegral(float fA, float fB);
}; };
class TSpline class TSpline
{ {
public: public:
__fastcall TSpline(); __fastcall TSpline();
__fastcall TSpline(AnsiString asNName); __fastcall TSpline(AnsiString asNName);
__fastcall ~TSpline(); __fastcall ~TSpline();
bool __fastcall Create( int n, AnsiString asNName="foo" ); bool __fastcall Create(int n, AnsiString asNName = "foo");
bool __fastcall AssignKnots( TKnot *FirstKnot, int n ); bool __fastcall AssignKnots(TKnot *FirstKnot, int n);
int __fastcall LoadFromFile( AnsiString FileName, TKnot *FirstKnot = NULL ); int __fastcall LoadFromFile(AnsiString FileName, TKnot *FirstKnot = NULL);
int __fastcall Load( TQueryParserComp *Parser, AnsiString asEndString="endspline" ); int __fastcall Load(TQueryParserComp *Parser, AnsiString asEndString = "endspline");
float __fastcall GetLength(); float __fastcall GetLength();
vector3 __fastcall GetCenter(); vector3 __fastcall GetCenter();
TKnot* __fastcall GetLastKnot(); TKnot *__fastcall GetLastKnot();
bool __fastcall Render(); bool __fastcall Render();
// inline int NextIndex(int n) { return (n<KnotsCount-1 ? n+1 : 0); }; // inline int NextIndex(int n) { return (n<KnotsCount-1 ? n+1 : 0); };
// inline vector3 InterpolateSegm(int i, float t) { return (Interpolate(t,Knots[i].Point,Knots[i].CPointOut,Knots[NextIndex(i)].CPointIn,Knots[NextIndex(i)].Point) ); }; // inline vector3 InterpolateSegm(int i, float t) { return
// inline vector3 InterpolateSegm(TKnot *Knot, float t) { return (Interpolate(t,Knots[i].Point,Knots[i].CPointOut,Knots[NextIndex(i)].CPointIn,Knots[NextIndex(i)].Point) ); }; // (Interpolate(t,Knots[i].Point,Knots[i].CPointOut,Knots[NextIndex(i)].CPointIn,Knots[NextIndex(i)].Point)
// bool Closed; // ); };
// AnsiString asName; // inline vector3 InterpolateSegm(TKnot *Knot, float t) { return
// TKnot *Knots; // (Interpolate(t,Knots[i].Point,Knots[i].CPointOut,Knots[NextIndex(i)].CPointIn,Knots[NextIndex(i)].Point)
// ); };
// bool Closed;
// AnsiString asName;
// TKnot *Knots;
TKnot *RootKnot; TKnot *RootKnot;
bool KnotsAllocated; bool KnotsAllocated;
int iNumKnots; int iNumKnots;
// TSpline *Next,*Prev; // TSpline *Next,*Prev;
// TKnot Next,Prev; // TKnot Next,Prev;
private:
private:
}; };
bool __fastcall Connect(TKnot *k1, TKnot *k2); bool __fastcall Connect(TKnot *k1, TKnot *k2);

67
Spring.cpp
View File

@@ -9,70 +9,63 @@
#include "Spring.h" #include "Spring.h"
#include "Usefull.h" #include "Usefull.h"
__fastcall TSpring::TSpring() __fastcall TSpring::TSpring()
{ {
vForce1=vForce2= vector3(0,0,0); vForce1 = vForce2 = vector3(0, 0, 0);
Ks= 0; Ks = 0;
Kd= 0; Kd = 0;
restLen= 0; restLen = 0;
} }
__fastcall TSpring::~TSpring() __fastcall TSpring::~TSpring() {}
{
}
void __fastcall TSpring::Init(double nrestLen, double nKs, double nKd) void __fastcall TSpring::Init(double nrestLen, double nKs, double nKd)
{ {
Ks= nKs; Ks = nKs;
Kd= nKd; Kd = nKd;
restLen= nrestLen; restLen = nrestLen;
} }
bool __fastcall TSpring::ComputateForces(vector3 pPosition1, vector3 pPosition2) bool __fastcall TSpring::ComputateForces(vector3 pPosition1, vector3 pPosition2)
{ {
double dist, Hterm, Dterm; double dist, Hterm, Dterm;
vector3 springForce,deltaV,deltaP; vector3 springForce, deltaV, deltaP;
// p1 = &system[spring->p1]; // p1 = &system[spring->p1];
// p2 = &system[spring->p2]; // p2 = &system[spring->p2];
// VectorDifference(&p1->pos,&p2->pos,&deltaP); // Vector distance // VectorDifference(&p1->pos,&p2->pos,&deltaP); // Vector distance
deltaP= pPosition1 - pPosition2; deltaP = pPosition1 - pPosition2;
// dist = VectorLength(&deltaP); // Magnitude of deltaP // dist = VectorLength(&deltaP); // Magnitude of
//deltaP
dist = deltaP.Length(); dist = deltaP.Length();
if (dist==0) if (dist == 0)
{ {
vForce1=vForce2=vector3(0,0,0); vForce1 = vForce2 = vector3(0, 0, 0);
return false; return false;
} }
// Hterm = (dist - spring->restLen) * spring->Ks; // Ks * (dist - rest) // Hterm = (dist - spring->restLen) * spring->Ks; // Ks * (dist - rest)
Hterm= (dist - restLen) * Ks; // Ks * (dist - rest) Hterm = (dist - restLen) * Ks; // Ks * (dist - rest)
// VectorDifference(&p1->v,&p2->v,&deltaV); // Delta Velocity Vector // VectorDifference(&p1->v,&p2->v,&deltaV); // Delta Velocity Vector
deltaV= pPosition1 - pPosition2; deltaV = pPosition1 - pPosition2;
// Dterm = (DotProduct(&deltaV,&deltaP) * spring->Kd) / dist; // Damping Term // Dterm = (DotProduct(&deltaV,&deltaP) * spring->Kd) / dist; // Damping Term
//Dterm = (DotProduct(deltaV,deltaP) * Kd) / dist; // Dterm = (DotProduct(deltaV,deltaP) * Kd) / dist;
Dterm= 0; Dterm = 0;
// ScaleVector(&deltaP,1.0f / dist, &springForce); // Normalize Distance Vector // ScaleVector(&deltaP,1.0f / dist, &springForce); // Normalize Distance Vector
// ScaleVector(&springForce,-(Hterm + Dterm),&springForce); // Calc Force // ScaleVector(&springForce,-(Hterm + Dterm),&springForce); // Calc Force
springForce= deltaP/dist*(-(Hterm + Dterm)); springForce = deltaP / dist * (-(Hterm + Dterm));
// VectorSum(&p1->f,&springForce,&p1->f); // Apply to Particle 1 // VectorSum(&p1->f,&springForce,&p1->f); // Apply to Particle 1
// VectorDifference(&p2->f,&springForce,&p2->f); // - Force on Particle 2 // VectorDifference(&p2->f,&springForce,&p2->f); // - Force on Particle 2
vForce1= springForce; vForce1 = springForce;
vForce2= springForce; vForce2 = springForce;
return true; return true;
} }
void __fastcall TSpring::Render() void __fastcall TSpring::Render() {}
{
}
//--------------------------------------------------------------------------- //---------------------------------------------------------------------------

15
Spring.h
View File

@@ -3,9 +3,8 @@
#ifndef ParticlesH #ifndef ParticlesH
#define ParticlesH #define ParticlesH
#define STATIC_THRESHOLD 0.17f #define STATIC_THRESHOLD 0.17f
//efine STATIC_THRESHOLD 0.03f // efine STATIC_THRESHOLD 0.03f
const double m_Kd = 0.02f; // DAMPING FACTOR const double m_Kd = 0.02f; // DAMPING FACTOR
const double m_Kr = 0.8f; // 1.0 = SUPERBALL BOUNCE 0.0 = DEAD WEIGHT const double m_Kr = 0.8f; // 1.0 = SUPERBALL BOUNCE 0.0 = DEAD WEIGHT
const double m_Ksh = 5.0f; // HOOK'S SPRING CONSTANT const double m_Ksh = 5.0f; // HOOK'S SPRING CONSTANT
@@ -19,20 +18,20 @@ using namespace Math3D;
class TSpring class TSpring
{ {
public: public:
__fastcall TSpring(); __fastcall TSpring();
__fastcall ~TSpring(); __fastcall ~TSpring();
// void __fastcall Init(TParticnp1, TParticle *np2, double nKs= 0.5f, double nKd= 0.002f, double nrestLen= -1.0f); // void __fastcall Init(TParticnp1, TParticle *np2, double nKs= 0.5f, double nKd= 0.002f,
void __fastcall Init(double nrestLen, double nKs= 0.5f, double nKd= 0.002f); // double nrestLen= -1.0f);
void __fastcall Init(double nrestLen, double nKs = 0.5f, double nKd = 0.002f);
bool __fastcall ComputateForces(vector3 pPosition1, vector3 pPosition2); bool __fastcall ComputateForces(vector3 pPosition1, vector3 pPosition2);
void __fastcall Render(); void __fastcall Render();
vector3 vForce1,vForce2; vector3 vForce1, vForce2;
double restLen; // LENGTH OF SPRING AT REST double restLen; // LENGTH OF SPRING AT REST
double Ks; // SPRING CONSTANT double Ks; // SPRING CONSTANT
double Kd; // SPRING DAMPING double Kd; // SPRING DAMPING
private: private:
}; };
//--------------------------------------------------------------------------- //---------------------------------------------------------------------------
#endif #endif

746
Texture.cpp
View File

File diff suppressed because it is too large Load Diff

20
Texture.h
View File

@@ -24,35 +24,35 @@ void __fastcall glDebug()
class TTexturesManager class TTexturesManager
{ {
public: public:
static void Init(); static void Init();
static void Free(); static void Free();
static GLuint GetTextureID(char* dir,char* where,std::string name,int filter=-1); static GLuint GetTextureID(char *dir, char *where, std::string name, int filter = -1);
static bool GetAlpha(GLuint ID); //McZapkie-141203: czy tekstura ma polprzeroczystosc static bool GetAlpha(GLuint ID); // McZapkie-141203: czy tekstura ma polprzeroczystosc
static std::string GetName(GLuint id); static std::string GetName(GLuint id);
private: private:
typedef std::pair<GLuint, bool> AlphaValue; typedef std::pair<GLuint, bool> AlphaValue;
typedef std::map<std::string, GLuint> Names; typedef std::map<std::string, GLuint> Names;
typedef std::map<GLuint, bool> Alphas; typedef std::map<GLuint, bool> Alphas;
static Names::iterator LoadFromFile(std::string name,int filter=-1); static Names::iterator LoadFromFile(std::string name, int filter = -1);
static AlphaValue LoadBMP(std::string fileName); static AlphaValue LoadBMP(std::string fileName);
static AlphaValue LoadTEX(std::string fileName); static AlphaValue LoadTEX(std::string fileName);
static AlphaValue LoadTGA(std::string fileName,int filter=-1); static AlphaValue LoadTGA(std::string fileName, int filter = -1);
static AlphaValue LoadDDS(std::string fileName,int filter=-1); static AlphaValue LoadDDS(std::string fileName, int filter = -1);
static void SetFiltering(int filter); static void SetFiltering(int filter);
static void SetFiltering(bool alpha, bool hash); static void SetFiltering(bool alpha, bool hash);
static GLuint CreateTexture(char *buff,GLint bpp,int width,int height,bool bHasAlpha,bool bHash,bool bDollar=true,int filter=-1); static GLuint CreateTexture(char *buff, GLint bpp, int width, int height, bool bHasAlpha,
bool bHash, bool bDollar = true, int filter = -1);
static Names _names; static Names _names;
static Alphas _alphas; static Alphas _alphas;
// std::list<TTexture> Textures; // std::list<TTexture> Textures;
}; };
//--------------------------------------------------------------------------- //---------------------------------------------------------------------------
#endif #endif

135
TextureDDS.cpp
View File

@@ -1,6 +1,6 @@
#include "TextureDDS.h" #include "TextureDDS.h"
void DxtcReadColors(const GLubyte* Data, Color8888* result) void DxtcReadColors(const GLubyte *Data, Color8888 *result)
{ {
GLubyte r0, g0, b0, r1, g1, b1; GLubyte r0, g0, b0, r1, g1, b1;
@@ -21,7 +21,7 @@ void DxtcReadColors(const GLubyte* Data, Color8888* result)
result[1].b = b1 << 3 | b1 >> 2; result[1].b = b1 << 3 | b1 >> 2;
}; };
void DxtcReadColor(GLushort Data, Color8888* Out) void DxtcReadColor(GLushort Data, Color8888 *Out)
{ {
GLubyte r, g, b; GLubyte r, g, b;
@@ -48,18 +48,21 @@ void DecompressDXT1(DDS_IMAGE_DATA lImage, const GLubyte *lCompData, GLubyte *Da
colours[1].a = 0xFF; colours[1].a = 0xFF;
colours[2].a = 0xFF; colours[2].a = 0xFF;
for (y = 0; y < lImage.height; y += 4) { for (y = 0; y < lImage.height; y += 4)
for (x = 0; x < lImage.width; x += 4) { {
color_0 = *((const GLushort*)Temp); for (x = 0; x < lImage.width; x += 4)
color_1 = *((const GLushort*)(Temp + 2)); {
color_0 = *((const GLushort *)Temp);
color_1 = *((const GLushort *)(Temp + 2));
DxtcReadColor(color_0, colours); DxtcReadColor(color_0, colours);
DxtcReadColor(color_1, colours + 1); DxtcReadColor(color_1, colours + 1);
bitmask = ((const GLuint*)Temp)[1]; bitmask = ((const GLuint *)Temp)[1];
Temp += 8; Temp += 8;
if (color_0 > color_1) { if (color_0 > color_1)
{
// Four-color block: derive the other two colors. // Four-color block: derive the other two colors.
// 00 = color_0, 01 = color_1, 10 = color_2, 11 = color_3 // 00 = color_0, 01 = color_1, 10 = color_2, 11 = color_3
// These 2-bit codes correspond to the 2-bit fields // These 2-bit codes correspond to the 2-bit fields
@@ -90,13 +93,17 @@ void DecompressDXT1(DDS_IMAGE_DATA lImage, const GLubyte *lCompData, GLubyte *Da
colours[3].a = 0x00; colours[3].a = 0x00;
} }
for (j = 0, k = 0; j < 4; j++) { for (j = 0, k = 0; j < 4; j++)
for (i = 0; i < 4; i++, k++) { {
Select = (bitmask & (0x03 << k*2)) >> k*2; for (i = 0; i < 4; i++, k++)
{
Select = (bitmask & (0x03 << k * 2)) >> k * 2;
col = &colours[Select]; col = &colours[Select];
if (((x + i) < lImage.width) && ((y + j) < lImage.height)) { if (((x + i) < lImage.width) && ((y + j) < lImage.height))
Offset = (y + j) * lImage.width * lImage.components + (x + i) * lImage.components; {
Offset = (y + j) * lImage.width * lImage.components +
(x + i) * lImage.components;
Data[Offset + 0] = col->r; Data[Offset + 0] = col->r;
Data[Offset + 1] = col->g; Data[Offset + 1] = col->g;
Data[Offset + 2] = col->b; Data[Offset + 2] = col->b;
@@ -110,18 +117,20 @@ void DecompressDXT1(DDS_IMAGE_DATA lImage, const GLubyte *lCompData, GLubyte *Da
void DecompressDXT3(DDS_IMAGE_DATA lImage, const GLubyte *lCompData, GLubyte *Data) void DecompressDXT3(DDS_IMAGE_DATA lImage, const GLubyte *lCompData, GLubyte *Data)
{ {
const GLubyte* Temp = lCompData; const GLubyte *Temp = lCompData;
Color8888 colours[4], *col; Color8888 colours[4], *col;
GLuint bitmask, Offset; GLuint bitmask, Offset;
const GLubyte* alpha; const GLubyte *alpha;
for (GLint y = 0; y < lImage.height; y += 4) { for (GLint y = 0; y < lImage.height; y += 4)
for (GLint x = 0; x < lImage.width; x += 4) { {
for (GLint x = 0; x < lImage.width; x += 4)
{
alpha = Temp; alpha = Temp;
Temp += 8; Temp += 8;
DxtcReadColors(Temp, colours); DxtcReadColors(Temp, colours);
bitmask = ((GLuint*)Temp)[1]; bitmask = ((GLuint *)Temp)[1];
Temp += 8; Temp += 8;
@@ -138,13 +147,17 @@ void DecompressDXT3(DDS_IMAGE_DATA lImage, const GLubyte *lCompData, GLubyte *Da
colours[3].r = (colours[0].r + 2 * colours[1].r + 1) / 3; colours[3].r = (colours[0].r + 2 * colours[1].r + 1) / 3;
GLuint k = 0; GLuint k = 0;
for (GLint j = 0; j < 4; j++) { for (GLint j = 0; j < 4; j++)
for (GLint i = 0; i < 4; i++, k++) { {
GLuint Select = (bitmask & (0x03 << k*2)) >> k*2; for (GLint i = 0; i < 4; i++, k++)
{
GLuint Select = (bitmask & (0x03 << k * 2)) >> k * 2;
col = &colours[Select]; col = &colours[Select];
if (((x + i) < lImage.width) && ((y + j) < lImage.height)) { if (((x + i) < lImage.width) && ((y + j) < lImage.height))
Offset = (y + j) * lImage.width * lImage.components + (x + i) * lImage.components; {
Offset = (y + j) * lImage.width * lImage.components +
(x + i) * lImage.components;
Data[Offset + 0] = col->r; Data[Offset + 0] = col->r;
Data[Offset + 1] = col->g; Data[Offset + 1] = col->g;
Data[Offset + 2] = col->b; Data[Offset + 2] = col->b;
@@ -152,11 +165,15 @@ void DecompressDXT3(DDS_IMAGE_DATA lImage, const GLubyte *lCompData, GLubyte *Da
} }
} }
for (GLint j = 0; j < 4; j++) { for (GLint j = 0; j < 4; j++)
GLushort word = alpha[2*j] + 256*alpha[2*j+1]; {
for (GLint i = 0; i < 4; i++) { GLushort word = alpha[2 * j] + 256 * alpha[2 * j + 1];
if (((x + i) < lImage.width) && ((y + j) < lImage.height)) { for (GLint i = 0; i < 4; i++)
Offset = (y + j) * lImage.width * lImage.components + (x + i) * lImage.components + 3; {
if (((x + i) < lImage.width) && ((y + j) < lImage.height))
{
Offset = (y + j) * lImage.width * lImage.components +
(x + i) * lImage.components + 3;
Data[Offset] = word & 0x0F; Data[Offset] = word & 0x0F;
Data[Offset] = Data[Offset] | (Data[Offset] << 4); Data[Offset] = Data[Offset] | (Data[Offset] << 4);
} }
@@ -179,17 +196,19 @@ void DecompressDXT5(DDS_IMAGE_DATA lImage, const GLubyte *lCompData, GLubyte *Da
Temp = lCompData; Temp = lCompData;
for (y = 0; y < lImage.height; y += 4) { for (y = 0; y < lImage.height; y += 4)
for (x = 0; x < lImage.width; x += 4) { {
for (x = 0; x < lImage.width; x += 4)
{
if (y >= lImage.height || x >= lImage.width) if (y >= lImage.height || x >= lImage.width)
break; break;
alphas[0] = Temp[0]; alphas[0] = Temp[0];
alphas[1] = Temp[1]; alphas[1] = Temp[1];
const GLubyte* alphamask = Temp + 2; const GLubyte *alphamask = Temp + 2;
Temp += 8; Temp += 8;
DxtcReadColors(Temp, colours); DxtcReadColors(Temp, colours);
bitmask = ((const GLuint*)Temp)[1]; bitmask = ((const GLuint *)Temp)[1];
Temp += 8; Temp += 8;
@@ -206,15 +225,19 @@ void DecompressDXT5(DDS_IMAGE_DATA lImage, const GLubyte *lCompData, GLubyte *Da
colours[3].r = (colours[0].r + 2 * colours[1].r + 1) / 3; colours[3].r = (colours[0].r + 2 * colours[1].r + 1) / 3;
k = 0; k = 0;
for (j = 0; j < 4; j++) { for (j = 0; j < 4; j++)
for (i = 0; i < 4; i++, k++) { {
for (i = 0; i < 4; i++, k++)
{
Select = (bitmask & (0x03 << k*2)) >> k*2; Select = (bitmask & (0x03 << k * 2)) >> k * 2;
col = &colours[Select]; col = &colours[Select];
// only put pixels out < width or height // only put pixels out < width or height
if (((x + i) < lImage.width) && ((y + j) < lImage.height)) { if (((x + i) < lImage.width) && ((y + j) < lImage.height))
Offset = (y + j) * lImage.width * lImage.components + (x + i) * lImage.components; {
Offset = (y + j) * lImage.width * lImage.components +
(x + i) * lImage.components;
Data[Offset + 0] = col->r; Data[Offset + 0] = col->r;
Data[Offset + 1] = col->g; Data[Offset + 1] = col->g;
Data[Offset + 2] = col->b; Data[Offset + 2] = col->b;
@@ -223,7 +246,8 @@ void DecompressDXT5(DDS_IMAGE_DATA lImage, const GLubyte *lCompData, GLubyte *Da
} }
// 8-alpha or 6-alpha block? // 8-alpha or 6-alpha block?
if (alphas[0] > alphas[1]) { if (alphas[0] > alphas[1])
{
// 8-alpha block: derive the other six alphas. // 8-alpha block: derive the other six alphas.
// Bit code 000 = alpha_0, 001 = alpha_1, others are interpolated. // Bit code 000 = alpha_0, 001 = alpha_1, others are interpolated.
alphas[2] = (6 * alphas[0] + 1 * alphas[1] + 3) / 7; // bit code 010 alphas[2] = (6 * alphas[0] + 1 * alphas[1] + 3) / 7; // bit code 010
@@ -233,7 +257,8 @@ void DecompressDXT5(DDS_IMAGE_DATA lImage, const GLubyte *lCompData, GLubyte *Da
alphas[6] = (2 * alphas[0] + 5 * alphas[1] + 3) / 7; // bit code 110 alphas[6] = (2 * alphas[0] + 5 * alphas[1] + 3) / 7; // bit code 110
alphas[7] = (1 * alphas[0] + 6 * alphas[1] + 3) / 7; // bit code 111 alphas[7] = (1 * alphas[0] + 6 * alphas[1] + 3) / 7; // bit code 111
} }
else { else
{
// 6-alpha block. // 6-alpha block.
// Bit code 000 = alpha_0, 001 = alpha_1, others are interpolated. // Bit code 000 = alpha_0, 001 = alpha_1, others are interpolated.
alphas[2] = (4 * alphas[0] + 1 * alphas[1] + 2) / 5; // Bit code 010 alphas[2] = (4 * alphas[0] + 1 * alphas[1] + 2) / 5; // Bit code 010
@@ -248,13 +273,17 @@ void DecompressDXT5(DDS_IMAGE_DATA lImage, const GLubyte *lCompData, GLubyte *Da
// it operates on a 6-byte system. // it operates on a 6-byte system.
// First three bytes // First three bytes
//bits = *((ILint*)alphamask); // bits = *((ILint*)alphamask);
bits = (alphamask[0]) | (alphamask[1] << 8) | (alphamask[2] << 16); bits = (alphamask[0]) | (alphamask[1] << 8) | (alphamask[2] << 16);
for (j = 0; j < 2; j++) { for (j = 0; j < 2; j++)
for (i = 0; i < 4; i++) { {
for (i = 0; i < 4; i++)
{
// only put pixels out < width or height // only put pixels out < width or height
if (((x + i) < lImage.width) && ((y + j) < lImage.height)) { if (((x + i) < lImage.width) && ((y + j) < lImage.height))
Offset = (y + j) * lImage.width * lImage.components + (x + i) * lImage.components + 3; {
Offset = (y + j) * lImage.width * lImage.components +
(x + i) * lImage.components + 3;
Data[Offset] = alphas[bits & 0x07]; Data[Offset] = alphas[bits & 0x07];
} }
bits >>= 3; bits >>= 3;
@@ -262,13 +291,17 @@ void DecompressDXT5(DDS_IMAGE_DATA lImage, const GLubyte *lCompData, GLubyte *Da
} }
// Last three bytes // Last three bytes
//bits = *((ILint*)&alphamask[3]); // bits = *((ILint*)&alphamask[3]);
bits = (alphamask[3]) | (alphamask[4] << 8) | (alphamask[5] << 16); bits = (alphamask[3]) | (alphamask[4] << 8) | (alphamask[5] << 16);
for (j = 2; j < 4; j++) { for (j = 2; j < 4; j++)
for (i = 0; i < 4; i++) { {
for (i = 0; i < 4; i++)
{
// only put pixels out < width or height // only put pixels out < width or height
if (((x + i) < lImage.width) && ((y + j) < lImage.height)) { if (((x + i) < lImage.width) && ((y + j) < lImage.height))
Offset = (y + j) * lImage.width * lImage.components + (x + i) * lImage.components + 3; {
Offset = (y + j) * lImage.width * lImage.components +
(x + i) * lImage.components + 3;
Data[Offset] = alphas[bits & 0x07]; Data[Offset] = alphas[bits & 0x07];
} }
bits >>= 3; bits >>= 3;
@@ -280,7 +313,7 @@ void DecompressDXT5(DDS_IMAGE_DATA lImage, const GLubyte *lCompData, GLubyte *Da
void DecompressDXT(DDS_IMAGE_DATA lImage, const GLubyte *lCompData, GLubyte *Data) void DecompressDXT(DDS_IMAGE_DATA lImage, const GLubyte *lCompData, GLubyte *Data)
{ {
switch(lImage.format) switch (lImage.format)
{ {
case GL_COMPRESSED_RGBA_S3TC_DXT1_EXT: case GL_COMPRESSED_RGBA_S3TC_DXT1_EXT:
DecompressDXT1(lImage, lCompData, Data); DecompressDXT1(lImage, lCompData, Data);
@@ -293,7 +326,5 @@ void DecompressDXT(DDS_IMAGE_DATA lImage, const GLubyte *lCompData, GLubyte *Dat
case GL_COMPRESSED_RGBA_S3TC_DXT5_EXT: case GL_COMPRESSED_RGBA_S3TC_DXT5_EXT:
DecompressDXT5(lImage, lCompData, Data); DecompressDXT5(lImage, lCompData, Data);
break; break;
}; };
} }

1
TextureDDS.h
View File

@@ -27,4 +27,3 @@ struct DDS_IMAGE_DATA
void DecompressDXT(DDS_IMAGE_DATA lImage, const GLubyte *lCompData, GLubyte *Data); void DecompressDXT(DDS_IMAGE_DATA lImage, const GLubyte *lCompData, GLubyte *Data);
#endif #endif

124
Timer.cpp
View File

@@ -7,113 +7,85 @@
#include "Timer.h" #include "Timer.h"
#include "Globals.h" #include "Globals.h"
namespace Timer { namespace Timer
double DeltaTime,DeltaRenderTime;
double fFPS =0.0f;
double fLastTime =0.0f;
DWORD dwFrames =0L;
double fSimulationTime=0;
double fSoundTimer=0;
double fSinceStart=0;
double __fastcall GetTime()
{ {
return fSimulationTime;
}
double __fastcall GetDeltaTime() double DeltaTime, DeltaRenderTime;
{//czas symulacji (stoi gdy pauza) double fFPS = 0.0f;
return DeltaTime; double fLastTime = 0.0f;
} DWORD dwFrames = 0L;
double fSimulationTime = 0;
double fSoundTimer = 0;
double fSinceStart = 0;
double __fastcall GetDeltaRenderTime() double __fastcall GetTime() { return fSimulationTime; }
{//czas renderowania (do poruszania siê)
return DeltaRenderTime;
}
double __fastcall GetfSinceStart() double __fastcall GetDeltaTime() { // czas symulacji (stoi gdy pauza) return DeltaTime; }
{
return fSinceStart;
}
void __fastcall SetDeltaTime(double t) double __fastcall GetDeltaRenderTime() { // czas renderowania (do poruszania siê) return DeltaRenderTime; }
{
DeltaTime= t;
}
double __fastcall GetSimulationTime() double __fastcall GetfSinceStart() { return fSinceStart; }
{
return fSimulationTime;
}
void __fastcall SetSimulationTime(double t) void __fastcall SetDeltaTime(double t) { DeltaTime = t; }
{
fSimulationTime=t; double __fastcall GetSimulationTime() { return fSimulationTime; }
}
void __fastcall SetSimulationTime(double t) { fSimulationTime = t; }
bool __fastcall GetSoundTimer() bool __fastcall GetSoundTimer()
{//Ra: byæ mo¿e, by dŸwiêki nie modyfikowa³y siê zbyt czêsto, po 0.1s zeruje siê ten licznik { // Ra: byæ mo¿e, by dŸwiêki nie modyfikowa³y siê zbyt czêsto, po 0.1s zeruje siê ten licznik
return (fSoundTimer==0.0f); return (fSoundTimer == 0.0f); }
}
double __fastcall GetFPS() { return fFPS; }
double __fastcall GetFPS()
{
return fFPS;
}
void __fastcall ResetTimers() void __fastcall ResetTimers()
{ {
//double CurrentTime= // double CurrentTime=
GetTickCount(); GetTickCount();
DeltaTime=0.1; DeltaTime = 0.1;
DeltaRenderTime=0; DeltaRenderTime = 0;
fSoundTimer=0; fSoundTimer = 0;
}; };
LONGLONG fr,count,oldCount; LONGLONG fr, count, oldCount;
//LARGE_INTEGER fr,count; // LARGE_INTEGER fr,count;
void __fastcall UpdateTimers(bool pause) void __fastcall UpdateTimers(bool pause)
{ {
QueryPerformanceFrequency((LARGE_INTEGER*)&fr); QueryPerformanceFrequency((LARGE_INTEGER *)&fr);
QueryPerformanceCounter((LARGE_INTEGER*)&count); QueryPerformanceCounter((LARGE_INTEGER *)&count);
DeltaRenderTime=double(count-oldCount)/double(fr); DeltaRenderTime = double(count - oldCount) / double(fr);
if (!pause) if (!pause)
{DeltaTime=Global::fTimeSpeed*DeltaRenderTime; {
fSoundTimer+=DeltaTime; DeltaTime = Global::fTimeSpeed * DeltaRenderTime;
if (fSoundTimer>0.1) fSoundTimer=0; fSoundTimer += DeltaTime;
/* if (fSoundTimer > 0.1)
fSoundTimer = 0;
/*
double CurrentTime= double(count)/double(fr);//GetTickCount(); double CurrentTime= double(count)/double(fr);//GetTickCount();
DeltaTime= (CurrentTime-OldTime); DeltaTime= (CurrentTime-OldTime);
OldTime= CurrentTime; OldTime= CurrentTime;
*/ */
if (DeltaTime>1) DeltaTime=1; if (DeltaTime > 1)
DeltaTime = 1;
} }
else else
DeltaTime=0; //wszystko stoi, bo czas nie p³ynie DeltaTime = 0; // wszystko stoi, bo czas nie p³ynie
oldCount=count; oldCount = count;
// Keep track of the time lapse and frame count // Keep track of the time lapse and frame count
double fTime=GetTickCount()*0.001f; // Get current time in seconds double fTime = GetTickCount() * 0.001f; // Get current time in seconds
++dwFrames; //licznik ramek ++dwFrames; // licznik ramek
//update the frame rate once per second // update the frame rate once per second
if (fTime-fLastTime>1.0f) if (fTime - fLastTime > 1.0f)
{ {
fFPS =dwFrames/(fTime-fLastTime); fFPS = dwFrames / (fTime - fLastTime);
fLastTime=fTime; fLastTime = fTime;
dwFrames =0L; dwFrames = 0L;
} }
fSimulationTime+=DeltaTime; fSimulationTime += DeltaTime;
}; };
}; };
//--------------------------------------------------------------------------- //---------------------------------------------------------------------------
#pragma package(smart_init) #pragma package(smart_init)

5
Timer.h
View File

@@ -3,8 +3,8 @@
#ifndef TimerH #ifndef TimerH
#define TimerH #define TimerH
namespace Timer { namespace Timer
{
double __fastcall GetTime(); double __fastcall GetTime();
@@ -26,7 +26,6 @@ double __fastcall GetFPS();
void __fastcall ResetTimers(); void __fastcall ResetTimers();
void __fastcall UpdateTimers(bool pause); void __fastcall UpdateTimers(bool pause);
}; };
//--------------------------------------------------------------------------- //---------------------------------------------------------------------------

4020
Track.cpp
View File

File diff suppressed because it is too large Load Diff

289
Track.h
View File

@@ -9,13 +9,29 @@
#include <system.hpp> #include <system.hpp>
#include "Classes.h" #include "Classes.h"
class TEvent; class TEvent;
typedef enum { tt_Unknown, tt_Normal, tt_Switch, tt_Table, tt_Cross, tt_Tributary } TTrackType; typedef enum
//McZapkie-100502 {
typedef enum {e_unknown=-1, e_flat=0, e_mountains, e_canyon, e_tunnel, e_bridge, e_bank} TEnvironmentType; tt_Unknown,
//Ra: opracować alternatywny system cieni/świateł z definiowaniem koloru oświetlenia w halach tt_Normal,
tt_Switch,
tt_Table,
tt_Cross,
tt_Tributary
} TTrackType;
// McZapkie-100502
typedef enum
{
e_unknown = -1,
e_flat = 0,
e_mountains,
e_canyon,
e_tunnel,
e_bridge,
e_bank
} TEnvironmentType;
// Ra: opracować alternatywny system cieni/świateł z definiowaniem koloru oświetlenia w halach
class TTrack; class TTrack;
class TGroundNode; class TGroundNode;
@@ -23,157 +39,164 @@ class TSubRect;
class TTraction; class TTraction;
class TSwitchExtension class TSwitchExtension
{//dodatkowe dane do toru, który jest zwrotnicą { // dodatkowe dane do toru, który jest zwrotnicą
public: public:
__fastcall TSwitchExtension(TTrack *owner,int what); __fastcall TSwitchExtension(TTrack *owner, int what);
__fastcall ~TSwitchExtension(); __fastcall ~TSwitchExtension();
TSegment *Segments[6]; //dwa tory od punktu 1, pozostałe dwa od 2? Ra 140101: 6 połączeń dla skrzyżowań TSegment *Segments[6]; // dwa tory od punktu 1, pozostałe dwa od 2? Ra 140101: 6 połączeń dla
//TTrack *trNear[4]; //tory dołączone do punktów 1, 2, 3 i 4 // skrzyżowań
//dotychczasowe [2]+[2] wskaźniki zamienić na nowe [4] // TTrack *trNear[4]; //tory dołączone do punktów 1, 2, 3 i 4
TTrack *pNexts[2]; //tory dołączone do punktów 2 i 4 // dotychczasowe [2]+[2] wskaźniki zamienić na nowe [4]
TTrack *pPrevs[2]; //tory dołączone do punktów 1 i 3 TTrack *pNexts[2]; // tory dołączone do punktów 2 i 4
int iNextDirection[2]; //to też z [2]+[2] przerobić na [4] TTrack *pPrevs[2]; // tory dołączone do punktów 1 i 3
int iNextDirection[2]; // to też z [2]+[2] przerobić na [4]
int iPrevDirection[2]; int iPrevDirection[2];
int CurrentIndex; //dla zwrotnicy int CurrentIndex; // dla zwrotnicy
double fOffset,fDesiredOffset; //aktualne i docelowe położenie napędu iglic double fOffset, fDesiredOffset; // aktualne i docelowe położenie napędu iglic
double fOffsetSpeed; //prędkość liniowa ruchu iglic double fOffsetSpeed; // prędkość liniowa ruchu iglic
double fOffsetDelay; //opóźnienie ruchu drugiej iglicy względem pierwszej double fOffsetDelay; // opóźnienie ruchu drugiej iglicy względem pierwszej
union union
{ {
struct struct
{//zmienne potrzebne tylko dla zwrotnicy { // zmienne potrzebne tylko dla zwrotnicy
double fOffset1,fOffset2; //przesunięcia iglic - 0=na wprost double fOffset1, fOffset2; // przesunięcia iglic - 0=na wprost
bool RightSwitch; //czy zwrotnica w prawo bool RightSwitch; // czy zwrotnica w prawo
}; };
struct struct
{//zmienne potrzebne tylko dla obrotnicy/przesuwnicy { // zmienne potrzebne tylko dla obrotnicy/przesuwnicy
TGroundNode *pMyNode; //dla obrotnicy do wtórnego podłączania torów TGroundNode *pMyNode; // dla obrotnicy do wtórnego podłączania torów
//TAnimContainer *pAnim; //animator modelu dla obrotnicy // TAnimContainer *pAnim; //animator modelu dla obrotnicy
TAnimModel *pModel; //na razie model TAnimModel *pModel; // na razie model
}; };
struct struct
{//zmienne dla skrzyżowania { // zmienne dla skrzyżowania
vector3 *vPoints; //tablica wierzchołków nawierzchni, generowana przez pobocze vector3 *vPoints; // tablica wierzchołków nawierzchni, generowana przez pobocze
int iPoints; //liczba faktycznie użytych wierzchołków nawierzchni int iPoints; // liczba faktycznie użytych wierzchołków nawierzchni
bool bPoints; //czy utworzone? bool bPoints; // czy utworzone?
int iRoads; //ile dróg się spotyka? int iRoads; // ile dróg się spotyka?
}; };
}; };
bool bMovement; //czy w trakcie animacji bool bMovement; // czy w trakcie animacji
int iLeftVBO,iRightVBO; //indeksy iglic w VBO int iLeftVBO, iRightVBO; // indeksy iglic w VBO
TSubRect *pOwner; //sektor, któremu trzeba zgłosić animację TSubRect *pOwner; // sektor, któremu trzeba zgłosić animację
TTrack *pNextAnim; //następny tor do animowania TTrack *pNextAnim; // następny tor do animowania
TEvent *evPlus,*evMinus; //zdarzenia sygnalizacji rozprucia TEvent *evPlus, *evMinus; // zdarzenia sygnalizacji rozprucia
float fVelocity; //maksymalne ograniczenie prędkości (ustawianej eventem) float fVelocity; // maksymalne ograniczenie prędkości (ustawianej eventem)
vector3 vTrans; //docelowa translacja przesuwnicy vector3 vTrans; // docelowa translacja przesuwnicy
private: private:
}; };
const int iMaxNumDynamics=40; //McZapkie-100303 const int iMaxNumDynamics = 40; // McZapkie-100303
class TIsolated class TIsolated
{//obiekt zbierający zajętości z kilku odcinków { // obiekt zbierający zajętości z kilku odcinków
int iAxles; //ilość osi na odcinkach obsługiwanych przez obiekt int iAxles; // ilość osi na odcinkach obsługiwanych przez obiekt
TIsolated *pNext; //odcinki izolowane są trzymane w postaci listy jednikierunkowej TIsolated *pNext; // odcinki izolowane są trzymane w postaci listy jednikierunkowej
static TIsolated *pRoot; //początek listy static TIsolated *pRoot; // początek listy
public: public:
AnsiString asName; //nazwa obiektu, baza do nazw eventów AnsiString asName; // nazwa obiektu, baza do nazw eventów
TEvent *evBusy; //zdarzenie wyzwalane po zajęciu grupy TEvent *evBusy; // zdarzenie wyzwalane po zajęciu grupy
TEvent *evFree; //zdarzenie wyzwalane po całkowitym zwolnieniu zajętości grupy TEvent *evFree; // zdarzenie wyzwalane po całkowitym zwolnieniu zajętości grupy
TMemCell *pMemCell; //automatyczna komórka pamięci, która współpracuje z odcinkiem izolowanym TMemCell *pMemCell; // automatyczna komórka pamięci, która współpracuje z odcinkiem izolowanym
__fastcall TIsolated(); __fastcall TIsolated();
__fastcall TIsolated(const AnsiString &n,TIsolated *i); __fastcall TIsolated(const AnsiString &n, TIsolated *i);
__fastcall ~TIsolated(); __fastcall ~TIsolated();
static TIsolated* __fastcall Find(const AnsiString &n); //znalezienie obiektu albo utworzenie nowego static TIsolated *__fastcall Find(
void __fastcall Modify(int i,TDynamicObject *o); //dodanie lub odjęcie osi const AnsiString &n); // znalezienie obiektu albo utworzenie nowego
bool __fastcall Busy() { return (iAxles>0); }; void __fastcall Modify(int i, TDynamicObject *o); // dodanie lub odjęcie osi
static TIsolated* __fastcall Root() { return (pRoot); }; bool __fastcall Busy() { return (iAxles > 0); };
TIsolated* __fastcall Next() { return (pNext); }; static TIsolated *__fastcall Root() { return (pRoot); };
TIsolated *__fastcall Next() { return (pNext); };
}; };
class TTrack : public Resource class TTrack : public Resource
{//trajektoria ruchu - opakowanie { // trajektoria ruchu - opakowanie
private: private:
TSwitchExtension *SwitchExtension; //dodatkowe dane do toru, który jest zwrotnicą TSwitchExtension *SwitchExtension; // dodatkowe dane do toru, który jest zwrotnicą
TSegment *Segment; TSegment *Segment;
TTrack *trNext; //odcinek od strony punktu 2 - to powinno być w segmencie TTrack *trNext; // odcinek od strony punktu 2 - to powinno być w segmencie
TTrack *trPrev; //odcinek od strony punktu 1 TTrack *trPrev; // odcinek od strony punktu 1
//McZapkie-070402: dodalem zmienne opisujace rozmiary tekstur // McZapkie-070402: dodalem zmienne opisujace rozmiary tekstur
GLuint TextureID1; //tekstura szyn albo nawierzchni GLuint TextureID1; // tekstura szyn albo nawierzchni
GLuint TextureID2; //tekstura automatycznej podsypki albo pobocza GLuint TextureID2; // tekstura automatycznej podsypki albo pobocza
float fTexLength; //długość powtarzania tekstury w metrach float fTexLength; // długość powtarzania tekstury w metrach
float fTexRatio1; //proporcja rozmiarów tekstury dla nawierzchni drogi float fTexRatio1; // proporcja rozmiarów tekstury dla nawierzchni drogi
float fTexRatio2; //proporcja rozmiarów tekstury dla chodnika float fTexRatio2; // proporcja rozmiarów tekstury dla chodnika
float fTexHeight1; //wysokość brzegu względem trajektorii float fTexHeight1; // wysokość brzegu względem trajektorii
float fTexWidth; //szerokość boku float fTexWidth; // szerokość boku
float fTexSlope; float fTexSlope;
double fRadiusTable[2]; //dwa promienie, drugi dla zwrotnicy double fRadiusTable[2]; // dwa promienie, drugi dla zwrotnicy
int iTrapezoid; //0-standard, 1-przechyłka, 2-trapez, 3-oba int iTrapezoid; // 0-standard, 1-przechyłka, 2-trapez, 3-oba
GLuint DisplayListID; GLuint DisplayListID;
TIsolated *pIsolated; //obwód izolowany obsługujący zajęcia/zwolnienia grupy torów TIsolated *pIsolated; // obwód izolowany obsługujący zajęcia/zwolnienia grupy torów
TGroundNode *pMyNode; //Ra: proteza, żeby tor znał swoją nazwę TODO: odziedziczyć TTrack z TGroundNode TGroundNode *
public: pMyNode; // Ra: proteza, żeby tor znał swoją nazwę TODO: odziedziczyć TTrack z TGroundNode
public:
int iNumDynamics; int iNumDynamics;
TDynamicObject *Dynamics[iMaxNumDynamics]; TDynamicObject *Dynamics[iMaxNumDynamics];
int iEvents; //Ra: flaga informująca o obecności eventów int iEvents; // Ra: flaga informująca o obecności eventów
TEvent *evEventall0; //McZapkie-140302: wyzwalany gdy pojazd stoi TEvent *evEventall0; // McZapkie-140302: wyzwalany gdy pojazd stoi
TEvent *evEventall1; TEvent *evEventall1;
TEvent *evEventall2; TEvent *evEventall2;
TEvent *evEvent0; //McZapkie-280503: wyzwalany tylko gdy headdriver TEvent *evEvent0; // McZapkie-280503: wyzwalany tylko gdy headdriver
TEvent *evEvent1; TEvent *evEvent1;
TEvent *evEvent2; TEvent *evEvent2;
AnsiString asEventall0Name; //nazwy eventów AnsiString asEventall0Name; // nazwy eventów
AnsiString asEventall1Name; AnsiString asEventall1Name;
AnsiString asEventall2Name; AnsiString asEventall2Name;
AnsiString asEvent0Name; AnsiString asEvent0Name;
AnsiString asEvent1Name; AnsiString asEvent1Name;
AnsiString asEvent2Name; AnsiString asEvent2Name;
int iNextDirection; //0:Point1, 1:Point2, 3:do odchylonego na zwrotnicy int iNextDirection; // 0:Point1, 1:Point2, 3:do odchylonego na zwrotnicy
int iPrevDirection; int iPrevDirection;
TTrackType eType; TTrackType eType;
int iCategoryFlag; //0x100 - usuwanie pojazów int iCategoryFlag; // 0x100 - usuwanie pojazów
float fTrackWidth; //szerokość w punkcie 1 float fTrackWidth; // szerokość w punkcie 1
float fTrackWidth2; //szerokość w punkcie 2 (głównie drogi i rzeki) float fTrackWidth2; // szerokość w punkcie 2 (głównie drogi i rzeki)
float fFriction; //współczynnik tarcia float fFriction; // współczynnik tarcia
float fSoundDistance; float fSoundDistance;
int iQualityFlag; int iQualityFlag;
int iDamageFlag; int iDamageFlag;
TEnvironmentType eEnvironment; //dźwięk i oświetlenie TEnvironmentType eEnvironment; // dźwięk i oświetlenie
bool bVisible; //czy rysowany bool bVisible; // czy rysowany
int iAction; //czy modyfikowany eventami (specjalna obsługa przy skanowaniu) int iAction; // czy modyfikowany eventami (specjalna obsługa przy skanowaniu)
float fOverhead; //informacja o stanie sieci: 0-jazda bezprądowa, >0-z opuszczonym i ograniczeniem prędkości float fOverhead; // informacja o stanie sieci: 0-jazda bezprądowa, >0-z opuszczonym i
private: // ograniczeniem prędkości
double fVelocity; //prędkość dla AI (powyżej rośnie prawdopowobieństwo wykolejenia) private:
public: double fVelocity; // prędkość dla AI (powyżej rośnie prawdopowobieństwo wykolejenia)
//McZapkie-100502: public:
double fTrackLength; //długość z wpisu, nigdzie nie używana // McZapkie-100502:
double fRadius; //promień, dla zwrotnicy kopiowany z tabeli double fTrackLength; // długość z wpisu, nigdzie nie używana
bool ScannedFlag; //McZapkie: do zaznaczania kolorem torów skanowanych przez AI double fRadius; // promień, dla zwrotnicy kopiowany z tabeli
TTraction *hvOverhead; //drut zasilający do szybkiego znalezienia (nie używany) bool ScannedFlag; // McZapkie: do zaznaczania kolorem torów skanowanych przez AI
TGroundNode *nFouling[2]; //współrzędne ukresu albo oporu kozła TTraction *hvOverhead; // drut zasilający do szybkiego znalezienia (nie używany)
TTrack *trColides; //tor kolizyjny, na którym trzeba sprawdzać pojazdy pod kątem zderzenia TGroundNode *nFouling[2]; // współrzędne ukresu albo oporu kozła
TTrack *trColides; // tor kolizyjny, na którym trzeba sprawdzać pojazdy pod kątem zderzenia
__fastcall TTrack(TGroundNode *g); __fastcall TTrack(TGroundNode *g);
__fastcall ~TTrack(); __fastcall ~TTrack();
void __fastcall Init(); void __fastcall Init();
static TTrack* __fastcall Create400m(int what,double dx); static TTrack *__fastcall Create400m(int what, double dx);
TTrack* __fastcall NullCreate(int dir); TTrack *__fastcall NullCreate(int dir);
inline bool __fastcall IsEmpty() { return (iNumDynamics<=0); }; inline bool __fastcall IsEmpty() { return (iNumDynamics <= 0); };
void __fastcall ConnectPrevPrev(TTrack *pNewPrev,int typ); void __fastcall ConnectPrevPrev(TTrack *pNewPrev, int typ);
void __fastcall ConnectPrevNext(TTrack *pNewPrev,int typ); void __fastcall ConnectPrevNext(TTrack *pNewPrev, int typ);
void __fastcall ConnectNextPrev(TTrack *pNewNext,int typ); void __fastcall ConnectNextPrev(TTrack *pNewNext, int typ);
void __fastcall ConnectNextNext(TTrack *pNewNext,int typ); void __fastcall ConnectNextNext(TTrack *pNewNext, int typ);
inline double __fastcall Length() { return Segment->GetLength(); }; inline double __fastcall Length() { return Segment->GetLength(); };
inline TSegment* __fastcall CurrentSegment() { return Segment; }; inline TSegment *__fastcall CurrentSegment() { return Segment; };
inline TTrack* __fastcall CurrentNext() {return (trNext);}; inline TTrack *__fastcall CurrentNext() { return (trNext); };
inline TTrack* __fastcall CurrentPrev() {return (trPrev);}; inline TTrack *__fastcall CurrentPrev() { return (trPrev); };
TTrack* __fastcall Neightbour(int s,double &d); TTrack *__fastcall Neightbour(int s, double &d);
bool __fastcall SetConnections(int i); bool __fastcall SetConnections(int i);
bool __fastcall Switch(int i,double t=-1.0,double d=-1.0); bool __fastcall Switch(int i, double t = -1.0, double d = -1.0);
bool __fastcall SwitchForced(int i,TDynamicObject *o); bool __fastcall SwitchForced(int i, TDynamicObject *o);
int __fastcall CrossSegment(int from,int into); int __fastcall CrossSegment(int from, int into);
inline int __fastcall GetSwitchState() { return (SwitchExtension?SwitchExtension->CurrentIndex:-1); }; inline int __fastcall GetSwitchState()
void __fastcall Load(cParser *parser, vector3 pOrigin,AnsiString name); {
return (SwitchExtension ? SwitchExtension->CurrentIndex : -1);
};
void __fastcall Load(cParser *parser, vector3 pOrigin, AnsiString name);
bool __fastcall AssignEvents(TEvent *NewEvent0, TEvent *NewEvent1, TEvent *NewEvent2); bool __fastcall AssignEvents(TEvent *NewEvent0, TEvent *NewEvent1, TEvent *NewEvent2);
bool __fastcall AssignallEvents(TEvent *NewEvent0, TEvent *NewEvent1, TEvent *NewEvent2); bool __fastcall AssignallEvents(TEvent *NewEvent0, TEvent *NewEvent1, TEvent *NewEvent2);
bool __fastcall AssignForcedEvents(TEvent *NewEventPlus, TEvent *NewEventMinus); bool __fastcall AssignForcedEvents(TEvent *NewEventPlus, TEvent *NewEventMinus);
@@ -183,31 +206,38 @@ public:
void __fastcall MoveMe(vector3 pPosition); void __fastcall MoveMe(vector3 pPosition);
void Release(); void Release();
void __fastcall Compile(GLuint tex=0); void __fastcall Compile(GLuint tex = 0);
void __fastcall Render(); //renderowanie z Display Lists void __fastcall Render(); // renderowanie z Display Lists
int __fastcall RaArrayPrepare(); //zliczanie rozmiaru dla VBO sektroa int __fastcall RaArrayPrepare(); // zliczanie rozmiaru dla VBO sektroa
void __fastcall RaArrayFill(CVertNormTex *Vert,const CVertNormTex *Start); //wypełnianie VBO void __fastcall RaArrayFill(CVertNormTex *Vert, const CVertNormTex *Start); // wypełnianie VBO
void __fastcall RaRenderVBO(int iPtr); //renderowanie z VBO sektora void __fastcall RaRenderVBO(int iPtr); // renderowanie z VBO sektora
void __fastcall RenderDyn(); //renderowanie nieprzezroczystych pojazdów (oba tryby) void __fastcall RenderDyn(); // renderowanie nieprzezroczystych pojazdów (oba tryby)
void __fastcall RenderDynAlpha(); //renderowanie przezroczystych pojazdów (oba tryby) void __fastcall RenderDynAlpha(); // renderowanie przezroczystych pojazdów (oba tryby)
void __fastcall RenderDynSounds(); //odtwarzanie dźwięków pojazdów jest niezależne od ich wyświetlania void __fastcall RenderDynSounds(); // odtwarzanie dźwięków pojazdów jest niezależne od ich
// wyświetlania
void __fastcall RaOwnerSet(TSubRect *o) void __fastcall RaOwnerSet(TSubRect *o)
{if (SwitchExtension) SwitchExtension->pOwner=o;}; {
bool __fastcall InMovement(); //czy w trakcie animacji? if (SwitchExtension)
void __fastcall RaAssign(TGroundNode *gn,TAnimContainer *ac); SwitchExtension->pOwner = o;
void __fastcall RaAssign(TGroundNode *gn,TAnimModel *am,TEvent *done,TEvent *joined); };
bool __fastcall InMovement(); // czy w trakcie animacji?
void __fastcall RaAssign(TGroundNode *gn, TAnimContainer *ac);
void __fastcall RaAssign(TGroundNode *gn, TAnimModel *am, TEvent *done, TEvent *joined);
void __fastcall RaAnimListAdd(TTrack *t); void __fastcall RaAnimListAdd(TTrack *t);
TTrack* __fastcall RaAnimate(); TTrack *__fastcall RaAnimate();
void __fastcall RadioStop(); void __fastcall RadioStop();
void __fastcall AxleCounter(int i,TDynamicObject *o) void __fastcall AxleCounter(int i, TDynamicObject *o)
{if (pIsolated) pIsolated->Modify(i,o);}; //dodanie lub odjęcie osi {
if (pIsolated)
pIsolated->Modify(i, o);
}; // dodanie lub odjęcie osi
AnsiString __fastcall IsolatedName(); AnsiString __fastcall IsolatedName();
bool __fastcall IsolatedEventsAssign(TEvent *busy,TEvent *free); bool __fastcall IsolatedEventsAssign(TEvent *busy, TEvent *free);
double __fastcall WidthTotal(); double __fastcall WidthTotal();
GLuint TextureGet(int i) {return i?TextureID1:TextureID2;}; GLuint TextureGet(int i) { return i ? TextureID1 : TextureID2; };
bool __fastcall IsGroupable(); bool __fastcall IsGroupable();
int __fastcall TestPoint(vector3 *Point); int __fastcall TestPoint(vector3 *Point);
void __fastcall MovedUp1(double dh); void __fastcall MovedUp1(double dh);
@@ -215,7 +245,8 @@ public:
void __fastcall VelocitySet(float v); void __fastcall VelocitySet(float v);
float __fastcall VelocityGet(); float __fastcall VelocityGet();
void __fastcall ConnectionsLog(); void __fastcall ConnectionsLog();
private:
private:
void __fastcall EnvironmentSet(); void __fastcall EnvironmentSet();
void __fastcall EnvironmentReset(); void __fastcall EnvironmentReset();
}; };

744
Traction.cpp
View File

@@ -88,148 +88,161 @@ jawnie nazw
sekcji z sąsiedniego przęsła). sekcji z sąsiedniego przęsła).
*/ */
TTraction::TTraction() TTraction::TTraction()
{ {
pPoint1=pPoint2=pPoint3=pPoint4=vector3(0,0,0); pPoint1 = pPoint2 = pPoint3 = pPoint4 = vector3(0, 0, 0);
//vFront=vector3(0,0,1); // vFront=vector3(0,0,1);
//vUp=vector3(0,1,0); // vUp=vector3(0,1,0);
//vLeft=vector3(1,0,0); // vLeft=vector3(1,0,0);
fHeightDifference=0; fHeightDifference = 0;
iNumSections=0; iNumSections = 0;
iLines=0; iLines = 0;
// dwFlags= 0; // dwFlags= 0;
Wires=2; Wires = 2;
// fU=fR= 0; // fU=fR= 0;
uiDisplayList=0; uiDisplayList = 0;
asPowerSupplyName=""; asPowerSupplyName = "";
// mdPole= NULL; // mdPole= NULL;
// ReplacableSkinID= 0; // ReplacableSkinID= 0;
hvNext[0]=hvNext[1]=NULL; hvNext[0] = hvNext[1] = NULL;
iLast=1; //że niby ostatni drut iLast = 1; //że niby ostatni drut
psPowered=psPower[0]=psPower[1]=NULL; //na początku zasilanie nie podłączone psPowered = psPower[0] = psPower[1] = NULL; // na początku zasilanie nie podłączone
psSection=NULL; //na początku nie podłączone psSection = NULL; // na początku nie podłączone
hvParallel=NULL; //normalnie brak bieżni wspólnej hvParallel = NULL; // normalnie brak bieżni wspólnej
fResistance[0]=fResistance[1]=-1.0; //trzeba dopiero policzyć fResistance[0] = fResistance[1] = -1.0; // trzeba dopiero policzyć
iTries=0; //ile razy próbować podłączyć, ustawiane później iTries = 0; // ile razy próbować podłączyć, ustawiane później
} }
TTraction::~TTraction() TTraction::~TTraction()
{ {
if (!Global::bUseVBO) if (!Global::bUseVBO)
glDeleteLists(uiDisplayList,1); glDeleteLists(uiDisplayList, 1);
} }
void __fastcall TTraction::Optimize() void __fastcall TTraction::Optimize()
{ {
if (Global::bUseVBO) return; if (Global::bUseVBO)
uiDisplayList=glGenLists(1); return;
glNewList(uiDisplayList,GL_COMPILE); uiDisplayList = glGenLists(1);
glNewList(uiDisplayList, GL_COMPILE);
glBindTexture(GL_TEXTURE_2D, 0); glBindTexture(GL_TEXTURE_2D, 0);
// glColor3ub(0,0,0); McZapkie: to do render // glColor3ub(0,0,0); McZapkie: to do render
// glPushMatrix(); // glPushMatrix();
// glTranslatef(pPosition.x,pPosition.y,pPosition.z); // glTranslatef(pPosition.x,pPosition.y,pPosition.z);
if (Wires!=0) if (Wires != 0)
{ {
//Dlugosc odcinka trakcji 'Winger // Dlugosc odcinka trakcji 'Winger
double ddp=hypot(pPoint2.x-pPoint1.x,pPoint2.z-pPoint1.z); double ddp = hypot(pPoint2.x - pPoint1.x, pPoint2.z - pPoint1.z);
if (Wires==2) WireOffset=0; if (Wires == 2)
//Przewoz jezdny 1 'Marcin WireOffset = 0;
// Przewoz jezdny 1 'Marcin
glBegin(GL_LINE_STRIP); glBegin(GL_LINE_STRIP);
glVertex3f(pPoint1.x-(pPoint2.z/ddp-pPoint1.z/ddp)*WireOffset,pPoint1.y,pPoint1.z-(-pPoint2.x/ddp+pPoint1.x/ddp)*WireOffset); glVertex3f(pPoint1.x - (pPoint2.z / ddp - pPoint1.z / ddp) * WireOffset, pPoint1.y,
glVertex3f(pPoint2.x-(pPoint2.z/ddp-pPoint1.z/ddp)*WireOffset,pPoint2.y,pPoint2.z-(-pPoint2.x/ddp+pPoint1.x/ddp)*WireOffset); pPoint1.z - (-pPoint2.x / ddp + pPoint1.x / ddp) * WireOffset);
glVertex3f(pPoint2.x - (pPoint2.z / ddp - pPoint1.z / ddp) * WireOffset, pPoint2.y,
pPoint2.z - (-pPoint2.x / ddp + pPoint1.x / ddp) * WireOffset);
glEnd(); glEnd();
//Nie wiem co 'Marcin // Nie wiem co 'Marcin
vector3 pt1,pt2,pt3,pt4,v1,v2; vector3 pt1, pt2, pt3, pt4, v1, v2;
v1= pPoint4-pPoint3; v1 = pPoint4 - pPoint3;
v2= pPoint2-pPoint1; v2 = pPoint2 - pPoint1;
float step= 0; float step = 0;
if (iNumSections>0) if (iNumSections > 0)
step= 1.0f/(float)iNumSections; step = 1.0f / (float)iNumSections;
float f= step; float f = step;
float mid= 0.5; float mid = 0.5;
float t; float t;
//Przewod nosny 'Marcin // Przewod nosny 'Marcin
if (Wires != 1) if (Wires != 1)
{ {
glBegin(GL_LINE_STRIP); glBegin(GL_LINE_STRIP);
glVertex3f(pPoint3.x,pPoint3.y,pPoint3.z); glVertex3f(pPoint3.x, pPoint3.y, pPoint3.z);
for (int i=0; i<iNumSections-1; i++) for (int i = 0; i < iNumSections - 1; i++)
{ {
pt3= pPoint3+v1*f; pt3 = pPoint3 + v1 * f;
t= (1-fabs(f-mid)*2); t = (1 - fabs(f - mid) * 2);
if ((Wires<4)||((i!=0)&&(i!=iNumSections-2))) if ((Wires < 4) || ((i != 0) && (i != iNumSections - 2)))
glVertex3f(pt3.x,pt3.y-sqrt(t)*fHeightDifference,pt3.z); glVertex3f(pt3.x, pt3.y - sqrt(t) * fHeightDifference, pt3.z);
f+= step; f += step;
} }
glVertex3f(pPoint4.x,pPoint4.y,pPoint4.z); glVertex3f(pPoint4.x, pPoint4.y, pPoint4.z);
glEnd(); glEnd();
} }
//Drugi przewod jezdny 'Winger // Drugi przewod jezdny 'Winger
if (Wires > 2) if (Wires > 2)
{ {
glBegin(GL_LINE_STRIP); glBegin(GL_LINE_STRIP);
glVertex3f(pPoint1.x+(pPoint2.z/ddp-pPoint1.z/ddp)*WireOffset,pPoint1.y,pPoint1.z+(-pPoint2.x/ddp+pPoint1.x/ddp)*WireOffset); glVertex3f(pPoint1.x + (pPoint2.z / ddp - pPoint1.z / ddp) * WireOffset, pPoint1.y,
glVertex3f(pPoint2.x+(pPoint2.z/ddp-pPoint1.z/ddp)*WireOffset,pPoint2.y,pPoint2.z+(-pPoint2.x/ddp+pPoint1.x/ddp)*WireOffset); pPoint1.z + (-pPoint2.x / ddp + pPoint1.x / ddp) * WireOffset);
glVertex3f(pPoint2.x + (pPoint2.z / ddp - pPoint1.z / ddp) * WireOffset, pPoint2.y,
pPoint2.z + (-pPoint2.x / ddp + pPoint1.x / ddp) * WireOffset);
glEnd(); glEnd();
} }
f= step; f = step;
if (Wires == 4) if (Wires == 4)
{ {
glBegin(GL_LINE_STRIP); glBegin(GL_LINE_STRIP);
glVertex3f(pPoint3.x,pPoint3.y-0.65f*fHeightDifference,pPoint3.z); glVertex3f(pPoint3.x, pPoint3.y - 0.65f * fHeightDifference, pPoint3.z);
for (int i=0; i<iNumSections-1; i++) for (int i = 0; i < iNumSections - 1; i++)
{ {
pt3= pPoint3+v1*f; pt3 = pPoint3 + v1 * f;
t= (1-fabs(f-mid)*2); t = (1 - fabs(f - mid) * 2);
glVertex3f(pt3.x,pt3.y-sqrt(t)*fHeightDifference-((i==0)||(i==iNumSections-2)?0.25f*fHeightDifference:+0.05),pt3.z); glVertex3f(
f+= step; pt3.x,
pt3.y - sqrt(t) * fHeightDifference -
((i == 0) || (i == iNumSections - 2) ? 0.25f * fHeightDifference : +0.05),
pt3.z);
f += step;
} }
glVertex3f(pPoint4.x,pPoint4.y-0.65f*fHeightDifference,pPoint4.z); glVertex3f(pPoint4.x, pPoint4.y - 0.65f * fHeightDifference, pPoint4.z);
glEnd(); glEnd();
} }
f = step;
f= step; // Przewody pionowe (wieszaki) 'Marcin, poprawki na 2 przewody jezdne 'Winger
//Przewody pionowe (wieszaki) 'Marcin, poprawki na 2 przewody jezdne 'Winger
if (Wires != 1) if (Wires != 1)
{ {
glBegin(GL_LINES); glBegin(GL_LINES);
for (int i=0; i<iNumSections-1; i++) for (int i = 0; i < iNumSections - 1; i++)
{ {
float flo,flo1; float flo, flo1;
flo=(Wires==4?0.25f*fHeightDifference:0); flo = (Wires == 4 ? 0.25f * fHeightDifference : 0);
flo1=(Wires==4?+0.05:0); flo1 = (Wires == 4 ? +0.05 : 0);
pt3= pPoint3+v1*f; pt3 = pPoint3 + v1 * f;
pt4= pPoint1+v2*f; pt4 = pPoint1 + v2 * f;
t= (1-fabs(f-mid)*2); t = (1 - fabs(f - mid) * 2);
if ((i%2) == 0) if ((i % 2) == 0)
{ {
glVertex3f(pt3.x,pt3.y-sqrt(t)*fHeightDifference-((i==0)||(i==iNumSections-2)?flo:flo1),pt3.z); glVertex3f(pt3.x, pt3.y - sqrt(t) * fHeightDifference -
glVertex3f(pt4.x-(pPoint2.z/ddp-pPoint1.z/ddp)*WireOffset,pt4.y,pt4.z-(-pPoint2.x/ddp+pPoint1.x/ddp)*WireOffset); ((i == 0) || (i == iNumSections - 2) ? flo : flo1),
pt3.z);
glVertex3f(pt4.x - (pPoint2.z / ddp - pPoint1.z / ddp) * WireOffset, pt4.y,
pt4.z - (-pPoint2.x / ddp + pPoint1.x / ddp) * WireOffset);
} }
else else
{ {
glVertex3f(pt3.x,pt3.y-sqrt(t)*fHeightDifference-((i==0)||(i==iNumSections-2)?flo:flo1),pt3.z); glVertex3f(pt3.x, pt3.y - sqrt(t) * fHeightDifference -
glVertex3f(pt4.x+(pPoint2.z/ddp-pPoint1.z/ddp)*WireOffset,pt4.y,pt4.z+(-pPoint2.x/ddp+pPoint1.x/ddp)*WireOffset); ((i == 0) || (i == iNumSections - 2) ? flo : flo1),
pt3.z);
glVertex3f(pt4.x + (pPoint2.z / ddp - pPoint1.z / ddp) * WireOffset, pt4.y,
pt4.z + (-pPoint2.x / ddp + pPoint1.x / ddp) * WireOffset);
} }
if((Wires==4)&&((i==1)||(i==iNumSections-3))) if ((Wires == 4) && ((i == 1) || (i == iNumSections - 3)))
{ {
glVertex3f(pt3.x,pt3.y-sqrt(t)*fHeightDifference-0.05,pt3.z); glVertex3f(pt3.x, pt3.y - sqrt(t) * fHeightDifference - 0.05, pt3.z);
glVertex3f(pt3.x,pt3.y-sqrt(t)*fHeightDifference,pt3.z); glVertex3f(pt3.x, pt3.y - sqrt(t) * fHeightDifference, pt3.z);
} }
//endif; // endif;
f+= step; f += step;
} }
glEnd(); glEnd();
} }
@@ -243,236 +256,302 @@ void __fastcall TTraction::InitCenter(vector3 Angles, vector3 pOrigin)
fSquaredRadius= SquareMagnitude((pPoint2-pPoint1)*0.5f); fSquaredRadius= SquareMagnitude((pPoint2-pPoint1)*0.5f);
} */ } */
void __fastcall TTraction::RenderDL(float mgn) //McZapkie: mgn to odleglosc od obserwatora void __fastcall TTraction::RenderDL(float mgn) // McZapkie: mgn to odleglosc od obserwatora
{ {
//McZapkie: ustalanie przezroczystosci i koloru linii: // McZapkie: ustalanie przezroczystosci i koloru linii:
if (Wires!=0 && !TestFlag(DamageFlag,128)) //rysuj jesli sa druty i nie zerwana if (Wires != 0 && !TestFlag(DamageFlag, 128)) // rysuj jesli sa druty i nie zerwana
{ {
//glDisable(GL_LIGHTING); //aby nie używało wektorów normalnych do kolorowania // glDisable(GL_LIGHTING); //aby nie używało wektorów normalnych do kolorowania
glColor4f(0,0,0,1); //jak nieznany kolor to czarne nieprzezroczyste glColor4f(0, 0, 0, 1); // jak nieznany kolor to czarne nieprzezroczyste
if (!Global::bSmoothTraction) if (!Global::bSmoothTraction)
glDisable(GL_LINE_SMOOTH); //na liniach kiepsko wygląda - robi gradient glDisable(GL_LINE_SMOOTH); // na liniach kiepsko wygląda - robi gradient
float linealpha=5000*WireThickness/(mgn+1.0); //*WireThickness float linealpha = 5000 * WireThickness / (mgn + 1.0); //*WireThickness
if (linealpha>1.2) linealpha=1.2; //zbyt grube nie są dobre if (linealpha > 1.2)
linealpha = 1.2; // zbyt grube nie są dobre
glLineWidth(linealpha); glLineWidth(linealpha);
if (linealpha>1.0) linealpha = 1.0; if (linealpha > 1.0)
//McZapkie-261102: kolor zalezy od materialu i zasniedzenia linealpha = 1.0;
float r,g,b; // McZapkie-261102: kolor zalezy od materialu i zasniedzenia
float r, g, b;
switch (Material) switch (Material)
{//Ra: kolory podzieliłem przez 2, bo po zmianie ambient za jasne były { // Ra: kolory podzieliłem przez 2, bo po zmianie ambient za jasne były
//trzeba uwzględnić kierunek świecenia Słońca - tylko ze Słońcem widać kolor // trzeba uwzględnić kierunek świecenia Słońca - tylko ze Słońcem widać kolor
case 1: case 1:
if (TestFlag(DamageFlag,1)) if (TestFlag(DamageFlag, 1))
{ {
r=0.00000; g=0.32549; b=0.2882353; //zielona miedź r = 0.00000;
g = 0.32549;
b = 0.2882353; // zielona miedź
} }
else else
{ {
r=0.35098; g=0.22549; b=0.1; //czerwona miedź r = 0.35098;
g = 0.22549;
b = 0.1; // czerwona miedź
} }
break; break;
case 2: case 2:
if (TestFlag(DamageFlag,1)) if (TestFlag(DamageFlag, 1))
{ {
r=0.10; g=0.10; b=0.10; //czarne Al r = 0.10;
g = 0.10;
b = 0.10; // czarne Al
} }
else else
{ {
r=0.25; g=0.25; b=0.25; //srebrne Al r = 0.25;
g = 0.25;
b = 0.25; // srebrne Al
} }
break; break;
//tymczasowo pokazanie zasilanych odcinków // tymczasowo pokazanie zasilanych odcinków
case 4: r=0.5; g=0.5; b=1.0; break; //niebieskie z podłączonym zasilaniem case 4:
case 5: r=1.0; g=0.0; b=0.0; break; //czerwone z podłączonym zasilaniem 1 r = 0.5;
case 6: r=0.0; g=1.0; b=0.0; break; //zielone z podłączonym zasilaniem 2 g = 0.5;
case 7: r=1.0; g=1.0; b=0.0; break; //żółte z podłączonym zasilaniem z obu stron b = 1.0;
break; // niebieskie z podłączonym zasilaniem
case 5:
r = 1.0;
g = 0.0;
b = 0.0;
break; // czerwone z podłączonym zasilaniem 1
case 6:
r = 0.0;
g = 1.0;
b = 0.0;
break; // zielone z podłączonym zasilaniem 2
case 7:
r = 1.0;
g = 1.0;
b = 0.0;
break; //żółte z podłączonym zasilaniem z obu stron
} }
if (DebugModeFlag) if (DebugModeFlag)
if (hvParallel) if (hvParallel)
{//jeśli z bieżnią wspólną, to dodatkowo przyciemniamy { // jeśli z bieżnią wspólną, to dodatkowo przyciemniamy
r*=0.6; g*=0.6; b*=0.6; r *= 0.6;
g *= 0.6;
b *= 0.6;
} }
r*=Global::ambientDayLight[0]; //w zaleźności od koloru swiatła r *= Global::ambientDayLight[0]; // w zaleźności od koloru swiatła
g*=Global::ambientDayLight[1]; g *= Global::ambientDayLight[1];
b*=Global::ambientDayLight[2]; b *= Global::ambientDayLight[2];
if (linealpha>1.0) linealpha=1.0; //trzeba ograniczyć do <=1 if (linealpha > 1.0)
glColor4f(r,g,b,linealpha); linealpha = 1.0; // trzeba ograniczyć do <=1
glColor4f(r, g, b, linealpha);
if (!uiDisplayList) if (!uiDisplayList)
Optimize(); //generowanie DL w miarę potrzeby Optimize(); // generowanie DL w miarę potrzeby
glCallList(uiDisplayList); glCallList(uiDisplayList);
glLineWidth(1.0); glLineWidth(1.0);
glEnable(GL_LINE_SMOOTH); glEnable(GL_LINE_SMOOTH);
//glEnable(GL_LIGHTING); //bez tego się modele nie oświetlają // glEnable(GL_LIGHTING); //bez tego się modele nie oświetlają
} }
} }
int __fastcall TTraction::RaArrayPrepare() int __fastcall TTraction::RaArrayPrepare()
{//przygotowanie tablic do skopiowania do VBO (zliczanie wierzchołków) { // przygotowanie tablic do skopiowania do VBO (zliczanie wierzchołków)
//if (bVisible) //o ile w ogóle widać // if (bVisible) //o ile w ogóle widać
switch (Wires) switch (Wires)
{ {
case 1: iLines=2; break; case 1:
case 2: iLines=iNumSections?4*(iNumSections)-2+2:4; break; iLines = 2;
case 3: iLines=iNumSections?4*(iNumSections)-2+4:6; break; break;
case 4: iLines=iNumSections?4*(iNumSections)-2+6:8; break; case 2:
default: iLines=0; iLines = iNumSections ? 4 * (iNumSections)-2 + 2 : 4;
break;
case 3:
iLines = iNumSections ? 4 * (iNumSections)-2 + 4 : 6;
break;
case 4:
iLines = iNumSections ? 4 * (iNumSections)-2 + 6 : 8;
break;
default:
iLines = 0;
} }
//else iLines=0; // else iLines=0;
return iLines; return iLines;
}; };
void __fastcall TTraction::RaArrayFill(CVertNormTex *Vert) void __fastcall TTraction::RaArrayFill(CVertNormTex *Vert)
{//wypełnianie tablic VBO { // wypełnianie tablic VBO
CVertNormTex *old=Vert; CVertNormTex *old = Vert;
double ddp=hypot(pPoint2.x-pPoint1.x,pPoint2.z-pPoint1.z); double ddp = hypot(pPoint2.x - pPoint1.x, pPoint2.z - pPoint1.z);
if (Wires==2) WireOffset=0; if (Wires == 2)
//jezdny WireOffset = 0;
Vert->x=pPoint1.x-(pPoint2.z/ddp-pPoint1.z/ddp)*WireOffset; // jezdny
Vert->y=pPoint1.y; Vert->x = pPoint1.x - (pPoint2.z / ddp - pPoint1.z / ddp) * WireOffset;
Vert->z=pPoint1.z-(-pPoint2.x/ddp+pPoint1.x/ddp)*WireOffset; Vert->y = pPoint1.y;
Vert->z = pPoint1.z - (-pPoint2.x / ddp + pPoint1.x / ddp) * WireOffset;
++Vert; ++Vert;
Vert->x=pPoint2.x-(pPoint2.z/ddp-pPoint1.z/ddp)*WireOffset; Vert->x = pPoint2.x - (pPoint2.z / ddp - pPoint1.z / ddp) * WireOffset;
Vert->y=pPoint2.y; Vert->y = pPoint2.y;
Vert->z=pPoint2.z-(-pPoint2.x/ddp+pPoint1.x/ddp)*WireOffset; Vert->z = pPoint2.z - (-pPoint2.x / ddp + pPoint1.x / ddp) * WireOffset;
++Vert; ++Vert;
//Nie wiem co 'Marcin // Nie wiem co 'Marcin
vector3 pt1,pt2,pt3,pt4,v1,v2; vector3 pt1, pt2, pt3, pt4, v1, v2;
v1=pPoint4-pPoint3; v1 = pPoint4 - pPoint3;
v2=pPoint2-pPoint1; v2 = pPoint2 - pPoint1;
float step=0; float step = 0;
if (iNumSections>0) if (iNumSections > 0)
step=1.0f/(float)iNumSections; step = 1.0f / (float)iNumSections;
float f=step; float f = step;
float mid=0.5; float mid = 0.5;
float t; float t;
//Przewod nosny 'Marcin // Przewod nosny 'Marcin
if (Wires>1) if (Wires > 1)
{//lina nośna w kawałkach { // lina nośna w kawałkach
Vert->x=pPoint3.x; Vert->x = pPoint3.x;
Vert->y=pPoint3.y; Vert->y = pPoint3.y;
Vert->z=pPoint3.z; Vert->z = pPoint3.z;
++Vert; ++Vert;
for (int i=0;i<iNumSections-1;i++) for (int i = 0; i < iNumSections - 1; i++)
{ {
pt3=pPoint3+v1*f; pt3 = pPoint3 + v1 * f;
t=(1-fabs(f-mid)*2); t = (1 - fabs(f - mid) * 2);
Vert->x=pt3.x; Vert->x = pt3.x;
Vert->y=pt3.y-sqrt(t)*fHeightDifference; Vert->y = pt3.y - sqrt(t) * fHeightDifference;
Vert->z=pt3.z; Vert->z = pt3.z;
++Vert; ++Vert;
Vert->x=pt3.x; //drugi raz, bo nie jest line_strip Vert->x = pt3.x; // drugi raz, bo nie jest line_strip
Vert->y=pt3.y-sqrt(t)*fHeightDifference; Vert->y = pt3.y - sqrt(t) * fHeightDifference;
Vert->z=pt3.z; Vert->z = pt3.z;
++Vert; ++Vert;
f+=step; f += step;
} }
Vert->x=pPoint4.x; Vert->x = pPoint4.x;
Vert->y=pPoint4.y; Vert->y = pPoint4.y;
Vert->z=pPoint4.z; Vert->z = pPoint4.z;
++Vert; ++Vert;
} }
//Drugi przewod jezdny 'Winger // Drugi przewod jezdny 'Winger
if (Wires==3) if (Wires == 3)
{ {
Vert->x=pPoint1.x+(pPoint2.z/ddp-pPoint1.z/ddp)*WireOffset; Vert->x = pPoint1.x + (pPoint2.z / ddp - pPoint1.z / ddp) * WireOffset;
Vert->y=pPoint1.y; Vert->y = pPoint1.y;
Vert->z=pPoint1.z+(-pPoint2.x/ddp+pPoint1.x/ddp)*WireOffset; Vert->z = pPoint1.z + (-pPoint2.x / ddp + pPoint1.x / ddp) * WireOffset;
++Vert; ++Vert;
Vert->x=pPoint2.x+(pPoint2.z/ddp-pPoint1.z/ddp)*WireOffset; Vert->x = pPoint2.x + (pPoint2.z / ddp - pPoint1.z / ddp) * WireOffset;
Vert->y=pPoint2.y; Vert->y = pPoint2.y;
Vert->z=pPoint2.z+(-pPoint2.x/ddp+pPoint1.x/ddp)*WireOffset; Vert->z = pPoint2.z + (-pPoint2.x / ddp + pPoint1.x / ddp) * WireOffset;
++Vert; ++Vert;
} }
f=step; f = step;
//Przewody pionowe (wieszaki) 'Marcin, poprawki na 2 przewody jezdne 'Winger // Przewody pionowe (wieszaki) 'Marcin, poprawki na 2 przewody jezdne 'Winger
if (Wires>1) if (Wires > 1)
{ {
for (int i=0;i<iNumSections-1;i++) for (int i = 0; i < iNumSections - 1; i++)
{ {
pt3=pPoint3+v1*f; pt3 = pPoint3 + v1 * f;
pt4=pPoint1+v2*f; pt4 = pPoint1 + v2 * f;
t=(1-fabs(f-mid)*2); t = (1 - fabs(f - mid) * 2);
Vert->x=pt3.x; Vert->x = pt3.x;
Vert->y=pt3.y-sqrt(t)*fHeightDifference; Vert->y = pt3.y - sqrt(t) * fHeightDifference;
Vert->z=pt3.z; Vert->z = pt3.z;
++Vert; ++Vert;
if ((i%2)==0) if ((i % 2) == 0)
{ {
Vert->x=pt4.x-(pPoint2.z/ddp-pPoint1.z/ddp)*WireOffset; Vert->x = pt4.x - (pPoint2.z / ddp - pPoint1.z / ddp) * WireOffset;
Vert->y=pt4.y; Vert->y = pt4.y;
Vert->z=pt4.z-(-pPoint2.x/ddp+pPoint1.x/ddp)*WireOffset; Vert->z = pt4.z - (-pPoint2.x / ddp + pPoint1.x / ddp) * WireOffset;
} }
else else
{ {
Vert->x=pt4.x+(pPoint2.z/ddp-pPoint1.z/ddp)*WireOffset; Vert->x = pt4.x + (pPoint2.z / ddp - pPoint1.z / ddp) * WireOffset;
Vert->y=pt4.y; Vert->y = pt4.y;
Vert->z=pt4.z+(-pPoint2.x/ddp+pPoint1.x/ddp)*WireOffset; Vert->z = pt4.z + (-pPoint2.x / ddp + pPoint1.x / ddp) * WireOffset;
} }
++Vert; ++Vert;
f+=step; f += step;
} }
} }
if ((Vert-old)!=iLines) if ((Vert - old) != iLines)
WriteLog("!!! Wygenerowano punktów "+AnsiString(Vert-old)+", powinno być "+AnsiString(iLines)); WriteLog("!!! Wygenerowano punktów " + AnsiString(Vert - old) + ", powinno być " +
AnsiString(iLines));
}; };
void __fastcall TTraction::RenderVBO(float mgn,int iPtr) void __fastcall TTraction::RenderVBO(float mgn, int iPtr)
{//renderowanie z użyciem VBO { // renderowanie z użyciem VBO
if (Wires!=0 && !TestFlag(DamageFlag,128)) //rysuj jesli sa druty i nie zerwana if (Wires != 0 && !TestFlag(DamageFlag, 128)) // rysuj jesli sa druty i nie zerwana
{ {
glBindTexture(GL_TEXTURE_2D,0); glBindTexture(GL_TEXTURE_2D, 0);
glDisable(GL_LIGHTING); //aby nie używało wektorów normalnych do kolorowania glDisable(GL_LIGHTING); // aby nie używało wektorów normalnych do kolorowania
glColor4f(0,0,0,1); //jak nieznany kolor to czarne nieprzezroczyste glColor4f(0, 0, 0, 1); // jak nieznany kolor to czarne nieprzezroczyste
if (!Global::bSmoothTraction) if (!Global::bSmoothTraction)
glDisable(GL_LINE_SMOOTH); //na liniach kiepsko wygląda - robi gradient glDisable(GL_LINE_SMOOTH); // na liniach kiepsko wygląda - robi gradient
float linealpha=5000*WireThickness/(mgn+1.0); //*WireThickness float linealpha = 5000 * WireThickness / (mgn + 1.0); //*WireThickness
if (linealpha>1.2) linealpha=1.2; //zbyt grube nie są dobre if (linealpha > 1.2)
linealpha = 1.2; // zbyt grube nie są dobre
glLineWidth(linealpha); glLineWidth(linealpha);
//McZapkie-261102: kolor zalezy od materialu i zasniedzenia // McZapkie-261102: kolor zalezy od materialu i zasniedzenia
float r,g,b; float r, g, b;
switch (Material) switch (Material)
{//Ra: kolory podzieliłem przez 2, bo po zmianie ambient za jasne były { // Ra: kolory podzieliłem przez 2, bo po zmianie ambient za jasne były
//trzeba uwzględnić kierunek świecenia Słońca - tylko ze Słońcem widać kolor // trzeba uwzględnić kierunek świecenia Słońca - tylko ze Słońcem widać kolor
case 1: case 1:
if (TestFlag(DamageFlag,1)) if (TestFlag(DamageFlag, 1))
{ {
r=0.00000; g=0.32549; b=0.2882353; //zielona miedź r = 0.00000;
g = 0.32549;
b = 0.2882353; // zielona miedź
} }
else else
{ {
r=0.35098; g=0.22549; b=0.1; //czerwona miedź r = 0.35098;
g = 0.22549;
b = 0.1; // czerwona miedź
} }
break; break;
case 2: case 2:
if (TestFlag(DamageFlag,1)) if (TestFlag(DamageFlag, 1))
{ {
r=0.10; g=0.10; b=0.10; //czarne Al r = 0.10;
g = 0.10;
b = 0.10; // czarne Al
} }
else else
{ {
r=0.25; g=0.25; b=0.25; //srebrne Al r = 0.25;
g = 0.25;
b = 0.25; // srebrne Al
} }
break; break;
//tymczasowo pokazanie zasilanych odcinków // tymczasowo pokazanie zasilanych odcinków
case 4: r=0.5; g=0.5; b=1.0; break; //niebieskie z podłączonym zasilaniem case 4:
case 5: r=1.0; g=0.0; b=0.0; break; //czerwone z podłączonym zasilaniem 1 r = 0.5;
case 6: r=0.0; g=1.0; b=0.0; break; //zielone z podłączonym zasilaniem 2 g = 0.5;
case 7: r=1.0; g=1.0; b=0.0; break; //żółte z podłączonym zasilaniem z obu stron b = 1.0;
break; // niebieskie z podłączonym zasilaniem
case 5:
r = 1.0;
g = 0.0;
b = 0.0;
break; // czerwone z podłączonym zasilaniem 1
case 6:
r = 0.0;
g = 1.0;
b = 0.0;
break; // zielone z podłączonym zasilaniem 2
case 7:
r = 1.0;
g = 1.0;
b = 0.0;
break; //żółte z podłączonym zasilaniem z obu stron
} }
r=r*Global::ambientDayLight[0]; //w zaleznosci od koloru swiatla r = r * Global::ambientDayLight[0]; // w zaleznosci od koloru swiatla
g=g*Global::ambientDayLight[1]; g = g * Global::ambientDayLight[1];
b=b*Global::ambientDayLight[2]; b = b * Global::ambientDayLight[2];
if (linealpha>1.0) linealpha=1.0; //trzeba ograniczyć do <=1 if (linealpha > 1.0)
glColor4f(r,g,b,linealpha); linealpha = 1.0; // trzeba ograniczyć do <=1
glDrawArrays(GL_LINES,iPtr,iLines); glColor4f(r, g, b, linealpha);
glDrawArrays(GL_LINES, iPtr, iLines);
glLineWidth(1.0); glLineWidth(1.0);
glEnable(GL_LINE_SMOOTH); glEnable(GL_LINE_SMOOTH);
glEnable(GL_LIGHTING); //bez tego się modele nie oświetlają glEnable(GL_LIGHTING); // bez tego się modele nie oświetlają
} }
}; };
int __fastcall TTraction::TestPoint(vector3 *Point) int __fastcall TTraction::TestPoint(vector3 *Point)
{//sprawdzanie, czy przęsła można połączyć { // sprawdzanie, czy przęsła można połączyć
if (!hvNext[0]) if (!hvNext[0])
if (pPoint1.Equal(Point)) if (pPoint1.Equal(Point))
return 0; return 0;
@@ -482,143 +561,156 @@ int __fastcall TTraction::TestPoint(vector3 *Point)
return -1; return -1;
}; };
void __fastcall TTraction::Connect(int my,TTraction *with,int to) void __fastcall TTraction::Connect(int my, TTraction *with, int to)
{//łączenie segmentu (with) od strony (my) do jego (to) { //łączenie segmentu (with) od strony (my) do jego (to)
if (my) if (my)
{//do mojego Point2 { // do mojego Point2
hvNext[1]=with; hvNext[1] = with;
iNext[1]=to; iNext[1] = to;
} }
else else
{//do mojego Point1 { // do mojego Point1
hvNext[0]=with; hvNext[0] = with;
iNext[0]=to; iNext[0] = to;
} }
if (to) if (to)
{//do jego Point2 { // do jego Point2
with->hvNext[1]=this; with->hvNext[1] = this;
with->iNext[1]=my; with->iNext[1] = my;
} }
else else
{//do jego Point1 { // do jego Point1
with->hvNext[0]=this; with->hvNext[0] = this;
with->iNext[0]=my; with->iNext[0] = my;
} }
if (hvNext[0]) //jeśli z obu stron podłączony if (hvNext[0]) // jeśli z obu stron podłączony
if (hvNext[1]) if (hvNext[1])
iLast=0; //to nie jest ostatnim iLast = 0; // to nie jest ostatnim
if (with->hvNext[0]) //temu też, bo drugi raz łączenie się nie nie wykona if (with->hvNext[0]) // temu też, bo drugi raz łączenie się nie nie wykona
if (with->hvNext[1]) if (with->hvNext[1])
with->iLast=0; //to nie jest ostatnim with->iLast = 0; // to nie jest ostatnim
}; };
bool __fastcall TTraction::WhereIs() bool __fastcall TTraction::WhereIs()
{//ustalenie przedostatnich przęseł { // ustalenie przedostatnich przęseł
if (iLast) return (iLast==1); //ma już ustaloną informację o położeniu if (iLast)
if (hvNext[0]?hvNext[0]->iLast==1:false) //jeśli poprzedni jest ostatnim return (iLast == 1); // ma już ustaloną informację o położeniu
iLast=2; //jest przedostatnim if (hvNext[0] ? hvNext[0]->iLast == 1 : false) // jeśli poprzedni jest ostatnim
else iLast = 2; // jest przedostatnim
if (hvNext[1]?hvNext[1]->iLast==1:false) //jeśli następny jest ostatnim else if (hvNext[1] ? hvNext[1]->iLast == 1 : false) // jeśli następny jest ostatnim
iLast=2; //jest przedostatnim iLast = 2; // jest przedostatnim
return (iLast==1); //ostatnie będą dostawać zasilanie return (iLast == 1); // ostatnie będą dostawać zasilanie
}; };
void __fastcall TTraction::Init() void __fastcall TTraction::Init()
{//przeliczenie parametrów { // przeliczenie parametrów
vParametric=pPoint2-pPoint1; //wektor mnożników parametru dla równania parametrycznego vParametric = pPoint2 - pPoint1; // wektor mnożników parametru dla równania parametrycznego
}; };
void __fastcall TTraction::ResistanceCalc(int d,double r,TTractionPowerSource *ps) void __fastcall TTraction::ResistanceCalc(int d, double r, TTractionPowerSource *ps)
{//(this) jest przęsłem zasilanym, o rezystancji (r), policzyć rezystancję zastępczą sąsiednich { //(this) jest przęsłem zasilanym, o rezystancji (r), policzyć rezystancję zastępczą sąsiednich
if (d>=0) if (d >= 0)
{//podążanie we wskazanym kierunku { // podążanie we wskazanym kierunku
TTraction *t=hvNext[d],*p; TTraction *t = hvNext[d], *p;
if (ps) if (ps)
psPower[d^1]=ps; //podłączenie podanego psPower[d ^ 1] = ps; // podłączenie podanego
else else
ps=psPower[d^1]; //zasilacz od przeciwnej strony niż idzie analiza ps = psPower[d ^ 1]; // zasilacz od przeciwnej strony niż idzie analiza
d=iNext[d]; //kierunek d = iNext[d]; // kierunek
//double r; //sumaryczna rezystancja // double r; //sumaryczna rezystancja
if (DebugModeFlag) //tylko podczas testów if (DebugModeFlag) // tylko podczas testów
Material=4; //pokazanie, że to przęsło ma podłączone zasilanie Material = 4; // pokazanie, że to przęsło ma podłączone zasilanie
while (t?!t->psPower[d]:false) //jeśli jest jakiś kolejny i nie ma ustalonego zasilacza while (t ? !t->psPower[d] : false) // jeśli jest jakiś kolejny i nie ma ustalonego zasilacza
{//ustawienie zasilacza i policzenie rezystancji zastępczej { // ustawienie zasilacza i policzenie rezystancji zastępczej
if (DebugModeFlag) //tylko podczas testów if (DebugModeFlag) // tylko podczas testów
if (t->Material!=4) //przęsła zasilającego nie modyfikować if (t->Material != 4) // przęsła zasilającego nie modyfikować
{if (t->Material<4) t->Material=4; //tymczasowo, aby zmieniła kolor {
t->Material|=d?2:1; //kolor zależny od strony, z której jest zasilanie if (t->Material < 4)
t->Material = 4; // tymczasowo, aby zmieniła kolor
t->Material |= d ? 2 : 1; // kolor zależny od strony, z której jest zasilanie
} }
t->psPower[d]=ps; //skopiowanie wskaźnika zasilacza od danej strony t->psPower[d] = ps; // skopiowanie wskaźnika zasilacza od danej strony
t->fResistance[d]=r; //wpisanie rezystancji w kierunku tego zasilacza t->fResistance[d] = r; // wpisanie rezystancji w kierunku tego zasilacza
r+=t->fResistivity*Length3(t->vParametric); //doliczenie oporu kolejnego odcinka r += t->fResistivity * Length3(t->vParametric); // doliczenie oporu kolejnego odcinka
p=t; //zapamiętanie dotychczasowego p = t; // zapamiętanie dotychczasowego
t=p->hvNext[d^1]; //podążanie w tę samą stronę t = p->hvNext[d ^ 1]; // podążanie w tę samą stronę
d=p->iNext[d^1]; d = p->iNext[d ^ 1];
//w przypadku zapętlenia sieci może się zawiesić? // w przypadku zapętlenia sieci może się zawiesić?
} }
} }
else else
{//podążanie w obu kierunkach, można by rekurencją, ale szkoda zasobów { // podążanie w obu kierunkach, można by rekurencją, ale szkoda zasobów
r=0.5*fResistivity*Length3(vParametric); //powiedzmy, że w zasilanym przęśle jest połowa r = 0.5 * fResistivity *
if (fResistance[0]==0.0) ResistanceCalc(0,r); //do tyłu (w stronę Point1) Length3(vParametric); // powiedzmy, że w zasilanym przęśle jest połowa
if (fResistance[1]==0.0) ResistanceCalc(1,r); //do przodu (w stronę Point2) if (fResistance[0] == 0.0)
ResistanceCalc(0, r); // do tyłu (w stronę Point1)
if (fResistance[1] == 0.0)
ResistanceCalc(1, r); // do przodu (w stronę Point2)
} }
}; };
void __fastcall TTraction::PowerSet(TTractionPowerSource *ps) void __fastcall TTraction::PowerSet(TTractionPowerSource *ps)
{//podłączenie przęsła do zasilacza { // podłączenie przęsła do zasilacza
if (ps->bSection) if (ps->bSection)
psSection=ps; //ustalenie sekcji zasilania psSection = ps; // ustalenie sekcji zasilania
else else
{//ustalenie punktu zasilania (nie ma jeszcze połączeń między przęsłami) { // ustalenie punktu zasilania (nie ma jeszcze połączeń między przęsłami)
psPowered=ps; //ustawienie bezpośredniego zasilania dla przęsła psPowered = ps; // ustawienie bezpośredniego zasilania dla przęsła
psPower[0]=psPower[1]=ps; //a to chyba nie jest dobry pomysł, bo nawet zasilane przęsło powinno mieć wskazania na inne psPower[0] = psPower[1] = ps; // a to chyba nie jest dobry pomysł, bo nawet zasilane przęsło
fResistance[0]=fResistance[1]=0.0; //a liczy się tylko rezystancja zasilacza // powinno mieć wskazania na inne
fResistance[0] = fResistance[1] = 0.0; // a liczy się tylko rezystancja zasilacza
} }
}; };
double __fastcall TTraction::VoltageGet(double u,double i) double __fastcall TTraction::VoltageGet(double u, double i)
{//pobranie napięcia na przęśle po podłączeniu do niego rezystancji (res) - na razie jest to prąd { // pobranie napięcia na przęśle po podłączeniu do niego rezystancji (res) - na razie jest to prąd
if (!psSection) if (!psSection)
if (!psPowered) if (!psPowered)
return NominalVoltage; //jak nie ma zasilacza, to napięcie podane w przęśle return NominalVoltage; // jak nie ma zasilacza, to napięcie podane w przęśle
//na początek można założyć, że wszystkie podstacje mają to samo napięcie i nie płynie prąd pomiędzy nimi // na początek można założyć, że wszystkie podstacje mają to samo napięcie i nie płynie prąd
//dla danego przęsła mamy 3 źródła zasilania // pomiędzy nimi
//1. zasilacz psPower[0] z rezystancją fResistance[0] oraz jego wewnętrzną // dla danego przęsła mamy 3 źródła zasilania
//2. zasilacz psPower[1] z rezystancją fResistance[1] oraz jego wewnętrzną // 1. zasilacz psPower[0] z rezystancją fResistance[0] oraz jego wewnętrzną
//3. zasilacz psPowered z jego wewnętrzną rezystancją dla przęseł zasilanych bezpośrednio // 2. zasilacz psPower[1] z rezystancją fResistance[1] oraz jego wewnętrzną
double res=(i!=0.0)?fabs(u/i):10000.0; // 3. zasilacz psPowered z jego wewnętrzną rezystancją dla przęseł zasilanych bezpośrednio
if (psPowered) return psPowered->CurrentGet(res)*res; //yB: dla zasilanego nie baw się w gwiazdy, tylko bierz bezpośrednio double res = (i != 0.0) ? fabs(u / i) : 10000.0;
double r0t,r1t,r0g,r1g; if (psPowered)
double u0,u1,i0,i1; return psPowered->CurrentGet(res) *
r0t=fResistance[0]; //średni pomysł, ale lepsze niż nic res; // yB: dla zasilanego nie baw się w gwiazdy, tylko bierz bezpośrednio
r1t=fResistance[1]; //bo nie uwzględnia spadków z innych pojazdów double r0t, r1t, r0g, r1g;
if (psPower[0]&&psPower[1]) double u0, u1, i0, i1;
{//gdy przęsło jest zasilane z obu stron - mamy trójkąt: res, r0t, r1t r0t = fResistance[0]; //średni pomysł, ale lepsze niż nic
//yB: Gdy wywali podstacja, to zaczyna się robić nieciekawie - napięcie w sekcji na jednym końcu jest równe zasilaniu, r1t = fResistance[1]; // bo nie uwzględnia spadków z innych pojazdów
//yB: a na drugim końcu jest równe 0. Kolejna sprawa to rozróżnienie uszynienia sieci na podstacji/odłączniku (czyli if (psPower[0] && psPower[1])
//yB: potencjał masy na sieci) od braku zasilania (czyli odłączenie źródła od sieci i brak jego wpływu na napięcie). { // gdy przęsło jest zasilane z obu stron - mamy trójkąt: res, r0t, r1t
if ((r0t>0.0)&&(r1t>0.0)) // yB: Gdy wywali podstacja, to zaczyna się robić nieciekawie - napięcie w sekcji na jednym
{//rezystancje w mianowniku nie mogą być zerowe // końcu jest równe zasilaniu,
r0g=res+r0t+(res*r0t)/r1t; //przeliczenie z trójkąta na gwiazdę // yB: a na drugim końcu jest równe 0. Kolejna sprawa to rozróżnienie uszynienia sieci na
r1g=res+r1t+(res*r1t)/r0t; // podstacji/odłączniku (czyli
//pobierane są prądy dla każdej rezystancji, a suma jest mnożona przez rezystancję pojazdu w celu uzyskania napięcia // yB: potencjał masy na sieci) od braku zasilania (czyli odłączenie źródła od sieci i brak
i0=psPower[0]->CurrentGet(r0g); //oddzielnie dla sprawdzenia // jego wpływu na napięcie).
i1=psPower[1]->CurrentGet(r1g); if ((r0t > 0.0) && (r1t > 0.0))
return (i0+i1)*res; { // rezystancje w mianowniku nie mogą być zerowe
r0g = res + r0t + (res * r0t) / r1t; // przeliczenie z trójkąta na gwiazdę
r1g = res + r1t + (res * r1t) / r0t;
// pobierane są prądy dla każdej rezystancji, a suma jest mnożona przez rezystancję
// pojazdu w celu uzyskania napięcia
i0 = psPower[0]->CurrentGet(r0g); // oddzielnie dla sprawdzenia
i1 = psPower[1]->CurrentGet(r1g);
return (i0 + i1) * res;
} }
else if (r0t>=0.0) else if (r0t >= 0.0)
return psPower[0]->CurrentGet(res+r0t)*res; return psPower[0]->CurrentGet(res + r0t) * res;
else if (r1t>=0.0) else if (r1t >= 0.0)
return psPower[1]->CurrentGet(res+r1t)*res; return psPower[1]->CurrentGet(res + r1t) * res;
else else
return 0.0; //co z tym zrobić? return 0.0; // co z tym zrobić?
} }
else if (psPower[0]&&(r0t>=0.0)) else if (psPower[0] && (r0t >= 0.0))
{//jeśli odcinek podłączony jest tylko z jednej strony { // jeśli odcinek podłączony jest tylko z jednej strony
return psPower[0]->CurrentGet(res+r0t)*res; return psPower[0]->CurrentGet(res + r0t) * res;
} }
else if (psPower[1]&&(r1t>=0.0)) else if (psPower[1] && (r1t >= 0.0))
return psPower[1]->CurrentGet(res+r1t)*res; return psPower[1]->CurrentGet(res + r1t) * res;
return 0.0; //gdy nie podłączony wcale? return 0.0; // gdy nie podłączony wcale?
}; };

69
Traction.h
View File

@@ -12,66 +12,69 @@ using namespace Math3D;
class TTractionPowerSource; class TTractionPowerSource;
class TTraction class TTraction
{//drut zasilaj¹cy, dla wskaŸników u¿ywaæ przedrostka "hv" { // drut zasilaj¹cy, dla wskaŸników u¿ywaæ przedrostka "hv"
private: private:
//vector3 vUp,vFront,vLeft; // vector3 vUp,vFront,vLeft;
//matrix4x4 mMatrix; // matrix4x4 mMatrix;
//matryca do wyliczania pozycji drutu w zale¿noœci od [X,Y,k¹t] w scenerii: // matryca do wyliczania pozycji drutu w zale¿noœci od [X,Y,k¹t] w scenerii:
// - x: odleg³oœæ w bok (czy odbierak siê nie zsun¹³) // - x: odleg³oœæ w bok (czy odbierak siê nie zsun¹³)
// - y: przyjmuje wartoœæ <0,1>, jeœli pod drutem (wzd³u¿) // - y: przyjmuje wartoœæ <0,1>, jeœli pod drutem (wzd³u¿)
// - z: wysokoœæ bezwzglêdna drutu w danym miejsu // - z: wysokoœæ bezwzglêdna drutu w danym miejsu
public: //na razie public: // na razie
TTractionPowerSource *psPower[2]; //najbli¿sze zasilacze z obu kierunków TTractionPowerSource *psPower[2]; // najbli¿sze zasilacze z obu kierunków
TTractionPowerSource *psPowered; //ustawione tylko dla bezpoœrednio zasilanego przês³a TTractionPowerSource *psPowered; // ustawione tylko dla bezpoœrednio zasilanego przês³a
TTraction *hvNext[2]; //³¹czenie drutów w sieæ TTraction *hvNext[2]; //³¹czenie drutów w sieæ
int iNext[2]; //do którego koñca siê ³¹czy int iNext[2]; // do którego koñca siê ³¹czy
int iLast; //ustawiony bit 0, jeœli jest ostatnim drutem w sekcji; bit1 - przedostatni int iLast; // ustawiony bit 0, jeœli jest ostatnim drutem w sekcji; bit1 - przedostatni
public: public:
GLuint uiDisplayList; GLuint uiDisplayList;
vector3 pPoint1,pPoint2,pPoint3,pPoint4; vector3 pPoint1, pPoint2, pPoint3, pPoint4;
vector3 vParametric; //wspó³czynniki równania parametrycznego odcinka vector3 vParametric; // wspó³czynniki równania parametrycznego odcinka
double fHeightDifference;//,fMiddleHeight; double fHeightDifference; //,fMiddleHeight;
//int iCategory,iMaterial,iDamageFlag; // int iCategory,iMaterial,iDamageFlag;
//float fU,fR,fMaxI,fWireThickness; // float fU,fR,fMaxI,fWireThickness;
int iNumSections; int iNumSections;
int iLines; //ilosc linii dla VBO int iLines; // ilosc linii dla VBO
float NominalVoltage; float NominalVoltage;
float MaxCurrent; float MaxCurrent;
float fResistivity; //[om/m], przeliczone z [om/km] float fResistivity; //[om/m], przeliczone z [om/km]
DWORD Material; //1: Cu, 2: Al DWORD Material; // 1: Cu, 2: Al
float WireThickness; float WireThickness;
DWORD DamageFlag; //1: zasniedziale, 128: zerwana DWORD DamageFlag; // 1: zasniedziale, 128: zerwana
int Wires; int Wires;
float WireOffset; float WireOffset;
AnsiString asPowerSupplyName; //McZapkie: nazwa podstacji trakcyjnej AnsiString asPowerSupplyName; // McZapkie: nazwa podstacji trakcyjnej
TTractionPowerSource *psSection; //zasilacz (opcjonalnie mo¿e to byæ pulpit steruj¹cy EL2 w hali!) TTractionPowerSource *
AnsiString asParallel; //nazwa przês³a, z którym mo¿e byæ bie¿nia wspólna psSection; // zasilacz (opcjonalnie mo¿e to byæ pulpit steruj¹cy EL2 w hali!)
TTraction *hvParallel; //jednokierunkowa i zapêtlona lista przêse³ ewentualnej bie¿ni wspólnej AnsiString asParallel; // nazwa przês³a, z którym mo¿e byæ bie¿nia wspólna
float fResistance[2]; //rezystancja zastêpcza do punktu zasilania (0: przês³o zasilane, <0: do policzenia) TTraction *hvParallel; // jednokierunkowa i zapêtlona lista przêse³ ewentualnej bie¿ni wspólnej
float fResistance[2]; // rezystancja zastêpcza do punktu zasilania (0: przês³o zasilane, <0: do
// policzenia)
int iTries; int iTries;
//bool bVisible; // bool bVisible;
//DWORD dwFlags; // DWORD dwFlags;
void __fastcall Optimize(); void __fastcall Optimize();
TTraction(); TTraction();
~TTraction(); ~TTraction();
// virtual void __fastcall InitCenter(vector3 Angles, vector3 pOrigin); // virtual void __fastcall InitCenter(vector3 Angles, vector3 pOrigin);
// virtual bool __fastcall Hit(double x, double z, vector3 &hitPoint, vector3 &hitDirection) { return TNode::Hit(x,z,hitPoint,hitDirection); }; // virtual bool __fastcall Hit(double x, double z, vector3 &hitPoint, vector3 &hitDirection)
// { return TNode::Hit(x,z,hitPoint,hitDirection); };
// virtual bool __fastcall Move(double dx, double dy, double dz) { return false; }; // virtual bool __fastcall Move(double dx, double dy, double dz) { return false; };
// virtual void __fastcall SelectedRender(); // virtual void __fastcall SelectedRender();
void __fastcall RenderDL(float mgn); void __fastcall RenderDL(float mgn);
int __fastcall RaArrayPrepare(); int __fastcall RaArrayPrepare();
void __fastcall RaArrayFill(CVertNormTex *Vert); void __fastcall RaArrayFill(CVertNormTex *Vert);
void __fastcall RenderVBO(float mgn,int iPtr); void __fastcall RenderVBO(float mgn, int iPtr);
int __fastcall TestPoint(vector3 *Point); int __fastcall TestPoint(vector3 *Point);
void __fastcall Connect(int my,TTraction *with,int to); void __fastcall Connect(int my, TTraction *with, int to);
void __fastcall Init(); void __fastcall Init();
bool __fastcall WhereIs(); bool __fastcall WhereIs();
void __fastcall ResistanceCalc(int d=-1,double r=0,TTractionPowerSource *ps=NULL); void __fastcall ResistanceCalc(int d = -1, double r = 0, TTractionPowerSource *ps = NULL);
void __fastcall PowerSet(TTractionPowerSource *ps); void __fastcall PowerSet(TTractionPowerSource *ps);
double __fastcall VoltageGet(double u,double i); double __fastcall VoltageGet(double u, double i);
}; };
//--------------------------------------------------------------------------- //---------------------------------------------------------------------------
#endif #endif

171
TractionPower.cpp
View File

@@ -6,7 +6,6 @@
*/ */
#include "system.hpp" #include "system.hpp"
#include "classes.hpp" #include "classes.hpp"
#pragma hdrstop #pragma hdrstop
@@ -24,131 +23,137 @@
__fastcall TTractionPowerSource::TTractionPowerSource() __fastcall TTractionPowerSource::TTractionPowerSource()
{ {
NominalVoltage=0; NominalVoltage = 0;
VoltageFrequency=0; VoltageFrequency = 0;
InternalRes=0.2; InternalRes = 0.2;
MaxOutputCurrent=0; MaxOutputCurrent = 0;
FastFuseTimeOut=1; FastFuseTimeOut = 1;
FastFuseRepetition=3; FastFuseRepetition = 3;
SlowFuseTimeOut=60; SlowFuseTimeOut = 60;
Recuperation=false; Recuperation = false;
TotalAdmitance=1e-10; //10Mom - jakaœ tam up³ywnoœæ TotalAdmitance = 1e-10; // 10Mom - jakaœ tam up³ywnoœæ
TotalPreviousAdmitance=1e-10; //zero jest szkodliwe TotalPreviousAdmitance = 1e-10; // zero jest szkodliwe
OutputVoltage=0; OutputVoltage = 0;
FastFuse=false; FastFuse = false;
SlowFuse=false; SlowFuse = false;
FuseTimer=0; FuseTimer = 0;
FuseCounter=0; FuseCounter = 0;
psNode[0]=NULL; //sekcje zostan¹ pod³¹czone do zasilaczy psNode[0] = NULL; // sekcje zostan¹ pod³¹czone do zasilaczy
psNode[1]=NULL; psNode[1] = NULL;
bSection=false; //sekcja nie jest Ÿród³em zasilania, tylko grupuje przês³a bSection = false; // sekcja nie jest Ÿród³em zasilania, tylko grupuje przês³a
}; };
__fastcall TTractionPowerSource::~TTractionPowerSource() __fastcall TTractionPowerSource::~TTractionPowerSource(){};
{
};
void __fastcall TTractionPowerSource::Init(double u,double i) void __fastcall TTractionPowerSource::Init(double u, double i)
{//ustawianie zasilacza przy braku w scenerii { // ustawianie zasilacza przy braku w scenerii
NominalVoltage=u; NominalVoltage = u;
VoltageFrequency=0; VoltageFrequency = 0;
MaxOutputCurrent=i; MaxOutputCurrent = i;
}; };
bool __fastcall TTractionPowerSource::Load(cParser *parser) bool __fastcall TTractionPowerSource::Load(cParser *parser)
{ {
std::string token; std::string token;
//AnsiString str; // AnsiString str;
//str= Parser->GetNextSymbol()LowerCase(); // str= Parser->GetNextSymbol()LowerCase();
//asName= str; // asName= str;
parser->getTokens(5); parser->getTokens(5);
*parser >> NominalVoltage >> VoltageFrequency >> InternalRes >> MaxOutputCurrent >> FastFuseTimeOut; *parser >> NominalVoltage >> VoltageFrequency >> InternalRes >> MaxOutputCurrent >>
FastFuseTimeOut;
parser->getTokens(); parser->getTokens();
*parser >> FastFuseRepetition; *parser >> FastFuseRepetition;
parser->getTokens(); parser->getTokens();
*parser >> SlowFuseTimeOut; *parser >> SlowFuseTimeOut;
parser->getTokens(); parser->getTokens();
*parser >> token; *parser >> token;
if (token.compare("recuperation")==0) if (token.compare("recuperation") == 0)
Recuperation=true; Recuperation = true;
else if (token.compare("section")==0) //od³¹cznik sekcyjny else if (token.compare("section") == 0) // od³¹cznik sekcyjny
bSection=true; //nie jest Ÿród³em zasilania, a jedynie informuje o pr¹dzie od³¹czenia sekcji z obwodu bSection = true; // nie jest Ÿród³em zasilania, a jedynie informuje o pr¹dzie od³¹czenia
// sekcji z obwodu
parser->getTokens(); parser->getTokens();
*parser >> token; *parser >> token;
if (token.compare("end")!=0) if (token.compare("end") != 0)
Error("tractionpowersource end statement missing"); Error("tractionpowersource end statement missing");
//if (!bSection) //od³¹cznik sekcji zasadniczo nie ma impedancji (0.01 jest OK) // if (!bSection) //od³¹cznik sekcji zasadniczo nie ma impedancji (0.01 jest OK)
if (InternalRes<0.1) //coœ ma³a ta rezystancja by³a... if (InternalRes < 0.1) // coœ ma³a ta rezystancja by³a...
InternalRes=0.2; //tak oko³o 0.2, wg http://www.ikolej.pl/fileadmin/user_upload/Seminaria_IK/13_05_07_Prezentacja_Kruczek.pdf InternalRes =
0.2; // tak oko³o 0.2, wg
// http://www.ikolej.pl/fileadmin/user_upload/Seminaria_IK/13_05_07_Prezentacja_Kruczek.pdf
return true; return true;
}; };
bool __fastcall TTractionPowerSource::Render() { return true; };
bool __fastcall TTractionPowerSource::Render()
{
return true;
};
bool __fastcall TTractionPowerSource::Update(double dt) bool __fastcall TTractionPowerSource::Update(double dt)
{//powinno byæ wykonane raz na krok fizyki { // powinno byæ wykonane raz na krok fizyki
if (NominalVoltage*TotalPreviousAdmitance>MaxOutputCurrent) //iloczyn napiêcia i admitancji daje pr¹d if (NominalVoltage * TotalPreviousAdmitance >
MaxOutputCurrent) // iloczyn napiêcia i admitancji daje pr¹d
{ {
FastFuse=true; FastFuse = true;
FuseCounter+=1; FuseCounter += 1;
if (FuseCounter>FastFuseRepetition) if (FuseCounter > FastFuseRepetition)
{SlowFuse=true; {
ErrorLog("Power overload: \""+gMyNode->asName+"\" disabled for "+AnsiString(SlowFuseTimeOut)+"s"); SlowFuse = true;
ErrorLog("Power overload: \"" + gMyNode->asName + "\" disabled for " +
AnsiString(SlowFuseTimeOut) + "s");
} }
else else
ErrorLog("Power overload: \""+gMyNode->asName+"\" disabled for "+AnsiString(FastFuseTimeOut)+"s"); ErrorLog("Power overload: \"" + gMyNode->asName + "\" disabled for " +
FuseTimer=0; AnsiString(FastFuseTimeOut) + "s");
FuseTimer = 0;
} }
if (FastFuse||SlowFuse) if (FastFuse || SlowFuse)
{//jeœli któryœ z bezpieczników zadzia³a³ { // jeœli któryœ z bezpieczników zadzia³a³
TotalAdmitance=0; TotalAdmitance = 0;
FuseTimer+=dt; FuseTimer += dt;
if (!SlowFuse) if (!SlowFuse)
{//gdy szybki, odczekaæ krótko i za³¹czyæ { // gdy szybki, odczekaæ krótko i za³¹czyæ
if (FuseTimer>FastFuseTimeOut) if (FuseTimer > FastFuseTimeOut)
FastFuse=false; FastFuse = false;
} }
else else if (FuseTimer > SlowFuseTimeOut)
if (FuseTimer>SlowFuseTimeOut) {
{SlowFuse=false; SlowFuse = false;
FuseCounter=0; //dajemy znów szansê FuseCounter = 0; // dajemy znów szansê
} }
} }
TotalPreviousAdmitance=TotalAdmitance; //u¿ywamy admitancji z poprzedniego kroku TotalPreviousAdmitance = TotalAdmitance; // u¿ywamy admitancji z poprzedniego kroku
if (TotalPreviousAdmitance==0.0) if (TotalPreviousAdmitance == 0.0)
TotalPreviousAdmitance=1e-10; //przynajmniej minimalna up³ywnoœæ TotalPreviousAdmitance = 1e-10; // przynajmniej minimalna up³ywnoœæ
TotalAdmitance=1e-10; //a w aktualnym kroku sumujemy admitancjê TotalAdmitance = 1e-10; // a w aktualnym kroku sumujemy admitancjê
return true; return true;
}; };
double __fastcall TTractionPowerSource::CurrentGet(double res) double __fastcall TTractionPowerSource::CurrentGet(double res)
{//pobranie wartoœci pr¹du przypadaj¹cego na rezystancjê (res) { // pobranie wartoœci pr¹du przypadaj¹cego na rezystancjê (res)
//niech pamiêta poprzedni¹ admitancjê i wg niej przydziela pr¹d // niech pamiêta poprzedni¹ admitancjê i wg niej przydziela pr¹d
if (SlowFuse||FastFuse) if (SlowFuse || FastFuse)
{//czekanie na zanik obci¹¿enia sekcji { // czekanie na zanik obci¹¿enia sekcji
if (res<100.0) //liczenie czasu dopiero, gdy obci¹¿enie zniknie if (res < 100.0) // liczenie czasu dopiero, gdy obci¹¿enie zniknie
FuseTimer=0; FuseTimer = 0;
return 0; return 0;
} }
if ((res>0)||((res<0)&&(Recuperation))) if ((res > 0) || ((res < 0) && (Recuperation)))
TotalAdmitance+=1.0/res; //po³¹czenie równoleg³e rezystancji jest równowa¿ne sumie admitancji TotalAdmitance +=
TotalCurrent=(TotalPreviousAdmitance!=0.0)?NominalVoltage/(InternalRes+1.0/TotalPreviousAdmitance):0.0; //napiêcie dzielone przez sumê rezystancji wewnêtrznej i obci¹¿enia 1.0 / res; // po³¹czenie równoleg³e rezystancji jest równowa¿ne sumie admitancji
OutputVoltage=NominalVoltage-InternalRes*TotalCurrent; //napiêcie na obci¹¿eniu TotalCurrent = (TotalPreviousAdmitance != 0.0) ?
return TotalCurrent/(res*TotalPreviousAdmitance); //pr¹d proporcjonalny do udzia³u (1/res) w ca³kowitej admitancji NominalVoltage / (InternalRes + 1.0 / TotalPreviousAdmitance) :
0.0; // napiêcie dzielone przez sumê rezystancji wewnêtrznej i obci¹¿enia
OutputVoltage = NominalVoltage - InternalRes * TotalCurrent; // napiêcie na obci¹¿eniu
return TotalCurrent / (res * TotalPreviousAdmitance); // pr¹d proporcjonalny do udzia³u (1/res)
// w ca³kowitej admitancji
}; };
void __fastcall TTractionPowerSource::PowerSet(TTractionPowerSource *ps) void __fastcall TTractionPowerSource::PowerSet(TTractionPowerSource *ps)
{//wskazanie zasilacza w obiekcie sekcji { // wskazanie zasilacza w obiekcie sekcji
if (!psNode[0]) if (!psNode[0])
psNode[0]=ps; psNode[0] = ps;
else if (!psNode[1]) else if (!psNode[1])
psNode[1]=ps; psNode[1] = ps;
//else ErrorLog("nie mo¿e byæ wiêcej punktów zasilania ni¿ dwa"); // else ErrorLog("nie mo¿e byæ wiêcej punktów zasilania ni¿ dwa");
}; };
//--------------------------------------------------------------------------- //---------------------------------------------------------------------------

20
TractionPower.h
View File

@@ -8,7 +8,7 @@ class TGroundNode;
class TTractionPowerSource class TTractionPowerSource
{ {
private: private:
double NominalVoltage; double NominalVoltage;
double VoltageFrequency; double VoltageFrequency;
double InternalRes; double InternalRes;
@@ -26,22 +26,22 @@ private:
bool SlowFuse; bool SlowFuse;
double FuseTimer; double FuseTimer;
int FuseCounter; int FuseCounter;
protected:
public: //zmienne publiczne protected:
TTractionPowerSource *psNode[2]; //zasilanie na koñcach dla sekcji public: // zmienne publiczne
bool bSection; //czy jest sekcj¹ TTractionPowerSource *psNode[2]; // zasilanie na koñcach dla sekcji
TGroundNode *gMyNode; //Ra 2015-03: znowu prowizorka, aby mieæ nazwê do logowania bool bSection; // czy jest sekcj¹
public: TGroundNode *gMyNode; // Ra 2015-03: znowu prowizorka, aby mieæ nazwê do logowania
//AnsiString asName; public:
// AnsiString asName;
__fastcall TTractionPowerSource(); __fastcall TTractionPowerSource();
__fastcall ~TTractionPowerSource(); __fastcall ~TTractionPowerSource();
void __fastcall Init(double u,double i); void __fastcall Init(double u, double i);
bool __fastcall Load(cParser *parser); bool __fastcall Load(cParser *parser);
bool __fastcall Render(); bool __fastcall Render();
bool __fastcall Update(double dt); bool __fastcall Update(double dt);
double __fastcall CurrentGet(double res); double __fastcall CurrentGet(double res);
void __fastcall VoltageSet(double v) {NominalVoltage=v;}; void __fastcall VoltageSet(double v) { NominalVoltage = v; };
void __fastcall PowerSet(TTractionPowerSource *ps); void __fastcall PowerSet(TTractionPowerSource *ps);
}; };

5134
Train.cpp
View File

File diff suppressed because it is too large Load Diff

280
Train.h
View File

@@ -17,106 +17,105 @@
#include "RealSound.h" #include "RealSound.h"
#include "FadeSound.h" #include "FadeSound.h"
// typedef enum {st_Off, st_Starting, st_On, st_ShuttingDown} T4State; // typedef enum {st_Off, st_Starting, st_On, st_ShuttingDown} T4State;
const int maxcab=2; const int maxcab = 2;
// const double fCzuwakTime= 90.0f; // const double fCzuwakTime= 90.0f;
const double fCzuwakBlink=0.15; const double fCzuwakBlink = 0.15;
const float fConverterPrzekaznik=1.5; //hunter-261211: do przekaznika nadmiarowego przetwornicy const float fConverterPrzekaznik = 1.5; // hunter-261211: do przekaznika nadmiarowego przetwornicy
//0.33f // 0.33f
// const double fBuzzerTime= 5.0f; // const double fBuzzerTime= 5.0f;
const float fHaslerTime=1.2; const float fHaslerTime = 1.2;
// const double fStycznTime= 0.5f; // const double fStycznTime= 0.5f;
// const double fDblClickTime= 0.2f; // const double fDblClickTime= 0.2f;
class TCab class TCab
{ {
public: public:
__fastcall TCab(); __fastcall TCab();
__fastcall ~TCab(); __fastcall ~TCab();
void __fastcall Init(double Initx1,double Inity1,double Initz1,double Initx2,double Inity2,double Initz2,bool InitEnabled,bool InitOccupied); void __fastcall Init(double Initx1, double Inity1, double Initz1, double Initx2, double Inity2,
double Initz2, bool InitEnabled, bool InitOccupied);
void __fastcall Load(TQueryParserComp *Parser); void __fastcall Load(TQueryParserComp *Parser);
vector3 CabPos1; vector3 CabPos1;
vector3 CabPos2; vector3 CabPos2;
bool bEnabled; bool bEnabled;
bool bOccupied; bool bOccupied;
double dimm_r, dimm_g, dimm_b; //McZapkie-120503: tlumienie swiatla double dimm_r, dimm_g, dimm_b; // McZapkie-120503: tlumienie swiatla
double intlit_r, intlit_g, intlit_b; //McZapkie-120503: oswietlenie kabiny double intlit_r, intlit_g, intlit_b; // McZapkie-120503: oswietlenie kabiny
double intlitlow_r, intlitlow_g, intlitlow_b; //McZapkie-120503: przyciemnione oswietlenie kabiny double intlitlow_r, intlitlow_g,
private: intlitlow_b; // McZapkie-120503: przyciemnione oswietlenie kabiny
//bool bChangePossible; private:
TGauge *ggList; //Ra 2014-08: lista animacji macierzowych (ga³ek) w kabinie // bool bChangePossible;
int iGaugesMax,iGauges; //ile miejsca w tablicy i ile jest w u¿yciu TGauge *ggList; // Ra 2014-08: lista animacji macierzowych (ga³ek) w kabinie
TButton *btList; //Ra 2014-08: lista animacji dwustanowych (lampek) w kabinie int iGaugesMax, iGauges; // ile miejsca w tablicy i ile jest w u¿yciu
int iButtonsMax,iButtons; //ile miejsca w tablicy i ile jest w u¿yciu TButton *btList; // Ra 2014-08: lista animacji dwustanowych (lampek) w kabinie
public: int iButtonsMax, iButtons; // ile miejsca w tablicy i ile jest w u¿yciu
TGauge* __fastcall Gauge(int n=-1); //pobranie adresu obiektu public:
TButton* __fastcall Button(int n=-1); //pobranie adresu obiektu TGauge *__fastcall Gauge(int n = -1); // pobranie adresu obiektu
TButton *__fastcall Button(int n = -1); // pobranie adresu obiektu
void __fastcall Update(); void __fastcall Update();
}; };
class TTrain class TTrain
{ {
public: public:
bool CabChange(int iDirection); bool CabChange(int iDirection);
bool ActiveUniversal4; bool ActiveUniversal4;
bool ShowNextCurrent; //pokaz przd w podlaczonej lokomotywie (ET41) bool ShowNextCurrent; // pokaz przd w podlaczonej lokomotywie (ET41)
bool InitializeCab(int NewCabNo, AnsiString asFileName); bool InitializeCab(int NewCabNo, AnsiString asFileName);
__fastcall TTrain(); __fastcall TTrain();
__fastcall ~TTrain(); __fastcall ~TTrain();
// bool __fastcall Init(TTrack *Track); // bool __fastcall Init(TTrack *Track);
//McZapkie-010302 // McZapkie-010302
bool __fastcall Init(TDynamicObject *NewDynamicObject,bool e3d=false); bool __fastcall Init(TDynamicObject *NewDynamicObject, bool e3d = false);
void __fastcall OnKeyDown(int cKey); void __fastcall OnKeyDown(int cKey);
void __fastcall OnKeyUp(int cKey); void __fastcall OnKeyUp(int cKey);
// bool __fastcall SHP() { fShpTimer= 0; }; // bool __fastcall SHP() { fShpTimer= 0; };
inline vector3 __fastcall GetDirection() { return DynamicObject->VectorFront(); }; inline vector3 __fastcall GetDirection() { return DynamicObject->VectorFront(); };
inline vector3 __fastcall GetUp() { return DynamicObject->VectorUp(); }; inline vector3 __fastcall GetUp() { return DynamicObject->VectorUp(); };
void __fastcall UpdateMechPosition(double dt); void __fastcall UpdateMechPosition(double dt);
bool __fastcall Update(); bool __fastcall Update();
void __fastcall MechStop(); void __fastcall MechStop();
// virtual bool __fastcall RenderAlpha(); // virtual bool __fastcall RenderAlpha();
//McZapkie-310302: ladowanie parametrow z pliku // McZapkie-310302: ladowanie parametrow z pliku
bool __fastcall LoadMMediaFile(AnsiString asFileName); bool __fastcall LoadMMediaFile(AnsiString asFileName);
private: //¿eby go nic z zewn¹trz nie przestawia³o private: //¿eby go nic z zewn¹trz nie przestawia³o
TDynamicObject *DynamicObject; //przestawia zmiana pojazdu [F5] TDynamicObject *DynamicObject; // przestawia zmiana pojazdu [F5]
private: //¿eby go nic z zewn¹trz nie przestawia³o private: //¿eby go nic z zewn¹trz nie przestawia³o
TMoverParameters *mvControlled; //cz³on, w którym sterujemy silnikiem TMoverParameters *mvControlled; // cz³on, w którym sterujemy silnikiem
TMoverParameters *mvOccupied; //cz³on, w którym sterujemy hamulcem TMoverParameters *mvOccupied; // cz³on, w którym sterujemy hamulcem
TMoverParameters *mvSecond; //drugi cz³on (ET40, ET41, ET42, ukrotnienia) TMoverParameters *mvSecond; // drugi cz³on (ET40, ET41, ET42, ukrotnienia)
TMoverParameters *mvThird; //trzeci cz³on (SN61) TMoverParameters *mvThird; // trzeci cz³on (SN61)
public: //reszta mo¿e byæ publiczna public: // reszta mo¿e byæ publiczna
// AnsiString asMessage;
//AnsiString asMessage; // McZapkie: definicje wskaŸników
// Ra 2014-08: czêsciowo przeniesione do tablicy w TCab
//McZapkie: definicje wskaŸników
//Ra 2014-08: czêsciowo przeniesione do tablicy w TCab
TGauge ggZbS; TGauge ggZbS;
TGauge ggClockSInd; TGauge ggClockSInd;
TGauge ggClockMInd; TGauge ggClockMInd;
TGauge ggClockHInd; TGauge ggClockHInd;
//TGauge ggHVoltage; // TGauge ggHVoltage;
TGauge ggLVoltage; TGauge ggLVoltage;
//TGauge ggEnrot1m; // TGauge ggEnrot1m;
//TGauge ggEnrot2m; // TGauge ggEnrot2m;
//TGauge ggEnrot3m; // TGauge ggEnrot3m;
//TGauge ggEngageRatio; // TGauge ggEngageRatio;
TGauge ggMainGearStatus; TGauge ggMainGearStatus;
TGauge ggEngineVoltage; TGauge ggEngineVoltage;
TGauge ggI1B; //drugi cz³on w postaci jawnej TGauge ggI1B; // drugi cz³on w postaci jawnej
TGauge ggI2B; TGauge ggI2B;
TGauge ggI3B; TGauge ggI3B;
TGauge ggItotalB; TGauge ggItotalB;
//McZapkie: definicje regulatorow // McZapkie: definicje regulatorow
TGauge ggMainCtrl; TGauge ggMainCtrl;
TGauge ggMainCtrlAct; TGauge ggMainCtrlAct;
TGauge ggScndCtrl; TGauge ggScndCtrl;
@@ -125,20 +124,21 @@ public: //reszta mo
TGauge ggBrakeCtrl; TGauge ggBrakeCtrl;
TGauge ggLocalBrake; TGauge ggLocalBrake;
TGauge ggManualBrake; TGauge ggManualBrake;
TGauge ggBrakeProfileCtrl; //nastawiacz GPR - przelacznik obrotowy TGauge ggBrakeProfileCtrl; // nastawiacz GPR - przelacznik obrotowy
TGauge ggBrakeProfileG; //nastawiacz GP - hebelek towarowy TGauge ggBrakeProfileG; // nastawiacz GP - hebelek towarowy
TGauge ggBrakeProfileR; //nastawiacz PR - hamowanie dwustopniowe TGauge ggBrakeProfileR; // nastawiacz PR - hamowanie dwustopniowe
TGauge ggMaxCurrentCtrl; TGauge ggMaxCurrentCtrl;
TGauge ggMainOffButton; TGauge ggMainOffButton;
TGauge ggMainOnButton; TGauge ggMainOnButton;
TGauge ggMainButton; //EZT TGauge ggMainButton; // EZT
TGauge ggSecurityResetButton; TGauge ggSecurityResetButton;
TGauge ggReleaserButton; TGauge ggReleaserButton;
TGauge ggAntiSlipButton; TGauge ggAntiSlipButton;
TGauge ggFuseButton; TGauge ggFuseButton;
TGauge ggConverterFuseButton; //hunter-261211: przycisk odblokowania nadmiarowego przetwornic i ogrzewania TGauge ggConverterFuseButton; // hunter-261211: przycisk odblokowania nadmiarowego przetwornic i
// ogrzewania
TGauge ggStLinOffButton; TGauge ggStLinOffButton;
TGauge ggRadioButton; TGauge ggRadioButton;
TGauge ggUpperLightButton; TGauge ggUpperLightButton;
@@ -147,7 +147,7 @@ public: //reszta mo
TGauge ggLeftEndLightButton; TGauge ggLeftEndLightButton;
TGauge ggRightEndLightButton; TGauge ggRightEndLightButton;
//hunter-230112: przelacznik swiatel tylnich // hunter-230112: przelacznik swiatel tylnich
TGauge ggRearUpperLightButton; TGauge ggRearUpperLightButton;
TGauge ggRearLeftLightButton; TGauge ggRearLeftLightButton;
TGauge ggRearRightLightButton; TGauge ggRearRightLightButton;
@@ -160,35 +160,35 @@ public: //reszta mo
TGauge ggConverterButton; TGauge ggConverterButton;
TGauge ggConverterOffButton; TGauge ggConverterOffButton;
//ABu 090305 - syrena i prad nastepnego czlonu // ABu 090305 - syrena i prad nastepnego czlonu
TGauge ggHornButton; TGauge ggHornButton;
TGauge ggNextCurrentButton; TGauge ggNextCurrentButton;
//ABu 090305 - uniwersalne przyciski // ABu 090305 - uniwersalne przyciski
TGauge ggUniversal1Button; TGauge ggUniversal1Button;
TGauge ggUniversal2Button; TGauge ggUniversal2Button;
TGauge ggUniversal3Button; TGauge ggUniversal3Button;
TGauge ggUniversal4Button; TGauge ggUniversal4Button;
TGauge ggCabLightButton; //hunter-091012: przelacznik oswietlania kabiny TGauge ggCabLightButton; // hunter-091012: przelacznik oswietlania kabiny
TGauge ggCabLightDimButton; //hunter-091012: przelacznik przyciemnienia oswietlenia kabiny TGauge ggCabLightDimButton; // hunter-091012: przelacznik przyciemnienia oswietlenia kabiny
//NBMX wrzesien 2003 - obsluga drzwi // NBMX wrzesien 2003 - obsluga drzwi
TGauge ggDoorLeftButton; TGauge ggDoorLeftButton;
TGauge ggDoorRightButton; TGauge ggDoorRightButton;
TGauge ggDepartureSignalButton; TGauge ggDepartureSignalButton;
//Winger 160204 - obsluga pantografow - ZROBIC // Winger 160204 - obsluga pantografow - ZROBIC
TGauge ggPantFrontButton; TGauge ggPantFrontButton;
TGauge ggPantRearButton; TGauge ggPantRearButton;
TGauge ggPantFrontButtonOff; //EZT TGauge ggPantFrontButtonOff; // EZT
TGauge ggPantAllDownButton; TGauge ggPantAllDownButton;
//Winger 020304 - wlacznik ogrzewania // Winger 020304 - wlacznik ogrzewania
TGauge ggTrainHeatingButton; TGauge ggTrainHeatingButton;
TGauge ggSignallingButton; TGauge ggSignallingButton;
TGauge ggDoorSignallingButton; TGauge ggDoorSignallingButton;
// TModel3d *mdKabina; McZapkie-030303: to do dynobj // TModel3d *mdKabina; McZapkie-030303: to do dynobj
//TGauge ggDistCounter; //Ra 2014-07: licznik kilometrów // TGauge ggDistCounter; //Ra 2014-07: licznik kilometrów
//TGauge ggVelocityDgt; //i od razu prêdkoœciomierz // TGauge ggVelocityDgt; //i od razu prêdkoœciomierz
TButton btLampkaPoslizg; TButton btLampkaPoslizg;
TButton btLampkaStyczn; TButton btLampkaStyczn;
@@ -200,13 +200,13 @@ public: //reszta mo
TButton btLampkaWylSzybki; TButton btLampkaWylSzybki;
TButton btLampkaNadmWent; TButton btLampkaNadmWent;
TButton btLampkaNadmSpr; TButton btLampkaNadmSpr;
//yB: drugie lampki dla EP05 i ET42 // yB: drugie lampki dla EP05 i ET42
TButton btLampkaOporyB; TButton btLampkaOporyB;
TButton btLampkaStycznB; TButton btLampkaStycznB;
TButton btLampkaWylSzybkiB; TButton btLampkaWylSzybkiB;
TButton btLampkaNadmPrzetwB; TButton btLampkaNadmPrzetwB;
TButton btLampkaPrzetwB; TButton btLampkaPrzetwB;
//KURS90 lampki jazdy bezoporowej dla EU04 // KURS90 lampki jazdy bezoporowej dla EU04
TButton btLampkaBezoporowaB; TButton btLampkaBezoporowaB;
TButton btLampkaBezoporowa; TButton btLampkaBezoporowa;
TButton btLampkaUkrotnienie; TButton btLampkaUkrotnienie;
@@ -214,18 +214,18 @@ public: //reszta mo
TButton btLampkaRadio; TButton btLampkaRadio;
TButton btLampkaHamowanie1zes; TButton btLampkaHamowanie1zes;
TButton btLampkaHamowanie2zes; TButton btLampkaHamowanie2zes;
// TButton btLampkaUnknown; // TButton btLampkaUnknown;
TButton btLampkaOpory; TButton btLampkaOpory;
TButton btLampkaWysRozr; TButton btLampkaWysRozr;
TButton btLampkaUniversal3; TButton btLampkaUniversal3;
int LampkaUniversal3_typ; //ABu 030405 - swiecenie uzaleznione od: 0-nic, 1-obw.gl, 2-przetw. int LampkaUniversal3_typ; // ABu 030405 - swiecenie uzaleznione od: 0-nic, 1-obw.gl, 2-przetw.
bool LampkaUniversal3_st; bool LampkaUniversal3_st;
TButton btLampkaWentZaluzje; //ET22 TButton btLampkaWentZaluzje; // ET22
TButton btLampkaOgrzewanieSkladu; TButton btLampkaOgrzewanieSkladu;
TButton btLampkaSHP; TButton btLampkaSHP;
TButton btLampkaCzuwaka; //McZapkie-141102 TButton btLampkaCzuwaka; // McZapkie-141102
TButton btLampkaRezerwa; TButton btLampkaRezerwa;
//youBy - jakies dodatkowe lampki // youBy - jakies dodatkowe lampki
TButton btLampkaNapNastHam; TButton btLampkaNapNastHam;
TButton btLampkaSprezarka; TButton btLampkaSprezarka;
TButton btLampkaSprezarkaB; TButton btLampkaSprezarkaB;
@@ -235,39 +235,39 @@ public: //reszta mo
TButton btLampkaBocznik4; TButton btLampkaBocznik4;
TButton btLampkaRadiotelefon; TButton btLampkaRadiotelefon;
TButton btLampkaHamienie; TButton btLampkaHamienie;
TButton btLampkaJazda; //Ra: nie u¿ywane TButton btLampkaJazda; // Ra: nie u¿ywane
//KURS90 // KURS90
TButton btLampkaBoczniki; TButton btLampkaBoczniki;
TButton btLampkaMaxSila; TButton btLampkaMaxSila;
TButton btLampkaPrzekrMaxSila; TButton btLampkaPrzekrMaxSila;
// TButton bt; // TButton bt;
// //
TButton btLampkaDoorLeft; TButton btLampkaDoorLeft;
TButton btLampkaDoorRight; TButton btLampkaDoorRight;
TButton btLampkaDepartureSignal; TButton btLampkaDepartureSignal;
TButton btLampkaBlokadaDrzwi; TButton btLampkaBlokadaDrzwi;
TButton btLampkaHamulecReczny; TButton btLampkaHamulecReczny;
TButton btLampkaForward; //Ra: lampki w przód i w ty³ dla komputerowych kabin TButton btLampkaForward; // Ra: lampki w przód i w ty³ dla komputerowych kabin
TButton btLampkaBackward; TButton btLampkaBackward;
TButton btCabLight; //hunter-171012: lampa oswietlajaca kabine TButton btCabLight; // hunter-171012: lampa oswietlajaca kabine
//Ra 2013-12: wirtualne "lampki" do odbijania na haslerze w PoKeys // Ra 2013-12: wirtualne "lampki" do odbijania na haslerze w PoKeys
TButton btHaslerBrakes; //ciœnienie w cylindrach TButton btHaslerBrakes; // ciœnienie w cylindrach
TButton btHaslerCurrent; //pr¹d na silnikach TButton btHaslerCurrent; // pr¹d na silnikach
vector3 pPosition; vector3 pPosition;
vector3 pMechOffset; //driverNpos vector3 pMechOffset; // driverNpos
vector3 vMechMovement; vector3 vMechMovement;
vector3 pMechPosition; vector3 pMechPosition;
vector3 pMechShake; vector3 pMechShake;
vector3 vMechVelocity; vector3 vMechVelocity;
//McZapkie: do poruszania sie po kabinie // McZapkie: do poruszania sie po kabinie
double fMechCroach; double fMechCroach;
//McZapkie: opis kabiny - obszar poruszania sie mechanika oraz zajetosc // McZapkie: opis kabiny - obszar poruszania sie mechanika oraz zajetosc
TCab Cabine[maxcab+1]; //przedzial maszynowy, kabina 1 (A), kabina 2 (B) TCab Cabine[maxcab + 1]; // przedzial maszynowy, kabina 1 (A), kabina 2 (B)
int iCabn; int iCabn;
TSpring MechSpring; TSpring MechSpring;
double fMechSpringX; //McZapkie-250303: parametry bujania double fMechSpringX; // McZapkie-250303: parametry bujania
double fMechSpringY; double fMechSpringY;
double fMechSpringZ; double fMechSpringZ;
double fMechMaxSpring; double fMechMaxSpring;
@@ -275,40 +275,39 @@ public: //reszta mo
double fMechPitch; double fMechPitch;
PSound dsbNastawnikJazdy; PSound dsbNastawnikJazdy;
PSound dsbNastawnikBocz; //hunter-081211 PSound dsbNastawnikBocz; // hunter-081211
PSound dsbRelay; PSound dsbRelay;
PSound dsbPneumaticRelay; PSound dsbPneumaticRelay;
PSound dsbSwitch; PSound dsbSwitch;
PSound dsbPneumaticSwitch; PSound dsbPneumaticSwitch;
PSound dsbReverserKey; //hunter-121211 PSound dsbReverserKey; // hunter-121211
PSound dsbCouplerAttach; //Ra: w kabinie???? PSound dsbCouplerAttach; // Ra: w kabinie????
PSound dsbCouplerDetach; //Ra: w kabinie??? PSound dsbCouplerDetach; // Ra: w kabinie???
PSound dsbDieselIgnition; //Ra: w kabinie??? PSound dsbDieselIgnition; // Ra: w kabinie???
PSound dsbDoorClose; //Ra: w kabinie??? PSound dsbDoorClose; // Ra: w kabinie???
PSound dsbDoorOpen; //Ra: w kabinie??? PSound dsbDoorOpen; // Ra: w kabinie???
//Winger 010304 // Winger 010304
PSound dsbPantUp; PSound dsbPantUp;
PSound dsbPantDown; PSound dsbPantDown;
PSound dsbWejscie_na_bezoporow; PSound dsbWejscie_na_bezoporow;
PSound dsbWejscie_na_drugi_uklad; //hunter-081211: poprawka literowki PSound dsbWejscie_na_drugi_uklad; // hunter-081211: poprawka literowki
// PSound dsbHiss1;
// PSound dsbHiss1;
// PSound dsbHiss2; // PSound dsbHiss2;
//McZapkie-280302 // McZapkie-280302
TRealSound rsBrake; TRealSound rsBrake;
TRealSound rsSlippery; TRealSound rsSlippery;
TRealSound rsHiss; //upuszczanie TRealSound rsHiss; // upuszczanie
TRealSound rsHissU; //napelnianie TRealSound rsHissU; // napelnianie
TRealSound rsHissE; //nagle TRealSound rsHissE; // nagle
TRealSound rsHissX; //fala TRealSound rsHissX; // fala
TRealSound rsHissT; //czasowy TRealSound rsHissT; // czasowy
TRealSound rsSBHiss; TRealSound rsSBHiss;
TRealSound rsRunningNoise; TRealSound rsRunningNoise;
TRealSound rsEngageSlippery; TRealSound rsEngageSlippery;
@@ -316,59 +315,60 @@ public: //reszta mo
PSound dsbHasler; PSound dsbHasler;
PSound dsbBuzzer; PSound dsbBuzzer;
PSound dsbSlipAlarm; //Bombardier 011010: alarm przy poslizgu dla 181/182 PSound dsbSlipAlarm; // Bombardier 011010: alarm przy poslizgu dla 181/182
//TFadeSound sConverter; //przetwornica // TFadeSound sConverter; //przetwornica
//TFadeSound sSmallCompressor; //przetwornica // TFadeSound sSmallCompressor; //przetwornica
int iCabLightFlag; //McZapkie:120503: oswietlenie kabiny (0: wyl, 1: przyciemnione, 2: pelne) int iCabLightFlag; // McZapkie:120503: oswietlenie kabiny (0: wyl, 1: przyciemnione, 2: pelne)
bool bCabLight; //hunter-091012: czy swiatlo jest zapalone? bool bCabLight; // hunter-091012: czy swiatlo jest zapalone?
bool bCabLightDim; //hunter-091012: czy przyciemnienie kabiny jest zapalone? bool bCabLightDim; // hunter-091012: czy przyciemnienie kabiny jest zapalone?
vector3 pMechSittingPosition; //ABu 180404 vector3 pMechSittingPosition; // ABu 180404
vector3 __fastcall MirrorPosition(bool lewe); vector3 __fastcall MirrorPosition(bool lewe);
private:
//PSound dsbBuzzer; private:
// PSound dsbBuzzer;
PSound dsbCouplerStretch; PSound dsbCouplerStretch;
PSound dsbEN57_CouplerStretch; PSound dsbEN57_CouplerStretch;
PSound dsbBufferClamp; PSound dsbBufferClamp;
// TSubModel *smCzuwakShpOn; // TSubModel *smCzuwakShpOn;
// TSubModel *smCzuwakOn; // TSubModel *smCzuwakOn;
// TSubModel *smShpOn; // TSubModel *smShpOn;
// TSubModel *smCzuwakShpOff; // TSubModel *smCzuwakShpOff;
// double fCzuwakTimer; // double fCzuwakTimer;
double fBlinkTimer; double fBlinkTimer;
float fHaslerTimer; float fHaslerTimer;
float fConverterTimer; //hunter-261211: dla przekaznika float fConverterTimer; // hunter-261211: dla przekaznika
float fMainRelayTimer; //hunter-141211: zalaczanie WSa z opoznieniem float fMainRelayTimer; // hunter-141211: zalaczanie WSa z opoznieniem
float fCzuwakTestTimer; //hunter-091012: do testu czuwaka float fCzuwakTestTimer; // hunter-091012: do testu czuwaka
int CAflag; //hunter-131211: dla osobnego zbijania CA i SHP int CAflag; // hunter-131211: dla osobnego zbijania CA i SHP
double fPoslizgTimer; double fPoslizgTimer;
// double fShpTimer; // double fShpTimer;
// double fDblClickTimer; // double fDblClickTimer;
//ABu: Przeniesione do public. - Wiem, ze to nieladnie... // ABu: Przeniesione do public. - Wiem, ze to nieladnie...
//bool CabChange(int iDirection); // bool CabChange(int iDirection);
//bool InitializeCab(int NewCabNo, AnsiString asFileName); // bool InitializeCab(int NewCabNo, AnsiString asFileName);
TTrack *tor; TTrack *tor;
int keybrakecount; int keybrakecount;
//McZapkie-240302 - przyda sie do tachometru // McZapkie-240302 - przyda sie do tachometru
float fTachoVelocity; float fTachoVelocity;
float fTachoVelocityJump; //ze skakaniem float fTachoVelocityJump; // ze skakaniem
float fTachoTimer; float fTachoTimer;
float fTachoCount; float fTachoCount;
float fHVoltage; //napiêcie dla dynamicznych ga³ek float fHVoltage; // napiêcie dla dynamicznych ga³ek
float fHCurrent[4]; //pr¹dy: suma i amperomierze 1,2,3 float fHCurrent[4]; // pr¹dy: suma i amperomierze 1,2,3
float fEngine[4]; //obroty te¿ trzeba pobraæ float fEngine[4]; // obroty te¿ trzeba pobraæ
//McZapkie: do syczenia // McZapkie: do syczenia
float fPPress,fNPress; float fPPress, fNPress;
float fSPPress,fSNPress; float fSPPress, fSNPress;
int iSekunda; //Ra: sekunda aktualizacji prêdkoœci int iSekunda; // Ra: sekunda aktualizacji prêdkoœci
int iRadioChannel; //numer aktualnego kana³u radiowego int iRadioChannel; // numer aktualnego kana³u radiowego
public: public:
int __fastcall RadioChannel() {return iRadioChannel;}; int __fastcall RadioChannel() { return iRadioChannel; };
inline TDynamicObject* __fastcall Dynamic() {return DynamicObject;}; inline TDynamicObject *__fastcall Dynamic() { return DynamicObject; };
inline TMoverParameters* __fastcall Controlled() {return mvControlled;}; inline TMoverParameters *__fastcall Controlled() { return mvControlled; };
void __fastcall DynamicSet(TDynamicObject *d); void __fastcall DynamicSet(TDynamicObject *d);
void __fastcall Silence(); void __fastcall Silence();
}; };

420
TrkFoll.cpp
View File

@@ -22,63 +22,69 @@
__fastcall TTrackFollower::TTrackFollower() __fastcall TTrackFollower::TTrackFollower()
{ {
pCurrentTrack=NULL; pCurrentTrack = NULL;
pCurrentSegment=NULL; pCurrentSegment = NULL;
fCurrentDistance=0; fCurrentDistance = 0;
pPosition=vAngles=vector3(0,0,0); pPosition = vAngles = vector3(0, 0, 0);
fDirection=1; //jest przodem do Point2 fDirection = 1; // jest przodem do Point2
fOffsetH=0.0; //na starcie stoi na środku fOffsetH = 0.0; // na starcie stoi na środku
} }
__fastcall TTrackFollower::~TTrackFollower() __fastcall TTrackFollower::~TTrackFollower() {}
{
}
bool __fastcall TTrackFollower::Init(TTrack *pTrack,TDynamicObject *NewOwner,double fDir) bool __fastcall TTrackFollower::Init(TTrack *pTrack, TDynamicObject *NewOwner, double fDir)
{ {
fDirection=fDir; fDirection = fDir;
Owner=NewOwner; Owner = NewOwner;
SetCurrentTrack(pTrack,0); SetCurrentTrack(pTrack, 0);
iEventFlag=3; //na torze startowym również wykonać eventy 1/2 iEventFlag = 3; // na torze startowym również wykonać eventy 1/2
iEventallFlag=3; iEventallFlag = 3;
if ((pCurrentSegment))// && (pCurrentSegment->GetLength()<fFirstDistance)) if ((pCurrentSegment)) // && (pCurrentSegment->GetLength()<fFirstDistance))
return false; return false;
return true; return true;
} }
TTrack* __fastcall TTrackFollower::SetCurrentTrack(TTrack *pTrack,int end) TTrack *__fastcall TTrackFollower::SetCurrentTrack(TTrack *pTrack, int end)
{//przejechanie na inny odcinkek toru, z ewentualnym rozpruciem { // przejechanie na inny odcinkek toru, z ewentualnym rozpruciem
if (pTrack) if (pTrack)
switch (pTrack->eType) switch (pTrack->eType)
{case tt_Switch: //jeśli zwrotnica, to przekładamy ją, aby uzyskać dobry segment {
{int i=(end?pCurrentTrack->iNextDirection:pCurrentTrack->iPrevDirection); case tt_Switch: // jeśli zwrotnica, to przekładamy ją, aby uzyskać dobry segment
if (i>0) //jeżeli wjazd z ostrza {
pTrack->SwitchForced(i>>1,Owner); //to przełożenie zwrotnicy - rozprucie! int i = (end ? pCurrentTrack->iNextDirection : pCurrentTrack->iPrevDirection);
if (i > 0) // jeżeli wjazd z ostrza
pTrack->SwitchForced(i >> 1, Owner); // to przełożenie zwrotnicy - rozprucie!
} }
break; break;
case tt_Cross: //skrzyżowanie trzeba tymczasowo przełączyć, aby wjechać na właściwy tor case tt_Cross: // skrzyżowanie trzeba tymczasowo przełączyć, aby wjechać na właściwy tor
{iSegment=Owner->RouteWish(pTrack); //nr segmentu został ustalony podczas skanowania {
//Ra 2014-08: aby ustalić dalszą trasę, należy zapytać AI - trasa jest ustalana podczas skanowania iSegment = Owner->RouteWish(pTrack); // nr segmentu został ustalony podczas skanowania
//Ra 15-01: zapytanie AI nie wybiera segmentu - kolejny skanujący może przestawić // Ra 2014-08: aby ustalić dalszą trasę, należy zapytać AI - trasa jest ustalana podczas
//pTrack->CrossSegment(end?pCurrentTrack->iNextDirection:pCurrentTrack->iPrevDirection,i); //ustawienie właściwego wskaźnika // skanowania
//powinno zwracać kierunek do zapamiętania, bo segmenty mogą mieć różny kierunek // Ra 15-01: zapytanie AI nie wybiera segmentu - kolejny skanujący może przestawić
//if fDirection=(iSegment>0)?1.0:-1.0; //kierunek na tym segmencie jest ustalany bezpośrednio // pTrack->CrossSegment(end?pCurrentTrack->iNextDirection:pCurrentTrack->iPrevDirection,i);
if (iSegment==0) // //ustawienie właściwego wskaźnika
{//to jest błędna sytuacja - generuje pętle zawracające za skrzyżowaniem - ustalić, kiedy powstaje! // powinno zwracać kierunek do zapamiętania, bo segmenty mogą mieć różny kierunek
iSegment=1; //doraźna poprawka // if fDirection=(iSegment>0)?1.0:-1.0; //kierunek na tym segmencie jest ustalany
// bezpośrednio
if (iSegment == 0)
{ // to jest błędna sytuacja - generuje pętle zawracające za skrzyżowaniem - ustalić,
// kiedy powstaje!
iSegment = 1; // doraźna poprawka
} }
if ((end?iSegment:-iSegment)<0) if ((end ? iSegment : -iSegment) < 0)
fDirection=-fDirection; //wtórna zmiana fDirection = -fDirection; // wtórna zmiana
pTrack->SwitchForced(abs(iSegment)-1,NULL); //wybór zapamiętanego segmentu pTrack->SwitchForced(abs(iSegment) - 1, NULL); // wybór zapamiętanego segmentu
} }
break; break;
} }
if (!pTrack) if (!pTrack)
{//gdy nie ma toru w kierunku jazdy { // gdy nie ma toru w kierunku jazdy
pTrack=pCurrentTrack->NullCreate(end); //tworzenie toru wykolejącego na przedłużeniu pCurrentTrack pTrack = pCurrentTrack->NullCreate(
if (!end) //jeśli dodana od strony zero, to zmiana kierunku end); // tworzenie toru wykolejącego na przedłużeniu pCurrentTrack
fDirection=-fDirection; //wtórna zmiana if (!end) // jeśli dodana od strony zero, to zmiana kierunku
//if (pTrack->iCategoryFlag&2) fDirection = -fDirection; // wtórna zmiana
// if (pTrack->iCategoryFlag&2)
//{//jeśli samochód, zepsuć na miejscu //{//jeśli samochód, zepsuć na miejscu
// Owner->MoverParameters->V=0; //zatrzymać // Owner->MoverParameters->V=0; //zatrzymać
// Owner->MoverParameters->Power=0; //ukraść silnik // Owner->MoverParameters->Power=0; //ukraść silnik
@@ -87,187 +93,217 @@ TTrack* __fastcall TTrackFollower::SetCurrentTrack(TTrack *pTrack,int end)
//} //}
} }
else else
{//najpierw +1, później -1, aby odcinek izolowany wspólny dla tych torów nie wykrył zera { // najpierw +1, później -1, aby odcinek izolowany wspólny dla tych torów nie wykrył zera
pTrack->AxleCounter(+1,Owner); //zajęcie nowego toru pTrack->AxleCounter(+1, Owner); // zajęcie nowego toru
if (pCurrentTrack) pCurrentTrack->AxleCounter(-1,Owner); //opuszczenie tamtego toru if (pCurrentTrack)
pCurrentTrack->AxleCounter(-1, Owner); // opuszczenie tamtego toru
} }
pCurrentTrack=pTrack; pCurrentTrack = pTrack;
pCurrentSegment=(pCurrentTrack?pCurrentTrack->CurrentSegment():NULL); pCurrentSegment = (pCurrentTrack ? pCurrentTrack->CurrentSegment() : NULL);
if (!pCurrentTrack) if (!pCurrentTrack)
Error(Owner->MoverParameters->Name+" at NULL track"); Error(Owner->MoverParameters->Name + " at NULL track");
return pCurrentTrack; return pCurrentTrack;
}; };
bool __fastcall TTrackFollower::Move(double fDistance,bool bPrimary) bool __fastcall TTrackFollower::Move(double fDistance, bool bPrimary)
{//przesuwanie wózka po torach o odległość (fDistance), z wyzwoleniem eventów { // przesuwanie wózka po torach o odległość (fDistance), z wyzwoleniem eventów
//bPrimary=true - jest pierwszą osią w pojeździe, czyli generuje eventy i przepisuje pojazd // bPrimary=true - jest pierwszą osią w pojeździe, czyli generuje eventy i przepisuje pojazd
//Ra: zwraca false, jeśli pojazd ma być usunięty // Ra: zwraca false, jeśli pojazd ma być usunięty
fDistance*=fDirection; //dystans mnożnony przez kierunek fDistance *= fDirection; // dystans mnożnony przez kierunek
double s; //roboczy dystans double s; // roboczy dystans
double dir; //zapamiętany kierunek do sprawdzenia, czy się zmienił double dir; // zapamiętany kierunek do sprawdzenia, czy się zmienił
bool bCanSkip; //czy przemieścić pojazd na inny tor bool bCanSkip; // czy przemieścić pojazd na inny tor
while (true) //pętla wychodzi, gdy przesunięcie wyjdzie zerowe while (true) // pętla wychodzi, gdy przesunięcie wyjdzie zerowe
{//pętla przesuwająca wózek przez kolejne tory, aż do trafienia w jakiś { // pętla przesuwająca wózek przez kolejne tory, aż do trafienia w jakiś
if (!pCurrentTrack) return false; //nie ma toru, to nie ma przesuwania if (!pCurrentTrack)
if (pCurrentTrack->iEvents) //sumaryczna informacja o eventach return false; // nie ma toru, to nie ma przesuwania
{//omijamy cały ten blok, gdy tor nie ma on żadnych eventów (większość nie ma) if (pCurrentTrack->iEvents) // sumaryczna informacja o eventach
if (fDistance<0) { // omijamy cały ten blok, gdy tor nie ma on żadnych eventów (większość nie ma)
if (fDistance < 0)
{ {
if (iSetFlag(iEventFlag,-1)) //zawsze zeruje flagę sprawdzenia, jak mechanik dosiądzie, to się nie wykona if (iSetFlag(iEventFlag, -1)) // zawsze zeruje flagę sprawdzenia, jak mechanik
if (Owner->Mechanik) //tylko dla jednego członu // dosiądzie, to się nie wykona
//if (TestFlag(iEventFlag,1)) //McZapkie-280503: wyzwalanie event tylko dla pojazdow z obsada if (Owner->Mechanik) // tylko dla jednego członu
if (bPrimary && pCurrentTrack->evEvent1 && (!pCurrentTrack->evEvent1->iQueued)) // if (TestFlag(iEventFlag,1)) //McZapkie-280503: wyzwalanie event tylko dla
Global::AddToQuery(pCurrentTrack->evEvent1,Owner); //dodanie do kolejki // pojazdow z obsada
//Owner->RaAxleEvent(pCurrentTrack->Event1); //Ra: dynamic zdecyduje, czy dodać do kolejki if (bPrimary && pCurrentTrack->evEvent1 &&
//if (TestFlag(iEventallFlag,1)) (!pCurrentTrack->evEvent1->iQueued))
if (iSetFlag(iEventallFlag,-1)) //McZapkie-280503: wyzwalanie eventall dla wszystkich pojazdow Global::AddToQuery(pCurrentTrack->evEvent1, Owner); // dodanie do
if (bPrimary && pCurrentTrack->evEventall1 && (!pCurrentTrack->evEventall1->iQueued)) // kolejki
Global::AddToQuery(pCurrentTrack->evEventall1,Owner); //dodanie do kolejki // Owner->RaAxleEvent(pCurrentTrack->Event1); //Ra: dynamic zdecyduje, czy dodać do
//Owner->RaAxleEvent(pCurrentTrack->Eventall1); //Ra: dynamic zdecyduje, czy dodać do kolejki // kolejki
// if (TestFlag(iEventallFlag,1))
if (iSetFlag(iEventallFlag,
-1)) // McZapkie-280503: wyzwalanie eventall dla wszystkich pojazdow
if (bPrimary && pCurrentTrack->evEventall1 &&
(!pCurrentTrack->evEventall1->iQueued))
Global::AddToQuery(pCurrentTrack->evEventall1, Owner); // dodanie do kolejki
// Owner->RaAxleEvent(pCurrentTrack->Eventall1); //Ra: dynamic zdecyduje, czy dodać
// do kolejki
} }
else if (fDistance>0) else if (fDistance > 0)
{ {
if (iSetFlag(iEventFlag,-2)) //zawsze ustawia flagę sprawdzenia, jak mechanik dosiądzie, to się nie wykona if (iSetFlag(iEventFlag, -2)) // zawsze ustawia flagę sprawdzenia, jak mechanik
if (Owner->Mechanik) //tylko dla jednego członu // dosiądzie, to się nie wykona
//if (TestFlag(iEventFlag,2)) //sprawdzanie jest od razu w pierwszym warunku if (Owner->Mechanik) // tylko dla jednego członu
if (bPrimary && pCurrentTrack->evEvent2 && (!pCurrentTrack->evEvent2->iQueued)) // if (TestFlag(iEventFlag,2)) //sprawdzanie jest od razu w pierwszym
Global::AddToQuery(pCurrentTrack->evEvent2,Owner); // warunku
//Owner->RaAxleEvent(pCurrentTrack->Event2); //Ra: dynamic zdecyduje, czy dodać do kolejki if (bPrimary && pCurrentTrack->evEvent2 &&
//if (TestFlag(iEventallFlag,2)) (!pCurrentTrack->evEvent2->iQueued))
if (iSetFlag(iEventallFlag,-2)) //sprawdza i zeruje na przyszłość, true jeśli zmieni z 2 na 0 Global::AddToQuery(pCurrentTrack->evEvent2, Owner);
if (bPrimary && pCurrentTrack->evEventall2 && (!pCurrentTrack->evEventall2->iQueued)) // Owner->RaAxleEvent(pCurrentTrack->Event2); //Ra: dynamic zdecyduje, czy dodać do
Global::AddToQuery(pCurrentTrack->evEventall2,Owner); // kolejki
//Owner->RaAxleEvent(pCurrentTrack->Eventall2); //Ra: dynamic zdecyduje, czy dodać do kolejki // if (TestFlag(iEventallFlag,2))
if (iSetFlag(iEventallFlag,
-2)) // sprawdza i zeruje na przyszłość, true jeśli zmieni z 2 na 0
if (bPrimary && pCurrentTrack->evEventall2 &&
(!pCurrentTrack->evEventall2->iQueued))
Global::AddToQuery(pCurrentTrack->evEventall2, Owner);
// Owner->RaAxleEvent(pCurrentTrack->Eventall2); //Ra: dynamic zdecyduje, czy dodać
// do kolejki
} }
else //if (fDistance==0) //McZapkie-140602: wyzwalanie zdarzenia gdy pojazd stoi else // if (fDistance==0) //McZapkie-140602: wyzwalanie zdarzenia gdy pojazd stoi
{ {
if (Owner->Mechanik) //tylko dla jednego członu if (Owner->Mechanik) // tylko dla jednego członu
if (pCurrentTrack->evEvent0) if (pCurrentTrack->evEvent0)
if (!pCurrentTrack->evEvent0->iQueued) if (!pCurrentTrack->evEvent0->iQueued)
Global::AddToQuery(pCurrentTrack->evEvent0,Owner); Global::AddToQuery(pCurrentTrack->evEvent0, Owner);
//Owner->RaAxleEvent(pCurrentTrack->Event0); //Ra: dynamic zdecyduje, czy dodać do kolejki // Owner->RaAxleEvent(pCurrentTrack->Event0); //Ra: dynamic zdecyduje, czy dodać do
// kolejki
if (pCurrentTrack->evEventall0) if (pCurrentTrack->evEventall0)
if (!pCurrentTrack->evEventall0->iQueued) if (!pCurrentTrack->evEventall0->iQueued)
Global::AddToQuery(pCurrentTrack->evEventall0,Owner); Global::AddToQuery(pCurrentTrack->evEventall0, Owner);
//Owner->RaAxleEvent(pCurrentTrack->Eventall0); //Ra: dynamic zdecyduje, czy dodać do kolejki // Owner->RaAxleEvent(pCurrentTrack->Eventall0); //Ra: dynamic zdecyduje, czy dodać
// do kolejki
} }
} }
if (!pCurrentSegment) //jeżeli nie ma powiązanego segmentu toru? if (!pCurrentSegment) // jeżeli nie ma powiązanego segmentu toru?
return false; return false;
//if (fDistance==0.0) return true; //Ra: jak stoi, to chyba dalej nie ma co kombinować? // if (fDistance==0.0) return true; //Ra: jak stoi, to chyba dalej nie ma co kombinować?
s=fCurrentDistance+fDistance; //doliczenie przesunięcia s = fCurrentDistance + fDistance; // doliczenie przesunięcia
//Ra: W Point2 toru może znajdować się "dziura", która zamieni energię kinetyczną // Ra: W Point2 toru może znajdować się "dziura", która zamieni energię kinetyczną
// ruchu wzdłużnego na energię potencjalną, zamieniającą się potem na energię // ruchu wzdłużnego na energię potencjalną, zamieniającą się potem na energię
// sprężystości na amortyzatorach. Należałoby we wpisie toru umieścić współczynnik // sprężystości na amortyzatorach. Należałoby we wpisie toru umieścić współczynnik
// podziału energii kinetycznej. // podziału energii kinetycznej.
// Współczynnik normalnie 1, z dziurą np. 0.99, a -1 będzie oznaczało 100% odbicia (kozioł). // Współczynnik normalnie 1, z dziurą np. 0.99, a -1 będzie oznaczało 100% odbicia (kozioł).
// Albo w postaci kąta: normalnie 0°, a 180° oznacza 100% odbicia (cosinus powyższego). // Albo w postaci kąta: normalnie 0°, a 180° oznacza 100% odbicia (cosinus powyższego).
/* /*
if (pCurrentTrack->eType==tt_Cross) if (pCurrentTrack->eType==tt_Cross)
{//zjazdu ze skrzyżowania nie da się określić przez (iPrevDirection) i (iNextDirection) {//zjazdu ze skrzyżowania nie da się określić przez (iPrevDirection) i (iNextDirection)
//int segment=Owner->RouteWish(pCurrentTrack); //numer segmentu dla skrzyżowań //int segment=Owner->RouteWish(pCurrentTrack); //numer segmentu dla skrzyżowań
//pCurrentTrack->SwitchForced(abs(segment)-1,NULL); //tymczasowo ustawienie tego segmentu //pCurrentTrack->SwitchForced(abs(segment)-1,NULL); //tymczasowo ustawienie tego segmentu
//pCurrentSegment=pCurrentTrack->CurrentSegment(); //odświeżyć sobie wskaźnik segmentu (?) //pCurrentSegment=pCurrentTrack->CurrentSegment(); //odświeżyć sobie wskaźnik segmentu
(?)
} }
*/ */
if (s<0) if (s < 0)
{//jeśli przekroczenie toru od strony Point1 { // jeśli przekroczenie toru od strony Point1
bCanSkip=bPrimary?pCurrentTrack->CheckDynamicObject(Owner):false; bCanSkip = bPrimary ? pCurrentTrack->CheckDynamicObject(Owner) : false;
if (bCanSkip) //tylko główna oś przenosi pojazd do innego toru if (bCanSkip) // tylko główna oś przenosi pojazd do innego toru
Owner->MyTrack->RemoveDynamicObject(Owner); //zdejmujemy pojazd z dotychczasowego toru Owner->MyTrack->RemoveDynamicObject(
dir=fDirection; Owner); // zdejmujemy pojazd z dotychczasowego toru
if (pCurrentTrack->eType==tt_Cross) dir = fDirection;
{if (!SetCurrentTrack(pCurrentTrack->Neightbour(iSegment,fDirection),0)) if (pCurrentTrack->eType == tt_Cross)
return false; //wyjście z błędem
}
else if (!SetCurrentTrack(pCurrentTrack->Neightbour(-1,fDirection),0)) //ustawia fDirection
return false; //wyjście z błędem
if (dir==fDirection) //(pCurrentTrack->iPrevDirection)
{//gdy kierunek bez zmiany (Point1->Point2)
fCurrentDistance=pCurrentSegment->GetLength();
fDistance=s;
}
else
{//gdy zmiana kierunku toru (Point1->Point1)
fCurrentDistance=0;
fDistance=-s;
}
if (bCanSkip)
{//jak główna oś, to dodanie pojazdu do nowego toru
pCurrentTrack->AddDynamicObject(Owner);
iEventFlag=3; //McZapkie-020602: umozliwienie uruchamiania event1,2 po zmianie toru
iEventallFlag=3; //McZapkie-280503: jw, dla eventall1,2
if (!Owner->MyTrack) return false;
}
continue;
}
else if (s>pCurrentSegment->GetLength())
{//jeśli przekroczenie toru od strony Point2
bCanSkip=bPrimary?pCurrentTrack->CheckDynamicObject(Owner):false;
if (bCanSkip) //tylko główna oś przenosi pojazd do innego toru
Owner->MyTrack->RemoveDynamicObject(Owner); //zdejmujemy pojazd z dotychczasowego toru
fDistance=s-pCurrentSegment->GetLength();
dir=fDirection;
if (pCurrentTrack->eType==tt_Cross)
{if (!SetCurrentTrack(pCurrentTrack->Neightbour(iSegment,fDirection),1))
return false; //wyjście z błędem
}
else if (!SetCurrentTrack(pCurrentTrack->Neightbour(1,fDirection),1)) //ustawia fDirection
return false; //wyjście z błędem
if (dir!=fDirection) //(pCurrentTrack->iNextDirection)
{//gdy zmiana kierunku toru (Point2->Point2)
fDistance=-fDistance; //(s-pCurrentSegment->GetLength());
fCurrentDistance=pCurrentSegment->GetLength();
}
else //gdy kierunek bez zmiany (Point2->Point1)
fCurrentDistance=0;
if (bCanSkip)
{//jak główna oś, to dodanie pojazdu do nowego toru
pCurrentTrack->AddDynamicObject(Owner);
iEventFlag=3; //McZapkie-020602: umozliwienie uruchamiania event1,2 po zmianie toru
iEventallFlag=3;
if (!Owner->MyTrack) return false;
}
continue;
}
else
{//gdy zostaje na tym samym torze (przesuwanie już nie zmienia toru)
if (bPrimary)
{//tylko gdy początkowe ustawienie, dodajemy eventy stania do kolejki
if (Owner->MoverParameters->ActiveCab!=0)
//if (Owner->MoverParameters->CabNo!=0)
{ {
if (pCurrentTrack->evEvent1 && pCurrentTrack->evEvent1->fDelay<=-1.0f) if (!SetCurrentTrack(pCurrentTrack->Neightbour(iSegment, fDirection), 0))
Global::AddToQuery(pCurrentTrack->evEvent1,Owner); return false; // wyjście z błędem
if (pCurrentTrack->evEvent2 && pCurrentTrack->evEvent2->fDelay<=-1.0f)
Global::AddToQuery(pCurrentTrack->evEvent2,Owner);
} }
if (pCurrentTrack->evEventall1 && pCurrentTrack->evEventall1->fDelay<=-1.0f) else if (!SetCurrentTrack(pCurrentTrack->Neightbour(-1, fDirection),
Global::AddToQuery(pCurrentTrack->evEventall1,Owner); 0)) // ustawia fDirection
if (pCurrentTrack->evEventall2 && pCurrentTrack->evEventall2->fDelay<=-1.0f) return false; // wyjście z błędem
Global::AddToQuery(pCurrentTrack->evEventall2,Owner); if (dir == fDirection) //(pCurrentTrack->iPrevDirection)
{ // gdy kierunek bez zmiany (Point1->Point2)
fCurrentDistance = pCurrentSegment->GetLength();
fDistance = s;
} }
fCurrentDistance=s; else
//fDistance=0; { // gdy zmiana kierunku toru (Point1->Point1)
return ComputatePosition(); //przeliczenie XYZ, true o ile nie wyjechał na NULL fCurrentDistance = 0;
fDistance = -s;
}
if (bCanSkip)
{ // jak główna oś, to dodanie pojazdu do nowego toru
pCurrentTrack->AddDynamicObject(Owner);
iEventFlag =
3; // McZapkie-020602: umozliwienie uruchamiania event1,2 po zmianie toru
iEventallFlag = 3; // McZapkie-280503: jw, dla eventall1,2
if (!Owner->MyTrack)
return false;
}
continue;
}
else if (s > pCurrentSegment->GetLength())
{ // jeśli przekroczenie toru od strony Point2
bCanSkip = bPrimary ? pCurrentTrack->CheckDynamicObject(Owner) : false;
if (bCanSkip) // tylko główna oś przenosi pojazd do innego toru
Owner->MyTrack->RemoveDynamicObject(
Owner); // zdejmujemy pojazd z dotychczasowego toru
fDistance = s - pCurrentSegment->GetLength();
dir = fDirection;
if (pCurrentTrack->eType == tt_Cross)
{
if (!SetCurrentTrack(pCurrentTrack->Neightbour(iSegment, fDirection), 1))
return false; // wyjście z błędem
}
else if (!SetCurrentTrack(pCurrentTrack->Neightbour(1, fDirection),
1)) // ustawia fDirection
return false; // wyjście z błędem
if (dir != fDirection) //(pCurrentTrack->iNextDirection)
{ // gdy zmiana kierunku toru (Point2->Point2)
fDistance = -fDistance; //(s-pCurrentSegment->GetLength());
fCurrentDistance = pCurrentSegment->GetLength();
}
else // gdy kierunek bez zmiany (Point2->Point1)
fCurrentDistance = 0;
if (bCanSkip)
{ // jak główna oś, to dodanie pojazdu do nowego toru
pCurrentTrack->AddDynamicObject(Owner);
iEventFlag =
3; // McZapkie-020602: umozliwienie uruchamiania event1,2 po zmianie toru
iEventallFlag = 3;
if (!Owner->MyTrack)
return false;
}
continue;
}
else
{ // gdy zostaje na tym samym torze (przesuwanie już nie zmienia toru)
if (bPrimary)
{ // tylko gdy początkowe ustawienie, dodajemy eventy stania do kolejki
if (Owner->MoverParameters->ActiveCab != 0)
// if (Owner->MoverParameters->CabNo!=0)
{
if (pCurrentTrack->evEvent1 && pCurrentTrack->evEvent1->fDelay <= -1.0f)
Global::AddToQuery(pCurrentTrack->evEvent1, Owner);
if (pCurrentTrack->evEvent2 && pCurrentTrack->evEvent2->fDelay <= -1.0f)
Global::AddToQuery(pCurrentTrack->evEvent2, Owner);
}
if (pCurrentTrack->evEventall1 && pCurrentTrack->evEventall1->fDelay <= -1.0f)
Global::AddToQuery(pCurrentTrack->evEventall1, Owner);
if (pCurrentTrack->evEventall2 && pCurrentTrack->evEventall2->fDelay <= -1.0f)
Global::AddToQuery(pCurrentTrack->evEventall2, Owner);
}
fCurrentDistance = s;
// fDistance=0;
return ComputatePosition(); // przeliczenie XYZ, true o ile nie wyjechał na NULL
} }
} }
}; };
bool __fastcall TTrackFollower::ComputatePosition() bool __fastcall TTrackFollower::ComputatePosition()
{//ustalenie współrzędnych XYZ { // ustalenie współrzędnych XYZ
if (pCurrentSegment) //o ile jest tor if (pCurrentSegment) // o ile jest tor
{ {
pCurrentSegment->RaPositionGet(fCurrentDistance,pPosition,vAngles); pCurrentSegment->RaPositionGet(fCurrentDistance, pPosition, vAngles);
if (fDirection<0) //kąty zależą jeszcze od zwrotu na torze if (fDirection < 0) // kąty zależą jeszcze od zwrotu na torze
{//kąty są w przedziale <-M_PI;M_PI> { // kąty są w przedziale <-M_PI;M_PI>
vAngles.x=-vAngles.x; //przechyłka jest w przecinwą stronę vAngles.x = -vAngles.x; // przechyłka jest w przecinwą stronę
vAngles.y=-vAngles.y; //pochylenie jest w przecinwą stronę vAngles.y = -vAngles.y; // pochylenie jest w przecinwą stronę
vAngles.z+=(vAngles.z>=M_PI)?-M_PI:M_PI; //ale kierunek w planie jest obrócony o 180° vAngles.z +=
(vAngles.z >= M_PI) ? -M_PI : M_PI; // ale kierunek w planie jest obrócony o 180°
} }
if (fOffsetH!=0.0) if (fOffsetH != 0.0)
{//jeśli przesunięcie względem osi toru, to je doliczyć { // jeśli przesunięcie względem osi toru, to je doliczyć
} }
return true; return true;
} }
@@ -277,15 +313,15 @@ bool __fastcall TTrackFollower::ComputatePosition()
#include "opengl/glew.h" #include "opengl/glew.h"
#include "opengl/glut.h" #include "opengl/glut.h"
void __fastcall TTrackFollower::Render(float fNr) void __fastcall TTrackFollower::Render(float fNr)
{//funkcja rysująca stożek w miejscu osi { // funkcja rysująca stożek w miejscu osi
glPushMatrix(); //matryca kamery glPushMatrix(); // matryca kamery
glTranslatef(pPosition.x,pPosition.y+6,pPosition.z); //6m ponad glTranslatef(pPosition.x, pPosition.y + 6, pPosition.z); // 6m ponad
glRotated(RadToDeg(-vAngles.z),0,1,0); //obrót względem osi OY glRotated(RadToDeg(-vAngles.z), 0, 1, 0); // obrót względem osi OY
//glRotated(RadToDeg(vAngles.z),0,1,0); //obrót względem osi OY // glRotated(RadToDeg(vAngles.z),0,1,0); //obrót względem osi OY
glDisable(GL_LIGHTING); glDisable(GL_LIGHTING);
glColor3f(1.0,1.0-fNr,1.0-fNr); //biały dla 0, czerwony dla 1 glColor3f(1.0, 1.0 - fNr, 1.0 - fNr); // biały dla 0, czerwony dla 1
//glutWireCone(promień podstawy,wysokość,kątność podstawy,ilość segmentów na wysokość) // glutWireCone(promień podstawy,wysokość,kątność podstawy,ilość segmentów na wysokość)
glutWireCone(0.5,2,4,1); //rysowanie stożka (ostrosłupa o podstawie wieloboka) glutWireCone(0.5, 2, 4, 1); // rysowanie stożka (ostrosłupa o podstawie wieloboka)
glEnable(GL_LIGHTING); glEnable(GL_LIGHTING);
glPopMatrix(); glPopMatrix();
} }

50
TrkFoll.h
View File

@@ -8,34 +8,38 @@
class TDynamicObject; class TDynamicObject;
class TTrackFollower class TTrackFollower
{//oś poruszająca się po torze { // oś poruszająca się po torze
private: private:
TTrack *pCurrentTrack; //na którym torze się znajduje TTrack *pCurrentTrack; // na którym torze się znajduje
TSegment *pCurrentSegment; //zwrotnice mogą mieć dwa segmenty TSegment *pCurrentSegment; // zwrotnice mogą mieć dwa segmenty
double fCurrentDistance; //przesunięcie względem Point1 w stronę Point2 double fCurrentDistance; // przesunięcie względem Point1 w stronę Point2
double fDirection; //ustawienie względem toru: -1.0 albo 1.0, mnożone przez dystans double fDirection; // ustawienie względem toru: -1.0 albo 1.0, mnożone przez dystans
bool __fastcall ComputatePosition(); //przeliczenie pozycji na torze bool __fastcall ComputatePosition(); // przeliczenie pozycji na torze
TDynamicObject *Owner; //pojazd posiadający TDynamicObject *Owner; // pojazd posiadający
int iEventFlag; //McZapkie-020602: informacja o tym czy wyzwalac zdarzenie: 0,1,2,3 int iEventFlag; // McZapkie-020602: informacja o tym czy wyzwalac zdarzenie: 0,1,2,3
int iEventallFlag; int iEventallFlag;
int iSegment; //który segment toru jest używany (żeby nie przeskakiwało po przestawieniu zwrotnicy pod taborem) int iSegment; // który segment toru jest używany (żeby nie przeskakiwało po przestawieniu
public: // zwrotnicy pod taborem)
double fOffsetH; //Ra: odległość środka osi od osi toru (dla samochodów) - użyć do wężykowania public:
vector3 pPosition; //współrzędne XYZ w układzie scenerii double fOffsetH; // Ra: odległość środka osi od osi toru (dla samochodów) - użyć do wężykowania
vector3 vAngles; //x:przechyłka, y:pochylenie, z:kierunek w planie (w radianach) vector3 pPosition; // współrzędne XYZ w układzie scenerii
vector3 vAngles; // x:przechyłka, y:pochylenie, z:kierunek w planie (w radianach)
__fastcall TTrackFollower(); __fastcall TTrackFollower();
__fastcall ~TTrackFollower(); __fastcall ~TTrackFollower();
TTrack* __fastcall SetCurrentTrack(TTrack *pTrack,int end); TTrack *__fastcall SetCurrentTrack(TTrack *pTrack, int end);
bool __fastcall Move(double fDistance,bool bPrimary); bool __fastcall Move(double fDistance, bool bPrimary);
inline TTrack* __fastcall GetTrack() {return pCurrentTrack;}; inline TTrack *__fastcall GetTrack() { return pCurrentTrack; };
inline double __fastcall GetRoll() {return vAngles.x;}; //przechyłka policzona przy ustalaniu pozycji inline double __fastcall GetRoll()
{
return vAngles.x;
}; // przechyłka policzona przy ustalaniu pozycji
//{return pCurrentSegment->GetRoll(fCurrentDistance)*fDirection;}; //zamiast liczyć można pobrać //{return pCurrentSegment->GetRoll(fCurrentDistance)*fDirection;}; //zamiast liczyć można pobrać
inline double __fastcall GetDirection() {return fDirection;}; //zwrot na torze inline double __fastcall GetDirection() { return fDirection; }; // zwrot na torze
inline double __fastcall GetTranslation() {return fCurrentDistance;}; //ABu-030403 inline double __fastcall GetTranslation() { return fCurrentDistance; }; // ABu-030403
//inline double __fastcall GetLength(vector3 p1, vector3 cp1, vector3 cp2, vector3 p2) // inline double __fastcall GetLength(vector3 p1, vector3 cp1, vector3 cp2, vector3 p2)
//{ return pCurrentSegment->ComputeLength(p1,cp1,cp2,p2); }; //{ return pCurrentSegment->ComputeLength(p1,cp1,cp2,p2); };
//inline double __fastcall GetRadius(double L, double d); //McZapkie-150503 // inline double __fastcall GetRadius(double L, double d); //McZapkie-150503
bool __fastcall Init(TTrack *pTrack,TDynamicObject *NewOwner,double fDir); bool __fastcall Init(TTrack *pTrack, TDynamicObject *NewOwner, double fDir);
void __fastcall Render(float fNr); void __fastcall Render(float fNr);
}; };
//--------------------------------------------------------------------------- //---------------------------------------------------------------------------

90
VBO.cpp
View File

@@ -11,85 +11,89 @@
#pragma package(smart_init) #pragma package(smart_init)
__fastcall CMesh::CMesh() __fastcall CMesh::CMesh()
{//utworzenie pustego obiektu { // utworzenie pustego obiektu
m_pVNT=NULL; m_pVNT = NULL;
m_nVertexCount=-1; m_nVertexCount = -1;
m_nVBOVertices=0; //nie zarezerwowane m_nVBOVertices = 0; // nie zarezerwowane
}; };
__fastcall CMesh::~CMesh() __fastcall CMesh::~CMesh()
{//usuwanie obiektu { // usuwanie obiektu
Clear(); //zwolnienie zasobów Clear(); // zwolnienie zasobów
}; };
void __fastcall CMesh::MakeArray(int n) void __fastcall CMesh::MakeArray(int n)
{//tworzenie tablic { // tworzenie tablic
m_nVertexCount=n; m_nVertexCount = n;
m_pVNT=new CVertNormTex[m_nVertexCount]; // przydzielenie pamięci dla tablicy m_pVNT = new CVertNormTex[m_nVertexCount]; // przydzielenie pamięci dla tablicy
}; };
void __fastcall CMesh::BuildVBOs(bool del) void __fastcall CMesh::BuildVBOs(bool del)
{//tworzenie VBO i kasowanie już niepotrzebnych tablic { // tworzenie VBO i kasowanie już niepotrzebnych tablic
//pobierz numer VBO oraz ustaw go jako aktywny // pobierz numer VBO oraz ustaw go jako aktywny
glGenBuffersARB(1,&m_nVBOVertices); //pobierz numer glGenBuffersARB(1, &m_nVBOVertices); // pobierz numer
glBindBufferARB(GL_ARRAY_BUFFER_ARB,m_nVBOVertices); //ustaw bufor jako aktualny glBindBufferARB(GL_ARRAY_BUFFER_ARB, m_nVBOVertices); // ustaw bufor jako aktualny
glBufferDataARB(GL_ARRAY_BUFFER_ARB,m_nVertexCount*sizeof(CVertNormTex),m_pVNT,GL_STATIC_DRAW_ARB); glBufferDataARB(GL_ARRAY_BUFFER_ARB, m_nVertexCount * sizeof(CVertNormTex), m_pVNT,
//WriteLog("Assigned VBO number "+AnsiString(m_nVBOVertices)+", vertices: "+AnsiString(m_nVertexCount)); GL_STATIC_DRAW_ARB);
if (del) SafeDeleteArray(m_pVNT); //wierzchołki już się nie przydadzą // WriteLog("Assigned VBO number "+AnsiString(m_nVBOVertices)+", vertices:
// "+AnsiString(m_nVertexCount));
if (del)
SafeDeleteArray(m_pVNT); // wierzchołki już się nie przydadzą
}; };
void __fastcall CMesh::Clear() void __fastcall CMesh::Clear()
{//niewirtualne zwolnienie zasobów przez sprzątacz albo destruktor { // niewirtualne zwolnienie zasobów przez sprzątacz albo destruktor
//inna nazwa, żeby nie mieszało się z funkcją wirtualną sprzątacza // inna nazwa, żeby nie mieszało się z funkcją wirtualną sprzątacza
if (m_nVBOVertices) //jeśli było coś rezerwowane if (m_nVBOVertices) // jeśli było coś rezerwowane
{ {
glDeleteBuffersARB(1,&m_nVBOVertices); // Free The Memory glDeleteBuffersARB(1, &m_nVBOVertices); // Free The Memory
//WriteLog("Released VBO number "+AnsiString(m_nVBOVertices)); // WriteLog("Released VBO number "+AnsiString(m_nVBOVertices));
} }
m_nVBOVertices=0; m_nVBOVertices = 0;
m_nVertexCount=-1; //do ponownego zliczenia m_nVertexCount = -1; // do ponownego zliczenia
SafeDeleteArray(m_pVNT); //usuwanie tablic, gdy były użyte do Vertex Array SafeDeleteArray(m_pVNT); // usuwanie tablic, gdy były użyte do Vertex Array
}; };
bool __fastcall CMesh::StartVBO() bool __fastcall CMesh::StartVBO()
{//początek rysowania elementów z VBO { // początek rysowania elementów z VBO
if (m_nVertexCount<=0) return false; //nie ma nic do rysowania w ten sposób if (m_nVertexCount <= 0)
return false; // nie ma nic do rysowania w ten sposób
glEnableClientState(GL_VERTEX_ARRAY); glEnableClientState(GL_VERTEX_ARRAY);
glEnableClientState(GL_NORMAL_ARRAY); glEnableClientState(GL_NORMAL_ARRAY);
glEnableClientState(GL_TEXTURE_COORD_ARRAY); glEnableClientState(GL_TEXTURE_COORD_ARRAY);
if (m_nVBOVertices) if (m_nVBOVertices)
{ {
glBindBufferARB(GL_ARRAY_BUFFER_ARB,m_nVBOVertices); glBindBufferARB(GL_ARRAY_BUFFER_ARB, m_nVBOVertices);
glVertexPointer(3,GL_FLOAT,sizeof(CVertNormTex),((char*)NULL)); //pozycje glVertexPointer(3, GL_FLOAT, sizeof(CVertNormTex), ((char *)NULL)); // pozycje
glNormalPointer(GL_FLOAT,sizeof(CVertNormTex),((char*)NULL)+12); //normalne glNormalPointer(GL_FLOAT, sizeof(CVertNormTex), ((char *)NULL) + 12); // normalne
glTexCoordPointer(2,GL_FLOAT,sizeof(CVertNormTex),((char*)NULL)+24); //wierzchołki glTexCoordPointer(2, GL_FLOAT, sizeof(CVertNormTex), ((char *)NULL) + 24); // wierzchołki
} }
return true; //można rysować z VBO return true; // można rysować z VBO
}; };
bool __fastcall CMesh::StartColorVBO() bool __fastcall CMesh::StartColorVBO()
{//początek rysowania punktów świecących z VBO { // początek rysowania punktów świecących z VBO
if (m_nVertexCount<=0) return false; //nie ma nic do rysowania w ten sposób if (m_nVertexCount <= 0)
return false; // nie ma nic do rysowania w ten sposób
glEnableClientState(GL_VERTEX_ARRAY); glEnableClientState(GL_VERTEX_ARRAY);
glEnableClientState(GL_COLOR_ARRAY); glEnableClientState(GL_COLOR_ARRAY);
if (m_nVBOVertices) if (m_nVBOVertices)
{ {
glBindBufferARB(GL_ARRAY_BUFFER_ARB,m_nVBOVertices); glBindBufferARB(GL_ARRAY_BUFFER_ARB, m_nVBOVertices);
glVertexPointer(3,GL_FLOAT,sizeof(CVertNormTex),((char*)NULL)); //pozycje glVertexPointer(3, GL_FLOAT, sizeof(CVertNormTex), ((char *)NULL)); // pozycje
//glColorPointer(3,GL_UNSIGNED_BYTE,sizeof(CVertNormTex),((char*)NULL)+12); //kolory // glColorPointer(3,GL_UNSIGNED_BYTE,sizeof(CVertNormTex),((char*)NULL)+12); //kolory
glColorPointer(3,GL_FLOAT,sizeof(CVertNormTex),((char*)NULL)+12); //kolory glColorPointer(3, GL_FLOAT, sizeof(CVertNormTex), ((char *)NULL) + 12); // kolory
} }
return true; //można rysować z VBO return true; // można rysować z VBO
}; };
void __fastcall CMesh::EndVBO() void __fastcall CMesh::EndVBO()
{//koniec użycia VBO { // koniec użycia VBO
glDisableClientState(GL_VERTEX_ARRAY); glDisableClientState(GL_VERTEX_ARRAY);
glDisableClientState(GL_NORMAL_ARRAY); glDisableClientState(GL_NORMAL_ARRAY);
glDisableClientState(GL_TEXTURE_COORD_ARRAY); glDisableClientState(GL_TEXTURE_COORD_ARRAY);
glDisableClientState(GL_COLOR_ARRAY); glDisableClientState(GL_COLOR_ARRAY);
//glBindBuffer(GL_ARRAY_BUFFER,0); //takie coś psuje, mimo iż polecali użyć // glBindBuffer(GL_ARRAY_BUFFER,0); //takie coś psuje, mimo iż polecali użyć
glBindBufferARB(GL_ARRAY_BUFFER_ARB,0); glBindBufferARB(GL_ARRAY_BUFFER_ARB, 0);
glBindBufferARB(GL_ELEMENT_ARRAY_BUFFER_ARB,0); //Ra: to na przyszłość glBindBufferARB(GL_ELEMENT_ARRAY_BUFFER_ARB, 0); // Ra: to na przyszłość
}; };

33
VBO.h
View File

@@ -5,32 +5,31 @@
//--------------------------------------------------------------------------- //---------------------------------------------------------------------------
class CVertNormTex class CVertNormTex
{ {
public: public:
float x; //X wierzchołka float x; // X wierzchołka
float y; //Y wierzchołka float y; // Y wierzchołka
float z; //Z wierzchołka float z; // Z wierzchołka
float nx; //X wektora normalnego float nx; // X wektora normalnego
float ny; //Y wektora normalnego float ny; // Y wektora normalnego
float nz; //Z wektora normalnego float nz; // Z wektora normalnego
float u; //U mapowania float u; // U mapowania
float v; //V mapowania float v; // V mapowania
}; };
class CMesh class CMesh
{//wsparcie dla VBO { // wsparcie dla VBO
public: public:
int m_nVertexCount; //liczba wierzchołków int m_nVertexCount; // liczba wierzchołków
CVertNormTex *m_pVNT; CVertNormTex *m_pVNT;
unsigned int m_nVBOVertices; //numer VBO z wierzchołkami unsigned int m_nVBOVertices; // numer VBO z wierzchołkami
__fastcall CMesh(); __fastcall CMesh();
__fastcall ~CMesh(); __fastcall ~CMesh();
void __fastcall MakeArray(int n); //tworzenie tablicy z elementami VNT void __fastcall MakeArray(int n); // tworzenie tablicy z elementami VNT
void __fastcall BuildVBOs(bool del=true); //zamiana tablic na VBO void __fastcall BuildVBOs(bool del = true); // zamiana tablic na VBO
void __fastcall Clear(); //zwolnienie zasobów void __fastcall Clear(); // zwolnienie zasobów
bool __fastcall StartVBO(); bool __fastcall StartVBO();
void __fastcall EndVBO(); void __fastcall EndVBO();
bool __fastcall StartColorVBO(); bool __fastcall StartColorVBO();
}; };
#endif #endif

3278
World.cpp
View File

File diff suppressed because it is too large Load Diff

40
World.h
View File

@@ -3,7 +3,6 @@
#ifndef WorldH #ifndef WorldH
#define WorldH #define WorldH
#include "Usefull.h" #include "Usefull.h"
#include "Classes.h" #include "Classes.h"
#include "Texture.h" #include "Texture.h"
@@ -17,24 +16,25 @@
class TWorld class TWorld
{ {
void __fastcall InOutKey(); void __fastcall InOutKey();
void __fastcall FollowView(bool wycisz=true); void __fastcall FollowView(bool wycisz = true);
void __fastcall DistantView(); void __fastcall DistantView();
public:
public:
bool __fastcall Init(HWND NhWnd, HDC hDC); bool __fastcall Init(HWND NhWnd, HDC hDC);
HWND hWnd; HWND hWnd;
GLvoid __fastcall glPrint(const char *fmt); GLvoid __fastcall glPrint(const char *fmt);
void __fastcall OnKeyDown(int cKey); void __fastcall OnKeyDown(int cKey);
void __fastcall OnKeyUp(int cKey); void __fastcall OnKeyUp(int cKey);
//void __fastcall UpdateWindow(); // void __fastcall UpdateWindow();
void __fastcall OnMouseMove(double x, double y); void __fastcall OnMouseMove(double x, double y);
void __fastcall OnCommandGet(DaneRozkaz *pRozkaz); void __fastcall OnCommandGet(DaneRozkaz *pRozkaz);
bool __fastcall Update(); bool __fastcall Update();
void __fastcall TrainDelete(TDynamicObject *d=NULL); void __fastcall TrainDelete(TDynamicObject *d = NULL);
__fastcall TWorld(); __fastcall TWorld();
__fastcall ~TWorld(); __fastcall ~TWorld();
//double Aspect; // double Aspect;
private: private:
AnsiString OutText1; //teksty na ekranie AnsiString OutText1; // teksty na ekranie
AnsiString OutText2; AnsiString OutText2;
AnsiString OutText3; AnsiString OutText3;
AnsiString OutText4; AnsiString OutText4;
@@ -45,20 +45,20 @@ private:
TTrain *Train; TTrain *Train;
TDynamicObject *pDynamicNearest; TDynamicObject *pDynamicNearest;
bool Paused; bool Paused;
GLuint base; //numer DL dla znaków w napisach GLuint base; // numer DL dla znaków w napisach
GLuint light; //numer tekstury dla smugi GLuint light; // numer tekstury dla smugi
TSky Clouds; TSky Clouds;
TEvent *KeyEvents[10]; //eventy wyzwalane z klawiaury TEvent *KeyEvents[10]; // eventy wyzwalane z klawiaury
TMoverParameters *mvControlled; //wskaŸnik na cz³on silnikowy, do wyœwietlania jego parametrów TMoverParameters *mvControlled; // wskaŸnik na cz³on silnikowy, do wyœwietlania jego parametrów
int iCheckFPS; //kiedy znów sprawdziæ FPS, ¿eby wy³¹czaæ optymalizacji od razu do zera int iCheckFPS; // kiedy znów sprawdziæ FPS, ¿eby wy³¹czaæ optymalizacji od razu do zera
double fTime50Hz; //bufor czasu dla komunikacji z PoKeys double fTime50Hz; // bufor czasu dla komunikacji z PoKeys
double fTimeBuffer; //bufor czasu aktualizacji dla sta³ego kroku fizyki double fTimeBuffer; // bufor czasu aktualizacji dla sta³ego kroku fizyki
double fMaxDt; //[s] krok czasowy fizyki (0.01 dla normalnych warunków) double fMaxDt; //[s] krok czasowy fizyki (0.01 dla normalnych warunków)
int iPause; //wykrywanie zmian w zapauzowaniu int iPause; // wykrywanie zmian w zapauzowaniu
public: public:
void __fastcall ModifyTGA(const AnsiString &dir=""); void __fastcall ModifyTGA(const AnsiString &dir = "");
void __fastcall CreateE3D(const AnsiString &dir="",bool dyn=false); void __fastcall CreateE3D(const AnsiString &dir = "", bool dyn = false);
void __fastcall CabChange(TDynamicObject *old,TDynamicObject *now); void __fastcall CabChange(TDynamicObject *old, TDynamicObject *now);
}; };
//--------------------------------------------------------------------------- //---------------------------------------------------------------------------
#endif #endif

295
dumb3d.cpp
View File

@@ -2,72 +2,95 @@
#include "fastmath.h" #include "fastmath.h"
#include <cassert> #include <cassert>
namespace Math3D { namespace Math3D
{
void __fastcall vector3::RotateX(double angle) void __fastcall vector3::RotateX(double angle)
{ {
double ty= y; double ty = y;
y= (cos(angle)*y-z*sin(angle)); y = (cos(angle) * y - z * sin(angle));
z= (z*cos(angle)+sin(angle)*ty); z = (z * cos(angle) + sin(angle) * ty);
}; };
void __fastcall vector3::RotateY(double angle) void __fastcall vector3::RotateY(double angle)
{ {
double tx= x; double tx = x;
x= (cos(angle)*x+z*sin(angle)); x = (cos(angle) * x + z * sin(angle));
z= (z*cos(angle)-sin(angle)*tx); z = (z * cos(angle) - sin(angle) * tx);
}; };
void __fastcall vector3::RotateZ(double angle) void __fastcall vector3::RotateZ(double angle)
{ {
double ty= y; double ty = y;
y= (cos(angle)*y+x*sin(angle)); y = (cos(angle) * y + x * sin(angle));
x= (x*cos(angle)-sin(angle)*ty); x = (x * cos(angle) - sin(angle) * ty);
}; };
void inline __fastcall vector3::SafeNormalize() void inline __fastcall vector3::SafeNormalize()
{ {
double l= Length(); double l = Length();
if (l==0) if (l == 0)
{ {
x=y=z=0; x = y = z = 0;
} }
else else
{ {
x/= l; x /= l;
y/= l; y /= l;
z/= l; z /= l;
} }
} }
// From code in Graphics Gems; p. 766 // From code in Graphics Gems; p. 766
inline scalar_t det2x2 (scalar_t a, scalar_t b, scalar_t c, scalar_t d) { inline scalar_t det2x2(scalar_t a, scalar_t b, scalar_t c, scalar_t d) { return a * d - b * c; }
return a*d - b*c;
inline scalar_t det3x3(scalar_t a1, scalar_t a2, scalar_t a3, scalar_t b1, scalar_t b2, scalar_t b3,
scalar_t c1, scalar_t c2, scalar_t c3)
{
return a1 * det2x2(b2, b3, c2, c3) - b1 * det2x2(a2, a3, c2, c3) + c1 * det2x2(a2, a3, b2, b3);
} }
inline scalar_t det3x3 ( scalar_t a1, scalar_t a2, scalar_t a3, scalar_t Determinant(const matrix4x4 &m)
scalar_t b1, scalar_t b2, scalar_t b3, {
scalar_t c1, scalar_t c2, scalar_t c3) { scalar_t a1 = m[0][0];
return a1 * det2x2(b2, b3, c2, c3) scalar_t a2 = m[1][0];
- b1 * det2x2(a2, a3, c2, c3) scalar_t a3 = m[2][0];
+ c1 * det2x2(a2, a3, b2, b3); scalar_t a4 = m[3][0];
scalar_t b1 = m[0][1];
scalar_t b2 = m[1][1];
scalar_t b3 = m[2][1];
scalar_t b4 = m[3][1];
scalar_t c1 = m[0][2];
scalar_t c2 = m[1][2];
scalar_t c3 = m[2][2];
scalar_t c4 = m[3][2];
scalar_t d1 = m[0][3];
scalar_t d2 = m[1][3];
scalar_t d3 = m[2][3];
scalar_t d4 = m[3][3];
return a1 * det3x3(b2, b3, b4, c2, c3, c4, d2, d3, d4) -
b1 * det3x3(a2, a3, a4, c2, c3, c4, d2, d3, d4) +
c1 * det3x3(a2, a3, a4, b2, b3, b4, d2, d3, d4) -
d1 * det3x3(a2, a3, a4, b2, b3, b4, c2, c3, c4);
} }
scalar_t Determinant (const matrix4x4& m) { matrix4x4 Adjoint(const matrix4x4 &m)
scalar_t a1 = m[0][0]; scalar_t a2 = m[1][0]; scalar_t a3 = m[2][0]; scalar_t a4 = m[3][0]; {
scalar_t b1 = m[0][1]; scalar_t b2 = m[1][1]; scalar_t b3 = m[2][1]; scalar_t b4 = m[3][1]; scalar_t a1 = m[0][0];
scalar_t c1 = m[0][2]; scalar_t c2 = m[1][2]; scalar_t c3 = m[2][2]; scalar_t c4 = m[3][2]; scalar_t a2 = m[0][1];
scalar_t d1 = m[0][3]; scalar_t d2 = m[1][3]; scalar_t d3 = m[2][3]; scalar_t d4 = m[3][3]; scalar_t a3 = m[0][2];
scalar_t a4 = m[0][3];
return a1 * det3x3(b2, b3, b4, c2, c3, c4, d2, d3, d4) scalar_t b1 = m[1][0];
- b1 * det3x3(a2, a3, a4, c2, c3, c4, d2, d3, d4) scalar_t b2 = m[1][1];
+ c1 * det3x3(a2, a3, a4, b2, b3, b4, d2, d3, d4) scalar_t b3 = m[1][2];
- d1 * det3x3(a2, a3, a4, b2, b3, b4, c2, c3, c4); scalar_t b4 = m[1][3];
} scalar_t c1 = m[2][0];
scalar_t c2 = m[2][1];
matrix4x4 Adjoint (const matrix4x4& m) { scalar_t c3 = m[2][2];
scalar_t a1 = m[0][0]; scalar_t a2 = m[0][1]; scalar_t a3 = m[0][2]; scalar_t a4 = m[0][3]; scalar_t c4 = m[2][3];
scalar_t b1 = m[1][0]; scalar_t b2 = m[1][1]; scalar_t b3 = m[1][2]; scalar_t b4 = m[1][3]; scalar_t d1 = m[3][0];
scalar_t c1 = m[2][0]; scalar_t c2 = m[2][1]; scalar_t c3 = m[2][2]; scalar_t c4 = m[2][3]; scalar_t d2 = m[3][1];
scalar_t d1 = m[3][0]; scalar_t d2 = m[3][1]; scalar_t d3 = m[3][2]; scalar_t d4 = m[3][3]; scalar_t d3 = m[3][2];
scalar_t d4 = m[3][3];
// Adjoint(x,y) = -1^(x+y) * a(y,x) // Adjoint(x,y) = -1^(x+y) * a(y,x)
// Where a(i,j) is the 3x3 determinant of m with row i and col j removed // Where a(i,j) is the 3x3 determinant of m with row i and col j removed
@@ -95,13 +118,16 @@ matrix4x4 Adjoint (const matrix4x4& m) {
return retVal; return retVal;
} }
matrix4x4 Inverse (const matrix4x4& m) { matrix4x4 Inverse(const matrix4x4 &m)
{
matrix4x4 retVal = Adjoint(m); matrix4x4 retVal = Adjoint(m);
scalar_t det = Determinant(m); scalar_t det = Determinant(m);
assert(det); assert(det);
for (int i=0;i<4;++i) { for (int i = 0; i < 4; ++i)
for (int j=0;j<4;++j) { {
for (int j = 0; j < 4; ++j)
{
retVal(i)[j] /= det; retVal(i)[j] /= det;
} }
} }
@@ -110,8 +136,6 @@ matrix4x4 Inverse (const matrix4x4& m) {
} }
} }
//************************************** //**************************************
// Testing from here on. // Testing from here on.
//************************************** //**************************************
@@ -123,68 +147,83 @@ using namespace std;
static int failures = 0; static int failures = 0;
void ReportFailure (const char* className, const char* testName, bool passed) { void ReportFailure(const char *className, const char *testName, bool passed)
{
cout << className; cout << className;
if (passed) if (passed)
cout << " passed test "; cout << " passed test ";
else { else
{
cout << " FAILED test "; cout << " FAILED test ";
++failures; ++failures;
} }
cout << testName << "." << endl; cout << testName << "." << endl;
} }
const char* vector3Name = "vector3"; const char *vector3Name = "vector3";
const char* matrix4x4Name = "matrix4x4"; const char *matrix4x4Name = "matrix4x4";
void Testvector3Constructors(void) { void Testvector3Constructors(void)
{
// Default ctor... just make sure it compiles // Default ctor... just make sure it compiles
vector3 defaultCtorTest; vector3 defaultCtorTest;
// Initializer ctor test (3 param) // Initializer ctor test (3 param)
vector3 initCtorTest(1, 2, 3); vector3 initCtorTest(1, 2, 3);
ReportFailure (vector3Name, "initialized ctor (3 parameter version)", (initCtorTest[0] == 1 && initCtorTest[1] == 2 && initCtorTest[2] == 3 && initCtorTest[3] == 1)); ReportFailure(vector3Name, "initialized ctor (3 parameter version)",
(initCtorTest[0] == 1 && initCtorTest[1] == 2 && initCtorTest[2] == 3 &&
initCtorTest[3] == 1));
// Initializer ctor test (4 param) // Initializer ctor test (4 param)
vector3 initCtorTest2 (1,2,3,4); vector3 initCtorTest2(1, 2, 3, 4);
ReportFailure (vector3Name, "initialized ctor (4 parameter version)", (initCtorTest2[0] == 1 && initCtorTest2[1] == 2 && initCtorTest2[2] == 3 && initCtorTest2[3] == 4)); ReportFailure(vector3Name, "initialized ctor (4 parameter version)",
(initCtorTest2[0] == 1 && initCtorTest2[1] == 2 && initCtorTest2[2] == 3 &&
initCtorTest2[3] == 4));
scalar_t initArray[] = { 1, 2, 3, 4}; scalar_t initArray[] = {1, 2, 3, 4};
vector3 initCtorArrayTest3 (initArray); vector3 initCtorArrayTest3(initArray);
ReportFailure (vector3Name, "array initialized ctor (3 parameter version)", (initCtorArrayTest3[0] == 1 && initCtorArrayTest3[1] == 2 && initCtorArrayTest3[2] == 3 && initCtorArrayTest3[3] == 1)); ReportFailure(vector3Name, "array initialized ctor (3 parameter version)",
(initCtorArrayTest3[0] == 1 && initCtorArrayTest3[1] == 2 &&
initCtorArrayTest3[2] == 3 && initCtorArrayTest3[3] == 1));
vector3 initCtorArrayTest4 (initArray, 4); vector3 initCtorArrayTest4(initArray, 4);
ReportFailure (vector3Name, "array initialized ctor (4 parameter version)", (initCtorArrayTest4[0] == 1 && initCtorArrayTest4[1] == 2 && initCtorArrayTest4[2] == 3 && initCtorArrayTest4[3] == 4)); ReportFailure(vector3Name, "array initialized ctor (4 parameter version)",
(initCtorArrayTest4[0] == 1 && initCtorArrayTest4[1] == 2 &&
initCtorArrayTest4[2] == 3 && initCtorArrayTest4[3] == 4));
// Copy ctor test // Copy ctor test
vector3 copyCtorTest(initCtorTest2); vector3 copyCtorTest(initCtorTest2);
ReportFailure (vector3Name, "copy ctor", (copyCtorTest[0] == 1 && copyCtorTest[1] == 2 && copyCtorTest[2] == 3 && copyCtorTest[3] == 4)); ReportFailure(vector3Name, "copy ctor", (copyCtorTest[0] == 1 && copyCtorTest[1] == 2 &&
copyCtorTest[2] == 3 && copyCtorTest[3] == 4));
} }
void Testvector3Comparison(void) { void Testvector3Comparison(void)
vector3 alpha(1,1,1); {
vector3 alpha(1, 1, 1);
vector3 beta(alpha); vector3 beta(alpha);
vector3 gamma(2,3,4); vector3 gamma(2, 3, 4);
ReportFailure (vector3Name, "equivalence operator test 1", (alpha==beta)); ReportFailure(vector3Name, "equivalence operator test 1", (alpha == beta));
ReportFailure (vector3Name, "equivalence operator test 2", (!(alpha == gamma))); ReportFailure(vector3Name, "equivalence operator test 2", (!(alpha == gamma)));
ReportFailure (vector3Name, "comparison operator test 1", !(alpha < beta)); ReportFailure(vector3Name, "comparison operator test 1", !(alpha < beta));
ReportFailure (vector3Name, "comparison operator test 2", (alpha < gamma)); ReportFailure(vector3Name, "comparison operator test 2", (alpha < gamma));
ReportFailure (vector3Name, "comparison operator test 3", !(gamma < beta)); ReportFailure(vector3Name, "comparison operator test 3", !(gamma < beta));
} }
void Testvector3Assignment (void) { void Testvector3Assignment(void)
vector3 alpha(1,1,1,1); {
vector3 beta(10,10,10,10); vector3 alpha(1, 1, 1, 1);
vector3 beta(10, 10, 10, 10);
alpha = beta; alpha = beta;
ReportFailure (vector3Name, "assignment operator", (alpha == beta)); ReportFailure(vector3Name, "assignment operator", (alpha == beta));
} }
void Testvector3UnaryOps (void) { void Testvector3UnaryOps(void)
vector3 alpha(10,10,10,10); {
vector3 beta(-10,-10,-10,-10); vector3 alpha(10, 10, 10, 10);
vector3 beta(-10, -10, -10, -10);
alpha = -alpha; alpha = -alpha;
ReportFailure(vector3Name, "negation operator", (alpha==beta)); ReportFailure(vector3Name, "negation operator", (alpha == beta));
ReportFailure(vector3Name, "length squared 3 element version", LengthSquared3(alpha) == 300); ReportFailure(vector3Name, "length squared 3 element version", LengthSquared3(alpha) == 300);
ReportFailure(vector3Name, "length 3 element version", Length3(alpha) == SQRT_FUNCTION(300)); ReportFailure(vector3Name, "length 3 element version", Length3(alpha) == SQRT_FUNCTION(300));
@@ -195,24 +234,27 @@ void Testvector3UnaryOps (void) {
// Done without /= on vector3, as we want to be independant of failure of /= // Done without /= on vector3, as we want to be independant of failure of /=
// Earlier failures should be resolved before later ones (just like C++) // Earlier failures should be resolved before later ones (just like C++)
beta = alpha; beta = alpha;
for (int i=0;i<3;++i) beta(i) /= SQRT_FUNCTION(300); for (int i = 0; i < 3; ++i)
beta(i) /= SQRT_FUNCTION(300);
beta(3) = 1; beta(3) = 1;
ReportFailure(vector3Name, "normalize 3 element version", Normalize3(alpha) == beta); ReportFailure(vector3Name, "normalize 3 element version", Normalize3(alpha) == beta);
beta = alpha; beta = alpha;
for (int i=0;i<4;++i) beta(i) /= SQRT_FUNCTION(400); for (int i = 0; i < 4; ++i)
beta(i) /= SQRT_FUNCTION(400);
ReportFailure(vector3Name, "normalize 4 element version", Normalize4(alpha) == beta); ReportFailure(vector3Name, "normalize 4 element version", Normalize4(alpha) == beta);
} }
void Testvector3BinaryOps (void) { void Testvector3BinaryOps(void)
{
// Vector * Matrix is tested in Testmatrix4x4BinaryOps // Vector * Matrix is tested in Testmatrix4x4BinaryOps
vector3 testVec(1,1,1,1); vector3 testVec(1, 1, 1, 1);
vector3 deltaVec(1,2,3,4); vector3 deltaVec(1, 2, 3, 4);
vector3 crossVec(1, -2, 1, 1); // testVec x deltaVec vector3 crossVec(1, -2, 1, 1); // testVec x deltaVec
vector3 factorVec(10,10,10,10); vector3 factorVec(10, 10, 10, 10);
vector3 sumVec(2,3,4,5); vector3 sumVec(2, 3, 4, 5);
vector3 difVec(0,-1,-2,-3); vector3 difVec(0, -1, -2, -3);
vector3 testVec2; vector3 testVec2;
ReportFailure(vector3Name, "scalar multiply 1", (testVec * 10) == factorVec); ReportFailure(vector3Name, "scalar multiply 1", (testVec * 10) == factorVec);
@@ -238,7 +280,8 @@ void Testvector3BinaryOps (void) {
ReportFailure(vector3Name, "cross product", crossVec == CrossProduct(testVec, deltaVec)); ReportFailure(vector3Name, "cross product", crossVec == CrossProduct(testVec, deltaVec));
} }
void Testvector3 (void) { void Testvector3(void)
{
// Accessors cannot be tested effectively... // Accessors cannot be tested effectively...
// They are really trivial, and so don't really need testing, // They are really trivial, and so don't really need testing,
// but more importantly, how do you test the ctors without assuming // but more importantly, how do you test the ctors without assuming
@@ -252,37 +295,34 @@ void Testvector3 (void) {
Testvector3BinaryOps(); Testvector3BinaryOps();
} }
void Testmatrix4x4Constructors (void) { void Testmatrix4x4Constructors(void)
{
// Check if default ctor compiles // Check if default ctor compiles
matrix4x4 defaultTest; matrix4x4 defaultTest;
scalar_t initArray[] = { 0, 1, 2, 3, scalar_t initArray[] = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15};
4, 5, 6, 7,
8, 9, 10, 11,
12, 13, 14, 15 };
matrix4x4 arrayTest; matrix4x4 arrayTest;
arrayTest.C_Matrix(initArray); arrayTest.C_Matrix(initArray);
bool passedTest = true; bool passedTest = true;
for (int x=0;x<4;++x) for (int y=0;y<4;++y) for (int x = 0; x < 4; ++x)
if (arrayTest[x][y] != initArray[(y<<2) + x]) passedTest = false; for (int y = 0; y < 4; ++y)
if (arrayTest[x][y] != initArray[(y << 2) + x])
passedTest = false;
ReportFailure(matrix4x4Name, "array constructor", passedTest); ReportFailure(matrix4x4Name, "array constructor", passedTest);
matrix4x4 copyTest(arrayTest); matrix4x4 copyTest(arrayTest);
passedTest = true; passedTest = true;
for (int x=0;x<4;++x) for (int y=0;y<4;++y) for (int x = 0; x < 4; ++x)
if (arrayTest[x][y] != copyTest[x][y]) passedTest = false; for (int y = 0; y < 4; ++y)
if (arrayTest[x][y] != copyTest[x][y])
passedTest = false;
ReportFailure(matrix4x4Name, "copy constructor", passedTest); ReportFailure(matrix4x4Name, "copy constructor", passedTest);
} }
void Testmatrix4x4Comparison (void) { void Testmatrix4x4Comparison(void)
scalar_t initArray[] = { 0, 1, 2, 3, {
4, 5, 6, 7, scalar_t initArray[] = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15};
8, 9, 10, 11, scalar_t initArray2[] = {1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1};
12, 13, 14, 15 };
scalar_t initArray2[] = { 1, 1, 1, 1,
1, 1, 1, 1,
1, 1, 1, 1,
1, 1, 1, 1 };
matrix4x4 alpha, beta, gamma; matrix4x4 alpha, beta, gamma;
alpha.C_Matrix(initArray); alpha.C_Matrix(initArray);
beta.C_Matrix(initArray); beta.C_Matrix(initArray);
@@ -295,45 +335,43 @@ void Testmatrix4x4Comparison (void) {
ReportFailure(matrix4x4Name, "comparison test 3", !(alpha < beta)); ReportFailure(matrix4x4Name, "comparison test 3", !(alpha < beta));
} }
void Testmatrix4x4BinaryOps (void) { void Testmatrix4x4BinaryOps(void)
scalar_t initVector[] = { 0, 1, 2, 3 }; {
scalar_t initMatrix[] = { 0, 1, 2, 3, scalar_t initVector[] = {0, 1, 2, 3};
4, 5, 6, 7, scalar_t initMatrix[] = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15};
8, 9, 10, 11, scalar_t resultVector[] = {0 * 0 + 1 * 1 + 2 * 2 + 3 * 3, 0 * 4 + 1 * 5 + 2 * 6 + 3 * 7,
12, 13, 14, 15 }; 0 * 8 + 1 * 9 + 2 * 10 + 3 * 11, 0 * 12 + 1 * 13 + 2 * 14 + 3 * 15};
scalar_t resultVector[] = { 0 * 0 + 1 * 1 + 2 * 2 + 3 * 3,
0 * 4 + 1 * 5 + 2 * 6 + 3 * 7,
0 * 8 + 1 * 9 + 2 * 10 + 3 * 11,
0 * 12 + 1 * 13 + 2 * 14 + 3 * 15 };
vector3 vector1 (initVector, 4); vector3 vector1(initVector, 4);
matrix4x4 matrix1; matrix4x4 matrix1;
matrix1.C_Matrix(initMatrix); matrix1.C_Matrix(initMatrix);
vector3 vectorTest (resultVector, 4); vector3 vectorTest(resultVector, 4);
ReportFailure (matrix4x4Name, "matrix * vector", vectorTest == matrix1 * vector1); ReportFailure(matrix4x4Name, "matrix * vector", vectorTest == matrix1 * vector1);
scalar_t initMatrix2[] = { 15, 14, 13, 12, scalar_t initMatrix2[] = {15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0};
11, 10, 9, 8,
7, 6, 5, 4,
3, 2, 1, 0 };
matrix4x4 matrix2; matrix4x4 matrix2;
matrix2.C_Matrix(initMatrix2); matrix2.C_Matrix(initMatrix2);
matrix4x4 resultMatrix; matrix4x4 resultMatrix;
for (int x=0;x<4;++x) for (int y=0;y<4;++y) { for (int x = 0; x < 4; ++x)
for (int y = 0; y < 4; ++y)
{
resultMatrix(x)[y] = 0; resultMatrix(x)[y] = 0;
for (int i=0;i<4;++i) resultMatrix(x)[y] += matrix1[i][y] * matrix2[x][i]; for (int i = 0; i < 4; ++i)
resultMatrix(x)[y] += matrix1[i][y] * matrix2[x][i];
} }
ReportFailure (matrix4x4Name, "matrix * matrix", resultMatrix == matrix1 * matrix2); ReportFailure(matrix4x4Name, "matrix * matrix", resultMatrix == matrix1 * matrix2);
} }
void Testmatrix4x4 (void) { void Testmatrix4x4(void)
{
Testmatrix4x4Constructors(); Testmatrix4x4Constructors();
Testmatrix4x4Comparison(); Testmatrix4x4Comparison();
Testmatrix4x4BinaryOps(); Testmatrix4x4BinaryOps();
} }
int main (int, char*[]) { int main(int, char *[])
{
int vectorFailures = 0; int vectorFailures = 0;
int matrixFailures = 0; int matrixFailures = 0;
Testvector3(); Testvector3();
@@ -347,12 +385,13 @@ int main (int, char*[]) {
cout << "* *" << endl; cout << "* *" << endl;
if (vectorFailures + matrixFailures == 0) if (vectorFailures + matrixFailures == 0)
cout << "* No failures detected in Math3D *" << endl; cout << "* No failures detected in Math3D *" << endl;
else { else
{
cout << "* FAILURES DETECTED IN MATH3D! *" << endl; cout << "* FAILURES DETECTED IN MATH3D! *" << endl;
cout << "* Total vector3 failures: " << vectorFailures << " *" << endl; cout << "* Total vector3 failures: " << vectorFailures << " *" << endl;
cout << "* Total matrix4x4 failures: " << matrixFailures << " *" << endl; cout << "* Total matrix4x4 failures: " << matrixFailures << " *" << endl;
cout << "* Total Failures in Math3D: " << vectorFailures + matrixFailures << " *" << endl; cout << "* Total Failures in Math3D: " << vectorFailures + matrixFailures << " *"
<< endl;
} }
cout << "* *" << endl; cout << "* *" << endl;
cout << "****************************************" << endl; cout << "****************************************" << endl;

507
dumb3d.h
View File

@@ -4,7 +4,8 @@
//#include <cmath> //#include <cmath>
#include <fastmath.h> #include <fastmath.h>
namespace Math3D { namespace Math3D
{
// Define this to have Math3D.cp generate a main which tests these classes // Define this to have Math3D.cp generate a main which tests these classes
//#define TEST_MATH3D //#define TEST_MATH3D
@@ -17,16 +18,20 @@ namespace Math3D {
typedef double scalar_t; typedef double scalar_t;
// inline pass-throughs to various basic math functions // inline pass-throughs to various basic math functions
// written in this style to allow for easy substitution with more efficient versions // written in this style to allow for easy substitution with more efficient versions
inline scalar_t SINE_FUNCTION (scalar_t x) { return sin(x); } inline scalar_t SINE_FUNCTION(scalar_t x) { return sin(x); }
inline scalar_t COSINE_FUNCTION (scalar_t x) { return cos(x); } inline scalar_t COSINE_FUNCTION(scalar_t x) { return cos(x); }
inline scalar_t SQRT_FUNCTION (scalar_t x) { return sqrt(x); } inline scalar_t SQRT_FUNCTION(scalar_t x) { return sqrt(x); }
// 2 element vector // 2 element vector
class vector2 { class vector2
public: {
vector2 (void) {} public:
__fastcall vector2 (scalar_t a, scalar_t b) vector2(void) {}
{ x=a; y=b; } __fastcall vector2(scalar_t a, scalar_t b)
{
x = a;
y = b;
}
double x; double x;
union union
{ {
@@ -35,15 +40,20 @@ public:
}; };
}; };
// 3 element vector // 3 element vector
class vector3 { class vector3
public: {
vector3 (void) {} public:
__fastcall vector3 (scalar_t a, scalar_t b, scalar_t c) vector3(void) {}
{ x=a; y=b; z=c; } __fastcall vector3(scalar_t a, scalar_t b, scalar_t c)
{
x = a;
y = b;
z = c;
}
// The int parameter is the number of elements to copy from initArray (3 or 4) // The int parameter is the number of elements to copy from initArray (3 or 4)
// explicit vector3(scalar_t* initArray, int arraySize = 3) // explicit vector3(scalar_t* initArray, int arraySize = 3)
// { for (int i = 0;i<arraySize;++i) e[i] = initArray[i]; } // { for (int i = 0;i<arraySize;++i) e[i] = initArray[i]; }
void __fastcall RotateX(double angle); void __fastcall RotateX(double angle);
void __fastcall RotateY(double angle); void __fastcall RotateY(double angle);
@@ -52,286 +62,360 @@ public:
void inline __fastcall Normalize(); void inline __fastcall Normalize();
void inline __fastcall SafeNormalize(); void inline __fastcall SafeNormalize();
double inline __fastcall Length(); double inline __fastcall Length();
void inline __fastcall Zero() {x=y=z=0.0;}; void inline __fastcall Zero() { x = y = z = 0.0; };
// [] is to read, () is to write (const correctness) // [] is to read, () is to write (const correctness)
// const scalar_t& operator[] (int i) const { return e[i]; } // const scalar_t& operator[] (int i) const { return e[i]; }
// scalar_t& operator() (int i) { return e[i]; } // scalar_t& operator() (int i) { return e[i]; }
// Provides access to the underlying array; useful for passing this class off to C APIs // Provides access to the underlying array; useful for passing this class off to C APIs
const scalar_t* readArray(void) { return &x; } const scalar_t *readArray(void) { return &x; }
scalar_t* getArray(void) { return &x; } scalar_t *getArray(void) { return &x; }
// union // union
// { // {
// struct // struct
// { // {
double x,y,z; double x, y, z;
// }; // };
// scalar_t e[3]; // scalar_t e[3];
// }; // };
bool inline __fastcall Equal(vector3 *v) bool inline __fastcall Equal(vector3 *v)
{//sprawdzenie odleg³oœci punktów { // sprawdzenie odleg³oœci punktów
if (fabs(x-v->x)>0.02) return false; //szeœcian zamiast kuli if (fabs(x - v->x) > 0.02)
if (fabs(z-v->z)>0.02) return false; return false; // szeœcian zamiast kuli
if (fabs(y-v->y)>0.02) return false; if (fabs(z - v->z) > 0.02)
return false;
if (fabs(y - v->y) > 0.02)
return false;
return true; return true;
}; };
private: private:
}; };
// 4 element matrix // 4 element matrix
class matrix4x4 { class matrix4x4
public: {
matrix4x4 (void) {} public:
matrix4x4(void) {}
// When defining matrices in C arrays, it is easiest to define them with // When defining matrices in C arrays, it is easiest to define them with
// the column increasing fastest. However, some APIs (OpenGL in particular) do this // the column increasing fastest. However, some APIs (OpenGL in particular) do this
// backwards, hence the "constructor" from C matrices, or from OpenGL matrices. // backwards, hence the "constructor" from C matrices, or from OpenGL matrices.
// Note that matrices are stored internally in OpenGL format. // Note that matrices are stored internally in OpenGL format.
void C_Matrix (scalar_t* initArray) void C_Matrix(scalar_t *initArray)
{ int i = 0; for (int y=0;y<4;++y) for (int x=0;x<4;++x) (*this)(x)[y] = initArray[i++]; } {
void OpenGL_Matrix (scalar_t* initArray) int i = 0;
{ int i = 0; for (int x = 0; x < 4; ++x) for (int y=0;y<4;++y) (*this)(x)[y] = initArray[i++]; } for (int y = 0; y < 4; ++y)
for (int x = 0; x < 4; ++x)
(*this)(x)[y] = initArray[i++];
}
void OpenGL_Matrix(scalar_t *initArray)
{
int i = 0;
for (int x = 0; x < 4; ++x)
for (int y = 0; y < 4; ++y)
(*this)(x)[y] = initArray[i++];
}
// [] is to read, () is to write (const correctness) // [] is to read, () is to write (const correctness)
// m[x][y] or m(x)[y] is the correct form // m[x][y] or m(x)[y] is the correct form
const scalar_t* operator[] (int i) const { return &e[i<<2]; } const scalar_t *operator[](int i) const { return &e[i << 2]; }
scalar_t* operator() (int i) { return &e[i<<2]; } scalar_t *operator()(int i) { return &e[i << 2]; }
// Low-level access to the array. // Low-level access to the array.
const scalar_t* readArray (void) { return e; } const scalar_t *readArray(void) { return e; }
scalar_t* getArray(void) { return e; } scalar_t *getArray(void) { return e; }
// Construct various matrices; REPLACES CURRENT CONTENTS OF THE MATRIX! // Construct various matrices; REPLACES CURRENT CONTENTS OF THE MATRIX!
// Written this way to work in-place and hence be somewhat more efficient // Written this way to work in-place and hence be somewhat more efficient
void Identity (void) { for (int i=0;i<16;++i) e[i] = 0; e[0] = 1; e[5] = 1; e[10] = 1; e[15] = 1; } void Identity(void)
inline matrix4x4& Rotation (scalar_t angle, vector3 axis); {
inline matrix4x4& Translation(const vector3& translation); for (int i = 0; i < 16; ++i)
inline matrix4x4& Scale (scalar_t x, scalar_t y, scalar_t z); e[i] = 0;
inline matrix4x4& BasisChange (const vector3& v, const vector3& n); e[0] = 1;
inline matrix4x4& BasisChange (const vector3& u, const vector3& v, const vector3& n); e[5] = 1;
inline matrix4x4& ProjectionMatrix (bool perspective, scalar_t l, scalar_t r, scalar_t t, scalar_t b, scalar_t n, scalar_t f); e[10] = 1;
e[15] = 1;
}
inline matrix4x4 &Rotation(scalar_t angle, vector3 axis);
inline matrix4x4 &Translation(const vector3 &translation);
inline matrix4x4 &Scale(scalar_t x, scalar_t y, scalar_t z);
inline matrix4x4 &BasisChange(const vector3 &v, const vector3 &n);
inline matrix4x4 &BasisChange(const vector3 &u, const vector3 &v, const vector3 &n);
inline matrix4x4 &ProjectionMatrix(bool perspective, scalar_t l, scalar_t r, scalar_t t,
scalar_t b, scalar_t n, scalar_t f);
void InitialRotate() void InitialRotate()
{//taka specjalna rotacja, nie ma co ci¹gaæ trygonometrii { // taka specjalna rotacja, nie ma co ci¹gaæ trygonometrii
double f; double f;
for (int i=0;i<16;i+=4) for (int i = 0; i < 16; i += 4)
{e[i]=-e[i]; //zmiana znaku X {
f=e[i+1]; e[i+1]=e[i+2]; e[i+2]=f; //zamiana Y i Z e[i] = -e[i]; // zmiana znaku X
f = e[i + 1];
e[i + 1] = e[i + 2];
e[i + 2] = f; // zamiana Y i Z
} }
}; };
inline bool IdentityIs() inline bool IdentityIs()
{//sprawdzenie jednostkowoœci { // sprawdzenie jednostkowoœci
for (int i=0;i<16;++i) for (int i = 0; i < 16; ++i)
if (e[i]!=((i%5)?0.0:1.0)) //jedynki tylko na 0, 5, 10 i 15 if (e[i] != ((i % 5) ? 0.0 : 1.0)) // jedynki tylko na 0, 5, 10 i 15
return false; return false;
return true; return true;
} }
private: private:
scalar_t e[16]; scalar_t e[16];
}; };
// Scalar operations // Scalar operations
// Returns false if there are 0 solutions // Returns false if there are 0 solutions
inline bool SolveQuadratic (scalar_t a, scalar_t b, scalar_t c, scalar_t* x1, scalar_t* x2); inline bool SolveQuadratic(scalar_t a, scalar_t b, scalar_t c, scalar_t *x1, scalar_t *x2);
// Vector operations // Vector operations
inline bool operator== (const vector3&, const vector3&); inline bool operator==(const vector3 &, const vector3 &);
inline bool operator< (const vector3&, const vector3&); inline bool operator<(const vector3 &, const vector3 &);
inline vector3 operator- (const vector3&); inline vector3 operator-(const vector3 &);
inline vector3 operator* (const vector3&, scalar_t); inline vector3 operator*(const vector3 &, scalar_t);
inline vector3 operator* (scalar_t, const vector3&); inline vector3 operator*(scalar_t, const vector3 &);
inline vector3& operator*= (vector3&, scalar_t); inline vector3 &operator*=(vector3 &, scalar_t);
inline vector3 operator/ (const vector3&, scalar_t); inline vector3 operator/(const vector3 &, scalar_t);
inline vector3& operator/= (vector3&, scalar_t); inline vector3 &operator/=(vector3 &, scalar_t);
inline vector3 operator+ (const vector3&, const vector3&); inline vector3 operator+(const vector3 &, const vector3 &);
inline vector3& operator+= (vector3&, const vector3&); inline vector3 &operator+=(vector3 &, const vector3 &);
inline vector3 operator- (const vector3&, const vector3&); inline vector3 operator-(const vector3 &, const vector3 &);
inline vector3& operator-= (vector3&, const vector3&); inline vector3 &operator-=(vector3 &, const vector3 &);
// X3 is the 3 element version of a function, X4 is four element // X3 is the 3 element version of a function, X4 is four element
inline scalar_t LengthSquared3 (const vector3&); inline scalar_t LengthSquared3(const vector3 &);
inline scalar_t LengthSquared4 (const vector3&); inline scalar_t LengthSquared4(const vector3 &);
inline scalar_t Length3 (const vector3&); inline scalar_t Length3(const vector3 &);
inline scalar_t Length4 (const vector3&); inline scalar_t Length4(const vector3 &);
inline vector3 Normalize (const vector3&); inline vector3 Normalize(const vector3 &);
inline vector3 Normalize4 (const vector3&); inline vector3 Normalize4(const vector3 &);
inline scalar_t DotProduct (const vector3&, const vector3&); inline scalar_t DotProduct(const vector3 &, const vector3 &);
inline scalar_t DotProduct4 (const vector3&, const vector3&); inline scalar_t DotProduct4(const vector3 &, const vector3 &);
// Cross product is only defined for 3 elements // Cross product is only defined for 3 elements
inline vector3 CrossProduct (const vector3&, const vector3&); inline vector3 CrossProduct(const vector3 &, const vector3 &);
inline vector3 operator* (const matrix4x4&, const vector3&); inline vector3 operator*(const matrix4x4 &, const vector3 &);
// Matrix operations // Matrix operations
inline bool operator== (const matrix4x4&, const matrix4x4&); inline bool operator==(const matrix4x4 &, const matrix4x4 &);
inline bool operator< (const matrix4x4&, const matrix4x4&); inline bool operator<(const matrix4x4 &, const matrix4x4 &);
inline matrix4x4 operator* (const matrix4x4&, const matrix4x4&); inline matrix4x4 operator*(const matrix4x4 &, const matrix4x4 &);
inline matrix4x4 Transpose (const matrix4x4&); inline matrix4x4 Transpose(const matrix4x4 &);
scalar_t Determinant (const matrix4x4&); scalar_t Determinant(const matrix4x4 &);
matrix4x4 Adjoint (const matrix4x4&); matrix4x4 Adjoint(const matrix4x4 &);
matrix4x4 Inverse (const matrix4x4&); matrix4x4 Inverse(const matrix4x4 &);
// Inline implementations follow // Inline implementations follow
inline bool SolveQuadratic (scalar_t a, scalar_t b, scalar_t c, scalar_t* x1, scalar_t* x2) { inline bool SolveQuadratic(scalar_t a, scalar_t b, scalar_t c, scalar_t *x1, scalar_t *x2)
{
// If a == 0, solve a linear equation // If a == 0, solve a linear equation
if (a == 0) { if (a == 0)
if (b == 0) return false; {
if (b == 0)
return false;
*x1 = c / b; *x1 = c / b;
*x2 = *x1; *x2 = *x1;
return true; return true;
} else { }
else
{
scalar_t det = b * b - 4 * a * c; scalar_t det = b * b - 4 * a * c;
if (det < 0) return false; if (det < 0)
return false;
det = SQRT_FUNCTION(det) / (2 * a); det = SQRT_FUNCTION(det) / (2 * a);
scalar_t prefix = -b / (2*a); scalar_t prefix = -b / (2 * a);
*x1 = prefix + det; *x1 = prefix + det;
*x2 = prefix - det; *x2 = prefix - det;
return true; return true;
} }
} }
inline bool operator== (const vector3& v1, const vector3& v2) inline bool operator==(const vector3 &v1, const vector3 &v2)
{ return (v1.x==v2.x&&v1.y==v2.y&&v1.z==v2.z); } {
return (v1.x == v2.x && v1.y == v2.y && v1.z == v2.z);
}
inline bool operator< (const vector3& v1, const vector3& v2) { inline bool operator<(const vector3 &v1, const vector3 &v2)
// for (int i=0;i<4;++i) {
// for (int i=0;i<4;++i)
// if (v1[i] < v2[i]) return true; // if (v1[i] < v2[i]) return true;
// else if (v1[i] > v2[i]) return false; // else if (v1[i] > v2[i]) return false;
return false; return false;
} }
inline vector3 operator- (const vector3& v) inline vector3 operator-(const vector3 &v) { return vector3(-v.x, -v.y, -v.z); }
{ return vector3(-v.x, -v.y, -v.z); }
inline vector3 operator* (const vector3& v, scalar_t k) inline vector3 operator*(const vector3 &v, scalar_t k)
{ return vector3(k*v.x, k*v.y, k*v.z); }
inline vector3 operator* (scalar_t k, const vector3& v)
{ return v * k; }
inline vector3& operator*= (vector3& v, scalar_t k)
{ v.x*= k; v.y*= k; v.z*= k; return v; };
inline vector3 operator/ (const vector3& v, scalar_t k)
{ return vector3(v.x/k, v.y/k, v.z/k); }
inline vector3& operator/= (vector3& v, scalar_t k)
{ v.x/= k; v.y/= k; v.z/= k; return v; }
inline scalar_t LengthSquared3 (const vector3& v)
{ return DotProduct(v,v); }
inline scalar_t LengthSquared4 (const vector3& v)
{ return DotProduct4(v,v); }
inline scalar_t Length3 (const vector3& v)
{ return SQRT_FUNCTION(LengthSquared3(v)); }
inline scalar_t Length4 (const vector3& v)
{ return SQRT_FUNCTION(LengthSquared4(v)); }
inline vector3 Normalize (const vector3& v)
{ vector3 retVal = v / Length3(v); return retVal; }
inline vector3 SafeNormalize(const vector3& v)
{ {
double l= Length3(v); return vector3(k * v.x, k * v.y, k * v.z);
vector3 retVal; }
if (l==0)
retVal.x=retVal.y=retVal.z=0; inline vector3 operator*(scalar_t k, const vector3 &v) { return v * k; }
else
retVal=v/l; inline vector3 &operator*=(vector3 &v, scalar_t k)
{
v.x *= k;
v.y *= k;
v.z *= k;
return v;
};
inline vector3 operator/(const vector3 &v, scalar_t k)
{
return vector3(v.x / k, v.y / k, v.z / k);
}
inline vector3 &operator/=(vector3 &v, scalar_t k)
{
v.x /= k;
v.y /= k;
v.z /= k;
return v;
}
inline scalar_t LengthSquared3(const vector3 &v) { return DotProduct(v, v); }
inline scalar_t LengthSquared4(const vector3 &v) { return DotProduct4(v, v); }
inline scalar_t Length3(const vector3 &v) { return SQRT_FUNCTION(LengthSquared3(v)); }
inline scalar_t Length4(const vector3 &v) { return SQRT_FUNCTION(LengthSquared4(v)); }
inline vector3 Normalize(const vector3 &v)
{
vector3 retVal = v / Length3(v);
return retVal; return retVal;
} }
inline vector3 Normalize4 (const vector3& v) inline vector3 SafeNormalize(const vector3 &v)
{ return v / Length4(v); } {
double l = Length3(v);
vector3 retVal;
if (l == 0)
retVal.x = retVal.y = retVal.z = 0;
else
retVal = v / l;
return retVal;
}
inline vector3 Normalize4(const vector3 &v) { return v / Length4(v); }
inline vector3 operator+ (const vector3& v1, const vector3& v2) inline vector3 operator+(const vector3 &v1, const vector3 &v2)
{ return vector3(v1.x+v2.x, v1.y+v2.y, v1.z+v2.z); } {
return vector3(v1.x + v2.x, v1.y + v2.y, v1.z + v2.z);
inline vector3& operator+= (vector3& v1, const vector3& v2)
{ v1.x+= v2.x; v1.y+= v2.y; v1.z+= v2.z; return v1;}
inline vector3 operator- (const vector3& v1, const vector3& v2)
{ return vector3(v1.x-v2.x, v1.y-v2.y, v1.z-v2.z); }
inline vector3& operator-= (vector3& v1, const vector3& v2)
{ v1.x-= v2.x; v1.y-= v2.y; v1.z-= v2.z; return v1;}
inline scalar_t DotProduct (const vector3& v1, const vector3& v2)
{ return v1.x*v2.x + v1.y*v2.y + v1.z*v2.z; }
inline scalar_t DotProduct4 (const vector3& v1, const vector3& v2)
{ return v1.x*v2.x + v1.y*v2.y + v1.z*v2.z; }
inline vector3 CrossProduct (const vector3& v1, const vector3& v2) {
return vector3( v1.y * v2.z - v1.z * v2.y
,v2.x * v1.z - v2.z * v1.x
,v1.x * v2.y - v1.y * v2.x);
} }
inline vector3 operator* (const matrix4x4& m, const vector3& v) { inline vector3 &operator+=(vector3 &v1, const vector3 &v2)
return vector3( v.x*m[0][0] + v.y*m[1][0] + v.z*m[2][0] + m[3][0], {
v.x*m[0][1] + v.y*m[1][1] + v.z*m[2][1] + m[3][1], v1.x += v2.x;
v.x*m[0][2] + v.y*m[1][2] + v.z*m[2][2] + m[3][2]); v1.y += v2.y;
v1.z += v2.z;
return v1;
}
inline vector3 operator-(const vector3 &v1, const vector3 &v2)
{
return vector3(v1.x - v2.x, v1.y - v2.y, v1.z - v2.z);
}
inline vector3 &operator-=(vector3 &v1, const vector3 &v2)
{
v1.x -= v2.x;
v1.y -= v2.y;
v1.z -= v2.z;
return v1;
}
inline scalar_t DotProduct(const vector3 &v1, const vector3 &v2)
{
return v1.x * v2.x + v1.y * v2.y + v1.z * v2.z;
}
inline scalar_t DotProduct4(const vector3 &v1, const vector3 &v2)
{
return v1.x * v2.x + v1.y * v2.y + v1.z * v2.z;
}
inline vector3 CrossProduct(const vector3 &v1, const vector3 &v2)
{
return vector3(v1.y * v2.z - v1.z * v2.y, v2.x * v1.z - v2.z * v1.x, v1.x * v2.y - v1.y * v2.x);
}
inline vector3 operator*(const matrix4x4 &m, const vector3 &v)
{
return vector3(v.x * m[0][0] + v.y * m[1][0] + v.z * m[2][0] + m[3][0],
v.x * m[0][1] + v.y * m[1][1] + v.z * m[2][1] + m[3][1],
v.x * m[0][2] + v.y * m[1][2] + v.z * m[2][2] + m[3][2]);
} }
void inline __fastcall vector3::Normalize() void inline __fastcall vector3::Normalize()
{ {
double il= 1/Length(); double il = 1 / Length();
x*= il; x *= il;
y*= il; y *= il;
z*= il; z *= il;
} }
double inline __fastcall vector3::Length() double inline __fastcall vector3::Length() { return SQRT_FUNCTION(x * x + y * y + z * z); }
inline bool operator==(const matrix4x4 &m1, const matrix4x4 &m2)
{ {
return SQRT_FUNCTION(x*x+y*y+z*z); for (int x = 0; x < 4; ++x)
} for (int y = 0; y < 4; ++y)
if (m1[x][y] != m2[x][y])
inline bool operator== (const matrix4x4& m1, const matrix4x4& m2) { return false;
for (int x=0;x<4;++x) for (int y=0;y<4;++y)
if (m1[x][y] != m2[x][y]) return false;
return true; return true;
} }
inline bool operator< (const matrix4x4& m1, const matrix4x4& m2) { inline bool operator<(const matrix4x4 &m1, const matrix4x4 &m2)
for (int x=0;x<4;++x) for (int y=0;y<4;++y) {
if (m1[x][y] < m2[x][y]) return true; for (int x = 0; x < 4; ++x)
else if (m1[x][y] > m2[x][y]) return false; for (int y = 0; y < 4; ++y)
if (m1[x][y] < m2[x][y])
return true;
else if (m1[x][y] > m2[x][y])
return false;
return false; return false;
} }
inline matrix4x4 operator* (const matrix4x4& m1, const matrix4x4& m2) { inline matrix4x4 operator*(const matrix4x4 &m1, const matrix4x4 &m2)
{
matrix4x4 retVal; matrix4x4 retVal;
for (int x=0;x<4;++x) for (int y=0;y<4;++y) { for (int x = 0; x < 4; ++x)
for (int y = 0; y < 4; ++y)
{
retVal(x)[y] = 0; retVal(x)[y] = 0;
for (int i=0;i<4;++i) retVal(x)[y] += m1[i][y] * m2[x][i]; for (int i = 0; i < 4; ++i)
retVal(x)[y] += m1[i][y] * m2[x][i];
} }
return retVal; return retVal;
} }
inline matrix4x4 Transpose (const matrix4x4& m) { inline matrix4x4 Transpose(const matrix4x4 &m)
{
matrix4x4 retVal; matrix4x4 retVal;
for (int x=0;x<4;++x) for (int y=0;y<4;++y) for (int x = 0; x < 4; ++x)
for (int y = 0; y < 4; ++y)
retVal(x)[y] = m[y][x]; retVal(x)[y] = m[y][x];
return retVal; return retVal;
} }
inline matrix4x4& matrix4x4::Rotation (scalar_t angle, vector3 axis) { inline matrix4x4 &matrix4x4::Rotation(scalar_t angle, vector3 axis)
{
scalar_t c = COSINE_FUNCTION(angle); scalar_t c = COSINE_FUNCTION(angle);
scalar_t s = SINE_FUNCTION(angle); scalar_t s = SINE_FUNCTION(angle);
// One minus c (short name for legibility of formulai) // One minus c (short name for legibility of formulai)
scalar_t omc = (1 - c); scalar_t omc = (1 - c);
if (LengthSquared3(axis) != 1) axis = Normalize(axis); if (LengthSquared3(axis) != 1)
axis = Normalize(axis);
scalar_t x = axis.x; scalar_t x = axis.x;
scalar_t y = axis.y; scalar_t y = axis.y;
@@ -343,19 +427,19 @@ inline matrix4x4& matrix4x4::Rotation (scalar_t angle, vector3 axis) {
scalar_t xzomc = x * z * omc; scalar_t xzomc = x * z * omc;
scalar_t yzomc = y * z * omc; scalar_t yzomc = y * z * omc;
e[0] = x*x*omc + c; e[0] = x * x * omc + c;
e[1] = xyomc + zs; e[1] = xyomc + zs;
e[2] = xzomc - ys; e[2] = xzomc - ys;
e[3] = 0; e[3] = 0;
e[4] = xyomc - zs; e[4] = xyomc - zs;
e[5] = y*y*omc + c; e[5] = y * y * omc + c;
e[6] = yzomc + xs; e[6] = yzomc + xs;
e[7] = 0; e[7] = 0;
e[8] = xzomc + ys; e[8] = xzomc + ys;
e[9] = yzomc - xs; e[9] = yzomc - xs;
e[10] = z*z*omc + c; e[10] = z * z * omc + c;
e[11] = 0; e[11] = 0;
e[12] = 0; e[12] = 0;
@@ -366,7 +450,8 @@ inline matrix4x4& matrix4x4::Rotation (scalar_t angle, vector3 axis) {
return *this; return *this;
} }
inline matrix4x4& matrix4x4::Translation(const vector3& translation) { inline matrix4x4 &matrix4x4::Translation(const vector3 &translation)
{
Identity(); Identity();
e[12] = translation.x; e[12] = translation.x;
e[13] = translation.y; e[13] = translation.y;
@@ -374,7 +459,8 @@ inline matrix4x4& matrix4x4::Translation(const vector3& translation) {
return *this; return *this;
} }
inline matrix4x4& matrix4x4::Scale (scalar_t x, scalar_t y, scalar_t z) { inline matrix4x4 &matrix4x4::Scale(scalar_t x, scalar_t y, scalar_t z)
{
Identity(); Identity();
e[0] = x; e[0] = x;
e[5] = y; e[5] = y;
@@ -382,7 +468,8 @@ inline matrix4x4& matrix4x4::Scale (scalar_t x, scalar_t y, scalar_t z) {
return *this; return *this;
} }
inline matrix4x4& matrix4x4::BasisChange (const vector3& u, const vector3& v, const vector3& n) { inline matrix4x4 &matrix4x4::BasisChange(const vector3 &u, const vector3 &v, const vector3 &n)
{
e[0] = u.x; e[0] = u.x;
e[1] = v.x; e[1] = v.x;
e[2] = n.x; e[2] = n.x;
@@ -406,21 +493,24 @@ inline matrix4x4& matrix4x4::BasisChange (const vector3& u, const vector3& v, co
return *this; return *this;
} }
inline matrix4x4& matrix4x4::BasisChange (const vector3& v, const vector3& n) { inline matrix4x4 &matrix4x4::BasisChange(const vector3 &v, const vector3 &n)
vector3 u = CrossProduct(v,n); {
return BasisChange (u, v, n); vector3 u = CrossProduct(v, n);
return BasisChange(u, v, n);
} }
inline matrix4x4& matrix4x4::ProjectionMatrix (bool perspective, scalar_t left_plane, scalar_t right_plane, inline matrix4x4 &matrix4x4::ProjectionMatrix(bool perspective, scalar_t left_plane,
scalar_t top_plane, scalar_t bottom_plane, scalar_t right_plane, scalar_t top_plane,
scalar_t near_plane, scalar_t far_plane) scalar_t bottom_plane, scalar_t near_plane,
scalar_t far_plane)
{ {
scalar_t A = (right_plane + left_plane) / (right_plane - left_plane); scalar_t A = (right_plane + left_plane) / (right_plane - left_plane);
scalar_t B = (top_plane + bottom_plane) / (top_plane - bottom_plane); scalar_t B = (top_plane + bottom_plane) / (top_plane - bottom_plane);
scalar_t C = (far_plane + near_plane) / (far_plane - near_plane); scalar_t C = (far_plane + near_plane) / (far_plane - near_plane);
Identity(); Identity();
if (perspective) { if (perspective)
{
e[0] = 2 * near_plane / (right_plane - left_plane); e[0] = 2 * near_plane / (right_plane - left_plane);
e[5] = 2 * near_plane / (top_plane - bottom_plane); e[5] = 2 * near_plane / (top_plane - bottom_plane);
e[8] = A; e[8] = A;
@@ -428,7 +518,9 @@ inline matrix4x4& matrix4x4::ProjectionMatrix (bool perspective, scalar_t left_
e[10] = C; e[10] = C;
e[11] = -1; e[11] = -1;
e[14] = 2 * far_plane * near_plane / (far_plane - near_plane); e[14] = 2 * far_plane * near_plane / (far_plane - near_plane);
} else { }
else
{
e[0] = 2 / (right_plane - left_plane); e[0] = 2 / (right_plane - left_plane);
e[5] = 2 / (top_plane - bottom_plane); e[5] = 2 / (top_plane - bottom_plane);
e[10] = -2 / (far_plane - near_plane); e[10] = -2 / (far_plane - near_plane);
@@ -439,9 +531,9 @@ inline matrix4x4& matrix4x4::ProjectionMatrix (bool perspective, scalar_t left_
return *this; return *this;
} }
double inline __fastcall SquareMagnitude(const vector3& v) double inline __fastcall SquareMagnitude(const vector3 &v)
{ {
return v.x*v.x+v.y*v.y+v.z*v.z; return v.x * v.x + v.y * v.y + v.z * v.z;
} }
} // close namespace } // close namespace
@@ -454,17 +546,20 @@ double inline __fastcall SquareMagnitude(const vector3& v)
#ifdef OSTREAM_MATH3D #ifdef OSTREAM_MATH3D
#include <ostream> #include <ostream>
// Streaming support // Streaming support
std::ostream& operator<< (std::ostream& os, const Math3D::vector3& v) { std::ostream &operator<<(std::ostream &os, const Math3D::vector3 &v)
{
os << '['; os << '[';
for (int i=0; i<4; ++i) for (int i = 0; i < 4; ++i)
os << ' ' << v[i]; os << ' ' << v[i];
return os << ']'; return os << ']';
} }
std::ostream& operator<< (std::ostream& os, const Math3D::matrix4x4& m) { std::ostream &operator<<(std::ostream &os, const Math3D::matrix4x4 &m)
for (int y=0; y<4; ++y) { {
for (int y = 0; y < 4; ++y)
{
os << '['; os << '[';
for (int x=0;x<4;++x) for (int x = 0; x < 4; ++x)
os << ' ' << m[x][y]; os << ' ' << m[x][y];
os << " ]" << std::endl; os << " ]" << std::endl;
} }

86
geometry.cpp
View File

@@ -4,113 +4,97 @@
#include "Geometry.h" #include "Geometry.h"
inline double __fastcall sqr(double a) { return ( a*a ); }; inline double __fastcall sqr(double a) { return (a * a); };
__fastcall TLine::TLine() __fastcall TLine::TLine(){};
{
};
__fastcall TLine::TLine(vector3 NPoint, vector3 NVector) __fastcall TLine::TLine(vector3 NPoint, vector3 NVector)
{ {
Vector= NVector; Point= NPoint; Vector = NVector;
Point = NPoint;
}; };
__fastcall TLine::~TLine() __fastcall TLine::~TLine(){};
{
};
TPlane __fastcall TLine::GetPlane() TPlane __fastcall TLine::GetPlane() { return (TPlane(Point, Vector)); };
{
return(TPlane(Point,Vector));
};
double __fastcall TLine::GetDistance(vector3 Point1) double __fastcall TLine::GetDistance(vector3 Point1)
{ {
return ( (sqr((Point1.x-Point.x)*Vector.x-(Point1.y-Point.y)*Vector.y)- return ((sqr((Point1.x - Point.x) * Vector.x - (Point1.y - Point.y) * Vector.y) -
sqr((Point1.y-Point.y)*Vector.y-(Point1.z-Point.z)*Vector.z)- sqr((Point1.y - Point.y) * Vector.y - (Point1.z - Point.z) * Vector.z) -
sqr((Point1.z-Point.z)*Vector.z-(Point1.x-Point.x)*Vector.x))/ sqr((Point1.z - Point.z) * Vector.z - (Point1.x - Point.x) * Vector.x)) /
(sqr(Vector.x)+sqr(Vector.y)+sqr(Vector.z)) ); (sqr(Vector.x) + sqr(Vector.y) + sqr(Vector.z)));
; ;
}; };
//--------------------------------------------------------------------------- //---------------------------------------------------------------------------
__fastcall TPlane::TPlane() __fastcall TPlane::TPlane()
{ {
Vector= vector3(0,0,0); Vector = vector3(0, 0, 0);
d= 0; d = 0;
}; };
__fastcall TPlane::TPlane(vector3 NVector, double nd) __fastcall TPlane::TPlane(vector3 NVector, double nd)
{ {
Vector= NVector; d= nd; Vector = NVector;
d = nd;
} }
__fastcall TPlane::TPlane(vector3 Point, vector3 NVector) __fastcall TPlane::TPlane(vector3 Point, vector3 NVector)
{ {
Vector= NVector; d= -NVector.x*Point.x-NVector.y*Point.y-NVector.z*Point.z; Vector = NVector;
d = -NVector.x * Point.x - NVector.y * Point.y - NVector.z * Point.z;
}; };
__fastcall TPlane::TPlane(vector3 Point1, vector3 Vector1, vector3 Vector2) __fastcall TPlane::TPlane(vector3 Point1, vector3 Vector1, vector3 Vector2)
{ {
Vector= CrossProduct(Vector1,Vector2); d= -Vector.x*Point1.x-Vector.y*Point1.y-Vector.z*Point1.z; Vector = CrossProduct(Vector1, Vector2);
d = -Vector.x * Point1.x - Vector.y * Point1.y - Vector.z * Point1.z;
}; };
__fastcall TPlane::~TPlane() __fastcall TPlane::~TPlane(){};
{
};
void __fastcall TPlane::Normalize() void __fastcall TPlane::Normalize()
{ {
double mgn= Vector.Length(); double mgn = Vector.Length();
Vector= Vector/mgn; d/= mgn; Vector = Vector / mgn;
d /= mgn;
}; };
double __fastcall TPlane::GetSide(vector3 Point) double __fastcall TPlane::GetSide(vector3 Point)
{ {
return (Vector.x*Point.x+Vector.y*Point.y+Vector.z*Point.z+d); return (Vector.x * Point.x + Vector.y * Point.y + Vector.z * Point.z + d);
}; };
//void __fastcall TPlane::Transform(D3DMATRIX &Transformations) // void __fastcall TPlane::Transform(D3DMATRIX &Transformations)
//{ //{
// vector3 src= Vector; // vector3 src= Vector;
// D3DMath_VectorMatrixMultiply(Vector,src,Transformations); // D3DMath_VectorMatrixMultiply(Vector,src,Transformations);
//}; //};
bool __fastcall TPlane::Defined() bool __fastcall TPlane::Defined() { return !(Vector == vector3(0, 0, 0)); };
{
return !(Vector==vector3(0,0,0));
};
//--------------------------------------------------------------------------- //---------------------------------------------------------------------------
inline double __fastcall Sum(vector3 &Vector) inline double __fastcall Sum(vector3 &Vector) { return (Vector.x + Vector.y + Vector.z); };
{
return( Vector.x+Vector.y+Vector.z );
};
bool __fastcall CrossPoint(vector3 &RetPoint, TLine &Line, TPlane &Plane) bool __fastcall CrossPoint(vector3 &RetPoint, TLine &Line, TPlane &Plane)
{ {
double ro= DotProduct(Plane.Vector,Line.Vector); double ro = DotProduct(Plane.Vector, Line.Vector);
if (ro==0) if (ro == 0)
return( false ); return (false);
ro= (DotProduct(Plane.Vector,Line.Point)+Plane.d)/ro; ro = (DotProduct(Plane.Vector, Line.Point) + Plane.d) / ro;
RetPoint= Line.Point-(Line.Vector*ro); RetPoint = Line.Point - (Line.Vector * ro);
return( true ); return (true);
}; };
inline double __fastcall GetLength(vector3& Vector) inline double __fastcall GetLength(vector3 &Vector) { return (Vector.Length()); };
{
return ( Vector.Length() );
};
inline vector3 __fastcall SetLength(vector3& Vector, double Length) inline vector3 __fastcall SetLength(vector3 &Vector, double Length)
{ {
Vector.Normalize(); Vector.Normalize();
return ( Vector*Length ); return (Vector * Length);
}; };
//--------------------------------------------------------------------------- //---------------------------------------------------------------------------
//#pragma package(smart_init) //#pragma package(smart_init)

6
geometry.h
View File

@@ -11,7 +11,7 @@ class TPlane;
class TLine class TLine
{ {
public: public:
vector3 Vector, Point; vector3 Vector, Point;
__fastcall TLine(); __fastcall TLine();
__fastcall TLine(vector3 NPoint, vector3 NVector); __fastcall TLine(vector3 NPoint, vector3 NVector);
@@ -24,7 +24,7 @@ public:
class TPlane class TPlane
{ {
public: public:
vector3 Vector; vector3 Vector;
double d; double d;
__fastcall TPlane(); __fastcall TPlane();
@@ -34,7 +34,7 @@ public:
__fastcall ~TPlane(); __fastcall ~TPlane();
void __fastcall Normalize(); void __fastcall Normalize();
double __fastcall GetSide(vector3 Point); double __fastcall GetSide(vector3 Point);
// void __fastcall Transform(D3DMATRIX &Transformations); // void __fastcall Transform(D3DMATRIX &Transformations);
bool __fastcall Defined(); bool __fastcall Defined();
}; };

151
parser.cpp
View File

@@ -10,162 +10,170 @@
*/ */
///////////////////////////////////////////////////////////////////////////////////////////////////// /////////////////////////////////////////////////////////////////////////////////////////////////////
// cParser -- generic class for parsing text data. // cParser -- generic class for parsing text data.
// constructors // constructors
cParser::cParser(std::string Stream,buffertype Type,std::string Path,bool tr) cParser::cParser(std::string Stream, buffertype Type, std::string Path, bool tr)
{ {
LoadTraction=tr; LoadTraction = tr;
// build comments map // build comments map
mComments.insert(commentmap::value_type("/*","*/")); mComments.insert(commentmap::value_type("/*", "*/"));
mComments.insert(commentmap::value_type("//","\n")); mComments.insert(commentmap::value_type("//", "\n"));
//mComments.insert(commentmap::value_type("--","\n")); //Ra: to chyba nie u¿ywane // mComments.insert(commentmap::value_type("--","\n")); //Ra: to chyba nie u¿ywane
// store to calculate sub-sequent includes from relative path // store to calculate sub-sequent includes from relative path
mPath=Path; mPath = Path;
// reset pointers and attach proper type of buffer // reset pointers and attach proper type of buffer
switch (Type) switch (Type)
{ {
case buffer_FILE: case buffer_FILE:
Path.append(Stream); Path.append(Stream);
mStream=new std::ifstream(Path.c_str()); mStream = new std::ifstream(Path.c_str());
break; break;
case buffer_TEXT: case buffer_TEXT:
mStream=new std::istringstream(Stream); mStream = new std::istringstream(Stream);
break; break;
default: default:
mStream=NULL; mStream = NULL;
} }
mIncludeParser=NULL; mIncludeParser = NULL;
// calculate stream size // calculate stream size
if (mStream) if (mStream)
{ {
mSize=mStream->rdbuf()->pubseekoff(0,std::ios_base::end); mSize = mStream->rdbuf()->pubseekoff(0, std::ios_base::end);
mStream->rdbuf()->pubseekoff(0,std::ios_base::beg); mStream->rdbuf()->pubseekoff(0, std::ios_base::beg);
} }
else else
mSize=0; mSize = 0;
} }
// destructor // destructor
cParser::~cParser() cParser::~cParser()
{ {
if (mIncludeParser) delete mIncludeParser; if (mIncludeParser)
if (mStream) delete mStream; delete mIncludeParser;
if (mStream)
delete mStream;
mComments.clear(); mComments.clear();
} }
// methods // methods
bool cParser::getTokens(int Count,bool ToLower,const char* Break) bool cParser::getTokens(int Count, bool ToLower, const char *Break)
{ {
/* /*
if (LoadTraction==true) if (LoadTraction==true)
trtest="niemaproblema"; //wczytywaæ trtest="niemaproblema"; //wczytywaæ
else else
trtest="x"; //nie wczytywaæ trtest="x"; //nie wczytywaæ
*/ */
int i; int i;
this->str(""); this->str("");
this->clear(); this->clear();
for (i=0;i<Count;++i) for (i = 0; i < Count; ++i)
{ {
std::string string=readToken(ToLower,Break); std::string string = readToken(ToLower, Break);
// collect parameters // collect parameters
if (i==0) if (i == 0)
this->str(string); this->str(string);
else else
{ {
std::string temp=this->str(); std::string temp = this->str();
temp.append("\n"); temp.append("\n");
temp.append(string); temp.append(string);
this->str(temp); this->str(temp);
} }
} }
if (i<Count) if (i < Count)
return false; return false;
else else
return true; return true;
} }
std::string cParser::readToken(bool ToLower,const char* Break) std::string cParser::readToken(bool ToLower, const char *Break)
{ {
std::string token=""; std::string token = "";
size_t pos; //pocz¹tek podmienianego ci¹gu size_t pos; // pocz¹tek podmienianego ci¹gu
// see if there's include parsing going on. clean up when it's done. // see if there's include parsing going on. clean up when it's done.
if (mIncludeParser) if (mIncludeParser)
{ {
token=(*mIncludeParser).readToken(ToLower,Break); token = (*mIncludeParser).readToken(ToLower, Break);
if (!token.empty()) if (!token.empty())
{pos=token.find("(p");
// check if the token is a parameter which should be replaced with stored true value
if (pos!=std::string::npos) //!=npos to znalezione
{ {
std::string parameter=token.substr(pos+2,token.find(")",pos)-pos+2); //numer parametru pos = token.find("(p");
token.erase(pos,token.find(")",pos)-pos+1); //najpierw usuniêcie "(pN)" // check if the token is a parameter which should be replaced with stored true value
size_t nr=atoi(parameter.c_str())-1; if (pos != std::string::npos) //!=npos to znalezione
if (nr<parameters.size()) {
{token.insert(pos,parameters.at(nr)); //wklejenie wartoœci parametru std::string parameter =
token.substr(pos + 2, token.find(")", pos) - pos + 2); // numer parametru
token.erase(pos, token.find(")", pos) - pos + 1); // najpierw usuniêcie "(pN)"
size_t nr = atoi(parameter.c_str()) - 1;
if (nr < parameters.size())
{
token.insert(pos, parameters.at(nr)); // wklejenie wartoœci parametru
if (ToLower) if (ToLower)
for (;pos<token.length();++pos) for (; pos < token.length(); ++pos)
token[pos]=tolower(token[pos]); token[pos] = tolower(token[pos]);
} }
else else
token.insert(pos,"none"); //zabezpieczenie przed brakiem parametru token.insert(pos, "none"); // zabezpieczenie przed brakiem parametru
} }
return token; return token;
} }
else else
{delete mIncludeParser; {
mIncludeParser=NULL; delete mIncludeParser;
mIncludeParser = NULL;
parameters.clear(); parameters.clear();
} }
} }
// get the token yourself if there's no child to delegate it to. // get the token yourself if there's no child to delegate it to.
char c; char c;
do do
{while (mStream->peek()!=EOF&& strchr( Break, c = mStream->get() ) == NULL)
{ {
if (ToLower) c=tolower(c); while (mStream->peek() != EOF && strchr(Break, c = mStream->get()) == NULL)
token+=c; {
if (ToLower)
c = tolower(c);
token += c;
if (trimComments(token)) // don't glue together words separated with comment if (trimComments(token)) // don't glue together words separated with comment
break; break;
} }
} while (token=="" && mStream->peek()!=EOF); // double check to deal with trailing spaces } while (token == "" && mStream->peek() != EOF); // double check to deal with trailing spaces
// launch child parser if include directive found. // launch child parser if include directive found.
// NOTE: parameter collecting uses default set of token separators. // NOTE: parameter collecting uses default set of token separators.
if (token.compare("include")==0) if (token.compare("include") == 0)
{//obs³uga include { // obs³uga include
std::string includefile=readToken(ToLower); //nazwa pliku std::string includefile = readToken(ToLower); // nazwa pliku
if (LoadTraction?true:((includefile.find("tr/")==std::string::npos)&&(includefile.find("tra/")==std::string::npos))) if (LoadTraction ? true : ((includefile.find("tr/") == std::string::npos) &&
(includefile.find("tra/") == std::string::npos)))
{ {
//std::string trtest2="niemaproblema"; //nazwa odporna na znalezienie "tr/" // std::string trtest2="niemaproblema"; //nazwa odporna na znalezienie "tr/"
//if (trtest=="x") //jeœli nie wczytywaæ drutów // if (trtest=="x") //jeœli nie wczytywaæ drutów
//trtest2=includefile; //kopiowanie œcie¿ki do pliku // trtest2=includefile; //kopiowanie œcie¿ki do pliku
std::string parameter=readToken(false); //w parametrach nie zmniejszamy std::string parameter = readToken(false); // w parametrach nie zmniejszamy
while (parameter.compare("end")!=0) while (parameter.compare("end") != 0)
{ {
parameters.push_back(parameter); parameters.push_back(parameter);
parameter=readToken(ToLower); parameter = readToken(ToLower);
} }
//if (trtest2.find("tr/")!=0) // if (trtest2.find("tr/")!=0)
mIncludeParser=new cParser(includefile,buffer_FILE,mPath,LoadTraction); mIncludeParser = new cParser(includefile, buffer_FILE, mPath, LoadTraction);
if (mIncludeParser->mSize<=0) if (mIncludeParser->mSize <= 0)
ErrorLog("Missed include: "+AnsiString(includefile.c_str())); ErrorLog("Missed include: " + AnsiString(includefile.c_str()));
} }
else else
while (token.compare("end")!=0) while (token.compare("end") != 0)
token=readToken(ToLower); token = readToken(ToLower);
token=readToken(ToLower,Break); token = readToken(ToLower, Break);
} }
return token; return token;
} }
bool cParser::trimComments(std::string &String) bool cParser::trimComments(std::string &String)
{ {
for (commentmap::iterator cmIt=mComments.begin();cmIt!=mComments.end();++cmIt) for (commentmap::iterator cmIt = mComments.begin(); cmIt != mComments.end(); ++cmIt)
{ {
if (String.find((*cmIt).first)!=std::string::npos) if (String.find((*cmIt).first) != std::string::npos)
{ {
readComment((*cmIt).second); readComment((*cmIt).second);
String.resize(String.find((*cmIt).first)); String.resize(String.find((*cmIt).first));
@@ -176,12 +184,12 @@ bool cParser::trimComments(std::string &String)
} }
std::string cParser::readComment(const std::string Break) std::string cParser::readComment(const std::string Break)
{//pobieranie znaków a¿ do znalezienia znacznika koñca { // pobieranie znaków a¿ do znalezienia znacznika koñca
std::string token=""; std::string token = "";
while (mStream->peek()!=EOF) while (mStream->peek() != EOF)
{//o ile nie koniec pliku { // o ile nie koniec pliku
token+=mStream->get(); //pobranie znaku token += mStream->get(); // pobranie znaku
if (token.find(Break)!=std::string::npos) //szukanie znacznika koñca if (token.find(Break) != std::string::npos) // szukanie znacznika koñca
break; break;
} }
return token; return token;
@@ -189,6 +197,5 @@ std::string cParser::readComment(const std::string Break)
int cParser::getProgress() const int cParser::getProgress() const
{ {
return mStream->rdbuf()->pubseekoff( 0, std::ios_base::cur ) * 100 / mSize; return mStream->rdbuf()->pubseekoff(0, std::ios_base::cur) * 100 / mSize;
} }

62
parser.h
View File

@@ -2,7 +2,7 @@
#if !defined(rainKERNELTEXTPARSER_H_INCLUDED) #if !defined(rainKERNELTEXTPARSER_H_INCLUDED)
#define rainKERNELTEXTPARSER_H_INCLUDED #define rainKERNELTEXTPARSER_H_INCLUDED
#pragma warning ( disable : 4786 ) // 'containers too long for debug' warning #pragma warning(disable : 4786) // 'containers too long for debug' warning
#include <string> #include <string>
#include <sstream> #include <sstream>
@@ -16,40 +16,52 @@
class cParser : public std::stringstream class cParser : public std::stringstream
{ {
public: public:
//parameters: // parameters:
enum buffertype {buffer_FILE,buffer_TEXT}; enum buffertype
//constructors: {
cParser(std::string Stream,buffertype Type=buffer_TEXT,std::string Path="",bool tr=true); buffer_FILE,
//destructor: buffer_TEXT
};
// constructors:
cParser(std::string Stream, buffertype Type = buffer_TEXT, std::string Path = "",
bool tr = true);
// destructor:
virtual ~cParser(); virtual ~cParser();
//methods:
template <typename OutputT>
inline void getToken(OutputT& output) {getTokens(); *this >> output;};
inline void ignoreToken() {readToken();};
inline void ignoreTokens(int count) {for (int i=0;i<count;i++) readToken();};
inline bool expectToken(std::string value) {return readToken()==value;};
bool eof() {return mStream->eof();};
bool ok() {return !mStream->fail();};
bool getTokens(int Count=1,bool ToLower=true,const char* Break="\n\t ;");
int getProgress() const; // percentage of file processed.
//load traction?
bool LoadTraction;
protected:
// methods: // methods:
std::string readToken(bool ToLower=true,const char* Break="\n\t ;"); template <typename OutputT> inline void getToken(OutputT &output)
std::string readComment(const std::string Break="\n\t ;"); {
getTokens();
*this >> output;
};
inline void ignoreToken() { readToken(); };
inline void ignoreTokens(int count)
{
for (int i = 0; i < count; i++)
readToken();
};
inline bool expectToken(std::string value) { return readToken() == value; };
bool eof() { return mStream->eof(); };
bool ok() { return !mStream->fail(); };
bool getTokens(int Count = 1, bool ToLower = true, const char *Break = "\n\t ;");
int getProgress() const; // percentage of file processed.
// load traction?
bool LoadTraction;
protected:
// methods:
std::string readToken(bool ToLower = true, const char *Break = "\n\t ;");
std::string readComment(const std::string Break = "\n\t ;");
std::string trtest; std::string trtest;
bool trimComments(std::string& String); bool trimComments(std::string &String);
// members: // members:
std::istream *mStream; // relevant kind of buffer is attached on creation. std::istream *mStream; // relevant kind of buffer is attached on creation.
std::string mPath; // path to open stream, for relative path lookups. std::string mPath; // path to open stream, for relative path lookups.
int mSize; // size of open stream, for progress report. int mSize; // size of open stream, for progress report.
typedef std::map<std::string,std::string> commentmap; typedef std::map<std::string, std::string> commentmap;
commentmap mComments; commentmap mComments;
cParser *mIncludeParser; // child class to handle include directives. cParser *mIncludeParser; // child class to handle include directives.
std::vector<std::string> parameters; // parameter list for included file. std::vector<std::string> parameters; // parameter list for included file.
}; };
#endif // ..!defined(rainKERNELTEXTPARSER_H_INCLUDED) #endif // ..!defined(rainKERNELTEXTPARSER_H_INCLUDED)

51
sky.cpp
View File

@@ -8,58 +8,51 @@
#include "Globals.h" #include "Globals.h"
//--------------------------------------------------------------------------- //---------------------------------------------------------------------------
GLfloat lightPos[4] = { 0.0f, 0.0f, 0.0f, 1.0f }; GLfloat lightPos[4] = {0.0f, 0.0f, 0.0f, 1.0f};
__fastcall TSky::~TSky() __fastcall TSky::~TSky(){};
{
};
__fastcall TSky::TSky()
{
};
__fastcall TSky::TSky(){};
void __fastcall TSky::Init() void __fastcall TSky::Init()
{ {
WriteLog(Global::asSky.c_str()); WriteLog(Global::asSky.c_str());
WriteLog("init"); WriteLog("init");
AnsiString asModel; AnsiString asModel;
asModel=Global::asSky; asModel = Global::asSky;
if ((asModel!="1") && (asModel!="0")) if ((asModel != "1") && (asModel != "0"))
// { // {
mdCloud=TModelsManager::GetModel(asModel.c_str()); mdCloud = TModelsManager::GetModel(asModel.c_str());
// } // }
}; };
void __fastcall TSky::Render() void __fastcall TSky::Render()
{ {
if (mdCloud) if (mdCloud)
{//jeœli jest model nieba { // jeœli jest model nieba
glPushMatrix(); glPushMatrix();
//glDisable(GL_DEPTH_TEST); // glDisable(GL_DEPTH_TEST);
glTranslatef(Global::pCameraPosition.x, Global::pCameraPosition.y, Global::pCameraPosition.z); glTranslatef(Global::pCameraPosition.x, Global::pCameraPosition.y,
glLightfv(GL_LIGHT0,GL_POSITION,lightPos); Global::pCameraPosition.z);
glLightfv(GL_LIGHT0, GL_POSITION, lightPos);
if (Global::bUseVBO) if (Global::bUseVBO)
{//renderowanie z VBO { // renderowanie z VBO
mdCloud->RaRender(100,0); mdCloud->RaRender(100, 0);
mdCloud->RaRenderAlpha(100,0); mdCloud->RaRenderAlpha(100, 0);
} }
else else
{//renderowanie z Display List { // renderowanie z Display List
mdCloud->Render(100,0); mdCloud->Render(100, 0);
mdCloud->RenderAlpha(100,0); mdCloud->RenderAlpha(100, 0);
} }
//glEnable(GL_DEPTH_TEST); // glEnable(GL_DEPTH_TEST);
glClear(GL_DEPTH_BUFFER_BIT); glClear(GL_DEPTH_BUFFER_BIT);
//glEnable(GL_LIGHTING); // glEnable(GL_LIGHTING);
glPopMatrix(); glPopMatrix();
glLightfv(GL_LIGHT0,GL_POSITION,Global::lightPos); glLightfv(GL_LIGHT0, GL_POSITION, Global::lightPos);
} }
}; };
//--------------------------------------------------------------------------- //---------------------------------------------------------------------------
#pragma package(smart_init) #pragma package(smart_init)

5
sky.h
View File

@@ -7,9 +7,10 @@
class TSky class TSky
{ {
private: private:
TModel3d *mdCloud; TModel3d *mdCloud;
public:
public:
__fastcall TSky(); __fastcall TSky();
__fastcall ~TSky(); __fastcall ~TSky();
void __fastcall Init(); void __fastcall Init();

36
usefull.h
View File

@@ -9,21 +9,35 @@
//#define B2(t) (3*t*t*(1-t)) //#define B2(t) (3*t*t*(1-t))
//#define B3(t) (3*t*(1-t)*(1-t)) //#define B3(t) (3*t*(1-t)*(1-t))
//#define B4(t) ((1-t)*(1-t)*(1-t)) //#define B4(t) ((1-t)*(1-t)*(1-t))
//Ra: to jest mocno nieoptymalne: 10+3*4=22 mno¿enia, 6 odejmowañ, 3*3=9 dodawañ // Ra: to jest mocno nieoptymalne: 10+3*4=22 mno¿enia, 6 odejmowañ, 3*3=9 dodawañ
//Ra: po przeliczeniu wspó³czynników mamy: 3*3=9 mno¿eñ i 3*3=9 dodawañ // Ra: po przeliczeniu wspó³czynników mamy: 3*3=9 mno¿eñ i 3*3=9 dodawañ
//#define Interpolate(t,p1,cp1,cp2,p2) (B4(t)*p1+B3(t)*cp1+B2(t)*cp2+B1(t)*p2) //#define Interpolate(t,p1,cp1,cp2,p2) (B4(t)*p1+B3(t)*cp1+B2(t)*cp2+B1(t)*p2)
//Ra: "delete NULL" nic nie zrobi, wiêc "if (a!=NULL)" jest zbêdne // Ra: "delete NULL" nic nie zrobi, wiêc "if (a!=NULL)" jest zbêdne
//#define SafeFree(a) if (a!=NULL) free(a) //#define SafeFree(a) if (a!=NULL) free(a)
#define SafeDelete(a) { delete (a); a=NULL; } #define SafeDelete(a) \
#define SafeDeleteArray(a) { delete[] (a); a=NULL; } { \
delete (a); \
a = NULL; \
}
#define SafeDeleteArray(a) \
{ \
delete[](a); \
a = NULL; \
}
#define sign(x) ((x)<0?-1:((x)>0?1:0)) #define sign(x) ((x) < 0 ? -1 : ((x) > 0 ? 1 : 0))
#define DegToRad(a) ((M_PI/180.0)*(a)) //(a) w nawiasie, bo mo¿e byæ dodawaniem #define DegToRad(a) ((M_PI / 180.0) * (a)) //(a) w nawiasie, bo mo¿e byæ dodawaniem
#define RadToDeg(r) ((180.0/M_PI)*(r)) #define RadToDeg(r) ((180.0 / M_PI) * (r))
#define Fix(a,b,c) {if (a<b) a=b; if (a>c) a=c;} #define Fix(a, b, c) \
{ \
if (a < b) \
a = b; \
if (a > c) \
a = c; \
}
#define asModelsPath AnsiString("models\\") #define asModelsPath AnsiString("models\\")
#define asSceneryPath AnsiString("scenery\\") #define asSceneryPath AnsiString("scenery\\")
@@ -33,12 +47,8 @@
#define szTexturePath "textures\\" #define szTexturePath "textures\\"
//#define szDefaultTextureExt ".dds" //#define szDefaultTextureExt ".dds"
//#define DevelopTime //FIXME //#define DevelopTime //FIXME
//#define EditorMode //#define EditorMode
//--------------------------------------------------------------------------- //---------------------------------------------------------------------------
#endif #endif

151
wavread.cpp
View File

@@ -9,80 +9,86 @@
#include <windows.h> #include <windows.h>
#include "WavRead.h" #include "WavRead.h"
//----------------------------------------------------------------------------- //-----------------------------------------------------------------------------
// Defines, constants, and global variables // Defines, constants, and global variables
//----------------------------------------------------------------------------- //-----------------------------------------------------------------------------
#define SAFE_DELETE(p) { if(p) { delete (p); (p)=NULL; } } #define SAFE_DELETE(p) \
#define SAFE_RELEASE(p) { if(p) { (p)->Release(); (p)=NULL; } } { \
if (p) \
{ \
delete (p); \
(p) = NULL; \
} \
}
#define SAFE_RELEASE(p) \
{ \
if (p) \
{ \
(p)->Release(); \
(p) = NULL; \
} \
}
//----------------------------------------------------------------------------- //-----------------------------------------------------------------------------
// Name: ReadMMIO() // Name: ReadMMIO()
// Desc: Support function for reading from a multimedia I/O stream // Desc: Support function for reading from a multimedia I/O stream
//----------------------------------------------------------------------------- //-----------------------------------------------------------------------------
HRESULT ReadMMIO( HMMIO hmmioIn, MMCKINFO* pckInRIFF, WAVEFORMATEX** ppwfxInfo ) HRESULT ReadMMIO(HMMIO hmmioIn, MMCKINFO *pckInRIFF, WAVEFORMATEX **ppwfxInfo)
{ {
MMCKINFO ckIn; // chunk info. for general use. MMCKINFO ckIn; // chunk info. for general use.
PCMWAVEFORMAT pcmWaveFormat; // Temp PCM structure to load in. PCMWAVEFORMAT pcmWaveFormat; // Temp PCM structure to load in.
*ppwfxInfo = NULL; *ppwfxInfo = NULL;
if( ( 0 != mmioDescend( hmmioIn, pckInRIFF, NULL, 0 ) ) ) if ((0 != mmioDescend(hmmioIn, pckInRIFF, NULL, 0)))
return E_FAIL; return E_FAIL;
if( (pckInRIFF->ckid != FOURCC_RIFF) || if ((pckInRIFF->ckid != FOURCC_RIFF) || (pckInRIFF->fccType != mmioFOURCC('W', 'A', 'V', 'E')))
(pckInRIFF->fccType != mmioFOURCC('W', 'A', 'V', 'E') ) )
return E_FAIL; return E_FAIL;
// Search the input file for for the 'fmt ' chunk. // Search the input file for for the 'fmt ' chunk.
ckIn.ckid = mmioFOURCC('f', 'm', 't', ' '); ckIn.ckid = mmioFOURCC('f', 'm', 't', ' ');
if( 0 != mmioDescend(hmmioIn, &ckIn, pckInRIFF, MMIO_FINDCHUNK) ) if (0 != mmioDescend(hmmioIn, &ckIn, pckInRIFF, MMIO_FINDCHUNK))
return E_FAIL; return E_FAIL;
// Expect the 'fmt' chunk to be at least as large as <PCMWAVEFORMAT>; // Expect the 'fmt' chunk to be at least as large as <PCMWAVEFORMAT>;
// if there are extra parameters at the end, we'll ignore them // if there are extra parameters at the end, we'll ignore them
if( ckIn.cksize < (LONG) sizeof(PCMWAVEFORMAT) ) if (ckIn.cksize < (LONG)sizeof(PCMWAVEFORMAT))
return E_FAIL; return E_FAIL;
// Read the 'fmt ' chunk into <pcmWaveFormat>. // Read the 'fmt ' chunk into <pcmWaveFormat>.
if( mmioRead( hmmioIn, (HPSTR) &pcmWaveFormat, if (mmioRead(hmmioIn, (HPSTR)&pcmWaveFormat, sizeof(pcmWaveFormat)) != sizeof(pcmWaveFormat))
sizeof(pcmWaveFormat)) != sizeof(pcmWaveFormat) )
return E_FAIL; return E_FAIL;
// Allocate the waveformatex, but if its not pcm format, read the next // Allocate the waveformatex, but if its not pcm format, read the next
// word, and thats how many extra bytes to allocate. // word, and thats how many extra bytes to allocate.
if( pcmWaveFormat.wf.wFormatTag == WAVE_FORMAT_PCM ) if (pcmWaveFormat.wf.wFormatTag == WAVE_FORMAT_PCM)
{ {
if( NULL == ( *ppwfxInfo = new WAVEFORMATEX ) ) if (NULL == (*ppwfxInfo = new WAVEFORMATEX))
return E_FAIL; return E_FAIL;
// Copy the bytes from the pcm structure to the waveformatex structure // Copy the bytes from the pcm structure to the waveformatex structure
memcpy( *ppwfxInfo, &pcmWaveFormat, sizeof(pcmWaveFormat) ); memcpy(*ppwfxInfo, &pcmWaveFormat, sizeof(pcmWaveFormat));
(*ppwfxInfo)->cbSize = 0; (*ppwfxInfo)->cbSize = 0;
} }
else else
{ {
// Read in length of extra bytes. // Read in length of extra bytes.
WORD cbExtraBytes = 0L; WORD cbExtraBytes = 0L;
if( mmioRead( hmmioIn, (CHAR*)&cbExtraBytes, sizeof(WORD)) != sizeof(WORD) ) if (mmioRead(hmmioIn, (CHAR *)&cbExtraBytes, sizeof(WORD)) != sizeof(WORD))
return E_FAIL; return E_FAIL;
*ppwfxInfo = (WAVEFORMATEX*)new CHAR[ sizeof(WAVEFORMATEX) + cbExtraBytes ]; *ppwfxInfo = (WAVEFORMATEX *)new CHAR[sizeof(WAVEFORMATEX) + cbExtraBytes];
if( NULL == *ppwfxInfo ) if (NULL == *ppwfxInfo)
return E_FAIL; return E_FAIL;
// Copy the bytes from the pcm structure to the waveformatex structure // Copy the bytes from the pcm structure to the waveformatex structure
memcpy( *ppwfxInfo, &pcmWaveFormat, sizeof(pcmWaveFormat) ); memcpy(*ppwfxInfo, &pcmWaveFormat, sizeof(pcmWaveFormat));
(*ppwfxInfo)->cbSize = cbExtraBytes; (*ppwfxInfo)->cbSize = cbExtraBytes;
// Now, read those extra bytes into the structure, if cbExtraAlloc != 0. // Now, read those extra bytes into the structure, if cbExtraAlloc != 0.
if( mmioRead( hmmioIn, (CHAR*)(((BYTE*)&((*ppwfxInfo)->cbSize))+sizeof(WORD)), if (mmioRead(hmmioIn, (CHAR *)(((BYTE *)&((*ppwfxInfo)->cbSize)) + sizeof(WORD)),
cbExtraBytes ) != cbExtraBytes ) cbExtraBytes) != cbExtraBytes)
{ {
delete *ppwfxInfo; delete *ppwfxInfo;
*ppwfxInfo = NULL; *ppwfxInfo = NULL;
@@ -91,7 +97,7 @@ HRESULT ReadMMIO( HMMIO hmmioIn, MMCKINFO* pckInRIFF, WAVEFORMATEX** ppwfxInfo )
} }
// Ascend the input file out of the 'fmt ' chunk. // Ascend the input file out of the 'fmt ' chunk.
if( 0 != mmioAscend( hmmioIn, &ckIn, 0 ) ) if (0 != mmioAscend(hmmioIn, &ckIn, 0))
{ {
delete *ppwfxInfo; delete *ppwfxInfo;
*ppwfxInfo = NULL; *ppwfxInfo = NULL;
@@ -101,27 +107,24 @@ HRESULT ReadMMIO( HMMIO hmmioIn, MMCKINFO* pckInRIFF, WAVEFORMATEX** ppwfxInfo )
return S_OK; return S_OK;
} }
//----------------------------------------------------------------------------- //-----------------------------------------------------------------------------
// Name: WaveOpenFile() // Name: WaveOpenFile()
// Desc: This function will open a wave input file and prepare it for reading, // Desc: This function will open a wave input file and prepare it for reading,
// so the data can be easily read with WaveReadFile. Returns 0 if // so the data can be easily read with WaveReadFile. Returns 0 if
// successful, the error code if not. // successful, the error code if not.
//----------------------------------------------------------------------------- //-----------------------------------------------------------------------------
HRESULT WaveOpenFile( CHAR* strFileName, HMMIO* phmmioIn, WAVEFORMATEX** ppwfxInfo, HRESULT WaveOpenFile(CHAR *strFileName, HMMIO *phmmioIn, WAVEFORMATEX **ppwfxInfo,
MMCKINFO* pckInRIFF ) MMCKINFO *pckInRIFF)
{ {
HRESULT hr; HRESULT hr;
HMMIO hmmioIn = NULL; HMMIO hmmioIn = NULL;
if( NULL == ( hmmioIn = mmioOpen( strFileName, NULL, MMIO_ALLOCBUF|MMIO_READ ) ) ) if (NULL == (hmmioIn = mmioOpen(strFileName, NULL, MMIO_ALLOCBUF | MMIO_READ)))
return E_FAIL; return E_FAIL;
if( FAILED( hr = ReadMMIO( hmmioIn, pckInRIFF, ppwfxInfo ) ) ) if (FAILED(hr = ReadMMIO(hmmioIn, pckInRIFF, ppwfxInfo)))
{ {
mmioClose( hmmioIn, 0 ); mmioClose(hmmioIn, 0);
return hr; return hr;
} }
@@ -130,9 +133,6 @@ HRESULT WaveOpenFile( CHAR* strFileName, HMMIO* phmmioIn, WAVEFORMATEX** ppwfxIn
return S_OK; return S_OK;
} }
//----------------------------------------------------------------------------- //-----------------------------------------------------------------------------
// Name: WaveStartDataRead() // Name: WaveStartDataRead()
// Desc: Routine has to be called before WaveReadFile as it searches for the // Desc: Routine has to be called before WaveReadFile as it searches for the
@@ -141,25 +141,20 @@ HRESULT WaveOpenFile( CHAR* strFileName, HMMIO* phmmioIn, WAVEFORMATEX** ppwfxIn
// moved to a separate routine so there was more control on the chunks // moved to a separate routine so there was more control on the chunks
// that are before the data chunk, such as 'fact', etc... // that are before the data chunk, such as 'fact', etc...
//----------------------------------------------------------------------------- //-----------------------------------------------------------------------------
HRESULT WaveStartDataRead( HMMIO* phmmioIn, MMCKINFO* pckIn, HRESULT WaveStartDataRead(HMMIO *phmmioIn, MMCKINFO *pckIn, MMCKINFO *pckInRIFF)
MMCKINFO* pckInRIFF )
{ {
// Seek to the data // Seek to the data
if( -1 == mmioSeek( *phmmioIn, pckInRIFF->dwDataOffset + sizeof(FOURCC), if (-1 == mmioSeek(*phmmioIn, pckInRIFF->dwDataOffset + sizeof(FOURCC), SEEK_SET))
SEEK_SET ) )
return E_FAIL; return E_FAIL;
// Search the input file for for the 'data' chunk. // Search the input file for for the 'data' chunk.
pckIn->ckid = mmioFOURCC('d', 'a', 't', 'a'); pckIn->ckid = mmioFOURCC('d', 'a', 't', 'a');
if( 0 != mmioDescend( *phmmioIn, pckIn, pckInRIFF, MMIO_FINDCHUNK ) ) if (0 != mmioDescend(*phmmioIn, pckIn, pckInRIFF, MMIO_FINDCHUNK))
return E_FAIL; return E_FAIL;
return S_OK; return S_OK;
} }
//----------------------------------------------------------------------------- //-----------------------------------------------------------------------------
// Name: WaveReadFile() // Name: WaveReadFile()
// Desc: Reads wave data from the wave file. Make sure we're descended into // Desc: Reads wave data from the wave file. Make sure we're descended into
@@ -169,60 +164,50 @@ HRESULT WaveStartDataRead( HMMIO* phmmioIn, MMCKINFO* pckIn,
// pbDest - Destination buffer to put bytes. // pbDest - Destination buffer to put bytes.
// cbActualRead - # of bytes actually read. // cbActualRead - # of bytes actually read.
//----------------------------------------------------------------------------- //-----------------------------------------------------------------------------
HRESULT WaveReadFile( HMMIO hmmioIn, UINT cbRead, BYTE* pbDest, HRESULT WaveReadFile(HMMIO hmmioIn, UINT cbRead, BYTE *pbDest, MMCKINFO *pckIn, UINT *cbActualRead)
MMCKINFO* pckIn, UINT* cbActualRead )
{ {
MMIOINFO mmioinfoIn; // current status of <hmmioIn> MMIOINFO mmioinfoIn; // current status of <hmmioIn>
*cbActualRead = 0; *cbActualRead = 0;
if( 0 != mmioGetInfo( hmmioIn, &mmioinfoIn, 0 ) ) if (0 != mmioGetInfo(hmmioIn, &mmioinfoIn, 0))
return E_FAIL; return E_FAIL;
UINT cbDataIn = cbRead; UINT cbDataIn = cbRead;
if( cbDataIn > pckIn->cksize ) if (cbDataIn > pckIn->cksize)
cbDataIn = pckIn->cksize; cbDataIn = pckIn->cksize;
pckIn->cksize -= cbDataIn; pckIn->cksize -= cbDataIn;
for( DWORD cT = 0; cT < cbDataIn; cT++ ) for (DWORD cT = 0; cT < cbDataIn; cT++)
{ {
// Copy the bytes from the io to the buffer. // Copy the bytes from the io to the buffer.
if( mmioinfoIn.pchNext == mmioinfoIn.pchEndRead ) if (mmioinfoIn.pchNext == mmioinfoIn.pchEndRead)
{ {
if( 0 != mmioAdvance( hmmioIn, &mmioinfoIn, MMIO_READ ) ) if (0 != mmioAdvance(hmmioIn, &mmioinfoIn, MMIO_READ))
return E_FAIL; return E_FAIL;
if( mmioinfoIn.pchNext == mmioinfoIn.pchEndRead ) if (mmioinfoIn.pchNext == mmioinfoIn.pchEndRead)
return E_FAIL; return E_FAIL;
} }
// Actual copy. // Actual copy.
*((BYTE*)pbDest+cT) = *((BYTE*)mmioinfoIn.pchNext); *((BYTE *)pbDest + cT) = *((BYTE *)mmioinfoIn.pchNext);
mmioinfoIn.pchNext++; mmioinfoIn.pchNext++;
} }
if( 0 != mmioSetInfo( hmmioIn, &mmioinfoIn, 0 ) ) if (0 != mmioSetInfo(hmmioIn, &mmioinfoIn, 0))
return E_FAIL; return E_FAIL;
*cbActualRead = cbDataIn; *cbActualRead = cbDataIn;
return S_OK; return S_OK;
} }
//----------------------------------------------------------------------------- //-----------------------------------------------------------------------------
// Name: CWaveSoundRead() // Name: CWaveSoundRead()
// Desc: Constructs the class // Desc: Constructs the class
//----------------------------------------------------------------------------- //-----------------------------------------------------------------------------
CWaveSoundRead::CWaveSoundRead() CWaveSoundRead::CWaveSoundRead() { m_pwfx = NULL; }
{
m_pwfx = NULL;
}
//----------------------------------------------------------------------------- //-----------------------------------------------------------------------------
// Name: ~CWaveSoundRead() // Name: ~CWaveSoundRead()
@@ -231,69 +216,51 @@ CWaveSoundRead::CWaveSoundRead()
CWaveSoundRead::~CWaveSoundRead() CWaveSoundRead::~CWaveSoundRead()
{ {
Close(); Close();
SAFE_DELETE( m_pwfx ); SAFE_DELETE(m_pwfx);
} }
//----------------------------------------------------------------------------- //-----------------------------------------------------------------------------
// Name: Open() // Name: Open()
// Desc: Opens a wave file for reading // Desc: Opens a wave file for reading
//----------------------------------------------------------------------------- //-----------------------------------------------------------------------------
HRESULT CWaveSoundRead::Open( CHAR* strFilename ) HRESULT CWaveSoundRead::Open(CHAR *strFilename)
{ {
SAFE_DELETE( m_pwfx ); SAFE_DELETE(m_pwfx);
HRESULT hr; HRESULT hr;
if( FAILED( hr = WaveOpenFile( strFilename, &m_hmmioIn, &m_pwfx, &m_ckInRiff ) ) ) if (FAILED(hr = WaveOpenFile(strFilename, &m_hmmioIn, &m_pwfx, &m_ckInRiff)))
return hr; return hr;
if( FAILED( hr = Reset() ) ) if (FAILED(hr = Reset()))
return hr; return hr;
return hr; return hr;
} }
//----------------------------------------------------------------------------- //-----------------------------------------------------------------------------
// Name: Reset() // Name: Reset()
// Desc: Resets the internal m_ckIn pointer so reading starts from the // Desc: Resets the internal m_ckIn pointer so reading starts from the
// beginning of the file again // beginning of the file again
//----------------------------------------------------------------------------- //-----------------------------------------------------------------------------
HRESULT CWaveSoundRead::Reset() HRESULT CWaveSoundRead::Reset() { return WaveStartDataRead(&m_hmmioIn, &m_ckIn, &m_ckInRiff); }
{
return WaveStartDataRead( &m_hmmioIn, &m_ckIn, &m_ckInRiff );
}
//----------------------------------------------------------------------------- //-----------------------------------------------------------------------------
// Name: Read() // Name: Read()
// Desc: Reads a wave file into a pointer and returns how much read // Desc: Reads a wave file into a pointer and returns how much read
// using m_ckIn to determine where to start reading from // using m_ckIn to determine where to start reading from
//----------------------------------------------------------------------------- //-----------------------------------------------------------------------------
HRESULT CWaveSoundRead::Read( UINT nSizeToRead, BYTE* pbData, UINT* pnSizeRead ) HRESULT CWaveSoundRead::Read(UINT nSizeToRead, BYTE *pbData, UINT *pnSizeRead)
{ {
return WaveReadFile( m_hmmioIn, nSizeToRead, pbData, &m_ckIn, pnSizeRead ); return WaveReadFile(m_hmmioIn, nSizeToRead, pbData, &m_ckIn, pnSizeRead);
} }
//----------------------------------------------------------------------------- //-----------------------------------------------------------------------------
// Name: Close() // Name: Close()
// Desc: Closes an open wave file // Desc: Closes an open wave file
//----------------------------------------------------------------------------- //-----------------------------------------------------------------------------
HRESULT CWaveSoundRead::Close() HRESULT CWaveSoundRead::Close()
{ {
mmioClose( m_hmmioIn, 0 ); mmioClose(m_hmmioIn, 0);
return S_OK; return S_OK;
} }

27
wavread.h
View File

@@ -9,17 +9,13 @@
#ifndef WAVE_READ_H #ifndef WAVE_READ_H
#define WAVE_READ_H #define WAVE_READ_H
#include <mmreg.h> #include <mmreg.h>
#include <mmsystem.h> #include <mmsystem.h>
HRESULT WaveOpenFile(CHAR *strFileName, HMMIO *phmmioIn, WAVEFORMATEX **ppwfxInfo,
HRESULT WaveOpenFile( CHAR* strFileName, HMMIO* phmmioIn, WAVEFORMATEX** ppwfxInfo, MMCKINFO *pckInRIFF);
MMCKINFO* pckInRIFF ); HRESULT WaveStartDataRead(HMMIO *phmmioIn, MMCKINFO *pckIn, MMCKINFO *pckInRIFF);
HRESULT WaveStartDataRead( HMMIO* phmmioIn, MMCKINFO* pckIn, HRESULT WaveReadFile(HMMIO hmmioIn, UINT cbRead, BYTE *pbDest, MMCKINFO *pckIn, UINT *cbActualRead);
MMCKINFO* pckInRIFF );
HRESULT WaveReadFile( HMMIO hmmioIn, UINT cbRead, BYTE* pbDest,
MMCKINFO* pckIn, UINT* cbActualRead );
//----------------------------------------------------------------------------- //-----------------------------------------------------------------------------
// Name: class CWaveSoundRead // Name: class CWaveSoundRead
@@ -27,25 +23,20 @@ HRESULT WaveReadFile( HMMIO hmmioIn, UINT cbRead, BYTE* pbDest,
//----------------------------------------------------------------------------- //-----------------------------------------------------------------------------
class CWaveSoundRead class CWaveSoundRead
{ {
public: public:
WAVEFORMATEX* m_pwfx; // Pointer to WAVEFORMATEX structure WAVEFORMATEX *m_pwfx; // Pointer to WAVEFORMATEX structure
HMMIO m_hmmioIn; // MM I/O handle for the WAVE HMMIO m_hmmioIn; // MM I/O handle for the WAVE
MMCKINFO m_ckIn; // Multimedia RIFF chunk MMCKINFO m_ckIn; // Multimedia RIFF chunk
MMCKINFO m_ckInRiff; // Use in opening a WAVE file MMCKINFO m_ckInRiff; // Use in opening a WAVE file
public: public:
CWaveSoundRead(); CWaveSoundRead();
~CWaveSoundRead(); ~CWaveSoundRead();
HRESULT Open( CHAR* strFilename ); HRESULT Open(CHAR *strFilename);
HRESULT Reset(); HRESULT Reset();
HRESULT Read( UINT nSizeToRead, BYTE* pbData, UINT* pnSizeRead ); HRESULT Read(UINT nSizeToRead, BYTE *pbData, UINT *pnSizeRead);
HRESULT Close(); HRESULT Close();
}; };
#endif WAVE_READ_H #endif WAVE_READ_H