Set dp branch as trunk

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