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

coś było źle

Browse Source
This commit is contained in:
VB
2017-02-14 21:17:22 +01:00
parent 20f95c5f3b
commit 7c98a177da
2 changed files with 2405 additions and 2420 deletions
Download Patch File Download Diff File Expand all files Collapse all files

4084
Model3d.cpp
View File

File diff suppressed because it is too large Load Diff

741
Model3d.h
View File

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