mirror of
https://github.com/MaSzyna-EU07/maszyna.git
synced 2026-03-22 15:05:03 +01:00
403 lines
16 KiB
C++
403 lines
16 KiB
C++
//---------------------------------------------------------------------------
|
|
#ifndef Model3dH
|
|
#define Model3dH
|
|
|
|
#include "opengl/glew.h"
|
|
#include "Parser.h"
|
|
#include "dumb3d.h"
|
|
using namespace Math3D;
|
|
#include "Float3d.h"
|
|
#include "VBO.h"
|
|
|
|
struct GLVERTEX
|
|
{
|
|
vector3 Point;
|
|
vector3 Normal;
|
|
float tu, tv;
|
|
};
|
|
|
|
class TStringPack
|
|
{
|
|
char *data;
|
|
//+0 - 4 bajty: typ kromki
|
|
//+4 - 4 bajty: długość łącznie z nagłówkiem
|
|
//+8 - obszar łańcuchów znakowych, każdy zakończony zerem
|
|
int *index;
|
|
//+0 - 4 bajty: typ kromki
|
|
//+4 - 4 bajty: długość łącznie z nagłówkiem
|
|
//+8 - tabela indeksów
|
|
public:
|
|
char *String(int n);
|
|
char *StringAt(int n) { return data + 9 + n; };
|
|
__fastcall TStringPack()
|
|
{
|
|
data = NULL;
|
|
index = NULL;
|
|
};
|
|
void __fastcall Init(char *d) { data = d; };
|
|
void __fastcall InitIndex(int *i) { index = i; };
|
|
};
|
|
|
|
class TMaterialColor
|
|
{
|
|
public:
|
|
__fastcall TMaterialColor(){};
|
|
__fastcall TMaterialColor(char V) { r = g = b = V; };
|
|
// __fastcall TMaterialColor(double R, double G, double B)
|
|
__fastcall TMaterialColor(char R, char G, char B)
|
|
{
|
|
r = R;
|
|
g = G;
|
|
b = B;
|
|
};
|
|
|
|
char r, g, b;
|
|
};
|
|
|
|
/*
|
|
struct TMaterial
|
|
{
|
|
int ID;
|
|
AnsiString Name;
|
|
//McZapkie-240702: lepiej uzywac wartosci float do opisu koloru bo funkcje opengl chyba tego na ogol
|
|
uzywaja
|
|
float Ambient[4];
|
|
float Diffuse[4];
|
|
float Specular[4];
|
|
float Transparency;
|
|
GLuint TextureID;
|
|
};
|
|
*/
|
|
/*
|
|
struct THitBoxContainer
|
|
{
|
|
TPlane Planes[6];
|
|
int Index;
|
|
inline void __fastcall Reset() { Planes[0]= TPlane(vector3(0,0,0),0.0f); };
|
|
inline bool __fastcall Inside(vector3 Point)
|
|
{
|
|
bool Hit= true;
|
|
|
|
if (Planes[0].Defined())
|
|
for (int i=0; i<6; i++)
|
|
{
|
|
if (Planes[i].GetSide(Point)>0)
|
|
{
|
|
Hit= false;
|
|
break;
|
|
};
|
|
|
|
}
|
|
else return(false);
|
|
return(Hit);
|
|
};
|
|
};
|
|
*/
|
|
|
|
/* Ra: tego nie będziemy już używać, bo można wycisnąć więcej
|
|
typedef enum
|
|
{smt_Unknown, //nieznany
|
|
smt_Mesh, //siatka
|
|
smt_Point,
|
|
smt_FreeSpotLight, //punkt świetlny
|
|
smt_Text, //generator tekstu
|
|
smt_Stars //wiele punktów świetlnych
|
|
} TSubModelType;
|
|
*/
|
|
// Ra: specjalne typy submodeli, poza tym GL_TRIANGLES itp.
|
|
const int TP_ROTATOR = 256;
|
|
const int TP_FREESPOTLIGHT = 257;
|
|
const int TP_STARS = 258;
|
|
const int TP_TEXT = 259;
|
|
|
|
enum TAnimType // rodzaj animacji
|
|
{
|
|
at_None, // brak
|
|
at_Rotate, // obrót względem wektora o kąt
|
|
at_RotateXYZ, // obrót względem osi o kąty
|
|
at_Translate, // przesunięcie
|
|
at_SecondsJump, // sekundy z przeskokiem
|
|
at_MinutesJump, // minuty z przeskokiem
|
|
at_HoursJump, // godziny z przeskokiem 12h/360°
|
|
at_Hours24Jump, // godziny z przeskokiem 24h/360°
|
|
at_Seconds, // sekundy płynnie
|
|
at_Minutes, // minuty płynnie
|
|
at_Hours, // godziny płynnie 12h/360°
|
|
at_Hours24, // godziny płynnie 24h/360°
|
|
at_Billboard, // obrót w pionie do kamery
|
|
at_Wind, // ruch pod wpływem wiatru
|
|
at_Sky, // animacja nieba
|
|
at_IK = 0x100, // odwrotna kinematyka - submodel sterujący (np. staw skokowy)
|
|
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_IK22 = 0x103, // odwrotna kinematyka - submodel nadrzędny do nadrzędnego sterowango (np. udo)
|
|
at_Digital = 0x200, // dziesięciocyfrowy licznik mechaniczny (z cylindrami)
|
|
at_DigiClk = 0x201, // zegar cyfrowy jako licznik na dziesięciościanach
|
|
at_Undefined = 0x800000FF // animacja chwilowo nieokreślona
|
|
};
|
|
|
|
class TModel3d;
|
|
class TSubModelInfo;
|
|
|
|
class TSubModel
|
|
{ // 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: nie przestawiać zmiennych, bo wczytują się z pliku binarnego!
|
|
private:
|
|
TSubModel *Next;
|
|
TSubModel *Child;
|
|
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
|
|
public: // chwilowo
|
|
TAnimType b_Anim;
|
|
|
|
private:
|
|
int iFlags; // flagi informacyjne:
|
|
// bit 0: =1 faza rysowania zależy od wymiennej tekstury 0
|
|
// bit 1: =1 faza rysowania zależy od wymiennej tekstury 1
|
|
// bit 2: =1 faza rysowania zależy od wymiennej tekstury 2
|
|
// bit 3: =1 faza rysowania zależy od wymiennej tekstury 3
|
|
// bit 4: =1 rysowany w fazie nieprzezroczystych (stała tekstura albo brak)
|
|
// bit 5: =1 rysowany w fazie przezroczystych (stała tekstura)
|
|
// bit 7: =1 ta sama tekstura, co poprzedni albo nadrzędny
|
|
// bit 8: =1 wierzchołki wyświetlane z indeksów
|
|
// 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 14: =1 wymagane przechowanie macierzy (animacje)
|
|
// bit 15: =1 wymagane przechowanie macierzy (transform niejedynkowy)
|
|
union
|
|
{ // transform, nie każdy submodel musi mieć
|
|
float4x4 *fMatrix; // pojedyncza precyzja wystarcza
|
|
// 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 iTexture; // numer nazwy tekstury, -1 wymienna, 0 brak
|
|
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 f4Ambient[4];
|
|
float f4Diffuse[4]; // float ze względu na glMaterialfv()
|
|
float f4Specular[4];
|
|
float f4Emision[4];
|
|
float fWireSize; // nie używane, ale wczytywane
|
|
float fSquareMaxDist;
|
|
float fSquareMinDist;
|
|
// McZapkie-050702: parametry dla swiatla:
|
|
float fNearAttenStart;
|
|
float fNearAttenEnd;
|
|
int bUseNearAtten; // te 3 zmienne okreslaja rysowanie aureoli wokol zrodla swiatla
|
|
int iFarAttenDecay; // ta zmienna okresla typ zaniku natezenia swiatla (0:brak, 1,2: potega 1/R)
|
|
float fFarDecayRadius; // normalizacja j.w.
|
|
float fCosFalloffAngle; // cosinus kąta stożka pod którym widać światło
|
|
float fCosHotspotAngle; // cosinus kąta stożka pod którym widać aureolę i zwiększone natężenie
|
|
// światła
|
|
float fCosViewAngle; // cos kata pod jakim sie teraz patrzy
|
|
// Ra: dalej są zmienne robocze, można je przestawiać z zachowaniem rozmiaru klasy
|
|
int TextureID; // numer tekstury, -1 wymienna, 0 brak
|
|
int bWire; // nie używane, ale wczytywane
|
|
// short TexAlpha; //Ra: nie używane już
|
|
GLuint uiDisplayList; // roboczy numer listy wyświetlania
|
|
float Opacity; // nie używane, ale wczytywane
|
|
// ABu: te same zmienne, ale zdublowane dla Render i RenderAlpha,
|
|
// bo sie chrzanilo przemieszczanie obiektow.
|
|
// Ra: już się nie chrzani
|
|
float f_Angle;
|
|
float3 v_RotateAxis;
|
|
float3 v_Angles;
|
|
|
|
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 __fastcall SeekFaceNormal(DWORD *Masks, int f,DWORD dwMask,vector3 *pt,GLVERTEX
|
|
// *Vertices);
|
|
int __fastcall SeekFaceNormal(DWORD *Masks, int f, DWORD dwMask, float3 *pt, float8 *Vertices);
|
|
void __fastcall RaAnimation(TAnimType a);
|
|
|
|
public:
|
|
static int iInstance; // identyfikator egzemplarza, który aktualnie renderuje model
|
|
static GLuint *ReplacableSkinId;
|
|
static int iAlpha; // maska bitowa dla danego przebiegu
|
|
static double fSquareDist;
|
|
static TModel3d *pRoot;
|
|
static AnsiString *pasText; // tekst dla wyświetlacza (!!!! do przemyślenia)
|
|
__fastcall TSubModel();
|
|
__fastcall ~TSubModel();
|
|
void __fastcall FirstInit();
|
|
int __fastcall Load(cParser &Parser, TModel3d *Model, int Pos, bool dynamic);
|
|
void __fastcall ChildAdd(TSubModel *SubModel);
|
|
void __fastcall NextAdd(TSubModel *SubModel);
|
|
TSubModel *__fastcall NextGet() { return Next; };
|
|
TSubModel *__fastcall ChildGet() { return Child; };
|
|
int __fastcall TriangleAdd(TModel3d *m, int tex, int tri);
|
|
float8 *__fastcall TrianglePtr(int tex, int pos, int *la, int *ld, int *ls);
|
|
// float8* __fastcall TrianglePtr(const char *tex,int tri);
|
|
// void __fastcall SetRotate(vector3 vNewRotateAxis,float fNewAngle);
|
|
void __fastcall SetRotate(float3 vNewRotateAxis, float fNewAngle);
|
|
void __fastcall SetRotateXYZ(vector3 vNewAngles);
|
|
void __fastcall SetRotateXYZ(float3 vNewAngles);
|
|
void __fastcall SetTranslate(vector3 vNewTransVector);
|
|
void __fastcall SetTranslate(float3 vNewTransVector);
|
|
void __fastcall SetRotateIK1(float3 vNewAngles);
|
|
TSubModel *__fastcall GetFromName(AnsiString search, bool i = true);
|
|
TSubModel *__fastcall GetFromName(char *search, bool i = true);
|
|
void __fastcall RenderDL();
|
|
void __fastcall RenderAlphaDL();
|
|
void __fastcall RenderVBO();
|
|
void __fastcall RenderAlphaVBO();
|
|
// inline matrix4x4* __fastcall GetMatrix() {return dMatrix;};
|
|
inline float4x4 *__fastcall GetMatrix() { return fMatrix; };
|
|
// matrix4x4* __fastcall GetTransform() {return Matrix;};
|
|
inline void __fastcall Hide() { iVisible = 0; };
|
|
void __fastcall RaArrayFill(CVertNormTex *Vert);
|
|
// void __fastcall Render();
|
|
int __fastcall FlagsCheck();
|
|
void __fastcall WillBeAnimated()
|
|
{
|
|
if (this)
|
|
iFlags |= 0x4000;
|
|
};
|
|
void __fastcall InitialRotate(bool doit);
|
|
void __fastcall DisplayLists();
|
|
void __fastcall Info();
|
|
void __fastcall InfoSet(TSubModelInfo *info);
|
|
void __fastcall BinInit(TSubModel *s, float4x4 *m, float8 *v, TStringPack *t,
|
|
TStringPack *n = NULL, bool dynamic = false);
|
|
void __fastcall ReplacableSet(GLuint *r, int a)
|
|
{
|
|
ReplacableSkinId = r;
|
|
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
|
|
{ // klasa z informacjami o submodelach, do tworzenia pliku binarnego
|
|
public:
|
|
TSubModel *pSubModel; // wskaźnik na submodel
|
|
int iTransform; // numer transformu (-1 gdy brak)
|
|
int iName; // numer nazwy
|
|
int iTexture; // numer tekstury
|
|
int iNameLen; // długość nazwy
|
|
int iTextureLen; // długość tekstury
|
|
int iNext, iChild; // numer następnego i potomnego
|
|
static int iTotalTransforms; // ilość transformów
|
|
static int iTotalNames; // ilość nazw
|
|
static int iTotalTextures; // ilość tekstur
|
|
static int iCurrent; // aktualny obiekt
|
|
static TSubModelInfo *pTable; // tabele obiektów pomocniczych
|
|
__fastcall TSubModelInfo()
|
|
{
|
|
pSubModel = NULL;
|
|
iTransform = iName = iTexture = iNext = iChild = -1; // nie ma
|
|
iNameLen = iTextureLen = 0;
|
|
}
|
|
void __fastcall Reset()
|
|
{
|
|
pTable = this; // ustawienie wskaźnika tabeli obiektów
|
|
iTotalTransforms = iTotalNames = iTotalTextures = iCurrent = 0; // zerowanie liczników
|
|
}
|
|
__fastcall ~TSubModelInfo(){};
|
|
};
|
|
|
|
class TModel3d : public CMesh
|
|
{
|
|
private:
|
|
// TMaterial *Materials;
|
|
// int MaterialsCount; //Ra: nie używane
|
|
// bool TractionPart; //Ra: nie używane
|
|
TSubModel *Root; // drzewo submodeli
|
|
int iFlags; // Ra: czy submodele mają przezroczyste tekstury
|
|
public: // Ra: tymczasowo
|
|
int iNumVerts; // ilość wierzchołków (gdy nie ma VBO, to m_nVertexCount=0)
|
|
private:
|
|
TStringPack Textures; // nazwy tekstur
|
|
TStringPack Names; // nazwy submodeli
|
|
int *iModel; // zawartość pliku binarnego
|
|
int iSubModelsCount; // Ra: używane do tworzenia binarnych
|
|
AnsiString asBinary; // nazwa pod którą zapisać model binarny
|
|
public:
|
|
inline TSubModel *__fastcall GetSMRoot() { return (Root); };
|
|
// double Radius; //Ra: nie używane
|
|
__fastcall TModel3d();
|
|
__fastcall TModel3d(char *FileName);
|
|
__fastcall ~TModel3d();
|
|
TSubModel *__fastcall GetFromName(const char *sName);
|
|
// TMaterial* __fastcall GetMaterialFromName(char *sName);
|
|
TSubModel *__fastcall AddToNamed(const char *Name, TSubModel *SubModel);
|
|
void __fastcall AddTo(TSubModel *tmp, TSubModel *SubModel);
|
|
void __fastcall LoadFromTextFile(char *FileName, bool dynamic);
|
|
void __fastcall LoadFromBinFile(char *FileName, bool dynamic);
|
|
bool __fastcall LoadFromFile(char *FileName, bool dynamic);
|
|
void __fastcall SaveToBinFile(char *FileName);
|
|
void __fastcall BreakHierarhy();
|
|
// renderowanie specjalne
|
|
void __fastcall Render(double fSquareDistance, GLuint *ReplacableSkinId = NULL,
|
|
int iAlpha = 0x30300030);
|
|
void __fastcall RenderAlpha(double fSquareDistance, GLuint *ReplacableSkinId = NULL,
|
|
int iAlpha = 0x30300030);
|
|
void __fastcall RaRender(double fSquareDistance, GLuint *ReplacableSkinId = NULL,
|
|
int iAlpha = 0x30300030);
|
|
void __fastcall RaRenderAlpha(double fSquareDistance, GLuint *ReplacableSkinId = NULL,
|
|
int iAlpha = 0x30300030);
|
|
// jeden kąt obrotu
|
|
void __fastcall Render(vector3 pPosition, double fAngle = 0, GLuint *ReplacableSkinId = NULL,
|
|
int iAlpha = 0x30300030);
|
|
void __fastcall RenderAlpha(vector3 pPosition, double fAngle = 0,
|
|
GLuint *ReplacableSkinId = NULL, int iAlpha = 0x30300030);
|
|
void __fastcall RaRender(vector3 pPosition, double fAngle = 0, GLuint *ReplacableSkinId = NULL,
|
|
int iAlpha = 0x30300030);
|
|
void __fastcall RaRenderAlpha(vector3 pPosition, double fAngle = 0,
|
|
GLuint *ReplacableSkinId = NULL, int iAlpha = 0x30300030);
|
|
// trzy kąty obrotu
|
|
void __fastcall Render(vector3 *vPosition, vector3 *vAngle, GLuint *ReplacableSkinId = NULL,
|
|
int iAlpha = 0x30300030);
|
|
void __fastcall RenderAlpha(vector3 *vPosition, vector3 *vAngle,
|
|
GLuint *ReplacableSkinId = NULL, int iAlpha = 0x30300030);
|
|
void __fastcall RaRender(vector3 *vPosition, vector3 *vAngle, GLuint *ReplacableSkinId = NULL,
|
|
int iAlpha = 0x30300030);
|
|
void __fastcall RaRenderAlpha(vector3 *vPosition, vector3 *vAngle,
|
|
GLuint *ReplacableSkinId = NULL, int iAlpha = 0x30300030);
|
|
// inline int __fastcall GetSubModelsCount() { return (SubModelsCount); };
|
|
int __fastcall Flags() { return iFlags; };
|
|
void __fastcall Init();
|
|
char *__fastcall NameGet() { return Root ? Root->pName : NULL; };
|
|
int __fastcall TerrainCount();
|
|
TSubModel *__fastcall TerrainSquare(int n);
|
|
void __fastcall TerrainRenderVBO(int n);
|
|
};
|
|
|
|
//---------------------------------------------------------------------------
|
|
#endif
|