eu07/maszyna
1
0
Fork 0
mirror of https://github.com/MaSzyna-EU07/maszyna.git synced 2026-03-22 15:05:03 +01:00
Code Issues Packages Projects Releases Wiki Activity
Files
91c96bedbfff3d80a655b520235e890a530a1e73
maszyna/Model3d.cpp
Zbigniew Mandziejewicz cb19354db4 Format source code using clang-format
2015-04-03 22:01:10 +08:00

2284 lines
94 KiB
C++
Raw Blame History

//---------------------------------------------------------------------------
/*
MaSzyna EU07 locomotive simulator
Copyright (C) 2001-2004 Marcin Wozniak, Maciej Czapkiewicz and others
*/
#include "system.hpp"
#include "classes.hpp"
#pragma hdrstop
#include "Model3d.h"
#include "Usefull.h"
#include "Texture.h"
#include "logs.h"
#include "Globals.h"
#include "Timer.h"
#include "mtable.hpp"
//---------------------------------------------------------------------------
#pragma package(smart_init)
double TSubModel::fSquareDist = 0;
int TSubModel::iInstance; // numer renderowanego egzemplarza obiektu
GLuint *TSubModel::ReplacableSkinId = NULL;
int TSubModel::iAlpha = 0x30300030; // maska do testowania flag tekstur wymiennych
TModel3d *TSubModel::pRoot; // Ra: tymczasowo wskaŸnik na model widoczny z submodelu
AnsiString *TSubModel::pasText;
// przyk³ady dla TSubModel::iAlpha:
// 0x30300030 - wszystkie bez kana³u alfa
// 0x31310031 - tekstura -1 u¿ywana w danym cyklu, pozosta³e nie
// 0x32320032 - tekstura -2 u¿ywana w danym cyklu, pozosta³e nie
// 0x34340034 - tekstura -3 u¿ywana w danym cyklu, pozosta³e nie
// 0x38380038 - tekstura -4 u¿ywana w danym cyklu, pozosta³e nie
// 0x3F3F003F - wszystkie wymienne tekstury u¿ywane w danym cyklu
// Ale w TModel3d okerœla przezroczystoœæ tekstur wymiennych!
int TSubModelInfo::iTotalTransforms = 0; // iloœæ transformów
int TSubModelInfo::iTotalNames = 0; // d³ugoœæ obszaru nazw
int TSubModelInfo::iTotalTextures = 0; // d³ugoœæ obszaru tekstur
int TSubModelInfo::iCurrent = 0; // aktualny obiekt
TSubModelInfo *TSubModelInfo::pTable = NULL; // tabele obiektów pomocniczych
char *TStringPack::String(int n)
{ // zwraca wskaŸnik do ³añcucha o podanym numerze
if (index ? n < (index[1] >> 2) - 2 : false)
return data + 8 + index[n + 2]; // indeks upraszcza kwestiê wyszukiwania
// jak nie ma indeksu, to trzeba szukaæ
int max = *((int *)(data + 4)); // d³ugoœæ obszaru ³añcuchów
char *ptr = data + 8; // pocz¹ek obszaru ³añcuchów
for (int i = 0; i < n; ++i)
{ // wyszukiwanie ³añcuchów nie jest zbyt optymalne, ale nie musi byæ
while (*ptr)
++ptr; // wyszukiwanie zera
++ptr; // pominiêcie zera
if (ptr > data + max)
return NULL; // zbyt wysoki numer
}
return ptr;
};
__fastcall TSubModel::TSubModel()
{
ZeroMemory(this, sizeof(TSubModel)); // istotne przy zapisywaniu wersji binarnej
FirstInit();
};
void __fastcall TSubModel::FirstInit()
{
eType = TP_ROTATOR;
Vertices = NULL;
uiDisplayList = 0;
iNumVerts = -1; // do sprawdzenia
iVboPtr = -1;
fLight = -1.0; //œwietcenie wy³¹czone
v_RotateAxis = float3(0, 0, 0);
v_TransVector = float3(0, 0, 0);
f_Angle = 0;
b_Anim = at_None;
b_aAnim = at_None;
fVisible = 0.0; // zawsze widoczne
iVisible = 1;
fMatrix = NULL; // to samo co iMatrix=0;
Next = NULL;
Child = NULL;
TextureID = 0;
// TexAlpha=false;
iFlags = 0x0200; // bit 9=1: submodel zosta³ utworzony a nie ustawiony na wczytany plik
// TexHash=false;
// Hits=NULL;
// CollisionPts=NULL;
// CollisionPtsCount=0;
Opacity = 1.0; // przy wczytywaniu modeli by³o dzielone przez 100...
bWire = false;
fWireSize = 0;
fNearAttenStart = 40;
fNearAttenEnd = 80;
bUseNearAtten = false;
iFarAttenDecay = 0;
fFarDecayRadius = 100;
fCosFalloffAngle = 0.5; // 120°?
fCosHotspotAngle = 0.3; // 145°?
fCosViewAngle = 0;
fSquareMaxDist = 10000 * 10000; // 10km
fSquareMinDist = 0;
iName = -1; // brak nazwy
iTexture = 0; // brak tekstury
// asName="";
// asTexture="";
pName = pTexture = NULL;
f4Ambient[0] = f4Ambient[1] = f4Ambient[2] = f4Ambient[3] = 1.0; //{1,1,1,1};
f4Diffuse[0] = f4Diffuse[1] = f4Diffuse[2] = f4Diffuse[3] = 1.0; //{1,1,1,1};
f4Specular[0] = f4Specular[1] = f4Specular[2] = 0.0;
f4Specular[3] = 1.0; //{0,0,0,1};
f4Emision[0] = f4Emision[1] = f4Emision[2] = f4Emision[3] = 1.0;
smLetter = NULL; // u¿ywany tylko roboczo dla TP_TEXT, do przyspieszenia wyœwietlania
};
__fastcall TSubModel::~TSubModel()
{
if (uiDisplayList)
glDeleteLists(uiDisplayList, 1);
if (iFlags & 0x0200)
{ // wczytany z pliku tekstowego musi sam posprz¹taæ
// SafeDeleteArray(Indices);
SafeDelete(Next);
SafeDelete(Child);
delete fMatrix; // w³asny transform trzeba usun¹æ (zawsze jeden)
delete[] Vertices;
delete[] pTexture;
delete[] pName;
}
/*
else
{//wczytano z pliku binarnego (nie jest w³aœcicielem tablic)
}
*/
delete[] smLetter; // u¿ywany tylko roboczo dla TP_TEXT, do przyspieszenia wyœwietlania
};
void __fastcall TSubModel::TextureNameSet(const char *n)
{ // ustawienie nazwy submodelu, o ile nie jest wczytany z E3D
if (iFlags & 0x0200)
{ // tylko je¿eli submodel zosta utworzony przez new
delete[] pTexture; // usuniêcie poprzedniej
int i = strlen(n);
if (i)
{ // utworzenie nowej
pTexture = new char[i + 1];
strcpy(pTexture, n);
}
else
pTexture = NULL;
}
};
void __fastcall TSubModel::NameSet(const char *n)
{ // ustawienie nazwy submodelu, o ile nie jest wczytany z E3D
if (iFlags & 0x0200)
{ // tylko je¿eli submodel zosta utworzony przez new
delete[] pName; // usuniêcie poprzedniej
int i = strlen(n);
if (i)
{ // utworzenie nowej
pName = new char[i + 1];
strcpy(pName, n);
}
else
pName = NULL;
}
};
// int __fastcall TSubModel::SeekFaceNormal(DWORD *Masks, int f,DWORD dwMask,vector3 *pt,GLVERTEX
// *Vertices)
int __fastcall TSubModel::SeekFaceNormal(DWORD *Masks, int f, DWORD dwMask, float3 *pt,
float8 *Vertices)
{ // szukanie punktu stycznego do (pt), zwraca numer wierzcho³ka, a nie trójk¹ta
int iNumFaces = iNumVerts / 3; // bo maska powierzchni jest jedna na trójk¹t
// GLVERTEX *p; //roboczy wskaŸnik
float8 *p; // roboczy wskaŸnik
for (int i = f; i < iNumFaces; ++i) // pêtla po trójk¹tach, od trójk¹ta (f)
if (Masks[i] & dwMask) // jeœli wspólna maska powierzchni
{
p = Vertices + 3 * i;
if (p->Point == *pt)
return 3 * i;
if ((++p)->Point == *pt)
return 3 * i + 1;
if ((++p)->Point == *pt)
return 3 * i + 2;
}
return -1; // nie znaleziono stycznego wierzcho³ka
}
float emm1[] = {1, 1, 1, 0};
float emm2[] = {0, 0, 0, 1};
inline double readIntAsDouble(cParser &parser, int base = 255)
{
int value;
parser.getToken(value);
return double(value) / base;
};
template <typename ColorT> inline void readColor(cParser &parser, ColorT *color)
{
parser.ignoreToken();
color[0] = readIntAsDouble(parser);
color[1] = readIntAsDouble(parser);
color[2] = readIntAsDouble(parser);
};
inline void readColor(cParser &parser, int &color)
{
int r, g, b;
parser.ignoreToken();
parser.getToken(r);
parser.getToken(g);
parser.getToken(b);
color = r + (g << 8) + (b << 16);
};
/*
inline void readMatrix(cParser& parser,matrix4x4& matrix)
{//Ra: wczytanie transforma
for (int x=0;x<=3;x++) //wiersze
for (int y=0;y<=3;y++) //kolumny
parser.getToken(matrix(x)[y]);
};
*/
inline void readMatrix(cParser &parser, float4x4 &matrix)
{ // Ra: wczytanie transforma
for (int x = 0; x <= 3; x++) // wiersze
for (int y = 0; y <= 3; y++) // kolumny
parser.getToken(matrix(x)[y]);
};
int __fastcall TSubModel::Load(cParser &parser, TModel3d *Model, int Pos, bool dynamic)
{ // Ra: VBO tworzone na poziomie modelu, a nie submodeli
iNumVerts = 0;
iVboPtr = Pos; // pozycja w VBO
// TMaterialColorf Ambient,Diffuse,Specular;
// GLuint TextureID;
// char *extName;
if (!parser.expectToken("type:"))
Error("Model type parse failure!");
{
std::string type;
parser.getToken(type);
if (type == "mesh")
eType = GL_TRIANGLES; // submodel - trójkaty
else if (type == "point")
eType = GL_POINTS; // co to niby jest?
else if (type == "freespotlight")
eType = TP_FREESPOTLIGHT; //œwiate³ko
else if (type == "text")
eType = TP_TEXT; // wyœwietlacz tekstowy (generator napisów)
else if (type == "stars")
eType = TP_STARS; // wiele punktów œwietlnych
};
parser.ignoreToken();
std::string token;
// parser.getToken(token1); //ze zmian¹ na ma³e!
parser.getTokens(1, false); // nazwa submodelu bez zmieny na ma³e
parser >> token;
NameSet(token.c_str());
if (dynamic)
{ // dla pojazdu, blokujemy za³¹czone submodele, które mog¹ byæ nieobs³ugiwane
if (token.find("_on") + 3 == token.length()) // jeœli nazwa koñczy siê na "_on"
iVisible = 0; // to domyœlnie wy³¹czyæ, ¿eby siê nie nak³ada³o z obiektem "_off"
}
else // dla pozosta³ych modeli blokujemy zapalone œwiat³a, które mog¹ byæ nieobs³ugiwane
if (token.find("Light_On") == 0) // jeœli nazwa zaczyna siê od "Light_On"
iVisible = 0; // to domyœlnie wy³¹czyæ, ¿eby siê nie nak³ada³o z obiektem "Light_Off"
if (parser.expectToken("anim:")) // Ra: ta informacja by siê przyda³a!
{ // rodzaj animacji
std::string type;
parser.getToken(type);
if (type != "false")
{
iFlags |= 0x4000; // jak animacja, to trzeba przechowywaæ macierz zawsze
if (type == "seconds_jump")
b_Anim = b_aAnim = at_SecondsJump; // sekundy z przeskokiem
else if (type == "minutes_jump")
b_Anim = b_aAnim = at_MinutesJump; // minuty z przeskokiem
else if (type == "hours_jump")
b_Anim = b_aAnim = at_HoursJump; // godziny z przeskokiem
else if (type == "hours24_jump")
b_Anim = b_aAnim = at_Hours24Jump; // godziny z przeskokiem
else if (type == "seconds")
b_Anim = b_aAnim = at_Seconds; // minuty p³ynnie
else if (type == "minutes")
b_Anim = b_aAnim = at_Minutes; // minuty p³ynnie
else if (type == "hours")
b_Anim = b_aAnim = at_Hours; // godziny p³ynnie
else if (type == "hours24")
b_Anim = b_aAnim = at_Hours24; // godziny p³ynnie
else if (type == "billboard")
b_Anim = b_aAnim = at_Billboard; // obrót w pionie do kamery
else if (type == "wind")
b_Anim = b_aAnim = at_Wind; // ruch pod wp³ywem wiatru
else if (type == "sky")
b_Anim = b_aAnim = at_Sky; // aniamacja nieba
else if (type == "ik")
b_Anim = b_aAnim = at_IK; // IK: zadaj¹cy
else if (type == "ik11")
b_Anim = b_aAnim = at_IK11; // IK: kierunkowany
else if (type == "ik21")
b_Anim = b_aAnim = at_IK21; // IK: kierunkowany
else if (type == "ik22")
b_Anim = b_aAnim = at_IK22; // IK: kierunkowany
else if (type == "digital")
b_Anim = b_aAnim = at_Digital; // licznik mechaniczny
else if (type == "digiclk")
b_Anim = b_aAnim = at_DigiClk; // zegar cyfrowy
else
b_Anim = b_aAnim = at_Undefined; // nieznana forma animacji
}
}
if (eType < TP_ROTATOR)
readColor(parser, f4Ambient); // ignoruje token przed
readColor(parser, f4Diffuse);
if (eType < TP_ROTATOR)
readColor(parser, f4Specular);
parser.ignoreTokens(1); // zignorowanie nazwy "SelfIllum:"
{
std::string light;
parser.getToken(light);
if (light == "true")
fLight = 2.0; // zawsze œwieci
else if (light == "false")
fLight = -1.0; // zawsze ciemy
else
fLight = atof(light.c_str());
};
if (eType == TP_FREESPOTLIGHT)
{
if (!parser.expectToken("nearattenstart:"))
Error("Model light parse failure!");
parser.getToken(fNearAttenStart);
parser.ignoreToken();
parser.getToken(fNearAttenEnd);
parser.ignoreToken();
bUseNearAtten = parser.expectToken("true");
parser.ignoreToken();
parser.getToken(iFarAttenDecay);
parser.ignoreToken();
parser.getToken(fFarDecayRadius);
parser.ignoreToken();
parser.getToken(fCosFalloffAngle); // k¹t liczony dla œrednicy, a nie promienia
fCosFalloffAngle = cos(DegToRad(0.5 * fCosFalloffAngle));
parser.ignoreToken();
parser.getToken(fCosHotspotAngle); // k¹t liczony dla œrednicy, a nie promienia
fCosHotspotAngle = cos(DegToRad(0.5 * fCosHotspotAngle));
iNumVerts = 1;
iFlags |= 0x4010; // rysowane w cyklu nieprzezroczystych, macierz musi zostaæ bez zmiany
}
else if (eType < TP_ROTATOR)
{
parser.ignoreToken();
bWire = parser.expectToken("true");
parser.ignoreToken();
parser.getToken(fWireSize);
parser.ignoreToken();
Opacity = readIntAsDouble(parser,
100.0f); // wymagane jest 0 dla szyb, 100 idzie w nieprzezroczyste
if (Opacity > 1.0)
Opacity *= 0.01; // w 2013 by³ b³¹d i aby go obejœæ, trzeba by³o wpisaæ 10000.0
if ((Global::iConvertModels & 1) == 0) // dla zgodnoœci wstecz
Opacity = 0.0; // wszystko idzie w przezroczyste albo zale¿nie od tekstury
if (!parser.expectToken("map:"))
Error("Model map parse failure!");
std::string texture;
parser.getToken(texture);
if (texture == "none")
{ // rysowanie podanym kolorem
TextureID = 0;
iFlags |= 0x10; // rysowane w cyklu nieprzezroczystych
}
else if (texture.find("replacableskin") != texture.npos)
{ // McZapkie-060702: zmienialne skory modelu
TextureID = -1;
iFlags |= (Opacity < 1.0) ? 1 : 0x10; // zmienna tekstura 1
}
else if (texture == "-1")
{
TextureID = -1;
iFlags |= (Opacity < 1.0) ? 1 : 0x10; // zmienna tekstura 1
}
else if (texture == "-2")
{
TextureID = -2;
iFlags |= (Opacity < 1.0) ? 2 : 0x10; // zmienna tekstura 2
}
else if (texture == "-3")
{
TextureID = -3;
iFlags |= (Opacity < 1.0) ? 4 : 0x10; // zmienna tekstura 3
}
else if (texture == "-4")
{
TextureID = -4;
iFlags |= (Opacity < 1.0) ? 8 : 0x10; // zmienna tekstura 4
}
else
{ // jeœli tylko nazwa pliku, to dawaæ bie¿¹c¹ œcie¿kê do tekstur
// asTexture=AnsiString(texture.c_str()); //zapamiêtanie nazwy tekstury
TextureNameSet(texture.c_str());
if (texture.find_first_of("/\\") == texture.npos)
texture.insert(0, Global::asCurrentTexturePath.c_str());
TextureID = TTexturesManager::GetTextureID(
szTexturePath, Global::asCurrentTexturePath.c_str(), texture);
// TexAlpha=TTexturesManager::GetAlpha(TextureID);
// iFlags|=TexAlpha?0x20:0x10; //0x10-nieprzezroczysta, 0x20-przezroczysta
if (Opacity < 1.0) // przezroczystoϾ z tekstury brana tylko dla Opacity 0!
iFlags |= TTexturesManager::GetAlpha(TextureID) ?
0x20 :
0x10; // 0x10-nieprzezroczysta, 0x20-przezroczysta
else
iFlags |= 0x10; // normalnie nieprzezroczyste
// renderowanie w cyklu przezroczystych tylko jeœli:
// 1. Opacity=0 (przejœciowo <1, czy tam <100) oraz
// 2. tekstura ma przezroczystoϾ
};
}
else
iFlags |= 0x10;
parser.ignoreToken();
parser.getToken(fSquareMaxDist);
if (fSquareMaxDist >= 0.0)
fSquareMaxDist *= fSquareMaxDist;
else
fSquareMaxDist = 15000 * 15000; // 15km to wiêcej, ni¿ siê obecnie wyœwietla
parser.ignoreToken();
parser.getToken(fSquareMinDist);
fSquareMinDist *= fSquareMinDist;
parser.ignoreToken();
fMatrix = new float4x4();
readMatrix(parser, *fMatrix); // wczytanie transform
if (!fMatrix->IdentityIs())
iFlags |= 0x8000; // transform niejedynkowy - trzeba go przechowaæ
int iNumFaces; // iloœæ trójk¹tów
DWORD *sg; // maski przynale¿noœci trójk¹tów do powierzchni
if (eType < TP_ROTATOR)
{ // wczytywanie wierzcho³ków
parser.ignoreToken();
// Ra 15-01: to wczytaæ jako tekst - jeœli pierwszy znak zawiera "*", to dalej bêdzie nazwa
// wczeœniejszego submodelu, z którego nale¿y wzi¹æ wierzcho³ki
// zapewni to jak¹œ zgodnoœæ wstecz, bo zamiast liczby bêdzie ci¹g, którego wartoœæ powinna
// byæ uznana jako zerowa
// parser.getToken(iNumVerts);
parser.getToken(token);
if (token[0] == '*')
{ // jeœli pierwszy znak jest gwiazdk¹, poszukaæ submodelu o nazwie bez tej gwiazdki i wzi¹æ
// z niego wierzcho³ki
Error("Verticles reference not yet supported!");
}
else
{ // normalna lista wierzcho³ków
iNumVerts = atoi(token.c_str());
if (iNumVerts % 3)
{
iNumVerts = 0;
Error("Mesh error, (iNumVertices=" + AnsiString(iNumVerts) + ")%3<>0");
return 0;
}
// Vertices=new GLVERTEX[iNumVerts];
if (iNumVerts)
{
Vertices = new float8[iNumVerts];
iNumFaces = iNumVerts / 3;
sg = new DWORD[iNumFaces]; // maski powierzchni: 0 oznacza brak u¿redniania wektorów
// normalnych
int *wsp = new int[iNumVerts]; // z którego wierzcho³ka kopiowaæ wektor normalny
int maska = 0;
for (int i = 0; i < iNumVerts; i++)
{ // Ra: z konwersj¹ na uk³ad scenerii - bêdzie wydajniejsze wyœwietlanie
wsp[i] = -1; // wektory normalne nie s¹ policzone dla tego wierzcho³ka
if ((i % 3) == 0)
{ // jeœli bêdzie maska -1, to dalej bêd¹ wierzcho³ki z wektorami normalnymi,
// podanymi jawnie
parser.getToken(maska); // maska powierzchni trójk¹ta
sg[i / 3] = (maska == -1) ? 0 : maska; // dla maski -1 bêdzie 0, czyli nie
// ma wspólnych wektorów normalnych
}
parser.getToken(Vertices[i].Point.x);
parser.getToken(Vertices[i].Point.y);
parser.getToken(Vertices[i].Point.z);
if (maska == -1)
{ // jeœli wektory normalne podane jawnie
parser.getToken(Vertices[i].Normal.x);
parser.getToken(Vertices[i].Normal.y);
parser.getToken(Vertices[i].Normal.z);
wsp[i] = i; // wektory normalne "s¹ ju¿ policzone"
}
parser.getToken(Vertices[i].tu);
parser.getToken(Vertices[i].tv);
if (i % 3 == 2) // je¿eli wczytano 3 punkty
{
if (Vertices[i].Point == Vertices[i - 1].Point ||
Vertices[i - 1].Point == Vertices[i - 2].Point ||
Vertices[i - 2].Point == Vertices[i].Point)
{ // je¿eli punkty siê nak³adaj¹ na siebie
--iNumFaces; // o jeden trójk¹t mniej
iNumVerts -= 3; // czyli o 3 wierzcho³ki
i -= 3; // wczytanie kolejnego w to miejsce
WriteLog(AnsiString("Degenerated triangle ignored in: \"") +
AnsiString(pName) + "\", verticle " + AnsiString(i));
}
if (i > 0) // jeœli pierwszy trójk¹t bêdzie zdegenerowany, to zostanie
// usuniêty i nie ma co sprawdzaæ
if (((Vertices[i].Point - Vertices[i - 1].Point).Length() > 1000.0) ||
((Vertices[i - 1].Point - Vertices[i - 2].Point).Length() >
1000.0) ||
((Vertices[i - 2].Point - Vertices[i].Point).Length() > 1000.0))
{ // je¿eli s¹ dalej ni¿ 2km od siebie //Ra 15-01: obiekt wstawiany nie
// powinien byæ wiêkszy ni¿ 300m (trójk¹ty terenu w E3D mog¹ mieæ
// 1.5km)
--iNumFaces; // o jeden trójk¹t mniej
iNumVerts -= 3; // czyli o 3 wierzcho³ki
i -= 3; // wczytanie kolejnego w to miejsce
WriteLog(AnsiString("Too large triangle ignored in: \"") +
AnsiString(pName) + "\"");
}
}
}
int i; // indeks dla trójk¹tów
float3 *n = new float3[iNumFaces]; // tablica wektorów normalnych dla trójk¹tów
for (i = 0; i < iNumFaces; i++) // pêtla po trójk¹tach - bêdzie szybciej, jak
// wstêpnie przeliczymy normalne trójk¹tów
n[i] = SafeNormalize(
CrossProduct(Vertices[i * 3].Point - Vertices[i * 3 + 1].Point,
Vertices[i * 3].Point - Vertices[i * 3 + 2].Point));
int v; // indeks dla wierzcho³ków
int f; // numer trójk¹ta stycznego
float3 norm; // roboczy wektor normalny
for (v = 0; v < iNumVerts; v++)
{ // pêtla po wierzcho³kach trójk¹tów
if (wsp[v] >=
0) // jeœli ju¿ by³ liczony wektor normalny z u¿yciem tego wierzcho³ka
Vertices[v].Normal =
Vertices[wsp[v]].Normal; // to wystarczy skopiowaæ policzony wczeœniej
else
{ // inaczej musimy dopiero policzyæ
i = v / 3; // numer trójk¹ta
norm = float3(0, 0, 0); // liczenie zaczynamy od zera
f = v; // zaczynamy dodawanie wektorów normalnych od w³asnego
while (f >= 0)
{ // sumowanie z wektorem normalnym s¹siada (w³¹cznie ze sob¹)
wsp[f] = v; // informacja, ¿e w tym wierzcho³ku jest ju¿ policzony
// wektor normalny
norm += n[f / 3];
f = SeekFaceNormal(sg, f / 3 + 1, sg[i], &Vertices[v].Point,
Vertices); // i szukanie od kolejnego trójk¹ta
}
// Ra 15-01: nale¿a³o by jeszcze uwzglêdniæ skalowanie wprowadzane przez
// transformy, aby normalne po przeskalowaniu by³y jednostkowe
Vertices[v].Normal =
SafeNormalize(norm); // przepisanie do wierzcho³ka trójk¹ta
}
}
delete[] wsp;
delete[] n;
delete[] sg;
}
else // gdy brak wierzcho³ków
{
eType = TP_ROTATOR; // submodel pomocniczy, ma tylko macierz przekszta³cenia
iVboPtr = iNumVerts = 0; // dla formalnoœci
}
} // obs³uga submodelu z w³asn¹ list¹ wierzcho³ków
}
else if (eType == TP_STARS)
{ // punkty œwiec¹ce dookólnie - sk³adnia jak dla smt_Mesh
parser.ignoreToken();
parser.getToken(iNumVerts);
// Vertices=new GLVERTEX[iNumVerts];
Vertices = new float8[iNumVerts];
int i, j;
for (i = 0; i < iNumVerts; i++)
{
if (i % 3 == 0)
parser.ignoreToken(); // maska powierzchni trójk¹ta
parser.getToken(Vertices[i].Point.x);
parser.getToken(Vertices[i].Point.y);
parser.getToken(Vertices[i].Point.z);
parser.getToken(j); // zakodowany kolor
parser.ignoreToken();
Vertices[i].Normal.x = ((j)&0xFF) / 255.0; // R
Vertices[i].Normal.y = ((j >> 8) & 0xFF) / 255.0; // G
Vertices[i].Normal.z = ((j >> 16) & 0xFF) / 255.0; // B
}
}
// Visible=true; //siê potem wy³¹czy w razie potrzeby
// iFlags|=0x0200; //wczytano z pliku tekstowego (jest w³aœcicielem tablic)
if (iNumVerts < 1)
iFlags &= ~0x3F; // cykl renderowania uzale¿niony od potomnych
return iNumVerts; // do okreœlenia wielkoœci VBO
};
int __fastcall TSubModel::TriangleAdd(TModel3d *m, int tex, int tri)
{ // dodanie trójk¹tów do submodelu, u¿ywane przy tworzeniu E3D terenu
TSubModel *s = this;
while (s ? (s->TextureID != tex) : false)
{ // szukanie submodelu o danej teksturze
if (s == this)
s = Child;
else
s = s->Next;
}
if (!s)
{
if (TextureID <= 0)
s = this; // u¿ycie g³ównego
else
{ // dodanie nowego submodelu do listy potomnych
s = new TSubModel();
m->AddTo(this, s);
}
// s->asTexture=AnsiString(TTexturesManager::GetName(tex).c_str());
s->TextureNameSet(TTexturesManager::GetName(tex).c_str());
s->TextureID = tex;
s->eType = GL_TRIANGLES;
// iAnimOwner=0; //roboczy wskaŸnik na wierzcho³ek
}
if (s->iNumVerts < 0)
s->iNumVerts = tri; // bo na pocz¹tku jest -1, czyli ¿e nie wiadomo
else
s->iNumVerts += tri; // aktualizacja iloœci wierzcho³ków
return s->iNumVerts - tri; // zwraca pozycjê tych trójk¹tów w submodelu
};
float8 *__fastcall TSubModel::TrianglePtr(int tex, int pos, int *la, int *ld, int *ls)
{ // zwraca wskaŸnik do wype³nienia tabeli wierzcho³ków, u¿ywane przy tworzeniu E3D terenu
TSubModel *s = this;
while (s ? s->TextureID != tex : false)
{ // szukanie submodelu o danej teksturze
if (s == this)
s = Child;
else
s = s->Next;
}
if (!s)
return NULL; // coœ nie tak posz³o
if (!s->Vertices)
{ // utworznie tabeli trójk¹tów
s->Vertices = new float8[s->iNumVerts];
// iVboPtr=pos; //pozycja submodelu w tabeli wierzcho³ków
// pos+=iNumVerts; //rezerwacja miejsca w tabeli
s->iVboPtr = iInstance; // pozycja submodelu w tabeli wierzcho³ków
iInstance += s->iNumVerts; // pozycja dla nastêpnego
}
s->ColorsSet(la, ld, ls); // ustawienie kolorów œwiate³
return s->Vertices + pos; // wskaŸnik na wolne miejsce w tabeli wierzcho³ków
};
void __fastcall TSubModel::DisplayLists()
{ // utworznie po jednej skompilowanej liœcie dla ka¿dego submodelu
if (Global::bUseVBO)
return; // Ra: przy VBO to siê nie przyda
// iFlags|=0x4000; //wy³¹czenie przeliczania wierzcho³ków, bo nie s¹ zachowane
if (eType < TP_ROTATOR)
{
if (iNumVerts > 0)
{
uiDisplayList = glGenLists(1);
glNewList(uiDisplayList, GL_COMPILE);
glColor3fv(f4Diffuse); // McZapkie-240702: zamiast ub
#ifdef USE_VERTEX_ARRAYS
// ShaXbee-121209: przekazywanie wierzcholkow hurtem
glVertexPointer(3, GL_DOUBLE, sizeof(GLVERTEX), &Vertices[0].Point.x);
glNormalPointer(GL_DOUBLE, sizeof(GLVERTEX), &Vertices[0].Normal.x);
glTexCoordPointer(2, GL_FLOAT, sizeof(GLVERTEX), &Vertices[0].tu);
glDrawArrays(eType, 0, iNumVerts);
#else
glBegin(eType);
for (int i = 0; i < iNumVerts; i++)
{
/*
glNormal3dv(&Vertices[i].Normal.x);
glTexCoord2f(Vertices[i].tu,Vertices[i].tv);
glVertex3dv(&Vertices[i].Point.x);
*/
glNormal3fv(&Vertices[i].Normal.x);
glTexCoord2f(Vertices[i].tu, Vertices[i].tv);
glVertex3fv(&Vertices[i].Point.x);
};
glEnd();
#endif
glEndList();
}
}
else if (eType == TP_FREESPOTLIGHT)
{
uiDisplayList = glGenLists(1);
glNewList(uiDisplayList, GL_COMPILE);
glBindTexture(GL_TEXTURE_2D, 0);
// if (eType==smt_FreeSpotLight)
// {
// if (iFarAttenDecay==0)
// glColor3f(Diffuse[0],Diffuse[1],Diffuse[2]);
// }
// else
// TODO: poprawic zeby dzialalo
// glColor3f(f4Diffuse[0],f4Diffuse[1],f4Diffuse[2]);
glColorMaterial(GL_FRONT, GL_EMISSION);
glDisable(GL_LIGHTING); // Tolaris-030603: bo mu punkty swiecace sie blendowaly
glBegin(GL_POINTS);
glVertex3f(0, 0, 0);
glEnd();
glEnable(GL_LIGHTING);
glColorMaterial(GL_FRONT, GL_AMBIENT_AND_DIFFUSE);
glMaterialfv(GL_FRONT, GL_EMISSION, emm2);
glEndList();
}
else if (eType == TP_STARS)
{ // punkty œwiec¹ce dookólnie
uiDisplayList = glGenLists(1);
glNewList(uiDisplayList, GL_COMPILE);
glBindTexture(GL_TEXTURE_2D, 0); // tekstury nie ma
glColorMaterial(GL_FRONT, GL_EMISSION);
glDisable(GL_LIGHTING); // Tolaris-030603: bo mu punkty swiecace sie blendowaly
glBegin(GL_POINTS);
for (int i = 0; i < iNumVerts; i++)
{
glColor3f(Vertices[i].Normal.x, Vertices[i].Normal.y, Vertices[i].Normal.z);
// glVertex3dv(&Vertices[i].Point.x);
glVertex3fv(&Vertices[i].Point.x);
};
glEnd();
glEnable(GL_LIGHTING);
glColorMaterial(GL_FRONT, GL_AMBIENT_AND_DIFFUSE);
glMaterialfv(GL_FRONT, GL_EMISSION, emm2);
glEndList();
}
// SafeDeleteArray(Vertices); //przy VBO musz¹ zostaæ do za³adowania ca³ego modelu
if (Child)
Child->DisplayLists();
if (Next)
Next->DisplayLists();
};
void __fastcall TSubModel::InitialRotate(bool doit)
{ // konwersja uk³adu wspó³rzêdnych na zgodny ze sceneri¹
if (iFlags & 0xC000) // jeœli jest animacja albo niejednostkowy transform
{ // niejednostkowy transform jest mno¿ony i wystarczy zabawy
if (doit)
{ // obrót lewostronny
if (!fMatrix) // macierzy mo¿e nie byæ w dodanym "bananie"
{
fMatrix = new float4x4(); // tworzy macierz o przypadkowej zawartoœci
fMatrix->Identity(); // a zaczynamy obracanie od jednostkowej
}
iFlags |= 0x8000; // po obróceniu bêdzie raczej niejedynkowy matrix
fMatrix->InitialRotate(); // zmiana znaku X oraz zamiana Y i Z
if (fMatrix->IdentityIs())
iFlags &= ~0x8000; // jednak jednostkowa po obróceniu
}
if (Child)
Child->InitialRotate(
false); // potomnych nie obracamy ju¿, tylko ewentualnie optymalizujemy
else if (Global::iConvertModels & 2) // optymalizacja jest opcjonalna
if ((iFlags & 0xC000) == 0x8000) // o ile nie ma animacji
{ // jak nie ma potomnych, mo¿na wymno¿yæ przez transform i wyjedynkowaæ go
float4x4 *mat = GetMatrix(); // transform submodelu
if (Vertices)
{
for (int i = 0; i < iNumVerts; ++i)
Vertices[i].Point = (*mat) * Vertices[i].Point;
(*mat)(3)[0] = (*mat)(3)[1] = (*mat)(3)[2] =
0.0; // zerujemy przesuniêcie przed obracaniem normalnych
if (eType != TP_STARS) // gwiazdki maj¹ kolory zamiast normalnych, to ich wtedy
// nie ruszamy
for (int i = 0; i < iNumVerts; ++i)
Vertices[i].Normal = SafeNormalize((*mat) * Vertices[i].Normal);
}
mat->Identity(); // jedynkowanie transformu po przeliczeniu wierzcho³ków
iFlags &= ~0x8000; // transform jedynkowy
}
}
else // jak jest jednostkowy i nie ma animacji
if (doit)
{ // jeœli jest jednostkowy transform, to przeliczamy wierzcho³ki, a mno¿enie podajemy dalej
double t;
if (Vertices)
for (int i = 0; i < iNumVerts; ++i)
{
Vertices[i].Point.x = -Vertices[i].Point.x; // zmiana znaku X
t = Vertices[i].Point.y; // zamiana Y i Z
Vertices[i].Point.y = Vertices[i].Point.z;
Vertices[i].Point.z = t;
// wektory normalne równie¿ trzeba przekszta³ciæ, bo siê Ÿle oœwietlaj¹
Vertices[i].Normal.x = -Vertices[i].Normal.x; // zmiana znaku X
t = Vertices[i].Normal.y; // zamiana Y i Z
Vertices[i].Normal.y = Vertices[i].Normal.z;
Vertices[i].Normal.z = t;
}
if (Child)
Child->InitialRotate(doit); // potomne ewentualnie obrócimy
}
if (Next)
Next->InitialRotate(doit);
};
void __fastcall TSubModel::ChildAdd(TSubModel *SubModel)
{ // dodanie submodelu potemnego (uzale¿nionego)
// Ra: zmiana kolejnoœci, ¿eby kolejne móc renderowaæ po aktualnym (by³o przed)
if (SubModel)
SubModel->NextAdd(Child); // Ra: zmiana kolejnoœci renderowania
Child = SubModel;
};
void __fastcall TSubModel::NextAdd(TSubModel *SubModel)
{ // dodanie submodelu kolejnego (wspólny przodek)
if (Next)
Next->NextAdd(SubModel);
else
Next = SubModel;
};
int __fastcall TSubModel::FlagsCheck()
{ // analiza koniecznych zmian pomiêdzy submodelami
// samo pomijanie glBindTexture() nie poprawi wydajnoœci
// ale mo¿na sprawdziæ, czy mo¿na w ogóle pomin¹æ kod do tekstur (sprawdzanie replaceskin)
int i;
if (Child)
{ // Child jest renderowany po danym submodelu
if (Child->TextureID) // o ile ma teksturê
if (Child->TextureID != TextureID) // i jest ona inna ni¿ rodzica
Child->iFlags |= 0x80; // to trzeba sprawdzaæ, jak z teksturami jest
i = Child->FlagsCheck();
iFlags |= 0x00FF0000 & ((i << 16) | (i) | (i >> 8)); // potomny, rodzeñstwo i dzieci
if (eType == TP_TEXT)
{ // wy³¹czenie renderowania Next dla znaków wyœwietlacza tekstowego
TSubModel *p = Child;
while (p)
{
p->iFlags &= 0xC0FFFFFF;
p = p->Next;
}
}
}
if (Next)
{ // Next jest renderowany po danym submodelu (kolejnoœæ odwrócona po wczytaniu T3D)
if (TextureID) // o ile dany ma teksturê
if ((TextureID != Next->TextureID) ||
(i & 0x00800000)) // a ma inn¹ albo dzieci zmieniaj¹
iFlags |= 0x80; // to dany submodel musi sobie j¹ ustawiaæ
i = Next->FlagsCheck();
iFlags |= 0xFF000000 & ((i << 24) | (i << 8) | (i)); // nastêpny, kolejne i ich dzieci
// tekstury nie ustawiamy tylko wtedy, gdy jest taka sama jak Next i jego dzieci nie
// zmieniaj¹
}
return iFlags;
};
void __fastcall TSubModel::SetRotate(float3 vNewRotateAxis, float fNewAngle)
{ // obrócenie submodelu wg podanej osi (np. wskazówki w kabinie)
v_RotateAxis = vNewRotateAxis;
f_Angle = fNewAngle;
if (fNewAngle != 0.0)
{
b_Anim = at_Rotate;
b_aAnim = at_Rotate;
}
iAnimOwner = iInstance; // zapamiêtanie czyja jest animacja
}
void __fastcall TSubModel::SetRotateXYZ(float3 vNewAngles)
{ // obrócenie submodelu o podane k¹ty wokó³ osi lokalnego uk³adu
v_Angles = vNewAngles;
b_Anim = at_RotateXYZ;
b_aAnim = at_RotateXYZ;
iAnimOwner = iInstance; // zapamiêtanie czyja jest animacja
}
void __fastcall TSubModel::SetRotateXYZ(vector3 vNewAngles)
{ // obrócenie submodelu o podane k¹ty wokó³ osi lokalnego uk³adu
v_Angles.x = vNewAngles.x;
v_Angles.y = vNewAngles.y;
v_Angles.z = vNewAngles.z;
b_Anim = at_RotateXYZ;
b_aAnim = at_RotateXYZ;
iAnimOwner = iInstance; // zapamiêtanie czyja jest animacja
}
void __fastcall TSubModel::SetTranslate(float3 vNewTransVector)
{ // przesuniêcie submodelu (np. w kabinie)
v_TransVector = vNewTransVector;
b_Anim = at_Translate;
b_aAnim = at_Translate;
iAnimOwner = iInstance; // zapamiêtanie czyja jest animacja
}
void __fastcall TSubModel::SetTranslate(vector3 vNewTransVector)
{ // przesuniêcie submodelu (np. w kabinie)
v_TransVector.x = vNewTransVector.x;
v_TransVector.y = vNewTransVector.y;
v_TransVector.z = vNewTransVector.z;
b_Anim = at_Translate;
b_aAnim = at_Translate;
iAnimOwner = iInstance; // zapamiêtanie czyja jest animacja
}
void __fastcall TSubModel::SetRotateIK1(float3 vNewAngles)
{ // obrócenie submodelu o podane k¹ty wokó³ osi lokalnego uk³adu
v_Angles = vNewAngles;
iAnimOwner = iInstance; // zapamiêtanie czyja jest animacja
}
struct ToLower
{
char operator()(char input) { return tolower(input); }
};
TSubModel *__fastcall TSubModel::GetFromName(AnsiString search, bool i)
{
return GetFromName(search.c_str(), i);
};
TSubModel *__fastcall TSubModel::GetFromName(char *search, bool i)
{
TSubModel *result;
// std::transform(search.begin(),search.end(),search.begin(),ToLower());
// search=search.LowerCase();
// AnsiString name=AnsiString();
if (pName && search)
if ((i ? stricmp(pName, search) : strcmp(pName, search)) == 0)
return this;
else if (pName == search)
return this; // oba NULL
if (Next)
{
result = Next->GetFromName(search);
if (result)
return result;
}
if (Child)
{
result = Child->GetFromName(search);
if (result)
return result;
}
return NULL;
};
// WORD hbIndices[18]={3,0,1,5,4,2,1,0,4,1,5,3,2,3,5,2,4,0};
void __fastcall TSubModel::RaAnimation(TAnimType a)
{ // wykonanie animacji niezale¿nie od renderowania
switch (a)
{ // korekcja po³o¿enia, jeœli submodel jest animowany
case at_Translate: // Ra: by³o "true"
if (iAnimOwner != iInstance)
break; // cudza animacja
glTranslatef(v_TransVector.x, v_TransVector.y, v_TransVector.z);
break;
case at_Rotate: // Ra: by³o "true"
if (iAnimOwner != iInstance)
break; // cudza animacja
glRotatef(f_Angle, v_RotateAxis.x, v_RotateAxis.y, v_RotateAxis.z);
break;
case at_RotateXYZ:
if (iAnimOwner != iInstance)
break; // cudza animacja
glTranslatef(v_TransVector.x, v_TransVector.y, v_TransVector.z);
glRotatef(v_Angles.x, 1.0, 0.0, 0.0);
glRotatef(v_Angles.y, 0.0, 1.0, 0.0);
glRotatef(v_Angles.z, 0.0, 0.0, 1.0);
break;
case at_SecondsJump: // sekundy z przeskokiem
glRotatef(floor(GlobalTime->mr) * 6.0, 0.0, 1.0, 0.0);
break;
case at_MinutesJump: // minuty z przeskokiem
glRotatef(GlobalTime->mm * 6.0, 0.0, 1.0, 0.0);
break;
case at_HoursJump: // godziny skokowo 12h/360°
glRotatef(GlobalTime->hh * 30.0 * 0.5, 0.0, 1.0, 0.0);
break;
case at_Hours24Jump: // godziny skokowo 24h/360°
glRotatef(GlobalTime->hh * 15.0 * 0.25, 0.0, 1.0, 0.0);
break;
case at_Seconds: // sekundy p³ynnie
glRotatef(GlobalTime->mr * 6.0, 0.0, 1.0, 0.0);
break;
case at_Minutes: // minuty p³ynnie
glRotatef(GlobalTime->mm * 6.0 + GlobalTime->mr * 0.1, 0.0, 1.0, 0.0);
break;
case at_Hours: // godziny p³ynnie 12h/360°
// glRotatef(GlobalTime->hh*30.0+GlobalTime->mm*0.5+GlobalTime->mr/120.0,0.0,1.0,0.0);
glRotatef(2.0 * Global::fTimeAngleDeg, 0.0, 1.0, 0.0);
break;
case at_Hours24: // godziny p³ynnie 24h/360°
// glRotatef(GlobalTime->hh*15.0+GlobalTime->mm*0.25+GlobalTime->mr/240.0,0.0,1.0,0.0);
glRotatef(Global::fTimeAngleDeg, 0.0, 1.0, 0.0);
break;
case at_Billboard: // obrót w pionie do kamery
{
matrix4x4 mat; // potrzebujemy wspó³rzêdne przesuniêcia œrodka uk³adu wspó³rzêdnych
// submodelu
glGetDoublev(GL_MODELVIEW_MATRIX, mat.getArray()); // pobranie aktualnej matrycy
float3 gdzie = float3(mat[3][0], mat[3][1],
mat[3][2]); // pocz¹tek uk³adu wspó³rzêdnych submodelu wzglêdem kamery
glLoadIdentity(); // macierz jedynkowa
glTranslatef(gdzie.x, gdzie.y, gdzie.z); // pocz¹tek uk³adu zostaje bez zmian
glRotated(atan2(gdzie.x, gdzie.z) * 180.0 / M_PI, 0.0, 1.0,
0.0); // jedynie obracamy w pionie o k¹t
}
break;
case at_Wind: // ruch pod wp³ywem wiatru (wiatr bêdziemy liczyæ potem...)
glRotated(1.5 * sin(M_PI * GlobalTime->mr / 6.0), 0.0, 1.0, 0.0);
break;
case at_Sky: // animacja nieba
glRotated(Global::fLatitudeDeg, 1.0, 0.0, 0.0); // ustawienie osi OY na pó³noc
// glRotatef(Global::fTimeAngleDeg,0.0,1.0,0.0); //obrót dobowy osi OX
glRotated(-fmod(Global::fTimeAngleDeg, 360.0), 0.0, 1.0, 0.0); // obrót dobowy osi OX
break;
case at_IK11: // ostatni element animacji szkieletowej (podudzie, stopa)
glRotatef(v_Angles.z, 0.0, 1.0, 0.0); // obrót wzglêdem osi pionowej (azymut)
glRotatef(v_Angles.x, 1.0, 0.0, 0.0); // obrót wzglêdem poziomu (deklinacja)
break;
case at_DigiClk: // animacja zegara cyfrowego
{ // ustawienie animacji w submodelach potomnych
TSubModel *sm = ChildGet();
do
{ // pêtla po submodelach potomnych i obracanie ich o k¹t zale¿y od czasu
if (sm->pName)
{ // musi mieæ niepust¹ nazwê
if ((*sm->pName) >= '0')
if ((*sm->pName) <= '5') // zegarek ma 6 cyfr maksymalnie
sm->SetRotate(float3(0, 1, 0), -Global::fClockAngleDeg[(*sm->pName) - '0']);
}
sm = sm->NextGet();
} while (sm);
}
break;
}
if (mAnimMatrix) // mo¿na by to daæ np. do at_Translate
{
glMultMatrixf(mAnimMatrix->readArray());
mAnimMatrix = NULL; // jak animator bêdzie potrzebowa³, to ustawi ponownie
}
};
void __fastcall TSubModel::RenderDL()
{ // g³ówna procedura renderowania przez DL
if (iVisible && (fSquareDist >= fSquareMinDist) && (fSquareDist < fSquareMaxDist))
{
if (iFlags & 0xC000)
{
glPushMatrix();
if (fMatrix)
glMultMatrixf(fMatrix->readArray());
if (b_Anim)
RaAnimation(b_Anim);
}
if (eType < TP_ROTATOR)
{ // renderowanie obiektów OpenGL
if (iAlpha & iFlags & 0x1F) // rysuj gdy element nieprzezroczysty
{
if (TextureID < 0) // && (ReplacableSkinId!=0))
{ // zmienialne skóry
glBindTexture(GL_TEXTURE_2D, ReplacableSkinId[-TextureID]);
// TexAlpha=!(iAlpha&1); //zmiana tylko w przypadku wymienej tekstury
}
else
glBindTexture(GL_TEXTURE_2D, TextureID); // równie¿ 0
if (Global::fLuminance < fLight)
{
glMaterialfv(GL_FRONT, GL_EMISSION, f4Diffuse); // zeby swiecilo na kolorowo
glCallList(uiDisplayList); // tylko dla siatki
glMaterialfv(GL_FRONT, GL_EMISSION, emm2);
}
else
glCallList(uiDisplayList); // tylko dla siatki
}
}
else if (eType == TP_FREESPOTLIGHT)
{ // wersja DL
matrix4x4 mat; // macierz opisuje uk³ad renderowania wzglêdem kamery
glGetDoublev(GL_MODELVIEW_MATRIX, mat.getArray());
// k¹t miêdzy kierunkiem œwiat³a a wspó³rzêdnymi kamery
vector3 gdzie = mat * vector3(0, 0, 0); // pozycja punktu œwiec¹cego wzglêdem kamery
fCosViewAngle = DotProduct(Normalize(mat * vector3(0, 0, 1) - gdzie), Normalize(gdzie));
if (fCosViewAngle > fCosFalloffAngle) // k¹t wiêkszy ni¿ maksymalny sto¿ek swiat³a
{
double Distdimm = 1.0;
if (fCosViewAngle < fCosHotspotAngle) // zmniejszona jasnoœæ miêdzy Hotspot a
// Falloff
if (fCosFalloffAngle < fCosHotspotAngle)
Distdimm = 1.0 -
(fCosHotspotAngle - fCosViewAngle) /
(fCosHotspotAngle - fCosFalloffAngle);
glColor3f(f4Diffuse[0] * Distdimm, f4Diffuse[1] * Distdimm,
f4Diffuse[2] * Distdimm);
/* TODO: poprawic to zeby dzialalo
if (iFarAttenDecay>0)
switch (iFarAttenDecay)
{
case 1:
Distdimm=fFarDecayRadius/(1+sqrt(fSquareDist)); //dorobic od
kata
break;
case 2:
Distdimm=fFarDecayRadius/(1+fSquareDist); //dorobic od kata
break;
}
if (Distdimm>1)
Distdimm=1;
glColor3f(Diffuse[0]*Distdimm,Diffuse[1]*Distdimm,Diffuse[2]*Distdimm);
*/
// glPopMatrix();
// return;
glCallList(uiDisplayList); // wyœwietlenie warunkowe
}
}
else if (eType == TP_STARS)
{
// glDisable(GL_LIGHTING); //Tolaris-030603: bo mu punkty swiecace sie blendowaly
if (Global::fLuminance < fLight)
{
glMaterialfv(GL_FRONT, GL_EMISSION, f4Diffuse); // zeby swiecilo na kolorowo
glCallList(uiDisplayList); // narysuj naraz wszystkie punkty z DL
glMaterialfv(GL_FRONT, GL_EMISSION, emm2);
}
}
if (Child != NULL)
if (iAlpha & iFlags & 0x001F0000)
Child->RenderDL();
if (iFlags & 0xC000)
glPopMatrix();
}
if (b_Anim < at_SecondsJump)
b_Anim = at_None; // wy³¹czenie animacji dla kolejnego u¿ycia subm
if (Next)
if (iAlpha & iFlags & 0x1F000000)
Next->RenderDL(); // dalsze rekurencyjnie
}; // Render
void __fastcall TSubModel::RenderAlphaDL()
{ // renderowanie przezroczystych przez DL
if (iVisible && (fSquareDist >= fSquareMinDist) && (fSquareDist < fSquareMaxDist))
{
if (iFlags & 0xC000)
{
glPushMatrix();
if (fMatrix)
glMultMatrixf(fMatrix->readArray());
if (b_aAnim)
RaAnimation(b_aAnim);
}
if (eType < TP_ROTATOR)
{ // renderowanie obiektów OpenGL
if (iAlpha & iFlags & 0x2F) // rysuj gdy element przezroczysty
{
if (TextureID < 0) // && (ReplacableSkinId!=0))
{ // zmienialne skóry
glBindTexture(GL_TEXTURE_2D, ReplacableSkinId[-TextureID]);
// TexAlpha=iAlpha&1; //zmiana tylko w przypadku wymienej tekstury
}
else
glBindTexture(GL_TEXTURE_2D, TextureID); // równie¿ 0
if (Global::fLuminance < fLight)
{
glMaterialfv(GL_FRONT, GL_EMISSION, f4Diffuse); // zeby swiecilo na kolorowo
glCallList(uiDisplayList); // tylko dla siatki
glMaterialfv(GL_FRONT, GL_EMISSION, emm2);
}
else
glCallList(uiDisplayList); // tylko dla siatki
}
}
else if (eType == TP_FREESPOTLIGHT)
{
// dorobiæ aureolê!
}
if (Child != NULL)
if (eType == TP_TEXT)
{ // tekst renderujemy w specjalny sposób, zamiast submodeli z ³añcucha Child
int i, j = pasText->Length();
TSubModel *p;
char c;
if (!smLetter)
{ // jeœli nie ma tablicy, to j¹ stworzyæ; miejsce nieodpowiednie, ale tymczasowo
// mo¿e byæ
smLetter = new TSubModel *[256]; // tablica wskaŸników submodeli dla
// wyœwietlania tekstu
ZeroMemory(smLetter, 256 * sizeof(TSubModel *)); // wype³nianie zerami
p = Child;
while (p)
{
smLetter[*p->pName] = p;
p = p->Next; // kolejny znak
}
}
for (i = 1; i <= j; ++i)
{
p = smLetter[(*pasText)[i]]; // znak do wyœwietlenia
if (p)
{ // na razie tylko jako przezroczyste
p->RenderAlphaDL();
if (p->fMatrix)
glMultMatrixf(p->fMatrix->readArray()); // przesuwanie widoku
}
}
}
else if (iAlpha & iFlags & 0x002F0000)
Child->RenderAlphaDL();
if (iFlags & 0xC000)
glPopMatrix();
}
if (b_aAnim < at_SecondsJump)
b_aAnim = at_None; // wy³¹czenie animacji dla kolejnego u¿ycia submodelu
if (Next != NULL)
if (iAlpha & iFlags & 0x2F000000)
Next->RenderAlphaDL();
}; // RenderAlpha
void __fastcall TSubModel::RenderVBO()
{ // g³ówna procedura renderowania przez VBO
if (iVisible && (fSquareDist >= fSquareMinDist) && (fSquareDist < fSquareMaxDist))
{
if (iFlags & 0xC000)
{
glPushMatrix();
if (fMatrix)
glMultMatrixf(fMatrix->readArray());
if (b_Anim)
RaAnimation(b_Anim);
}
if (eType < TP_ROTATOR)
{ // renderowanie obiektów OpenGL
if (iAlpha & iFlags & 0x1F) // rysuj gdy element nieprzezroczysty
{
if (TextureID < 0) // && (ReplacableSkinId!=0))
{ // zmienialne skóry
glBindTexture(GL_TEXTURE_2D, ReplacableSkinId[-TextureID]);
// TexAlpha=!(iAlpha&1); //zmiana tylko w przypadku wymienej tekstury
}
else
glBindTexture(GL_TEXTURE_2D, TextureID); // równie¿ 0
glColor3fv(f4Diffuse); // McZapkie-240702: zamiast ub
// glMaterialfv(GL_FRONT,GL_AMBIENT_AND_DIFFUSE,f4Diffuse); //to samo, co glColor
if (Global::fLuminance < fLight)
{
glMaterialfv(GL_FRONT, GL_EMISSION, f4Diffuse); // zeby swiecilo na kolorowo
glDrawArrays(eType, iVboPtr,
iNumVerts); // narysuj naraz wszystkie trójk¹ty z VBO
glMaterialfv(GL_FRONT, GL_EMISSION, emm2);
}
else
glDrawArrays(eType, iVboPtr,
iNumVerts); // narysuj naraz wszystkie trójk¹ty z VBO
}
}
else if (eType == TP_FREESPOTLIGHT)
{ // wersja VBO
matrix4x4 mat; // macierz opisuje uk³ad renderowania wzglêdem kamery
glGetDoublev(GL_MODELVIEW_MATRIX, mat.getArray());
// k¹t miêdzy kierunkiem œwiat³a a wspó³rzêdnymi kamery
vector3 gdzie = mat * vector3(0, 0, 0); // pozycja punktu œwiec¹cego wzglêdem kamery
fCosViewAngle = DotProduct(Normalize(mat * vector3(0, 0, 1) - gdzie), Normalize(gdzie));
if (fCosViewAngle > fCosFalloffAngle) // k¹t wiêkszy ni¿ maksymalny sto¿ek swiat³a
{
double Distdimm = 1.0;
if (fCosViewAngle < fCosHotspotAngle) // zmniejszona jasnoœæ miêdzy Hotspot a
// Falloff
if (fCosFalloffAngle < fCosHotspotAngle)
Distdimm = 1.0 -
(fCosHotspotAngle - fCosViewAngle) /
(fCosHotspotAngle - fCosFalloffAngle);
/* TODO: poprawic to zeby dzialalo
2- Inverse (Applies inverse decay. The formula is luminance=R0/R, where R0 is
the radial source of the light if no attenuation is used, or the Near End
value of the light if Attenuation is used. R is the radial distance of the
illuminated surface from R0.)
3- Inverse Square (Applies inverse-square decay. The formula for this is (R0/R)^2.
This is actually the "real-world" decay of light, but you might find it too dim
in the world of computer graphics.)
<light>.DecayRadius -- The distance over which the decay occurs.
if (iFarAttenDecay>0)
switch (iFarAttenDecay)
{
case 1:
Distdimm=fFarDecayRadius/(1+sqrt(fSquareDist)); //dorobic od
kata
break;
case 2:
Distdimm=fFarDecayRadius/(1+fSquareDist); //dorobic od kata
break;
}
if (Distdimm>1)
Distdimm=1;
*/
glBindTexture(GL_TEXTURE_2D, 0); // nie teksturowaæ
// glColor3f(f4Diffuse[0],f4Diffuse[1],f4Diffuse[2]);
// glColorMaterial(GL_FRONT,GL_EMISSION);
float color[4] = {f4Diffuse[0] * Distdimm, f4Diffuse[1] * Distdimm,
f4Diffuse[2] * Distdimm, 0};
// glColor3f(f4Diffuse[0]*Distdimm,f4Diffuse[1]*Distdimm,f4Diffuse[2]*Distdimm);
glColorMaterial(GL_FRONT, GL_EMISSION);
glDisable(GL_LIGHTING); // Tolaris-030603: bo mu punkty swiecace sie blendowaly
glColor3fv(color); // inaczej s¹ bia³e
glMaterialfv(GL_FRONT, GL_EMISSION, color);
glDrawArrays(GL_POINTS, iVboPtr, iNumVerts); // narysuj wierzcho³ek z VBO
glEnable(GL_LIGHTING);
glColorMaterial(GL_FRONT, GL_AMBIENT_AND_DIFFUSE); // co ma ustawiaæ glColor
glMaterialfv(GL_FRONT, GL_EMISSION, emm2); // bez tego s³upy siê œwiec¹
}
}
else if (eType == TP_STARS)
{
// glDisable(GL_LIGHTING); //Tolaris-030603: bo mu punkty swiecace sie blendowaly
if (Global::fLuminance < fLight)
{ // Ra: pewnie mo¿na by to zrobiæ lepiej, bez powtarzania StartVBO()
pRoot->EndVBO(); // Ra: to te¿ nie jest zbyt ³adne
if (pRoot->StartColorVBO())
{ // wyœwietlanie kolorowych punktów zamiast trójk¹tów
glBindTexture(GL_TEXTURE_2D, 0); // tekstury nie ma
glColorMaterial(GL_FRONT, GL_EMISSION);
glDisable(GL_LIGHTING); // Tolaris-030603: bo mu punkty swiecace sie blendowaly
// glMaterialfv(GL_FRONT,GL_EMISSION,f4Diffuse); //zeby swiecilo na kolorowo
glDrawArrays(GL_POINTS, iVboPtr,
iNumVerts); // narysuj naraz wszystkie punkty z VBO
glEnable(GL_LIGHTING);
glColorMaterial(GL_FRONT, GL_AMBIENT_AND_DIFFUSE);
// glMaterialfv(GL_FRONT,GL_EMISSION,emm2);
pRoot->EndVBO();
pRoot->StartVBO();
}
}
}
/*Ra: tu coœ jest bez sensu...
else
{
glBindTexture(GL_TEXTURE_2D, 0);
// if (eType==smt_FreeSpotLight)
// {
// if (iFarAttenDecay==0)
// glColor3f(Diffuse[0],Diffuse[1],Diffuse[2]);
// }
// else
//TODO: poprawic zeby dzialalo
glColor3f(f4Diffuse[0],f4Diffuse[1],f4Diffuse[2]);
glColorMaterial(GL_FRONT,GL_EMISSION);
glDisable(GL_LIGHTING); //Tolaris-030603: bo mu punkty swiecace sie blendowaly
//glBegin(GL_POINTS);
glDrawArrays(GL_POINTS,iVboPtr,iNumVerts); //narysuj wierzcho³ek z VBO
// glVertex3f(0,0,0);
//glEnd();
glEnable(GL_LIGHTING);
glColorMaterial(GL_FRONT,GL_AMBIENT_AND_DIFFUSE);
glMaterialfv(GL_FRONT,GL_EMISSION,emm2);
//glEndList();
}
*/
if (Child != NULL)
if (iAlpha & iFlags & 0x001F0000)
Child->RenderVBO();
if (iFlags & 0xC000)
glPopMatrix();
}
if (b_Anim < at_SecondsJump)
b_Anim = at_None; // wy³¹czenie animacji dla kolejnego u¿ycia submodelu
if (Next)
if (iAlpha & iFlags & 0x1F000000)
Next->RenderVBO(); // dalsze rekurencyjnie
}; // RaRender
void __fastcall TSubModel::RenderAlphaVBO()
{ // renderowanie przezroczystych przez VBO
if (iVisible && (fSquareDist >= fSquareMinDist) && (fSquareDist < fSquareMaxDist))
{
if (iFlags & 0xC000)
{
glPushMatrix(); // zapamiêtanie matrycy
if (fMatrix)
glMultMatrixf(fMatrix->readArray());
if (b_aAnim)
RaAnimation(b_aAnim);
}
glColor3fv(f4Diffuse);
if (eType < TP_ROTATOR)
{ // renderowanie obiektów OpenGL
if (iAlpha & iFlags & 0x2F) // rysuj gdy element przezroczysty
{
if (TextureID < 0) // && (ReplacableSkinId!=0))
{ // zmienialne skory
glBindTexture(GL_TEXTURE_2D, ReplacableSkinId[-TextureID]);
// TexAlpha=iAlpha&1; //zmiana tylko w przypadku wymienej tekstury
}
else
glBindTexture(GL_TEXTURE_2D, TextureID); // równie¿ 0
if (Global::fLuminance < fLight)
{
glMaterialfv(GL_FRONT, GL_EMISSION, f4Diffuse); // zeby swiecilo na kolorowo
glDrawArrays(eType, iVboPtr,
iNumVerts); // narysuj naraz wszystkie trójk¹ty z VBO
glMaterialfv(GL_FRONT, GL_EMISSION, emm2);
}
else
glDrawArrays(eType, iVboPtr,
iNumVerts); // narysuj naraz wszystkie trójk¹ty z VBO
}
}
else if (eType == TP_FREESPOTLIGHT)
{
// dorobiæ aureolê!
}
if (Child)
if (iAlpha & iFlags & 0x002F0000)
Child->RenderAlphaVBO();
if (iFlags & 0xC000)
glPopMatrix();
}
if (b_aAnim < at_SecondsJump)
b_aAnim = at_None; // wy³¹czenie animacji dla kolejnego u¿ycia submodelu
if (Next)
if (iAlpha & iFlags & 0x2F000000)
Next->RenderAlphaVBO();
}; // RaRenderAlpha
//---------------------------------------------------------------------------
void __fastcall TSubModel::RaArrayFill(CVertNormTex *Vert)
{ // wype³nianie tablic VBO
if (Child)
Child->RaArrayFill(Vert);
if ((eType < TP_ROTATOR) || (eType == TP_STARS))
for (int i = 0; i < iNumVerts; ++i)
{
Vert[iVboPtr + i].x = Vertices[i].Point.x;
Vert[iVboPtr + i].y = Vertices[i].Point.y;
Vert[iVboPtr + i].z = Vertices[i].Point.z;
Vert[iVboPtr + i].nx = Vertices[i].Normal.x;
Vert[iVboPtr + i].ny = Vertices[i].Normal.y;
Vert[iVboPtr + i].nz = Vertices[i].Normal.z;
Vert[iVboPtr + i].u = Vertices[i].tu;
Vert[iVboPtr + i].v = Vertices[i].tv;
}
else if (eType == TP_FREESPOTLIGHT)
Vert[iVboPtr].x = Vert[iVboPtr].y = Vert[iVboPtr].z = 0.0;
if (Next)
Next->RaArrayFill(Vert);
};
void __fastcall TSubModel::Info()
{ // zapisanie informacji o submodelu do obiektu pomocniczego
TSubModelInfo *info = TSubModelInfo::pTable + TSubModelInfo::iCurrent;
info->pSubModel = this;
if (fMatrix && (iFlags & 0x8000)) // ma matrycê i jest ona niejednostkowa
info->iTransform = info->iTotalTransforms++;
if (TextureID > 0)
{ // jeœli ma teksturê niewymienn¹
for (int i = 0; i < info->iCurrent; ++i)
if (TextureID == info->pTable[i].pSubModel->TextureID) // porównanie z wczeœniejszym
{
info->iTexture = info->pTable[i].iTexture; // taki jaki ju¿ by³
break; // koniec sprawdzania
}
if (info->iTexture < 0) // jeœli nie znaleziono we wczeœniejszych
{
info->iTexture = ++info->iTotalTextures; // przydzielenie numeru tekstury w pliku (od 1)
AnsiString t = AnsiString(pTexture);
if (t.SubString(t.Length() - 3, 4) == ".tga")
t.Delete(t.Length() - 3, 4);
else if (t.SubString(t.Length() - 3, 4) == ".dds")
t.Delete(t.Length() - 3, 4);
if (t != AnsiString(pTexture))
{ // jeœli siê zmieni³o
// pName=new char[token.length()+1]; //nie ma sensu skracaæ tabeli
strcpy(pTexture, t.c_str());
}
info->iTextureLen = t.Length() + 1; // przygotowanie do zapisania, z zerem na koñcu
}
}
else
info->iTexture = TextureID; // nie ma albo wymienna
// if (asName.Length())
if (pName)
{
info->iName = info->iTotalNames++; // przydzielenie numeru nazwy w pliku (od 0)
info->iNameLen = strlen(pName) + 1; // z zerem na koñcu
}
++info->iCurrent; // przejœcie do kolejnego obiektu pomocniczego
if (Child)
{
info->iChild = info->iCurrent;
Child->Info();
}
if (Next)
{
info->iNext = info->iCurrent;
Next->Info();
}
};
void __fastcall TSubModel::InfoSet(TSubModelInfo *info)
{ // ustawienie danych wg obiektu pomocniczego do zapisania w pliku
int ile = (char *)&uiDisplayList - (char *)&eType; // iloœæ bajtów pomiêdzy tymi zmiennymi
ZeroMemory(this, sizeof(TSubModel)); // zerowaie ca³oœci
CopyMemory(this, info->pSubModel, ile); // skopiowanie pamiêci 1:1
iTexture = info->iTexture; // numer nazwy tekstury, a nie numer w OpenGL
TextureID = info->iTexture; // numer tekstury w OpenGL
iName = info->iName; // numer nazwy w obszarze nazw
iMatrix = info->iTransform; // numer macierzy
Next = (TSubModel *)info->iNext; // numer nastêpnego
Child = (TSubModel *)info->iChild; // numer potomnego
iFlags &= ~0x200; // nie jest wczytany z tekstowego
// asTexture=asName="";
pTexture = pName = NULL;
};
void __fastcall TSubModel::BinInit(TSubModel *s, float4x4 *m, float8 *v, TStringPack *t,
TStringPack *n, bool dynamic)
{ // ustawienie wskaŸników w submodelu
iVisible = 1; // tymczasowo u¿ywane
Child = ((int)Child > 0) ? s + (int)Child : NULL; // zerowy nie mo¿e byæ potomnym
Next = ((int)Next > 0) ? s + (int)Next : NULL; // zerowy nie mo¿e byæ nastêpnym
fMatrix = ((iMatrix >= 0) && m) ? m + iMatrix : NULL;
// if (n&&(iName>=0)) asName=AnsiString(n->String(iName)); else asName="";
if (n && (iName >= 0))
{
pName = n->String(iName);
AnsiString s = AnsiString(pName);
if (!s.IsEmpty())
{ // jeœli dany submodel jest zgaszonym œwiat³em, to domyœlnie go ukrywamy
if (s.SubString(1, 8) == "Light_On") // jeœli jest œwiat³em numerowanym
iVisible = 0; // to domyœlnie wy³¹czyæ, ¿eby siê nie nak³ada³o z obiektem
// "Light_Off"
else if (dynamic) // inaczej wy³¹cza³o smugê w latarniach
if (s.SubString(s.Length() - 2, 3) ==
"_on") // jeœli jest kontrolk¹ w stanie zapalonym
iVisible = 0; // to domyœlnie wy³¹czyæ, ¿eby siê nie nak³ada³o z obiektem "_off"
}
}
else
pName = NULL;
if (iTexture > 0)
{ // obs³uga sta³ej tekstury
// TextureID=TTexturesManager::GetTextureID(t->String(TextureID));
// asTexture=AnsiString(t->String(iTexture));
pTexture = t->String(iTexture);
AnsiString t = AnsiString(pTexture);
if (t.LastDelimiter("/\\") == 0)
t.Insert(Global::asCurrentTexturePath, 1);
TextureID = TTexturesManager::GetTextureID(szTexturePath,
Global::asCurrentTexturePath.c_str(), t.c_str());
// TexAlpha=TTexturesManager::GetAlpha(TextureID); //zmienna robocza
// ustawienie cyklu przezroczyste/nieprzezroczyste zale¿nie od w³asnoœci sta³ej tekstury
// iFlags=(iFlags&~0x30)|(TTexturesManager::GetAlpha(TextureID)?0x20:0x10);
// //0x10-nieprzezroczysta, 0x20-przezroczysta
if (Opacity < 1.0) // przezroczystoϾ z tekstury brana tylko dla Opacity 0!
iFlags |= TTexturesManager::GetAlpha(TextureID) ?
0x20 :
0x10; // 0x10-nieprzezroczysta, 0x20-przezroczysta
else
iFlags |= 0x10; // normalnie nieprzezroczyste
}
b_aAnim = b_Anim; // skopiowanie animacji do drugiego cyklu
iFlags &= ~0x0200; // wczytano z pliku binarnego (nie jest w³aœcicielem tablic)
Vertices = v + iVboPtr;
// if (!iNumVerts) eType=-1; //tymczasowo zmiana typu, ¿eby siê nie renderowa³o na si³ê
};
void __fastcall TSubModel::AdjustDist()
{ // aktualizacja odleg³oœci faz LoD, zale¿na od rozdzielczoœci pionowej oraz multisamplingu
if (fSquareMaxDist > 0.0)
fSquareMaxDist *= Global::fDistanceFactor;
if (fSquareMinDist > 0.0)
fSquareMinDist *= Global::fDistanceFactor;
// if (fNearAttenStart>0.0) fNearAttenStart*=Global::fDistanceFactor;
// if (fNearAttenEnd>0.0) fNearAttenEnd*=Global::fDistanceFactor;
if (Child)
Child->AdjustDist();
if (Next)
Next->AdjustDist();
};
void __fastcall TSubModel::ColorsSet(int *a, int *d, int *s)
{ // ustawienie kolorów dla modelu terenu
int i;
if (a)
for (i = 0; i < 4; ++i)
f4Ambient[i] = a[i] / 255.0;
if (d)
for (i = 0; i < 4; ++i)
f4Diffuse[i] = d[i] / 255.0;
if (s)
for (i = 0; i < 4; ++i)
f4Specular[i] = s[i] / 255.0;
};
void __fastcall TSubModel::ParentMatrix(float4x4 *m)
{ // pobranie transformacji wzglêdem wstawienia modelu
// jeœli nie zosta³o wykonane Init() (tzn. zaraz po wczytaniu T3D), to dodatkowy obrót
// obrót T3D jest wymagany np. do policzenia wysokoœci pantografów
*m = float4x4(*fMatrix); // skopiowanie, bo bêdziemy mno¿yæ
// m(3)[1]=m[3][1]+0.054; //w górê o wysokoœæ œlizgu (na razie tak)
TSubModel *sm = this;
while (sm->Parent)
{ // przenieœæ tê funkcjê do modelu
if (sm->Parent->GetMatrix())
*m = *sm->Parent->GetMatrix() * *m;
sm = sm->Parent;
}
// dla ostatniego mo¿e byæ potrzebny dodatkowy obrót, jeœli wczytano z T3D, a nie obrócono
// jeszcze
};
float __fastcall TSubModel::MaxY(const float4x4 &m)
{ // obliczenie maksymalnej wysokoœci, na pocz¹tek œlizgu w pantografie
if (eType != 4)
return 0; // tylko dla trójk¹tów liczymy
if (iNumVerts < 1)
return 0;
if (!Vertices)
return 0;
float y, my = m[0][1] * Vertices[0].Point.x + m[1][1] * Vertices[0].Point.y +
m[2][1] * Vertices[0].Point.z + m[3][1];
for (int i = 1; i < iNumVerts; ++i)
{
y = m[0][1] * Vertices[i].Point.x + m[1][1] * Vertices[i].Point.y +
m[2][1] * Vertices[i].Point.z + m[3][1];
if (my < y)
my = y;
}
return my;
};
//---------------------------------------------------------------------------
__fastcall TModel3d::TModel3d()
{
// Materials=NULL;
// MaterialsCount=0;
Root = NULL;
iFlags = 0;
iSubModelsCount = 0;
iModel = NULL; // tylko jak wczytany model binarny
iNumVerts = 0; // nie ma jeszcze wierzcho³ków
};
/*
__fastcall TModel3d::TModel3d(char *FileName)
{
// Root=NULL;
// Materials=NULL;
// MaterialsCount=0;
Root=NULL;
SubModelsCount=0;
iFlags=0;
LoadFromFile(FileName);
};
*/
__fastcall TModel3d::~TModel3d()
{
// SafeDeleteArray(Materials);
if (iFlags & 0x0200)
{ // wczytany z pliku tekstowego, submodele sprz¹taj¹ same
SafeDelete(Root); // submodele siê usun¹ rekurencyjnie
}
else
{ // wczytano z pliku binarnego (jest w³aœcicielem tablic)
m_pVNT = NULL; // nie usuwaæ tego, bo wskazuje na iModel
Root = NULL;
delete[] iModel; // usuwamy ca³y wczytany plik i to wystarczy
}
// póŸniej siê jeszcze usuwa obiekt z którego dziedziczymy tabelê VBO
};
TSubModel *__fastcall TModel3d::AddToNamed(const char *Name, TSubModel *SubModel)
{
TSubModel *sm = Name ? GetFromName(Name) : NULL;
AddTo(sm, SubModel); // szukanie nadrzêdnego
return sm; // zwracamy wskaŸnik do nadrzêdnego submodelu
};
void __fastcall TModel3d::AddTo(TSubModel *tmp, TSubModel *SubModel)
{ // jedyny poprawny sposób dodawania submodeli, inaczej mog¹ zgin¹æ przy zapisie E3D
if (tmp)
{ // jeœli znaleziony, pod³¹czamy mu jako potomny
tmp->ChildAdd(SubModel);
}
else
{ // jeœli nie znaleziony, podczepiamy do ³añcucha g³ównego
SubModel->NextAdd(Root); // Ra: zmiana kolejnoœci renderowania wymusza zmianê tu
Root = SubModel;
}
++iSubModelsCount; // teraz jest o 1 submodel wiêcej
iFlags |= 0x0200; // submodele s¹ oddzielne
};
TSubModel *__fastcall TModel3d::GetFromName(const char *sName)
{ // wyszukanie submodelu po nazwie
if (!sName)
return Root; // potrzebne do terenu z E3D
if (iFlags & 0x0200) // wczytany z pliku tekstowego, wyszukiwanie rekurencyjne
return Root ? Root->GetFromName(sName) : NULL;
else // wczytano z pliku binarnego, mo¿na wyszukaæ iteracyjnie
{
// for (int i=0;i<iSubModelsCount;++i)
return Root ? Root->GetFromName(sName) : NULL;
}
};
/*
TMaterial* __fastcall TModel3d::GetMaterialFromName(char *sName)
{
AnsiString tmp=AnsiString(sName).Trim();
for (int i=0; i<MaterialsCount; i++)
if (strcmp(sName,Materials[i].Name.c_str())==0)
// if (Trim()==Materials[i].Name.tmp)
return Materials+i;
return Materials;
}
*/
bool __fastcall TModel3d::LoadFromFile(char *FileName, bool dynamic)
{ // wczytanie modelu z pliku
AnsiString name = AnsiString(FileName).LowerCase();
int i = name.LastDelimiter(".");
if (i)
if (name.SubString(i, name.Length() - i + 1) == ".t3d")
name.Delete(i, 4);
asBinary = name + ".e3d";
if (FileExists(asBinary))
{
LoadFromBinFile(asBinary.c_str(), dynamic);
asBinary = ""; // wy³¹czenie zapisu
Init();
}
else
{
if (FileExists(name + ".t3d"))
{
LoadFromTextFile(FileName, dynamic); // wczytanie tekstowego
if (!dynamic) // pojazdy dopiero po ustawieniu animacji
Init(); // generowanie siatek i zapis E3D
}
}
return Root ? (iSubModelsCount > 0) : false; // brak pliku albo problem z wczytaniem
};
void __fastcall TModel3d::LoadFromBinFile(char *FileName, bool dynamic)
{ // wczytanie modelu z pliku binarnego
WriteLog("Loading - binary model: " + AnsiString(FileName));
int i = 0, j, k, ch, size;
TFileStream *fs = new TFileStream(AnsiString(FileName), fmOpenRead);
size = fs->Size >> 2;
iModel = new int[size]; // ten wskaŸnik musi byæ w modelu, aby zwolniæ pamiêæ
fs->Read(iModel, fs->Size); // wczytanie pliku
delete fs;
float4x4 *m = NULL; // transformy
// zestaw kromek:
while ((i << 2) < size) // w pliku mo¿e byæ kilka modeli
{
ch = iModel[i]; // nazwa kromki
j = i + (iModel[i + 1] >> 2); // pocz¹tek nastêpnej kromki
if (ch == 'E3D0') // g³ówna: 'E3D0',len,pod-kromki
{ // tylko tê kromkê znamy, mo¿e kiedyœ jeszcze DOF siê zrobi
i += 2;
while (i < j)
{ // przetwarzanie kromek wewnêtrznych
ch = iModel[i]; // nazwa kromki
k = (iModel[i + 1] >> 2); // d³ugoœæ aktualnej kromki
switch (ch)
{
case 'MDL0': // zmienne modelu: 'E3D0',len,(informacje o modelu)
break;
case 'VNT0': // wierzcho³ki: 'VNT0',len,(32 bajty na wierzcho³ek)
iNumVerts = (k - 2) >> 3;
m_nVertexCount = iNumVerts;
m_pVNT = (CVertNormTex *)(iModel + i + 2);
break;
case 'SUB0': // submodele: 'SUB0',len,(256 bajtów na submodel)
iSubModelsCount = (k - 2) / 64;
Root = (TSubModel *)(iModel + i + 2); // numery na wskaŸniki przetworzymy
// póŸniej
break;
case 'SUB1': // submodele: 'SUB1',len,(320 bajtów na submodel)
iSubModelsCount = (k - 2) / 80;
Root = (TSubModel *)(iModel + i + 2); // numery na wskaŸniki przetworzymy
// póŸniej
for (ch = 1; ch < iSubModelsCount;
++ch) // trzeba przesun¹æ bli¿ej, bo 256 wystarczy
MoveMemory(((char *)Root) + 256 * ch, ((char *)Root) + 320 * ch, 256);
break;
case 'TRA0': // transformy: 'TRA0',len,(64 bajty na transform)
m = (float4x4 *)(iModel + i + 2); // tabela transformów
break;
case 'TRA1': // transformy: 'TRA1',len,(128 bajtów na transform)
m = (float4x4 *)(iModel + i + 2); // tabela transformów
for (ch = 0; ch < ((k - 2) >> 1); ++ch)
*(((float *)m) + ch) = *(((double *)m) + ch); // przepisanie double do float
break;
case 'IDX1': // indeksy 1B: 'IDX2',len,(po bajcie na numer wierzcho³ka)
break;
case 'IDX2': // indeksy 2B: 'IDX2',len,(po 2 bajty na numer wierzcho³ka)
break;
case 'IDX4': // indeksy 4B: 'IDX4',len,(po 4 bajty na numer wierzcho³ka)
break;
case 'TEX0': // tekstury: 'TEX0',len,(³añcuchy zakoñczone zerem - pliki tekstur)
Textures.Init((char *)(iModel + i)); //³¹cznie z nag³ówkiem
break;
case 'TIX0': // indeks nazw tekstur
Textures.InitIndex((int *)(iModel + i)); //³¹cznie z nag³ówkiem
break;
case 'NAM0': // nazwy: 'NAM0',len,(³añcuchy zakoñczone zerem - nazwy submodeli)
Names.Init((char *)(iModel + i)); //³¹cznie z nag³ówkiem
break;
case 'NIX0': // indeks nazw submodeli
Names.InitIndex((int *)(iModel + i)); //³¹cznie z nag³ówkiem
break;
}
i += k; // przejœcie do kolejnej kromki
}
}
i = j;
}
for (i = 0; i < iSubModelsCount; ++i)
{ // aktualizacja wskaŸników w submodelach
Root[i].BinInit(Root, m, (float8 *)m_pVNT, &Textures, &Names, dynamic);
if (Root[i].ChildGet())
Root[i].ChildGet()->Parent = Root + i; // wpisanie wskaŸnika nadrzêdnego do potmnego
if (Root[i].NextGet())
Root[i].NextGet()->Parent =
Root[i].Parent; // skopiowanie wskaŸnika nadrzêdnego do kolejnego
}
iFlags &= ~0x0200;
return;
};
void __fastcall TModel3d::LoadFromTextFile(char *FileName, bool dynamic)
{ // wczytanie submodelu z pliku tekstowego
WriteLog("Loading - text model: " + AnsiString(FileName));
iFlags |= 0x0200; // wczytano z pliku tekstowego (w³aœcicielami tablic s¹ submodle)
cParser parser(FileName, cParser::buffer_FILE); // Ra: tu powinno byæ "models\\"...
TSubModel *SubModel;
std::string token;
parser.getToken(token);
iNumVerts = 0; // w konstruktorze to jest
while (token != "" || parser.eof())
{
std::string parent;
// parser.getToken(parent);
parser.getTokens(1, false); // nazwa submodelu nadrzêdnego bez zmieny na ma³e
parser >> parent;
if (parent == "")
break;
SubModel = new TSubModel();
iNumVerts += SubModel->Load(parser, this, iNumVerts, dynamic);
SubModel->Parent = AddToNamed(
parent.c_str(), SubModel); // bêdzie potrzebne do wyliczenia pozycji, np. pantografu
// iSubModelsCount++;
parser.getToken(token);
}
// Ra: od wersji 334 przechylany jest ca³y model, a nie tylko pierwszy submodel
// ale bujanie kabiny nadal u¿ywa bananów :( od 393 przywrócone, ale z dodatkowym warunkiem
if (Global::iConvertModels & 4)
{ // automatyczne banany czasem psu³y przechylanie kabin...
if (dynamic && Root)
{
if (Root->NextGet()) // jeœli ma jakiekolwiek kolejne
{ // dynamic musi mieæ "banana", bo tylko pierwszy obiekt jest animowany, a nastêpne nie
SubModel = new TSubModel(); // utworzenie pustego
SubModel->ChildAdd(Root);
Root = SubModel;
++iSubModelsCount;
}
Root->WillBeAnimated(); // bo z tym jest du¿o problemów
}
}
}
void __fastcall TModel3d::Init()
{ // obrócenie pocz¹tkowe uk³adu wspó³rzêdnych, dla pojazdów wykonywane po analizie animacji
if (iFlags & 0x8000)
return; // operacje zosta³y ju¿ wykonane
if (Root)
{
if (iFlags & 0x0200) // jeœli wczytano z pliku tekstowego
{ // jest jakiœ dziwny b³¹d, ¿e obkrêcany ma byæ tylko ostatni submodel g³ównego ³añcucha
// TSubModel *p=Root;
// do
//{p->InitialRotate(true); //ostatniemu nale¿y siê konwersja uk³adu wspó³rzêdnych
// p=p->NextGet();
//}
// while (p->NextGet())
// Root->InitialRotate(false); //a poprzednim tylko optymalizacja
Root->InitialRotate(true); // argumet okreœla, czy wykonaæ pierwotny obrót
}
iFlags |= Root->FlagsCheck() | 0x8000; // flagi ca³ego modelu
if (!asBinary.IsEmpty()) // jeœli jest podana nazwa
{
if (Global::iConvertModels) // i w³¹czony zapis
SaveToBinFile(asBinary.c_str()); // utworzy tablicê (m_pVNT)
asBinary = ""; // zablokowanie powtórnego zapisu
}
if (iNumVerts)
{
if (Global::fDistanceFactor !=
1.0) // trochê zaoszczêdzi czasu na modelach z wieloma submocelami
Root->AdjustDist(); // aktualizacja odleg³oœci faz LoD, zale¿nie od rozdzielczoœci
// pionowej oraz multisamplingu
if (Global::bUseVBO)
{
if (!m_pVNT) // jeœli nie ma jeszcze tablicy (wczytano z pliku tekstowego)
{ // tworzenie tymczasowej tablicy z wierzcho³kami ca³ego modelu
MakeArray(iNumVerts); // tworzenie tablic dla VBO
Root->RaArrayFill(m_pVNT); // wype³nianie tablicy
BuildVBOs(); // tworzenie VBO i usuwanie tablicy z pamiêci
}
else
BuildVBOs(false); // tworzenie VBO bez usuwania tablicy z pamiêci
}
else
{ // przygotowanie skompilowanych siatek dla DisplayLists
Root->DisplayLists(); // tworzenie skompilowanej listy dla submodelu
}
// if (Root->TextureID) //o ile ma teksturê
// Root->iFlags|=0x80; //koniecznoϾ ustawienia tekstury
}
}
};
void __fastcall TModel3d::SaveToBinFile(char *FileName)
{ // zapis modelu binarnego
WriteLog("Saving E3D binary model.");
int i, zero = 0;
TSubModelInfo *info = new TSubModelInfo[iSubModelsCount];
info->Reset();
Root->Info(); // zebranie informacji o submodelach
int len; //³¹czna d³ugoœæ pliku
int sub; // iloϾ submodeli (w bajtach)
int tra; // wielkoœæ obszaru transformów
int vnt; // wielkoœæ obszaru wierzcho³ków
int tex = 0; // wielkoϾ obszaru nazw tekstur
int nam = 0; // wielkoϾ obszaru nazw submodeli
sub = 8 + sizeof(TSubModel) * iSubModelsCount;
tra = info->iTotalTransforms ? 8 + 64 * info->iTotalTransforms : 0;
vnt = 8 + 32 * iNumVerts;
for (i = 0; i < iSubModelsCount; ++i)
{
tex += info[i].iTextureLen;
nam += info[i].iNameLen;
}
if (tex)
tex += 9; // 8 na nag³ówek i jeden ci¹g pusty (tylko znacznik koñca)
if (nam)
nam += 8;
len = 8 + sub + tra + vnt + tex + ((-tex) & 3) + nam + ((-nam) & 3);
TSubModel *roboczy = new TSubModel(); // bufor u¿ywany do zapisywania
// AnsiString *asN=&roboczy->asName,*asT=&roboczy->asTexture;
// roboczy->FirstInit(); //¿eby delete nie usuwa³o czego nie powinno
TFileStream *fs = new TFileStream(AnsiString(FileName), fmCreate);
fs->Write("E3D0", 4); // kromka g³ówna
fs->Write(&len, 4);
{
fs->Write("SUB0", 4); // dane submodeli
fs->Write(&sub, 4);
for (i = 0; i < iSubModelsCount; ++i)
{
roboczy->InfoSet(info + i);
fs->Write(roboczy, sizeof(TSubModel)); // zapis jednego submodelu
}
}
if (tra)
{ // zapis transformów
fs->Write("TRA0", 4); // transformy
fs->Write(&tra, 4);
for (i = 0; i < iSubModelsCount; ++i)
if (info[i].iTransform >= 0)
fs->Write(info[i].pSubModel->GetMatrix(), 16 * 4);
}
{ // zapis wierzcho³ków
MakeArray(iNumVerts); // tworzenie tablic dla VBO
Root->RaArrayFill(m_pVNT); // wype³nianie tablicy
fs->Write("VNT0", 4); // wierzcho³ki
fs->Write(&vnt, 4);
fs->Write(m_pVNT, 32 * iNumVerts);
}
if (tex) // mo¿e byæ jeden submodel ze zmienn¹ tekstur¹ i nazwy nie bêdzie
{ // zapis nazw tekstur
fs->Write("TEX0", 4); // nazwy tekstur
i = (tex + 3) & ~3; // zaokr¹glenie w górê
fs->Write(&i, 4);
fs->Write(&zero, 1); // ci¹g o numerze zero nie jest u¿ywany, ma tylko znacznik koñca
for (i = 0; i < iSubModelsCount; ++i)
if (info[i].iTextureLen)
fs->Write(info[i].pSubModel->pTexture, info[i].iTextureLen);
if ((-tex) & 3)
fs->Write(&zero, ((-tex) & 3)); // wyrównanie do wielokrotnoœci 4 bajtów
}
if (nam) // mo¿e byæ jeden anonimowy submodel w modelu
{ // zapis nazw submodeli
fs->Write("NAM0", 4); // nazwy submodeli
i = (nam + 3) & ~3; // zaokr¹glenie w górê
fs->Write(&i, 4);
for (i = 0; i < iSubModelsCount; ++i)
if (info[i].iNameLen)
fs->Write(info[i].pSubModel->pName, info[i].iNameLen);
if ((-nam) & 3)
fs->Write(&zero, ((-nam) & 3)); // wyrównanie do wielokrotnoœci 4 bajtów
}
delete fs;
// roboczy->FirstInit(); //¿eby delete nie usuwa³o czego nie powinno
// roboczy->iFlags=0; //¿eby delete nie usuwa³o czego nie powinno
// roboczy->asName)=asN;
//&roboczy->asTexture=asT;
delete roboczy;
delete[] info;
};
void __fastcall TModel3d::BreakHierarhy() { Error("Not implemented yet :("); };
/*
void __fastcall TModel3d::Render(vector3 pPosition,double fAngle,GLuint ReplacableSkinId,int iAlpha)
{
// glColor3f(1.0f,1.0f,1.0f);
// glColor3f(0.0f,0.0f,0.0f);
glPushMatrix();
glTranslated(pPosition.x,pPosition.y,pPosition.z);
if (fAngle!=0)
glRotatef(fAngle,0,1,0);
/*
matrix4x4 Identity;
Identity.Identity();
matrix4x4 CurrentMatrix;
glGetdoublev(GL_MODELVIEW_MATRIX,CurrentMatrix.getArray());
vector3 pos=vector3(0,0,0);
pos=CurrentMatrix*pos;
fSquareDist=SquareMagnitude(pos);
* /
fSquareDist=SquareMagnitude(pPosition-Global::GetCameraPosition());
#ifdef _DEBUG
if (Root)
Root->Render(ReplacableSkinId,iAlpha);
#else
Root->Render(ReplacableSkinId,iAlpha);
#endif
glPopMatrix();
};
*/
void __fastcall TModel3d::Render(double fSquareDistance, GLuint *ReplacableSkinId, int iAlpha)
{
iAlpha ^= 0x0F0F000F; // odwrócenie flag tekstur, aby wy³apaæ nieprzezroczyste
if (iAlpha & iFlags & 0x1F1F001F) // czy w ogóle jest co robiæ w tym cyklu?
{
TSubModel::fSquareDist = fSquareDistance; // zmienna globalna!
Root->ReplacableSet(ReplacableSkinId, iAlpha);
Root->RenderDL();
}
};
void __fastcall TModel3d::RenderAlpha(double fSquareDistance, GLuint *ReplacableSkinId, int iAlpha)
{
if (iAlpha & iFlags & 0x2F2F002F)
{
TSubModel::fSquareDist = fSquareDistance; // zmienna globalna!
Root->ReplacableSet(ReplacableSkinId, iAlpha);
Root->RenderAlphaDL();
}
};
/*
void __fastcall TModel3d::RaRender(vector3 pPosition,double fAngle,GLuint *ReplacableSkinId,int
iAlpha)
{
// glColor3f(1.0f,1.0f,1.0f);
// glColor3f(0.0f,0.0f,0.0f);
glPushMatrix(); //zapamiêtanie matrycy przekszta³cenia
glTranslated(pPosition.x,pPosition.y,pPosition.z);
if (fAngle!=0)
glRotatef(fAngle,0,1,0);
/*
matrix4x4 Identity;
Identity.Identity();
matrix4x4 CurrentMatrix;
glGetdoublev(GL_MODELVIEW_MATRIX,CurrentMatrix.getArray());
vector3 pos=vector3(0,0,0);
pos=CurrentMatrix*pos;
fSquareDist=SquareMagnitude(pos);
*/
/*
fSquareDist=SquareMagnitude(pPosition-Global::GetCameraPosition()); //zmienna globalna!
if (StartVBO())
{//odwrócenie flag, aby wy³apaæ nieprzezroczyste
Root->ReplacableSet(ReplacableSkinId,iAlpha^0x0F0F000F);
Root->RaRender();
EndVBO();
}
glPopMatrix(); //przywrócenie ustawieñ przekszta³cenia
};
*/
void __fastcall TModel3d::RaRender(double fSquareDistance, GLuint *ReplacableSkinId, int iAlpha)
{ // renderowanie specjalne, np. kabiny
iAlpha ^= 0x0F0F000F; // odwrócenie flag tekstur, aby wy³apaæ nieprzezroczyste
if (iAlpha & iFlags & 0x1F1F001F) // czy w ogóle jest co robiæ w tym cyklu?
{
TSubModel::fSquareDist = fSquareDistance; // zmienna globalna!
if (StartVBO())
{ // odwrócenie flag, aby wy³apaæ nieprzezroczyste
Root->ReplacableSet(ReplacableSkinId, iAlpha);
Root->pRoot = this;
Root->RenderVBO();
EndVBO();
}
}
};
void __fastcall TModel3d::RaRenderAlpha(double fSquareDistance, GLuint *ReplacableSkinId,
int iAlpha)
{ // renderowanie specjalne, np. kabiny
if (iAlpha & iFlags & 0x2F2F002F) // czy w ogóle jest co robiæ w tym cyklu?
{
TSubModel::fSquareDist = fSquareDistance; // zmienna globalna!
if (StartVBO())
{
Root->ReplacableSet(ReplacableSkinId, iAlpha);
Root->RenderAlphaVBO();
EndVBO();
}
}
};
/*
void __fastcall TModel3d::RaRenderAlpha(vector3 pPosition,double fAngle,GLuint *ReplacableSkinId,int
iAlpha)
{
glPushMatrix();
glTranslatef(pPosition.x,pPosition.y,pPosition.z);
if (fAngle!=0)
glRotatef(fAngle,0,1,0);
fSquareDist=SquareMagnitude(pPosition-Global::GetCameraPosition()); //zmienna globalna!
if (StartVBO())
{Root->ReplacableSet(ReplacableSkinId,iAlpha);
Root->RaRenderAlpha();
EndVBO();
}
glPopMatrix();
};
*/
//-----------------------------------------------------------------------------
// 2011-03-16 cztery nowe funkcje renderowania z mo¿liwoœci¹ pochylania obiektów
//-----------------------------------------------------------------------------
void __fastcall TModel3d::Render(vector3 *vPosition, vector3 *vAngle, GLuint *ReplacableSkinId,
int iAlpha)
{ // nieprzezroczyste, Display List
glPushMatrix();
glTranslated(vPosition->x, vPosition->y, vPosition->z);
if (vAngle->y != 0.0)
glRotated(vAngle->y, 0.0, 1.0, 0.0);
if (vAngle->x != 0.0)
glRotated(vAngle->x, 1.0, 0.0, 0.0);
if (vAngle->z != 0.0)
glRotated(vAngle->z, 0.0, 0.0, 1.0);
TSubModel::fSquareDist =
SquareMagnitude(*vPosition - Global::GetCameraPosition()); // zmienna globalna!
// odwrócenie flag, aby wy³apaæ nieprzezroczyste
Root->ReplacableSet(ReplacableSkinId, iAlpha ^ 0x0F0F000F);
Root->RenderDL();
glPopMatrix();
};
void __fastcall TModel3d::RenderAlpha(vector3 *vPosition, vector3 *vAngle, GLuint *ReplacableSkinId,
int iAlpha)
{ // przezroczyste, Display List
glPushMatrix();
glTranslated(vPosition->x, vPosition->y, vPosition->z);
if (vAngle->y != 0.0)
glRotated(vAngle->y, 0.0, 1.0, 0.0);
if (vAngle->x != 0.0)
glRotated(vAngle->x, 1.0, 0.0, 0.0);
if (vAngle->z != 0.0)
glRotated(vAngle->z, 0.0, 0.0, 1.0);
TSubModel::fSquareDist =
SquareMagnitude(*vPosition - Global::GetCameraPosition()); // zmienna globalna!
Root->ReplacableSet(ReplacableSkinId, iAlpha);
Root->RenderAlphaDL();
glPopMatrix();
};
void __fastcall TModel3d::RaRender(vector3 *vPosition, vector3 *vAngle, GLuint *ReplacableSkinId,
int iAlpha)
{ // nieprzezroczyste, VBO
glPushMatrix();
glTranslated(vPosition->x, vPosition->y, vPosition->z);
if (vAngle->y != 0.0)
glRotated(vAngle->y, 0.0, 1.0, 0.0);
if (vAngle->x != 0.0)
glRotated(vAngle->x, 1.0, 0.0, 0.0);
if (vAngle->z != 0.0)
glRotated(vAngle->z, 0.0, 0.0, 1.0);
TSubModel::fSquareDist =
SquareMagnitude(*vPosition - Global::GetCameraPosition()); // zmienna globalna!
if (StartVBO())
{ // odwrócenie flag, aby wy³apaæ nieprzezroczyste
Root->ReplacableSet(ReplacableSkinId, iAlpha ^ 0x0F0F000F);
Root->RenderVBO();
EndVBO();
}
glPopMatrix();
};
void __fastcall TModel3d::RaRenderAlpha(vector3 *vPosition, vector3 *vAngle,
GLuint *ReplacableSkinId, int iAlpha)
{ // przezroczyste, VBO
glPushMatrix();
glTranslated(vPosition->x, vPosition->y, vPosition->z);
if (vAngle->y != 0.0)
glRotated(vAngle->y, 0.0, 1.0, 0.0);
if (vAngle->x != 0.0)
glRotated(vAngle->x, 1.0, 0.0, 0.0);
if (vAngle->z != 0.0)
glRotated(vAngle->z, 0.0, 0.0, 1.0);
TSubModel::fSquareDist =
SquareMagnitude(*vPosition - Global::GetCameraPosition()); // zmienna globalna!
if (StartVBO())
{
Root->ReplacableSet(ReplacableSkinId, iAlpha);
Root->RenderAlphaVBO();
EndVBO();
}
glPopMatrix();
};
//-----------------------------------------------------------------------------
// 2012-02 funkcje do tworzenia terenu z E3D
//-----------------------------------------------------------------------------
int __fastcall TModel3d::TerrainCount()
{ // zliczanie kwadratów kilometrowych (g³ówna linia po Next) do tworznia tablicy
int i = 0;
TSubModel *r = Root;
while (r)
{
r = r->NextGet();
++i;
}
return i;
};
TSubModel *__fastcall TModel3d::TerrainSquare(int n)
{ // pobieranie wskaŸnika do submodelu (n)
int i = 0;
TSubModel *r = Root;
while (i < n)
{
r = r->NextGet();
++i;
}
r->UnFlagNext(); // blokowanie wyœwietlania po Next g³ównej listy
return r;
};
void __fastcall TModel3d::TerrainRenderVBO(int n)
{ // renderowanie terenu z VBO
glPushMatrix();
// glTranslated(vPosition->x,vPosition->y,vPosition->z);
// if (vAngle->y!=0.0) glRotated(vAngle->y,0.0,1.0,0.0);
// if (vAngle->x!=0.0) glRotated(vAngle->x,1.0,0.0,0.0);
// if (vAngle->z!=0.0) glRotated(vAngle->z,0.0,0.0,1.0);
// TSubModel::fSquareDist=SquareMagnitude(*vPosition-Global::GetCameraPosition()); //zmienna
// globalna!
if (StartVBO())
{ // odwrócenie flag, aby wy³apaæ nieprzezroczyste
// Root->ReplacableSet(ReplacableSkinId,iAlpha^0x0F0F000F);
TSubModel *r = Root;
while (r)
{
if (r->iVisible == n) // tylko jeœli ma byæ widoczny w danej ramce (problem dla
// 0==false)
r->RenderVBO(); // sub kolejne (Next) siê nie wyrenderuj¹
r = r->NextGet();
}
EndVBO();
}
glPopMatrix();
};
Reference in New Issue View Git Blame Copy Permalink