mirror of
https://github.com/MaSzyna-EU07/maszyna.git
synced 2026-03-22 15:05:03 +01:00
Konwersja na UTF-8
Konwersja na UTF-8 Konwersja na UTF-8 Konwersja na UTF-8 Konwersja na UTF-8 Konwersja do UTF-8 Konwersja na UTF-8 Konwersja na UTF-8 Konwersja na UTF-8
This commit is contained in:
firleju
306
Segment.cpp
306
Segment.cpp
@@ -19,10 +19,10 @@ http://mozilla.org/MPL/2.0/.
|
||||
//---------------------------------------------------------------------------
|
||||
|
||||
// 101206 Ra: trapezoidalne drogi
|
||||
// 110806 Ra: odwrócone mapowanie wzdłuż - Point1 == 1.0
|
||||
// 110806 Ra: odwrócone mapowanie wzdłuż - Point1 == 1.0
|
||||
|
||||
std::string Where(vector3 p)
|
||||
{ // zamiana współrzędnych na tekst, używana w błędach
|
||||
{ // zamiana współrzędnych na tekst, używana w błędach
|
||||
return std::to_string(p.x) + " " + std::to_string(p.y) + " " + std::to_string(p.z);
|
||||
};
|
||||
|
||||
@@ -44,17 +44,17 @@ TSegment::~TSegment()
|
||||
|
||||
bool TSegment::Init(vector3 NewPoint1, vector3 NewPoint2, double fNewStep, double fNewRoll1,
|
||||
double fNewRoll2)
|
||||
{ // wersja dla prostego - wyliczanie punktów kontrolnych
|
||||
{ // wersja dla prostego - wyliczanie punktów kontrolnych
|
||||
vector3 dir;
|
||||
if (fNewRoll1 == fNewRoll2)
|
||||
{ // faktyczny prosty
|
||||
dir = Normalize(NewPoint2 - NewPoint1); // wektor kierunku o długości 1
|
||||
dir = Normalize(NewPoint2 - NewPoint1); // wektor kierunku o długości 1
|
||||
return TSegment::Init(NewPoint1, dir, -dir, NewPoint2, fNewStep, fNewRoll1, fNewRoll2,
|
||||
false);
|
||||
}
|
||||
else
|
||||
{ // prosty ze zmienną przechyłką musi być segmentowany jak krzywe
|
||||
dir = (NewPoint2 - NewPoint1) / 3.0; // punkty kontrolne prostego są w 1/3 długości
|
||||
{ // prosty ze zmienną przechyłką musi być segmentowany jak krzywe
|
||||
dir = (NewPoint2 - NewPoint1) / 3.0; // punkty kontrolne prostego są w 1/3 długości
|
||||
return TSegment::Init(NewPoint1, NewPoint1 + dir, NewPoint2 - dir, NewPoint2, fNewStep,
|
||||
fNewRoll1, fNewRoll2, true);
|
||||
}
|
||||
@@ -68,41 +68,41 @@ bool TSegment::Init(vector3 &NewPoint1, vector3 NewCPointOut, vector3 NewCPointI
|
||||
CPointOut = NewCPointOut;
|
||||
CPointIn = NewCPointIn;
|
||||
Point2 = NewPoint2;
|
||||
// poprawienie przechyłki
|
||||
fRoll1 = DegToRad(fNewRoll1); // Ra: przeliczone jest bardziej przydatne do obliczeń
|
||||
// poprawienie przechyłki
|
||||
fRoll1 = DegToRad(fNewRoll1); // Ra: przeliczone jest bardziej przydatne do obliczeń
|
||||
fRoll2 = DegToRad(fNewRoll2);
|
||||
if (Global::bRollFix)
|
||||
{ // Ra: poprawianie przechyłki
|
||||
// Przechyłka powinna być na środku wewnętrznej szyny, a standardowo jest w osi
|
||||
// toru. Dlatego trzeba podnieść tor oraz odpowiednio podwyższyć podsypkę.
|
||||
// Nie wykonywać tej funkcji, jeśli podwyższenie zostało uwzględnione w edytorze.
|
||||
// Problematyczne mogą byc rozjazdy na przechyłce - lepiej je modelować w edytorze.
|
||||
// Na razie wszystkie scenerie powinny być poprawiane.
|
||||
// Jedynie problem będzie z podwójną rampą przechyłkową, która w środku będzie
|
||||
// mieć moment wypoziomowania, ale musi on być również podniesiony.
|
||||
{ // Ra: poprawianie przechyłki
|
||||
// Przechyłka powinna być na środku wewnętrznej szyny, a standardowo jest w osi
|
||||
// toru. Dlatego trzeba podnieść tor oraz odpowiednio podwyższyć podsypkę.
|
||||
// Nie wykonywać tej funkcji, jeśli podwyższenie zostało uwzględnione w edytorze.
|
||||
// Problematyczne mogą byc rozjazdy na przechyłce - lepiej je modelować w edytorze.
|
||||
// Na razie wszystkie scenerie powinny być poprawiane.
|
||||
// Jedynie problem będzie z podwójną rampą przechyłkową, która w środku będzie
|
||||
// mieć moment wypoziomowania, ale musi on być również podniesiony.
|
||||
if (fRoll1 != 0.0)
|
||||
{ // tylko jeśli jest przechyłka
|
||||
{ // tylko jeśli jest przechyłka
|
||||
double w1 = fabs(sin(fRoll1) * 0.75); // 0.5*w2+0.0325; //0.75m dla 1.435
|
||||
Point1.y += w1; // modyfikacja musi być przed policzeniem dalszych parametrów
|
||||
Point1.y += w1; // modyfikacja musi być przed policzeniem dalszych parametrów
|
||||
if (bCurve)
|
||||
CPointOut.y += w1; // prosty ma wektory jednostkowe
|
||||
pOwner->MovedUp1(w1); // zwrócić trzeba informację o podwyższeniu podsypki
|
||||
pOwner->MovedUp1(w1); // zwrócić trzeba informację o podwyższeniu podsypki
|
||||
}
|
||||
if (fRoll2 != 0.0)
|
||||
{
|
||||
double w2 = fabs(sin(fRoll2) * 0.75); // 0.5*w2+0.0325; //0.75m dla 1.435
|
||||
Point2.y += w2; // modyfikacja musi być przed policzeniem dalszych parametrów
|
||||
Point2.y += w2; // modyfikacja musi być przed policzeniem dalszych parametrów
|
||||
if (bCurve)
|
||||
CPointIn.y += w2; // prosty ma wektory jednostkowe
|
||||
// zwrócić trzeba informację o podwyższeniu podsypki
|
||||
// zwrócić trzeba informację o podwyższeniu podsypki
|
||||
}
|
||||
}
|
||||
// Ra: ten kąt jeszcze do przemyślenia jest
|
||||
// Ra: ten kąt jeszcze do przemyślenia jest
|
||||
fDirection = -atan2(Point2.x - Point1.x,
|
||||
Point2.z - Point1.z); // kąt w planie, żeby nie liczyć wielokrotnie
|
||||
Point2.z - Point1.z); // kąt w planie, żeby nie liczyć wielokrotnie
|
||||
bCurve = bIsCurve;
|
||||
if (bCurve)
|
||||
{ // przeliczenie współczynników wielomianu, będzie mniej mnożeń i można policzyć pochodne
|
||||
{ // przeliczenie współczynników wielomianu, będzie mniej mnożeń i można policzyć pochodne
|
||||
vC = 3.0 * (CPointOut - Point1); // t^1
|
||||
vB = 3.0 * (CPointIn - CPointOut) - vC; // t^2
|
||||
vA = Point2 - Point1 - vC - vB; // t^3
|
||||
@@ -115,17 +115,17 @@ bool TSegment::Init(vector3 &NewPoint1, vector3 NewCPointOut, vector3 NewCPointI
|
||||
{
|
||||
ErrorLog("Bad geometry: Length <= 0 in TSegment::Init at " + Where(Point1));
|
||||
// MessageBox(0,"Length<=0","TSegment::Init",MB_OK);
|
||||
return false; // zerowe nie mogą być
|
||||
return false; // zerowe nie mogą być
|
||||
}
|
||||
fStoop = atan2((Point2.y - Point1.y),
|
||||
fLength); // pochylenie toru prostego, żeby nie liczyć wielokrotnie
|
||||
fLength); // pochylenie toru prostego, żeby nie liczyć wielokrotnie
|
||||
SafeDeleteArray(fTsBuffer);
|
||||
if ((bCurve) && (fStep > 0))
|
||||
{ // Ra: prosty dostanie podział, jak ma różną przechyłkę na końcach
|
||||
{ // Ra: prosty dostanie podział, jak ma różną przechyłkę na końcach
|
||||
double s = 0;
|
||||
int i = 0;
|
||||
iSegCount = ceil(fLength / fStep); // potrzebne do VBO
|
||||
// fStep=fLength/(double)(iSegCount-1); //wyrównanie podziału
|
||||
// fStep=fLength/(double)(iSegCount-1); //wyrównanie podziału
|
||||
fTsBuffer = new double[iSegCount + 1];
|
||||
fTsBuffer[0] = 0; /* TODO : fix fTsBuffer */
|
||||
while (s < fLength)
|
||||
@@ -138,7 +138,7 @@ bool TSegment::Init(vector3 &NewPoint1, vector3 NewCPointOut, vector3 NewCPointI
|
||||
}
|
||||
}
|
||||
if (fLength > 500)
|
||||
{ // tor ma pojemność 40 pojazdów, więc nie może być za długi
|
||||
{ // tor ma pojemność 40 pojazdów, więc nie może być za długi
|
||||
ErrorLog("Bad geometry: Length > 500m at " + Where(Point1));
|
||||
// MessageBox(0,"Length>500","TSegment::Init",MB_OK);
|
||||
return false;
|
||||
@@ -226,83 +226,83 @@ double TSegment::GetTFromS(double s)
|
||||
};
|
||||
|
||||
vector3 TSegment::RaInterpolate(double t)
|
||||
{ // wyliczenie XYZ na krzywej Beziera z użyciem współczynników
|
||||
return t * (t * (t * vA + vB) + vC) + Point1; // 9 mnożeń, 9 dodawań
|
||||
{ // wyliczenie XYZ na krzywej Beziera z użyciem współczynników
|
||||
return t * (t * (t * vA + vB) + vC) + Point1; // 9 mnożeń, 9 dodawań
|
||||
};
|
||||
|
||||
vector3 TSegment::RaInterpolate0(double t)
|
||||
{ // wyliczenie XYZ na krzywej Beziera, na użytek liczenia długości nie jest dodawane Point1
|
||||
return t * (t * (t * vA + vB) + vC); // 9 mnożeń, 6 dodawań
|
||||
{ // wyliczenie XYZ na krzywej Beziera, na użytek liczenia długości nie jest dodawane Point1
|
||||
return t * (t * (t * vA + vB) + vC); // 9 mnożeń, 6 dodawań
|
||||
};
|
||||
|
||||
double TSegment::ComputeLength() // McZapkie-150503: dlugosc miedzy punktami krzywej
|
||||
{ // obliczenie długości krzywej Beziera za pomocą interpolacji odcinkami
|
||||
// Ra: zamienić na liczenie rekurencyjne średniej z cięciwy i łamanej po kontrolnych
|
||||
// Ra: koniec rekurencji jeśli po podziale suma długości nie różni się więcej niż 0.5mm od
|
||||
{ // obliczenie długości krzywej Beziera za pomocą interpolacji odcinkami
|
||||
// Ra: zamienić na liczenie rekurencyjne średniej z cięciwy i łamanej po kontrolnych
|
||||
// Ra: koniec rekurencji jeśli po podziale suma długości nie różni się więcej niż 0.5mm od
|
||||
// poprzedniej
|
||||
// Ra: ewentualnie rozpoznać łuk okręgu płaskiego i liczyć ze wzoru na długość łuku
|
||||
// Ra: ewentualnie rozpoznać łuk okręgu płaskiego i liczyć ze wzoru na długość łuku
|
||||
double t, l = 0;
|
||||
vector3 last = vector3(0, 0, 0); // długość liczona po przesunięciu odcinka do początku układu
|
||||
vector3 last = vector3(0, 0, 0); // długość liczona po przesunięciu odcinka do początku układu
|
||||
vector3 tmp = Point2 - Point1;
|
||||
int m = 20.0 * tmp.Length(); // było zawsze do 10000, teraz jest liczone odcinkami po około 5cm
|
||||
int m = 20.0 * tmp.Length(); // było zawsze do 10000, teraz jest liczone odcinkami po około 5cm
|
||||
for (int i = 1; i <= m; i++)
|
||||
{
|
||||
t = double(i) / double(m); // wyznaczenie parametru na krzywej z przedziału (0,1>
|
||||
t = double(i) / double(m); // wyznaczenie parametru na krzywej z przedziału (0,1>
|
||||
// tmp=Interpolate(t,p1,cp1,cp2,p2);
|
||||
tmp = RaInterpolate0(t); // obliczenie punktu dla tego parametru
|
||||
t = vector3(tmp - last).Length(); // obliczenie długości wektora
|
||||
l += t; // zwiększenie wyliczanej długości
|
||||
t = vector3(tmp - last).Length(); // obliczenie długości wektora
|
||||
l += t; // zwiększenie wyliczanej długości
|
||||
last = tmp;
|
||||
}
|
||||
return (l);
|
||||
}
|
||||
|
||||
const double fDirectionOffset = 0.1; // długość wektora do wyliczenia kierunku
|
||||
const double fDirectionOffset = 0.1; // długość wektora do wyliczenia kierunku
|
||||
|
||||
vector3 TSegment::GetDirection(double fDistance)
|
||||
{ // takie toporne liczenie pochodnej dla podanego dystansu od Point1
|
||||
double t1 = GetTFromS(fDistance - fDirectionOffset);
|
||||
if (t1 <= 0.0)
|
||||
return (CPointOut - Point1); // na zewnątrz jako prosta
|
||||
return (CPointOut - Point1); // na zewnątrz jako prosta
|
||||
double t2 = GetTFromS(fDistance + fDirectionOffset);
|
||||
if (t2 >= 1.0)
|
||||
return (Point1 - CPointIn); // na zewnątrz jako prosta
|
||||
return (Point1 - CPointIn); // na zewnątrz jako prosta
|
||||
return (FastGetPoint(t2) - FastGetPoint(t1));
|
||||
}
|
||||
|
||||
vector3 TSegment::FastGetDirection(double fDistance, double fOffset)
|
||||
{ // takie toporne liczenie pochodnej dla parametru 0.0÷1.0
|
||||
{ // takie toporne liczenie pochodnej dla parametru 0.0÷1.0
|
||||
double t1 = fDistance - fOffset;
|
||||
if (t1 <= 0.0)
|
||||
return (CPointOut - Point1); // wektor na początku jest stały
|
||||
return (CPointOut - Point1); // wektor na początku jest stały
|
||||
double t2 = fDistance + fOffset;
|
||||
if (t2 >= 1.0)
|
||||
return (Point2 - CPointIn); // wektor na końcu jest stały
|
||||
return (Point2 - CPointIn); // wektor na końcu jest stały
|
||||
return (FastGetPoint(t2) - FastGetPoint(t1));
|
||||
}
|
||||
|
||||
vector3 TSegment::GetPoint(double fDistance)
|
||||
{ // wyliczenie współrzędnych XYZ na torze w odległości (fDistance) od Point1
|
||||
{ // wyliczenie współrzędnych XYZ na torze w odległości (fDistance) od Point1
|
||||
if (bCurve)
|
||||
{ // można by wprowadzić uproszczony wzór dla okręgów płaskich
|
||||
{ // można by wprowadzić uproszczony wzór dla okręgów płaskich
|
||||
double t = GetTFromS(fDistance); // aproksymacja dystansu na krzywej Beziera
|
||||
// return Interpolate(t,Point1,CPointOut,CPointIn,Point2);
|
||||
return RaInterpolate(t);
|
||||
}
|
||||
else
|
||||
{ // wyliczenie dla odcinka prostego jest prostsze
|
||||
double t = fDistance / fLength; // zerowych torów nie ma
|
||||
double t = fDistance / fLength; // zerowych torów nie ma
|
||||
return ((1.0 - t) * Point1 + (t)*Point2);
|
||||
}
|
||||
};
|
||||
|
||||
void TSegment::RaPositionGet(double fDistance, vector3 &p, vector3 &a)
|
||||
{ // ustalenie pozycji osi na torze, przechyłki, pochylenia i kierunku jazdy
|
||||
{ // ustalenie pozycji osi na torze, przechyłki, pochylenia i kierunku jazdy
|
||||
if (bCurve)
|
||||
{ // można by wprowadzić uproszczony wzór dla okręgów płaskich
|
||||
{ // można by wprowadzić uproszczony wzór dla okręgów płaskich
|
||||
double t = GetTFromS(fDistance); // aproksymacja dystansu na krzywej Beziera na parametr (t)
|
||||
p = RaInterpolate(t);
|
||||
a.x = (1.0 - t) * fRoll1 + (t)*fRoll2; // przechyłka w danym miejscu (zmienia się liniowo)
|
||||
a.x = (1.0 - t) * fRoll1 + (t)*fRoll2; // przechyłka w danym miejscu (zmienia się liniowo)
|
||||
// pochodna jest 3*A*t^2+2*B*t+C
|
||||
a.y = atan(t * (t * 3.0 * vA.y + vB.y + vB.y) + vC.y); // pochylenie krzywej (w pionie)
|
||||
a.z = -atan2(t * (t * 3.0 * vA.x + vB.x + vB.x) + vC.x,
|
||||
@@ -310,9 +310,9 @@ void TSegment::RaPositionGet(double fDistance, vector3 &p, vector3 &a)
|
||||
}
|
||||
else
|
||||
{ // wyliczenie dla odcinka prostego jest prostsze
|
||||
double t = fDistance / fLength; // zerowych torów nie ma
|
||||
double t = fDistance / fLength; // zerowych torów nie ma
|
||||
p = ((1.0 - t) * Point1 + (t)*Point2);
|
||||
a.x = (1.0 - t) * fRoll1 + (t)*fRoll2; // przechyłka w danym miejscu (zmienia się liniowo)
|
||||
a.x = (1.0 - t) * fRoll1 + (t)*fRoll2; // przechyłka w danym miejscu (zmienia się liniowo)
|
||||
a.y = fStoop; // pochylenie toru prostego
|
||||
a.z = fDirection; // kierunek toru w planie
|
||||
}
|
||||
@@ -326,32 +326,32 @@ vector3 TSegment::FastGetPoint(double t)
|
||||
|
||||
void TSegment::RenderLoft(const vector6 *ShapePoints, int iNumShapePoints, double fTextureLength,
|
||||
int iSkip, int iQualityFactor, vector3 **p, bool bRender)
|
||||
{ // generowanie trójkątów dla odcinka trajektorii ruchu
|
||||
// standardowo tworzy triangle_strip dla prostego albo ich zestaw dla łuku
|
||||
{ // generowanie trójkątów dla odcinka trajektorii ruchu
|
||||
// standardowo tworzy triangle_strip dla prostego albo ich zestaw dla łuku
|
||||
// po modyfikacji - dla ujemnego (iNumShapePoints) w dodatkowych polach tabeli
|
||||
// podany jest przekrój końcowy
|
||||
// podsypka toru jest robiona za pomocą 6 punktów, szyna 12, drogi i rzeki na 3+2+3
|
||||
// podany jest przekrój końcowy
|
||||
// podsypka toru jest robiona za pomocą 6 punktów, szyna 12, drogi i rzeki na 3+2+3
|
||||
if (iQualityFactor < 1)
|
||||
iQualityFactor = 1; // co który segment ma być uwzględniony
|
||||
iQualityFactor = 1; // co który segment ma być uwzględniony
|
||||
vector3 pos1, pos2, dir, parallel1, parallel2, pt, norm;
|
||||
double s, step, fOffset, tv1, tv2, t;
|
||||
int i, j;
|
||||
bool trapez = iNumShapePoints < 0; // sygnalizacja trapezowatości
|
||||
bool trapez = iNumShapePoints < 0; // sygnalizacja trapezowatości
|
||||
iNumShapePoints = abs(iNumShapePoints);
|
||||
if (bCurve)
|
||||
{
|
||||
double m1, jmm1, m2, jmm2; // pozycje względne na odcinku 0...1 (ale nie parametr Beziera)
|
||||
tv1 = 1.0; // Ra: to by można było wyliczać dla odcinka, wyglądało by lepiej
|
||||
double m1, jmm1, m2, jmm2; // pozycje względne na odcinku 0...1 (ale nie parametr Beziera)
|
||||
tv1 = 1.0; // Ra: to by można było wyliczać dla odcinka, wyglądało by lepiej
|
||||
step = fStep * iQualityFactor;
|
||||
s = fStep * iSkip; // iSkip - ile odcinków z początku pominąć
|
||||
i = iSkip; // domyślnie 0
|
||||
s = fStep * iSkip; // iSkip - ile odcinków z początku pominąć
|
||||
i = iSkip; // domyślnie 0
|
||||
if (!fTsBuffer)
|
||||
return; // prowizoryczne zabezpieczenie przed wysypem - ustalić faktyczną przyczynę
|
||||
return; // prowizoryczne zabezpieczenie przed wysypem - ustalić faktyczną przyczynę
|
||||
if (i > iSegCount)
|
||||
return; // prowizoryczne zabezpieczenie przed wysypem - ustalić faktyczną przyczynę
|
||||
t = fTsBuffer[i]; // tabela watości t dla segmentów
|
||||
return; // prowizoryczne zabezpieczenie przed wysypem - ustalić faktyczną przyczynę
|
||||
t = fTsBuffer[i]; // tabela watości t dla segmentów
|
||||
fOffset = 0.1 / fLength; // pierwsze 10cm
|
||||
pos1 = FastGetPoint(t); // wektor początku segmentu
|
||||
pos1 = FastGetPoint(t); // wektor początku segmentu
|
||||
dir = FastGetDirection(t, fOffset); // wektor kierunku
|
||||
// parallel1=Normalize(CrossProduct(dir,vector3(0,1,0))); //wektor poprzeczny
|
||||
parallel1 = Normalize(vector3(-dir.z, 0.0, dir.x)); // wektor poprzeczny
|
||||
@@ -360,23 +360,23 @@ void TSegment::RenderLoft(const vector6 *ShapePoints, int iNumShapePoints, doubl
|
||||
while (s < fLength)
|
||||
{
|
||||
// step=SquareMagnitude(Global::GetCameraPosition()+pos);
|
||||
i += iQualityFactor; // kolejny punkt łamanej
|
||||
s += step; // końcowa pozycja segmentu [m]
|
||||
i += iQualityFactor; // kolejny punkt łamanej
|
||||
s += step; // końcowa pozycja segmentu [m]
|
||||
m1 = m2;
|
||||
jmm1 = jmm2; // stara pozycja
|
||||
m2 = s / fLength;
|
||||
jmm2 = 1.0 - m2; // nowa pozycja
|
||||
if (s > fLength - 0.5) // Ra: -0.5 żeby nie robiło cieniasa na końcu
|
||||
{ // gdy przekroczyliśmy koniec - stąd dziury w torach...
|
||||
if (s > fLength - 0.5) // Ra: -0.5 żeby nie robiło cieniasa na końcu
|
||||
{ // gdy przekroczyliśmy koniec - stąd dziury w torach...
|
||||
step -= (s - fLength); // jeszcze do wyliczenia mapowania potrzebny
|
||||
s = fLength;
|
||||
i = iSegCount; // 20/5 ma dawać 4
|
||||
i = iSegCount; // 20/5 ma dawać 4
|
||||
m2 = 1.0;
|
||||
jmm2 = 0.0;
|
||||
}
|
||||
while (tv1 < 0.0)
|
||||
tv1 += 1.0; // przestawienie mapowania
|
||||
tv2 = tv1 - step / fTextureLength; // mapowanie na końcu segmentu
|
||||
tv2 = tv1 - step / fTextureLength; // mapowanie na końcu segmentu
|
||||
t = fTsBuffer[i]; // szybsze od GetTFromS(s);
|
||||
pos2 = FastGetPoint(t);
|
||||
dir = FastGetDirection(t, fOffset); // nowy wektor kierunku
|
||||
@@ -394,21 +394,21 @@ void TSegment::RenderLoft(const vector6 *ShapePoints, int iNumShapePoints, doubl
|
||||
pos1;
|
||||
pt.y += jmm1 * ShapePoints[j].y + m1 * ShapePoints[j + iNumShapePoints].y;
|
||||
if (bRender)
|
||||
{ // skrzyżowania podczas łączenia siatek mogą nie renderować poboczy, ale
|
||||
// potrzebować punktów
|
||||
{ // skrzyżowania podczas łączenia siatek mogą nie renderować poboczy, ale
|
||||
// potrzebować punktów
|
||||
glNormal3f(norm.x, norm.y, norm.z);
|
||||
glTexCoord2f(
|
||||
jmm1 * ShapePoints[j].z + m1 * ShapePoints[j + iNumShapePoints].z, tv1);
|
||||
glVertex3f(pt.x, pt.y, pt.z); // pt nie mamy gdzie zapamiętać?
|
||||
glVertex3f(pt.x, pt.y, pt.z); // pt nie mamy gdzie zapamiętać?
|
||||
}
|
||||
if (p) // jeśli jest wskaźnik do tablicy
|
||||
if (p) // jeśli jest wskaźnik do tablicy
|
||||
if (*p)
|
||||
if (!j) // to dla pierwszego punktu
|
||||
{
|
||||
*(*p) = pt;
|
||||
(*p)++;
|
||||
} // zapamiętanie brzegu jezdni
|
||||
// dla trapezu drugi koniec ma inne współrzędne
|
||||
} // zapamiętanie brzegu jezdni
|
||||
// dla trapezu drugi koniec ma inne współrzędne
|
||||
norm = (jmm1 * ShapePoints[j].n.x + m1 * ShapePoints[j + iNumShapePoints].n.x) *
|
||||
parallel2;
|
||||
norm.y += jmm1 * ShapePoints[j].n.y + m1 * ShapePoints[j + iNumShapePoints].n.y;
|
||||
@@ -417,39 +417,39 @@ void TSegment::RenderLoft(const vector6 *ShapePoints, int iNumShapePoints, doubl
|
||||
pos2;
|
||||
pt.y += jmm2 * ShapePoints[j].y + m2 * ShapePoints[j + iNumShapePoints].y;
|
||||
if (bRender)
|
||||
{ // skrzyżowania podczas łączenia siatek mogą nie renderować poboczy, ale
|
||||
// potrzebować punktów
|
||||
{ // skrzyżowania podczas łączenia siatek mogą nie renderować poboczy, ale
|
||||
// potrzebować punktów
|
||||
glNormal3f(norm.x, norm.y, norm.z);
|
||||
glTexCoord2f(
|
||||
jmm2 * ShapePoints[j].z + m2 * ShapePoints[j + iNumShapePoints].z, tv2);
|
||||
glVertex3f(pt.x, pt.y, pt.z);
|
||||
}
|
||||
if (p) // jeśli jest wskaźnik do tablicy
|
||||
if (p) // jeśli jest wskaźnik do tablicy
|
||||
if (*p)
|
||||
if (!j) // to dla pierwszego punktu
|
||||
if (i == iSegCount)
|
||||
{
|
||||
*(*p) = pt;
|
||||
(*p)++;
|
||||
} // zapamiętanie brzegu jezdni
|
||||
} // zapamiętanie brzegu jezdni
|
||||
}
|
||||
else
|
||||
for (j = 0; j < iNumShapePoints; j++)
|
||||
{ //łuk z jednym profilem
|
||||
{ //łuk z jednym profilem
|
||||
norm = ShapePoints[j].n.x * parallel1;
|
||||
norm.y += ShapePoints[j].n.y;
|
||||
pt = parallel1 * ShapePoints[j].x + pos1;
|
||||
pt.y += ShapePoints[j].y;
|
||||
glNormal3f(norm.x, norm.y, norm.z);
|
||||
glTexCoord2f(ShapePoints[j].z, tv1);
|
||||
glVertex3f(pt.x, pt.y, pt.z); // punkt na początku odcinka
|
||||
glVertex3f(pt.x, pt.y, pt.z); // punkt na początku odcinka
|
||||
norm = ShapePoints[j].n.x * parallel2;
|
||||
norm.y += ShapePoints[j].n.y;
|
||||
pt = parallel2 * ShapePoints[j].x + pos2;
|
||||
pt.y += ShapePoints[j].y;
|
||||
glNormal3f(norm.x, norm.y, norm.z);
|
||||
glTexCoord2f(ShapePoints[j].z, tv2);
|
||||
glVertex3f(pt.x, pt.y, pt.z); // punkt na końcu odcinka
|
||||
glVertex3f(pt.x, pt.y, pt.z); // punkt na końcu odcinka
|
||||
}
|
||||
glEnd();
|
||||
pos1 = pos2;
|
||||
@@ -475,11 +475,11 @@ void TSegment::RenderLoft(const vector6 *ShapePoints, int iNumShapePoints, doubl
|
||||
glNormal3f(norm.x, norm.y, norm.z);
|
||||
glTexCoord2f(ShapePoints[j].z, 0);
|
||||
glVertex3f(pt.x, pt.y, pt.z);
|
||||
// dla trapezu drugi koniec ma inne współrzędne względne
|
||||
// dla trapezu drugi koniec ma inne współrzędne względne
|
||||
norm = ShapePoints[j + iNumShapePoints].n.x * parallel1;
|
||||
norm.y += ShapePoints[j + iNumShapePoints].n.y;
|
||||
pt = parallel1 * ShapePoints[j + iNumShapePoints].x + pos2; // odsunięcie
|
||||
pt.y += ShapePoints[j + iNumShapePoints].y; // wysokość
|
||||
pt = parallel1 * ShapePoints[j + iNumShapePoints].x + pos2; // odsunięcie
|
||||
pt.y += ShapePoints[j + iNumShapePoints].y; // wysokość
|
||||
glNormal3f(norm.x, norm.y, norm.z);
|
||||
glTexCoord2f(ShapePoints[j + iNumShapePoints].z, fLength / fTextureLength);
|
||||
glVertex3f(pt.x, pt.y, pt.z);
|
||||
@@ -507,26 +507,26 @@ void TSegment::RenderLoft(const vector6 *ShapePoints, int iNumShapePoints, doubl
|
||||
void TSegment::RenderSwitchRail(const vector6 *ShapePoints1, const vector6 *ShapePoints2,
|
||||
int iNumShapePoints, double fTextureLength, int iSkip,
|
||||
double fOffsetX)
|
||||
{ // tworzenie siatki trójkątów dla iglicy
|
||||
{ // tworzenie siatki trójkątów dla iglicy
|
||||
vector3 pos1, pos2, dir, parallel1, parallel2, pt;
|
||||
double a1, a2, s, step, offset, tv1, tv2, t, t2, t2step, oldt2, sp, oldsp;
|
||||
int i, j;
|
||||
if (bCurve)
|
||||
{ // dla toru odchylonego
|
||||
// t2= 0;
|
||||
t2step = 1 / double(iSkip); // przesunięcie tekstury?
|
||||
t2step = 1 / double(iSkip); // przesunięcie tekstury?
|
||||
oldt2 = 1;
|
||||
tv1 = 1.0;
|
||||
step = fStep; // długść segmentu
|
||||
step = fStep; // długść segmentu
|
||||
s = 0;
|
||||
i = 0;
|
||||
t = fTsBuffer[i]; // wartość t krzywej Beziera dla początku
|
||||
t = fTsBuffer[i]; // wartość t krzywej Beziera dla początku
|
||||
a1 = 0;
|
||||
// step= fStep/fLength;
|
||||
offset = 0.1 / fLength; // około 10cm w sensie parametru t
|
||||
pos1 = FastGetPoint(t); // współrzędne dla parmatru t
|
||||
offset = 0.1 / fLength; // około 10cm w sensie parametru t
|
||||
pos1 = FastGetPoint(t); // współrzędne dla parmatru t
|
||||
// dir= GetDirection1();
|
||||
dir = FastGetDirection(t, offset); // wektor wzdłużny
|
||||
dir = FastGetDirection(t, offset); // wektor wzdłużny
|
||||
// parallel1=Normalize(CrossProduct(dir,vector3(0,1,0))); //poprzeczny?
|
||||
parallel1 = Normalize(vector3(-dir.z, 0.0, dir.x)); // wektor poprzeczny
|
||||
|
||||
@@ -692,31 +692,31 @@ void TSegment::Render()
|
||||
|
||||
void TSegment::RaRenderLoft(CVertNormTex *&Vert, const vector6 *ShapePoints, int iNumShapePoints,
|
||||
double fTextureLength, int iSkip, int iEnd, double fOffsetX)
|
||||
{ // generowanie trójkątów dla odcinka trajektorii ruchu
|
||||
// standardowo tworzy triangle_strip dla prostego albo ich zestaw dla łuku
|
||||
{ // generowanie trójkątów dla odcinka trajektorii ruchu
|
||||
// standardowo tworzy triangle_strip dla prostego albo ich zestaw dla łuku
|
||||
// po modyfikacji - dla ujemnego (iNumShapePoints) w dodatkowych polach tabeli
|
||||
// podany jest przekrój końcowy
|
||||
// podsypka toru jest robiona za pomocą 6 punktów, szyna 12, drogi i rzeki na 3+2+3
|
||||
// na użytek VBO strip dla łuków jest tworzony wzdłuż
|
||||
// dla skróconego odcinka (iEnd<iSegCount), ShapePoints dotyczy
|
||||
// końców skróconych, a nie całości (to pod kątem iglic jest)
|
||||
// podany jest przekrój końcowy
|
||||
// podsypka toru jest robiona za pomocą 6 punktów, szyna 12, drogi i rzeki na 3+2+3
|
||||
// na użytek VBO strip dla łuków jest tworzony wzdłuż
|
||||
// dla skróconego odcinka (iEnd<iSegCount), ShapePoints dotyczy
|
||||
// końców skróconych, a nie całości (to pod kątem iglic jest)
|
||||
vector3 pos1, pos2, dir, parallel1, parallel2, pt, norm;
|
||||
double s, step, fOffset, tv1, tv2, t, fEnd;
|
||||
int i, j;
|
||||
bool trapez = iNumShapePoints < 0; // sygnalizacja trapezowatości
|
||||
bool trapez = iNumShapePoints < 0; // sygnalizacja trapezowatości
|
||||
iNumShapePoints = abs(iNumShapePoints);
|
||||
if (bCurve)
|
||||
{
|
||||
double m1, jmm1, m2, jmm2; // pozycje względne na odcinku 0...1 (ale nie parametr Beziera)
|
||||
double m1, jmm1, m2, jmm2; // pozycje względne na odcinku 0...1 (ale nie parametr Beziera)
|
||||
step = fStep;
|
||||
tv1 = 1.0; // Ra: to by można było wyliczać dla odcinka, wyglądało by lepiej
|
||||
s = fStep * iSkip; // iSkip - ile odcinków z początku pominąć
|
||||
i = iSkip; // domyślnie 0
|
||||
t = fTsBuffer[i]; // tabela wattości t dla segmentów
|
||||
tv1 = 1.0; // Ra: to by można było wyliczać dla odcinka, wyglądało by lepiej
|
||||
s = fStep * iSkip; // iSkip - ile odcinków z początku pominąć
|
||||
i = iSkip; // domyślnie 0
|
||||
t = fTsBuffer[i]; // tabela wattości t dla segmentów
|
||||
fOffset = 0.1 / fLength; // pierwsze 10cm
|
||||
pos1 = FastGetPoint(t); // wektor początku segmentu
|
||||
pos1 = FastGetPoint(t); // wektor początku segmentu
|
||||
dir = FastGetDirection(t, fOffset); // wektor kierunku
|
||||
// parallel1=Normalize(CrossProduct(dir,vector3(0,1,0))); //wektor prostopadły
|
||||
// parallel1=Normalize(CrossProduct(dir,vector3(0,1,0))); //wektor prostopadły
|
||||
parallel1 = Normalize(vector3(-dir.z, 0.0, dir.x)); // wektor poprzeczny
|
||||
if (iEnd == 0)
|
||||
iEnd = iSegCount;
|
||||
@@ -725,23 +725,23 @@ void TSegment::RaRenderLoft(CVertNormTex *&Vert, const vector6 *ShapePoints, int
|
||||
jmm2 = 1.0 - m2;
|
||||
while (i < iEnd)
|
||||
{
|
||||
++i; // kolejny punkt łamanej
|
||||
s += step; // końcowa pozycja segmentu [m]
|
||||
++i; // kolejny punkt łamanej
|
||||
s += step; // końcowa pozycja segmentu [m]
|
||||
m1 = m2;
|
||||
jmm1 = jmm2; // stara pozycja
|
||||
m2 = s / fEnd;
|
||||
jmm2 = 1.0 - m2; // nowa pozycja
|
||||
if (i == iEnd)
|
||||
{ // gdy przekroczyliśmy koniec - stąd dziury w torach...
|
||||
{ // gdy przekroczyliśmy koniec - stąd dziury w torach...
|
||||
step -= (s - fEnd); // jeszcze do wyliczenia mapowania potrzebny
|
||||
s = fEnd;
|
||||
// i=iEnd; //20/5 ma dawać 4
|
||||
// i=iEnd; //20/5 ma dawać 4
|
||||
m2 = 1.0;
|
||||
jmm2 = 0.0;
|
||||
}
|
||||
while (tv1 < 0.0)
|
||||
tv1 += 1.0;
|
||||
tv2 = tv1 - step / fTextureLength; // mapowanie na końcu segmentu
|
||||
tv2 = tv1 - step / fTextureLength; // mapowanie na końcu segmentu
|
||||
t = fTsBuffer[i]; // szybsze od GetTFromS(s);
|
||||
pos2 = FastGetPoint(t);
|
||||
dir = FastGetDirection(t, fOffset); // nowy wektor kierunku
|
||||
@@ -749,7 +749,7 @@ void TSegment::RaRenderLoft(CVertNormTex *&Vert, const vector6 *ShapePoints, int
|
||||
parallel2 = Normalize(vector3(-dir.z, 0.0, dir.x)); // wektor poprzeczny
|
||||
if (trapez)
|
||||
for (j = 0; j < iNumShapePoints; j++)
|
||||
{ // współrzędne początku
|
||||
{ // współrzędne początku
|
||||
norm = (jmm1 * ShapePoints[j].n.x + m1 * ShapePoints[j + iNumShapePoints].n.x) *
|
||||
parallel1;
|
||||
norm.y += jmm1 * ShapePoints[j].n.y + m1 * ShapePoints[j + iNumShapePoints].n.y;
|
||||
@@ -764,9 +764,9 @@ void TSegment::RaRenderLoft(CVertNormTex *&Vert, const vector6 *ShapePoints, int
|
||||
Vert->v = tv1;
|
||||
Vert->x = pt.x;
|
||||
Vert->y = pt.y;
|
||||
Vert->z = pt.z; // punkt na początku odcinka
|
||||
Vert->z = pt.z; // punkt na początku odcinka
|
||||
Vert++;
|
||||
// dla trapezu drugi koniec ma inne współrzędne względne
|
||||
// dla trapezu drugi koniec ma inne współrzędne względne
|
||||
norm = (jmm1 * ShapePoints[j].n.x + m1 * ShapePoints[j + iNumShapePoints].n.x) *
|
||||
parallel2;
|
||||
norm.y += jmm1 * ShapePoints[j].n.y + m1 * ShapePoints[j + iNumShapePoints].n.y;
|
||||
@@ -781,12 +781,12 @@ void TSegment::RaRenderLoft(CVertNormTex *&Vert, const vector6 *ShapePoints, int
|
||||
Vert->v = tv2;
|
||||
Vert->x = pt.x;
|
||||
Vert->y = pt.y;
|
||||
Vert->z = pt.z; // punkt na końcu odcinka
|
||||
Vert->z = pt.z; // punkt na końcu odcinka
|
||||
Vert++;
|
||||
}
|
||||
else
|
||||
for (j = 0; j < iNumShapePoints; j++)
|
||||
{ // współrzędne początku
|
||||
{ // współrzędne początku
|
||||
norm = ShapePoints[j].n.x * parallel1;
|
||||
norm.y += ShapePoints[j].n.y;
|
||||
pt = parallel1 * (ShapePoints[j].x - fOffsetX) + pos1;
|
||||
@@ -798,7 +798,7 @@ void TSegment::RaRenderLoft(CVertNormTex *&Vert, const vector6 *ShapePoints, int
|
||||
Vert->v = tv1;
|
||||
Vert->x = pt.x;
|
||||
Vert->y = pt.y;
|
||||
Vert->z = pt.z; // punkt na początku odcinka
|
||||
Vert->z = pt.z; // punkt na początku odcinka
|
||||
Vert++;
|
||||
norm = ShapePoints[j].n.x * parallel2;
|
||||
norm.y += ShapePoints[j].n.y;
|
||||
@@ -811,7 +811,7 @@ void TSegment::RaRenderLoft(CVertNormTex *&Vert, const vector6 *ShapePoints, int
|
||||
Vert->v = tv2;
|
||||
Vert->x = pt.x;
|
||||
Vert->y = pt.y;
|
||||
Vert->z = pt.z; // punkt na końcu odcinka
|
||||
Vert->z = pt.z; // punkt na końcu odcinka
|
||||
Vert++;
|
||||
}
|
||||
pos1 = pos2;
|
||||
@@ -840,14 +840,14 @@ void TSegment::RaRenderLoft(CVertNormTex *&Vert, const vector6 *ShapePoints, int
|
||||
Vert->v = 0;
|
||||
Vert->x = pt.x;
|
||||
Vert->y = pt.y;
|
||||
Vert->z = pt.z; // punkt na początku odcinka
|
||||
Vert->z = pt.z; // punkt na początku odcinka
|
||||
Vert++;
|
||||
// dla trapezu drugi koniec ma inne współrzędne
|
||||
// dla trapezu drugi koniec ma inne współrzędne
|
||||
norm = ShapePoints[j + iNumShapePoints].n.x * parallel1;
|
||||
norm.y += ShapePoints[j + iNumShapePoints].n.y;
|
||||
pt = parallel1 * (ShapePoints[j + iNumShapePoints].x - fOffsetX) +
|
||||
pos2; // odsunięcie
|
||||
pt.y += ShapePoints[j + iNumShapePoints].y; // wysokość
|
||||
pos2; // odsunięcie
|
||||
pt.y += ShapePoints[j + iNumShapePoints].y; // wysokość
|
||||
Vert->nx = norm.x; // niekoniecznie tak
|
||||
Vert->ny = norm.y;
|
||||
Vert->nz = norm.z;
|
||||
@@ -855,7 +855,7 @@ void TSegment::RaRenderLoft(CVertNormTex *&Vert, const vector6 *ShapePoints, int
|
||||
Vert->v = fLength / fTextureLength;
|
||||
Vert->x = pt.x;
|
||||
Vert->y = pt.y;
|
||||
Vert->z = pt.z; // punkt na końcu odcinka
|
||||
Vert->z = pt.z; // punkt na końcu odcinka
|
||||
Vert++;
|
||||
}
|
||||
else
|
||||
@@ -872,7 +872,7 @@ void TSegment::RaRenderLoft(CVertNormTex *&Vert, const vector6 *ShapePoints, int
|
||||
Vert->v = 0;
|
||||
Vert->x = pt.x;
|
||||
Vert->y = pt.y;
|
||||
Vert->z = pt.z; // punkt na początku odcinka
|
||||
Vert->z = pt.z; // punkt na początku odcinka
|
||||
Vert++;
|
||||
pt = parallel1 * (ShapePoints[j].x - fOffsetX) + pos2;
|
||||
pt.y += ShapePoints[j].y;
|
||||
@@ -883,7 +883,7 @@ void TSegment::RaRenderLoft(CVertNormTex *&Vert, const vector6 *ShapePoints, int
|
||||
Vert->v = fLength / fTextureLength;
|
||||
Vert->x = pt.x;
|
||||
Vert->y = pt.y;
|
||||
Vert->z = pt.z; // punkt na końcu odcinka
|
||||
Vert->z = pt.z; // punkt na końcu odcinka
|
||||
Vert++;
|
||||
}
|
||||
}
|
||||
@@ -891,23 +891,23 @@ void TSegment::RaRenderLoft(CVertNormTex *&Vert, const vector6 *ShapePoints, int
|
||||
|
||||
void TSegment::RaAnimate(CVertNormTex *&Vert, const vector6 *ShapePoints, int iNumShapePoints,
|
||||
double fTextureLength, int iSkip, int iEnd, double fOffsetX)
|
||||
{ // jak wyżej, tylko z pominięciem mapowania i braku trapezowania
|
||||
{ // jak wyżej, tylko z pominięciem mapowania i braku trapezowania
|
||||
vector3 pos1, pos2, dir, parallel1, parallel2, pt;
|
||||
double s, step, fOffset, t, fEnd;
|
||||
int i, j;
|
||||
bool trapez = iNumShapePoints < 0; // sygnalizacja trapezowatości
|
||||
bool trapez = iNumShapePoints < 0; // sygnalizacja trapezowatości
|
||||
iNumShapePoints = abs(iNumShapePoints);
|
||||
if (bCurve)
|
||||
{
|
||||
double m1, jmm1, m2, jmm2; // pozycje względne na odcinku 0...1 (ale nie parametr Beziera)
|
||||
double m1, jmm1, m2, jmm2; // pozycje względne na odcinku 0...1 (ale nie parametr Beziera)
|
||||
step = fStep;
|
||||
s = fStep * iSkip; // iSkip - ile odcinków z początku pominąć
|
||||
i = iSkip; // domyślnie 0
|
||||
t = fTsBuffer[i]; // tabela wattości t dla segmentów
|
||||
s = fStep * iSkip; // iSkip - ile odcinków z początku pominąć
|
||||
i = iSkip; // domyślnie 0
|
||||
t = fTsBuffer[i]; // tabela wattości t dla segmentów
|
||||
fOffset = 0.1 / fLength; // pierwsze 10cm
|
||||
pos1 = FastGetPoint(t); // wektor początku segmentu
|
||||
pos1 = FastGetPoint(t); // wektor początku segmentu
|
||||
dir = FastGetDirection(t, fOffset); // wektor kierunku
|
||||
// parallel1=Normalize(CrossProduct(dir,vector3(0,1,0))); //wektor prostopadły
|
||||
// parallel1=Normalize(CrossProduct(dir,vector3(0,1,0))); //wektor prostopadły
|
||||
parallel1 = Normalize(vector3(-dir.z, 0.0, dir.x)); // wektor poprzeczny
|
||||
if (iEnd == 0)
|
||||
iEnd = iSegCount;
|
||||
@@ -916,17 +916,17 @@ void TSegment::RaAnimate(CVertNormTex *&Vert, const vector6 *ShapePoints, int iN
|
||||
jmm2 = 1.0 - m2;
|
||||
while (i < iEnd)
|
||||
{
|
||||
++i; // kolejny punkt łamanej
|
||||
s += step; // końcowa pozycja segmentu [m]
|
||||
++i; // kolejny punkt łamanej
|
||||
s += step; // końcowa pozycja segmentu [m]
|
||||
m1 = m2;
|
||||
jmm1 = jmm2; // stara pozycja
|
||||
m2 = s / fEnd;
|
||||
jmm2 = 1.0 - m2; // nowa pozycja
|
||||
if (i == iEnd)
|
||||
{ // gdy przekroczyliśmy koniec - stąd dziury w torach...
|
||||
{ // gdy przekroczyliśmy koniec - stąd dziury w torach...
|
||||
step -= (s - fEnd); // jeszcze do wyliczenia mapowania potrzebny
|
||||
s = fEnd;
|
||||
// i=iEnd; //20/5 ma dawać 4
|
||||
// i=iEnd; //20/5 ma dawać 4
|
||||
m2 = 1.0;
|
||||
jmm2 = 0.0;
|
||||
}
|
||||
@@ -937,23 +937,23 @@ void TSegment::RaAnimate(CVertNormTex *&Vert, const vector6 *ShapePoints, int iN
|
||||
parallel2 = Normalize(vector3(-dir.z, 0.0, dir.x)); // wektor poprzeczny
|
||||
if (trapez)
|
||||
for (j = 0; j < iNumShapePoints; j++)
|
||||
{ // współrzędne początku
|
||||
{ // współrzędne początku
|
||||
pt = parallel1 * (jmm1 * (ShapePoints[j].x - fOffsetX) +
|
||||
m1 * ShapePoints[j + iNumShapePoints].x) +
|
||||
pos1;
|
||||
pt.y += jmm1 * ShapePoints[j].y + m1 * ShapePoints[j + iNumShapePoints].y;
|
||||
Vert->x = pt.x;
|
||||
Vert->y = pt.y;
|
||||
Vert->z = pt.z; // punkt na początku odcinka
|
||||
Vert->z = pt.z; // punkt na początku odcinka
|
||||
Vert++;
|
||||
// dla trapezu drugi koniec ma inne współrzędne
|
||||
// dla trapezu drugi koniec ma inne współrzędne
|
||||
pt = parallel2 * (jmm2 * (ShapePoints[j].x - fOffsetX) +
|
||||
m2 * ShapePoints[j + iNumShapePoints].x) +
|
||||
pos2;
|
||||
pt.y += jmm2 * ShapePoints[j].y + m2 * ShapePoints[j + iNumShapePoints].y;
|
||||
Vert->x = pt.x;
|
||||
Vert->y = pt.y;
|
||||
Vert->z = pt.z; // punkt na końcu odcinka
|
||||
Vert->z = pt.z; // punkt na końcu odcinka
|
||||
Vert++;
|
||||
}
|
||||
pos1 = pos2;
|
||||
@@ -974,14 +974,14 @@ void TSegment::RaAnimate(CVertNormTex *&Vert, const vector6 *ShapePoints, int iN
|
||||
pt.y += ShapePoints[j].y;
|
||||
Vert->x = pt.x;
|
||||
Vert->y = pt.y;
|
||||
Vert->z = pt.z; // punkt na początku odcinka
|
||||
Vert->z = pt.z; // punkt na początku odcinka
|
||||
Vert++;
|
||||
pt = parallel1 * (ShapePoints[j + iNumShapePoints].x - fOffsetX) +
|
||||
pos2; // odsunięcie
|
||||
pt.y += ShapePoints[j + iNumShapePoints].y; // wysokość
|
||||
pos2; // odsunięcie
|
||||
pt.y += ShapePoints[j + iNumShapePoints].y; // wysokość
|
||||
Vert->x = pt.x;
|
||||
Vert->y = pt.y;
|
||||
Vert->z = pt.z; // punkt na końcu odcinka
|
||||
Vert->z = pt.z; // punkt na końcu odcinka
|
||||
Vert++;
|
||||
}
|
||||
}
|
||||
|
||||
Reference in New Issue
Block a user