eu07/maszyna
16
0
Fork 0
mirror of https://github.com/MaSzyna-EU07/maszyna.git synced 2026-07-23 19:09:18 +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

199
AdvSound.cpp
View File

@@ -1,7 +1,7 @@
//--------------------------------------------------------------------------- //---------------------------------------------------------------------------
#include "system.hpp" #include "system.hpp"
#include "classes.hpp" #include "classes.hpp"
#pragma hdrstop #pragma hdrstop
#include "Timer.h" #include "Timer.h"
@@ -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;
}; };

17
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,17 +26,18 @@ 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);
void __fastcall Free(); void __fastcall Free();
void __fastcall Update(bool ListenerInside, vector3 NewPosition); void __fastcall Update(bool ListenerInside, vector3 NewPosition);
void __fastcall UpdateAF(double A, double F, bool ListenerInside, vector3 NewPosition); void __fastcall UpdateAF(double A, double F, bool ListenerInside, vector3 NewPosition);
void __fastcall CopyIfEmpty(TAdvancedSound &s); void __fastcall CopyIfEmpty(TAdvancedSound &s);
}; };
//--------------------------------------------------------------------------- //---------------------------------------------------------------------------

85
AirCoupler.cpp
View File

@@ -1,71 +1,68 @@
//--------------------------------------------------------------------------- //---------------------------------------------------------------------------
#include "system.hpp" #include "system.hpp"
#include "classes.hpp" #include "classes.hpp"
#pragma hdrstop #pragma hdrstop
#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;
return x; if (pModelxOn)
x = 2;
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;
} }
} }
//--------------------------------------------------------------------------- //---------------------------------------------------------------------------

52
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:
__fastcall TAirCoupler(); public:
__fastcall ~TAirCoupler(); __fastcall TAirCoupler();
void __fastcall Clear(); __fastcall ~TAirCoupler();
inline void TurnOn() { bOn=true; bxOn=false; Update(); }; void __fastcall Clear();
inline void TurnOff() { bOn=false; bxOn=false; Update(); }; inline void TurnOn()
inline void TurnxOn() { bOn=false; bxOn=true; Update(); }; {
// inline bool Active() { if ((pModelOn)||(pModelOff)) return true; return false;}; bOn = true;
int __fastcall GetStatus(); bxOn = false;
void __fastcall Init(AnsiString asName, TModel3d *pModel); Update();
void __fastcall Load(TQueryParserComp *Parser, TModel3d *pModel); };
// bool __fastcall Render(); 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();
void __fastcall Init(AnsiString asName, TModel3d *pModel);
void __fastcall Load(TQueryParserComp *Parser, TModel3d *pModel);
// bool __fastcall Render();
}; };
//--------------------------------------------------------------------------- //---------------------------------------------------------------------------

1348
AnimModel.cpp
View File

File diff suppressed because it is too large Load Diff

262
AnimModel.h
View File

@@ -5,144 +5,162 @@
#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 vDesiredAngles; vector3 vRotateAngles; // dla obrotów Eulera
double fRotateSpeed; vector3 vDesiredAngles;
vector3 vTranslation; double fRotateSpeed;
vector3 vTranslateTo; vector3 vTranslation;
double fTranslateSpeed; //mo¿e tu daæ wektor? vector3 vTranslateTo;
float4 qCurrent; //aktualny interpolowany double fTranslateSpeed; // mo¿e tu daæ wektor?
float4 qStart; //pozycja pocz¹tkowa (0 dla interpolacji) float4 qCurrent; // aktualny interpolowany
float4 qDesired; //pozycja koñcowa (1 dla interpolacji) float4 qStart; // pozycja pocz¹tkowa (0 dla interpolacji)
float fAngleCurrent; //parametr interpolacyjny: 0=start, 1=docelowy float4 qDesired; // pozycja koñcowa (1 dla interpolacji)
float fAngleSpeed; //zmiana parametru interpolacji w sekundach float fAngleCurrent; // parametr interpolacyjny: 0=start, 1=docelowy
TSubModel *pSubModel; float fAngleSpeed; // zmiana parametru interpolacji w sekundach
float4x4 *mAnim; //macierz do animacji kwaternionowych TSubModel *pSubModel;
//dla kinematyki odwróconej u¿ywane s¹ kwaterniony float4x4 *mAnim; // macierz do animacji kwaternionowych
float fLength; //d³ugoœæ koœci dla IK // dla kinematyki odwróconej u¿ywane s¹ kwaterniony
int iAnim; //animacja: +1-obrót Eulera, +2-przesuw, +4-obrót kwaternionem, +8-IK float fLength; // d³ugoœæ koœci dla IK
//+0x80000000: animacja z eventem, wykonywana poza wyœwietlaniem int iAnim; // animacja: +1-obrót Eulera, +2-przesuw, +4-obrót kwaternionem, +8-IK
//+0x100: pierwszy stopieñ IK - obróciæ w stronê pierwszego potomnego (dziecka) //+0x80000000: animacja z eventem, wykonywana poza wyœwietlaniem
//+0x200: drugi stopieñ IK - dostosowaæ do pozycji potomnego potomnego (wnuka) //+0x100: pierwszy stopieñ IK - obróciæ w stronê pierwszego potomnego (dziecka)
union //+0x200: drugi stopieñ IK - dostosowaæ do pozycji potomnego potomnego (wnuka)
{//mog¹ byæ animacje klatkowe ró¿nego typu, wskaŸniki u¿ywa AnimModel union
TAnimVocaloidFrame *pMovementData; //wskaŸnik do klatki { // mog¹ byæ animacje klatkowe ró¿nego typu, wskaŸniki u¿ywa AnimModel
}; TAnimVocaloidFrame *pMovementData; // wskaŸnik do klatki
TEvent *evDone; //ewent wykonywany po zakoñczeniu animacji, np. zapór, obrotnicy };
public: TEvent *evDone; // ewent wykonywany po zakoñczeniu animacji, np. zapór, obrotnicy
TAnimContainer *pNext; public:
TAnimContainer *acAnimNext; //lista animacji z eventem, które musz¹ byæ przeliczane równie¿ bez wyœwietlania TAnimContainer *pNext;
__fastcall TAnimContainer(); TAnimContainer *acAnimNext; // lista animacji z eventem, które musz¹ byæ przeliczane równie¿ bez
__fastcall ~TAnimContainer(); // wyœwietlania
bool __fastcall Init(TSubModel *pNewSubModel); __fastcall TAnimContainer();
//std::string inline __fastcall GetName() { return std::string(pSubModel?pSubModel->asName.c_str():""); }; __fastcall ~TAnimContainer();
//std::string inline __fastcall GetName() { return std::string(pSubModel?pSubModel->pName:""); }; bool __fastcall Init(TSubModel *pNewSubModel);
char* __fastcall NameGet() {return (pSubModel?pSubModel->pName:NULL);}; // std::string inline __fastcall GetName() { return
//void __fastcall SetRotateAnim(vector3 vNewRotateAxis, double fNewDesiredAngle, double fNewRotateSpeed, bool bResetAngle=false); // std::string(pSubModel?pSubModel->asName.c_str():""); };
void __fastcall SetRotateAnim(vector3 vNewRotateAngles, double fNewRotateSpeed); // std::string inline __fastcall GetName() { return std::string(pSubModel?pSubModel->pName:"");
void __fastcall SetTranslateAnim(vector3 vNewTranslate, double fNewSpeed); // };
void __fastcall AnimSetVMD(double fNewSpeed); char *__fastcall NameGet() { return (pSubModel ? pSubModel->pName : NULL); };
void __fastcall PrepareModel(); // void __fastcall SetRotateAnim(vector3 vNewRotateAxis, double fNewDesiredAngle, double
void __fastcall UpdateModel(); // fNewRotateSpeed, bool bResetAngle=false);
void __fastcall UpdateModelIK(); void __fastcall SetRotateAnim(vector3 vNewRotateAngles, double fNewRotateSpeed);
bool __fastcall InMovement(); //czy w trakcie animacji? void __fastcall SetTranslateAnim(vector3 vNewTranslate, double fNewSpeed);
double _fastcall AngleGet() {return vRotateAngles.z;}; //jednak ostatnia, T3D ma inny uk³ad void __fastcall AnimSetVMD(double fNewSpeed);
vector3 _fastcall TransGet() {return vector3(-vTranslation.x,vTranslation.z,vTranslation.y);}; //zmiana, bo T3D ma inny uk³ad void __fastcall PrepareModel();
void __fastcall WillBeAnimated() {if (pSubModel) pSubModel->WillBeAnimated();}; void __fastcall UpdateModel();
void __fastcall EventAssign(TEvent *ev); void __fastcall UpdateModelIK();
TEvent* __fastcall Event() {return evDone;}; bool __fastcall InMovement(); // czy w trakcie animacji?
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
void __fastcall WillBeAnimated()
{
if (pSubModel)
pSubModel->WillBeAnimated();
};
void __fastcall EventAssign(TEvent *ev);
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();
int __fastcall SortByBone(); int __fastcall SortByBone();
}; };
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
__fastcall TAnimModel(); // równie¿ bez wyœwietlania
__fastcall ~TAnimModel(); __fastcall TAnimModel();
bool __fastcall Init(TModel3d *pNewModel); __fastcall ~TAnimModel();
bool __fastcall Init(AnsiString asName,AnsiString asReplacableTexture); bool __fastcall Init(TModel3d *pNewModel);
bool __fastcall Load(cParser *parser, bool ter=false); bool __fastcall Init(AnsiString asName, AnsiString asReplacableTexture);
TAnimContainer* __fastcall AddContainer(char *pName); bool __fastcall Load(cParser *parser, bool ter = false);
TAnimContainer* __fastcall GetContainer(char *pName); TAnimContainer *__fastcall AddContainer(char *pName);
void __fastcall RenderDL(vector3 pPosition=vector3(0,0,0),double fAngle=0); TAnimContainer *__fastcall GetContainer(char *pName);
void __fastcall RenderAlphaDL(vector3 pPosition=vector3(0,0,0),double fAngle=0); void __fastcall RenderDL(vector3 pPosition = vector3(0, 0, 0), double fAngle = 0);
void __fastcall RenderVBO(vector3 pPosition=vector3(0,0,0),double fAngle=0); void __fastcall RenderAlphaDL(vector3 pPosition = vector3(0, 0, 0), double fAngle = 0);
void __fastcall RenderAlphaVBO(vector3 pPosition=vector3(0,0,0),double fAngle=0); void __fastcall RenderVBO(vector3 pPosition = vector3(0, 0, 0), double fAngle = 0);
void __fastcall RenderDL(vector3* vPosition); void __fastcall RenderAlphaVBO(vector3 pPosition = vector3(0, 0, 0), double fAngle = 0);
void __fastcall RenderAlphaDL(vector3* vPosition); void __fastcall RenderDL(vector3 *vPosition);
void __fastcall RenderVBO(vector3* vPosition); void __fastcall RenderAlphaDL(vector3 *vPosition);
void __fastcall RenderAlphaVBO(vector3* vPosition); void __fastcall RenderVBO(vector3 *vPosition);
int __fastcall Flags(); void __fastcall RenderAlphaVBO(vector3 *vPosition);
void __fastcall RaAnglesSet(double a,double b,double c) int __fastcall Flags();
{vAngle.x=a; vAngle.y=b; vAngle.z=c;}; void __fastcall RaAnglesSet(double a, double b, double c)
bool __fastcall TerrainLoaded(); {
int __fastcall TerrainCount(); vAngle.x = a;
TSubModel* __fastcall TerrainSquare(int n); vAngle.y = b;
void __fastcall TerrainRenderVBO(int n); vAngle.z = c;
void __fastcall AnimationVND(void* pData, double a, double b, double c, double d); };
void __fastcall LightSet(int n,float v); bool __fastcall TerrainLoaded();
static void __fastcall AnimUpdate(double dt); int __fastcall TerrainCount();
TSubModel *__fastcall TerrainSquare(int n);
void __fastcall TerrainRenderVBO(int n);
void __fastcall AnimationVND(void *pData, double a, double b, double c, double d);
void __fastcall LightSet(int n, float v);
static void __fastcall AnimUpdate(double dt);
}; };
TAnimContainer *TAnimModel::acAnimList=NULL; TAnimContainer *TAnimModel::acAnimList = NULL;
//--------------------------------------------------------------------------- //---------------------------------------------------------------------------
#endif #endif

85
Button.cpp
View File

@@ -1,7 +1,7 @@
//--------------------------------------------------------------------------- //---------------------------------------------------------------------------
#include "system.hpp" #include "system.hpp"
#include "classes.hpp" #include "classes.hpp"
#pragma hdrstop #pragma hdrstop
#include "Button.h" #include "Button.h"
@@ -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());
Update(); bOn = bNewOn;
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; {
pModelOff=NULL; pModelOn = 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;
Console::BitsSet(iFeedbackBit); if (iFeedbackBit) // je¿eli generuje informacjê zwrotn¹
else {
Console::BitsClear(iFeedbackBit); if (bOn) // zapalenie
} Console::BitsSet(iFeedbackBit);
else
Console::BitsClear(iFeedbackBit);
}
}; };

53
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:
__fastcall TButton(); public:
__fastcall ~TButton(); __fastcall TButton();
void __fastcall Clear(int i=-1); __fastcall ~TButton();
inline void FeedbackBitSet(int i) {iFeedbackBit=1<<i;}; void __fastcall Clear(int i = -1);
inline void Turn(bool to) { bOn=to; Update(); }; inline void FeedbackBitSet(int i) { iFeedbackBit = 1 << i; };
inline void TurnOn() { bOn=true; Update(); }; inline void Turn(bool to)
inline void TurnOff() { bOn=false; Update(); }; {
inline void Switch() { bOn=!bOn; Update(); }; bOn = to;
inline bool Active() { return (pModelOn)||(pModelOff);}; Update();
void __fastcall Init(AnsiString asName,TModel3d *pModel,bool bNewOn=false); };
void __fastcall Load(TQueryParserComp *Parser,TModel3d *pModel1,TModel3d *pModel2=NULL); inline void TurnOn()
{
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);
}; };
//--------------------------------------------------------------------------- //---------------------------------------------------------------------------

250
Camera.cpp
View File

@@ -1,6 +1,6 @@
//--------------------------------------------------------------------------- //---------------------------------------------------------------------------
#include "system.hpp" #include "system.hpp"
#include "classes.hpp" #include "classes.hpp"
#include "opengl/glew.h" #include "opengl/glew.h"
#include "opengl/glut.h" #include "opengl/glut.h"
@@ -16,181 +16,189 @@
//--------------------------------------------------------------------------- //---------------------------------------------------------------------------
#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;
if (Console::Pressed(VkKeyScan('d'))) // McZapkie-170402: zeby nie bylo konfliktow
Velocity.x+= a*Timer::GetDeltaTime(); /*
if (Console::Pressed(VkKeyScan('a'))) if (Console::Pressed(VkKeyScan('d')))
Velocity.x-= a*Timer::GetDeltaTime(); Velocity.x+= a*Timer::GetDeltaTime();
if (Console::Pressed(VkKeyScan('w'))) if (Console::Pressed(VkKeyScan('a')))
Velocity.z-= a*Timer::GetDeltaTime(); Velocity.x-= a*Timer::GetDeltaTime();
if (Console::Pressed(VkKeyScan('s'))) if (Console::Pressed(VkKeyScan('w')))
Velocity.z+= a*Timer::GetDeltaTime(); Velocity.z-= a*Timer::GetDeltaTime();
if (Console::Pressed(VkKeyScan('s')))
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) ||
Yaw+= +1*M_PI*Timer::GetDeltaTime(); Console::Pressed(VK_NUMPAD1))
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) ||
Yaw+= -1*M_PI*Timer::GetDeltaTime(); Console::Pressed(VK_NUMPAD3))
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) ||
Pitch+= -1*M_PI*Timer::GetDeltaTime(); Console::Pressed(VK_NUMPAD3))
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) ||
Pitch+= +1*M_PI*Timer::GetDeltaTime(); Console::Pressed(VK_NUMPAD9))
if (Console::Pressed(VkKeyScan('.'))) Pitch+= +1*M_PI*Timer::GetDeltaTime();
Roll+= -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(); if (Console::Pressed(VkKeyScan(',')))
Roll+= +1*M_PI*Timer::GetDeltaTime();
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);
}; };

61
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

56
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,24 +31,24 @@ 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,
cm_ChangeDirection, cm_ChangeDirection,
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

465
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,275 +73,278 @@ 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]
} }
}; };
__fastcall Console::~Console() __fastcall Console::~Console()
{ {
delete PoKeys55[0]; delete PoKeys55[0];
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
break; iConfig = 0; // licznik użycia Scroll Lock
case 3: //LPT break;
LPT=new TLPT(); //otwarcie inpout32.dll case 3: // LPT
if (LPT?LPT->Connect(iConfig):false) LPT = new TLPT(); // otwarcie inpout32.dll
{//wysłać 0? if (LPT ? LPT->Connect(iConfig) : false)
BitsUpdate(-1); //aktualizacjia stanów, bo przy wczytywaniu mogło być nieaktywne { // wysłać 0?
WriteLog("Feedback Mode 3: InpOut32.dll OK"); BitsUpdate(-1); // aktualizacjia stanów, bo przy wczytywaniu mogło być nieaktywne
} WriteLog("Feedback Mode 3: InpOut32.dll OK");
else }
{//połączenie nie wyszło, ma być NULL else
delete LPT; { // połączenie nie wyszło, ma być NULL
LPT=NULL; delete LPT;
} LPT = NULL;
break; }
case 4: //PoKeys break;
PoKeys55[0]=new TPoKeys55(); case 4: // PoKeys
if (PoKeys55[0]?PoKeys55[0]->Connect():false) PoKeys55[0] = new TPoKeys55();
{WriteLog("Found "+PoKeys55[0]->Version()); if (PoKeys55[0] ? PoKeys55[0]->Connect() : false)
BitsUpdate(-1); //aktualizacjia stanów, bo przy wczytywaniu mogło być nieaktywne {
} WriteLog("Found " + PoKeys55[0]->Version());
else BitsUpdate(-1); // aktualizacjia stanów, bo przy wczytywaniu mogło być nieaktywne
{//połączenie nie wyszło, ma być NULL }
delete PoKeys55[0]; else
PoKeys55[0]=NULL; { // połączenie nie wyszło, ma być NULL
} delete PoKeys55[0];
break; PoKeys55[0] = NULL;
} }
return 0; break;
}
return 0;
}; };
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; }
case 2: //sterowanie światełkami klawiatury: CA+SHP break;
if (mask&2) //gdy CA case 2: // sterowanie światełkami klawiatury: CA+SHP
SetLedState(VK_CAPITAL,iBits&2); if (mask & 2) // gdy CA
if (mask&1) //gdy SHP SetLedState(VK_CAPITAL, iBits & 2);
{//Scroll Lock ma jakoś dziwnie... zmiana stanu na przeciwny if (mask & 1) // gdy SHP
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; }
case 3: //LPT Marcela z modyfikacją (jazda na oporach zamiast brzęczyka) break;
if (LPT) case 3: // LPT Marcela z modyfikacją (jazda na oporach zamiast brzęczyka)
LPT->Out(iBits); if (LPT)
break; LPT->Out(iBits);
case 4: //PoKeys55 wg Marcela - wersja druga z końca 2012 break;
if (PoKeys55[0]) case 4: // PoKeys55 wg Marcela - wersja druga z końca 2012
{//pewnie trzeba będzie to dodatkowo buforować i oczekiwać na potwierdzenie if (PoKeys55[0])
if (mask&0x0001) //b0 gdy SHP { // pewnie trzeba będzie to dodatkowo buforować i oczekiwać na potwierdzenie
PoKeys55[0]->Write(0x40,23-1,iBits&0x0001?1:0); if (mask & 0x0001) // b0 gdy SHP
if (mask&0x0002) //b1 gdy zmieniony CA PoKeys55[0]->Write(0x40, 23 - 1, iBits & 0x0001 ? 1 : 0);
PoKeys55[0]->Write(0x40,24-1,iBits&0x0002?1:0); if (mask & 0x0002) // b1 gdy zmieniony CA
if (mask&0x0004) //b2 gdy jazda na oporach PoKeys55[0]->Write(0x40, 24 - 1, iBits & 0x0002 ? 1 : 0);
PoKeys55[0]->Write(0x40,32-1,iBits&0x0004?1:0); if (mask & 0x0004) // b2 gdy jazda na oporach
if (mask&0x0008) //b3 Lampka WS (wyłącznika szybkiego) PoKeys55[0]->Write(0x40, 32 - 1, iBits & 0x0004 ? 1 : 0);
PoKeys55[0]->Write(0x40,25-1,iBits&0x0008?1:0); if (mask & 0x0008) // b3 Lampka WS (wyłącznika szybkiego)
if (mask&0x0010) //b4 Lampka przekaźnika nadmiarowego silników trakcyjnych PoKeys55[0]->Write(0x40, 25 - 1, iBits & 0x0008 ? 1 : 0);
PoKeys55[0]->Write(0x40,27-1,iBits&0x0010?1:0); if (mask & 0x0010) // b4 Lampka przekaźnika nadmiarowego silników trakcyjnych
if (mask&0x0020) //b5 Lampka styczników liniowych PoKeys55[0]->Write(0x40, 27 - 1, iBits & 0x0010 ? 1 : 0);
PoKeys55[0]->Write(0x40,29-1,iBits&0x0020?1:0); if (mask & 0x0020) // b5 Lampka styczników liniowych
if (mask&0x0040) //b6 Lampka poślizgu PoKeys55[0]->Write(0x40, 29 - 1, iBits & 0x0020 ? 1 : 0);
PoKeys55[0]->Write(0x40,30-1,iBits&0x0040?1:0); if (mask & 0x0040) // b6 Lampka poślizgu
if (mask&0x0080) //b7 Lampka "przetwornicy" PoKeys55[0]->Write(0x40, 30 - 1, iBits & 0x0040 ? 1 : 0);
PoKeys55[0]->Write(0x40,28-1,iBits&0x0080?1:0); if (mask & 0x0080) // b7 Lampka "przetwornicy"
if (mask&0x0100) //b8 Kontrolka przekaźnika nadmiarowego sprężarki PoKeys55[0]->Write(0x40, 28 - 1, iBits & 0x0080 ? 1 : 0);
PoKeys55[0]->Write(0x40,33-1,iBits&0x0100?1:0); if (mask & 0x0100) // b8 Kontrolka przekaźnika nadmiarowego sprężarki
if (mask&0x0200) //b9 Kontrolka sygnalizacji wentylatorów i oporów PoKeys55[0]->Write(0x40, 33 - 1, iBits & 0x0100 ? 1 : 0);
PoKeys55[0]->Write(0x40,26-1,iBits&0x0200?1:0); if (mask & 0x0200) // b9 Kontrolka sygnalizacji wentylatorów i oporów
if (mask&0x0400) //b10 Kontrolka wysokiego rozruchu PoKeys55[0]->Write(0x40, 26 - 1, iBits & 0x0200 ? 1 : 0);
PoKeys55[0]->Write(0x40,31-1,iBits&0x0400?1:0); if (mask & 0x0400) // b10 Kontrolka wysokiego rozruchu
if (mask&0x0800) //b11 Kontrolka ogrzewania pociągu PoKeys55[0]->Write(0x40, 31 - 1, iBits & 0x0400 ? 1 : 0);
PoKeys55[0]->Write(0x40,34-1,iBits&0x0800?1:0); if (mask & 0x0800) // b11 Kontrolka ogrzewania pociągu
if (mask&0x1000) //b12 Ciśnienie w cylindrach do odbijania w haslerze PoKeys55[0]->Write(0x40, 34 - 1, iBits & 0x0800 ? 1 : 0);
PoKeys55[0]->Write(0x40,52-1,iBits&0x1000?1:0); if (mask & 0x1000) // b12 Ciśnienie w cylindrach do odbijania w haslerze
if (mask&0x2000) //b13 Prąd na silnikach do odbijania w haslerze PoKeys55[0]->Write(0x40, 52 - 1, iBits & 0x1000 ? 1 : 0);
PoKeys55[0]->Write(0x40,53-1,iBits&0x2000?1:0); if (mask & 0x2000) // b13 Prąd na silnikach do odbijania w haslerze
} 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);
};

79
Console.h
View File

@@ -3,53 +3,52 @@
#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);
static void __fastcall OnKeyDown(int k); static void __fastcall OnKeyDown(int k);
static void __fastcall OnKeyUp(int k); static void __fastcall OnKeyUp(int k);
static int __fastcall KeyDownConvert(int k); static int __fastcall KeyDownConvert(int k);
static int __fastcall KeyUpConvert(int k); static int __fastcall KeyUpConvert(int k);
}; };
#endif #endif

60
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 0x0278: {
OutPort(address+0x402,0); //SPP, czyli jednokierunkowe wyjœcie case 0x0378:
break; case 0x0278:
case 0xBC00: OutPort(address + 0x402, 0); // SPP, czyli jednokierunkowe wyjœcie
case 0xBD00: break;
OutPort(address+0x006,0); //0xBC06? czysta improwizacja case 0xBC00:
} case 0xBD00:
return bool(OutPort); OutPort(address + 0x006, 0); // 0xBC06? czysta improwizacja
}; }
return bool(OutPort);
void __fastcall TLPT::Out(int x)
{//wys³anie bajtu do portu
OutPort(address,x);
}; };
void __fastcall TLPT::Out(int x) { // wys³anie bajtu do portu OutPort(address, x); };

11
Console/LPT.h
View File

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

595
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,
HDEVINFO DeviceInfoTable; 0x11, 0x11, 0x00, 0x00, 0x30}; // wszystkie HID tak maj¹
PSP_DEVICE_INTERFACE_DATA InterfaceDataStructure=new SP_DEVICE_INTERFACE_DATA; HDEVINFO DeviceInfoTable;
PSP_DEVICE_INTERFACE_DETAIL_DATA DetailedInterfaceDataStructure=new SP_DEVICE_INTERFACE_DETAIL_DATA; PSP_DEVICE_INTERFACE_DATA InterfaceDataStructure = new SP_DEVICE_INTERFACE_DATA;
SP_DEVINFO_DATA DevInfoData; PSP_DEVICE_INTERFACE_DETAIL_DATA DetailedInterfaceDataStructure =
DWORD InterfaceIndex=0; new SP_DEVICE_INTERFACE_DETAIL_DATA;
//DWORD StatusLastError=0; SP_DEVINFO_DATA DevInfoData;
DWORD dwRegType; DWORD InterfaceIndex = 0;
DWORD dwRegSize; // DWORD StatusLastError=0;
DWORD StructureSize=0; DWORD dwRegType;
PBYTE PropertyValueBuffer; DWORD dwRegSize;
bool MatchFound; DWORD StructureSize = 0;
DWORD ErrorStatus; PBYTE PropertyValueBuffer;
HDEVINFO hDevInfo; bool MatchFound;
String DeviceIDFromRegistry; DWORD ErrorStatus;
String DeviceIDToFind="Vid_1dc3&Pid_1001&Rev_1000&MI_01"; HDEVINFO hDevInfo;
//First populate a list of plugged in devices (by specifying "DIGCF_PRESENT"), which are of the specified class GUID. String DeviceIDFromRegistry;
DeviceInfoTable=SetupDiGetClassDevs(&InterfaceClassGuid,NULL,NULL,DIGCF_PRESENT|DIGCF_DEVICEINTERFACE); String DeviceIDToFind = "Vid_1dc3&Pid_1001&Rev_1000&MI_01";
//Now look through the list we just populated. We are trying to see if any of them match our device. // First populate a list of plugged in devices (by specifying "DIGCF_PRESENT"), which are of the
while (true) // specified class GUID.
{ DeviceInfoTable =
InterfaceDataStructure->cbSize=sizeof(SP_DEVICE_INTERFACE_DATA); SetupDiGetClassDevs(&InterfaceClassGuid, NULL, NULL, DIGCF_PRESENT | DIGCF_DEVICEINTERFACE);
if (SetupDiEnumDeviceInterfaces(DeviceInfoTable, NULL, &InterfaceClassGuid, InterfaceIndex, InterfaceDataStructure)) // Now look through the list we just populated. We are trying to see if any of them match our
{ // device.
ErrorStatus=GetLastError(); while (true)
if (ERROR_NO_MORE_ITEMS==ErrorStatus) //Did we reach the end of the list of matching devices in the DeviceInfoTable? {
{//Cound not find the device. Must not have been attached. InterfaceDataStructure->cbSize = sizeof(SP_DEVICE_INTERFACE_DATA);
SetupDiDestroyDeviceInfoList(DeviceInfoTable); //Clean up the old structure we no longer need. if (SetupDiEnumDeviceInterfaces(DeviceInfoTable, NULL, &InterfaceClassGuid, InterfaceIndex,
//ShowMessage("Erreur: Sortie1"); InterfaceDataStructure))
{
ErrorStatus = GetLastError();
if (ERROR_NO_MORE_ITEMS == ErrorStatus) // Did we reach the end of the list of matching
// devices in the DeviceInfoTable?
{ // Cound not find the device. Must not have been attached.
SetupDiDestroyDeviceInfoList(
DeviceInfoTable); // Clean up the old structure we no longer need.
// ShowMessage("Erreur: Sortie1");
return false;
}
}
else // Else some other kind of unknown error ocurred...
{
ErrorStatus = GetLastError();
SetupDiDestroyDeviceInfoList(
DeviceInfoTable); // Clean up the old structure we no longer need.
// ShowMessage("Erreur: Sortie2");
return false;
}
// Now retrieve the hardware ID from the registry. The hardware ID contains the VID and PID,
// which we will then
// check to see if it is the correct device or not.
// Initialize an appropriate SP_DEVINFO_DATA structure. We need this structure for
// SetupDiGetDeviceRegistryProperty().
DevInfoData.cbSize = sizeof(SP_DEVINFO_DATA);
SetupDiEnumDeviceInfo(DeviceInfoTable, InterfaceIndex, &DevInfoData);
// First query for the size of the hardware ID, so we can know how big a buffer to allocate
// for the data.
SetupDiGetDeviceRegistryProperty(DeviceInfoTable, &DevInfoData, SPDRP_HARDWAREID,
&dwRegType, NULL, 0, &dwRegSize);
// Allocate a buffer for the hardware ID.
// PropertyValueBuffer=(BYTE*)malloc(dwRegSize);
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;
}
// Retrieve the hardware IDs for the current device we are looking at. PropertyValueBuffer
// gets filled with a
// REG_MULTI_SZ (array of null terminated strings). To find a device,we only care about the
// very first string in the
// buffer,which will be the "device ID". The device ID is a string which contains the VID
// and PID,in the example
// format "Vid_04d8&Pid_003f".
SetupDiGetDeviceRegistryProperty(DeviceInfoTable, &DevInfoData, SPDRP_HARDWAREID,
&dwRegType, PropertyValueBuffer, dwRegSize, NULL);
// Now check if the first string in the hardware ID matches the device ID of my USB device.
// ListBox1->Items->Add((char*)PropertyValueBuffer);
DeviceIDFromRegistry = StrPas((char *)PropertyValueBuffer);
// free(PropertyValueBuffer); //No longer need the PropertyValueBuffer,free the memory to
// prevent potential memory leaks
delete PropertyValueBuffer; // No longer need the PropertyValueBuffer,free the memory to
// 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.
// We can get the path by calling SetupDiGetDeviceInterfaceDetail(),however,we have to
// call this function twice: The first
// time to get the size of the required structure/buffer to hold the detailed interface
// data,then a second time to actually
// get the structure (after we have allocated enough memory for the structure.)
DetailedInterfaceDataStructure->cbSize = sizeof(SP_DEVICE_INTERFACE_DETAIL_DATA);
// First call populates "StructureSize" with the correct value
SetupDiGetDeviceInterfaceDetail(DeviceInfoTable, InterfaceDataStructure, NULL, NULL,
&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;
}
DetailedInterfaceDataStructure->cbSize = sizeof(SP_DEVICE_INTERFACE_DETAIL_DATA);
// Now call SetupDiGetDeviceInterfaceDetail() a second time to receive the goods.
SetupDiGetDeviceInterfaceDetail(DeviceInfoTable, InterfaceDataStructure,
DetailedInterfaceDataStructure, StructureSize, NULL,
NULL);
// We now have the proper device path,and we can finally open read and write handles to
// the device.
// 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
ReadHandle = CreateFile((DetailedInterfaceDataStructure->DevicePath), GENERIC_READ,
FILE_SHARE_READ | FILE_SHARE_WRITE, NULL, OPEN_EXISTING, 0, 0);
ErrorStatus = GetLastError();
if (ErrorStatus == ERROR_SUCCESS)
{
// GetPushbuttonState->Enabled=true;//Make button no longer greyed out
// StateLabel->Enabled=true;//Make label no longer greyed out
}
SetupDiDestroyDeviceInfoList(
DeviceInfoTable); // Clean up the old structure we no longer need.
iRepeats = 0; // nowe szanse na pod³¹czenie
return true;
}
InterfaceIndex++;
// Keep looping until we either find a device with matching VID and PID,or until we run out
// of items.
} // end of while(true)
// ShowMessage("Sortie");
return false; return false;
}
}
else //Else some other kind of unknown error ocurred...
{
ErrorStatus=GetLastError();
SetupDiDestroyDeviceInfoList(DeviceInfoTable); //Clean up the old structure we no longer need.
//ShowMessage("Erreur: Sortie2");
return false;
}
//Now retrieve the hardware ID from the registry. The hardware ID contains the VID and PID, which we will then
//check to see if it is the correct device or not.
//Initialize an appropriate SP_DEVINFO_DATA structure. We need this structure for SetupDiGetDeviceRegistryProperty().
DevInfoData.cbSize=sizeof(SP_DEVINFO_DATA);
SetupDiEnumDeviceInfo(DeviceInfoTable,InterfaceIndex,&DevInfoData);
//First query for the size of the hardware ID, so we can know how big a buffer to allocate for the data.
SetupDiGetDeviceRegistryProperty(DeviceInfoTable,&DevInfoData,SPDRP_HARDWAREID,&dwRegType,NULL,0,&dwRegSize);
//Allocate a buffer for the hardware ID.
//PropertyValueBuffer=(BYTE*)malloc(dwRegSize);
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;
}
//Retrieve the hardware IDs for the current device we are looking at. PropertyValueBuffer gets filled with a
//REG_MULTI_SZ (array of null terminated strings). To find a device,we only care about the very first string in the
//buffer,which will be the "device ID". The device ID is a string which contains the VID and PID,in the example
//format "Vid_04d8&Pid_003f".
SetupDiGetDeviceRegistryProperty(DeviceInfoTable,&DevInfoData,SPDRP_HARDWAREID,&dwRegType,PropertyValueBuffer,dwRegSize,NULL);
//Now check if the first string in the hardware ID matches the device ID of my USB device.
//ListBox1->Items->Add((char*)PropertyValueBuffer);
DeviceIDFromRegistry=StrPas((char*)PropertyValueBuffer);
//free(PropertyValueBuffer); //No longer need the PropertyValueBuffer,free the memory to prevent potential memory leaks
delete PropertyValueBuffer; //No longer need the PropertyValueBuffer,free the memory to 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.
//We can get the path by calling SetupDiGetDeviceInterfaceDetail(),however,we have to call this function twice: The first
//time to get the size of the required structure/buffer to hold the detailed interface data,then a second time to actually
//get the structure (after we have allocated enough memory for the structure.)
DetailedInterfaceDataStructure->cbSize=sizeof(SP_DEVICE_INTERFACE_DETAIL_DATA);
//First call populates "StructureSize" with the correct value
SetupDiGetDeviceInterfaceDetail(DeviceInfoTable,InterfaceDataStructure,NULL,NULL,&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;
}
DetailedInterfaceDataStructure->cbSize=sizeof(SP_DEVICE_INTERFACE_DETAIL_DATA);
//Now call SetupDiGetDeviceInterfaceDetail() a second time to receive the goods.
SetupDiGetDeviceInterfaceDetail(DeviceInfoTable,InterfaceDataStructure,DetailedInterfaceDataStructure,StructureSize,NULL,NULL);
//We now have the proper device path,and we can finally open read and write handles to the device.
//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
ReadHandle=CreateFile((DetailedInterfaceDataStructure->DevicePath),GENERIC_READ,FILE_SHARE_READ|FILE_SHARE_WRITE,NULL,OPEN_EXISTING,0,0);
ErrorStatus=GetLastError();
if (ErrorStatus==ERROR_SUCCESS)
{
//GetPushbuttonState->Enabled=true;//Make button no longer greyed out
//StateLabel->Enabled=true;//Make label no longer greyed out
}
SetupDiDestroyDeviceInfoList(DeviceInfoTable); //Clean up the old structure we no longer need.
iRepeats=0; //nowe szanse na pod³¹czenie
return true;
}
InterfaceIndex++;
//Keep looping until we either find a device with matching VID and PID,or until we run out of items.
}//end of while(true)
//ShowMessage("Sortie");
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?
//(once we have the read and write handles to the device, which are obtained with CreateFile()). // The basic Windows I/O functions WriteFile() and ReadFile() can be used to read and write to
//The following call to WriteFile() sends 64 bytes of data to the USB device. // HID class USB devices
WriteFile(WriteHandle,&OutputBuffer,65,&BytesWritten,0); //Blocking function, unless an "overlapped" structure is used //(once we have the read and write handles to the device, which are obtained with CreateFile()).
return (BytesWritten==65); // The following call to WriteFile() sends 64 bytes of data to the USB device.
//Read(); //odczyt trzeba zrobiæ inaczej - w tym miejscu bêdzie za szybko i nic siê nie odczyta WriteFile(WriteHandle, &OutputBuffer, 65, &BytesWritten,
0); // Blocking function, unless an "overlapped" structure is used
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
return false; } while (--i);
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 "";
if (ReadLoop(10)) Write(0x00, 0); // 0x00 - Read serial number, version
{//3: serial MSB; 4: serial LSB; 5: software version (v(1+[4-7]).([0-3])); 6: revision number if (ReadLoop(10))
AnsiString s="PoKeys55 #"+AnsiString((InputBuffer[3]<<8)+InputBuffer[4]); { // 3: serial MSB; 4: serial LSB; 5: software version (v(1+[4-7]).([0-3])); 6: revision number
s+=" v"+AnsiString(1+(InputBuffer[5]>>4))+"."+AnsiString(InputBuffer[5]&15)+"."+AnsiString(InputBuffer[6]); AnsiString s = "PoKeys55 #" + AnsiString((InputBuffer[3] << 8) + InputBuffer[4]);
/* //Ra: pozyskiwanie daty mo¿na sobie darowaæ, jest poniek¹d bez sensu s += " v" + AnsiString(1 + (InputBuffer[5] >> 4)) + "." + AnsiString(InputBuffer[5] & 15) +
Write(0x04,0); //0x04 - Read build date: drugi argument zmieniaæ od 0 do 2, uzyskuj¹c kolejno po 4 znaki "." + AnsiString(InputBuffer[6]);
if (ReadLoop(5)) /* //Ra: pozyskiwanie daty mo¿na sobie darowaæ, jest poniek¹d bez sensu
{//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") Write(0x04,0); //0x04 - Read build date: drugi argument zmieniaæ od 0 do 2, uzyskuj¹c
s+=" ("+AnsiString((char*)InputBuffer+3,4); 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)) {//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,2); //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
if (ReadLoop(5)) kolejno po 4 znaki
s+=AnsiString((char*)InputBuffer+3,3); if (ReadLoop(5))
} {s+=AnsiString((char*)InputBuffer+3,4);
s+=")"; Write(0x04,2); //0x04 - Read build date: drugi argument zmieniaæ od 0 do 2, uzyskuj¹c
} kolejno po 4 znaki
*/ if (ReadLoop(5))
return s; s+=AnsiString((char*)InputBuffer+3,3);
} }
return ""; s+=")";
}
*/
return s;
}
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
break; // iRepeats=0;
case 1: //odczyt wejϾ analogowych - komenda i przetwarzanie break;
if (iLastCommand!=0x3A) //asynchroniczne ustawienie kontrolki mo¿e namieszaæ case 1: // odczyt wejœæ analogowych - komenda i przetwarzanie
Write(0x3A,0); //0x3A - Analog inputs reading – all analog inputs in one command if (iLastCommand != 0x3A) // asynchroniczne ustawienie kontrolki mo¿e namieszaæ
else if (Read()) Write(0x3A, 0); // 0x3A - Analog inputs reading – all analog inputs in one command
{//jest odebrana ramka i zgodnoœæ numeru ¿¹dania else if (Read())
fAnalog[0]=((InputBuffer[21]<<8)+InputBuffer[22])/4095.0f; //pin 47 { // jest odebrana ramka i zgodnoœæ numeru ¿¹dania
fAnalog[1]=((InputBuffer[19]<<8)+InputBuffer[20])/4095.0f; //pin 46 fAnalog[0] = ((InputBuffer[21] << 8) + InputBuffer[22]) / 4095.0f; // pin 47
fAnalog[2]=((InputBuffer[17]<<8)+InputBuffer[18])/4095.0f; //pin 45 fAnalog[1] = ((InputBuffer[19] << 8) + InputBuffer[20]) / 4095.0f; // pin 46
fAnalog[3]=((InputBuffer[15]<<8)+InputBuffer[16])/4095.0f; //pin 44 fAnalog[2] = ((InputBuffer[17] << 8) + InputBuffer[18]) / 4095.0f; // pin 45
fAnalog[4]=((InputBuffer[13]<<8)+InputBuffer[14])/4095.0f; //pin 43 fAnalog[3] = ((InputBuffer[15] << 8) + InputBuffer[16]) / 4095.0f; // pin 44
fAnalog[5]=((InputBuffer[11]<<8)+InputBuffer[12])/4095.0f; //pin 42 fAnalog[4] = ((InputBuffer[13] << 8) + InputBuffer[14]) / 4095.0f; // pin 43
fAnalog[6]=((InputBuffer[ 9]<<8)+InputBuffer[10])/4095.0f; //pin 41 fAnalog[5] = ((InputBuffer[11] << 8) + InputBuffer[12]) / 4095.0f; // pin 42
++iFaza; //skoro odczytano, mo¿na przejœæ do kolejnej fazy fAnalog[6] = ((InputBuffer[9] << 8) + InputBuffer[10]) / 4095.0f; // pin 41
iRepeats=0; //zerowanie licznika prób ++iFaza; // skoro odczytano, mo¿na przejœæ do kolejnej fazy
} iRepeats = 0; // zerowanie licznika prób
else ++iRepeats; //licznik nieudanych prób }
break; else
case 2: //odczyt wejœæ cyfrowych - komenda i przetwarzanie ++iRepeats; // licznik nieudanych prób
if (iLastCommand!=0x31) //asynchroniczne ustawienie kontrolki mo¿e namieszaæ break;
Write(0x31,0); //0x31: blokowy odczyt wejϾ case 2: // odczyt wejϾ cyfrowych - komenda i przetwarzanie
else if (Read()) if (iLastCommand != 0x31) // asynchroniczne ustawienie kontrolki mo¿e namieszaæ
{//jest odebrana ramka i zgodnoœæ numeru ¿¹dania Write(0x31, 0); // 0x31: blokowy odczyt wejœæ
iInputs[0]=*((int*)(InputBuffer+3)); //odczyt 32 bitów else if (Read())
iFaza=3; //skoro odczytano, mo¿na kolejny cykl { // jest odebrana ramka i zgodnoœæ numeru ¿¹dania
iRepeats=0; //zerowanie licznika prób iInputs[0] = *((int *)(InputBuffer + 3)); // odczyt 32 bitów
} iFaza = 3; // skoro odczytano, mo¿na kolejny cykl
else ++iRepeats; //licznik nieudanych prób iRepeats = 0; // zerowanie licznika prób
break; }
case 3: //ustawienie wyjœæ analogowych, 0..4095 mapowaæ na 0..65520 (<<4) else
if (Write(0x41,43-1,(iPWM[6]>>4),(iPWM[6]<<4))) //wys³anie ustawieñ ++iRepeats; // licznik nieudanych prób
iRepeats=0; //informacja, ¿e posz³o dobrze break;
iFaza=0; //++iFaza; //ta faza zosta³a zakoñczona case 3: // ustawienie wyjœæ analogowych, 0..4095 mapowaæ na 0..65520 (<<4)
//powinno jeszcze przyjœæ potwierdzenie o kodzie 0x41 if (Write(0x41, 43 - 1, (iPWM[6] >> 4), (iPWM[6] << 4))) // wys³anie ustawieñ
break; iRepeats = 0; // informacja, ¿e posz³o dobrze
default: iFaza = 0; //++iFaza; //ta faza zosta³a zakoñczona
iFaza=0; //na wypadek, gdyby zb³¹dzi³o po jakichœ zmianach w kodzie // powinno jeszcze przyjœæ potwierdzenie o kodzie 0x41
//iRepeats=0; break;
} default:
if (!iRepeats) iFaza = 0; // na wypadek, gdyby zb³¹dzi³o po jakichœ zmianach w kodzie
bNoError=true; //jest OK // iRepeats=0;
else if (iRepeats>=10) //youBy 2014-07: przy 5 powtórzeniach sieje mi pauz¹ po 2 razy na sekundê, a przy 10 jest ok }
{//przekroczenie liczby prób wymusza kolejn¹ fazê if (!iRepeats)
++iFaza; bNoError = true; // jest OK
iRepeats=1; //w nowej fazie nowe szanse, ale nie od 0! else if (iRepeats >= 10) // youBy 2014-07: przy 5 powtórzeniach sieje mi pauz¹ po 2 razy na
bNoError=false; //zg³osiæ b³¹d // sekundê, a przy 10 jest ok
} { // przekroczenie liczby prób wymusza kolejn¹ fazê
return (bNoError); //true oznacza prawid³owe dzia³anie ++iFaza;
//czy w przypadku b³êdu komunikacji z PoKeys w³¹czaæ pauzê? iRepeats = 1; // w nowej fazie nowe szanse, ale nie od 0!
//dopiero poprawne pod³¹czenie zeruje licznik prób bNoError = false; // zg³osiæ b³¹d
}
return (bNoError); // true oznacza prawid³owe dzia³anie
// czy w przypadku b³êdu komunikacji z PoKeys w³¹czaæ pauzê?
// dopiero poprawne pod³¹czenie zeruje licznik prób
}; };

47
Console/PoKeys55.h
View File

@@ -3,29 +3,30 @@
#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,
bool __fastcall Read(); unsigned char b5 = 0);
bool __fastcall ReadLoop(int i); bool __fastcall Read();
AnsiString __fastcall Version(); bool __fastcall ReadLoop(int i);
bool __fastcall PWM(int x,float y); AnsiString __fastcall Version();
bool __fastcall Update(bool pause); bool __fastcall PWM(int x, float y);
bool __fastcall Update(bool pause);
}; };
//--------------------------------------------------------------------------- //---------------------------------------------------------------------------
#endif #endif

124
Curve.cpp
View File

@@ -1,110 +1,109 @@
//--------------------------------------------------------------------------- //---------------------------------------------------------------------------
#include "system.hpp" #include "system.hpp"
#include "classes.hpp" #include "classes.hpp"
#pragma hdrstop #pragma hdrstop
#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;
if (b>=iNumValues)
return false; return false;
p-= floor(p); if (b >= iNumValues)
if (p<0.5) return false;
Values[a][c]= v; p -= floor(p);
if (p < 0.5)
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

8614
Driver.cpp
View File

File diff suppressed because it is too large Load Diff

602
Driver.h
View File

@@ -9,312 +9,340 @@
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
struct vector3 vPos; // współrzędne XYZ do liczenia odległości
{ struct
TTrack *trTrack; //wskaźnik na tor o zmiennej prędkości (zwrotnica, obrotnica) {
TEvent *evEvent; //połączenie z eventem albo komórką pamięci TTrack *trTrack; // wskaźnik na tor o zmiennej prędkości (zwrotnica, obrotnica)
}; TEvent *evEvent; // połączenie z eventem albo komórką pamięci
void __fastcall CommandCheck(); };
public: void __fastcall CommandCheck();
void __fastcall Clear();
bool __fastcall Update(vector3 *p,vector3 *dir,double &len); public:
bool __fastcall Set(TEvent *e,double d); void __fastcall Clear();
void __fastcall Set(TTrack *t,double d,int f); bool __fastcall Update(vector3 *p, vector3 *dir, double &len);
AnsiString __fastcall TableText(); bool __fastcall Set(TEvent *e, double d);
void __fastcall Set(TTrack *t, double d, int f);
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 LastReactionTime; double deltalog; // przyrost czasu
double fActionTime; //czas używany przy regulacji prędkości i zamykaniu drzwi double LastReactionTime;
TAction eAction; //aktualny stan double fActionTime; // czas używany przy regulacji prędkości i zamykaniu drzwi
bool HelpMeFlag; //wystawiane True jesli cos niedobrego sie dzieje TAction eAction; // aktualny stan
public: bool HelpMeFlag; // wystawiane True jesli cos niedobrego sie dzieje
bool AIControllFlag; //rzeczywisty/wirtualny maszynista public:
int iRouteWanted; //oczekiwany kierunek jazdy (0-stop,1-lewo,2-prawo,3-prosto) np. odpala migacz lub czeka na stan zwrotnicy bool AIControllFlag; // rzeczywisty/wirtualny maszynista
private: int iRouteWanted; // oczekiwany kierunek jazdy (0-stop,1-lewo,2-prawo,3-prosto) np. odpala
TDynamicObject *pVehicle; //pojazd w którym siedzi sterujący // migacz lub czeka na stan zwrotnicy
TDynamicObject *pVehicles[2]; //skrajne pojazdy w składzie (niekoniecznie bezpośrednio sterowane) private:
TMoverParameters *mvControlling; //jakim pojazdem steruje (może silnikowym w EZT) TDynamicObject *pVehicle; // pojazd w którym siedzi sterujący
TMoverParameters *mvOccupied; //jakim pojazdem hamuje TDynamicObject *
Mtable::TTrainParameters *TrainParams; //rozkład jazdy zawsze jest, nawet jeśli pusty pVehicles[2]; // skrajne pojazdy w składzie (niekoniecznie bezpośrednio sterowane)
//int TrainNumber; //numer rozkladowy tego pociagu TMoverParameters *mvControlling; // jakim pojazdem steruje (może silnikowym w EZT)
//AnsiString OrderCommand; //komenda pobierana z pojazdu TMoverParameters *mvOccupied; // jakim pojazdem hamuje
//double OrderValue; //argument komendy Mtable::TTrainParameters *TrainParams; // rozkład jazdy zawsze jest, nawet jeśli pusty
int iRadioChannel; //numer aktualnego kanału radiowego // int TrainNumber; //numer rozkladowy tego pociagu
TTextSound *tsGuardSignal; //komunikat od kierownika // AnsiString OrderCommand; //komenda pobierana z pojazdu
int iGuardRadio; //numer kanału radiowego kierownika (0, gdy nie używa radia) // double OrderValue; //argument komendy
public: int iRadioChannel; // numer aktualnego kanału radiowego
double AccPreferred; //preferowane przyspieszenie (wg psychiki kierującego, zmniejszana przy wykryciu kolizji) TTextSound *tsGuardSignal; // komunikat od kierownika
double AccDesired; //przyspieszenie, jakie ma utrzymywać (<0:nie przyspieszaj,<-0.1:hamuj) int iGuardRadio; // numer kanału radiowego kierownika (0, gdy nie używa radia)
double VelDesired; //predkość, z jaką ma jechać, wynikająca z analizy tableki; <=VelSignal public:
double fAccDesiredAv; //uśrednione przyspieszenie z kolejnych przebłysków świadomości, żeby ograniczyć migotanie double AccPreferred; // preferowane przyspieszenie (wg psychiki kierującego, zmniejszana przy
private: // wykryciu kolizji)
double VelforDriver; //prędkość, używana przy zmianie kierunku (ograniczenie przy nieznajmości szlaku?) double AccDesired; // przyspieszenie, jakie ma utrzymywać (<0:nie przyspieszaj,<-0.1:hamuj)
double VelSignal; //predkość zadawana przez semafor (funkcją SetVelocity()) double VelDesired; // predkość, z jaką ma jechać, wynikająca z analizy tableki; <=VelSignal
double VelLimit; //predkość zadawana przez event jednokierunkowego ograniczenia prędkości (PutValues albo komendą) double fAccDesiredAv; // uśrednione przyspieszenie z kolejnych przebłysków świadomości, żeby
public: // ograniczyć migotanie
double VelNext; //prędkość, jaka ma być po przejechaniu długości ProximityDist private:
private: double VelforDriver; // prędkość, używana przy zmianie kierunku (ograniczenie przy nieznajmości
//double fProximityDist; //odleglosc podawana w SetProximityVelocity(); >0:przeliczać do punktu, <0:podana wartość // szlaku?)
public: double VelSignal; // predkość zadawana przez semafor (funkcją SetVelocity())
double ActualProximityDist; //odległość brana pod uwagę przy wyliczaniu prędkości i przyspieszenia double VelLimit; // predkość zadawana przez event jednokierunkowego ograniczenia prędkości
private: // (PutValues albo komendą)
vector3 vCommandLocation; //polozenie wskaznika, sygnalizatora lub innego obiektu do ktorego odnosi sie komenda public:
TOrders OrderList[maxorders]; //lista rozkazów double VelNext; // prędkość, jaka ma być po przejechaniu długości ProximityDist
int OrderPos,OrderTop; //rozkaz aktualny oraz wolne miejsce do wstawiania nowych private:
std::ofstream LogFile; //zapis parametrow fizycznych // double fProximityDist; //odleglosc podawana w SetProximityVelocity(); >0:przeliczać do
std::ofstream AILogFile; //log AI // punktu, <0:podana wartość
bool MaxVelFlag; public:
bool MinVelFlag; double
int iDirection; //kierunek jazdy względem sprzęgów pojazdu, w którym siedzi AI (1=przód,-1=tył) ActualProximityDist; // odległość brana pod uwagę przy wyliczaniu prędkości i przyspieszenia
int iDirectionOrder; //żadany kierunek jazdy (służy do zmiany kierunku) private:
int iVehicleCount; //ilość pojazdów do odłączenia albo zabrania ze składu (-1=wszystkie) vector3 vCommandLocation; // polozenie wskaznika, sygnalizatora lub innego obiektu do ktorego
int iCoupler; //maska sprzęgu, jaką należy użyć przy łączeniu (po osiągnięciu trybu Connect), 0 gdy jazda bez łączenia // odnosi sie komenda
int iDriverFailCount; //licznik błędów AI TOrders OrderList[maxorders]; // lista rozkazów
bool Need_TryAgain; //true, jeśli druga pozycja w elektryku nie załapała int OrderPos, OrderTop; // rozkaz aktualny oraz wolne miejsce do wstawiania nowych
bool Need_BrakeRelease; std::ofstream LogFile; // zapis parametrow fizycznych
public: std::ofstream AILogFile; // log AI
double fMinProximityDist; //minimalna oległość do przeszkody, jaką należy zachować bool MaxVelFlag;
double fOverhead1; //informacja o napięciu w sieci trakcyjnej (0=brak drutu, zatrzymaj!) bool MinVelFlag;
double fOverhead2; //informacja o sposobie jazdy (-1=normalnie, 0=bez prądu, >0=z opuszczonym i ograniczeniem prędkości) int iDirection; // kierunek jazdy względem sprzęgów pojazdu, w którym siedzi AI (1=przód,-1=tył)
int iOverheadZero; //suma bitowa jezdy bezprądowej, bity ustawiane przez pojazdy z podniesionymi pantografami int iDirectionOrder; //żadany kierunek jazdy (służy do zmiany kierunku)
int iOverheadDown; //suma bitowa opuszczenia pantografów, bity ustawiane przez pojazdy z podniesionymi pantografami int iVehicleCount; // ilość pojazdów do odłączenia albo zabrania ze składu (-1=wszystkie)
double fVoltage; //uśrednione napięcie sieci: przy spadku poniżej wartości minimalnej opóźnić rozruch o losowy czas int iCoupler; // maska sprzęgu, jaką należy użyć przy łączeniu (po osiągnięciu trybu Connect), 0
private: // gdy jazda bez łączenia
double fMaxProximityDist; //akceptowalna odległość stanięcia przed przeszkodą int iDriverFailCount; // licznik błędów AI
TStopReason eStopReason; //powód zatrzymania przy ustawieniu zerowej prędkości bool Need_TryAgain; // true, jeśli druga pozycja w elektryku nie załapała
AnsiString VehicleName; bool Need_BrakeRelease;
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 public:
double fWarningDuration; //ile czasu jeszcze trąbić double fMinProximityDist; // minimalna oległość do przeszkody, jaką należy zachować
double fStopTime; //czas postoju przed dalszą jazdą (np. na przystanku) double fOverhead1; // informacja o napięciu w sieci trakcyjnej (0=brak drutu, zatrzymaj!)
double WaitingTime; //zliczany czas oczekiwania do samoistnego ruszenia double fOverhead2; // informacja o sposobie jazdy (-1=normalnie, 0=bez prądu, >0=z opuszczonym i
double WaitingExpireTime; //maksymlany czas oczekiwania do samoistnego ruszenia // ograniczeniem prędkości)
//TEvent* eSignLast; //ostatnio znaleziony sygnał, o ile nie minięty int iOverheadZero; // suma bitowa jezdy bezprądowej, bity ustawiane przez pojazdy z
private: //---//---//---//---// koniec zmiennych, poniżej metody //---//---//---//---// // podniesionymi pantografami
void __fastcall SetDriverPsyche(); int iOverheadDown; // suma bitowa opuszczenia pantografów, bity ustawiane przez pojazdy z
bool __fastcall PrepareEngine(); // podniesionymi pantografami
bool __fastcall ReleaseEngine(); double fVoltage; // uśrednione napięcie sieci: przy spadku poniżej wartości minimalnej opóźnić
bool __fastcall IncBrake(); // rozruch o losowy czas
bool __fastcall DecBrake(); private:
bool __fastcall IncSpeed(); double fMaxProximityDist; // akceptowalna odległość stanięcia przed przeszkodą
bool __fastcall DecSpeed(bool force=false); TStopReason eStopReason; // powód zatrzymania przy ustawieniu zerowej prędkości
void __fastcall SpeedSet(); AnsiString VehicleName;
void __fastcall Doors(bool what); double fVelPlus; // dopuszczalne przekroczenie prędkości na ograniczeniu bez hamowania
void __fastcall RecognizeCommand(); //odczytuje komende przekazana lokomotywie double fVelMinus; // margines obniżenia prędkości, powodujący załączenie napędu
void __fastcall Activation(); //umieszczenie obsady w odpowiednim członie double fWarningDuration; // ile czasu jeszcze trąbić
void __fastcall ControllingSet(); //znajduje człon do sterowania double fStopTime; // czas postoju przed dalszą jazdą (np. na przystanku)
void __fastcall AutoRewident(); //ustawia hamulce w składzie double WaitingTime; // zliczany czas oczekiwania do samoistnego ruszenia
public: double WaitingExpireTime; // maksymlany czas oczekiwania do samoistnego ruszenia
Mtable::TTrainParameters* __fastcall Timetable() {return TrainParams;}; // TEvent* eSignLast; //ostatnio znaleziony sygnał, o ile nie minięty
void __fastcall PutCommand(AnsiString NewCommand,double NewValue1,double NewValue2,const _mover::TLocation &NewLocation,TStopReason reason=stopComm); private: //---//---//---//---// koniec zmiennych, poniżej metody //---//---//---//---//
bool __fastcall PutCommand(AnsiString NewCommand,double NewValue1,double NewValue2,const vector3 *NewLocation,TStopReason reason=stopComm); void __fastcall SetDriverPsyche();
bool __fastcall UpdateSituation(double dt); //uruchamiac przynajmniej raz na sekundę bool __fastcall PrepareEngine();
//procedury dotyczace rozkazow dla maszynisty bool __fastcall ReleaseEngine();
void __fastcall SetVelocity(double NewVel,double NewVelNext,TStopReason r=stopNone); //uaktualnia informacje o prędkości bool __fastcall IncBrake();
bool __fastcall SetProximityVelocity(double NewDist,double NewVelNext); //uaktualnia informacje o prędkości przy nastepnym semaforze bool __fastcall DecBrake();
public: bool __fastcall IncSpeed();
void __fastcall JumpToNextOrder(); bool __fastcall DecSpeed(bool force = false);
void __fastcall JumpToFirstOrder(); void __fastcall SpeedSet();
void __fastcall OrderPush(TOrders NewOrder); void __fastcall Doors(bool what);
void __fastcall OrderNext(TOrders NewOrder); void __fastcall RecognizeCommand(); // odczytuje komende przekazana lokomotywie
TOrders __fastcall OrderCurrentGet(); void __fastcall Activation(); // umieszczenie obsady w odpowiednim członie
TOrders __fastcall OrderNextGet(); void __fastcall ControllingSet(); // znajduje człon do sterowania
bool __fastcall CheckVehicles(TOrders user=Wait_for_orders); void __fastcall AutoRewident(); // ustawia hamulce w składzie
private: public:
void __fastcall CloseLog(); Mtable::TTrainParameters *__fastcall Timetable() { return TrainParams; };
void __fastcall OrderCheck(); void __fastcall PutCommand(AnsiString NewCommand, double NewValue1, double NewValue2,
public: const _mover::TLocation &NewLocation, TStopReason reason = stopComm);
void __fastcall OrdersInit(double fVel); bool __fastcall PutCommand(AnsiString NewCommand, double NewValue1, double NewValue2,
void __fastcall OrdersClear(); const vector3 *NewLocation, TStopReason reason = stopComm);
void __fastcall OrdersDump(); bool __fastcall UpdateSituation(double dt); // uruchamiac przynajmniej raz na sekundę
__fastcall TController // procedury dotyczace rozkazow dla maszynisty
(bool AI, void __fastcall SetVelocity(double NewVel, double NewVelNext,
TDynamicObject *NewControll, TStopReason r = stopNone); // uaktualnia informacje o prędkości
bool InitPsyche, bool __fastcall SetProximityVelocity(
bool primary=true //czy ma aktywnie prowadzić? double NewDist,
); double NewVelNext); // uaktualnia informacje o prędkości przy nastepnym semaforze
AnsiString __fastcall OrderCurrent(); public:
void __fastcall WaitingSet(double Seconds); void __fastcall JumpToNextOrder();
private: void __fastcall JumpToFirstOrder();
AnsiString __fastcall Order2Str(TOrders Order); void __fastcall OrderPush(TOrders NewOrder);
void __fastcall DirectionForward(bool forward); void __fastcall OrderNext(TOrders NewOrder);
int __fastcall OrderDirectionChange(int newdir,TMoverParameters *Vehicle); TOrders __fastcall OrderCurrentGet();
void __fastcall Lights(int head,int rear); TOrders __fastcall OrderNextGet();
double __fastcall Distance(vector3 &p1,vector3 &n,vector3 &p2); bool __fastcall CheckVehicles(TOrders user = Wait_for_orders);
private: //Ra: metody obsługujące skanowanie toru
TEvent* __fastcall CheckTrackEvent(double fDirection,TTrack *Track); private:
bool __fastcall TableCheckEvent(TEvent *e); void __fastcall CloseLog();
bool __fastcall TableAddNew(); void __fastcall OrderCheck();
bool __fastcall TableNotFound(TEvent *e);
void __fastcall TableClear(); public:
TEvent* __fastcall TableCheckTrackEvent(double fDirection,TTrack *Track); void __fastcall OrdersInit(double fVel);
void __fastcall TableTraceRoute(double fDistance,TDynamicObject *pVehicle=NULL); void __fastcall OrdersClear();
void __fastcall TableCheck(double fDistance); void __fastcall OrdersDump();
TCommandType __fastcall TableUpdate(double &fVelDes,double &fDist,double &fNext,double &fAcc); __fastcall TController(bool AI, TDynamicObject *NewControll, bool InitPsyche,
void __fastcall TablePurger(); bool primary = true // czy ma aktywnie prowadzić?
private: //Ra: stare funkcje skanujące, używane do szukania sygnalizatora z tyłu );
bool __fastcall BackwardTrackBusy(TTrack *Track); AnsiString __fastcall OrderCurrent();
TEvent* __fastcall CheckTrackEventBackward(double fDirection,TTrack *Track); void __fastcall WaitingSet(double Seconds);
TTrack* __fastcall BackwardTraceRoute(double &fDistance,double &fDirection,TTrack *Track,TEvent*&Event);
void __fastcall SetProximityVelocity(double dist,double vel,const vector3 *pos); private:
TCommandType __fastcall BackwardScan(); AnsiString __fastcall Order2Str(TOrders Order);
public: void __fastcall DirectionForward(bool forward);
void __fastcall PhysicsLog(); int __fastcall OrderDirectionChange(int newdir, TMoverParameters *Vehicle);
AnsiString __fastcall StopReasonText(); void __fastcall Lights(int head, int rear);
__fastcall ~TController(); double __fastcall Distance(vector3 &p1, vector3 &n, vector3 &p2);
AnsiString __fastcall NextStop();
void __fastcall TakeControl(bool yes); private: // Ra: metody obsługujące skanowanie toru
AnsiString __fastcall Relation(); TEvent *__fastcall CheckTrackEvent(double fDirection, TTrack *Track);
AnsiString __fastcall TrainName(); bool __fastcall TableCheckEvent(TEvent *e);
int __fastcall StationCount(); bool __fastcall TableAddNew();
int __fastcall StationIndex(); bool __fastcall TableNotFound(TEvent *e);
bool __fastcall IsStop(); void __fastcall TableClear();
bool __fastcall Primary() {return this?bool(iDrivigFlags&movePrimary):false;}; TEvent *__fastcall TableCheckTrackEvent(double fDirection, TTrack *Track);
int inline __fastcall DrivigFlags() {return iDrivigFlags;}; void __fastcall TableTraceRoute(double fDistance, TDynamicObject *pVehicle = NULL);
void __fastcall MoveTo(TDynamicObject *to); void __fastcall TableCheck(double fDistance);
void __fastcall DirectionInitial(); TCommandType __fastcall TableUpdate(double &fVelDes, double &fDist, double &fNext,
AnsiString __fastcall TableText(int i); double &fAcc);
int __fastcall CrossRoute(TTrack *tr); void __fastcall TablePurger();
void __fastcall RouteSwitch(int d);
AnsiString __fastcall OwnerName(); private: // Ra: stare funkcje skanujące, używane do szukania sygnalizatora z tyłu
bool __fastcall BackwardTrackBusy(TTrack *Track);
TEvent *__fastcall CheckTrackEventBackward(double fDirection, TTrack *Track);
TTrack *__fastcall BackwardTraceRoute(double &fDistance, double &fDirection, TTrack *Track,
TEvent *&Event);
void __fastcall SetProximityVelocity(double dist, double vel, const vector3 *pos);
TCommandType __fastcall BackwardScan();
public:
void __fastcall PhysicsLog();
AnsiString __fastcall StopReasonText();
__fastcall ~TController();
AnsiString __fastcall NextStop();
void __fastcall TakeControl(bool yes);
AnsiString __fastcall Relation();
AnsiString __fastcall TrainName();
int __fastcall StationCount();
int __fastcall StationIndex();
bool __fastcall IsStop();
bool __fastcall Primary() { return this ? bool(iDrivigFlags & movePrimary) : false; };
int inline __fastcall DrivigFlags() { return iDrivigFlags; };
void __fastcall MoveTo(TDynamicObject *to);
void __fastcall DirectionInitial();
AnsiString __fastcall TableText(int i);
int __fastcall CrossRoute(TTrack *tr);
void __fastcall RouteSwitch(int d);
AnsiString __fastcall OwnerName();
}; };
#endif #endif

8590
DynObj.cpp
View File

File diff suppressed because it is too large Load Diff

650
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.)
union public:
{ union
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 *smAnimated; // animowany submodel (jeśli tylko jeden, np. oś)
int iShift; //przesunięcie przed przydzieleniem wskaźnika TSubModel **smElement; // jeśli animowanych elementów jest więcej (pantograf, napęd
}; // parowozu)
union int iShift; // przesunięcie przed przydzieleniem wskaźnika
{//parametry animacji };
TAnimValveGear *pValveGear; //współczynniki do animacji parowozu union
double *dWheelAngle; //wskaźnik na kąt obrotu osi { // parametry animacji
float *fParam; //różne parametry dla animacji TAnimValveGear *pValveGear; // współczynniki do animacji parowozu
TAnimPant *fParamPants; //różne parametry dla animacji double *dWheelAngle; // wskaźnik na kąt obrotu osi
}; float *fParam; // różne parametry dla animacji
union TAnimPant *fParamPants; // różne parametry dla animacji
{//wskaźnik na obiekt odniesienia };
double *fDoubleBase; //jakiś double w fizyce union
float *fFloatBase; //jakiś float w fizyce { // wskaźnik na obiekt odniesienia
int *iIntBase; //jakiś int w fizyce double *fDoubleBase; // jakiś double w fizyce
}; float *fFloatBase; // jakiś float w fizyce
//void _fastcall Update(); //wskaźnik do funkcji aktualizacji animacji int *iIntBase; // jakiś int w fizyce
int iFlags; //flagi animacji };
float fMaxDist; //do jakiej odległości wykonywana jest animacja // void _fastcall Update(); //wskaźnik do funkcji aktualizacji animacji
float fSpeed; //parametr szybkości animacji int iFlags; // flagi animacji
int iNumber; //numer kolejny obiektu float fMaxDist; // do jakiej odległości wykonywana jest animacja
public: float fSpeed; // parametr szybkości animacji
__fastcall TAnim(); int iNumber; // numer kolejny obiektu
__fastcall ~TAnim(); public:
TUpdate yUpdate; //metoda TDynamicObject aktualizująca animację __fastcall TAnim();
int __fastcall TypeSet(int i,int fl=0); //ustawienie typu __fastcall ~TAnim();
void __fastcall Parovoz(); //wykonanie obliczeń animacji TUpdate yUpdate; // metoda TDynamicObject aktualizująca animację
int __fastcall TypeSet(int i, int fl = 0); // ustawienie typu
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)
void UpdateAxle(TAnim *pAnim); //animacja osi
void UpdateBoogie(TAnim *pAnim); //animacja wózka
void UpdateDoorTranslate(TAnim *pAnim); //animacja drzwi - przesuw
void UpdateDoorRotate(TAnim *pAnim); //animacja drzwi - obrót
void UpdateDoorFold(TAnim *pAnim); //animacja drzwi - składanie
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;
//Winger 160204 - pantografy
double pantspeedfactor;
//animacje typu przesuw
TSubModel *smBuforLewy[2];
TSubModel *smBuforPrawy[2];
TAnimValveGear *pValveGear;
vector3 vFloor; //podłoga dla ładunku
public:
TAnim *pants; //indeks obiektu animującego dla pantografu 0
double NoVoltTime; //czas od utraty zasilania
double dDoorMoveL; //NBMX
double dDoorMoveR; //NBMX
TSubModel *smBrakeSet; //nastawa hamulca (wajcha)
TSubModel *smLoadSet; //nastawa ładunku (wajcha)
TSubModel *smWiper; //wycieraczka (poniekąd też wajcha)
//Ra: koneic animacji do ogarnięcia
private: private: // zmienne i metody do animacji submodeli; Ra: sprzatam animacje w pojeździe
void ABuLittleUpdate(double ObjSqrDist); public: // tymczasowo udostępnione do wyszukiwania drutu
bool btnOn; //ABu: czy byly uzywane buttony, jesli tak, to po renderingu wylacz int iAnimType[ANIM_TYPES]; // 0-osie,1-drzwi,2-obracane,3-zderzaki,4-wózki,5-pantografy,6-tłoki
//bo ten sam model moze byc jeszcze wykorzystany przez inny obiekt! private:
double __fastcall ComputeRadius(vector3 p1,vector3 p2,vector3 p3,vector3 p4); int iAnimations; // liczba obiektów animujących
TAnim *pAnimations; // obiekty animujące (zawierają wskaźnik do funkcji wykonującej animację)
TSubModel **
pAnimated; // lista animowanych submodeli (może być ich więcej niż obiektów animujących)
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)
void UpdateAxle(TAnim *pAnim); // animacja osi
void UpdateBoogie(TAnim *pAnim); // animacja wózka
void UpdateDoorTranslate(TAnim *pAnim); // animacja drzwi - przesuw
void UpdateDoorRotate(TAnim *pAnim); // animacja drzwi - obrót
void UpdateDoorFold(TAnim *pAnim); // animacja drzwi - składanie
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;
// Winger 160204 - pantografy
double pantspeedfactor;
// animacje typu przesuw
TSubModel *smBuforLewy[2];
TSubModel *smBuforPrawy[2];
TAnimValveGear *pValveGear;
vector3 vFloor; // podłoga dla ładunku
public:
TAnim *pants; // indeks obiektu animującego dla pantografu 0
double NoVoltTime; // czas od utraty zasilania
double dDoorMoveL; // NBMX
double dDoorMoveR; // NBMX
TSubModel *smBrakeSet; // nastawa hamulca (wajcha)
TSubModel *smLoadSet; // nastawa ładunku (wajcha)
TSubModel *smWiper; // wycieraczka (poniekąd też wajcha)
// Ra: koneic animacji do ogarnięcia
TButton btCoupler1; //sprzegi private:
void ABuLittleUpdate(double ObjSqrDist);
bool btnOn; // ABu: czy byly uzywane buttony, jesli tak, to po renderingu wylacz
// bo ten sam model moze byc jeszcze wykorzystany przez inny obiekt!
double __fastcall ComputeRadius(vector3 p1, vector3 p2, vector3 p3, vector3 p4);
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);
void ABuSetModelShake(vector3 mShake); // TDynamicObject* __fastcall GetFirstCabDynamic(int cpl_type);
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(); {
return (iAxleFirst ? Axle1.GetTrack() : Axle0.GetTrack());
};
// void __fastcall UpdatePos();
// McZapkie-260202
void __fastcall LoadMMediaFile(AnsiString BaseDir, AnsiString TypeName,
AnsiString ReplacableSkin);
//McZapkie-260202 inline double __fastcall ABuGetDirection() // ABu.
void __fastcall LoadMMediaFile(AnsiString BaseDir, AnsiString TypeName, AnsiString ReplacableSkin); {
return (Axle1.GetTrack() == MyTrack ? Axle1.GetDirection() : Axle0.GetDirection());
inline double __fastcall ABuGetDirection() //ABu. };
{ // inline double __fastcall ABuGetTranslation() //ABu.
return (Axle1.GetTrack()==MyTrack?Axle1.GetDirection():Axle0.GetDirection()); // {//zwraca przesunięcie wózka względem Point1 toru
}; // return (Axle1.GetTrack()==MyTrack?Axle1.GetTranslation():Axle0.GetTranslation());
// inline double __fastcall ABuGetTranslation() //ABu. // };
// {//zwraca przesunięcie wózka względem Point1 toru inline double __fastcall RaDirectionGet()
// return (Axle1.GetTrack()==MyTrack?Axle1.GetTranslation():Axle0.GetTranslation()); { // zwraca kierunek pojazdu na torze z aktywną osą
// }; return iAxleFirst ? Axle1.GetDirection() : Axle0.GetDirection();
inline double __fastcall RaDirectionGet() };
{//zwraca kierunek pojazdu na torze z aktywną osą inline double __fastcall RaTranslationGet()
return iAxleFirst?Axle1.GetDirection():Axle0.GetDirection(); { // zwraca przesunięcie wózka względem Point1 toru z aktywną osią
}; return iAxleFirst ? Axle1.GetTranslation() : Axle0.GetTranslation();
inline double __fastcall RaTranslationGet() };
{//zwraca przesunięcie wózka względem Point1 toru z aktywną osią inline TTrack *__fastcall RaTrackGet()
return iAxleFirst?Axle1.GetTranslation():Axle0.GetTranslation(); { // zwraca tor z aktywną osią
}; return iAxleFirst ? Axle1.GetTrack() : Axle0.GetTrack();
inline TTrack* __fastcall RaTrackGet() };
{//zwraca tor z aktywną osią void CouplersDettach(double MinDist, int MyScanDir);
return iAxleFirst?Axle1.GetTrack():Axle0.GetTrack(); void __fastcall RadioStop();
}; void __fastcall RaLightsSet(int head, int rear);
void CouplersDettach(double MinDist,int MyScanDir); // void __fastcall RaAxleEvent(TEvent *e);
void __fastcall RadioStop(); TDynamicObject *__fastcall FirstFind(int &coupler_nr);
void __fastcall RaLightsSet(int head,int rear); float __fastcall GetEPP(); // wyliczanie sredniego cisnienia w PG
//void __fastcall RaAxleEvent(TEvent *e); int __fastcall DirectionSet(int d); // ustawienie kierunku w składzie
TDynamicObject* __fastcall FirstFind(int &coupler_nr); int __fastcall DirectionGet()
float __fastcall GetEPP(); //wyliczanie sredniego cisnienia w PG {
int __fastcall DirectionSet(int d); //ustawienie kierunku w składzie return iDirection + iDirection - 1;
int __fastcall DirectionGet() {return iDirection+iDirection-1;}; //odczyt kierunku w składzie }; // 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
void __fastcall DestinationSet(AnsiString to); // jechać
AnsiString __fastcall TextureTest(AnsiString &name); void __fastcall DestinationSet(AnsiString to);
void __fastcall OverheadTrack(float o); AnsiString __fastcall TextureTest(AnsiString &name);
void __fastcall OverheadTrack(float o);
}; };
//--------------------------------------------------------------------------- //---------------------------------------------------------------------------
#endif #endif

1172
EU07.cpp
View File

File diff suppressed because it is too large Load Diff

283
EvLaunch.cpp
View File

@@ -6,7 +6,7 @@
*/ */
#include "system.hpp" #include "system.hpp"
#pragma hdrstop #pragma hdrstop
#include "mtable.hpp" #include "mtable.hpp"
@@ -20,164 +20,161 @@
#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 >> token; parser->getTokens();
asEvent1Name=AnsiString(token.c_str()); //pierwszy event *parser >> token;
parser->getTokens(); asEvent1Name = AnsiString(token.c_str()); // pierwszy event
*parser >> token; parser->getTokens();
asEvent2Name=AnsiString(token.c_str()); //drugi event *parser >> token;
if ((asEvent2Name=="end")||(asEvent2Name=="condition")) asEvent2Name = AnsiString(token.c_str()); // drugi event
{//drugiego eventu mo¿e nie byæ, bo s¹ z tym problemy, ale ciii... if ((asEvent2Name == "end") || (asEvent2Name == "condition"))
str=asEvent2Name; //rozpoznane s³owo idzie do dalszego przetwarzania { // drugiego eventu mo¿e nie byæ, bo s¹ z tym problemy, ale ciii...
asEvent2Name="none"; //a drugiego eventu nie ma str = asEvent2Name; // rozpoznane s³owo idzie do dalszego przetwarzania
} asEvent2Name = "none"; // a drugiego eventu nie ma
else }
{//gdy s¹ dwa eventy else
parser->getTokens(); { // gdy s¹ dwa eventy
*parser >> token; parser->getTokens();
str=AnsiString(token.c_str()); *parser >> token;
} str = AnsiString(token.c_str());
if (str==AnsiString("condition")) }
{//obs³uga wyzwalania warunkowego if (str == AnsiString("condition"))
parser->getTokens(); { // obs³uga wyzwalania warunkowego
*parser >> token; parser->getTokens();
asMemCellName=AnsiString(token.c_str()); *parser >> token;
parser->getTokens(); asMemCellName = AnsiString(token.c_str());
*parser >> token; parser->getTokens();
SafeDeleteArray(szText); *parser >> token;
szText=new char[256]; SafeDeleteArray(szText);
strcpy(szText,token.c_str()); szText = new char[256];
if (token.compare("*")!=0) //*=nie braæ command pod uwagê strcpy(szText, token.c_str());
iCheckMask|=conditional_memstring; if (token.compare("*") != 0) //*=nie braæ command pod uwagê
parser->getTokens(); iCheckMask |= conditional_memstring;
*parser >> token; parser->getTokens();
if (token.compare("*")!=0) //*=nie braæ wartoœci 1. pod uwagê *parser >> token;
{ if (token.compare("*") != 0) //*=nie braæ wartoœci 1. pod uwagê
iCheckMask|=conditional_memval1; {
str=AnsiString(token.c_str()); iCheckMask |= conditional_memval1;
fVal1=str.ToDouble(); str = AnsiString(token.c_str());
} fVal1 = str.ToDouble();
else fVal1=0; }
parser->getTokens(); else
*parser >> token; fVal1 = 0;
if (token.compare("*")!=0) //*=nie braæ wartoœci 2. pod uwagê parser->getTokens();
{ *parser >> token;
iCheckMask|=conditional_memval2; if (token.compare("*") != 0) //*=nie braæ wartoœci 2. pod uwagê
str=AnsiString(token.c_str()); {
fVal2=str.ToDouble(); iCheckMask |= conditional_memval2;
} str = AnsiString(token.c_str());
else fVal2=0; fVal2 = str.ToDouble();
parser->getTokens(); //s³owo zamykaj¹ce }
*parser >> token; else
} fVal2 = 0;
return true; parser->getTokens(); // s³owo zamykaj¹ce
*parser >> token;
}
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
bCond=(Console::Pressed(iKey)); //czy klawisz wciœniêty
}
if (DeltaTime>0)
{
if (UpdatedTime>DeltaTime)
{
UpdatedTime=0; //naliczanie od nowa
bCond=true;
}
else
UpdatedTime+=Timer::GetDeltaTime(); //aktualizacja naliczania czasu
}
else
{//jeœli nie cykliczny, to sprawdziæ czas
if (GlobalTime->hh==iHour)
{if (GlobalTime->mm==iMinute)
{//zgodnoϾ czasu uruchomienia
if (UpdatedTime<10)
{ {
UpdatedTime=20; //czas do kolejnego wyzwolenia? if (Global::bActive) // tylko jeœli okno jest aktywne
bCond=true; bCond = (Console::Pressed(iKey)); // czy klawisz wciœniêty
} }
} if (DeltaTime > 0)
} {
else if (UpdatedTime > DeltaTime)
UpdatedTime=1; {
} UpdatedTime = 0; // naliczanie od nowa
if (bCond) //jeœli spe³niony zosta³ warunek bCond = true;
{ }
if ((iCheckMask!=0)&&MemCell) //sprawdzanie warunku na komórce pamiêci else
bCond=MemCell->Compare(szText,fVal1,fVal2,iCheckMask); UpdatedTime += Timer::GetDeltaTime(); // aktualizacja naliczania czasu
} }
return bCond; //sprawdzanie dRadius w Ground.cpp else
{ // jeœli nie cykliczny, to sprawdziæ czas
if (GlobalTime->hh == iHour)
{
if (GlobalTime->mm == iMinute)
{ // zgodnoϾ czasu uruchomienia
if (UpdatedTime < 10)
{
UpdatedTime = 20; // czas do kolejnego wyzwolenia?
bCond = true;
}
}
}
else
UpdatedTime = 1;
}
if (bCond) // jeœli spe³niony zosta³ warunek
{
if ((iCheckMask != 0) && MemCell) // sprawdzanie warunku na komórce pamiêci
bCond = MemCell->Compare(szText, fVal1, fVal2, iCheckMask);
}
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;
}; };
//--------------------------------------------------------------------------- //---------------------------------------------------------------------------

46
EvLaunch.h
View File

@@ -7,29 +7,29 @@
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;
AnsiString asMemCellName; AnsiString asMemCellName;
TEvent *Event1; TEvent *Event1;
TEvent *Event2; TEvent *Event2;
TMemCell *MemCell; TMemCell *MemCell;
int iCheckMask; int iCheckMask;
__fastcall TEventLauncher(); __fastcall TEventLauncher();
__fastcall ~TEventLauncher(); __fastcall ~TEventLauncher();
void __fastcall Init(); void __fastcall Init();
bool __fastcall Load(cParser *parser); bool __fastcall Load(cParser *parser);
bool __fastcall Render(); bool __fastcall Render();
bool __fastcall IsGlobal(); bool __fastcall IsGlobal();
}; };
//--------------------------------------------------------------------------- //---------------------------------------------------------------------------

1172
Event.cpp
View File

File diff suppressed because it is too large Load Diff

132
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,39 +71,40 @@ 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:
AnsiString asName; public:
bool bEnabled; //false gdy ma nie byæ dodawany do kolejki (skanowanie sygna³ów) AnsiString asName;
int iQueued; //ile razy dodany do kolejki bool bEnabled; // false gdy ma nie byæ dodawany do kolejki (skanowanie sygna³ów)
//bool bIsHistory; int iQueued; // ile razy dodany do kolejki
TEvent *evNext; //nastêpny w kolejce // bool bIsHistory;
TEvent *evNext2; TEvent *evNext; // nastêpny w kolejce
TEventType Type; TEvent *evNext2;
double fStartTime; TEventType Type;
double fDelay; double fStartTime;
TDynamicObject *Activator; double fDelay;
TParam Params[13]; //McZapkie-070502 //Ra: zamieniæ to na union/struct TDynamicObject *Activator;
unsigned int iFlags; //zamiast Params[8] z flagami warunku TParam Params[13]; // McZapkie-070502 //Ra: zamieniæ to na union/struct
AnsiString asNodeName; //McZapkie-100302 - dodalem zeby zapamietac nazwe toru unsigned int iFlags; // zamiast Params[8] z flagami warunku
TEvent *evJoined; //kolejny event z t¹ sam¹ nazw¹ - od wersji 378 AnsiString asNodeName; // McZapkie-100302 - dodalem zeby zapamietac nazwe toru
double fRandomDelay; //zakres dodatkowego opóŸnienia TEvent *evJoined; // kolejny event z t¹ sam¹ nazw¹ - od wersji 378
public: //metody double fRandomDelay; // zakres dodatkowego opóŸnienia
__fastcall TEvent(AnsiString m=""); public: // metody
__fastcall ~TEvent(); __fastcall TEvent(AnsiString m = "");
void __fastcall Init(); __fastcall ~TEvent();
void __fastcall Load(cParser* parser,vector3 *org); void __fastcall Init();
void __fastcall AddToQuery(TEvent *e); void __fastcall Load(cParser *parser, vector3 *org);
AnsiString __fastcall CommandGet(); void __fastcall AddToQuery(TEvent *e);
TCommandType __fastcall Command(); AnsiString __fastcall CommandGet();
double __fastcall ValueGet(int n); TCommandType __fastcall Command();
vector3 __fastcall PositionGet(); double __fastcall ValueGet(int n);
bool __fastcall StopCommand(); vector3 __fastcall PositionGet();
void __fastcall StopCommandSent(); bool __fastcall StopCommand();
void __fastcall Append(TEvent *e); void __fastcall StopCommandSent();
void __fastcall Append(TEvent *e);
}; };
//--------------------------------------------------------------------------- //---------------------------------------------------------------------------

87
FadeSound.cpp
View File

@@ -5,101 +5,86 @@
*/ */
#include "system.hpp" #include "system.hpp"
#include "classes.hpp" #include "classes.hpp"
#pragma hdrstop #pragma hdrstop
#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
}; };

448
Float3d.h
View File

@@ -6,264 +6,274 @@
//--------------------------------------------------------------------------- //---------------------------------------------------------------------------
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)
double inline __fastcall Length() const; {
x = a;
y = b;
z = c;
};
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; {
return v1; v1.x += v2.x;
v1.y += v2.y;
v1.z += v2.z;
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;
return v1; v1.y *= d;
v1.z *= d;
v1.w *= d;
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; } {
void __fastcall Identity() for (int i = 0; i < 16; ++i)
{for (int i=0;i<16;++i) e[i] = f[i];
e[i]=0; };
e[0]=e[5]=e[10]=e[15]=1.0f; float *__fastcall operator()(int i) { return &e[i << 2]; }
} const float *__fastcall readArray(void) { return e; }
const float* operator[](int i) const {return &e[i<<2];}; void __fastcall Identity()
void __fastcall InitialRotate() {
{//taka specjalna rotacja, nie ma co ci¹gaæ trygonometrii for (int i = 0; i < 16; ++i)
float f; e[i] = 0;
for (int i=0;i<16;i+=4) e[0] = e[5] = e[10] = e[15] = 1.0f;
{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 const float *operator[](int i) const { return &e[i << 2]; };
} void __fastcall InitialRotate()
}; { // taka specjalna rotacja, nie ma co ci¹gaæ trygonometrii
inline float4x4& Rotation(double angle,float3 axis); float f;
inline bool IdentityIs() for (int i = 0; i < 16; i += 4)
{//sprawdzenie jednostkowoœci {
for (int i=0;i<16;++i) e[i] = -e[i]; // zmiana znaku X
if (e[i]!=((i%5)?0.0:1.0)) //jedynki tylko na 0, 5, 10 i 15 f = e[i + 1];
return false; e[i + 1] = e[i + 2];
return true; e[i + 2] = f; // zamiana Y i Z
} }
void __fastcall Quaternion(float4 *q); };
inline float3* TranslationGet() inline float4x4 &Rotation(double angle, float3 axis);
{return (float3*)(e+12);} inline bool IdentityIs()
{ // sprawdzenie jednostkowoœci
for (int i = 0; i < 16; ++i)
if (e[i] != ((i % 5) ? 0.0 : 1.0)) // jedynki tylko na 0, 5, 10 i 15
return false;
return true;
}
void __fastcall Quaternion(float4 *q);
inline float3 *TranslationGet() { 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)
double x = axis.x; axis = SafeNormalize(axis);
double y = axis.y; double x = axis.x;
double z = axis.z; double y = axis.y;
double xs = x * s; double z = axis.z;
double ys = y * s; double xs = x * s;
double zs = z * s; double ys = y * s;
double xyomc = x * y * omc; double zs = z * s;
double xzomc = x * z * omc; double xyomc = x * y * omc;
double yzomc = y * z * omc; double xzomc = x * z * omc;
e[0] =x*x*omc+c; double yzomc = y * z * omc;
e[1] =xyomc+zs; e[0] = x * x * omc + c;
e[2] =xzomc-ys; e[1] = xyomc + zs;
e[3] =0; e[2] = xzomc - ys;
e[4] =xyomc-zs; e[3] = 0;
e[5] =y*y*omc+c; e[4] = xyomc - zs;
e[6] =yzomc+xs; e[5] = y * y * omc + c;
e[7] =0; e[6] = yzomc + xs;
e[8] =xzomc+ys; e[7] = 0;
e[9] =yzomc-xs; e[8] = xzomc + ys;
e[10]=z*z*omc+c; e[9] = yzomc - xs;
e[11]=0; e[10] = z * z * omc + c;
e[12]=0; e[11] = 0;
e[13]=0; e[12] = 0;
e[14]=0; e[13] = 0;
e[15]=1; e[14] = 0;
return *this; e[15] = 1;
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

303
Gauge.cpp
View File

@@ -6,8 +6,8 @@
*/ */
#include "system.hpp" #include "system.hpp"
#include "classes.hpp" #include "classes.hpp"
#pragma hdrstop #pragma hdrstop
#include "Timer.h" #include "Timer.h"
@@ -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)
if (NewSubModel) { // ustawienie parametrów animacji submodelu
{//warunek na wszelki wypadek, gdyby siê submodel nie pod³¹czy³ if (NewSubModel)
fFriction=fNewFriction; { // warunek na wszelki wypadek, gdyby siê submodel nie pod³¹czy³
fValue=fNewValue; fFriction = fNewFriction;
fOffset=fNewOffset; fValue = fNewValue;
fScale=fNewScale; fOffset = fNewOffset;
SubModel=NewSubModel; fScale = fNewScale;
eType=eNewType; SubModel = NewSubModel;
if (eType==gt_Digital) eType = eNewType;
{ if (eType == gt_Digital)
TSubModel *sm=SubModel->ChildGet(); {
do TSubModel *sm = SubModel->ChildGet();
{//pêtla po submodelach potomnych i obracanie ich o k¹t zale¿y od cyfry w (fValue) do
if (sm->pName) { // pêtla po submodelach potomnych i obracanie ich o k¹t zale¿y od cyfry w (fValue)
{//musi mieæ niepust¹ nazwê if (sm->pName)
if ((*sm->pName)>='0') { // musi mieæ niepust¹ nazwê
if ((*sm->pName)<='9') if ((*sm->pName) >= '0')
sm->WillBeAnimated(); //wy³¹czenie optymalizacji if ((*sm->pName) <= '9')
sm->WillBeAnimated(); // wy³¹czenie optymalizacji
}
sm = sm->NextGet();
} while (sm);
}
else // a banan mo¿e byæ z optymalizacj¹?
NewSubModel->WillBeAnimated(); // wy³¹czenie ignowania jedynkowego transformu
} }
sm=sm->NextGet();
} while (sm);
}
else //a banan mo¿e byæ z optymalizacj¹?
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 else if (md2) // a jest podany drugi model (np. zewnêtrzny)
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
sm=md2->GetFromName(str1.c_str()); //to mo¿e tam bêdzie, co za ró¿nica gdzie if (str2 == "mov")
if (str2=="mov") Init(sm, gt_Move, val3, val4, val5);
Init(sm,gt_Move,val3,val4,val5); else if (str2 == "wip")
else if (str2=="wip") Init(sm, gt_Wiper, val3, val4, val5);
Init(sm,gt_Wiper,val3,val4,val5); else if (str2 == "dgt")
else if (str2=="dgt") Init(sm, gt_Digital, val3, val4, val5);
Init(sm,gt_Digital,val3,val4,val5); else
else Init(sm, gt_Rotate, val3, val4, val5);
Init(sm,gt_Rotate,val3,val4,val5); return (md2); // true, gdy podany model zewnêtrzny, a w kabinie nie by³o
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 <
else 0.5 * fFriction)) // McZapkie-281102: zabezpieczenie przed oscylacjami dla dlugich czasow
fValue=fDesiredValue; fValue += dt * (fDesiredValue - fValue) / fFriction;
if (SubModel) else
{//warunek na wszelki wypadek, gdyby siê submodel nie pod³¹czy³ fValue = fDesiredValue;
TSubModel *sm; if (SubModel)
switch (eType) { // warunek na wszelki wypadek, gdyby siê submodel nie pod³¹czy³
{ TSubModel *sm;
case gt_Rotate: switch (eType)
SubModel->SetRotate(float3(0,1,0),fValue*360.0); {
break; case gt_Rotate:
case gt_Move: SubModel->SetRotate(float3(0, 1, 0), fValue * 360.0);
SubModel->SetTranslate(float3(0,0,fValue)); break;
break; case gt_Move:
case gt_Wiper: SubModel->SetTranslate(float3(0, 0, fValue));
SubModel->SetRotate(float3(0,1,0),fValue*360.0); break;
sm=SubModel->ChildGet(); case gt_Wiper:
if (sm) SubModel->SetRotate(float3(0, 1, 0), fValue * 360.0);
{sm->SetRotate(float3(0,1,0),fValue*360.0); sm = SubModel->ChildGet();
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);
sm = sm->ChildGet();
if (sm)
sm->SetRotate(float3(0, 1, 0), fValue * 360.0);
}
break;
case gt_Digital: // Ra 2014-07: licznik cyfrowy
sm = SubModel->ChildGet();
AnsiString n = FormatFloat("0000000000", floor(fValue)); // na razie tak trochê bez
// sensu
do
{ // pêtla po submodelach potomnych i obracanie ich o k¹t zale¿y od cyfry w (fValue)
if (sm->pName)
{ // musi mieæ niepust¹ nazwê
if ((*sm->pName) >= '0')
if ((*sm->pName) <= '9')
sm->SetRotate(float3(0, 1, 0),
-36.0 * (n['0' + 10 - (*sm->pName)] - '0'));
}
sm = sm->NextGet();
} while (sm);
break;
}
} }
break;
case gt_Digital: //Ra 2014-07: licznik cyfrowy
sm=SubModel->ChildGet();
AnsiString n=FormatFloat("0000000000",floor(fValue)); //na razie tak trochê bez sensu
do
{//pêtla po submodelach potomnych i obracanie ich o k¹t zale¿y od cyfry w (fValue)
if (sm->pName)
{//musi mieæ niepust¹ nazwê
if ((*sm->pName)>='0')
if ((*sm->pName)<='9')
sm->SetRotate(float3(0,1,0),-36.0*(n['0'+10-(*sm->pName)]-'0'));
}
sm=sm->NextGet();
} while (sm);
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)

93
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:
__fastcall TGauge(); public:
__fastcall ~TGauge(); __fastcall TGauge();
void __fastcall Clear(); __fastcall ~TGauge();
void __fastcall Init(TSubModel *NewSubModel,TGaugeType eNewTyp,double fNewScale=1,double fNewOffset=0,double fNewFriction=0,double fNewValue=0); void __fastcall Clear();
bool __fastcall Load(TQueryParserComp *Parser,TModel3d *md1,TModel3d *md2=NULL,double mul=1.0); void __fastcall Init(TSubModel *NewSubModel, TGaugeType eNewTyp, double fNewScale = 1,
void __fastcall PermIncValue(double fNewDesired); double fNewOffset = 0, double fNewFriction = 0, double fNewValue = 0);
void __fastcall IncValue(double fNewDesired); bool __fastcall Load(TQueryParserComp *Parser, TModel3d *md1, TModel3d *md2 = NULL,
void __fastcall DecValue(double fNewDesired); double mul = 1.0);
void __fastcall UpdateValue(double fNewDesired); void __fastcall PermIncValue(double fNewDesired);
void __fastcall PutValue(double fNewDesired); void __fastcall IncValue(double fNewDesired);
float GetValue() {return fValue;}; void __fastcall DecValue(double fNewDesired);
void __fastcall Update(); void __fastcall UpdateValue(double fNewDesired);
void __fastcall Render(); void __fastcall PutValue(double fNewDesired);
void __fastcall AssignFloat(float* fValue); float GetValue() { return fValue; };
void __fastcall AssignDouble(double* dValue); void __fastcall Update();
void __fastcall AssignInt(int* iValue); void __fastcall Render();
void __fastcall UpdateValue(); void __fastcall AssignFloat(float *fValue);
TSubModel *SubModel; //McZapkie-310302: zeby mozna bylo sprawdzac czy zainicjowany poprawnie void __fastcall AssignDouble(double *dValue);
void __fastcall AssignInt(int *iValue);
void __fastcall UpdateValue();
TSubModel *SubModel; // McZapkie-310302: zeby mozna bylo sprawdzac czy zainicjowany poprawnie
}; };
//--------------------------------------------------------------------------- //---------------------------------------------------------------------------
#endif #endif

163
Geom.cpp
View File

@@ -1,7 +1,7 @@
//--------------------------------------------------------------------------- //---------------------------------------------------------------------------
#include "system.hpp" #include "system.hpp"
#include "classes.hpp" #include "classes.hpp"
#include <gl/gl.h> #include <gl/gl.h>
#include <gl/glu.h> #include <gl/glu.h>
#include "opengl/glut.h" #include "opengl/glut.h"
@@ -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()) /
else Parser->GetNextSymbol().ToDouble();
if (str=="y") else if (str == "y")
TempVerts[i].tu= (TempVerts[i].Point.y+Parser->GetNextSymbol().ToDouble())/Parser->GetNextSymbol().ToDouble(); TempVerts[i].tu = (TempVerts[i].Point.y + Parser->GetNextSymbol().ToDouble()) /
else Parser->GetNextSymbol().ToDouble();
if (str=="z") else if (str == "z")
TempVerts[i].tu= (TempVerts[i].Point.z+Parser->GetNextSymbol().ToDouble())/Parser->GetNextSymbol().ToDouble(); TempVerts[i].tu = (TempVerts[i].Point.z + Parser->GetNextSymbol().ToDouble()) /
else Parser->GetNextSymbol().ToDouble();
TempVerts[i].tu= str.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()) /
else Parser->GetNextSymbol().ToDouble();
if (str=="y") else if (str == "y")
TempVerts[i].tv= (TempVerts[i].Point.y+Parser->GetNextSymbol().ToDouble())/Parser->GetNextSymbol().ToDouble(); TempVerts[i].tv = (TempVerts[i].Point.y + Parser->GetNextSymbol().ToDouble()) /
else Parser->GetNextSymbol().ToDouble();
if (str=="z") else if (str == "z")
TempVerts[i].tv= (TempVerts[i].Point.z+Parser->GetNextSymbol().ToDouble())/Parser->GetNextSymbol().ToDouble(); TempVerts[i].tv = (TempVerts[i].Point.z + Parser->GetNextSymbol().ToDouble()) /
else Parser->GetNextSymbol().ToDouble();
TempVerts[i].tv= str.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+= r;
// tmp->fSquareRadius= 2000*2000+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();

1399
Globals.cpp
View File

File diff suppressed because it is too large Load Diff

507
Globals.h
View File

@@ -11,295 +11,298 @@
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:
__fastcall TTranscripts(); public:
__fastcall ~TTranscripts(); __fastcall TTranscripts();
void __fastcall AddLine(char *txt,float show,float hide,bool it); __fastcall ~TTranscripts();
void __fastcall Add(char *txt,float len,bool backgorund=false); //dodanie tekstów, d³ugoœæ dŸwiêku, czy istotne void __fastcall AddLine(char *txt, float show, float hide, bool it);
void __fastcall Update(); //usuwanie niepotrzebnych (ok. 10 razy na sekundê) void __fastcall Add(char *txt, float len,
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 pFreeCameraInitAngle[10]; static vector3 pFreeCameraInit[10]; // pozycje kamery
static int iWindowWidth; static vector3 pFreeCameraInitAngle[10];
static int iWindowHeight; static int iWindowWidth;
static float fDistanceFactor; static int iWindowHeight;
static int iBpp; static float fDistanceFactor;
static bool bFullScreen; static int iBpp;
static bool bFreeFly; static bool bFullScreen;
//float RunningTime; static bool bFreeFly;
static bool bWireFrame; // float RunningTime;
static bool bSoundEnabled; static bool bWireFrame;
//McZapkie-131202 static bool bSoundEnabled;
//static bool bRenderAlpha; // McZapkie-131202
static bool bAdjustScreenFreq; // static bool bRenderAlpha;
static bool bEnableTraction; static bool bAdjustScreenFreq;
static bool bLoadTraction; static bool bEnableTraction;
static float fFriction; static bool bLoadTraction;
static bool bLiveTraction; static float fFriction;
static bool bManageNodes; static bool bLiveTraction;
static bool bDecompressDDS; static bool bManageNodes;
// bool WFreeFly; static bool bDecompressDDS;
static float Global::fMouseXScale; // bool WFreeFly;
static float Global::fMouseYScale; static float Global::fMouseXScale;
static double fFogStart; static float Global::fMouseYScale;
static double fFogEnd; static double fFogStart;
static TGround *pGround; static double fFogEnd;
static char** szDefaultExt; static TGround *pGround;
static char szSceneryFile[256]; static char **szDefaultExt;
static char CreatorName1[20]; static char szSceneryFile[256];
static char CreatorName2[20]; static char CreatorName1[20];
static char CreatorName3[20]; static char CreatorName2[20];
static char CreatorName4[30]; static char CreatorName3[20];
static char CreatorName5[30]; static char CreatorName4[30];
static AnsiString asCurrentSceneryPath; static char CreatorName5[30];
static AnsiString asCurrentTexturePath; static AnsiString asCurrentSceneryPath;
static AnsiString asCurrentDynamicPath; static AnsiString asCurrentTexturePath;
//McZapkie-170602: zewnetrzna definicja pojazdu uzytkownika static AnsiString asCurrentDynamicPath;
static AnsiString asHumanCtrlVehicle; // McZapkie-170602: zewnetrzna definicja pojazdu uzytkownika
static void __fastcall LoadIniFile(AnsiString asFileName); static AnsiString asHumanCtrlVehicle;
static void __fastcall InitKeys(AnsiString asFileName); static void __fastcall LoadIniFile(AnsiString asFileName);
inline static vector3 __fastcall GetCameraPosition() static void __fastcall InitKeys(AnsiString asFileName);
{return pCameraPosition;}; inline static vector3 __fastcall GetCameraPosition() { 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[];
static GLfloat ambientLight[]; static GLfloat ambientLight[];
static GLfloat diffuseLight[]; static GLfloat diffuseLight[];
static GLfloat specularLight[]; static GLfloat specularLight[];
static GLfloat whiteLight[]; static GLfloat whiteLight[];
static GLfloat noLight[]; static GLfloat noLight[];
static GLfloat darkLight[]; static GLfloat darkLight[];
static GLfloat lightPos[4]; static GLfloat lightPos[4];
static int iSlowMotion; static int iSlowMotion;
static TDynamicObject *changeDynObj; static TDynamicObject *changeDynObj;
static double ABuDebug; static double ABuDebug;
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 void __fastcall BindTexture(GLuint t); static bool bActive; // czy jest aktywnym oknem
static int iConvertModels; //tworzenie plików binarnych static void __fastcall BindTexture(GLuint t);
static int iErorrCounter; //licznik sprawdzañ do œledzenia b³êdów OpenGL static int iConvertModels; // tworzenie plików binarnych
static bool bInactivePause; //automatyczna pauza, gdy okno nieaktywne static int iErorrCounter; // licznik sprawdzañ do œledzenia b³êdów OpenGL
static int iTextures; //licznik u¿ytych tekstur static bool bInactivePause; // automatyczna pauza, gdy okno nieaktywne
static int iSlowMotionMask; //maska wy³¹czanych w³aœciwoœci static int iTextures; // licznik u¿ytych tekstur
static int iModifyTGA; //czy korygowaæ pliki TGA dla szybszego wczytywania static int iSlowMotionMask; // maska wy³¹czanych w³aœciwoœci
static bool bHideConsole; //hunter-271211: ukrywanie konsoli static int iModifyTGA; // czy korygowaæ pliki TGA dla szybszego wczytywania
static TWorld *pWorld; //wskaŸnik na œwiat do usuwania pojazdów static bool bHideConsole; // hunter-271211: ukrywanie konsoli
static TAnimModel *pTerrainCompact; //obiekt terenu do ewentualnego zapisania w pliku static TWorld *pWorld; // wskaŸnik na œwiat do usuwania pojazdów
static AnsiString asTerrainModel; //nazwa obiektu terenu do zapisania w pliku static TAnimModel *pTerrainCompact; // obiekt terenu do ewentualnego zapisania w pliku
static bool bRollFix; //czy wykonaæ przeliczanie przechy³ki static AnsiString asTerrainModel; // nazwa obiektu terenu do zapisania w pliku
static Queryparsercomp::TQueryParserComp *qParser; static bool bRollFix; // czy wykonaæ przeliczanie przechy³ki
static cParser *pParser; static Queryparsercomp::TQueryParserComp *qParser;
static int iSegmentsRendered; //iloœæ segmentów do regulacji wydajnoœci static cParser *pParser;
static double fFpsAverage; //oczekiwana wartosæ FPS static int iSegmentsRendered; // iloœæ segmentów do regulacji wydajnoœci
static double fFpsDeviation; //odchylenie standardowe FPS static double fFpsAverage; // oczekiwana wartosæ FPS
static double fFpsMin; //dolna granica FPS, przy której promieñ scenerii bêdzie zmniejszany static double fFpsDeviation; // odchylenie standardowe FPS
static double fFpsMax; //górna granica FPS, przy której promieñ scenerii bêdzie zwiêkszany static double fFpsMin; // dolna granica FPS, przy której promieñ scenerii bêdzie zmniejszany
static double fFpsRadiusMax; //maksymalny promieñ renderowania static double fFpsMax; // górna granica FPS, przy której promieñ scenerii bêdzie zwiêkszany
static int iFpsRadiusMax; //maksymalny promieñ renderowania w rozmiarze tabeli sektorów static double fFpsRadiusMax; // maksymalny promieñ renderowania
static double fRadiusFactor; //wspó³czynnik zmiany promienia static int iFpsRadiusMax; // maksymalny promieñ renderowania w rozmiarze tabeli sektorów
static TCamera *pCamera; //parametry kamery static double fRadiusFactor; // wspó³czynnik zmiany promienia
static TDynamicObject *pUserDynamic; //pojazd u¿ytkownika, renderowany bez trzêsienia static TCamera *pCamera; // parametry kamery
static double fCalibrateIn[6][4]; //parametry kalibracyjne wejœæ z pulpitu static TDynamicObject *pUserDynamic; // pojazd u¿ytkownika, renderowany bez trzêsienia
static double fCalibrateOut[7][4]; //parametry kalibracyjne wyjϾ dla pulpitu static double fCalibrateIn[6][4]; // parametry kalibracyjne wejϾ z pulpitu
static double fBrakeStep; //krok zmiany hamulca dla klawiszy [Num3] i [Num9] static double fCalibrateOut[7][4]; // parametry kalibracyjne wyjϾ dla pulpitu
static bool bJoinEvents; //czy grupowaæ eventy o tych samych nazwach static double fBrakeStep; // krok zmiany hamulca dla klawiszy [Num3] i [Num9]
static bool bSmudge; //czy wyœwietlaæ smugê, a pojazd u¿ytkownika na koñcu static bool bJoinEvents; // czy grupowaæ eventy o tych samych nazwach
static AnsiString asTranscript[5]; //napisy na ekranie (widoczne) static bool bSmudge; // czy wyœwietlaæ smugê, a pojazd u¿ytkownika na koñcu
static TTranscripts tranTexts; //obiekt obs³uguj¹cy stenogramy dŸwiêków na ekranie static AnsiString asTranscript[5]; // napisy na ekranie (widoczne)
static AnsiString asLang; //domyœlny jêzyk - http://tools.ietf.org/html/bcp47 static TTranscripts tranTexts; // obiekt obs³uguj¹cy stenogramy dŸwiêków na ekranie
static int iHiddenEvents; //czy ³¹czyæ eventy z torami poprzez nazwê toru static AnsiString asLang; // domyœlny jêzyk - http://tools.ietf.org/html/bcp47
static TTextSound *tsRadioBusy[10]; //zajêtoœæ kana³ów radiowych (wskaŸnik na odgrywany dŸwiêk) static int iHiddenEvents; // czy ³¹czyæ eventy z torami poprzez nazwê toru
//metody static TTextSound *tsRadioBusy[10]; // zajêtoœæ kana³ów radiowych (wskaŸnik na odgrywany dŸwiêk)
static void __fastcall TrainDelete(TDynamicObject *d); // metody
static void __fastcall ConfigParse(Queryparsercomp::TQueryParserComp *qp,cParser *cp=NULL); static void __fastcall TrainDelete(TDynamicObject *d);
static AnsiString __fastcall GetNextSymbol(); static void __fastcall ConfigParse(Queryparsercomp::TQueryParserComp *qp, cParser *cp = NULL);
static TDynamicObject* __fastcall DynamicNearest(); static AnsiString __fastcall GetNextSymbol();
static TDynamicObject* __fastcall CouplerNearest(); static TDynamicObject *__fastcall DynamicNearest();
static bool __fastcall AddToQuery(TEvent *event,TDynamicObject *who); static TDynamicObject *__fastcall CouplerNearest();
static bool __fastcall DoEvents(); static bool __fastcall AddToQuery(TEvent *event, TDynamicObject *who);
static AnsiString __fastcall Bezogonkow(AnsiString str, bool _=false); static bool __fastcall DoEvents();
static AnsiString __fastcall Bezogonkow(AnsiString str, bool _ = false);
}; };
//--------------------------------------------------------------------------- //---------------------------------------------------------------------------

8808
Ground.cpp
View File

File diff suppressed because it is too large Load Diff

665
Ground.h
View File

@@ -10,358 +10,379 @@
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]; {
int iPar[62]; float fPar[62];
char cString[248]; //upakowane stringi int iPar[62];
}; 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:
__fastcall TSubRect(); void __fastcall LoadNodes(); // utworzenie VBO sektora
virtual __fastcall ~TSubRect(); public:
virtual void Release(); //zwalnianie VBO sektora __fastcall TSubRect();
void __fastcall NodeAdd(TGroundNode *Node); //dodanie obiektu do sektora na etapie rozdzielania na sektory virtual __fastcall ~TSubRect();
void __fastcall RaNodeAdd(TGroundNode *Node); //dodanie obiektu do listy renderowania virtual void Release(); // zwalnianie VBO sektora
void __fastcall Sort(); //optymalizacja obiektów w sektorze (sortowanie wg tekstur) void __fastcall NodeAdd(
TTrack* __fastcall FindTrack(vector3 *Point,int &iConnection,TTrack *Exclude); TGroundNode *Node); // dodanie obiektu do sektora na etapie rozdzielania na sektory
TTraction* __fastcall FindTraction(vector3 *Point,int &iConnection,TTraction *Exclude); void __fastcall RaNodeAdd(TGroundNode *Node); // dodanie obiektu do listy renderowania
bool __fastcall StartVBO(); //ustwienie VBO sektora dla (nRenderRect), (nRenderRectAlpha) i (nRenderWires) void __fastcall Sort(); // optymalizacja obiektów w sektorze (sortowanie wg tekstur)
bool __fastcall RaTrackAnimAdd(TTrack *t); //zgłoszenie toru do animacji TTrack *__fastcall FindTrack(vector3 *Point, int &iConnection, TTrack *Exclude);
void __fastcall RaAnimate(); //przeliczenie animacji torów TTraction *__fastcall FindTraction(vector3 *Point, int &iConnection, TTraction *Exclude);
void __fastcall RenderDL(); //renderowanie nieprzezroczystych w Display Lists bool __fastcall StartVBO(); // ustwienie VBO sektora dla (nRenderRect), (nRenderRectAlpha) i
void __fastcall RenderAlphaDL(); //renderowanie przezroczystych w Display Lists (McZapkie-131202) // (nRenderWires)
void __fastcall RenderVBO(); //renderowanie nieprzezroczystych z własnego VBO bool __fastcall RaTrackAnimAdd(TTrack *t); // zgłoszenie toru do animacji
void __fastcall RenderAlphaVBO(); //renderowanie przezroczystych z (własnego) VBO void __fastcall RaAnimate(); // przeliczenie animacji torów
void __fastcall RenderSounds(); //dźwięki pojazdów z niewidocznych sektorów void __fastcall RenderDL(); // renderowanie nieprzezroczystych w Display Lists
void __fastcall RenderAlphaDL(); // renderowanie przezroczystych w Display Lists
// (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
TGroundNode *nTerrain; //model terenu z E3D - użyć nRootMesh?
__fastcall TGroundRect();
virtual __fastcall ~TGroundRect();
TSubRect* __fastcall SafeGetRect(int iCol,int iRow) public:
{//pobranie wskaźnika do małego kwadratu, utworzenie jeśli trzeba static int iFrameNumber; // numer kolejny wyświetlanej klatki
if (!pSubRects) Init(); //utworzenie małych kwadratów TGroundNode *nTerrain; // model terenu z E3D - użyć nRootMesh?
return pSubRects+iRow*iNumSubRects+iCol; //zwrócenie właściwego __fastcall TGroundRect();
}; virtual __fastcall ~TGroundRect();
TSubRect* __fastcall FastGetRect(int iCol,int iRow)
{//pobranie wskaźnika do małego kwadratu, bez tworzenia jeśli nie ma TSubRect *__fastcall SafeGetRect(int iCol, int iRow)
return (pSubRects?pSubRects+iRow*iNumSubRects+iCol:NULL); { // pobranie wskaźnika do małego kwadratu, utworzenie jeśli trzeba
}; if (!pSubRects)
void __fastcall Optimize() Init(); // utworzenie małych kwadratów
{//optymalizacja obiektów w sektorach return pSubRects + iRow * iNumSubRects + iCol; // zwrócenie właściwego
if (pSubRects) };
for (int i=iNumSubRects*iNumSubRects-1;i>=0;--i) TSubRect *__fastcall FastGetRect(int iCol, int iRow)
pSubRects[i].Sort(); //optymalizacja obiektów w sektorach { // pobranie wskaźnika do małego kwadratu, bez tworzenia jeśli nie ma
}; return (pSubRects ? pSubRects + iRow * iNumSubRects + iCol : NULL);
void __fastcall RenderDL(); };
void __fastcall RenderVBO(); void __fastcall Optimize()
{ // optymalizacja obiektów w sektorach
if (pSubRects)
for (int i = iNumSubRects * iNumSubRects - 1; i >= 0; --i)
pSubRects[i].Sort(); // optymalizacja obiektów w sektorach
};
void __fastcall RenderDL();
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
TDynamicObject *LastDyn; //ABu: paskudnie, ale na bardzo szybko moze jakos przejdzie...
//TTrain *pTrain;
//double fVDozwolona;
//bool bTrabil;
__fastcall TGround(); public:
__fastcall ~TGround(); bool bDynamicRemove; // czy uruchomić procedurę usuwania pojazdów
void __fastcall Free(); TDynamicObject *LastDyn; // ABu: paskudnie, ale na bardzo szybko moze jakos przejdzie...
bool __fastcall Init(AnsiString asFile,HDC hDC); // TTrain *pTrain;
void __fastcall FirstInit(); // double fVDozwolona;
void __fastcall InitTracks(); // bool bTrabil;
void __fastcall InitTraction();
bool __fastcall InitEvents(); __fastcall TGround();
bool __fastcall InitLaunchers(); __fastcall ~TGround();
TTrack* __fastcall FindTrack(vector3 Point,int &iConnection,TGroundNode *Exclude); void __fastcall Free();
TTraction* __fastcall FindTraction(vector3 *Point,int &iConnection,TGroundNode *Exclude); bool __fastcall Init(AnsiString asFile, HDC hDC);
TTraction* __fastcall TractionNearestFind(vector3 &p,int dir,TGroundNode *n); void __fastcall FirstInit();
//TGroundNode* __fastcall CreateGroundNode(); void __fastcall InitTracks();
TGroundNode* __fastcall AddGroundNode(cParser* parser); void __fastcall InitTraction();
bool __fastcall AddGroundNode(double x,double z,TGroundNode *Node) bool __fastcall InitEvents();
{ bool __fastcall InitLaunchers();
TSubRect *tmp=GetSubRect(x,z); TTrack *__fastcall FindTrack(vector3 Point, int &iConnection, TGroundNode *Exclude);
if (tmp) TTraction *__fastcall FindTraction(vector3 *Point, int &iConnection, TGroundNode *Exclude);
{ TTraction *__fastcall TractionNearestFind(vector3 &p, int dir, TGroundNode *n);
tmp->NodeAdd(Node); // TGroundNode* __fastcall CreateGroundNode();
return true; TGroundNode *__fastcall AddGroundNode(cParser *parser);
} bool __fastcall AddGroundNode(double x, double z, TGroundNode *Node)
else {
return false; TSubRect *tmp = GetSubRect(x, z);
}; if (tmp)
// bool __fastcall Include(TQueryParserComp *Parser); {
//TGroundNode* __fastcall GetVisible(AnsiString asName); tmp->NodeAdd(Node);
TGroundNode* __fastcall GetNode(AnsiString asName); return true;
bool __fastcall AddDynamic(TGroundNode *Node); }
void __fastcall MoveGroundNode(vector3 pPosition); else
void __fastcall UpdatePhys(double dt,int iter); //aktualizacja fizyki stałym krokiem return false;
bool __fastcall Update(double dt,int iter); //aktualizacja przesunięć zgodna z FPS };
bool __fastcall AddToQuery(TEvent *Event, TDynamicObject *Node); // bool __fastcall Include(TQueryParserComp *Parser);
bool __fastcall GetTraction(TDynamicObject *model); // TGroundNode* __fastcall GetVisible(AnsiString asName);
bool __fastcall RenderDL(vector3 pPosition); TGroundNode *__fastcall GetNode(AnsiString asName);
bool __fastcall RenderAlphaDL(vector3 pPosition); bool __fastcall AddDynamic(TGroundNode *Node);
bool __fastcall RenderVBO(vector3 pPosition); void __fastcall MoveGroundNode(vector3 pPosition);
bool __fastcall RenderAlphaVBO(vector3 pPosition); void __fastcall UpdatePhys(double dt, int iter); // aktualizacja fizyki stałym krokiem
bool __fastcall CheckQuery(); bool __fastcall Update(double dt, int iter); // aktualizacja przesunięć zgodna z FPS
// __fastcall GetRect(double x, double z) { return &(Rects[int(x/fSubRectSize+fHalfNumRects)][int(z/fSubRectSize+fHalfNumRects)]); }; bool __fastcall AddToQuery(TEvent *Event, TDynamicObject *Node);
/* bool __fastcall GetTraction(TDynamicObject *model);
int __fastcall GetRowFromZ(double z) { return (z/fRectSize+fHalfNumRects); }; bool __fastcall RenderDL(vector3 pPosition);
int __fastcall GetColFromX(double x) { return (x/fRectSize+fHalfNumRects); }; bool __fastcall RenderAlphaDL(vector3 pPosition);
int __fastcall GetSubRowFromZ(double z) { return (z/fSubRectSize+fHalfNumSubRects); }; bool __fastcall RenderVBO(vector3 pPosition);
int __fastcall GetSubColFromX(double x) { return (x/fSubRectSize+fHalfNumSubRects); }; bool __fastcall RenderAlphaVBO(vector3 pPosition);
*/ bool __fastcall CheckQuery();
/* // __fastcall GetRect(double x, double z) { return
inline TGroundNode* __fastcall FindGroundNode(const AnsiString &asNameToFind ) // &(Rects[int(x/fSubRectSize+fHalfNumRects)][int(z/fSubRectSize+fHalfNumRects)]); };
{ /*
if (RootNode) int __fastcall GetRowFromZ(double z) { return (z/fRectSize+fHalfNumRects); };
return (RootNode->Find( asNameToFind )); int __fastcall GetColFromX(double x) { return (x/fRectSize+fHalfNumRects); };
else int __fastcall GetSubRowFromZ(double z) { return (z/fSubRectSize+fHalfNumSubRects); };
return NULL; int __fastcall GetSubColFromX(double x) { return (x/fSubRectSize+fHalfNumSubRects); };
} */
*/ /*
TGroundNode* __fastcall DynamicFindAny(AnsiString asNameToFind); inline TGroundNode* __fastcall FindGroundNode(const AnsiString &asNameToFind )
TGroundNode* __fastcall DynamicFind(AnsiString asNameToFind); {
void __fastcall DynamicList(bool all=false); if (RootNode)
TGroundNode* __fastcall FindGroundNode(AnsiString asNameToFind,TGroundNodeType iNodeType); return (RootNode->Find( asNameToFind ));
TGroundRect* __fastcall GetRect(double x, double z) { return &Rects[GetColFromX(x)/iNumSubRects][GetRowFromZ(z)/iNumSubRects]; }; else
TSubRect* __fastcall GetSubRect(double x, double z) { return GetSubRect(GetColFromX(x),GetRowFromZ(z)); }; return NULL;
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); TGroundNode *__fastcall DynamicFindAny(AnsiString asNameToFind);
int __fastcall GetRowFromZ(double z) { return (z/fSubRectSize+fHalfTotalNumSubRects); }; TGroundNode *__fastcall DynamicFind(AnsiString asNameToFind);
int __fastcall GetColFromX(double x) { return (x/fSubRectSize+fHalfTotalNumSubRects); }; void __fastcall DynamicList(bool all = false);
TEvent* __fastcall FindEvent(const AnsiString &asEventName); TGroundNode *__fastcall FindGroundNode(AnsiString asNameToFind, TGroundNodeType iNodeType);
TEvent* __fastcall FindEventScan(const AnsiString &asEventName); TGroundRect *__fastcall GetRect(double x, double z)
void __fastcall TrackJoin(TGroundNode *Current); {
private: return &Rects[GetColFromX(x) / iNumSubRects][GetRowFromZ(z) / iNumSubRects];
void __fastcall OpenGLUpdate(HDC hDC); };
void __fastcall RaTriangleDivider(TGroundNode* node); TSubRect *__fastcall GetSubRect(double x, double z)
void __fastcall Navigate(String ClassName,UINT Msg,WPARAM wParam,LPARAM lParam); {
bool PROBLEND; return GetSubRect(GetColFromX(x), GetRowFromZ(z));
public: };
void __fastcall WyslijEvent(const AnsiString &e,const AnsiString &d); TSubRect *__fastcall FastGetSubRect(double x, double z)
int iRendered; //ilość renderowanych sektorów, pobierana przy pokazywniu FPS {
void __fastcall WyslijString(const AnsiString &t,int n); return FastGetSubRect(GetColFromX(x), GetRowFromZ(z));
void __fastcall WyslijWolny(const AnsiString &t); };
void __fastcall WyslijNamiary(TGroundNode* t); TSubRect *__fastcall GetSubRect(int iCol, int iRow);
void __fastcall WyslijParam(int nr,int fl); TSubRect *__fastcall FastGetSubRect(int iCol, int iRow);
void __fastcall RadioStop(vector3 pPosition); int __fastcall GetRowFromZ(double z) { return (z / fSubRectSize + fHalfTotalNumSubRects); };
TDynamicObject* __fastcall DynamicNearest(vector3 pPosition,double distance=20.0,bool mech=false); int __fastcall GetColFromX(double x) { return (x / fSubRectSize + fHalfTotalNumSubRects); };
TDynamicObject* __fastcall CouplerNearest(vector3 pPosition,double distance=20.0,bool mech=false); TEvent *__fastcall FindEvent(const AnsiString &asEventName);
void __fastcall DynamicRemove(TDynamicObject* dyn); TEvent *__fastcall FindEventScan(const AnsiString &asEventName);
void __fastcall TerrainRead(const AnsiString &f); void __fastcall TrackJoin(TGroundNode *Current);
void __fastcall TerrainWrite();
void __fastcall TrackBusyList(); private:
void __fastcall IsolatedBusyList(); void __fastcall OpenGLUpdate(HDC hDC);
void __fastcall IsolatedBusy(const AnsiString t); void __fastcall RaTriangleDivider(TGroundNode *node);
void __fastcall Silence(vector3 gdzie); void __fastcall Navigate(String ClassName, UINT Msg, WPARAM wParam, LPARAM lParam);
bool PROBLEND;
public:
void __fastcall WyslijEvent(const AnsiString &e, const AnsiString &d);
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 WyslijNamiary(TGroundNode *t);
void __fastcall WyslijParam(int nr, int fl);
void __fastcall RadioStop(vector3 pPosition);
TDynamicObject *__fastcall DynamicNearest(vector3 pPosition, double distance = 20.0,
bool mech = false);
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 TerrainWrite();
void __fastcall TrackBusyList();
void __fastcall IsolatedBusyList();
void __fastcall IsolatedBusy(const AnsiString t);
void __fastcall Silence(vector3 gdzie);
}; };
//--------------------------------------------------------------------------- //---------------------------------------------------------------------------
#endif #endif

123
Logs.cpp
View File

@@ -1,7 +1,7 @@
//--------------------------------------------------------------------------- //---------------------------------------------------------------------------
#include "system.hpp" #include "system.hpp"
#include "classes.hpp" #include "classes.hpp"
#pragma hdrstop #pragma hdrstop
#include "Logs.h" #include "Logs.h"
@@ -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 << str << "\n"; output.open("log.txt", std::ios::trunc);
output.flush(); output << str << "\n";
} output.flush();
//hunter-271211: pisanie do konsoli tylko, gdy nie jest ukrywana }
if (Global::iWriteLogEnabled&2) // hunter-271211: pisanie do konsoli tylko, gdy nie jest ukrywana
WriteConsoleOnly(str); if (Global::iWriteLogEnabled & 2)
} 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; }
errors << "\n"; if (str)
errors.flush(); errors << str;
errors << "\n";
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)

4
Logs.h
View File

@@ -2,13 +2,13 @@
#ifndef LogsH #ifndef LogsH
#define LogsH #define LogsH
#include <system.hpp> #include <system.hpp>
void __fastcall WriteConsoleOnly(const char *str, double value); 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);
//--------------------------------------------------------------------------- //---------------------------------------------------------------------------

110
Machajka.cpp
View File

@@ -1,23 +1,16 @@
//--------------------------------------------------------------------------- //---------------------------------------------------------------------------
#include "system.hpp" #include "system.hpp"
#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 if (cKey == Global::Keys[k_IncLocalBrakeLevel])
else (DynamicObject->MoverParameters->IncLocalBrakeLevel(1));
if (cKey==Global::Keys[k_IncLocalBrakeLevel]) else if (cKey == Global::Keys[k_DecLocalBrakeLevel])
(DynamicObject->MoverParameters->IncLocalBrakeLevel(1)); (DynamicObject->MoverParameters->DecLocalBrakeLevel(1));
else else if (cKey == Global::Keys[k_MechLeft])
if (cKey==Global::Keys[k_DecLocalBrakeLevel]) vMechMovement.x += fMechCroach;
(DynamicObject->MoverParameters->DecLocalBrakeLevel(1)); else if (cKey == Global::Keys[k_MechRight])
else vMechMovement.x -= fMechCroach;
if (cKey==Global::Keys[k_MechLeft]) 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_MechRight]) vMechMovement.z += fMechCroach;
vMechMovement.x-=fMechCroach; else if (cKey == Global::Keys[k_MechUp])
else pMechOffset.y += 0.3; // McZapkie-120302 - wstawanie
if (cKey==Global::Keys[k_MechBackward]) 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_MechForward]) else // z shiftem
vMechMovement.z+=fMechCroach; {
else if (cKey == Global::Keys[k_IncMainCtrlFAST])
if (cKey==Global::Keys[k_MechUp]) (DynamicObject->MoverParameters->AddPulseForce(2));
pMechOffset.y+=0.3; //McZapkie-120302 - wstawanie else if (cKey == Global::Keys[k_DecMainCtrlFAST])
else (DynamicObject->MoverParameters->AddPulseForce(-2));
if (cKey==Global::Keys[k_MechDown]) else if (cKey == Global::Keys[k_IncLocalBrakeLevelFAST])
pMechOffset.y-=0.3; //McZapkie-120302 - siadanie, kucanie itp (DynamicObject->MoverParameters->IncLocalBrakeLevel(2));
} else if (cKey == Global::Keys[k_DecLocalBrakeLevelFAST])
else //z shiftem (DynamicObject->MoverParameters->DecLocalBrakeLevel(2));
{ }
if (cKey==Global::Keys[k_IncMainCtrlFAST])
(DynamicObject->MoverParameters->AddPulseForce(2));
else
if (cKey==Global::Keys[k_DecMainCtrlFAST])
(DynamicObject->MoverParameters->AddPulseForce(-2));
else
if (cKey==Global::Keys[k_IncLocalBrakeLevelFAST])
(DynamicObject->MoverParameters->IncLocalBrakeLevel(2));
else
if (cKey==Global::Keys[k_DecLocalBrakeLevelFAST])
(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

251
MdlMngr.cpp
View File

@@ -6,8 +6,8 @@
*/ */
#include "system.hpp" #include "system.hpp"
#include "classes.hpp" #include "classes.hpp"
#include "Texture.h" #include "Texture.h"
#pragma hdrstop #pragma hdrstop
@@ -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,115 +50,122 @@ __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)
{ // wczytanie modelu do tablicy
TModel3d *mdl = NULL;
if (Count >= MAX_MODELS)
Error("FIXME: Too many models, program will now crash :)");
else
{
mdl = Models[Count].LoadModel(Name, dynamic);
if (mdl)
Count++; // jeśli błąd wczytania modelu, to go nie wliczamy
}
return mdl;
} }
TModel3d *__fastcall TModelsManager::GetModel(const char *Name, bool dynamic)
TModel3d* __fastcall TModelsManager::LoadModel(char *Name,bool dynamic) { // model może być we wpisie "node...model" albo "node...dynamic", a także być dodatkowym w dynamic
{//wczytanie modelu do tablicy // (kabina, wnętrze, ładunek)
TModel3d *mdl=NULL; // dla "node...dynamic" mamy podaną ścieżkę w "\dynamic\" i musi być co najmniej 1 poziom, zwkle
if (Count>=MAX_MODELS) // są 2
Error("FIXME: Too many models, program will now crash :)"); // dla "node...model" może być typowy model statyczny ze ścieżką, domyślnie w "\scenery\" albo
else // "\models"
{ // albo może być model z "\dynamic\", jeśli potrzebujemy wstawić auto czy wagon nieruchomo
mdl=Models[Count].LoadModel(Name,dynamic); // - ze ścieżki z której jest wywołany, np. dir="scenery\bud\" albo dir="dynamic\pkp\st44_v1\"
if (mdl) Count++; //jeśli błąd wczytania modelu, to go nie wliczamy // plus name="model.t3d"
} // - z domyślnej ścieżki dla modeli, np. "scenery\" albo "models\" plus name="bud\dombale.t3d"
return mdl; // (dir="")
} // - konkretnie podanej ścieżki np. name="\scenery\bud\dombale.t3d" (dir="")
// wywołania:
TModel3d* __fastcall TModelsManager::GetModel(const char *Name,bool dynamic) // - konwersja wszystkiego do E3D, podawana dokładna ścieżka, tekstury tam, gdzie plik
{//model może być we wpisie "node...model" albo "node...dynamic", a także być dodatkowym w dynamic (kabina, wnętrze, ładunek) // - wczytanie kabiny, dokładna ścieżka, tekstury z katalogu modelu
//dla "node...dynamic" mamy podaną ścieżkę w "\dynamic\" i musi być co najmniej 1 poziom, zwkle są 2 // - wczytanie ładunku, ścieżka dokładna, tekstury z katalogu modelu
//dla "node...model" może być typowy model statyczny ze ścieżką, domyślnie w "\scenery\" albo "\models" // - wczytanie modelu, ścieżka dokładna, tekstury z katalogu modelu
//albo może być model z "\dynamic\", jeśli potrzebujemy wstawić auto czy wagon nieruchomo // - wczytanie przedsionków, ścieżka dokładna, tekstury z katalogu modelu
// - ze ścieżki z której jest wywołany, np. dir="scenery\bud\" albo dir="dynamic\pkp\st44_v1\" plus name="model.t3d" // - wczytanie uproszczonego wnętrza, ścieżka dokładna, tekstury z katalogu modelu
// - z domyślnej ścieżki dla modeli, np. "scenery\" albo "models\" plus name="bud\dombale.t3d" (dir="") // - niebo animowane, ścieżka brana ze wpisu, tekstury nieokreślone
// - konkretnie podanej ścieżki np. name="\scenery\bud\dombale.t3d" (dir="") // - wczytanie modelu animowanego - Init() - sprawdzić
//wywołania: char buf[255];
// - konwersja wszystkiego do E3D, podawana dokładna ścieżka, tekstury tam, gdzie plik AnsiString buftp = Global::asCurrentTexturePath; // zapamiętanie aktualnej ścieżki do tekstur,
// - wczytanie kabiny, dokładna ścieżka, tekstury z katalogu modelu // bo będzie tyczmasowo zmieniana
// - wczytanie ładunku, ścieżka dokładna, tekstury z katalogu modelu /*
// - wczytanie modelu, ścieżka dokładna, tekstury z katalogu modelu // Ra: niby tak jest lepiej, ale działa gorzej, więc przywrócone jest oryginalne
// - wczytanie przedsionków, ścieżka dokładna, tekstury z katalogu modelu //nawet jeśli model będzie pobrany z tablicy, to trzeba ustalić ścieżkę dla tekstur
// - wczytanie uproszczonego wnętrza, ścieżka dokładna, tekstury z katalogu modelu if (dynamic) //na razie tak, bo nie wiadomo, jaki może mieć wpływ na pozostałe modele
// - niebo animowane, ścieżka brana ze wpisu, tekstury nieokreślone {//dla pojazdów podana jest zawsze pełna ścieżka do modelu
// - wczytanie modelu animowanego - Init() - sprawdzić strcpy(buf,Name);
char buf[255]; if (strchr(Name,'/')!=NULL)
AnsiString buftp=Global::asCurrentTexturePath; //zapamiętanie aktualnej ścieżki do tekstur, bo będzie tyczmasowo zmieniana {//pobieranie tekstur z katalogu, w którym jest model
/* Global::asCurrentTexturePath=Global::asCurrentTexturePath+AnsiString(Name);
// Ra: niby tak jest lepiej, ale działa gorzej, więc przywrócone jest oryginalne Global::asCurrentTexturePath.Delete(Global::asCurrentTexturePath.Pos("/")+1,Global::asCurrentTexturePath.Length());
//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 }
{//dla pojazdów podana jest zawsze pełna ścieżka do modelu else
strcpy(buf,Name); {//dla modeli scenerii trzeba ustalić ścieżkę
if (strchr(Name,'/')!=NULL) if (strchr(Name,'\\')==NULL)
{//pobieranie tekstur z katalogu, w którym jest model {//jeśli nie ma lewego ukośnika w ścieżce, a jest prawy, to zmienić ścieżkę dla tekstur na tę
Global::asCurrentTexturePath=Global::asCurrentTexturePath+AnsiString(Name); z modelem
Global::asCurrentTexturePath.Delete(Global::asCurrentTexturePath.Pos("/")+1,Global::asCurrentTexturePath.Length()); strcpy(buf,"models\\"); //Ra: było by lepiej katalog dodać w parserze
} //strcpy(buf,"scenery\\"); //Ra: było by lepiej katalog dodać w parserze
} strcat(buf,Name);
else if (strchr(Name,'/')!=NULL)
{//dla modeli scenerii trzeba ustalić ścieżkę {//jeszcze musi być prawy ukośnik
if (strchr(Name,'\\')==NULL) Global::asCurrentTexturePath=Global::asCurrentTexturePath+AnsiString(Name);
{//jeśli nie ma lewego ukośnika w ścieżce, a jest prawy, to zmienić ścieżkę dla tekstur na tę z modelem Global::asCurrentTexturePath.Delete(Global::asCurrentTexturePath.Pos("/")+1,Global::asCurrentTexturePath.Length());
strcpy(buf,"models\\"); //Ra: było by lepiej katalog dodać w parserze }
//strcpy(buf,"scenery\\"); //Ra: było by lepiej katalog dodać w parserze }
strcat(buf,Name); else
if (strchr(Name,'/')!=NULL) {//jeśli jest lewy ukośnik, to ścieżkę do tekstur zmienić tylko dla pojazdów
{//jeszcze musi być prawy ukośnik strcpy(buf,Name);
Global::asCurrentTexturePath=Global::asCurrentTexturePath+AnsiString(Name); }
Global::asCurrentTexturePath.Delete(Global::asCurrentTexturePath.Pos("/")+1,Global::asCurrentTexturePath.Length()); }
} StrLower(buf);
} for (int i=0;i<Count;i++)
else {//bezsensowne przeszukanie tabeli na okoliczność wystąpienia modelu
{//jeśli jest lewy ukośnik, to ścieżkę do tekstur zmienić tylko dla pojazdów if (strcmp(buf,Models[i].Name)==0)
strcpy(buf,Name); {
} Global::asCurrentTexturePath=buftp; //odtworzenie ścieżki do tekstur
} return (Models[i].Model); //model znaleziony
StrLower(buf); }
for (int i=0;i<Count;i++) };
{//bezsensowne przeszukanie tabeli na okoliczność wystąpienia modelu */
if (strcmp(buf,Models[i].Name)==0) if (strchr(Name, '\\') == NULL)
{ {
Global::asCurrentTexturePath=buftp; //odtworzenie ścieżki do tekstur strcpy(buf, "models\\"); // Ra: było by lepiej katalog dodać w parserze
return (Models[i].Model); //model znaleziony strcat(buf, Name);
} if (strchr(Name, '/') != NULL)
}; {
*/ Global::asCurrentTexturePath = Global::asCurrentTexturePath + AnsiString(Name);
if (strchr(Name,'\\')==NULL) Global::asCurrentTexturePath.Delete(Global::asCurrentTexturePath.Pos("/") + 1,
{ Global::asCurrentTexturePath.Length());
strcpy(buf,"models\\"); //Ra: było by lepiej katalog dodać w parserze }
strcat(buf,Name); }
if (strchr(Name,'/')!=NULL) else
{ {
Global::asCurrentTexturePath= Global::asCurrentTexturePath+AnsiString(Name); strcpy(buf, Name);
Global::asCurrentTexturePath.Delete(Global::asCurrentTexturePath.Pos("/")+1,Global::asCurrentTexturePath.Length()); if (dynamic) // na razie tak, bo nie wiadomo, jaki może mieć wpływ na pozostałe modele
} if (strchr(Name, '/') != NULL)
} { // pobieranie tekstur z katalogu, w którym jest model
else Global::asCurrentTexturePath = Global::asCurrentTexturePath + AnsiString(Name);
{strcpy(buf,Name); Global::asCurrentTexturePath.Delete(Global::asCurrentTexturePath.Pos("/") + 1,
if (dynamic) //na razie tak, bo nie wiadomo, jaki może mieć wpływ na pozostałe modele Global::asCurrentTexturePath.Length());
if (strchr(Name,'/')!=NULL) }
{//pobieranie tekstur z katalogu, w którym jest model }
Global::asCurrentTexturePath= Global::asCurrentTexturePath+AnsiString(Name); StrLower(buf);
Global::asCurrentTexturePath.Delete(Global::asCurrentTexturePath.Pos("/")+1,Global::asCurrentTexturePath.Length()); for (int i = 0; i < Count; i++)
} {
} if (strcmp(buf, Models[i].Name) == 0)
StrLower(buf); {
for (int i=0; i<Count; i++) Global::asCurrentTexturePath = buftp;
{ return (Models[i].Model);
if (strcmp(buf,Models[i].Name)==0) }
{ };
Global::asCurrentTexturePath= buftp; TModel3d *tmpModel = LoadModel(buf, dynamic); // model nie znaleziony, to wczytać
return (Models[i].Model); Global::asCurrentTexturePath = buftp; // odtworzenie ścieżki do tekstur
} return (tmpModel); // NULL jeśli błąd
};
TModel3d* tmpModel=LoadModel(buf,dynamic); //model nie znaleziony, to wczytać
Global::asCurrentTexturePath=buftp; //odtworzenie ścieżki do tekstur
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

247
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,151 +25,153 @@
__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 }
{eCommand=cm_ShuntVelocity; else if (strcmp(szText, "ShuntVelocity") == 0) // w tarczach manewrowych
bCommand=false; //ta komenda nie jest wysy³ana {
} eCommand = cm_ShuntVelocity;
else if (strcmp(szText,"Change_direction")==0) //zdarza siê bCommand = false; // ta komenda nie jest wysy³ana
{eCommand=cm_ChangeDirection; }
bCommand=true; //do wys³ania else if (strcmp(szText, "Change_direction") == 0) // zdarza siê
} {
else if (strcmp(szText,"OutsideStation")==0) //zdarza siê eCommand = cm_ChangeDirection;
{eCommand=cm_OutsideStation; bCommand = true; // do wys³ania
bCommand=false; //tego nie powinno byæ w komórce }
} else if (strcmp(szText, "OutsideStation") == 0) // zdarza siê
else if (strncmp(szText,"PassengerStopPoint:",19)==0) //porównanie pocz¹tków {
{eCommand=cm_PassengerStopPoint; eCommand = cm_OutsideStation;
bCommand=false; //tego nie powinno byæ w komórce bCommand = false; // tego nie powinno byæ w komórce
} }
else if (strcmp(szText,"SetProximityVelocity")==0) //nie powinno tego byæ else if (strncmp(szText, "PassengerStopPoint:", 19) == 0) // porównanie pocz¹tków
{eCommand=cm_SetProximityVelocity; {
bCommand=false; //ta komenda nie jest wysy³ana eCommand = cm_PassengerStopPoint;
} bCommand = false; // tego nie powinno byæ w komórce
else }
{eCommand=cm_Unknown; //ci¹g nierozpoznany (nie jest komend¹) else if (strcmp(szText, "SetProximityVelocity") == 0) // nie powinno tego byæ
bCommand=true; //do wys³ania {
} eCommand = cm_SetProximityVelocity;
return eCommand; bCommand = false; // ta komenda nie jest wysy³ana
}
else
{
eCommand = cm_Unknown; // ci¹g nierozpoznany (nie jest komend¹)
bCommand = true; // do wys³ania
}
return eCommand;
} }
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
if (pos) char *pos = StrPos(szTestText, "*"); // zwraca wskaŸnik na pozycjê albo NULL
{//porównanie fragmentu ³añcucha if (pos)
int i=pos-szTestText; //iloœæ porównywanych znaków { // porównanie fragmentu ³añcucha
if (i) //jeœli nie jest pierwszym znakiem int i = pos - szTestText; // iloœæ porównywanych znaków
if (AnsiString(szTestText,i)!=AnsiString(szText,i)) if (i) // jeœli nie jest pierwszym znakiem
return false; //pocz¹tki o d³ugoœci (i) s¹ ró¿ne if (AnsiString(szTestText, i) != AnsiString(szText, i))
} return false; // pocz¹tki o d³ugoœci (i) s¹ ró¿ne
else }
if (AnsiString(szTestText)!=AnsiString(szText)) else 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;
};

59
MemCell.h
View File

@@ -9,34 +9,37 @@ 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
__fastcall TMemCell(vector3 *p); asTrackName; // McZapkie-100302 - zeby nazwe toru na ktory jest Putcommand wysylane pamietac
__fastcall ~TMemCell(); __fastcall TMemCell(vector3 *p);
void __fastcall Init(); __fastcall ~TMemCell();
void __fastcall UpdateValues(char *szNewText, double fNewValue1, double fNewValue2, int CheckMask); void __fastcall Init();
bool __fastcall Load(cParser *parser); void __fastcall UpdateValues(char *szNewText, double fNewValue1, double fNewValue2,
void __fastcall PutCommand(TController *Mech, vector3 *Loc); int CheckMask);
bool __fastcall Compare(char *szTestText, double fTestValue1, double fTestValue2, int CheckMask); bool __fastcall Load(cParser *parser);
bool __fastcall Render(); void __fastcall PutCommand(TController *Mech, vector3 *Loc);
inline char* __fastcall Text() {return szText;}; bool __fastcall Compare(char *szTestText, double fTestValue1, double fTestValue2,
inline double __fastcall Value1() {return fValue1;}; int CheckMask);
inline double __fastcall Value2() {return fValue2;}; bool __fastcall Render();
inline vector3 __fastcall Position() {return vPosition;}; inline char *__fastcall Text() { return szText; };
inline TCommandType __fastcall Command() {return eCommand;}; inline double __fastcall Value1() { return fValue1; };
inline bool __fastcall StopCommand() {return bCommand;}; inline double __fastcall Value2() { return fValue2; };
void __fastcall StopCommandSent(); inline vector3 __fastcall Position() { return vPosition; };
TCommandType __fastcall CommandCheck(); inline TCommandType __fastcall Command() { return eCommand; };
bool __fastcall IsVelocity(); inline bool __fastcall StopCommand() { return bCommand; };
void __fastcall AssignEvents(TEvent *e); void __fastcall StopCommandSent();
TCommandType __fastcall CommandCheck();
bool __fastcall IsVelocity();
void __fastcall AssignEvents(TEvent *e);
}; };
//--------------------------------------------------------------------------- //---------------------------------------------------------------------------

3724
Model3d.cpp
View File

File diff suppressed because it is too large Load Diff

581
Model3d.h
View File

@@ -11,44 +11,47 @@ using namespace Math3D;
struct GLVERTEX struct GLVERTEX
{ {
vector3 Point; vector3 Point;
vector3 Normal; vector3 Normal;
float tu,tv; float tu, tv;
}; };
class TStringPack class TStringPack
{ {
char *data; char *data;
//+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 - obszar łańcuchów znakowych, każdy zakończony zerem //+8 - obszar łańcuchów znakowych, każdy zakończony zerem
int *index; int *index;
//+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; };
{ // __fastcall TMaterialColor(double R, double G, double B)
r=g=b=V;
};
// __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,265 +104,298 @@ 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)
union // bit 15: =1 wymagane przechowanie macierzy (transform niejedynkowy)
{//transform, nie każdy submodel musi mieć union
float4x4 *fMatrix; //pojedyncza precyzja wystarcza { // transform, nie każdy submodel musi mieć
//matrix4x4 *dMatrix; //do testu macierz podwójnej precyzji float4x4 *fMatrix; // pojedyncza precyzja wystarcza
int iMatrix; //w pliku binarnym jest numer matrycy // matrix4x4 *dMatrix; //do testu macierz podwójnej precyzji
}; int iMatrix; // w pliku binarnym jest numer matrycy
int iNumVerts; //ilość wierzchołków (1 dla FreeSpotLight) };
int iVboPtr; //początek na liście wierzchołków albo indeksów int iNumVerts; // ilość wierzchołków (1 dla FreeSpotLight)
int iTexture; //numer nazwy tekstury, -1 wymienna, 0 brak int iVboPtr; // początek na liście wierzchołków albo indeksów
float fVisible; //próg jasności światła do załączenia submodelu int iTexture; // numer nazwy tekstury, -1 wymienna, 0 brak
float fLight; //próg jasności światła do zadziałania selfillum float fVisible; // próg jasności światła do załączenia submodelu
float f4Ambient[4]; float fLight; // próg jasności światła do zadziałania selfillum
float f4Diffuse[4]; //float ze względu na glMaterialfv() float f4Ambient[4];
float f4Specular[4]; float f4Diffuse[4]; // float ze względu na glMaterialfv()
float f4Emision[4]; float f4Specular[4];
float fWireSize; //nie używane, ale wczytywane float f4Emision[4];
float fSquareMaxDist; float fWireSize; // nie używane, ale wczytywane
float fSquareMinDist; float fSquareMaxDist;
//McZapkie-050702: parametry dla swiatla: float fSquareMinDist;
float fNearAttenStart; // McZapkie-050702: parametry dla swiatla:
float fNearAttenEnd; float fNearAttenStart;
int bUseNearAtten; //te 3 zmienne okreslaja rysowanie aureoli wokol zrodla swiatla float fNearAttenEnd;
int iFarAttenDecay; //ta zmienna okresla typ zaniku natezenia swiatla (0:brak, 1,2: potega 1/R) int bUseNearAtten; // te 3 zmienne okreslaja rysowanie aureoli wokol zrodla swiatla
float fFarDecayRadius; //normalizacja j.w. int iFarAttenDecay; // ta zmienna okresla typ zaniku natezenia swiatla (0:brak, 1,2: potega 1/R)
float fCosFalloffAngle; //cosinus kąta stożka pod którym widać światło float fFarDecayRadius; // normalizacja j.w.
float fCosHotspotAngle; //cosinus kąta stożka pod którym widać aureolę i zwiększone natężenie światła float fCosFalloffAngle; // cosinus kąta stożka pod którym widać światło
float fCosViewAngle; //cos kata pod jakim sie teraz patrzy float fCosHotspotAngle; // cosinus kąta stożka pod którym widać aureolę i zwiększone natężenie
//Ra: dalej są zmienne robocze, można je przestawiać z zachowaniem rozmiaru klasy // światła
int TextureID; //numer tekstury, -1 wymienna, 0 brak float fCosViewAngle; // cos kata pod jakim sie teraz patrzy
int bWire; //nie używane, ale wczytywane // Ra: dalej są zmienne robocze, można je przestawiać z zachowaniem rozmiaru klasy
//short TexAlpha; //Ra: nie używane już int TextureID; // numer tekstury, -1 wymienna, 0 brak
GLuint uiDisplayList; //roboczy numer listy wyświetlania int bWire; // nie używane, ale wczytywane
float Opacity; //nie używane, ale wczytywane // short TexAlpha; //Ra: nie używane już
//ABu: te same zmienne, ale zdublowane dla Render i RenderAlpha, GLuint uiDisplayList; // roboczy numer listy wyświetlania
//bo sie chrzanilo przemieszczanie obiektow. float Opacity; // nie używane, ale wczytywane
//Ra: już się nie chrzani // ABu: te same zmienne, ale zdublowane dla Render i RenderAlpha,
float f_Angle; // bo sie chrzanilo przemieszczanie obiektow.
float3 v_RotateAxis; // Ra: już się nie chrzani
float3 v_Angles; float f_Angle;
public: //chwilowo float3 v_RotateAxis;
float3 v_TransVector; float3 v_Angles;
float8 *Vertices; //roboczy wskaźnik - wczytanie T3D do VBO
int iAnimOwner; //roboczy numer egzemplarza, który ustawił animację public: // chwilowo
TAnimType b_aAnim; //kody animacji oddzielnie, bo zerowane float3 v_TransVector;
public: float8 *Vertices; // roboczy wskaźnik - wczytanie T3D do VBO
float4x4 *mAnimMatrix; //macierz do animacji kwaternionowych (należy do AnimContainer) int iAnimOwner; // roboczy numer egzemplarza, który ustawił animację
char space[8]; //wolne miejsce na przyszłe zmienne (zmniejszyć w miarę potrzeby) TAnimType b_aAnim; // kody animacji oddzielnie, bo zerowane
public: public:
TSubModel **smLetter; //wskaźnik na tablicę submdeli do generoania tekstu (docelowo zapisać do E3D) float4x4 *mAnimMatrix; // macierz do animacji kwaternionowych (należy do AnimContainer)
TSubModel *Parent; //nadrzędny, np. do wymnażania macierzy char space[8]; // wolne miejsce na przyszłe zmienne (zmniejszyć w miarę potrzeby)
int iVisible; //roboczy stan widoczności public:
//AnsiString asTexture; //robocza nazwa tekstury do zapisania w pliku binarnym TSubModel **
//AnsiString asName; //robocza nazwa smLetter; // wskaźnik na tablicę submdeli do generoania tekstu (docelowo zapisać do E3D)
char *pTexture; //robocza nazwa tekstury do zapisania w pliku binarnym TSubModel *Parent; // nadrzędny, np. do wymnażania macierzy
char *pName; //robocza nazwa int iVisible; // roboczy stan widoczności
private: // AnsiString asTexture; //robocza nazwa tekstury do zapisania w pliku binarnym
//int __fastcall SeekFaceNormal(DWORD *Masks, int f,DWORD dwMask,vector3 *pt,GLVERTEX *Vertices); // AnsiString asName; //robocza nazwa
int __fastcall SeekFaceNormal(DWORD *Masks,int f,DWORD dwMask,float3 *pt,float8 *Vertices); char *pTexture; // robocza nazwa tekstury do zapisania w pliku binarnym
void __fastcall RaAnimation(TAnimType a); char *pName; // robocza nazwa
public: private:
static int iInstance; //identyfikator egzemplarza, który aktualnie renderuje model // int __fastcall SeekFaceNormal(DWORD *Masks, int f,DWORD dwMask,vector3 *pt,GLVERTEX
static GLuint *ReplacableSkinId; // *Vertices);
static int iAlpha; //maska bitowa dla danego przebiegu int __fastcall SeekFaceNormal(DWORD *Masks, int f, DWORD dwMask, float3 *pt, float8 *Vertices);
static double fSquareDist; void __fastcall RaAnimation(TAnimType a);
static TModel3d* pRoot;
static AnsiString* pasText; //tekst dla wyświetlacza (!!!! do przemyślenia) public:
__fastcall TSubModel(); static int iInstance; // identyfikator egzemplarza, który aktualnie renderuje model
__fastcall ~TSubModel(); static GLuint *ReplacableSkinId;
void __fastcall FirstInit(); static int iAlpha; // maska bitowa dla danego przebiegu
int __fastcall Load(cParser& Parser, TModel3d *Model,int Pos,bool dynamic); static double fSquareDist;
void __fastcall ChildAdd(TSubModel *SubModel); static TModel3d *pRoot;
void __fastcall NextAdd(TSubModel *SubModel); static AnsiString *pasText; // tekst dla wyświetlacza (!!!! do przemyślenia)
TSubModel* __fastcall NextGet() {return Next;}; __fastcall TSubModel();
TSubModel* __fastcall ChildGet() {return Child;}; __fastcall ~TSubModel();
int __fastcall TriangleAdd(TModel3d *m,int tex,int tri); void __fastcall FirstInit();
float8* __fastcall TrianglePtr(int tex,int pos,int *la,int *ld,int*ls); int __fastcall Load(cParser &Parser, TModel3d *Model, int Pos, bool dynamic);
//float8* __fastcall TrianglePtr(const char *tex,int tri); void __fastcall ChildAdd(TSubModel *SubModel);
//void __fastcall SetRotate(vector3 vNewRotateAxis,float fNewAngle); void __fastcall NextAdd(TSubModel *SubModel);
void __fastcall SetRotate(float3 vNewRotateAxis,float fNewAngle); TSubModel *__fastcall NextGet() { return Next; };
void __fastcall SetRotateXYZ(vector3 vNewAngles); TSubModel *__fastcall ChildGet() { return Child; };
void __fastcall SetRotateXYZ(float3 vNewAngles); int __fastcall TriangleAdd(TModel3d *m, int tex, int tri);
void __fastcall SetTranslate(vector3 vNewTransVector); float8 *__fastcall TrianglePtr(int tex, int pos, int *la, int *ld, int *ls);
void __fastcall SetTranslate(float3 vNewTransVector); // float8* __fastcall TrianglePtr(const char *tex,int tri);
void __fastcall SetRotateIK1(float3 vNewAngles); // void __fastcall SetRotate(vector3 vNewRotateAxis,float fNewAngle);
TSubModel* __fastcall GetFromName(AnsiString search,bool i=true); void __fastcall SetRotate(float3 vNewRotateAxis, float fNewAngle);
TSubModel* __fastcall GetFromName(char *search,bool i=true); void __fastcall SetRotateXYZ(vector3 vNewAngles);
void __fastcall RenderDL(); void __fastcall SetRotateXYZ(float3 vNewAngles);
void __fastcall RenderAlphaDL(); void __fastcall SetTranslate(vector3 vNewTransVector);
void __fastcall RenderVBO(); void __fastcall SetTranslate(float3 vNewTransVector);
void __fastcall RenderAlphaVBO(); void __fastcall SetRotateIK1(float3 vNewAngles);
//inline matrix4x4* __fastcall GetMatrix() {return dMatrix;}; TSubModel *__fastcall GetFromName(AnsiString search, bool i = true);
inline float4x4* __fastcall GetMatrix() {return fMatrix;}; TSubModel *__fastcall GetFromName(char *search, bool i = true);
//matrix4x4* __fastcall GetTransform() {return Matrix;}; void __fastcall RenderDL();
inline void __fastcall Hide() {iVisible=0;}; void __fastcall RenderAlphaDL();
void __fastcall RaArrayFill(CVertNormTex *Vert); void __fastcall RenderVBO();
//void __fastcall Render(); void __fastcall RenderAlphaVBO();
int __fastcall FlagsCheck(); // inline matrix4x4* __fastcall GetMatrix() {return dMatrix;};
void __fastcall WillBeAnimated() {if (this) iFlags|=0x4000;}; inline float4x4 *__fastcall GetMatrix() { return fMatrix; };
void __fastcall InitialRotate(bool doit); // matrix4x4* __fastcall GetTransform() {return Matrix;};
void __fastcall DisplayLists(); inline void __fastcall Hide() { iVisible = 0; };
void __fastcall Info(); void __fastcall RaArrayFill(CVertNormTex *Vert);
void __fastcall InfoSet(TSubModelInfo *info); // void __fastcall Render();
void __fastcall BinInit(TSubModel *s,float4x4 *m,float8 *v,TStringPack *t,TStringPack *n=NULL,bool dynamic=false); int __fastcall FlagsCheck();
void __fastcall ReplacableSet(GLuint *r,int a) void __fastcall WillBeAnimated()
{ReplacableSkinId=r; iAlpha=a;}; {
void __fastcall TextureNameSet(const char *n); if (this)
void __fastcall NameSet(const char *n); iFlags |= 0x4000;
//Ra: funkcje do budowania terenu z E3D };
int __fastcall Flags() {return iFlags;}; void __fastcall InitialRotate(bool doit);
void __fastcall UnFlagNext() {iFlags&=0x00FFFFFF;}; void __fastcall DisplayLists();
void __fastcall ColorsSet(int *a,int *d,int*s); void __fastcall Info();
inline float3 Translation1Get() void __fastcall InfoSet(TSubModelInfo *info);
{return fMatrix?*(fMatrix->TranslationGet())+v_TransVector:v_TransVector;} void __fastcall BinInit(TSubModel *s, float4x4 *m, float8 *v, TStringPack *t,
inline float3 Translation2Get() TStringPack *n = NULL, bool dynamic = false);
{return *(fMatrix->TranslationGet())+Child->Translation1Get();} void __fastcall ReplacableSet(GLuint *r, int a)
void __fastcall ParentMatrix(float4x4 *m); {
float __fastcall MaxY(const float4x4 &m); ReplacableSkinId = r;
void __fastcall AdjustDist(); iAlpha = a;
};
void __fastcall TextureNameSet(const char *n);
void __fastcall NameSet(const char *n);
// Ra: funkcje do budowania terenu z E3D
int __fastcall Flags() { return iFlags; };
void __fastcall UnFlagNext() { iFlags &= 0x00FFFFFF; };
void __fastcall ColorsSet(int *a, int *d, int *s);
inline float3 Translation1Get()
{
return fMatrix ? *(fMatrix->TranslationGet()) + v_TransVector : v_TransVector;
}
inline float3 Translation2Get()
{
return *(fMatrix->TranslationGet()) + Child->Translation1Get();
}
void __fastcall ParentMatrix(float4x4 *m);
float __fastcall MaxY(const float4x4 &m);
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() }
{pTable=this; //ustawienie wskaźnika tabeli obiektów void __fastcall Reset()
iTotalTransforms=iTotalNames=iTotalTextures=iCurrent=0; //zerowanie liczników {
} pTable = this; // ustawienie wskaźnika tabeli obiektów
__fastcall ~TSubModelInfo() {}; iTotalTransforms = iTotalNames = iTotalTextures = iCurrent = 0; // zerowanie liczników
}
__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,
void __fastcall Init(); GLuint *ReplacableSkinId = NULL, int iAlpha = 0x30300030);
char* __fastcall NameGet() {return Root?Root->pName:NULL;}; // trzy kąty obrotu
int __fastcall TerrainCount(); void __fastcall Render(vector3 *vPosition, vector3 *vAngle, GLuint *ReplacableSkinId = NULL,
TSubModel* __fastcall TerrainSquare(int n); int iAlpha = 0x30300030);
void __fastcall TerrainRenderVBO(int n); 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();
char *__fastcall NameGet() { return Root ? Root->pName : NULL; };
int __fastcall TerrainCount();
TSubModel *__fastcall TerrainSquare(int n);
void __fastcall TerrainRenderVBO(int n);
}; };
//--------------------------------------------------------------------------- //---------------------------------------------------------------------------

1007
Mover.cpp
View File

File diff suppressed because it is too large Load Diff

310
Mover.h
View File

@@ -13,161 +13,167 @@
#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
double __fastcall CouplerDist(Byte Coupler); private:
public: double __fastcall CouplerDist(Byte Coupler);
__fastcall TMoverParameters(double VelInitial,AnsiString TypeNameInit,AnsiString NameInit,
int LoadInitial,AnsiString LoadTypeInitial,int Cab); public:
//obs³uga sprzêgów __fastcall TMoverParameters(double VelInitial, AnsiString TypeNameInit, AnsiString NameInit,
double __fastcall Distance(const TLocation &Loc1,const TLocation &Loc2,const TDimension &Dim1,const TDimension &Dim2); int LoadInitial, AnsiString LoadTypeInitial, int Cab);
double __fastcall Distance(const vector3 &Loc1,const vector3 &Loc2,const vector3 &Dim1,const vector3 &Dim2); // obs³uga sprzêgów
bool __fastcall Attach(Byte ConnectNo,Byte ConnectToNr,TMoverParameters *ConnectTo,Byte CouplingType,bool Forced=false); double __fastcall Distance(const TLocation &Loc1, const TLocation &Loc2, const TDimension &Dim1,
bool __fastcall Attach(Byte ConnectNo,Byte ConnectToNr,T_MoverParameters *ConnectTo,Byte CouplingType,bool Forced=false); const TDimension &Dim2);
int __fastcall DettachStatus(Byte ConnectNo); double __fastcall Distance(const vector3 &Loc1, const vector3 &Loc2, const vector3 &Dim1,
bool __fastcall Dettach(Byte ConnectNo); const vector3 &Dim2);
void __fastcall SetCoupleDist(); bool __fastcall Attach(Byte ConnectNo, Byte ConnectToNr, TMoverParameters *ConnectTo,
bool __fastcall DirectionForward(); Byte CouplingType, bool Forced = false);
void __fastcall BrakeLevelSet(double b); bool __fastcall Attach(Byte ConnectNo, Byte ConnectToNr, T_MoverParameters *ConnectTo,
bool __fastcall BrakeLevelAdd(double b); Byte CouplingType, bool Forced = false);
bool __fastcall IncBrakeLevel(); //wersja na u¿ytek AI int __fastcall DettachStatus(Byte ConnectNo);
bool __fastcall DecBrakeLevel(); bool __fastcall Dettach(Byte ConnectNo);
bool __fastcall ChangeCab(int direction); void __fastcall SetCoupleDist();
bool __fastcall CurrentSwitch(int direction); bool __fastcall DirectionForward();
void __fastcall UpdateBatteryVoltage(double dt); void __fastcall BrakeLevelSet(double b);
double __fastcall ComputeMovement bool __fastcall BrakeLevelAdd(double b);
(double dt,double dt1, bool __fastcall IncBrakeLevel(); // wersja na u¿ytek AI
const TTrackShape &Shape,TTrackParam &Track,TTractionParam &ElectricTraction, bool __fastcall DecBrakeLevel();
const TLocation &NewLoc,TRotation &NewRot bool __fastcall ChangeCab(int direction);
); bool __fastcall CurrentSwitch(int direction);
double __fastcall FastComputeMovement void __fastcall UpdateBatteryVoltage(double dt);
(double dt, double __fastcall ComputeMovement(double dt, double dt1, const TTrackShape &Shape,
const TTrackShape &Shape,TTrackParam &Track, TTrackParam &Track, TTractionParam &ElectricTraction,
const TLocation &NewLoc,TRotation &NewRot const TLocation &NewLoc, TRotation &NewRot);
); double __fastcall FastComputeMovement(double dt, const TTrackShape &Shape, TTrackParam &Track,
double __fastcall ShowEngineRotation(int VehN); const TLocation &NewLoc, TRotation &NewRot);
//double __fastcall GetTrainsetVoltage(void); double __fastcall ShowEngineRotation(int VehN);
//bool __fastcall Physic_ReActivation(void); // double __fastcall GetTrainsetVoltage(void);
//double __fastcall LocalBrakeRatio(void); // bool __fastcall Physic_ReActivation(void);
//double __fastcall ManualBrakeRatio(void); // double __fastcall LocalBrakeRatio(void);
//double __fastcall PipeRatio(void); // double __fastcall ManualBrakeRatio(void);
//double __fastcall RealPipeRatio(void); // double __fastcall PipeRatio(void);
//double __fastcall BrakeVP(void); // double __fastcall RealPipeRatio(void);
//bool __fastcall DynamicBrakeSwitch(bool Switch); // double __fastcall BrakeVP(void);
//bool __fastcall SendCtrlBroadcast(AnsiString CtrlCommand, double ctrlvalue); // bool __fastcall DynamicBrakeSwitch(bool Switch);
//bool __fastcall SendCtrlToNext(AnsiString CtrlCommand, double ctrlvalue, double dir); // bool __fastcall SendCtrlBroadcast(AnsiString CtrlCommand, double ctrlvalue);
//bool __fastcall CabActivisation(void); // bool __fastcall SendCtrlToNext(AnsiString CtrlCommand, double ctrlvalue, double dir);
//bool __fastcall CabDeactivisation(void); // bool __fastcall CabActivisation(void);
//bool __fastcall IncMainCtrl(int CtrlSpeed); // bool __fastcall CabDeactivisation(void);
//bool __fastcall DecMainCtrl(int CtrlSpeed); // bool __fastcall IncMainCtrl(int CtrlSpeed);
//bool __fastcall IncScndCtrl(int CtrlSpeed); // bool __fastcall DecMainCtrl(int CtrlSpeed);
//bool __fastcall DecScndCtrl(int CtrlSpeed); // bool __fastcall IncScndCtrl(int CtrlSpeed);
//bool __fastcall AddPulseForce(int Multipler); // bool __fastcall DecScndCtrl(int CtrlSpeed);
//bool __fastcall SandDoseOn(void); // bool __fastcall AddPulseForce(int Multipler);
//bool __fastcall SecuritySystemReset(void); // bool __fastcall SandDoseOn(void);
//void __fastcall SecuritySystemCheck(double dt); // bool __fastcall SecuritySystemReset(void);
//bool __fastcall BatterySwitch(bool State); // void __fastcall SecuritySystemCheck(double dt);
//bool __fastcall EpFuseSwitch(bool State); // bool __fastcall BatterySwitch(bool State);
//bool __fastcall IncBrakeLevelOld(void); // bool __fastcall EpFuseSwitch(bool State);
//bool __fastcall DecBrakeLevelOld(void); // bool __fastcall IncBrakeLevelOld(void);
//bool __fastcall IncLocalBrakeLevel(Byte CtrlSpeed); // bool __fastcall DecBrakeLevelOld(void);
//bool __fastcall DecLocalBrakeLevel(Byte CtrlSpeed); // bool __fastcall IncLocalBrakeLevel(Byte CtrlSpeed);
//bool __fastcall IncLocalBrakeLevelFAST(void); // bool __fastcall DecLocalBrakeLevel(Byte CtrlSpeed);
//bool __fastcall DecLocalBrakeLevelFAST(void); // bool __fastcall IncLocalBrakeLevelFAST(void);
//bool __fastcall IncManualBrakeLevel(Byte CtrlSpeed); // bool __fastcall DecLocalBrakeLevelFAST(void);
//bool __fastcall DecManualBrakeLevel(Byte CtrlSpeed); // bool __fastcall IncManualBrakeLevel(Byte CtrlSpeed);
//bool __fastcall EmergencyBrakeSwitch(bool Switch); // bool __fastcall DecManualBrakeLevel(Byte CtrlSpeed);
//bool __fastcall AntiSlippingBrake(void); // bool __fastcall EmergencyBrakeSwitch(bool Switch);
//bool __fastcall BrakeReleaser(Byte state); // bool __fastcall AntiSlippingBrake(void);
//bool __fastcall SwitchEPBrake(Byte state); // bool __fastcall BrakeReleaser(Byte state);
//bool __fastcall AntiSlippingButton(void); // bool __fastcall SwitchEPBrake(Byte state);
//bool __fastcall IncBrakePress(double &brake, double PressLimit, double dp); // bool __fastcall AntiSlippingButton(void);
//bool __fastcall DecBrakePress(double &brake, double PressLimit, double dp); // bool __fastcall IncBrakePress(double &brake, double PressLimit, double dp);
//bool __fastcall BrakeDelaySwitch(Byte BDS); // bool __fastcall DecBrakePress(double &brake, double PressLimit, double dp);
//bool __fastcall IncBrakeMult(void); // bool __fastcall BrakeDelaySwitch(Byte BDS);
//bool __fastcall DecBrakeMult(void); // bool __fastcall IncBrakeMult(void);
//void __fastcall UpdateBrakePressure(double dt); // bool __fastcall DecBrakeMult(void);
//void __fastcall UpdatePipePressure(double dt); // void __fastcall UpdateBrakePressure(double dt);
//void __fastcall CompressorCheck(double dt); // void __fastcall UpdatePipePressure(double dt);
void __fastcall UpdatePantVolume(double dt); // void __fastcall CompressorCheck(double dt);
//void __fastcall UpdateScndPipePressure(double dt); void __fastcall UpdatePantVolume(double dt);
//void __fastcall UpdateBatteryVoltage(double dt); // void __fastcall UpdateScndPipePressure(double dt);
//double __fastcall GetDVc(double dt); // void __fastcall UpdateBatteryVoltage(double dt);
//void __fastcall ComputeConstans(void); // double __fastcall GetDVc(double dt);
//double __fastcall ComputeMass(void); // void __fastcall ComputeConstans(void);
//double __fastcall Adhesive(double staticfriction); // double __fastcall ComputeMass(void);
//double __fastcall TractionForce(double dt); // double __fastcall Adhesive(double staticfriction);
//double __fastcall FrictionForce(double R, Byte TDamage); // double __fastcall TractionForce(double dt);
//double __fastcall BrakeForce(const TTrackParam &Track); // double __fastcall FrictionForce(double R, Byte TDamage);
//double __fastcall CouplerForce(Byte CouplerN, double dt); // double __fastcall BrakeForce(const TTrackParam &Track);
//void __fastcall CollisionDetect(Byte CouplerN, double dt); // double __fastcall CouplerForce(Byte CouplerN, double dt);
//double __fastcall ComputeRotatingWheel(double WForce, double dt, double n); // void __fastcall CollisionDetect(Byte CouplerN, double dt);
//bool __fastcall SetInternalCommand(AnsiString NewCommand, double NewValue1, double NewValue2); // double __fastcall ComputeRotatingWheel(double WForce, double dt, double n);
//double __fastcall GetExternalCommand(AnsiString &Command); // bool __fastcall SetInternalCommand(AnsiString NewCommand, double NewValue1, double
//bool __fastcall RunCommand(AnsiString command, double CValue1, double CValue2); // NewValue2);
//bool __fastcall RunInternalCommand(void); // double __fastcall GetExternalCommand(AnsiString &Command);
//void __fastcall PutCommand(AnsiString NewCommand, double NewValue1, double NewValue2, const TLocation // bool __fastcall RunCommand(AnsiString command, double CValue1, double CValue2);
// &NewLocation); // bool __fastcall RunInternalCommand(void);
//bool __fastcall DirectionBackward(void); // void __fastcall PutCommand(AnsiString NewCommand, double NewValue1, double NewValue2, const
//bool __fastcall MainSwitch(bool State); // TLocation
//bool __fastcall ConverterSwitch(bool State); // &NewLocation);
//bool __fastcall CompressorSwitch(bool State); // bool __fastcall DirectionBackward(void);
void __fastcall ConverterCheck(); // bool __fastcall MainSwitch(bool State);
//bool __fastcall FuseOn(void); // bool __fastcall ConverterSwitch(bool State);
//bool __fastcall FuseFlagCheck(void); // bool __fastcall CompressorSwitch(bool State);
//void __fastcall FuseOff(void); void __fastcall ConverterCheck();
int __fastcall ShowCurrent(Byte AmpN); // bool __fastcall FuseOn(void);
//double __fastcall v2n(void); // bool __fastcall FuseFlagCheck(void);
//double __fastcall current(double n, double U); // void __fastcall FuseOff(void);
//double __fastcall Momentum(double I); int __fastcall ShowCurrent(Byte AmpN);
//double __fastcall MomentumF(double I, double Iw, Byte SCP); // double __fastcall v2n(void);
//bool __fastcall CutOffEngine(void); // double __fastcall current(double n, double U);
//bool __fastcall MaxCurrentSwitch(bool State); // double __fastcall Momentum(double I);
//bool __fastcall ResistorsFlagCheck(void); // double __fastcall MomentumF(double I, double Iw, Byte SCP);
//bool __fastcall MinCurrentSwitch(bool State); // bool __fastcall CutOffEngine(void);
//bool __fastcall AutoRelaySwitch(bool State); // bool __fastcall MaxCurrentSwitch(bool State);
//bool __fastcall AutoRelayCheck(void); // bool __fastcall ResistorsFlagCheck(void);
//bool __fastcall dizel_EngageSwitch(double state); // bool __fastcall MinCurrentSwitch(bool State);
//bool __fastcall dizel_EngageChange(double dt); // bool __fastcall AutoRelaySwitch(bool State);
//bool __fastcall dizel_AutoGearCheck(void); // bool __fastcall AutoRelayCheck(void);
//double __fastcall dizel_fillcheck(Byte mcp); // bool __fastcall dizel_EngageSwitch(double state);
//double __fastcall dizel_Momentum(double dizel_fill, double n, double dt); // bool __fastcall dizel_EngageChange(double dt);
//bool __fastcall dizel_Update(double dt); // bool __fastcall dizel_AutoGearCheck(void);
//bool __fastcall LoadingDone(double LSpeed, AnsiString LoadInit); // double __fastcall dizel_fillcheck(Byte mcp);
//void __fastcall ComputeTotalForce(double dt, double dt1, bool FullVer); // double __fastcall dizel_Momentum(double dizel_fill, double n, double dt);
//double __fastcall ComputeMovement(double dt, double dt1, const TTrackShape &Shape, TTrackParam &Track // bool __fastcall dizel_Update(double dt);
// , TTractionParam &ElectricTraction, const TLocation &NewLoc, TRotation &NewRot); // bool __fastcall LoadingDone(double LSpeed, AnsiString LoadInit);
//double __fastcall FastComputeMovement(double dt, const TTrackShape &Shape, TTrackParam &Track, const // void __fastcall ComputeTotalForce(double dt, double dt1, bool FullVer);
// TLocation &NewLoc, TRotation &NewRot); // double __fastcall ComputeMovement(double dt, double dt1, const TTrackShape &Shape,
//bool __fastcall ChangeOffsetH(double DeltaOffset); // TTrackParam &Track
//__fastcall T_MoverParameters(double VelInitial, AnsiString TypeNameInit, AnsiString NameInit, int LoadInitial // , TTractionParam &ElectricTraction, const TLocation &NewLoc, TRotation &NewRot);
// , AnsiString LoadTypeInitial, int Cab); // double __fastcall FastComputeMovement(double dt, const TTrackShape &Shape, TTrackParam
//bool __fastcall LoadChkFile(AnsiString chkpath); // &Track, const
//bool __fastcall CheckLocomotiveParameters(bool ReadyFlag, int Dir); // TLocation &NewLoc, TRotation &NewRot);
//AnsiString __fastcall EngineDescription(int what); // bool __fastcall ChangeOffsetH(double DeltaOffset);
//bool __fastcall DoorLeft(bool State); //__fastcall T_MoverParameters(double VelInitial, AnsiString TypeNameInit, AnsiString NameInit,
//bool __fastcall DoorRight(bool State); //int LoadInitial
//bool __fastcall DoorBlockedFlag(void); // , AnsiString LoadTypeInitial, int Cab);
//bool __fastcall PantFront(bool State); // bool __fastcall LoadChkFile(AnsiString chkpath);
//bool __fastcall PantRear(bool State); // bool __fastcall CheckLocomotiveParameters(bool ReadyFlag, int Dir);
// // AnsiString __fastcall EngineDescription(int what);
// bool __fastcall DoorLeft(bool State);
// bool __fastcall DoorRight(bool State);
// bool __fastcall DoorBlockedFlag(void);
// bool __fastcall PantFront(bool State);
// bool __fastcall PantRear(bool State);
//
}; };
#endif #endif

231
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)
else TreeAdd(r, c + 1); // ustawić wg kolejnego znaku, chyba że zero
if ((unsigned char)(cName[c])<(unsigned char)(r->cName[c])) else if ((unsigned char)(cName[c]) < (unsigned char)(r->cName[c]))
{//zero jest najmniejsze - doczepiamy jako (rNext) { // zero jest najmniejsze - doczepiamy jako (rNext)
if (!rNext) rNext=r; if (!rNext)
else rNext->TreeAdd(r,0); //doczepić do tej gałęzi rNext = r;
} else
else rNext->TreeAdd(r, 0); // doczepić do tej gałęzi
{ }
if (!rPrev) rPrev=r; else
else rPrev->TreeAdd(r,0); //doczepić do tej gałęzi {
} if (!rPrev)
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 {
r=r->rPrev; //wcześniejsza gałąź drzewa i = 0; // porównywać od nowa
} r = r->rPrev; // wcześniejsza gałąź drzewa
else }
{ else
i=0; //porównywać od nowa {
r=r->rNext; //późniejsza gałąź drzewa i = 0; // porównywać od nowa
} r = r->rNext; // późniejsza gałąź drzewa
} while (r); }
return NULL; } while (r);
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ę
delete[] r; rTypes[t]->ListGet(rRecords, q); // drzewo jest już posortowane - zamienić je na listę
} rTypes[t] = TreeSet(r, 0, (q - r) - 1);
return; delete[] r;
}
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;
}; };

85
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
unsigned int uData; int iData; // albo numer obiektu (tekstury)
}; unsigned int uData;
//typedef };
void __fastcall ListGet(ItemRecord *r,int*&n); // typedef
void __fastcall TreeAdd(ItemRecord *r,int c); void __fastcall ListGet(ItemRecord *r, int *&n);
template <typename TOut> inline TOut* DataGet() {return (TOut*)pData;}; void __fastcall TreeAdd(ItemRecord *r, int c);
template <typename TOut> inline void DataSet(TOut *x) {pData=(void*)x;}; template <typename TOut> inline TOut *DataGet() { return (TOut *)pData; };
void* __fastcall TreeFind(const char *n); template <typename TOut> inline void DataSet(TOut *x) { pData = (void *)x; };
ItemRecord* __fastcall TreeFindRecord(const char *n); void *__fastcall TreeFind(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 __fastcall TreeSet(); void *d); // dodanie jeœli nie ma, wymiana (d), gdy jest
ItemRecord* __fastcall TreeSet(int *n,int d,int u); void __fastcall TreeSet();
void __fastcall Sort(int t); //przebudowa drzewa typu (t) ItemRecord *__fastcall TreeSet(int *n, int d, int u);
ItemRecord* __fastcall Item(int n); //rekord o numerze (n) void __fastcall Sort(int t); // przebudowa drzewa typu (t)
inline void* Find(const int t,const char *n) ItemRecord *__fastcall Item(int n); // rekord o numerze (n)
{return rTypes[t]?rTypes[t]->TreeFind(n):NULL;}; inline void *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 rTypes[t] ? rTypes[t]->TreeFind(n) : NULL;
//{return (TOut*)(rTypes[t]->TreeFind(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));};
}; };
#endif #endif

441
RealSound.cpp
View File

@@ -5,8 +5,8 @@
*/ */
#include "system.hpp" #include "system.hpp"
#include "classes.hpp" #include "classes.hpp"
#pragma hdrstop #pragma hdrstop
#include "math.h" #include "math.h"
@@ -18,260 +18,273 @@
__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) +
AM=1.0; ", as modulated, should have 22.05kHz in header");
pSound->SetVolume(DSBVOLUME_MIN); }
} AM = 1.0;
else pSound->SetVolume(DSBVOLUME_MIN);
{//nie ma dźwięku, to jest wysyp }
AM=0; else
ErrorLog("Missed sound: "+AnsiString(SoundName)); { // nie ma dźwięku, to jest wysyp
} AM = 0;
if (DistanceAttenuation>0.0) ErrorLog("Missed sound: " + AnsiString(SoundName));
{ }
dSoundAtt=DistanceAttenuation*DistanceAttenuation; if (DistanceAttenuation > 0.0)
vSoundPosition.x=X; {
vSoundPosition.y=Y; dSoundAtt = DistanceAttenuation * DistanceAttenuation;
vSoundPosition.z=Z; vSoundPosition.x = X;
if (rmin<0) iDoppler=1; //wyłączenie efektu Dopplera, np. dla dźwięku ptaków vSoundPosition.y = Y;
} vSoundPosition.z = Z;
else if (rmin < 0)
dSoundAtt=-1; iDoppler = 1; // wyłączenie efektu Dopplera, np. dla dźwięku ptaków
}
else
dSoundAtt = -1;
}; };
double __fastcall TRealSound::ListenerDistance(vector3 ListenerPosition) double __fastcall TRealSound::ListenerDistance(vector3 ListenerPosition)
{ {
if (dSoundAtt==-1) if (dSoundAtt == -1)
{ return 0.0; } {
else return 0.0;
{ return SquareMagnitude(ListenerPosition-vSoundPosition); } }
else
{
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)
long int vol; return;
double dS; long int vol;
// double Distance; double dS;
DWORD stat; // double Distance;
if ((Global::bSoundEnabled)&&(AM!=0)) DWORD stat;
{ if ((Global::bSoundEnabled) && (AM != 0))
if (Volume>1.0) {
Volume=1.0; if (Volume > 1.0)
fPreviousDistance=fDistance; Volume = 1.0;
fDistance=0.0; //?? fPreviousDistance = fDistance;
if (dSoundAtt>0.0) fDistance = 0.0; //??
{ if (dSoundAtt > 0.0)
vSoundPosition=NewPosition; {
dS=dSoundAtt; //*dSoundAtt; //bo odleglosc podawana w kwadracie vSoundPosition = NewPosition;
fDistance=ListenerDistance(Global::pCameraPosition); dS = dSoundAtt; //*dSoundAtt; //bo odleglosc podawana w kwadracie
if (ListenerInside) //osłabianie dźwięków z odległością fDistance = ListenerDistance(Global::pCameraPosition);
Volume=Volume*dS/(dS+fDistance); if (ListenerInside) // osłabianie dźwięków z odległością
else Volume = Volume * dS / (dS + fDistance);
Volume=Volume*dS/(dS+2*fDistance); //podwójne dla ListenerInside=false else
} Volume = Volume * dS / (dS + 2 * fDistance); // podwójne dla ListenerInside=false
if (iDoppler) // }
{//Ra 2014-07: efekt Dopplera nie zawsze jest wskazany if (iDoppler) //
//if (FreeFlyModeFlag) //gdy swobodne latanie - nie sprawdza się to { // Ra 2014-07: efekt Dopplera nie zawsze jest wskazany
fPreviousDistance=fDistance; //to efektu Dopplera nie będzie // if (FreeFlyModeFlag) //gdy swobodne latanie - nie sprawdza się to
} 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 }
bLoopPlay=true; //dźwięk wyłączony if (Looping) // dźwięk zapętlony można wyłączyć i zostanie włączony w miarę potrzeby
//McZapkie-010302 - babranie tylko z niezbyt odleglymi dźwiękami bLoopPlay = true; // dźwięk wyłączony
if ((dSoundAtt==-1)||(fDistance<20.0*dS)) // McZapkie-010302 - babranie tylko z niezbyt odleglymi dźwiękami
{ if ((dSoundAtt == -1) || (fDistance < 20.0 * dS))
// vol=2*Volume+1; {
// if (vol<1) vol=1; // vol=2*Volume+1;
// vol=10000*(log(vol)-1); // if (vol<1) vol=1;
// vol=10000*(vol-1); // vol=10000*(log(vol)-1);
//int glos=1; // vol=10000*(vol-1);
//Volume=Volume*glos; //Ra: whatta hella is this // int glos=1;
if (Volume<0.0) Volume=0.0; // Volume=Volume*glos; //Ra: whatta hella is this
vol=-5000.0+5000.0*Volume; if (Volume < 0.0)
if (vol>=0) Volume = 0.0;
vol=-1; vol = -5000.0 + 5000.0 * Volume;
if (Timer::GetSoundTimer()||!Looping) //Ra: po co to jest? if (vol >= 0)
pSound->SetVolume(vol); //Attenuation, in hundredths of a decibel (dB). vol = -1;
pSound->GetStatus(&stat); if (Timer::GetSoundTimer() || !Looping) // Ra: po co to jest?
if (!(stat&DSBSTATUS_PLAYING)) pSound->SetVolume(vol); // Attenuation, in hundredths of a decibel (dB).
pSound->Play(0,0,Looping); pSound->GetStatus(&stat);
} if (!(stat & DSBSTATUS_PLAYING))
else //wylacz dzwiek bo daleko pSound->Play(0, 0, Looping);
{//Ra 2014-09: oddalanie się nie może być powodem do wyłączenie dźwięku }
/* else // wylacz dzwiek bo daleko
// Ra: stara wersja, ale podobno lepsza { // Ra 2014-09: oddalanie się nie może być powodem do wyłączenie dźwięku
pSound->GetStatus(&stat); /*
if (bLoopPlay) //jeśli zapętlony, to zostanie ponownie włączony, o ile znajdzie się bliżej // Ra: stara wersja, ale podobno lepsza
if (stat&DSBSTATUS_PLAYING) pSound->GetStatus(&stat);
pSound->Stop(); if (bLoopPlay) //jeśli zapętlony, to zostanie ponownie włączony, o ile znajdzie się
// Ra: wyłączyłem, bo podobno jest gorzej niż wcześniej bliżej
//ZiomalCl: dźwięk po wyłączeniu sam się nie włączy, gdy wrócimy w rejon odtwarzania if (stat&DSBSTATUS_PLAYING)
pSound->SetVolume(DSBVOLUME_MIN); //dlatego lepiej go wyciszyć na czas oddalenia się pSound->Stop();
pSound->GetStatus(&stat); // Ra: wyłączyłem, bo podobno jest gorzej niż wcześniej
if (!(stat&DSBSTATUS_PLAYING)) //ZiomalCl: dźwięk po wyłączeniu sam się nie włączy, gdy wrócimy w rejon odtwarzania
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->SetVolume(DSBVOLUME_MIN); //dlatego lepiej go wyciszyć na czas oddalenia się
*/ pSound->GetStatus(&stat);
} 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
*/
}
}
}; };
void __fastcall TRealSound::Start() void __fastcall TRealSound::Start(){// włączenie dźwięku
{//włączenie dźwięku
}; };
void __fastcall TRealSound::Stop() 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)
//efekt Dopplera
{ {
Vlist=(sqrt(fPreviousDistance)-sqrt(fDistance))/dt; if (dt > 0)
df= Freq*(1+Vlist/299.8); // efekt Dopplera
{
Vlist = (sqrt(fPreviousDistance) - sqrt(fDistance)) / dt;
df = Freq * (1 + Vlist / 299.8);
}
else
df = Freq;
if (Timer::GetSoundTimer())
{
df = fFrequency * df; // TODO - brac czestotliwosc probkowania z wav
pSound->SetFrequency((df < DSBFREQUENCY_MIN ?
DSBFREQUENCY_MIN :
(df > DSBFREQUENCY_MAX ? DSBFREQUENCY_MAX : df)));
}
} }
else
df=Freq;
if (Timer::GetSoundTimer())
{
df=fFrequency*df; //TODO - brac czestotliwosc probkowania z wav
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)
double WaveTime; return 0.0;
DSBCAPS caps; double WaveTime;
caps.dwSize=sizeof(caps); DSBCAPS caps;
pSound->GetCaps(&caps); caps.dwSize = sizeof(caps);
WaveTime=caps.dwBufferBytes; pSound->GetCaps(&caps);
return WaveTime/fFrequency; //(pSound->); // wielkosc w bajtach przez czestotliwosc probkowania WaveTime = caps.dwBufferBytes;
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;
} }
else else
return 0; return 0;
} }
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] == '/')
if (!FileExists(txt)) txt[i] = '\\'; // bo nie rozumi
txt="sounds\\"+txt; //ścieżka może nie być podana txt += "-" + Global::asLang + ".txt"; // już może być w różnych językach
if (FileExists(txt)) if (!FileExists(txt))
{//wczytanie txt = "sounds\\" + txt; //ścieżka może nie być podana
TFileStream *ts=new TFileStream(txt,fmOpenRead); if (FileExists(txt))
asText=AnsiString::StringOfChar(' ',ts->Size); { // wczytanie
ts->Read(asText.c_str(),ts->Size); TFileStream *ts = new TFileStream(txt, fmOpenRead);
delete ts; asText = AnsiString::StringOfChar(' ', ts->Size);
} ts->Read(asText.c_str(), ts->Size);
}; delete ts;
void __fastcall TTextSound::Play(double Volume,int Looping,bool ListenerInside,vector3 NewPosition)
{
if (!asText.IsEmpty())
{//jeśli ma powiązany tekst
DWORD stat;
pSound->GetStatus(&stat);
if (!(stat&DSBSTATUS_PLAYING)) //jeśli nie jest aktualnie odgrywany
{
int i;
AnsiString t=asText;
do
{//na razie zrobione jakkolwiek, docelowo przenieść teksty do tablicy nazw
i=t.Pos("\r"); //znak nowej linii
if (!i)
Global::tranTexts.Add(t.c_str(),fTime,true);
else
{
Global::tranTexts.Add(t.SubString(1,i-1).c_str(),fTime,true);
t.Delete(1,i);
while (t.IsEmpty()?false:(unsigned char)(t[1])<33)
t.Delete(1,1);
} }
} while (i>0); };
} void __fastcall TTextSound::Play(double Volume, int Looping, bool ListenerInside,
} vector3 NewPosition)
TRealSound::Play(Volume,Looping,ListenerInside,NewPosition); {
if (!asText.IsEmpty())
{ // jeśli ma powiązany tekst
DWORD stat;
pSound->GetStatus(&stat);
if (!(stat & DSBSTATUS_PLAYING)) // jeśli nie jest aktualnie odgrywany
{
int i;
AnsiString t = asText;
do
{ // na razie zrobione jakkolwiek, docelowo przenieść teksty do tablicy nazw
i = t.Pos("\r"); // znak nowej linii
if (!i)
Global::tranTexts.Add(t.c_str(), fTime, true);
else
{
Global::tranTexts.Add(t.SubString(1, i - 1).c_str(), fTime, true);
t.Delete(1, i);
while (t.IsEmpty() ? false : (unsigned char)(t[1]) < 33)
t.Delete(1, 1);
}
} while (i > 0);
}
}
TRealSound::Play(Volume, Looping, ListenerInside, NewPosition);
}; };
//--------------------------------------------------------------------------- //---------------------------------------------------------------------------
#pragma package(smart_init) #pragma package(smart_init)

96
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,
double __fastcall ListenerDistance(vector3 ListenerPosition); bool Dynamic, bool freqmod = false, double rmin = 0.0);
void __fastcall Play(double Volume,int Looping,bool ListenerInside,vector3 NewPosition); double __fastcall ListenerDistance(vector3 ListenerPosition);
void __fastcall Start(); void __fastcall Play(double Volume, int Looping, bool ListenerInside, vector3 NewPosition);
void __fastcall Stop(); void __fastcall Start();
void __fastcall AdjFreq(double Freq,double dt); void __fastcall Stop();
void __fastcall SetPan(int Pan); void __fastcall AdjFreq(double Freq, double dt);
double GetWaveTime(); //McZapkie TODO: dorobic dla roznych bps void __fastcall SetPan(int Pan);
int GetStatus(); double GetWaveTime(); // McZapkie TODO: dorobic dla roznych bps
void __fastcall ResetPosition(); int GetStatus();
//void __fastcall FreqReset(float f=22050.0) {fFrequency=f;}; void __fastcall ResetPosition();
// 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;
}; };

20
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

1618
Segment.cpp
View File

File diff suppressed because it is too large Load Diff

195
Segment.h
View File

@@ -1,7 +1,7 @@
//--------------------------------------------------------------------------- //---------------------------------------------------------------------------
#ifndef SegmentH #ifndef SegmentH
#define SegmentH #define SegmentH
#include "VBO.h" #include "VBO.h"
#include "dumb3d.h" #include "dumb3d.h"
@@ -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;
//{x=a; y=b; z=c; n.x=d; n.y=e; n.z=f;}; n.y = 1.0;
{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) __fastcall vector6(double a, double b, double c, double d, double e, double f)
{x=a; y=b; z=c; n.x=0.0; n.y=1.0; n.z=0.0;}; //{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;
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
__fastcall TSegment(TTrack *owner); // (0-Bezier,1-prosty,2/3-³uk w lewo/prawo,6/7-przejœciowa w lewo/prawo)
__fastcall ~TSegment(); __fastcall TSegment(TTrack *owner);
bool __fastcall Init(vector3 NewPoint1,vector3 NewPoint2,double fNewStep, __fastcall ~TSegment();
double fNewRoll1=0,double fNewRoll2=0); bool __fastcall Init(vector3 NewPoint1, vector3 NewPoint2, double fNewStep,
bool __fastcall Init(vector3 &NewPoint1,vector3 NewCPointOut, double fNewRoll1 = 0, double fNewRoll2 = 0);
vector3 NewCPointIn,vector3 &NewPoint2,double fNewStep, bool __fastcall Init(vector3 &NewPoint1, vector3 NewCPointOut, vector3 NewCPointIn,
double fNewRoll1=0,double fNewRoll2=0,bool bIsCurve=true); vector3 &NewPoint2, double fNewStep, double fNewRoll1 = 0,
inline double __fastcall ComputeLength(); //McZapkie-150503 double fNewRoll2 = 0, bool bIsCurve = true);
inline vector3 __fastcall GetDirection1() {return bCurve?CPointOut-Point1:CPointOut;}; inline double __fastcall ComputeLength(); // McZapkie-150503
inline vector3 __fastcall GetDirection2() {return bCurve?CPointIn-Point2:CPointIn;}; inline vector3 __fastcall GetDirection1() { return bCurve ? CPointOut - Point1 : CPointOut; };
vector3 __fastcall GetDirection(double fDistance); inline vector3 __fastcall GetDirection2() { return bCurve ? CPointIn - Point2 : CPointIn; };
vector3 __fastcall GetDirection() {return CPointOut;}; vector3 __fastcall GetDirection(double fDistance);
vector3 __fastcall FastGetDirection(double fDistance,double fOffset); vector3 __fastcall GetDirection() { return CPointOut; };
vector3 __fastcall GetPoint(double fDistance); vector3 __fastcall FastGetDirection(double fDistance, double fOffset);
void __fastcall RaPositionGet(double fDistance,vector3 &p,vector3 &a); vector3 __fastcall GetPoint(double fDistance);
vector3 __fastcall FastGetPoint(double t); void __fastcall RaPositionGet(double fDistance, vector3 &p, vector3 &a);
inline vector3 __fastcall FastGetPoint_0() {return Point1;}; vector3 __fastcall FastGetPoint(double t);
inline vector3 __fastcall FastGetPoint_1() {return Point2;}; inline vector3 __fastcall FastGetPoint_0() { return Point1; };
inline double __fastcall GetRoll(double s) inline vector3 __fastcall FastGetPoint_1() { return Point2; };
{ inline double __fastcall GetRoll(double s)
s/=fLength; {
return ((1.0-s)*fRoll1+s*fRoll2); s /= fLength;
} return ((1.0 - s) * fRoll1 + s * fRoll2);
void __fastcall GetRolls(double &r1,double &r2) }
{//pobranie przechy³ek (do generowania trójk¹tów) void __fastcall GetRolls(double &r1, double &r2)
r1=fRoll1; r2=fRoll2; { // pobranie przechy³ek (do generowania trójk¹tów)
} r1 = fRoll1;
void __fastcall RenderLoft(const vector6 *ShapePoints,int iNumShapePoints, r2 = fRoll2;
double fTextureLength,int iSkip=0,int iQualityFactor=1,vector3 **p=NULL,bool bRender=true); }
void __fastcall RenderSwitchRail(const vector6 *ShapePoints1,const vector6 *ShapePoints2, void __fastcall RenderLoft(const vector6 *ShapePoints, int iNumShapePoints,
int iNumShapePoints,double fTextureLength,int iSkip=0,double fOffsetX=0.0f); double fTextureLength, int iSkip = 0, int iQualityFactor = 1,
void __fastcall Render(); vector3 **p = NULL, bool bRender = true);
inline double __fastcall GetLength() {return fLength;}; void __fastcall RenderSwitchRail(const vector6 *ShapePoints1, const vector6 *ShapePoints2,
void __fastcall MoveMe(vector3 pPosition) int iNumShapePoints, double fTextureLength, int iSkip = 0,
{Point1+=pPosition; double fOffsetX = 0.0f);
Point2+=pPosition; void __fastcall Render();
if (bCurve) inline double __fastcall GetLength() { return fLength; };
{CPointIn+=pPosition; void __fastcall MoveMe(vector3 pPosition)
CPointOut+=pPosition; {
} Point1 += pPosition;
} Point2 += pPosition;
int __fastcall RaSegCount() {return fTsBuffer?iSegCount:1;}; if (bCurve)
void __fastcall RaRenderLoft(CVertNormTex* &Vert,const vector6 *ShapePoints,int iNumShapePoints, {
double fTextureLength,int iSkip=0,int iEnd=0,double fOffsetX=0.0); CPointIn += pPosition;
void __fastcall RaAnimate(CVertNormTex* &Vert,const vector6 *ShapePoints,int iNumShapePoints, CPointOut += pPosition;
double fTextureLength,int iSkip=0,int iEnd=0,double fOffsetX=0.0); }
void __fastcall AngleSet(int i,double a) {fAngle[i]=a;}; }
void __fastcall Rollment(double w1,double w2); //poprawianie przechy³ki int __fastcall RaSegCount() { return fTsBuffer ? iSegCount : 1; };
void __fastcall RaRenderLoft(CVertNormTex *&Vert, const vector6 *ShapePoints,
int iNumShapePoints, double fTextureLength, int iSkip = 0,
int iEnd = 0, double fOffsetX = 0.0);
void __fastcall RaAnimate(CVertNormTex *&Vert, const vector6 *ShapePoints, int iNumShapePoints,
double fTextureLength, int iSkip = 0, int iEnd = 0,
double fOffsetX = 0.0);
void __fastcall AngleSet(int i, double a) { fAngle[i] = a; };
void __fastcall Rollment(double w1, double w2); // poprawianie przechy³ki
}; };
//--------------------------------------------------------------------------- //---------------------------------------------------------------------------

441
Sound.cpp
View File

@@ -1,7 +1,7 @@
//--------------------------------------------------------------------------- //---------------------------------------------------------------------------
#include "system.hpp" #include "system.hpp"
#include "classes.hpp" #include "classes.hpp"
#pragma hdrstop #pragma hdrstop
#define STRICT #define STRICT
@@ -9,114 +9,115 @@
#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
DWORD dwBufferBytes; DWORD dwBufferBytes;
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;
// The size of wave data is in pWaveFileSound->m_ckIn // The size of wave data is in pWaveFileSound->m_ckIn
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,154 +127,149 @@ __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]))))
{ {
Concurrent= i; if( FAILED( hr= pDS->DuplicateSoundBuffer(pDSBuffer[0],&(pDSBuffer[i]))))
break; {
}; Concurrent= i;
break;
};
};*/ };*/
}; };
__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;
LPDIRECTSOUNDBUFFER buff; // jeœli siê dobrze zainicjowa³o
pDS->DuplicateSoundBuffer(DSBuffer,&buff); LPDIRECTSOUNDBUFFER buff;
if (buff) DSBuffers.push(buff); pDS->DuplicateSoundBuffer(DSBuffer, &buff);
return DSBuffers.top(); if (buff)
DSBuffers.push(buff);
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)
AnsiString file; { // wyszukanie dŸwiêku w pamiêci albo wczytanie z pliku
if (Dynamic) AnsiString file;
{//próba wczytania z katalogu pojazdu if (Dynamic)
file=Global::asCurrentDynamicPath+AnsiString(Name); { // próba wczytania z katalogu pojazdu
if (FileExists(file)) file = Global::asCurrentDynamicPath + AnsiString(Name);
Name=file.c_str(); //nowa nazwa if (FileExists(file))
else Name = file.c_str(); // nowa nazwa
Dynamic=false; //wczytanie z "sounds/" else
} Dynamic = false; // wczytanie z "sounds/"
TSoundContainer *Next=First; }
DWORD dwStatus; TSoundContainer *Next = First;
for (int i=0;i<Count;i++) DWORD dwStatus;
{ for (int i = 0; i < Count; i++)
if (strcmp(Name,Next->Name)==0) {
{ if (strcmp(Name, Next->Name) == 0)
if (fSamplingRate) {
*fSamplingRate=Next->fSamplingRate; //czêstotliwoœæ if (fSamplingRate)
return (Next->GetUnique(pDS)); *fSamplingRate = Next->fSamplingRate; // czêstotliwoœæ
// DSBuffers. return (Next->GetUnique(pDS));
/* // DSBuffers.
Next->pDSBuffer[Next->Oldest]->Stop(); /*
Next->pDSBuffer[Next->Oldest]->SetCurrentPosition(0); Next->pDSBuffer[Next->Oldest]->Stop();
if (Next->Oldest<Next->Concurrent-1) Next->pDSBuffer[Next->Oldest]->SetCurrentPosition(0);
{ if (Next->Oldest<Next->Concurrent-1)
Next->Oldest++; {
return (Next->pDSBuffer[Next->Oldest-1]); Next->Oldest++;
} return (Next->pDSBuffer[Next->Oldest-1]);
else }
{ else
Next->Oldest= 0; {
return (Next->pDSBuffer[Next->Concurrent-1]); Next->Oldest= 0;
}; 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);
if ((dwStatus & DSBSTATUS_PLAYING) != DSBSTATUS_PLAYING) if ((dwStatus & DSBSTATUS_PLAYING) != DSBSTATUS_PLAYING)
return (Next->pDSBuffer[j]); return (Next->pDSBuffer[j]);
} */ } */
} }
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)))
;
// return hr;
if( FAILED( hr = Next->DSBuffer->GetStatus( &dwStatus ) ) ); if (dwStatus & DSBSTATUS_BUFFERLOST)
// return hr;
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,96 +278,91 @@ 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;
wfx.wBitsPerSample = 16; wfx.wBitsPerSample = 16;
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)

64
Sound.h
View File

@@ -14,47 +14,49 @@
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,
__fastcall ~TSoundContainer(); int NConcurrent);
__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); // static void __fastcall Init(HWND hWnd, char *NDirectory);
__fastcall ~TSoundsManager(); static void __fastcall Init(HWND hWnd);
static void __fastcall Free(); __fastcall ~TSoundsManager();
static void __fastcall Init(char *Name, int Concurrent); static void __fastcall Free();
static void __fastcall LoadSounds(char *Directory); static void __fastcall Init(char *Name, int Concurrent);
static LPDIRECTSOUNDBUFFER __fastcall GetFromName(char *Name,bool Dynamic,float *fSamplingRate=NULL); static void __fastcall LoadSounds(char *Directory);
static void __fastcall RestoreAll(); static LPDIRECTSOUNDBUFFER __fastcall GetFromName(char *Name, bool Dynamic,
float *fSamplingRate = NULL);
static void __fastcall RestoreAll();
}; };
//--------------------------------------------------------------------------- //---------------------------------------------------------------------------

630
Spline.cpp
View File

@@ -1,7 +1,7 @@
//--------------------------------------------------------------------------- //---------------------------------------------------------------------------
#include "system.hpp" #include "system.hpp"
#include "classes.hpp" #include "classes.hpp"
#pragma hdrstop #pragma hdrstop
#include "Geometry.h" #include "Geometry.h"
@@ -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++)
while (true)
{
it++;
if (it>10)
MessageBox(0,"Too many iterations","TSpline->GetTFromS",MB_OK);
float fDifference = RombergIntegral(0,fTime) - s;
if ( ( fDifference>0 ? fDifference : -fDifference) < fTolerance )
return fTime;
fTime -= fDifference/GetFirstDerivative(fTime).Length();
}
// Newton's method failed. If this happens, increase iterations or
// tolerance or integration accuracy.
return -1;
// for (int i = 0; i < iIterations; i++)
while (true)
{
it++;
if (it > 10)
MessageBox(0, "Too many iterations", "TSpline->GetTFromS", MB_OK);
float fDifference = RombergIntegral(0, fTime) - s;
if ((fDifference > 0 ? fDifference : -fDifference) < fTolerance)
return fTime;
fTime -= fDifference / GetFirstDerivative(fTime).Length();
}
// Newton's method failed. If this happens, increase iterations or
// tolerance or integration accuracy.
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) +
else Normalize(Point - Prev->Point)));
CPointIn= Point-fLengthIn*Normalize(Point-Prev->Point); }
else else
CPointIn= Prev->Point; CPointIn = Point - fLengthIn * Normalize(Point - Prev->Point);
else
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) +
else; Normalize(Point - Next->Point)));
// CPointOut= -fLengthOut*Normalize(Next->Point-Point); }
else else
CPointOut= Next->Point; ;
else // CPointOut= -fLengthOut*Normalize(Next->Point-Point);
CPointOut= Point-fLengthOut*Normalize(Prev->Point-Point); else
CPointOut = Next->Point;
else
CPointOut = Point - fLengthOut * Normalize(Prev->Point - Point);
} }
bool __fastcall TKnot::InitLength() bool __fastcall TKnot::InitLength()
@@ -169,350 +170,341 @@ 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) else if (Next)
Length= (Point-Next->Point).Length(); Length = (Point - Next->Point).Length();
return true; return true;
} }
vector3 TKnot::GetFirstDerivative(float fTime) 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;
} }
float TKnot::RombergIntegral(float fA, float fB) 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()));
for (int i0 = 2, iP0 = 1; i0 <= ms_iOrder; i0++, iP0 *= 2, fH *= 0.5)
{
// approximations via the trapezoid rule
float fSum = 0.0;
int i1;
for (i1 = 1; i1 <= iP0; i1++)
fSum += (GetFirstDerivative(fA + fH*(i1-0.5)).Length());
// Richardson extrapolation
ms_apfRom[1][0] = 0.5*(ms_apfRom[0][0] + fH*fSum);
for (int i2 = 1, iP2 = 4; i2 < i0; i2++, iP2 *= 4)
{
ms_apfRom[1][i2] =
(iP2*ms_apfRom[1][i2-1] - ms_apfRom[0][i2-1])/(iP2-1);
}
for (i1 = 0; i1 < i0; i1++)
ms_apfRom[0][i1] = ms_apfRom[1][i1];
}
return ms_apfRom[0][ms_iOrder-1];
}
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)
{
// approximations via the trapezoid rule
float fSum = 0.0;
int i1;
for (i1 = 1; i1 <= iP0; i1++)
fSum += (GetFirstDerivative(fA + fH * (i1 - 0.5)).Length());
// Richardson extrapolation
ms_apfRom[1][0] = 0.5 * (ms_apfRom[0][0] + fH * fSum);
for (int i2 = 1, iP2 = 4; i2 < i0; i2++, iP2 *= 4)
{
ms_apfRom[1][i2] = (iP2 * ms_apfRom[1][i2 - 1] - ms_apfRom[0][i2 - 1]) / (iP2 - 1);
}
for (i1 = 0; i1 < i0; i1++)
ms_apfRom[0][i1] = ms_apfRom[1][i1];
}
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;
Knots[0].Prev= NULL; Knots[0].Prev= NULL;
Knots[iNumKnots-1].Next= NULL; Knots[iNumKnots-1].Next= NULL;
for (int i=1; i<iNumKnots; i++) for (int i=1; i<iNumKnots; i++)
Knots[i].Init(NULL,Knots+i-1); Knots[i].Init(NULL,Knots+i-1);
*/ */
} }
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;
AnsiString buf; AnsiString buf;
buf.SetLength(255); buf.SetLength(255);
TMapTextfile *tf= new TMapTextfile(); TMapTextfile *tf= new TMapTextfile();
tf->Open(asSceneryPatch+FileName,mmRead); tf->Open(asSceneryPatch+FileName,mmRead);
tf->ReadLn(buf);
if (buf==AnsiString("\"SPLINE\""))
{
tf->ReadLn(buf); tf->ReadLn(buf);
if (FirstKnot==NULL)
Create(buf.ToInt());
else
AssignKnots(FirstKnot,buf.ToInt());
TKnot *CurrentKnot= Knots;
// iNumKnots= buf.ToInt();
// Knots= new TKnot[iNumKnots];// malloc(*sizeof(TKnot));
DecimalSeparator= '.'; if (buf==AnsiString("\"SPLINE\""))
for (i=0; i<iNumKnots; i++)
{ {
tf->ReadLn(buf);
tf->ReadLn(buf); CurrentKnot->Point.x= buf.ToDouble(); if (FirstKnot==NULL)
tf->ReadLn(buf); CurrentKnot->Point.z= buf.ToDouble(); Create(buf.ToInt());
tf->ReadLn(buf); CurrentKnot->Point.y= buf.ToDouble();
tf->ReadLn(buf); CurrentKnot->CPointIn.x= buf.ToDouble();
tf->ReadLn(buf); CurrentKnot->CPointIn.z= buf.ToDouble();
tf->ReadLn(buf); CurrentKnot->CPointIn.y= buf.ToDouble();
tf->ReadLn(buf); CurrentKnot->CPointOut.x= buf.ToDouble();
tf->ReadLn(buf); CurrentKnot->CPointOut.z= buf.ToDouble();
tf->ReadLn(buf); CurrentKnot->CPointOut.y= buf.ToDouble();
tf->ReadLn(buf);
// buf.Trim();
Knots[i].IsCurve= (buf!="#line ");
CurrentKnot= CurrentKnot->Next;
}
DecimalSeparator= ',';
CurrentKnot= Knots;
for (i=0; i<iNumKnots-1; i++)
{
// Knots[i].InitLength();
if (CurrentKnot->IsCurve)
{
CurrentKnot->Length= CurveLength(CurrentKnot->Point,CurrentKnot->CPointOut,CurrentKnot->Next->CPointIn,CurrentKnot->Next->Point);
}
else else
AssignKnots(FirstKnot,buf.ToInt());
TKnot *CurrentKnot= Knots;
// iNumKnots= buf.ToInt();
// Knots= new TKnot[iNumKnots];// malloc(*sizeof(TKnot));
DecimalSeparator= '.';
for (i=0; i<iNumKnots; i++)
{ {
CurrentKnot->CPointOut= 2*CurrentKnot->Point-CurrentKnot->CPointIn;
CurrentKnot->Next->CPointIn= CurrentKnot->Point; tf->ReadLn(buf); CurrentKnot->Point.x= buf.ToDouble();
CurrentKnot->Length= (CurrentKnot->Point-CurrentKnot->Next->Point).Length(); tf->ReadLn(buf); CurrentKnot->Point.z= buf.ToDouble();
tf->ReadLn(buf); CurrentKnot->Point.y= buf.ToDouble();
tf->ReadLn(buf); CurrentKnot->CPointIn.x= buf.ToDouble();
tf->ReadLn(buf); CurrentKnot->CPointIn.z= buf.ToDouble();
tf->ReadLn(buf); CurrentKnot->CPointIn.y= buf.ToDouble();
tf->ReadLn(buf); CurrentKnot->CPointOut.x= buf.ToDouble();
tf->ReadLn(buf); CurrentKnot->CPointOut.z= buf.ToDouble();
tf->ReadLn(buf); CurrentKnot->CPointOut.y= buf.ToDouble();
tf->ReadLn(buf);
// buf.Trim();
Knots[i].IsCurve= (buf!="#line ");
CurrentKnot= CurrentKnot->Next;
} }
CurrentKnot= CurrentKnot->Next; DecimalSeparator= ',';
CurrentKnot= Knots;
for (i=0; i<iNumKnots-1; i++)
{
// Knots[i].InitLength();
if (CurrentKnot->IsCurve)
{
CurrentKnot->Length=
CurveLength(CurrentKnot->Point,CurrentKnot->CPointOut,CurrentKnot->Next->CPointIn,CurrentKnot->Next->Point);
}
else
{
CurrentKnot->CPointOut= 2*CurrentKnot->Point-CurrentKnot->CPointIn;
CurrentKnot->Next->CPointIn= CurrentKnot->Point;
CurrentKnot->Length= (CurrentKnot->Point-CurrentKnot->Next->Point).Length();
}
CurrentKnot= CurrentKnot->Next;
}
CurrentKnot->Length= -1;
} }
CurrentKnot->Length= -1;
}
tf->Close(); tf->Close();
delete tf; delete tf;
return (iNumKnots); return (iNumKnots);
*/ */
} }
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);
glBegin(GL_LINE_STRIP); glBegin(GL_LINE_STRIP);
glVertex3f(RootKnot->Point.x,RootKnot->Point.y,RootKnot->Point.z); glVertex3f(RootKnot->Point.x,RootKnot->Point.y,RootKnot->Point.z);
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);

81
Spring.cpp
View File

@@ -1,7 +1,7 @@
//--------------------------------------------------------------------------- //---------------------------------------------------------------------------
#include "system.hpp" #include "system.hpp"
#include "classes.hpp" #include "classes.hpp"
#include "opengl/glew.h" #include "opengl/glew.h"
#include "opengl/glut.h" #include "opengl/glut.h"
#pragma hdrstop #pragma hdrstop
@@ -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
dist = deltaP.Length(); //deltaP
if (dist==0) dist = deltaP.Length();
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;
}
void __fastcall TSpring::Render()
{
return true;
} }
void __fastcall TSpring::Render() {}
//--------------------------------------------------------------------------- //---------------------------------------------------------------------------

35
Spring.h
View File

@@ -3,36 +3,35 @@
#ifndef ParticlesH #ifndef ParticlesH
#define ParticlesH #define ParticlesH
#define STATIC_THRESHOLD 0.17f
// efine STATIC_THRESHOLD 0.03f
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_Ksh = 5.0f; // HOOK'S SPRING CONSTANT
const double m_Ksd = 0.1f; // SPRING DAMPING CONSTANT
#define STATIC_THRESHOLD 0.17f const double m_Csf = 0.9f; // Default Static Friction
//efine STATIC_THRESHOLD 0.03f const double m_Ckf = 0.7f; // Default Kinetic Friction
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_Ksh = 5.0f; // HOOK'S SPRING CONSTANT
const double m_Ksd = 0.1f; // SPRING DAMPING CONSTANT
const double m_Csf = 0.9f; // Default Static Friction
const double m_Ckf = 0.7f; // Default Kinetic Friction
#include "dumb3d.h" #include "dumb3d.h"
using namespace Math3D; 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

1200
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

503
TextureDDS.cpp
View File

@@ -1,299 +1,330 @@
#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;
b0 = Data[0] & 0x1F; b0 = Data[0] & 0x1F;
g0 = ((Data[0] & 0xE0) >> 5) | ((Data[1] & 0x7) << 3); g0 = ((Data[0] & 0xE0) >> 5) | ((Data[1] & 0x7) << 3);
r0 = (Data[1] & 0xF8) >> 3; r0 = (Data[1] & 0xF8) >> 3;
b1 = Data[2] & 0x1F; b1 = Data[2] & 0x1F;
g1 = ((Data[2] & 0xE0) >> 5) | ((Data[3] & 0x7) << 3); g1 = ((Data[2] & 0xE0) >> 5) | ((Data[3] & 0x7) << 3);
r1 = (Data[3] & 0xF8) >> 3; r1 = (Data[3] & 0xF8) >> 3;
result[0].r = r0 << 3 | r0 >> 2; result[0].r = r0 << 3 | r0 >> 2;
result[0].g = g0 << 2 | g0 >> 3; result[0].g = g0 << 2 | g0 >> 3;
result[0].b = b0 << 3 | b0 >> 2; result[0].b = b0 << 3 | b0 >> 2;
result[1].r = r1 << 3 | r1 >> 2; result[1].r = r1 << 3 | r1 >> 2;
result[1].g = g1 << 2 | g1 >> 3; result[1].g = g1 << 2 | g1 >> 3;
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;
b = Data & 0x1f; b = Data & 0x1f;
g = (Data & 0x7E0) >> 5; g = (Data & 0x7E0) >> 5;
r = (Data & 0xF800) >> 11; r = (Data & 0xF800) >> 11;
Out->r = r << 3 | r >> 2; Out->r = r << 3 | r >> 2;
Out->g = g << 2 | g >> 3; Out->g = g << 2 | g >> 3;
Out->b = b << 3 | r >> 2; Out->b = b << 3 | r >> 2;
}; };
void DecompressDXT1(DDS_IMAGE_DATA lImage, const GLubyte *lCompData, GLubyte *Data) void DecompressDXT1(DDS_IMAGE_DATA lImage, const GLubyte *lCompData, GLubyte *Data)
{ {
GLint x, y, i, j, k; GLint x, y, i, j, k;
GLuint Select; GLuint Select;
const GLubyte *Temp; const GLubyte *Temp;
Color8888 colours[4], *col; Color8888 colours[4], *col;
GLushort color_0, color_1; GLushort color_0, color_1;
GLuint bitmask, Offset; GLuint bitmask, Offset;
Temp = lCompData; Temp = lCompData;
colours[0].a = 0xFF; colours[0].a = 0xFF;
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.
// 00 = color_0, 01 = color_1, 10 = color_2, 11 = color_3
// These 2-bit codes correspond to the 2-bit fields
// stored in the 64-bit block.
colours[2].b = (2 * colours[0].b + colours[1].b + 1) / 3;
colours[2].g = (2 * colours[0].g + colours[1].g + 1) / 3;
colours[2].r = (2 * colours[0].r + colours[1].r + 1) / 3;
colours[3].b = (colours[0].b + 2 * colours[1].b + 1) / 3;
colours[3].g = (colours[0].g + 2 * colours[1].g + 1) / 3;
colours[3].r = (colours[0].r + 2 * colours[1].r + 1) / 3;
colours[3].a = 0xFF;
}
else
{ {
// Three-color block: derive the other color. // Four-color block: derive the other two colors.
// 00 = color_0, 01 = color_1, 10 = color_2, // 00 = color_0, 01 = color_1, 10 = color_2, 11 = color_3
// 11 = transparent. // These 2-bit codes correspond to the 2-bit fields
// These 2-bit codes correspond to the 2-bit fields // stored in the 64-bit block.
// stored in the 64-bit block. colours[2].b = (2 * colours[0].b + colours[1].b + 1) / 3;
colours[2].b = (colours[0].b + colours[1].b) / 2; colours[2].g = (2 * colours[0].g + colours[1].g + 1) / 3;
colours[2].g = (colours[0].g + colours[1].g) / 2; colours[2].r = (2 * colours[0].r + colours[1].r + 1) / 3;
colours[2].r = (colours[0].r + colours[1].r) / 2;
colours[3].b = (colours[0].b + 2 * colours[1].b + 1) / 3; colours[3].b = (colours[0].b + 2 * colours[1].b + 1) / 3;
colours[3].g = (colours[0].g + 2 * colours[1].g + 1) / 3; colours[3].g = (colours[0].g + 2 * colours[1].g + 1) / 3;
colours[3].r = (colours[0].r + 2 * colours[1].r + 1) / 3; colours[3].r = (colours[0].r + 2 * colours[1].r + 1) / 3;
colours[3].a = 0x00; colours[3].a = 0xFF;
} }
else
{
// Three-color block: derive the other color.
// 00 = color_0, 01 = color_1, 10 = color_2,
// 11 = transparent.
// These 2-bit codes correspond to the 2-bit fields
// stored in the 64-bit block.
colours[2].b = (colours[0].b + colours[1].b) / 2;
colours[2].g = (colours[0].g + colours[1].g) / 2;
colours[2].r = (colours[0].r + colours[1].r) / 2;
for (j = 0, k = 0; j < 4; j++) { colours[3].b = (colours[0].b + 2 * colours[1].b + 1) / 3;
for (i = 0; i < 4; i++, k++) { colours[3].g = (colours[0].g + 2 * colours[1].g + 1) / 3;
Select = (bitmask & (0x03 << k*2)) >> k*2; colours[3].r = (colours[0].r + 2 * colours[1].r + 1) / 3;
col = &colours[Select]; colours[3].a = 0x00;
}
if (((x + i) < lImage.width) && ((y + j) < lImage.height)) { for (j = 0, k = 0; j < 4; j++)
Offset = (y + j) * lImage.width * lImage.components + (x + i) * lImage.components; {
Data[Offset + 0] = col->r; for (i = 0; i < 4; i++, k++)
Data[Offset + 1] = col->g; {
Data[Offset + 2] = col->b; Select = (bitmask & (0x03 << k * 2)) >> k * 2;
Data[Offset + 3] = col->a; col = &colours[Select];
}
} if (((x + i) < lImage.width) && ((y + j) < lImage.height))
} {
} Offset = (y + j) * lImage.width * lImage.components +
} (x + i) * lImage.components;
Data[Offset + 0] = col->r;
Data[Offset + 1] = col->g;
Data[Offset + 2] = col->b;
Data[Offset + 3] = col->a;
}
}
}
}
}
} }
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) { {
alpha = Temp; for (GLint x = 0; x < lImage.width; x += 4)
Temp += 8; {
DxtcReadColors(Temp, colours); alpha = Temp;
bitmask = ((GLuint*)Temp)[1]; Temp += 8;
DxtcReadColors(Temp, colours);
bitmask = ((GLuint *)Temp)[1];
Temp += 8; Temp += 8;
// 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
// stored in the 64-bit block. // stored in the 64-bit block.
colours[2].b = (2 * colours[0].b + colours[1].b + 1) / 3; colours[2].b = (2 * colours[0].b + colours[1].b + 1) / 3;
colours[2].g = (2 * colours[0].g + colours[1].g + 1) / 3; colours[2].g = (2 * colours[0].g + colours[1].g + 1) / 3;
colours[2].r = (2 * colours[0].r + colours[1].r + 1) / 3; colours[2].r = (2 * colours[0].r + colours[1].r + 1) / 3;
colours[3].b = (colours[0].b + 2 * colours[1].b + 1) / 3; colours[3].b = (colours[0].b + 2 * colours[1].b + 1) / 3;
colours[3].g = (colours[0].g + 2 * colours[1].g + 1) / 3; colours[3].g = (colours[0].g + 2 * colours[1].g + 1) / 3;
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++)
col = &colours[Select]; {
GLuint Select = (bitmask & (0x03 << k * 2)) >> k * 2;
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; {
Data[Offset + 0] = col->r; Offset = (y + j) * lImage.width * lImage.components +
Data[Offset + 1] = col->g; (x + i) * lImage.components;
Data[Offset + 2] = col->b; Data[Offset + 0] = col->r;
} Data[Offset + 1] = col->g;
} Data[Offset + 2] = col->b;
} }
}
}
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; {
Data[Offset] = word & 0x0F; if (((x + i) < lImage.width) && ((y + j) < lImage.height))
Data[Offset] = Data[Offset] | (Data[Offset] << 4); {
} Offset = (y + j) * lImage.width * lImage.components +
word >>= 4; (x + i) * lImage.components + 3;
} Data[Offset] = word & 0x0F;
} Data[Offset] = Data[Offset] | (Data[Offset] << 4);
} }
} word >>= 4;
}
}
}
}
} }
void DecompressDXT5(DDS_IMAGE_DATA lImage, const GLubyte *lCompData, GLubyte *Data) void DecompressDXT5(DDS_IMAGE_DATA lImage, const GLubyte *lCompData, GLubyte *Data)
{ {
GLint x, y, z, i, j, k; GLint x, y, z, i, j, k;
GLuint Select; GLuint Select;
const GLubyte *Temp; //, r0, g0, b0, r1, g1, b1; const GLubyte *Temp; //, r0, g0, b0, r1, g1, b1;
Color8888 colours[4], *col; Color8888 colours[4], *col;
GLuint bitmask, Offset; GLuint bitmask, Offset;
GLubyte alphas[8]; GLubyte alphas[8];
GLuint bits; GLuint bits;
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) { {
if (y >= lImage.height || x >= lImage.width) for (x = 0; x < lImage.width; x += 4)
break; {
alphas[0] = Temp[0]; if (y >= lImage.height || x >= lImage.width)
alphas[1] = Temp[1]; break;
const GLubyte* alphamask = Temp + 2; alphas[0] = Temp[0];
Temp += 8; alphas[1] = Temp[1];
const GLubyte *alphamask = Temp + 2;
Temp += 8;
DxtcReadColors(Temp, colours); DxtcReadColors(Temp, colours);
bitmask = ((const GLuint*)Temp)[1]; bitmask = ((const GLuint *)Temp)[1];
Temp += 8; Temp += 8;
// 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
// stored in the 64-bit block. // stored in the 64-bit block.
colours[2].b = (2 * colours[0].b + colours[1].b + 1) / 3; colours[2].b = (2 * colours[0].b + colours[1].b + 1) / 3;
colours[2].g = (2 * colours[0].g + colours[1].g + 1) / 3; colours[2].g = (2 * colours[0].g + colours[1].g + 1) / 3;
colours[2].r = (2 * colours[0].r + colours[1].r + 1) / 3; colours[2].r = (2 * colours[0].r + colours[1].r + 1) / 3;
colours[3].b = (colours[0].b + 2 * colours[1].b + 1) / 3; colours[3].b = (colours[0].b + 2 * colours[1].b + 1) / 3;
colours[3].g = (colours[0].g + 2 * colours[1].g + 1) / 3; colours[3].g = (colours[0].g + 2 * colours[1].g + 1) / 3;
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; {
Data[Offset + 0] = col->r; Offset = (y + j) * lImage.width * lImage.components +
Data[Offset + 1] = col->g; (x + i) * lImage.components;
Data[Offset + 2] = col->b; Data[Offset + 0] = col->r;
} Data[Offset + 1] = col->g;
} Data[Offset + 2] = col->b;
} }
}
}
// 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. {
// Bit code 000 = alpha_0, 001 = alpha_1, others are interpolated. // 8-alpha block: derive the other six alphas.
alphas[2] = (6 * alphas[0] + 1 * alphas[1] + 3) / 7; // bit code 010 // Bit code 000 = alpha_0, 001 = alpha_1, others are interpolated.
alphas[3] = (5 * alphas[0] + 2 * alphas[1] + 3) / 7; // bit code 011 alphas[2] = (6 * alphas[0] + 1 * alphas[1] + 3) / 7; // bit code 010
alphas[4] = (4 * alphas[0] + 3 * alphas[1] + 3) / 7; // bit code 100 alphas[3] = (5 * alphas[0] + 2 * alphas[1] + 3) / 7; // bit code 011
alphas[5] = (3 * alphas[0] + 4 * alphas[1] + 3) / 7; // bit code 101 alphas[4] = (4 * alphas[0] + 3 * alphas[1] + 3) / 7; // bit code 100
alphas[6] = (2 * alphas[0] + 5 * alphas[1] + 3) / 7; // bit code 110 alphas[5] = (3 * alphas[0] + 4 * alphas[1] + 3) / 7; // bit code 101
alphas[7] = (1 * alphas[0] + 6 * alphas[1] + 3) / 7; // bit code 111 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
else { }
// 6-alpha block. else
// Bit code 000 = alpha_0, 001 = alpha_1, others are interpolated. {
alphas[2] = (4 * alphas[0] + 1 * alphas[1] + 2) / 5; // Bit code 010 // 6-alpha block.
alphas[3] = (3 * alphas[0] + 2 * alphas[1] + 2) / 5; // Bit code 011 // Bit code 000 = alpha_0, 001 = alpha_1, others are interpolated.
alphas[4] = (2 * alphas[0] + 3 * alphas[1] + 2) / 5; // Bit code 100 alphas[2] = (4 * alphas[0] + 1 * alphas[1] + 2) / 5; // Bit code 010
alphas[5] = (1 * alphas[0] + 4 * alphas[1] + 2) / 5; // Bit code 101 alphas[3] = (3 * alphas[0] + 2 * alphas[1] + 2) / 5; // Bit code 011
alphas[6] = 0x00; // Bit code 110 alphas[4] = (2 * alphas[0] + 3 * alphas[1] + 2) / 5; // Bit code 100
alphas[7] = 0xFF; // Bit code 111 alphas[5] = (1 * alphas[0] + 4 * alphas[1] + 2) / 5; // Bit code 101
} alphas[6] = 0x00; // Bit code 110
alphas[7] = 0xFF; // Bit code 111
}
// Note: Have to separate the next two loops, // Note: Have to separate the next two loops,
// 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++) { {
// only put pixels out < width or height for (i = 0; i < 4; i++)
if (((x + i) < lImage.width) && ((y + j) < lImage.height)) { {
Offset = (y + j) * lImage.width * lImage.components + (x + i) * lImage.components + 3; // only put pixels out < width or height
Data[Offset] = alphas[bits & 0x07]; if (((x + i) < lImage.width) && ((y + j) < lImage.height))
} {
bits >>= 3; Offset = (y + j) * lImage.width * lImage.components +
} (x + i) * lImage.components + 3;
} Data[Offset] = alphas[bits & 0x07];
}
bits >>= 3;
}
}
// 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++) { {
// only put pixels out < width or height for (i = 0; i < 4; i++)
if (((x + i) < lImage.width) && ((y + j) < lImage.height)) { {
Offset = (y + j) * lImage.width * lImage.components + (x + i) * lImage.components + 3; // only put pixels out < width or height
Data[Offset] = alphas[bits & 0x07]; if (((x + i) < lImage.width) && ((y + j) < lImage.height))
} {
bits >>= 3; Offset = (y + j) * lImage.width * lImage.components +
} (x + i) * lImage.components + 3;
} Data[Offset] = alphas[bits & 0x07];
} }
} bits >>= 3;
}
}
}
}
} }
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);
break; break;
case GL_COMPRESSED_RGBA_S3TC_DXT3_EXT: case GL_COMPRESSED_RGBA_S3TC_DXT3_EXT:
DecompressDXT3(lImage, lCompData, Data); DecompressDXT3(lImage, lCompData, Data);
break; break;
case GL_COMPRESSED_RGBA_S3TC_DXT5_EXT:
DecompressDXT5(lImage, lCompData, Data);
break;
case GL_COMPRESSED_RGBA_S3TC_DXT5_EXT:
DecompressDXT5(lImage, lCompData, Data);
break;
}; };
} }

21
TextureDDS.h
View File

@@ -7,24 +7,23 @@
struct Color8888 struct Color8888
{ {
GLubyte r; // change the order of names to change the GLubyte r; // change the order of names to change the
GLubyte g; // order of the output ARGB or BGRA, etc... GLubyte g; // order of the output ARGB or BGRA, etc...
GLubyte b; // Last one is MSB, 1st is LSB. GLubyte b; // Last one is MSB, 1st is LSB.
GLubyte a; GLubyte a;
}; };
struct DDS_IMAGE_DATA struct DDS_IMAGE_DATA
{ {
GLsizei width; GLsizei width;
GLsizei height; GLsizei height;
GLint components; GLint components;
GLenum format; GLenum format;
GLuint blockSize; GLuint blockSize;
int numMipMaps; int numMipMaps;
GLubyte *pixels; GLubyte *pixels;
}; };
void DecompressDXT(DDS_IMAGE_DATA lImage, const GLubyte *lCompData, GLubyte *Data); void DecompressDXT(DDS_IMAGE_DATA lImage, const GLubyte *lCompData, GLubyte *Data);
#endif #endif

144
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)
double CurrentTime= double(count)/double(fr);//GetTickCount(); fSoundTimer = 0;
DeltaTime= (CurrentTime-OldTime); /*
OldTime= CurrentTime; double CurrentTime= double(count)/double(fr);//GetTickCount();
*/ DeltaTime= (CurrentTime-OldTime);
if (DeltaTime>1) DeltaTime=1; OldTime= CurrentTime;
} */
else if (DeltaTime > 1)
DeltaTime=0; //wszystko stoi, bo czas nie p³ynie DeltaTime = 1;
oldCount=count; }
else
DeltaTime = 0; // wszystko stoi, bo czas nie p³ynie
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);
}; };
//--------------------------------------------------------------------------- //---------------------------------------------------------------------------

5324
Track.cpp
View File

File diff suppressed because it is too large Load Diff

407
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,201 +39,216 @@ 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 iPrevDirection[2]; int iNextDirection[2]; // to też z [2]+[2] przerobić na [4]
int CurrentIndex; //dla zwrotnicy int iPrevDirection[2];
double fOffset,fDesiredOffset; //aktualne i docelowe położenie napędu iglic int CurrentIndex; // dla zwrotnicy
double fOffsetSpeed; //prędkość liniowa ruchu iglic double fOffset, fDesiredOffset; // aktualne i docelowe położenie napędu iglic
double fOffsetDelay; //opóźnienie ruchu drugiej iglicy względem pierwszej double fOffsetSpeed; // prędkość liniowa ruchu iglic
union double fOffsetDelay; // opóźnienie ruchu drugiej iglicy względem pierwszej
{ union
struct {
{//zmienne potrzebne tylko dla zwrotnicy struct
double fOffset1,fOffset2; //przesunięcia iglic - 0=na wprost { // zmienne potrzebne tylko dla zwrotnicy
bool RightSwitch; //czy zwrotnica w prawo double fOffset1, fOffset2; // przesunięcia iglic - 0=na wprost
}; bool RightSwitch; // czy zwrotnica w prawo
struct };
{//zmienne potrzebne tylko dla obrotnicy/przesuwnicy struct
TGroundNode *pMyNode; //dla obrotnicy do wtórnego podłączania torów { // zmienne potrzebne tylko dla obrotnicy/przesuwnicy
//TAnimContainer *pAnim; //animator modelu dla obrotnicy TGroundNode *pMyNode; // dla obrotnicy do wtórnego podłączania torów
TAnimModel *pModel; //na razie model // TAnimContainer *pAnim; //animator modelu dla obrotnicy
}; TAnimModel *pModel; // na razie model
struct };
{//zmienne dla skrzyżowania struct
vector3 *vPoints; //tablica wierzchołków nawierzchni, generowana przez pobocze { // zmienne dla skrzyżowania
int iPoints; //liczba faktycznie użytych wierzchołków nawierzchni vector3 *vPoints; // tablica wierzchołków nawierzchni, generowana przez pobocze
bool bPoints; //czy utworzone? int iPoints; // liczba faktycznie użytych wierzchołków nawierzchni
int iRoads; //ile dróg się spotyka? bool bPoints; // czy utworzone?
}; int iRoads; // ile dróg się spotyka?
}; };
bool bMovement; //czy w trakcie animacji };
int iLeftVBO,iRightVBO; //indeksy iglic w VBO bool bMovement; // czy w trakcie animacji
TSubRect *pOwner; //sektor, któremu trzeba zgłosić animację int iLeftVBO, iRightVBO; // indeksy iglic w VBO
TTrack *pNextAnim; //następny tor do animowania TSubRect *pOwner; // sektor, któremu trzeba zgłosić animację
TEvent *evPlus,*evMinus; //zdarzenia sygnalizacji rozprucia TTrack *pNextAnim; // następny tor do animowania
float fVelocity; //maksymalne ograniczenie prędkości (ustawianej eventem) TEvent *evPlus, *evMinus; // zdarzenia sygnalizacji rozprucia
vector3 vTrans; //docelowa translacja przesuwnicy float fVelocity; // maksymalne ograniczenie prędkości (ustawianej eventem)
private: vector3 vTrans; // docelowa translacja przesuwnicy
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
int iNumDynamics; public:
TDynamicObject *Dynamics[iMaxNumDynamics]; int iNumDynamics;
int iEvents; //Ra: flaga informująca o obecności eventów TDynamicObject *Dynamics[iMaxNumDynamics];
TEvent *evEventall0; //McZapkie-140302: wyzwalany gdy pojazd stoi int iEvents; // Ra: flaga informująca o obecności eventów
TEvent *evEventall1; TEvent *evEventall0; // McZapkie-140302: wyzwalany gdy pojazd stoi
TEvent *evEventall2; TEvent *evEventall1;
TEvent *evEvent0; //McZapkie-280503: wyzwalany tylko gdy headdriver TEvent *evEventall2;
TEvent *evEvent1; TEvent *evEvent0; // McZapkie-280503: wyzwalany tylko gdy headdriver
TEvent *evEvent2; TEvent *evEvent1;
AnsiString asEventall0Name; //nazwy eventów TEvent *evEvent2;
AnsiString asEventall1Name; AnsiString asEventall0Name; // nazwy eventów
AnsiString asEventall2Name; AnsiString asEventall1Name;
AnsiString asEvent0Name; AnsiString asEventall2Name;
AnsiString asEvent1Name; AnsiString asEvent0Name;
AnsiString asEvent2Name; AnsiString asEvent1Name;
int iNextDirection; //0:Point1, 1:Point2, 3:do odchylonego na zwrotnicy AnsiString asEvent2Name;
int iPrevDirection; int iNextDirection; // 0:Point1, 1:Point2, 3:do odchylonego na zwrotnicy
TTrackType eType; int iPrevDirection;
int iCategoryFlag; //0x100 - usuwanie pojazów TTrackType eType;
float fTrackWidth; //szerokość w punkcie 1 int iCategoryFlag; // 0x100 - usuwanie pojazów
float fTrackWidth2; //szerokość w punkcie 2 (głównie drogi i rzeki) float fTrackWidth; // szerokość w punkcie 1
float fFriction; //współczynnik tarcia float fTrackWidth2; // szerokość w punkcie 2 (głównie drogi i rzeki)
float fSoundDistance; float fFriction; // współczynnik tarcia
int iQualityFlag; float fSoundDistance;
int iDamageFlag; int iQualityFlag;
TEnvironmentType eEnvironment; //dźwięk i oświetlenie int iDamageFlag;
bool bVisible; //czy rysowany TEnvironmentType eEnvironment; // dźwięk i oświetlenie
int iAction; //czy modyfikowany eventami (specjalna obsługa przy skanowaniu) bool bVisible; // czy rysowany
float fOverhead; //informacja o stanie sieci: 0-jazda bezprądowa, >0-z opuszczonym i ograniczeniem prędkości int iAction; // czy modyfikowany eventami (specjalna obsługa przy skanowaniu)
private: float fOverhead; // informacja o stanie sieci: 0-jazda bezprądowa, >0-z opuszczonym i
double fVelocity; //prędkość dla AI (powyżej rośnie prawdopowobieństwo wykolejenia) // ograniczeniem prędkości
public: private:
//McZapkie-100502: double fVelocity; // prędkość dla AI (powyżej rośnie prawdopowobieństwo wykolejenia)
double fTrackLength; //długość z wpisu, nigdzie nie używana public:
double fRadius; //promień, dla zwrotnicy kopiowany z tabeli // McZapkie-100502:
bool ScannedFlag; //McZapkie: do zaznaczania kolorem torów skanowanych przez AI double fTrackLength; // długość z wpisu, nigdzie nie używana
TTraction *hvOverhead; //drut zasilający do szybkiego znalezienia (nie używany) double fRadius; // promień, dla zwrotnicy kopiowany z tabeli
TGroundNode *nFouling[2]; //współrzędne ukresu albo oporu kozła bool ScannedFlag; // McZapkie: do zaznaczania kolorem torów skanowanych przez AI
TTrack *trColides; //tor kolizyjny, na którym trzeba sprawdzać pojazdy pod kątem zderzenia TTraction *hvOverhead; // drut zasilający do szybkiego znalezienia (nie używany)
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); {
bool __fastcall AssignEvents(TEvent *NewEvent0, TEvent *NewEvent1, TEvent *NewEvent2); return (SwitchExtension ? SwitchExtension->CurrentIndex : -1);
bool __fastcall AssignallEvents(TEvent *NewEvent0, TEvent *NewEvent1, TEvent *NewEvent2); };
bool __fastcall AssignForcedEvents(TEvent *NewEventPlus, TEvent *NewEventMinus); void __fastcall Load(cParser *parser, vector3 pOrigin, AnsiString name);
bool __fastcall CheckDynamicObject(TDynamicObject *Dynamic); bool __fastcall AssignEvents(TEvent *NewEvent0, TEvent *NewEvent1, TEvent *NewEvent2);
bool __fastcall AddDynamicObject(TDynamicObject *Dynamic); bool __fastcall AssignallEvents(TEvent *NewEvent0, TEvent *NewEvent1, TEvent *NewEvent2);
bool __fastcall RemoveDynamicObject(TDynamicObject *Dynamic); bool __fastcall AssignForcedEvents(TEvent *NewEventPlus, TEvent *NewEventMinus);
void __fastcall MoveMe(vector3 pPosition); bool __fastcall CheckDynamicObject(TDynamicObject *Dynamic);
bool __fastcall AddDynamicObject(TDynamicObject *Dynamic);
bool __fastcall RemoveDynamicObject(TDynamicObject *Dynamic);
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); };
void __fastcall RaAnimListAdd(TTrack *t); bool __fastcall InMovement(); // czy w trakcie animacji?
TTrack* __fastcall RaAnimate(); void __fastcall RaAssign(TGroundNode *gn, TAnimContainer *ac);
void __fastcall RaAssign(TGroundNode *gn, TAnimModel *am, TEvent *done, TEvent *joined);
void __fastcall RaAnimListAdd(TTrack *t);
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 {
AnsiString __fastcall IsolatedName(); if (pIsolated)
bool __fastcall IsolatedEventsAssign(TEvent *busy,TEvent *free); pIsolated->Modify(i, o);
double __fastcall WidthTotal(); }; // dodanie lub odjęcie osi
GLuint TextureGet(int i) {return i?TextureID1:TextureID2;}; AnsiString __fastcall IsolatedName();
bool __fastcall IsGroupable(); bool __fastcall IsolatedEventsAssign(TEvent *busy, TEvent *free);
int __fastcall TestPoint(vector3 *Point); double __fastcall WidthTotal();
void __fastcall MovedUp1(double dh); GLuint TextureGet(int i) { return i ? TextureID1 : TextureID2; };
AnsiString __fastcall NameGet(); bool __fastcall IsGroupable();
void __fastcall VelocitySet(float v); int __fastcall TestPoint(vector3 *Point);
float __fastcall VelocityGet(); void __fastcall MovedUp1(double dh);
void __fastcall ConnectionsLog(); AnsiString __fastcall NameGet();
private: void __fastcall VelocitySet(float v);
void __fastcall EnvironmentSet(); float __fastcall VelocityGet();
void __fastcall EnvironmentReset(); void __fastcall ConnectionsLog();
private:
void __fastcall EnvironmentSet();
void __fastcall EnvironmentReset();
}; };
//--------------------------------------------------------------------------- //---------------------------------------------------------------------------

1044
Traction.cpp
View File

File diff suppressed because it is too large Load Diff

115
Traction.h
View File

@@ -9,69 +9,72 @@
using namespace Math3D; 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
int iTries; float fResistance[2]; // rezystancja zastêpcza do punktu zasilania (0: przês³o zasilane, <0: do
//bool bVisible; // policzenia)
//DWORD dwFlags; int iTries;
// bool bVisible;
// 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)
// virtual bool __fastcall Move(double dx, double dy, double dz) { return false; }; // { return TNode::Hit(x,z,hitPoint,hitDirection); };
// virtual void __fastcall SelectedRender(); // virtual bool __fastcall Move(double dx, double dy, double dz) { return false; };
void __fastcall RenderDL(float mgn); // virtual void __fastcall SelectedRender();
int __fastcall RaArrayPrepare(); void __fastcall RenderDL(float mgn);
void __fastcall RaArrayFill(CVertNormTex *Vert); int __fastcall RaArrayPrepare();
void __fastcall RenderVBO(float mgn,int iPtr); void __fastcall RaArrayFill(CVertNormTex *Vert);
int __fastcall TestPoint(vector3 *Point); void __fastcall RenderVBO(float mgn, int iPtr);
void __fastcall Connect(int my,TTraction *with,int to); int __fastcall TestPoint(vector3 *Point);
void __fastcall Init(); void __fastcall Connect(int my, TTraction *with, int to);
bool __fastcall WhereIs(); void __fastcall Init();
void __fastcall ResistanceCalc(int d=-1,double r=0,TTractionPowerSource *ps=NULL); bool __fastcall WhereIs();
void __fastcall PowerSet(TTractionPowerSource *ps); void __fastcall ResistanceCalc(int d = -1, double r = 0, TTractionPowerSource *ps = NULL);
double __fastcall VoltageGet(double u,double i); void __fastcall PowerSet(TTractionPowerSource *ps);
double __fastcall VoltageGet(double u, double i);
}; };
//--------------------------------------------------------------------------- //---------------------------------------------------------------------------
#endif #endif

225
TractionPower.cpp
View File

@@ -6,9 +6,8 @@
*/ */
#include "system.hpp"
#include "system.hpp" #include "classes.hpp"
#include "classes.hpp"
#pragma hdrstop #pragma hdrstop
#include "Mover.h" #include "Mover.h"
@@ -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 >>
parser->getTokens(); FastFuseTimeOut;
*parser >> FastFuseRepetition; parser->getTokens();
parser->getTokens(); *parser >> FastFuseRepetition;
*parser >> SlowFuseTimeOut; parser->getTokens();
parser->getTokens(); *parser >> SlowFuseTimeOut;
*parser >> token; parser->getTokens();
if (token.compare("recuperation")==0) *parser >> token;
Recuperation=true; if (token.compare("recuperation") == 0)
else if (token.compare("section")==0) //od³¹cznik sekcyjny Recuperation = true;
bSection=true; //nie jest Ÿród³em zasilania, a jedynie informuje o pr¹dzie od³¹czenia sekcji z obwodu else if (token.compare("section") == 0) // od³¹cznik sekcyjny
parser->getTokens(); bSection = true; // nie jest Ÿród³em zasilania, a jedynie informuje o pr¹dzie od³¹czenia
*parser >> token; // sekcji z obwodu
if (token.compare("end")!=0) parser->getTokens();
Error("tractionpowersource end statement missing"); *parser >> token;
//if (!bSection) //od³¹cznik sekcji zasadniczo nie ma impedancji (0.01 jest OK) if (token.compare("end") != 0)
if (InternalRes<0.1) //coœ ma³a ta rezystancja by³a... Error("tractionpowersource end statement missing");
InternalRes=0.2; //tak oko³o 0.2, wg http://www.ikolej.pl/fileadmin/user_upload/Seminaria_IK/13_05_07_Prezentacja_Kruczek.pdf // if (!bSection) //od³¹cznik sekcji zasadniczo nie ma impedancji (0.01 jest OK)
return true; 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
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; {
FuseCounter+=1; FastFuse = true;
if (FuseCounter>FastFuseRepetition) FuseCounter += 1;
{SlowFuse=true; if (FuseCounter > FastFuseRepetition)
ErrorLog("Power overload: \""+gMyNode->asName+"\" disabled for "+AnsiString(SlowFuseTimeOut)+"s"); {
} SlowFuse = true;
else ErrorLog("Power overload: \"" + gMyNode->asName + "\" disabled for " +
ErrorLog("Power overload: \""+gMyNode->asName+"\" disabled for "+AnsiString(FastFuseTimeOut)+"s"); AnsiString(SlowFuseTimeOut) + "s");
FuseTimer=0; }
} else
if (FastFuse||SlowFuse) ErrorLog("Power overload: \"" + gMyNode->asName + "\" disabled for " +
{//jeœli któryœ z bezpieczników zadzia³a³ AnsiString(FastFuseTimeOut) + "s");
TotalAdmitance=0; FuseTimer = 0;
FuseTimer+=dt; }
if (!SlowFuse) if (FastFuse || SlowFuse)
{//gdy szybki, odczekaæ krótko i za³¹czyæ { // jeœli któryœ z bezpieczników zadzia³a³
if (FuseTimer>FastFuseTimeOut) TotalAdmitance = 0;
FastFuse=false; FuseTimer += dt;
} if (!SlowFuse)
else { // gdy szybki, odczekaæ krótko i za³¹czyæ
if (FuseTimer>SlowFuseTimeOut) if (FuseTimer > FastFuseTimeOut)
{SlowFuse=false; FastFuse = false;
FuseCounter=0; //dajemy znów szansê }
} else if (FuseTimer > SlowFuseTimeOut)
} {
TotalPreviousAdmitance=TotalAdmitance; //u¿ywamy admitancji z poprzedniego kroku SlowFuse = false;
if (TotalPreviousAdmitance==0.0) FuseCounter = 0; // dajemy znów szansê
TotalPreviousAdmitance=1e-10; //przynajmniej minimalna up³ywnoœæ }
TotalAdmitance=1e-10; //a w aktualnym kroku sumujemy admitancjê }
return true; TotalPreviousAdmitance = TotalAdmitance; // u¿ywamy admitancji z poprzedniego kroku
if (TotalPreviousAdmitance == 0.0)
TotalPreviousAdmitance = 1e-10; // przynajmniej minimalna up³ywnoœæ
TotalAdmitance = 1e-10; // a w aktualnym kroku sumujemy admitancjê
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");
}; };
//--------------------------------------------------------------------------- //---------------------------------------------------------------------------

66
TractionPower.h
View File

@@ -8,41 +8,41 @@ class TGroundNode;
class TTractionPowerSource class TTractionPowerSource
{ {
private: private:
double NominalVoltage; double NominalVoltage;
double VoltageFrequency; double VoltageFrequency;
double InternalRes; double InternalRes;
double MaxOutputCurrent; double MaxOutputCurrent;
double FastFuseTimeOut; double FastFuseTimeOut;
int FastFuseRepetition; int FastFuseRepetition;
double SlowFuseTimeOut; double SlowFuseTimeOut;
bool Recuperation; bool Recuperation;
double TotalCurrent; double TotalCurrent;
double TotalAdmitance; double TotalAdmitance;
double TotalPreviousAdmitance; double TotalPreviousAdmitance;
double OutputVoltage; double OutputVoltage;
bool FastFuse; bool FastFuse;
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:
__fastcall TTractionPowerSource(); // AnsiString asName;
__fastcall ~TTractionPowerSource(); __fastcall TTractionPowerSource();
void __fastcall Init(double u,double i); __fastcall ~TTractionPowerSource();
bool __fastcall Load(cParser *parser); void __fastcall Init(double u, double i);
bool __fastcall Render(); bool __fastcall Load(cParser *parser);
bool __fastcall Update(double dt); bool __fastcall Render();
double __fastcall CurrentGet(double res); bool __fastcall Update(double dt);
void __fastcall VoltageSet(double v) {NominalVoltage=v;}; double __fastcall CurrentGet(double res);
void __fastcall PowerSet(TTractionPowerSource *ps); void __fastcall VoltageSet(double v) { NominalVoltage = v; };
void __fastcall PowerSet(TTractionPowerSource *ps);
}; };
//--------------------------------------------------------------------------- //---------------------------------------------------------------------------

10592
Train.cpp
View File

File diff suppressed because it is too large Load Diff

344
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,
void __fastcall Load(TQueryParserComp *Parser); double Initz2, bool InitEnabled, bool InitOccupied);
vector3 CabPos1; void __fastcall Load(TQueryParserComp *Parser);
vector3 CabPos2; vector3 CabPos1;
bool bEnabled; vector3 CabPos2;
bool bOccupied; bool bEnabled;
double dimm_r, dimm_g, dimm_b; //McZapkie-120503: tlumienie swiatla bool bOccupied;
double intlit_r, intlit_g, intlit_b; //McZapkie-120503: oswietlenie kabiny double dimm_r, dimm_g, dimm_b; // McZapkie-120503: tlumienie swiatla
double intlitlow_r, intlitlow_g, intlitlow_b; //McZapkie-120503: przyciemnione oswietlenie kabiny double intlit_r, intlit_g, intlit_b; // McZapkie-120503: oswietlenie kabiny
private: double intlitlow_r, intlitlow_g,
//bool bChangePossible; intlitlow_b; // McZapkie-120503: przyciemnione oswietlenie kabiny
TGauge *ggList; //Ra 2014-08: lista animacji macierzowych (ga³ek) w kabinie private:
int iGaugesMax,iGauges; //ile miejsca w tablicy i ile jest w u¿yciu // bool bChangePossible;
TButton *btList; //Ra 2014-08: lista animacji dwustanowych (lampek) w kabinie TGauge *ggList; // Ra 2014-08: lista animacji macierzowych (ga³ek) w kabinie
int iButtonsMax,iButtons; //ile miejsca w tablicy i ile jest w u¿yciu int iGaugesMax, iGauges; // ile miejsca w tablicy i ile jest w u¿yciu
public: TButton *btList; // Ra 2014-08: lista animacji dwustanowych (lampek) w kabinie
TGauge* __fastcall Gauge(int n=-1); //pobranie adresu obiektu int iButtonsMax, iButtons; // ile miejsca w tablicy i ile jest w u¿yciu
TButton* __fastcall Button(int n=-1); //pobranie adresu obiektu public:
void __fastcall Update(); TGauge *__fastcall Gauge(int n = -1); // pobranie adresu obiektu
TButton *__fastcall Button(int n = -1); // pobranie adresu obiektu
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,32 +200,32 @@ 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;
TButton btLampkaHamPosp; TButton btLampkaHamPosp;
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 dsbHiss2;
// PSound dsbHiss1; // McZapkie-280302
// PSound dsbHiss2;
//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,61 +315,62 @@ 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;
PSound dsbCouplerStretch;
PSound dsbEN57_CouplerStretch;
PSound dsbBufferClamp;
// TSubModel *smCzuwakShpOn;
// TSubModel *smCzuwakOn;
// TSubModel *smShpOn;
// TSubModel *smCzuwakShpOff;
// double fCzuwakTimer;
double fBlinkTimer;
float fHaslerTimer;
float fConverterTimer; //hunter-261211: dla przekaznika
float fMainRelayTimer; //hunter-141211: zalaczanie WSa z opoznieniem
float fCzuwakTestTimer; //hunter-091012: do testu czuwaka
int CAflag; //hunter-131211: dla osobnego zbijania CA i SHP private:
// PSound dsbBuzzer;
PSound dsbCouplerStretch;
PSound dsbEN57_CouplerStretch;
PSound dsbBufferClamp;
// TSubModel *smCzuwakShpOn;
// TSubModel *smCzuwakOn;
// TSubModel *smShpOn;
// TSubModel *smCzuwakShpOff;
// double fCzuwakTimer;
double fBlinkTimer;
float fHaslerTimer;
float fConverterTimer; // hunter-261211: dla przekaznika
float fMainRelayTimer; // hunter-141211: zalaczanie WSa z opoznieniem
float fCzuwakTestTimer; // hunter-091012: do testu czuwaka
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();
}; };
//--------------------------------------------------------------------------- //---------------------------------------------------------------------------
#endif #endif

534
TrkFoll.cpp
View File

@@ -22,272 +22,308 @@
__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)
{ {
fDirection = fDir;
Owner = NewOwner;
SetCurrentTrack(pTrack, 0);
iEventFlag = 3; // na torze startowym również wykonać eventy 1/2
iEventallFlag = 3;
if ((pCurrentSegment)) // && (pCurrentSegment->GetLength()<fFirstDistance))
return false;
return true;
} }
bool __fastcall TTrackFollower::Init(TTrack *pTrack,TDynamicObject *NewOwner,double fDir) TTrack *__fastcall TTrackFollower::SetCurrentTrack(TTrack *pTrack, int end)
{ { // przejechanie na inny odcinkek toru, z ewentualnym rozpruciem
fDirection=fDir; if (pTrack)
Owner=NewOwner; switch (pTrack->eType)
SetCurrentTrack(pTrack,0); {
iEventFlag=3; //na torze startowym również wykonać eventy 1/2 case tt_Switch: // jeśli zwrotnica, to przekładamy ją, aby uzyskać dobry segment
iEventallFlag=3; {
if ((pCurrentSegment))// && (pCurrentSegment->GetLength()<fFirstDistance)) int i = (end ? pCurrentTrack->iNextDirection : pCurrentTrack->iPrevDirection);
return false; if (i > 0) // jeżeli wjazd z ostrza
return true; pTrack->SwitchForced(i >> 1, Owner); // to przełożenie zwrotnicy - rozprucie!
} }
break;
TTrack* __fastcall TTrackFollower::SetCurrentTrack(TTrack *pTrack,int end) case tt_Cross: // skrzyżowanie trzeba tymczasowo przełączyć, aby wjechać na właściwy tor
{//przejechanie na inny odcinkek toru, z ewentualnym rozpruciem {
if (pTrack) iSegment = Owner->RouteWish(pTrack); // nr segmentu został ustalony podczas skanowania
switch (pTrack->eType) // Ra 2014-08: aby ustalić dalszą trasę, należy zapytać AI - trasa jest ustalana podczas
{case tt_Switch: //jeśli zwrotnica, to przekładamy ją, aby uzyskać dobry segment // skanowania
{int i=(end?pCurrentTrack->iNextDirection:pCurrentTrack->iPrevDirection); // Ra 15-01: zapytanie AI nie wybiera segmentu - kolejny skanujący może przestawić
if (i>0) //jeżeli wjazd z ostrza // pTrack->CrossSegment(end?pCurrentTrack->iNextDirection:pCurrentTrack->iPrevDirection,i);
pTrack->SwitchForced(i>>1,Owner); //to przełożenie zwrotnicy - rozprucie! // //ustawienie właściwego wskaźnika
} // powinno zwracać kierunek do zapamiętania, bo segmenty mogą mieć różny kierunek
break; // if fDirection=(iSegment>0)?1.0:-1.0; //kierunek na tym segmencie jest ustalany
case tt_Cross: //skrzyżowanie trzeba tymczasowo przełączyć, aby wjechać na właściwy tor // bezpośrednio
{iSegment=Owner->RouteWish(pTrack); //nr segmentu został ustalony podczas skanowania if (iSegment == 0)
//Ra 2014-08: aby ustalić dalszą trasę, należy zapytać AI - trasa jest ustalana podczas skanowania { // to jest błędna sytuacja - generuje pętle zawracające za skrzyżowaniem - ustalić,
//Ra 15-01: zapytanie AI nie wybiera segmentu - kolejny skanujący może przestawić // kiedy powstaje!
//pTrack->CrossSegment(end?pCurrentTrack->iNextDirection:pCurrentTrack->iPrevDirection,i); //ustawienie właściwego wskaźnika iSegment = 1; // doraźna poprawka
//powinno zwracać kierunek do zapamiętania, bo segmenty mogą mieć różny kierunek }
//if fDirection=(iSegment>0)?1.0:-1.0; //kierunek na tym segmencie jest ustalany bezpośrednio if ((end ? iSegment : -iSegment) < 0)
if (iSegment==0) fDirection = -fDirection; // wtórna zmiana
{//to jest błędna sytuacja - generuje pętle zawracające za skrzyżowaniem - ustalić, kiedy powstaje! pTrack->SwitchForced(abs(iSegment) - 1, NULL); // wybór zapamiętanego segmentu
iSegment=1; //doraźna poprawka }
break;
}
if (!pTrack)
{ // gdy nie ma toru w kierunku jazdy
pTrack = pCurrentTrack->NullCreate(
end); // tworzenie toru wykolejącego na przedłużeniu pCurrentTrack
if (!end) // jeśli dodana od strony zero, to zmiana kierunku
fDirection = -fDirection; // wtórna zmiana
// if (pTrack->iCategoryFlag&2)
//{//jeśli samochód, zepsuć na miejscu
// Owner->MoverParameters->V=0; //zatrzymać
// Owner->MoverParameters->Power=0; //ukraść silnik
// Owner->MoverParameters->AccS=0; //wchłonąć moc
// Global::iPause|=1; //zapauzowanie symulacji
//}
} }
if ((end?iSegment:-iSegment)<0) else
fDirection=-fDirection; //wtórna zmiana { // najpierw +1, później -1, aby odcinek izolowany wspólny dla tych torów nie wykrył zera
pTrack->SwitchForced(abs(iSegment)-1,NULL); //wybór zapamiętanego segmentu pTrack->AxleCounter(+1, Owner); // zajęcie nowego toru
} if (pCurrentTrack)
break; pCurrentTrack->AxleCounter(-1, Owner); // opuszczenie tamtego toru
} }
if (!pTrack) pCurrentTrack = pTrack;
{//gdy nie ma toru w kierunku jazdy pCurrentSegment = (pCurrentTrack ? pCurrentTrack->CurrentSegment() : NULL);
pTrack=pCurrentTrack->NullCreate(end); //tworzenie toru wykolejącego na przedłużeniu pCurrentTrack if (!pCurrentTrack)
if (!end) //jeśli dodana od strony zero, to zmiana kierunku Error(Owner->MoverParameters->Name + " at NULL track");
fDirection=-fDirection; //wtórna zmiana return pCurrentTrack;
//if (pTrack->iCategoryFlag&2)
//{//jeśli samochód, zepsuć na miejscu
// Owner->MoverParameters->V=0; //zatrzymać
// Owner->MoverParameters->Power=0; //ukraść silnik
// Owner->MoverParameters->AccS=0; //wchłonąć moc
// Global::iPause|=1; //zapauzowanie symulacji
//}
}
else
{//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
if (pCurrentTrack) pCurrentTrack->AxleCounter(-1,Owner); //opuszczenie tamtego toru
}
pCurrentTrack=pTrack;
pCurrentSegment=(pCurrentTrack?pCurrentTrack->CurrentSegment():NULL);
if (!pCurrentTrack)
Error(Owner->MoverParameters->Name+" at NULL track");
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 (Owner->Mechanik) //tylko dla jednego członu if (iSetFlag(iEventFlag, -1)) // zawsze zeruje flagę sprawdzenia, jak mechanik
//if (TestFlag(iEventFlag,1)) //McZapkie-280503: wyzwalanie event tylko dla pojazdow z obsada // dosiądzie, to się nie wykona
if (bPrimary && pCurrentTrack->evEvent1 && (!pCurrentTrack->evEvent1->iQueued)) if (Owner->Mechanik) // tylko dla jednego członu
Global::AddToQuery(pCurrentTrack->evEvent1,Owner); //dodanie do kolejki // if (TestFlag(iEventFlag,1)) //McZapkie-280503: wyzwalanie event tylko dla
//Owner->RaAxleEvent(pCurrentTrack->Event1); //Ra: dynamic zdecyduje, czy dodać do kolejki // pojazdow z obsada
//if (TestFlag(iEventallFlag,1)) if (bPrimary && pCurrentTrack->evEvent1 &&
if (iSetFlag(iEventallFlag,-1)) //McZapkie-280503: wyzwalanie eventall dla wszystkich pojazdow (!pCurrentTrack->evEvent1->iQueued))
if (bPrimary && pCurrentTrack->evEventall1 && (!pCurrentTrack->evEventall1->iQueued)) Global::AddToQuery(pCurrentTrack->evEvent1, Owner); // dodanie do
Global::AddToQuery(pCurrentTrack->evEventall1,Owner); //dodanie do kolejki // kolejki
//Owner->RaAxleEvent(pCurrentTrack->Eventall1); //Ra: dynamic zdecyduje, czy dodać do kolejki // Owner->RaAxleEvent(pCurrentTrack->Event1); //Ra: dynamic zdecyduje, czy dodać do
} // kolejki
else if (fDistance>0) // if (TestFlag(iEventallFlag,1))
{ if (iSetFlag(iEventallFlag,
if (iSetFlag(iEventFlag,-2)) //zawsze ustawia flagę sprawdzenia, jak mechanik dosiądzie, to się nie wykona -1)) // McZapkie-280503: wyzwalanie eventall dla wszystkich pojazdow
if (Owner->Mechanik) //tylko dla jednego członu if (bPrimary && pCurrentTrack->evEventall1 &&
//if (TestFlag(iEventFlag,2)) //sprawdzanie jest od razu w pierwszym warunku (!pCurrentTrack->evEventall1->iQueued))
if (bPrimary && pCurrentTrack->evEvent2 && (!pCurrentTrack->evEvent2->iQueued)) Global::AddToQuery(pCurrentTrack->evEventall1, Owner); // dodanie do kolejki
Global::AddToQuery(pCurrentTrack->evEvent2,Owner); // Owner->RaAxleEvent(pCurrentTrack->Eventall1); //Ra: dynamic zdecyduje, czy dodać
//Owner->RaAxleEvent(pCurrentTrack->Event2); //Ra: dynamic zdecyduje, czy dodać do kolejki // do kolejki
//if (TestFlag(iEventallFlag,2)) }
if (iSetFlag(iEventallFlag,-2)) //sprawdza i zeruje na przyszłość, true jeśli zmieni z 2 na 0 else if (fDistance > 0)
if (bPrimary && pCurrentTrack->evEventall2 && (!pCurrentTrack->evEventall2->iQueued)) {
Global::AddToQuery(pCurrentTrack->evEventall2,Owner); if (iSetFlag(iEventFlag, -2)) // zawsze ustawia flagę sprawdzenia, jak mechanik
//Owner->RaAxleEvent(pCurrentTrack->Eventall2); //Ra: dynamic zdecyduje, czy dodać do kolejki // dosiądzie, to się nie wykona
} if (Owner->Mechanik) // tylko dla jednego członu
else //if (fDistance==0) //McZapkie-140602: wyzwalanie zdarzenia gdy pojazd stoi // if (TestFlag(iEventFlag,2)) //sprawdzanie jest od razu w pierwszym
{ // warunku
if (Owner->Mechanik) //tylko dla jednego członu if (bPrimary && pCurrentTrack->evEvent2 &&
if (pCurrentTrack->evEvent0) (!pCurrentTrack->evEvent2->iQueued))
if (!pCurrentTrack->evEvent0->iQueued) Global::AddToQuery(pCurrentTrack->evEvent2, Owner);
Global::AddToQuery(pCurrentTrack->evEvent0,Owner); // Owner->RaAxleEvent(pCurrentTrack->Event2); //Ra: dynamic zdecyduje, czy dodać do
//Owner->RaAxleEvent(pCurrentTrack->Event0); //Ra: dynamic zdecyduje, czy dodać do kolejki // kolejki
if (pCurrentTrack->evEventall0) // if (TestFlag(iEventallFlag,2))
if (!pCurrentTrack->evEventall0->iQueued) if (iSetFlag(iEventallFlag,
Global::AddToQuery(pCurrentTrack->evEventall0,Owner); -2)) // sprawdza i zeruje na przyszłość, true jeśli zmieni z 2 na 0
//Owner->RaAxleEvent(pCurrentTrack->Eventall0); //Ra: dynamic zdecyduje, czy dodać do kolejki if (bPrimary && pCurrentTrack->evEventall2 &&
} (!pCurrentTrack->evEventall2->iQueued))
} Global::AddToQuery(pCurrentTrack->evEventall2, Owner);
if (!pCurrentSegment) //jeżeli nie ma powiązanego segmentu toru? // Owner->RaAxleEvent(pCurrentTrack->Eventall2); //Ra: dynamic zdecyduje, czy dodać
return false; // do kolejki
//if (fDistance==0.0) return true; //Ra: jak stoi, to chyba dalej nie ma co kombinować? }
s=fCurrentDistance+fDistance; //doliczenie przesunięcia else // if (fDistance==0) //McZapkie-140602: wyzwalanie zdarzenia gdy pojazd stoi
//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ę if (Owner->Mechanik) // tylko dla jednego członu
// sprężystości na amortyzatorach. Należałoby we wpisie toru umieścić współczynnik if (pCurrentTrack->evEvent0)
// podziału energii kinetycznej. if (!pCurrentTrack->evEvent0->iQueued)
// Współczynnik normalnie 1, z dziurą np. 0.99, a -1 będzie oznaczało 100% odbicia (kozioł). Global::AddToQuery(pCurrentTrack->evEvent0, Owner);
// Albo w postaci kąta: normalnie 0°, a 180° oznacza 100% odbicia (cosinus powyższego). // Owner->RaAxleEvent(pCurrentTrack->Event0); //Ra: dynamic zdecyduje, czy dodać do
/* // kolejki
if (pCurrentTrack->eType==tt_Cross) if (pCurrentTrack->evEventall0)
{//zjazdu ze skrzyżowania nie da się określić przez (iPrevDirection) i (iNextDirection) if (!pCurrentTrack->evEventall0->iQueued)
//int segment=Owner->RouteWish(pCurrentTrack); //numer segmentu dla skrzyżowań Global::AddToQuery(pCurrentTrack->evEventall0, Owner);
//pCurrentTrack->SwitchForced(abs(segment)-1,NULL); //tymczasowo ustawienie tego segmentu // Owner->RaAxleEvent(pCurrentTrack->Eventall0); //Ra: dynamic zdecyduje, czy dodać
//pCurrentSegment=pCurrentTrack->CurrentSegment(); //odświeżyć sobie wskaźnik segmentu (?) // do kolejki
} }
*/ }
if (s<0) if (!pCurrentSegment) // jeżeli nie ma powiązanego segmentu toru?
{//jeśli przekroczenie toru od strony Point1 return false;
bCanSkip=bPrimary?pCurrentTrack->CheckDynamicObject(Owner):false; // if (fDistance==0.0) return true; //Ra: jak stoi, to chyba dalej nie ma co kombinować?
if (bCanSkip) //tylko główna oś przenosi pojazd do innego toru s = fCurrentDistance + fDistance; // doliczenie przesunięcia
Owner->MyTrack->RemoveDynamicObject(Owner); //zdejmujemy pojazd z dotychczasowego toru // Ra: W Point2 toru może znajdować się "dziura", która zamieni energię kinetyczną
dir=fDirection; // ruchu wzdłużnego na energię potencjalną, zamieniającą się potem na energię
if (pCurrentTrack->eType==tt_Cross) // sprężystości na amortyzatorach. Należałoby we wpisie toru umieścić współczynnik
{if (!SetCurrentTrack(pCurrentTrack->Neightbour(iSegment,fDirection),0)) // podziału energii kinetycznej.
return false; //wyjście z błędem // 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).
else if (!SetCurrentTrack(pCurrentTrack->Neightbour(-1,fDirection),0)) //ustawia fDirection /*
return false; //wyjście z błędem if (pCurrentTrack->eType==tt_Cross)
if (dir==fDirection) //(pCurrentTrack->iPrevDirection) {//zjazdu ze skrzyżowania nie da się określić przez (iPrevDirection) i (iNextDirection)
{//gdy kierunek bez zmiany (Point1->Point2) //int segment=Owner->RouteWish(pCurrentTrack); //numer segmentu dla skrzyżowań
fCurrentDistance=pCurrentSegment->GetLength(); //pCurrentTrack->SwitchForced(abs(segment)-1,NULL); //tymczasowo ustawienie tego segmentu
fDistance=s; //pCurrentSegment=pCurrentTrack->CurrentSegment(); //odświeżyć sobie wskaźnik segmentu
} (?)
else }
{//gdy zmiana kierunku toru (Point1->Point1) */
fCurrentDistance=0; if (s < 0)
fDistance=-s; { // jeśli przekroczenie toru od strony Point1
} bCanSkip = bPrimary ? pCurrentTrack->CheckDynamicObject(Owner) : false;
if (bCanSkip) if (bCanSkip) // tylko główna oś przenosi pojazd do innego toru
{//jak główna oś, to dodanie pojazdu do nowego toru Owner->MyTrack->RemoveDynamicObject(
pCurrentTrack->AddDynamicObject(Owner); Owner); // zdejmujemy pojazd z dotychczasowego toru
iEventFlag=3; //McZapkie-020602: umozliwienie uruchamiania event1,2 po zmianie toru dir = fDirection;
iEventallFlag=3; //McZapkie-280503: jw, dla eventall1,2 if (pCurrentTrack->eType == tt_Cross)
if (!Owner->MyTrack) return false; {
} if (!SetCurrentTrack(pCurrentTrack->Neightbour(iSegment, fDirection), 0))
continue; return false; // wyjście z błędem
} }
else if (s>pCurrentSegment->GetLength()) else if (!SetCurrentTrack(pCurrentTrack->Neightbour(-1, fDirection),
{//jeśli przekroczenie toru od strony Point2 0)) // ustawia fDirection
bCanSkip=bPrimary?pCurrentTrack->CheckDynamicObject(Owner):false; return false; // wyjście z błędem
if (bCanSkip) //tylko główna oś przenosi pojazd do innego toru if (dir == fDirection) //(pCurrentTrack->iPrevDirection)
Owner->MyTrack->RemoveDynamicObject(Owner); //zdejmujemy pojazd z dotychczasowego toru { // gdy kierunek bez zmiany (Point1->Point2)
fDistance=s-pCurrentSegment->GetLength(); fCurrentDistance = pCurrentSegment->GetLength();
dir=fDirection; fDistance = s;
if (pCurrentTrack->eType==tt_Cross) }
{if (!SetCurrentTrack(pCurrentTrack->Neightbour(iSegment,fDirection),1)) else
return false; //wyjście z błędem { // gdy zmiana kierunku toru (Point1->Point1)
} fCurrentDistance = 0;
else if (!SetCurrentTrack(pCurrentTrack->Neightbour(1,fDirection),1)) //ustawia fDirection fDistance = -s;
return false; //wyjście z błędem }
if (dir!=fDirection) //(pCurrentTrack->iNextDirection) if (bCanSkip)
{//gdy zmiana kierunku toru (Point2->Point2) { // jak główna oś, to dodanie pojazdu do nowego toru
fDistance=-fDistance; //(s-pCurrentSegment->GetLength()); pCurrentTrack->AddDynamicObject(Owner);
fCurrentDistance=pCurrentSegment->GetLength(); iEventFlag =
} 3; // McZapkie-020602: umozliwienie uruchamiania event1,2 po zmianie toru
else //gdy kierunek bez zmiany (Point2->Point1) iEventallFlag = 3; // McZapkie-280503: jw, dla eventall1,2
fCurrentDistance=0; if (!Owner->MyTrack)
if (bCanSkip) return false;
{//jak główna oś, to dodanie pojazdu do nowego toru }
pCurrentTrack->AddDynamicObject(Owner); continue;
iEventFlag=3; //McZapkie-020602: umozliwienie uruchamiania event1,2 po zmianie toru }
iEventallFlag=3; else if (s > pCurrentSegment->GetLength())
if (!Owner->MyTrack) return false; { // jeśli przekroczenie toru od strony Point2
} bCanSkip = bPrimary ? pCurrentTrack->CheckDynamicObject(Owner) : false;
continue; if (bCanSkip) // tylko główna oś przenosi pojazd do innego toru
} Owner->MyTrack->RemoveDynamicObject(
else Owner); // zdejmujemy pojazd z dotychczasowego toru
{//gdy zostaje na tym samym torze (przesuwanie już nie zmienia toru) fDistance = s - pCurrentSegment->GetLength();
if (bPrimary) dir = fDirection;
{//tylko gdy początkowe ustawienie, dodajemy eventy stania do kolejki if (pCurrentTrack->eType == tt_Cross)
if (Owner->MoverParameters->ActiveCab!=0) {
//if (Owner->MoverParameters->CabNo!=0) if (!SetCurrentTrack(pCurrentTrack->Neightbour(iSegment, fDirection), 1))
{ return false; // wyjście z błędem
if (pCurrentTrack->evEvent1 && pCurrentTrack->evEvent1->fDelay<=-1.0f) }
Global::AddToQuery(pCurrentTrack->evEvent1,Owner); else if (!SetCurrentTrack(pCurrentTrack->Neightbour(1, fDirection),
if (pCurrentTrack->evEvent2 && pCurrentTrack->evEvent2->fDelay<=-1.0f) 1)) // ustawia fDirection
Global::AddToQuery(pCurrentTrack->evEvent2,Owner); 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
}
} }
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) }
{//jeśli przesunięcie względem osi toru, to je doliczyć if (fOffsetH != 0.0)
{ // jeśli przesunięcie względem osi toru, to je doliczyć
} }
return true; return true;
} }
return false; return false;
} }
#if RENDER_CONE #if RENDER_CONE
#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();
} }
#endif #endif
//--------------------------------------------------------------------------- //---------------------------------------------------------------------------

62
TrkFoll.h
View File

@@ -8,35 +8,39 @@
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
__fastcall TTrackFollower(); vector3 vAngles; // x:przechyłka, y:pochylenie, z:kierunek w planie (w radianach)
__fastcall ~TTrackFollower(); __fastcall TTrackFollower();
TTrack* __fastcall SetCurrentTrack(TTrack *pTrack,int end); __fastcall ~TTrackFollower();
bool __fastcall Move(double fDistance,bool bPrimary); TTrack *__fastcall SetCurrentTrack(TTrack *pTrack, int end);
inline TTrack* __fastcall GetTrack() {return pCurrentTrack;}; bool __fastcall Move(double fDistance, bool bPrimary);
inline double __fastcall GetRoll() {return vAngles.x;}; //przechyłka policzona przy ustalaniu pozycji inline TTrack *__fastcall GetTrack() { return pCurrentTrack; };
//{return pCurrentSegment->GetRoll(fCurrentDistance)*fDirection;}; //zamiast liczyć można pobrać inline double __fastcall GetRoll()
inline double __fastcall GetDirection() {return fDirection;}; //zwrot na torze {
inline double __fastcall GetTranslation() {return fCurrentDistance;}; //ABu-030403 return vAngles.x;
//inline double __fastcall GetLength(vector3 p1, vector3 cp1, vector3 cp2, vector3 p2) }; // przechyłka policzona przy ustalaniu pozycji
//{ return pCurrentSegment->ComputeLength(p1,cp1,cp2,p2); }; //{return pCurrentSegment->GetRoll(fCurrentDistance)*fDirection;}; //zamiast liczyć można pobrać
//inline double __fastcall GetRadius(double L, double d); //McZapkie-150503 inline double __fastcall GetDirection() { return fDirection; }; // zwrot na torze
bool __fastcall Init(TTrack *pTrack,TDynamicObject *NewOwner,double fDir); inline double __fastcall GetTranslation() { return fCurrentDistance; }; // ABu-030403
void __fastcall Render(float fNr); // inline double __fastcall GetLength(vector3 p1, vector3 cp1, vector3 cp2, vector3 p2)
//{ return pCurrentSegment->ComputeLength(p1,cp1,cp2,p2); };
// inline double __fastcall GetRadius(double L, double d); //McZapkie-150503
bool __fastcall Init(TTrack *pTrack, TDynamicObject *NewOwner, double fDir);
void __fastcall Render(float fNr);
}; };
//--------------------------------------------------------------------------- //---------------------------------------------------------------------------
#endif #endif

124
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)
glEnableClientState(GL_VERTEX_ARRAY); return false; // nie ma nic do rysowania w ten sposób
glEnableClientState(GL_NORMAL_ARRAY); glEnableClientState(GL_VERTEX_ARRAY);
glEnableClientState(GL_TEXTURE_COORD_ARRAY); glEnableClientState(GL_NORMAL_ARRAY);
if (m_nVBOVertices) glEnableClientState(GL_TEXTURE_COORD_ARRAY);
{ if (m_nVBOVertices)
glBindBufferARB(GL_ARRAY_BUFFER_ARB,m_nVBOVertices); {
glVertexPointer(3,GL_FLOAT,sizeof(CVertNormTex),((char*)NULL)); //pozycje glBindBufferARB(GL_ARRAY_BUFFER_ARB, m_nVBOVertices);
glNormalPointer(GL_FLOAT,sizeof(CVertNormTex),((char*)NULL)+12); //normalne glVertexPointer(3, GL_FLOAT, sizeof(CVertNormTex), ((char *)NULL)); // pozycje
glTexCoordPointer(2,GL_FLOAT,sizeof(CVertNormTex),((char*)NULL)+24); //wierzchołki glNormalPointer(GL_FLOAT, sizeof(CVertNormTex), ((char *)NULL) + 12); // normalne
} 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)
glEnableClientState(GL_VERTEX_ARRAY); return false; // nie ma nic do rysowania w ten sposób
glEnableClientState(GL_COLOR_ARRAY); glEnableClientState(GL_VERTEX_ARRAY);
if (m_nVBOVertices) glEnableClientState(GL_COLOR_ARRAY);
{ if (m_nVBOVertices)
glBindBufferARB(GL_ARRAY_BUFFER_ARB,m_nVBOVertices); {
glVertexPointer(3,GL_FLOAT,sizeof(CVertNormTex),((char*)NULL)); //pozycje glBindBufferARB(GL_ARRAY_BUFFER_ARB, m_nVBOVertices);
//glColorPointer(3,GL_UNSIGNED_BYTE,sizeof(CVertNormTex),((char*)NULL)+12); //kolory glVertexPointer(3, GL_FLOAT, sizeof(CVertNormTex), ((char *)NULL)); // pozycje
glColorPointer(3,GL_FLOAT,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
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ść
}; };

45
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

4690
World.cpp
View File

File diff suppressed because it is too large Load Diff

88
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"
@@ -16,49 +15,50 @@
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:
bool __fastcall Init(HWND NhWnd, HDC hDC); public:
HWND hWnd; bool __fastcall Init(HWND NhWnd, HDC hDC);
GLvoid __fastcall glPrint(const char *fmt); HWND hWnd;
void __fastcall OnKeyDown(int cKey); GLvoid __fastcall glPrint(const char *fmt);
void __fastcall OnKeyUp(int cKey); void __fastcall OnKeyDown(int cKey);
//void __fastcall UpdateWindow(); void __fastcall OnKeyUp(int cKey);
void __fastcall OnMouseMove(double x, double y); // void __fastcall UpdateWindow();
void __fastcall OnCommandGet(DaneRozkaz *pRozkaz); void __fastcall OnMouseMove(double x, double y);
bool __fastcall Update(); void __fastcall OnCommandGet(DaneRozkaz *pRozkaz);
void __fastcall TrainDelete(TDynamicObject *d=NULL); bool __fastcall Update();
__fastcall TWorld(); void __fastcall TrainDelete(TDynamicObject *d = NULL);
__fastcall ~TWorld(); __fastcall TWorld();
//double Aspect; __fastcall ~TWorld();
private: // double Aspect;
AnsiString OutText1; //teksty na ekranie private:
AnsiString OutText2; AnsiString OutText1; // teksty na ekranie
AnsiString OutText3; AnsiString OutText2;
AnsiString OutText4; AnsiString OutText3;
void ShowHints(); AnsiString OutText4;
bool __fastcall Render(); void ShowHints();
TCamera Camera; bool __fastcall Render();
TGround Ground; TCamera Camera;
TTrain *Train; TGround Ground;
TDynamicObject *pDynamicNearest; TTrain *Train;
bool Paused; TDynamicObject *pDynamicNearest;
GLuint base; //numer DL dla znaków w napisach bool Paused;
GLuint light; //numer tekstury dla smugi GLuint base; // numer DL dla znaków w napisach
TSky Clouds; GLuint light; // numer tekstury dla smugi
TEvent *KeyEvents[10]; //eventy wyzwalane z klawiaury TSky Clouds;
TMoverParameters *mvControlled; //wskaŸnik na cz³on silnikowy, do wyœwietlania jego parametrów TEvent *KeyEvents[10]; // eventy wyzwalane z klawiaury
int iCheckFPS; //kiedy znów sprawdziæ FPS, ¿eby wy³¹czaæ optymalizacji od razu do zera TMoverParameters *mvControlled; // wskaŸnik na cz³on silnikowy, do wyœwietlania jego parametrów
double fTime50Hz; //bufor czasu dla komunikacji z PoKeys int iCheckFPS; // kiedy znów sprawdziæ FPS, ¿eby wy³¹czaæ optymalizacji od razu do zera
double fTimeBuffer; //bufor czasu aktualizacji dla sta³ego kroku fizyki double fTime50Hz; // bufor czasu dla komunikacji z PoKeys
double fMaxDt; //[s] krok czasowy fizyki (0.01 dla normalnych warunków) double fTimeBuffer; // bufor czasu aktualizacji dla sta³ego kroku fizyki
int iPause; //wykrywanie zmian w zapauzowaniu double fMaxDt; //[s] krok czasowy fizyki (0.01 dla normalnych warunków)
public: int iPause; // wykrywanie zmian w zapauzowaniu
void __fastcall ModifyTGA(const AnsiString &dir=""); public:
void __fastcall CreateE3D(const AnsiString &dir="",bool dyn=false); void __fastcall ModifyTGA(const AnsiString &dir = "");
void __fastcall CabChange(TDynamicObject *old,TDynamicObject *now); void __fastcall CreateE3D(const AnsiString &dir = "", bool dyn = false);
void __fastcall CabChange(TDynamicObject *old, TDynamicObject *now);
}; };
//--------------------------------------------------------------------------- //---------------------------------------------------------------------------
#endif #endif

603
dumb3d.cpp
View File

@@ -2,116 +2,140 @@
#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];
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 c1 = m[2][0];
scalar_t c2 = m[2][1];
scalar_t c3 = m[2][2];
scalar_t c4 = m[2][3];
scalar_t d1 = m[3][0];
scalar_t d2 = m[3][1];
scalar_t d3 = m[3][2];
scalar_t d4 = m[3][3];
return a1 * det3x3(b2, b3, b4, c2, c3, c4, d2, d3, d4) // Adjoint(x,y) = -1^(x+y) * a(y,x)
- b1 * det3x3(a2, a3, a4, c2, c3, c4, d2, d3, d4) // Where a(i,j) is the 3x3 determinant of m with row i and col j removed
+ c1 * det3x3(a2, a3, a4, b2, b3, b4, d2, d3, d4) matrix4x4 retVal;
- d1 * det3x3(a2, a3, a4, b2, b3, b4, c2, c3, c4); retVal(0)[0] = det3x3(b2, b3, b4, c2, c3, c4, d2, d3, d4);
retVal(0)[1] = -det3x3(a2, a3, a4, c2, c3, c4, d2, d3, d4);
retVal(0)[2] = det3x3(a2, a3, a4, b2, b3, b4, d2, d3, d4);
retVal(0)[3] = -det3x3(a2, a3, a4, b2, b3, b4, c2, c3, c4);
retVal(1)[0] = -det3x3(b1, b3, b4, c1, c3, c4, d1, d3, d4);
retVal(1)[1] = det3x3(a1, a3, a4, c1, c3, c4, d1, d3, d4);
retVal(1)[2] = -det3x3(a1, a3, a4, b1, b3, b4, d1, d3, d4);
retVal(1)[3] = det3x3(a1, a3, a4, b1, b3, b4, c1, c3, c4);
retVal(2)[0] = det3x3(b1, b2, b4, c1, c2, c4, d1, d2, d4);
retVal(2)[1] = -det3x3(a1, a2, a4, c1, c2, c4, d1, d2, d4);
retVal(2)[2] = det3x3(a1, a2, a4, b1, b2, b4, d1, d2, d4);
retVal(2)[3] = -det3x3(a1, a2, a4, b1, b2, b4, c1, c2, c4);
retVal(3)[0] = -det3x3(b1, b2, b3, c1, c2, c3, d1, d2, d3);
retVal(3)[1] = det3x3(a1, a2, a3, c1, c2, c3, d1, d2, d3);
retVal(3)[2] = -det3x3(a1, a2, a3, b1, b2, b3, d1, d2, d3);
retVal(3)[3] = det3x3(a1, a2, a3, b1, b2, b3, c1, c2, c3);
return retVal;
} }
matrix4x4 Adjoint (const matrix4x4& m) { matrix4x4 Inverse(const matrix4x4 &m)
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 b1 = m[1][0]; scalar_t b2 = m[1][1]; scalar_t b3 = m[1][2]; scalar_t b4 = m[1][3]; matrix4x4 retVal = Adjoint(m);
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 det = Determinant(m);
scalar_t d1 = m[3][0]; scalar_t d2 = m[3][1]; scalar_t d3 = m[3][2]; scalar_t d4 = m[3][3]; assert(det);
// Adjoint(x,y) = -1^(x+y) * a(y,x) for (int i = 0; i < 4; ++i)
// Where a(i,j) is the 3x3 determinant of m with row i and col j removed {
matrix4x4 retVal; for (int j = 0; j < 4; ++j)
retVal(0)[0] = det3x3(b2, b3, b4, c2, c3, c4, d2, d3, d4); {
retVal(0)[1] = -det3x3(a2, a3, a4, c2, c3, c4, d2, d3, d4); retVal(i)[j] /= det;
retVal(0)[2] = det3x3(a2, a3, a4, b2, b3, b4, d2, d3, d4); }
retVal(0)[3] = -det3x3(a2, a3, a4, b2, b3, b4, c2, c3, c4); }
retVal(1)[0] = -det3x3(b1, b3, b4, c1, c3, c4, d1, d3, d4);
retVal(1)[1] = det3x3(a1, a3, a4, c1, c3, c4, d1, d3, d4);
retVal(1)[2] = -det3x3(a1, a3, a4, b1, b3, b4, d1, d3, d4);
retVal(1)[3] = det3x3(a1, a3, a4, b1, b3, b4, c1, c3, c4);
retVal(2)[0] = det3x3(b1, b2, b4, c1, c2, c4, d1, d2, d4);
retVal(2)[1] = -det3x3(a1, a2, a4, c1, c2, c4, d1, d2, d4);
retVal(2)[2] = det3x3(a1, a2, a4, b1, b2, b4, d1, d2, d4);
retVal(2)[3] = -det3x3(a1, a2, a4, b1, b2, b4, c1, c2, c4);
retVal(3)[0] = -det3x3(b1, b2, b3, c1, c2, c3, d1, d2, d3);
retVal(3)[1] = det3x3(a1, a2, a3, c1, c2, c3, d1, d2, d3);
retVal(3)[2] = -det3x3(a1, a2, a3, b1, b2, b3, d1, d2, d3);
retVal(3)[3] = det3x3(a1, a2, a3, b1, b2, b3, c1, c2, c3);
return retVal;
}
matrix4x4 Inverse (const matrix4x4& m) { return retVal;
matrix4x4 retVal = Adjoint(m);
scalar_t det = Determinant(m);
assert(det);
for (int i=0;i<4;++i) {
for (int j=0;j<4;++j) {
retVal(i)[j] /= det;
}
}
return retVal;
} }
} }
//************************************** //**************************************
// Testing from here on. // Testing from here on.
//************************************** //**************************************
@@ -123,240 +147,255 @@ 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; {
if (passed) cout << className;
cout << " passed test "; if (passed)
else { cout << " passed test ";
cout << " FAILED test "; else
++failures; {
} cout << " FAILED test ";
cout << testName << "." << endl; ++failures;
}
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 {
vector3 defaultCtorTest; // Default ctor... just make sure it compiles
vector3 defaultCtorTest;
// Initializer ctor test (3 param)
vector3 initCtorTest(1, 2, 3);
ReportFailure (vector3Name, "initialized ctor (3 parameter version)", (initCtorTest[0] == 1 && initCtorTest[1] == 2 && initCtorTest[2] == 3 && initCtorTest[3] == 1));
// Initializer ctor test (4 param)
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));
scalar_t initArray[] = { 1, 2, 3, 4}; // Initializer ctor test (3 param)
vector3 initCtorArrayTest3 (initArray); vector3 initCtorTest(1, 2, 3);
ReportFailure (vector3Name, "array initialized ctor (3 parameter version)", (initCtorArrayTest3[0] == 1 && initCtorArrayTest3[1] == 2 && initCtorArrayTest3[2] == 3 && initCtorArrayTest3[3] == 1)); ReportFailure(vector3Name, "initialized ctor (3 parameter version)",
(initCtorTest[0] == 1 && initCtorTest[1] == 2 && initCtorTest[2] == 3 &&
initCtorTest[3] == 1));
vector3 initCtorArrayTest4 (initArray, 4); // Initializer ctor test (4 param)
ReportFailure (vector3Name, "array initialized ctor (4 parameter version)", (initCtorArrayTest4[0] == 1 && initCtorArrayTest4[1] == 2 && initCtorArrayTest4[2] == 3 && initCtorArrayTest4[3] == 4)); vector3 initCtorTest2(1, 2, 3, 4);
ReportFailure(vector3Name, "initialized ctor (4 parameter version)",
// Copy ctor test (initCtorTest2[0] == 1 && initCtorTest2[1] == 2 && initCtorTest2[2] == 3 &&
vector3 copyCtorTest(initCtorTest2); initCtorTest2[3] == 4));
ReportFailure (vector3Name, "copy ctor", (copyCtorTest[0] == 1 && copyCtorTest[1] == 2 && copyCtorTest[2] == 3 && copyCtorTest[3] == 4));
scalar_t initArray[] = {1, 2, 3, 4};
vector3 initCtorArrayTest3(initArray);
ReportFailure(vector3Name, "array initialized ctor (3 parameter version)",
(initCtorArrayTest3[0] == 1 && initCtorArrayTest3[1] == 2 &&
initCtorArrayTest3[2] == 3 && initCtorArrayTest3[3] == 1));
vector3 initCtorArrayTest4(initArray, 4);
ReportFailure(vector3Name, "array initialized ctor (4 parameter version)",
(initCtorArrayTest4[0] == 1 && initCtorArrayTest4[1] == 2 &&
initCtorArrayTest4[2] == 3 && initCtorArrayTest4[3] == 4));
// Copy ctor test
vector3 copyCtorTest(initCtorTest2);
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 beta(alpha); vector3 alpha(1, 1, 1);
vector3 gamma(2,3,4); vector3 beta(alpha);
vector3 gamma(2, 3, 4);
ReportFailure (vector3Name, "equivalence operator test 1", (alpha==beta));
ReportFailure (vector3Name, "equivalence operator test 2", (!(alpha == gamma))); ReportFailure(vector3Name, "equivalence operator test 1", (alpha == beta));
ReportFailure (vector3Name, "comparison operator test 1", !(alpha < beta)); ReportFailure(vector3Name, "equivalence operator test 2", (!(alpha == gamma)));
ReportFailure (vector3Name, "comparison operator test 2", (alpha < gamma)); ReportFailure(vector3Name, "comparison operator test 1", !(alpha < beta));
ReportFailure (vector3Name, "comparison operator test 3", !(gamma < beta)); ReportFailure(vector3Name, "comparison operator test 2", (alpha < gamma));
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);
alpha = beta; vector3 beta(10, 10, 10, 10);
ReportFailure (vector3Name, "assignment operator", (alpha == beta)); 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);
alpha = -alpha; vector3 beta(-10, -10, -10, -10);
ReportFailure(vector3Name, "negation operator", (alpha==beta)); alpha = -alpha;
ReportFailure(vector3Name, "negation operator", (alpha == beta));
ReportFailure(vector3Name, "length squared 3 element version", LengthSquared3(alpha) == 300);
ReportFailure(vector3Name, "length 3 element version", Length3(alpha) == SQRT_FUNCTION(300)); ReportFailure(vector3Name, "length squared 3 element version", LengthSquared3(alpha) == 300);
ReportFailure(vector3Name, "length squared 4 element version", LengthSquared4(alpha) == 400); ReportFailure(vector3Name, "length 3 element version", Length3(alpha) == SQRT_FUNCTION(300));
ReportFailure(vector3Name, "length 4 element version", Length4(alpha) == SQRT_FUNCTION(400)); ReportFailure(vector3Name, "length squared 4 element version", LengthSquared4(alpha) == 400);
ReportFailure(vector3Name, "length 4 element version", Length4(alpha) == SQRT_FUNCTION(400));
// Manually normalize beta
// Done without /= on vector3, as we want to be independant of failure of /= // Manually normalize beta
// Earlier failures should be resolved before later ones (just like C++) // Done without /= on vector3, as we want to be independant of failure of /=
beta = alpha; // Earlier failures should be resolved before later ones (just like C++)
for (int i=0;i<3;++i) beta(i) /= SQRT_FUNCTION(300); beta = alpha;
beta(3) = 1; for (int i = 0; i < 3; ++i)
ReportFailure(vector3Name, "normalize 3 element version", Normalize3(alpha) == beta); beta(i) /= SQRT_FUNCTION(300);
beta(3) = 1;
beta = alpha; ReportFailure(vector3Name, "normalize 3 element version", Normalize3(alpha) == beta);
for (int i=0;i<4;++i) beta(i) /= SQRT_FUNCTION(400);
ReportFailure(vector3Name, "normalize 4 element version", Normalize4(alpha) == beta); beta = alpha;
for (int i = 0; i < 4; ++i)
beta(i) /= SQRT_FUNCTION(400);
ReportFailure(vector3Name, "normalize 4 element version", Normalize4(alpha) == beta);
} }
void Testvector3BinaryOps (void) { void Testvector3BinaryOps(void)
// Vector * Matrix is tested in Testmatrix4x4BinaryOps {
vector3 testVec(1,1,1,1); // Vector * Matrix is tested in Testmatrix4x4BinaryOps
vector3 deltaVec(1,2,3,4); vector3 testVec(1, 1, 1, 1);
vector3 crossVec(1, -2, 1, 1); // testVec x deltaVec vector3 deltaVec(1, 2, 3, 4);
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 2", (10 * testVec) == factorVec);
testVec2 = testVec;
ReportFailure(vector3Name, "scalar multiply and store", (testVec2 *= 10) == factorVec);
ReportFailure(vector3Name, "scalar divide", (factorVec / 10) == testVec);
testVec2 = factorVec;
ReportFailure(vector3Name, "scalar divide and store", (testVec2 /= 10) == testVec);
ReportFailure(vector3Name, "vector addition", (testVec + deltaVec) == sumVec);
testVec2 = testVec;
ReportFailure(vector3Name, "vector addition and store", (testVec2 += deltaVec) == sumVec);
ReportFailure(vector3Name, "vector subtraction", (testVec - deltaVec) == difVec);
testVec2 = testVec;
ReportFailure(vector3Name, "vector subtraction and store", (testVec2 -= deltaVec) == difVec);
ReportFailure(vector3Name, "3 element dot product", 6 == DotProduct3(testVec, deltaVec));
ReportFailure(vector3Name, "4 element dot product", 10 == DotProduct4(testVec, deltaVec));
ReportFailure(vector3Name, "cross product", crossVec == CrossProduct(testVec, deltaVec)); ReportFailure(vector3Name, "scalar multiply 1", (testVec * 10) == factorVec);
ReportFailure(vector3Name, "scalar multiply 2", (10 * testVec) == factorVec);
testVec2 = testVec;
ReportFailure(vector3Name, "scalar multiply and store", (testVec2 *= 10) == factorVec);
ReportFailure(vector3Name, "scalar divide", (factorVec / 10) == testVec);
testVec2 = factorVec;
ReportFailure(vector3Name, "scalar divide and store", (testVec2 /= 10) == testVec);
ReportFailure(vector3Name, "vector addition", (testVec + deltaVec) == sumVec);
testVec2 = testVec;
ReportFailure(vector3Name, "vector addition and store", (testVec2 += deltaVec) == sumVec);
ReportFailure(vector3Name, "vector subtraction", (testVec - deltaVec) == difVec);
testVec2 = testVec;
ReportFailure(vector3Name, "vector subtraction and store", (testVec2 -= deltaVec) == difVec);
ReportFailure(vector3Name, "3 element dot product", 6 == DotProduct3(testVec, deltaVec));
ReportFailure(vector3Name, "4 element dot product", 10 == DotProduct4(testVec, deltaVec));
ReportFailure(vector3Name, "cross product", crossVec == CrossProduct(testVec, deltaVec));
} }
void Testvector3 (void) { void Testvector3(void)
// Accessors cannot be tested effectively... {
// They are really trivial, and so don't really need testing, // Accessors cannot be tested effectively...
// but more importantly, how do you test the ctors without assuming // They are really trivial, and so don't really need testing,
// the accessors work? Conversely, how do you test the acccessors // but more importantly, how do you test the ctors without assuming
// without assuming the ctors work? Chicken and egg problem, and I // the accessors work? Conversely, how do you test the acccessors
// decided on testing the ctors, not the accessors. // without assuming the ctors work? Chicken and egg problem, and I
Testvector3Constructors(); // decided on testing the ctors, not the accessors.
Testvector3Comparison(); Testvector3Constructors();
Testvector3Assignment(); Testvector3Comparison();
Testvector3UnaryOps(); Testvector3Assignment();
Testvector3BinaryOps(); Testvector3UnaryOps();
Testvector3BinaryOps();
} }
void Testmatrix4x4Constructors (void) { void Testmatrix4x4Constructors(void)
// Check if default ctor compiles {
matrix4x4 defaultTest; // Check if default ctor compiles
matrix4x4 defaultTest;
scalar_t initArray[] = { 0, 1, 2, 3,
4, 5, 6, 7,
8, 9, 10, 11,
12, 13, 14, 15 };
matrix4x4 arrayTest;
arrayTest.C_Matrix(initArray);
bool passedTest = true;
for (int x=0;x<4;++x) for (int y=0;y<4;++y)
if (arrayTest[x][y] != initArray[(y<<2) + x]) passedTest = false;
ReportFailure(matrix4x4Name, "array constructor", passedTest);
matrix4x4 copyTest(arrayTest); scalar_t initArray[] = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15};
passedTest = true; matrix4x4 arrayTest;
for (int x=0;x<4;++x) for (int y=0;y<4;++y) arrayTest.C_Matrix(initArray);
if (arrayTest[x][y] != copyTest[x][y]) passedTest = false; bool passedTest = true;
ReportFailure(matrix4x4Name, "copy constructor", passedTest); for (int x = 0; x < 4; ++x)
for (int y = 0; y < 4; ++y)
if (arrayTest[x][y] != initArray[(y << 2) + x])
passedTest = false;
ReportFailure(matrix4x4Name, "array constructor", passedTest);
matrix4x4 copyTest(arrayTest);
passedTest = true;
for (int x = 0; x < 4; ++x)
for (int y = 0; y < 4; ++y)
if (arrayTest[x][y] != copyTest[x][y])
passedTest = false;
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 }; matrix4x4 alpha, beta, gamma;
scalar_t initArray2[] = { 1, 1, 1, 1, alpha.C_Matrix(initArray);
1, 1, 1, 1, beta.C_Matrix(initArray);
1, 1, 1, 1, gamma.C_Matrix(initArray2);
1, 1, 1, 1 };
matrix4x4 alpha, beta, gamma; ReportFailure(matrix4x4Name, "equality test 1", alpha == beta);
alpha.C_Matrix(initArray); ReportFailure(matrix4x4Name, "equality test 2", !(alpha == gamma));
beta.C_Matrix(initArray); ReportFailure(matrix4x4Name, "comparison test 1", alpha < gamma);
gamma.C_Matrix(initArray2); ReportFailure(matrix4x4Name, "comparison test 2", !(gamma < alpha));
ReportFailure(matrix4x4Name, "comparison test 3", !(alpha < beta));
ReportFailure(matrix4x4Name, "equality test 1", alpha == beta);
ReportFailure(matrix4x4Name, "equality test 2", !(alpha == gamma));
ReportFailure(matrix4x4Name, "comparison test 1", alpha < gamma);
ReportFailure(matrix4x4Name, "comparison test 2", !(gamma < alpha));
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, vector3 vector1(initVector, 4);
0 * 8 + 1 * 9 + 2 * 10 + 3 * 11, matrix4x4 matrix1;
0 * 12 + 1 * 13 + 2 * 14 + 3 * 15 }; matrix1.C_Matrix(initMatrix);
vector3 vectorTest(resultVector, 4);
vector3 vector1 (initVector, 4); ReportFailure(matrix4x4Name, "matrix * vector", vectorTest == matrix1 * vector1);
matrix4x4 matrix1;
matrix1.C_Matrix(initMatrix); scalar_t initMatrix2[] = {15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0};
vector3 vectorTest (resultVector, 4);
ReportFailure (matrix4x4Name, "matrix * vector", vectorTest == matrix1 * vector1); matrix4x4 matrix2;
matrix2.C_Matrix(initMatrix2);
scalar_t initMatrix2[] = { 15, 14, 13, 12, matrix4x4 resultMatrix;
11, 10, 9, 8, for (int x = 0; x < 4; ++x)
7, 6, 5, 4, for (int y = 0; y < 4; ++y)
3, 2, 1, 0 }; {
resultMatrix(x)[y] = 0;
matrix4x4 matrix2; for (int i = 0; i < 4; ++i)
matrix2.C_Matrix(initMatrix2); resultMatrix(x)[y] += matrix1[i][y] * matrix2[x][i];
matrix4x4 resultMatrix; }
for (int x=0;x<4;++x) for (int y=0;y<4;++y) { ReportFailure(matrix4x4Name, "matrix * matrix", resultMatrix == matrix1 * matrix2);
resultMatrix(x)[y] = 0;
for (int i=0;i<4;++i) resultMatrix(x)[y] += matrix1[i][y] * matrix2[x][i];
}
ReportFailure (matrix4x4Name, "matrix * matrix", resultMatrix == matrix1 * matrix2);
} }
void Testmatrix4x4 (void) { void Testmatrix4x4(void)
Testmatrix4x4Constructors(); {
Testmatrix4x4Comparison(); Testmatrix4x4Constructors();
Testmatrix4x4BinaryOps(); Testmatrix4x4Comparison();
Testmatrix4x4BinaryOps();
} }
int main (int, char*[]) { int main(int, char *[])
int vectorFailures = 0; {
int matrixFailures = 0; int vectorFailures = 0;
Testvector3(); int matrixFailures = 0;
vectorFailures = failures; Testvector3();
failures = 0; vectorFailures = failures;
failures = 0;
Testmatrix4x4();
matrixFailures = failures;
cout << endl << "****************************************" << endl; Testmatrix4x4();
cout << "* *" << endl; matrixFailures = failures;
if (vectorFailures + matrixFailures == 0)
cout << "* No failures detected in Math3D *" << endl;
else {
cout << "* FAILURES DETECTED IN MATH3D! *" << endl;
cout << "* Total vector3 failures: " << vectorFailures << " *" << endl;
cout << "* Total matrix4x4 failures: " << matrixFailures << " *" << endl;
cout << "* Total Failures in Math3D: " << vectorFailures + matrixFailures << " *" << endl;
}
cout << "* *" << endl;
cout << "****************************************" << endl;
return 0; cout << endl << "****************************************" << endl;
cout << "* *" << endl;
if (vectorFailures + matrixFailures == 0)
cout << "* No failures detected in Math3D *" << endl;
else
{
cout << "* FAILURES DETECTED IN MATH3D! *" << endl;
cout << "* Total vector3 failures: " << vectorFailures << " *" << endl;
cout << "* Total matrix4x4 failures: " << matrixFailures << " *" << endl;
cout << "* Total Failures in Math3D: " << vectorFailures + matrixFailures << " *"
<< endl;
}
cout << "* *" << endl;
cout << "****************************************" << endl;
return 0;
} }
#endif #endif

845
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,396 +62,478 @@ 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 true; return false;
}; if (fabs(y - v->y) > 0.02)
return false;
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)
// [] is to read, () is to write (const correctness) (*this)(x)[y] = initArray[i++];
// m[x][y] or m(x)[y] is the correct form }
const scalar_t* operator[] (int i) const { return &e[i<<2]; } void OpenGL_Matrix(scalar_t *initArray)
scalar_t* operator() (int i) { return &e[i<<2]; } {
int i = 0;
// Low-level access to the array. for (int x = 0; x < 4; ++x)
const scalar_t* readArray (void) { return e; } for (int y = 0; y < 4; ++y)
scalar_t* getArray(void) { return e; } (*this)(x)[y] = initArray[i++];
}
// Construct various matrices; REPLACES CURRENT CONTENTS OF THE MATRIX! // [] is to read, () is to write (const correctness)
// Written this way to work in-place and hence be somewhat more efficient // m[x][y] or m(x)[y] is the correct form
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; } const scalar_t *operator[](int i) const { return &e[i << 2]; }
inline matrix4x4& Rotation (scalar_t angle, vector3 axis); scalar_t *operator()(int i) { return &e[i << 2]; }
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()
{//taka specjalna rotacja, nie ma co ci¹gaæ trygonometrii
double f;
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
}
};
inline bool IdentityIs()
{//sprawdzenie jednostkowoœci
for (int i=0;i<16;++i)
if (e[i]!=((i%5)?0.0:1.0)) //jedynki tylko na 0, 5, 10 i 15
return false;
return true;
}
private: // Low-level access to the array.
scalar_t e[16]; const scalar_t *readArray(void) { return e; }
scalar_t *getArray(void) { return e; }
// Construct various matrices; REPLACES CURRENT CONTENTS OF THE MATRIX!
// 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;
}
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()
{ // taka specjalna rotacja, nie ma co ci¹gaæ trygonometrii
double f;
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
}
};
inline bool IdentityIs()
{ // sprawdzenie jednostkowoœci
for (int i = 0; i < 16; ++i)
if (e[i] != ((i % 5) ? 0.0 : 1.0)) // jedynki tylko na 0, 5, 10 i 15
return false;
return true;
}
private:
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) {
if (b == 0) return false;
*x1 = c / b;
*x2 = *x1;
return true;
} else {
scalar_t det = b * b - 4 * a * c;
if (det < 0) return false;
det = SQRT_FUNCTION(det) / (2 * a);
scalar_t prefix = -b / (2*a);
*x1 = prefix + det;
*x2 = prefix - det;
return true;
}
}
inline bool operator== (const vector3& v1, const vector3& v2)
{ return (v1.x==v2.x&&v1.y==v2.y&&v1.z==v2.z); }
inline bool operator< (const vector3& v1, const vector3& v2) {
// for (int i=0;i<4;++i)
// if (v1[i] < v2[i]) return true;
// else if (v1[i] > v2[i]) return false;
return false;
}
inline vector3 operator- (const vector3& v)
{ return vector3(-v.x, -v.y, -v.z); }
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); // If a == 0, solve a linear equation
vector3 retVal; if (a == 0)
if (l==0) {
retVal.x=retVal.y=retVal.z=0; if (b == 0)
else return false;
retVal=v/l; *x1 = c / b;
return retVal; *x2 = *x1;
} return true;
inline vector3 Normalize4 (const vector3& v) }
{ return v / Length4(v); } else
{
inline vector3 operator+ (const vector3& v1, const vector3& v2) scalar_t det = b * b - 4 * a * c;
{ return vector3(v1.x+v2.x, v1.y+v2.y, v1.z+v2.z); } if (det < 0)
return false;
inline vector3& operator+= (vector3& v1, const vector3& v2) det = SQRT_FUNCTION(det) / (2 * a);
{ v1.x+= v2.x; v1.y+= v2.y; v1.z+= v2.z; return v1;} scalar_t prefix = -b / (2 * a);
*x1 = prefix + det;
inline vector3 operator- (const vector3& v1, const vector3& v2) *x2 = prefix - det;
{ return vector3(v1.x-v2.x, v1.y-v2.y, v1.z-v2.z); } return true;
}
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 bool operator==(const 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], return (v1.x == v2.x && v1.y == v2.y && v1.z == v2.z);
v.x*m[0][2] + v.y*m[1][2] + v.z*m[2][2] + m[3][2]); }
inline bool operator<(const vector3 &v1, const vector3 &v2)
{
// for (int i=0;i<4;++i)
// if (v1[i] < v2[i]) return true;
// else if (v1[i] > v2[i]) return false;
return false;
}
inline vector3 operator-(const vector3 &v) { return vector3(-v.x, -v.y, -v.z); }
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);
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)
{
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)
{
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])
return false;
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 false;
return true;
}
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;
else if (m1[x][y] > m2[x][y]) return false;
return false;
}
inline matrix4x4 operator* (const matrix4x4& m1, const matrix4x4& m2) {
matrix4x4 retVal;
for (int x=0;x<4;++x) for (int y=0;y<4;++y) {
retVal(x)[y] = 0;
for (int i=0;i<4;++i) retVal(x)[y] += m1[i][y] * m2[x][i];
}
return retVal;
}
inline matrix4x4 Transpose (const matrix4x4& m) {
matrix4x4 retVal;
for (int x=0;x<4;++x) for (int y=0;y<4;++y)
retVal(x)[y] = m[y][x];
return retVal;
}
inline matrix4x4& matrix4x4::Rotation (scalar_t angle, vector3 axis) {
scalar_t c = COSINE_FUNCTION(angle);
scalar_t s = SINE_FUNCTION(angle);
// One minus c (short name for legibility of formulai)
scalar_t omc = (1 - c);
if (LengthSquared3(axis) != 1) axis = Normalize(axis);
scalar_t x = axis.x;
scalar_t y = axis.y;
scalar_t z = axis.z;
scalar_t xs = x * s;
scalar_t ys = y * s;
scalar_t zs = z * s;
scalar_t xyomc = x * y * omc;
scalar_t xzomc = x * z * omc;
scalar_t yzomc = y * z * omc;
e[0] = x*x*omc + c;
e[1] = xyomc + zs;
e[2] = xzomc - ys;
e[3] = 0;
e[4] = xyomc - zs;
e[5] = y*y*omc + c;
e[6] = yzomc + xs;
e[7] = 0;
e[8] = xzomc + ys;
e[9] = yzomc - xs;
e[10] = z*z*omc + c;
e[11] = 0;
e[12] = 0;
e[13] = 0;
e[14] = 0;
e[15] = 1;
return *this;
}
inline matrix4x4& matrix4x4::Translation(const vector3& translation) {
Identity();
e[12] = translation.x;
e[13] = translation.y;
e[14] = translation.z;
return *this;
}
inline matrix4x4& matrix4x4::Scale (scalar_t x, scalar_t y, scalar_t z) {
Identity();
e[0] = x;
e[5] = y;
e[10] = z;
return *this;
}
inline matrix4x4& matrix4x4::BasisChange (const vector3& u, const vector3& v, const vector3& n) {
e[0] = u.x;
e[1] = v.x;
e[2] = n.x;
e[3] = 0;
e[4] = u.y;
e[5] = v.y;
e[6] = n.y;
e[7] = 0;
e[8] = u.z;
e[9] = v.z;
e[10] = n.z;
e[11] = 0;
e[12] = 0;
e[13] = 0;
e[14] = 0;
e[15] = 1;
return *this;
}
inline matrix4x4& matrix4x4::BasisChange (const vector3& v, const vector3& 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,
scalar_t top_plane, scalar_t bottom_plane,
scalar_t near_plane, scalar_t far_plane)
{ {
scalar_t A = (right_plane + left_plane) / (right_plane - left_plane); for (int x = 0; x < 4; ++x)
scalar_t B = (top_plane + bottom_plane) / (top_plane - bottom_plane); for (int y = 0; y < 4; ++y)
scalar_t C = (far_plane + near_plane) / (far_plane - near_plane); if (m1[x][y] < m2[x][y])
return true;
Identity(); else if (m1[x][y] > m2[x][y])
if (perspective) { return false;
e[0] = 2 * near_plane / (right_plane - left_plane); return false;
e[5] = 2 * near_plane / (top_plane - bottom_plane);
e[8] = A;
e[9] = B;
e[10] = C;
e[11] = -1;
e[14] = 2 * far_plane * near_plane / (far_plane - near_plane);
} else {
e[0] = 2 / (right_plane - left_plane);
e[5] = 2 / (top_plane - bottom_plane);
e[10] = -2 / (far_plane - near_plane);
e[12] = A;
e[13] = B;
e[14] = C;
}
return *this;
} }
double inline __fastcall SquareMagnitude(const vector3& v) inline matrix4x4 operator*(const matrix4x4 &m1, const matrix4x4 &m2)
{ {
return v.x*v.x+v.y*v.y+v.z*v.z; matrix4x4 retVal;
for (int x = 0; x < 4; ++x)
for (int y = 0; y < 4; ++y)
{
retVal(x)[y] = 0;
for (int i = 0; i < 4; ++i)
retVal(x)[y] += m1[i][y] * m2[x][i];
}
return retVal;
}
inline matrix4x4 Transpose(const matrix4x4 &m)
{
matrix4x4 retVal;
for (int x = 0; x < 4; ++x)
for (int y = 0; y < 4; ++y)
retVal(x)[y] = m[y][x];
return retVal;
}
inline matrix4x4 &matrix4x4::Rotation(scalar_t angle, vector3 axis)
{
scalar_t c = COSINE_FUNCTION(angle);
scalar_t s = SINE_FUNCTION(angle);
// One minus c (short name for legibility of formulai)
scalar_t omc = (1 - c);
if (LengthSquared3(axis) != 1)
axis = Normalize(axis);
scalar_t x = axis.x;
scalar_t y = axis.y;
scalar_t z = axis.z;
scalar_t xs = x * s;
scalar_t ys = y * s;
scalar_t zs = z * s;
scalar_t xyomc = x * y * omc;
scalar_t xzomc = x * z * omc;
scalar_t yzomc = y * z * omc;
e[0] = x * x * omc + c;
e[1] = xyomc + zs;
e[2] = xzomc - ys;
e[3] = 0;
e[4] = xyomc - zs;
e[5] = y * y * omc + c;
e[6] = yzomc + xs;
e[7] = 0;
e[8] = xzomc + ys;
e[9] = yzomc - xs;
e[10] = z * z * omc + c;
e[11] = 0;
e[12] = 0;
e[13] = 0;
e[14] = 0;
e[15] = 1;
return *this;
}
inline matrix4x4 &matrix4x4::Translation(const vector3 &translation)
{
Identity();
e[12] = translation.x;
e[13] = translation.y;
e[14] = translation.z;
return *this;
}
inline matrix4x4 &matrix4x4::Scale(scalar_t x, scalar_t y, scalar_t z)
{
Identity();
e[0] = x;
e[5] = y;
e[10] = z;
return *this;
}
inline matrix4x4 &matrix4x4::BasisChange(const vector3 &u, const vector3 &v, const vector3 &n)
{
e[0] = u.x;
e[1] = v.x;
e[2] = n.x;
e[3] = 0;
e[4] = u.y;
e[5] = v.y;
e[6] = n.y;
e[7] = 0;
e[8] = u.z;
e[9] = v.z;
e[10] = n.z;
e[11] = 0;
e[12] = 0;
e[13] = 0;
e[14] = 0;
e[15] = 1;
return *this;
}
inline matrix4x4 &matrix4x4::BasisChange(const vector3 &v, const vector3 &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, scalar_t top_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 B = (top_plane + bottom_plane) / (top_plane - bottom_plane);
scalar_t C = (far_plane + near_plane) / (far_plane - near_plane);
Identity();
if (perspective)
{
e[0] = 2 * near_plane / (right_plane - left_plane);
e[5] = 2 * near_plane / (top_plane - bottom_plane);
e[8] = A;
e[9] = B;
e[10] = C;
e[11] = -1;
e[14] = 2 * far_plane * near_plane / (far_plane - near_plane);
}
else
{
e[0] = 2 / (right_plane - left_plane);
e[5] = 2 / (top_plane - bottom_plane);
e[10] = -2 / (far_plane - near_plane);
e[12] = A;
e[13] = B;
e[14] = C;
}
return *this;
}
double inline __fastcall SquareMagnitude(const vector3 &v)
{
return v.x * v.x + v.y * v.y + v.z * v.z;
} }
} // close namespace } // close namespace
@@ -454,22 +546,25 @@ 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 << '['; {
for (int i=0; i<4; ++i) os << '[';
os << ' ' << v[i]; for (int i = 0; i < 4; ++i)
return os << ']'; os << ' ' << v[i];
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) { {
os << '['; for (int y = 0; y < 4; ++y)
for (int x=0;x<4;++x) {
os << ' ' << m[x][y]; os << '[';
os << " ]" << std::endl; for (int x = 0; x < 4; ++x)
} os << ' ' << m[x][y];
return os; os << " ]" << std::endl;
}
return os;
} }
#endif // OSTREAM_MATH3D #endif // OSTREAM_MATH3D
#endif #endif

88
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)

8
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,17 +24,17 @@ public:
class TPlane class TPlane
{ {
public: public:
vector3 Vector; vector3 Vector;
double d; double d;
__fastcall TPlane(); __fastcall TPlane();
__fastcall TPlane(vector3 NVector, double nd); __fastcall TPlane(vector3 NVector, double nd);
__fastcall TPlane(vector3 NPoint, vector3 NVector); __fastcall TPlane(vector3 NPoint, vector3 NVector);
__fastcall TPlane(vector3 Point1, vector3 Vector1, vector3 Vector2); __fastcall TPlane(vector3 Point1, vector3 Vector1, vector3 Vector2);
__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();
}; };

311
parser.cpp
View File

@@ -10,185 +10,192 @@
*/ */
///////////////////////////////////////////////////////////////////////////////////////////////////// /////////////////////////////////////////////////////////////////////////////////////////////////////
// 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;
mComments.clear(); if (mStream)
delete mStream;
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 pos = token.find("(p");
if (pos!=std::string::npos) //!=npos to znalezione // 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 {
token.erase(pos,token.find(")",pos)-pos+1); //najpierw usuniêcie "(pN)" std::string parameter =
size_t nr=atoi(parameter.c_str())-1; token.substr(pos + 2, token.find(")", pos) - pos + 2); // numer parametru
if (nr<parameters.size()) token.erase(pos, token.find(")", pos) - pos + 1); // najpierw usuniêcie "(pN)"
{token.insert(pos,parameters.at(nr)); //wklejenie wartoœci parametru size_t nr = atoi(parameter.c_str()) - 1;
if (ToLower) if (nr < parameters.size())
for (;pos<token.length();++pos) {
token[pos]=tolower(token[pos]); token.insert(pos, parameters.at(nr)); // wklejenie wartoœci parametru
if (ToLower)
for (; pos < token.length(); ++pos)
token[pos] = tolower(token[pos]);
}
else
token.insert(pos, "none"); // zabezpieczenie przed brakiem parametru
}
return token;
}
else
{
delete mIncludeParser;
mIncludeParser = NULL;
parameters.clear();
}
} }
else // get the token yourself if there's no child to delegate it to.
token.insert(pos,"none"); //zabezpieczenie przed brakiem parametru char c;
} do
return token; {
} while (mStream->peek() != EOF && strchr(Break, c = mStream->get()) == NULL)
else {
{delete mIncludeParser; if (ToLower)
mIncludeParser=NULL; c = tolower(c);
parameters.clear(); token += c;
} if (trimComments(token)) // don't glue together words separated with comment
} break;
// get the token yourself if there's no child to delegate it to. }
char c; } while (token == "" && mStream->peek() != EOF); // double check to deal with trailing spaces
do // launch child parser if include directive found.
{while (mStream->peek()!=EOF&& strchr( Break, c = mStream->get() ) == NULL) // NOTE: parameter collecting uses default set of token separators.
{ if (token.compare("include") == 0)
if (ToLower) c=tolower(c); { // obs³uga include
token+=c; std::string includefile = readToken(ToLower); // nazwa pliku
if (trimComments(token)) // don't glue together words separated with comment if (LoadTraction ? true : ((includefile.find("tr/") == std::string::npos) &&
break; (includefile.find("tra/") == std::string::npos)))
} {
} while (token=="" && mStream->peek()!=EOF); // double check to deal with trailing spaces // std::string trtest2="niemaproblema"; //nazwa odporna na znalezienie "tr/"
// launch child parser if include directive found. // if (trtest=="x") //jeœli nie wczytywaæ drutów
// NOTE: parameter collecting uses default set of token separators. // trtest2=includefile; //kopiowanie œcie¿ki do pliku
if (token.compare("include")==0) std::string parameter = readToken(false); // w parametrach nie zmniejszamy
{//obs³uga include while (parameter.compare("end") != 0)
std::string includefile=readToken(ToLower); //nazwa pliku {
if (LoadTraction?true:((includefile.find("tr/")==std::string::npos)&&(includefile.find("tra/")==std::string::npos))) parameters.push_back(parameter);
{ parameter = readToken(ToLower);
//std::string trtest2="niemaproblema"; //nazwa odporna na znalezienie "tr/" }
//if (trtest=="x") //jeœli nie wczytywaæ drutów // if (trtest2.find("tr/")!=0)
//trtest2=includefile; //kopiowanie œcie¿ki do pliku mIncludeParser = new cParser(includefile, buffer_FILE, mPath, LoadTraction);
std::string parameter=readToken(false); //w parametrach nie zmniejszamy if (mIncludeParser->mSize <= 0)
while (parameter.compare("end")!=0) ErrorLog("Missed include: " + AnsiString(includefile.c_str()));
{ }
parameters.push_back(parameter); else
parameter=readToken(ToLower); while (token.compare("end") != 0)
} token = readToken(ToLower);
//if (trtest2.find("tr/")!=0) token = readToken(ToLower, Break);
mIncludeParser=new cParser(includefile,buffer_FILE,mPath,LoadTraction); }
if (mIncludeParser->mSize<=0) return token;
ErrorLog("Missed include: "+AnsiString(includefile.c_str()));
}
else
while (token.compare("end")!=0)
token=readToken(ToLower);
token=readToken(ToLower,Break);
}
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));
return true; return true;
} }
} }
return false; return false;
} }
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;
} }
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;
} }

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

79
sky.cpp
View File

@@ -1,65 +1,58 @@
//--------------------------------------------------------------------------- //---------------------------------------------------------------------------
#include "system.hpp" #include "system.hpp"
#include "classes.hpp" #include "classes.hpp"
#pragma hdrstop #pragma hdrstop
#include "sky.h" #include "sky.h"
#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);
if (Global::bUseVBO) glLightfv(GL_LIGHT0, GL_POSITION, lightPos);
{//renderowanie z VBO if (Global::bUseVBO)
mdCloud->RaRender(100,0); { // renderowanie z VBO
mdCloud->RaRenderAlpha(100,0); mdCloud->RaRender(100, 0);
} mdCloud->RaRenderAlpha(100, 0);
else }
{//renderowanie z Display List else
mdCloud->Render(100,0); { // renderowanie z Display List
mdCloud->RenderAlpha(100,0); mdCloud->Render(100, 0);
} mdCloud->RenderAlpha(100, 0);
//glEnable(GL_DEPTH_TEST); }
glClear(GL_DEPTH_BUFFER_BIT); // glEnable(GL_DEPTH_TEST);
//glEnable(GL_LIGHTING); glClear(GL_DEPTH_BUFFER_BIT);
glPopMatrix(); // glEnable(GL_LIGHTING);
glLightfv(GL_LIGHT0,GL_POSITION,Global::lightPos); glPopMatrix();
} glLightfv(GL_LIGHT0, GL_POSITION, Global::lightPos);
}
}; };
//--------------------------------------------------------------------------- //---------------------------------------------------------------------------
#pragma package(smart_init) #pragma package(smart_init)

15
sky.h
View File

@@ -7,13 +7,14 @@
class TSky class TSky
{ {
private: private:
TModel3d *mdCloud; TModel3d *mdCloud;
public:
__fastcall TSky(); public:
__fastcall ~TSky(); __fastcall TSky();
void __fastcall Init(); __fastcall ~TSky();
void __fastcall Render(); void __fastcall Init();
void __fastcall Render();
}; };
//--------------------------------------------------------------------------- //---------------------------------------------------------------------------

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

183
wavread.cpp
View File

@@ -1,7 +1,7 @@
//----------------------------------------------------------------------------- //-----------------------------------------------------------------------------
// File: WavRead.cpp // File: WavRead.cpp
// //
// Desc: Wave file support for loading and playing Wave files using DirectSound // Desc: Wave file support for loading and playing Wave files using DirectSound
// buffers. // buffers.
// //
// Copyright (c) 1999 Microsoft Corp. All rights reserved. // Copyright (c) 1999 Microsoft Corp. All rights reserved.
@@ -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,88 +141,73 @@ 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
// the data chunk before calling this function. // the data chunk before calling this function.
// hmmioIn - Handle to mmio. // hmmioIn - Handle to mmio.
// cbRead - # of bytes to read. // cbRead - # of bytes to read.
// 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;
} }

33
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