commit 45f4c0d98a390d6cc819f61eef584e98ba77af1f Author: ShaXbee Date: Fri Apr 3 13:34:06 2015 +0000 Set dp branch as trunk diff --git a/AdvSound.cpp b/AdvSound.cpp new file mode 100644 index 00000000..8f7b4e41 --- /dev/null +++ b/AdvSound.cpp @@ -0,0 +1,181 @@ +//--------------------------------------------------------------------------- + +#include "system.hpp" +#include "classes.hpp" +#pragma hdrstop + +#include "Timer.h" +#include "AdvSound.h" +//--------------------------------------------------------------------------- +#pragma package(smart_init) + +__fastcall TAdvancedSound::TAdvancedSound() +{ +// SoundStart=SoundCommencing=SoundShut= NULL; + State=ss_Off; + fTime=0; + fStartLength=0; + fShutLength=0; +} + +__fastcall TAdvancedSound::~TAdvancedSound() +{//Ra: stopowanie się sypie + //SoundStart.Stop(); + //SoundCommencing.Stop(); + //SoundShut.Stop(); +} + +void __fastcall TAdvancedSound::Free() +{ +} + +void __fastcall TAdvancedSound::Init(char *NameOn, char *Name, char *NameOff, double DistanceAttenuation, vector3 pPosition) +{ + SoundStart.Init(NameOn,DistanceAttenuation,pPosition.x,pPosition.y,pPosition.z,true); + SoundCommencing.Init(Name,DistanceAttenuation,pPosition.x,pPosition.y,pPosition.z,true); + SoundShut.Init(NameOff,DistanceAttenuation,pPosition.x,pPosition.y,pPosition.z,true); + fStartLength=SoundStart.GetWaveTime(); + fShutLength=SoundShut.GetWaveTime(); + SoundStart.AM=1.0; + SoundStart.AA=0.0; + SoundStart.FM=1.0; + SoundStart.FA=0.0; + SoundCommencing.AM=1.0; + SoundCommencing.AA=0.0; + SoundCommencing.FM=1.0; + SoundCommencing.FA=0.0; + defAM=1.0; + defFM=1.0; + SoundShut.AM=1.0; + SoundShut.AA=0.0; + SoundShut.FM=1.0; + SoundShut.FA=0.0; +} + +void __fastcall TAdvancedSound::Load(TQueryParserComp *Parser, vector3 pPosition) +{ + AnsiString NameOn= Parser->GetNextSymbol().LowerCase(); + AnsiString Name= Parser->GetNextSymbol().LowerCase(); + AnsiString NameOff= Parser->GetNextSymbol().LowerCase(); + double DistanceAttenuation= Parser->GetNextSymbol().ToDouble(); + Init(NameOn.c_str(),Name.c_str(),NameOff.c_str(),DistanceAttenuation,pPosition); +} + +void __fastcall TAdvancedSound::TurnOn(bool ListenerInside, vector3 NewPosition) +{ + //hunter-311211: nie trzeba czekac na ponowne odtworzenie dzwieku, az sie wylaczy + if ((State==ss_Off || State==ss_ShuttingDown) && (SoundStart.AM>0)) + { + SoundStart.ResetPosition(); + SoundCommencing.ResetPosition(); + SoundStart.Play(1,0,ListenerInside,NewPosition); +// SoundStart->SetVolume(-10000); + State= ss_Starting; + fTime= 0; + } +} + +void __fastcall TAdvancedSound::TurnOff(bool ListenerInside, vector3 NewPosition) +{ + if ((State==ss_Commencing || State==ss_Starting) && (SoundShut.AM>0)) + { + SoundStart.Stop(); + SoundCommencing.Stop(); + SoundShut.ResetPosition(); + SoundShut.Play(1,0,ListenerInside,NewPosition); + State= ss_ShuttingDown; + fTime= fShutLength; +// SoundShut->SetVolume(0); + } +} + +void __fastcall TAdvancedSound::Update(bool ListenerInside, vector3 NewPosition) +{ + if ((State==ss_Commencing) && (SoundCommencing.AM>0)) + { +// SoundCommencing->SetFrequency(); + SoundShut.Stop(); //hunter-311211 + SoundCommencing.Play(1,DSBPLAY_LOOPING,ListenerInside,NewPosition); + } + else + if (State==ss_Starting) + { + fTime+= Timer::GetDeltaTime(); +// SoundStart->SetVolume(-1000*(4-fTime)/4); + if (fTime>=fStartLength) + { + State= ss_Commencing; + SoundCommencing.ResetPosition(); + SoundCommencing.Play(1,DSBPLAY_LOOPING,ListenerInside,NewPosition); + SoundStart.Stop(); + + } + else + SoundStart.Play(1,0,ListenerInside,NewPosition); + } + else + if (State==ss_ShuttingDown) + { + fTime-= Timer::GetDeltaTime(); +// SoundShut->SetVolume(-1000*(4-fTime)/4); + if (fTime<=0) + { + State= ss_Off; + SoundShut.Stop(); + } + else + SoundShut.Play(1,0,ListenerInside,NewPosition); + } +} + +void __fastcall TAdvancedSound::UpdateAF(double A, double F, bool ListenerInside, vector3 NewPosition) +{ //update, ale z amplituda i czestotliwoscia + if ((State==ss_Commencing) && (SoundCommencing.AM>0)) + { + SoundShut.Stop(); //hunter-311211 + SoundCommencing.Play(A,DSBPLAY_LOOPING,ListenerInside,NewPosition); + } + else + if (State==ss_Starting) + { + fTime+= Timer::GetDeltaTime(); +// SoundStart->SetVolume(-1000*(4-fTime)/4); + if (fTime>=fStartLength) + { + State= ss_Commencing; + SoundCommencing.ResetPosition(); + SoundCommencing.Play(A,DSBPLAY_LOOPING,ListenerInside,NewPosition); + SoundStart.Stop(); + } + else + SoundStart.Play(A,0,ListenerInside,NewPosition); + } + else + if (State==ss_ShuttingDown) + { + fTime-= Timer::GetDeltaTime(); +// SoundShut->SetVolume(-1000*(4-fTime)/4); + if (fTime<=0) + { + State= ss_Off; + SoundShut.Stop(); + } + else + SoundShut.Play(A,0,ListenerInside,NewPosition); + } + SoundCommencing.AdjFreq(F,Timer::GetDeltaTime()); +} + +void __fastcall TAdvancedSound::CopyIfEmpty(TAdvancedSound &s) +{//skopiowanie, gdyby był potrzebny, a nie został wczytany + if ((fStartLength>0.0)||(fShutLength>0.0)) return; //coś jest + SoundStart=s.SoundStart; + SoundCommencing=s.SoundCommencing; + SoundShut=s.SoundShut; + State=s.State; + fStartLength=s.fStartLength; + fShutLength=s.fShutLength; + defAM=s.defAM; + defFM=s.defFM; +}; + diff --git a/AdvSound.h b/AdvSound.h new file mode 100644 index 00000000..66d961cd --- /dev/null +++ b/AdvSound.h @@ -0,0 +1,37 @@ +//--------------------------------------------------------------------------- +#ifndef AdvSoundH +#define AdvSoundH + +#include "Sound.h" +#include "RealSound.h" +#include "QueryParserComp.hpp" + +typedef enum {ss_Off, ss_Starting, ss_Commencing, ss_ShuttingDown} TSoundState; + +class TAdvancedSound +{//klasa dźwięków mających początek, dowolnie długi środek oraz zakończenie (np. Rp1) + TRealSound SoundStart; + TRealSound SoundCommencing; + TRealSound SoundShut; + TSoundState State; + double fTime; + double fStartLength; + double fShutLength; + double defAM; + double defFM; + +public: + __fastcall TAdvancedSound(); + __fastcall ~TAdvancedSound(); + void __fastcall Init(char *NameOn, char *Name, char *NameOff, double DistanceAttenuation, vector3 pPosition); + void __fastcall Load(TQueryParserComp *Parser, vector3 pPosition); + void __fastcall TurnOn(bool ListenerInside, vector3 NewPosition); + void __fastcall TurnOff(bool ListenerInside, vector3 NewPosition); + void __fastcall Free(); + void __fastcall Update(bool ListenerInside, vector3 NewPosition); + void __fastcall UpdateAF(double A, double F, bool ListenerInside, vector3 NewPosition); + void __fastcall CopyIfEmpty(TAdvancedSound &s); +}; + +//--------------------------------------------------------------------------- +#endif diff --git a/AirCoupler.cpp b/AirCoupler.cpp new file mode 100644 index 00000000..18e7e061 --- /dev/null +++ b/AirCoupler.cpp @@ -0,0 +1,73 @@ +//--------------------------------------------------------------------------- + +#include "system.hpp" +#include "classes.hpp" +#pragma hdrstop + +#include "AirCoupler.h" +#include "Timer.h" + +__fastcall TAirCoupler::TAirCoupler() +{ + Clear(); +} + +__fastcall TAirCoupler::~TAirCoupler() +{ +} + +int __fastcall TAirCoupler::GetStatus() +{//zwraca 1, jeśli istnieje model prosty, 2 gdy skośny + int x=0; + if (pModelOn) x=1; + if (pModelxOn) x=2; + return x; +} + +void __fastcall TAirCoupler::Clear() +{//zerowanie wskaźników + pModelOn=NULL; + pModelOff=NULL; + pModelxOn=NULL; + bOn=false; + bxOn=false; +} + + +void __fastcall TAirCoupler::Init(AnsiString asName, TModel3d *pModel) +{//wyszukanie submodeli + if (!pModel) return; //nie ma w czym szukać + pModelOn=pModel->GetFromName(AnsiString(asName+"_on").c_str()); //połączony na wprost + pModelOff=pModel->GetFromName(AnsiString(asName+"_off").c_str()); //odwieszony + pModelxOn=pModel->GetFromName(AnsiString(asName+"_xon").c_str()); //połączony na skos +} + +void __fastcall TAirCoupler::Load(TQueryParserComp *Parser, TModel3d *pModel) +{ + AnsiString str=Parser->GetNextSymbol().LowerCase(); + if (pModel) + Init(str,pModel); + else + { + pModelOn=NULL; + pModelxOn=NULL; + pModelOff=NULL; + } +} + +void __fastcall TAirCoupler::Update() +{ +// if ((pModelOn!=NULL) && (pModelOn!=NULL)) + { + if (pModelOn) + pModelOn->iVisible=bOn; + if (pModelOff) + pModelOff->iVisible=!(bOn||bxOn); + if (pModelxOn) + pModelxOn->iVisible=bxOn; + } +} + +//--------------------------------------------------------------------------- + +#pragma package(smart_init) diff --git a/AirCoupler.h b/AirCoupler.h new file mode 100644 index 00000000..8a966dfe --- /dev/null +++ b/AirCoupler.h @@ -0,0 +1,32 @@ +//--------------------------------------------------------------------------- + +#ifndef AirCouplerH +#define AirCouplerH + +#include "Model3d.h" +#include "QueryParserComp.hpp" + +class TAirCoupler +{ +private: +// TButtonType eType; + TSubModel *pModelOn,*pModelOff,*pModelxOn; + bool bOn; + bool bxOn; + void __fastcall Update(); +public: + __fastcall TAirCoupler(); + __fastcall ~TAirCoupler(); + void __fastcall Clear(); + inline void TurnOn() { bOn=true; bxOn=false; Update(); }; + inline void TurnOff() { bOn=false; bxOn=false; Update(); }; + inline void TurnxOn() { bOn=false; bxOn=true; Update(); }; +// inline bool Active() { if ((pModelOn)||(pModelOff)) return true; return false;}; + int __fastcall GetStatus(); + void __fastcall Init(AnsiString asName, TModel3d *pModel); + void __fastcall Load(TQueryParserComp *Parser, TModel3d *pModel); +// bool __fastcall Render(); +}; + +//--------------------------------------------------------------------------- +#endif diff --git a/AnimModel.cpp b/AnimModel.cpp new file mode 100644 index 00000000..ff53f48f --- /dev/null +++ b/AnimModel.cpp @@ -0,0 +1,787 @@ +//--------------------------------------------------------------------------- +/* + MaSzyna EU07 locomotive simulator + Copyright (C) 2001-2004 Marcin Wozniak and others + +*/ + +#include "system.hpp" +#include "classes.hpp" +#pragma hdrstop + +#include "AnimModel.h" +#include "usefull.h" +#include "Timer.h" +#include "MdlMngr.h" +//McZapkie: +#include "Texture.h" +#include "Globals.h" +//--------------------------------------------------------------------------- +#pragma package(smart_init) +//--------------------------------------------------------------------------- + + +__fastcall TAnimAdvanced::TAnimAdvanced() +{ +}; +__fastcall TAnimAdvanced::~TAnimAdvanced() +{ + //delete[] pVocaloidMotionData; //plik został zmodyfikowany +}; + +int __fastcall TAnimAdvanced::SortByBone() +{//sortowanie pliku animacji w celu optymalniejszego wykonania + //rekordy zostają ułożone wg kolejnych ramek dla każdej kości + //ułożenie kości alfabetycznie nie jest niezbędne, ale upraszcza sortowanie bąbelkowe + TAnimVocaloidFrame buf; //bufor roboczy (przydało by się pascalowe Swap() + int i,j,k,swaps=0,last=iMovements-1,e; + for (i=0;i0) + k=j; //trzeba zamienić - ten pod j jest mniejszy + else if (!e) + if (pMovementData[k].iFrame>pMovementData[j].iFrame) + k=j; //numer klatki pod j jest mniejszy + } + if (k>i) + {//jeśli trzeba przestawić + //buf=pMovementData[i]; + //pMovementData[i]=pMovementData[k]; + //pMovementData[k]=buf; + memcpy(&buf,pMovementData+i,sizeof(TAnimVocaloidFrame)); + memcpy(pMovementData+i,pMovementData+k,sizeof(TAnimVocaloidFrame)); + memcpy(pMovementData+k,&buf,sizeof(TAnimVocaloidFrame)); + ++swaps; + } + } + return swaps; +}; + +__fastcall TAnimContainer::TAnimContainer() +{ + pNext=NULL; + vRotateAngles=vector3(0.0f,0.0f,0.0f); //aktualne kąty obrotu + vDesiredAngles=vector3(0.0f,0.0f,0.0f); //docelowe kąty obrotu + fRotateSpeed=0.0; + vTranslation=vector3(0.0f,0.0f,0.0f); //aktualne przesunięcie + vTranslateTo=vector3(0.0f,0.0f,0.0f); //docelowe przesunięcie + fTranslateSpeed=0.0; + fAngleSpeed=0.0; + pSubModel=NULL; + iAnim=0; //położenie początkowe + pMovementData=NULL; //nie ma zaawansowanej animacji + mAnim=NULL; //nie ma macierzy obrotu dla submodelu + evDone=NULL; //powiadamianie o zakończeniu animacji + acAnimNext=NULL; //na razie jest poza listą +} + +__fastcall TAnimContainer::~TAnimContainer() +{ + SafeDelete(pNext); + delete mAnim; //AnimContainer jest właścicielem takich macierzy +} + +bool __fastcall TAnimContainer::Init(TSubModel *pNewSubModel) +{ + fRotateSpeed=0.0f; + pSubModel=pNewSubModel; + return (pSubModel!=NULL); +} + +void __fastcall TAnimContainer::SetRotateAnim(vector3 vNewRotateAngles, double fNewRotateSpeed) +{ + if (!this) return; //wywoływane z eventu, gdy brak modelu + vDesiredAngles=vNewRotateAngles; + fRotateSpeed=fNewRotateSpeed; + iAnim|=1; +/* //Ra 2014-07: jeśli model nie jest renderowany, to obliczyć czas animacji i dodać event wewnętrzny + //można by też ustawić czas początku animacji zamiast pobierać czas ramki i liczyć różnicę +*/ + if (evDone) + {//dołączyć model do listy aniomowania, żeby animacje były przeliczane również bez wyświetlania + if (iAnim>=0) + {//jeśli nie jest jeszcze na liście animacyjnej + acAnimNext=TAnimModel::acAnimList; //pozostałe doklić sobie jako ogon + TAnimModel::acAnimList=this; //a wstawić się na początek + iAnim|=0x80000000; //dodany do listy + } + } +} + +void __fastcall TAnimContainer::SetTranslateAnim(vector3 vNewTranslate, double fNewSpeed) +{ + if (!this) return; //wywoływane z eventu, gdy brak modelu + vTranslateTo=vNewTranslate; + fTranslateSpeed=fNewSpeed; + iAnim|=2; +/* //Ra 2014-07: jeśli model nie jest renderowany, to obliczyć czas animacji i dodać event wewnętrzny + //można by też ustawić czas początku animacji zamiast pobierać czas ramki i liczyć różnicę +*/ + if (evDone) + {//dołączyć model do listy aniomowania, żeby animacje były przeliczane również bez wyświetlania + if (iAnim>=0) + {//jeśli nie jest jeszcze na liście animacyjnej + acAnimNext=TAnimModel::acAnimList; //pozostałe doklić sobie jako ogon + TAnimModel::acAnimList=this; //a wstawić się na początek + iAnim|=0x80000000; //dodany do listy + } + } +} + +void __fastcall TAnimContainer::AnimSetVMD(double fNewSpeed) +{ + if (!this) return; //wywoływane z eventu, gdy brak modelu + //skala do ustalenia, "cal" japoński (sun) to nieco ponad 3cm + //X-w lewo, Y-w górę, Z-do tyłu + //minimalna wysokość to -7.66, a nadal musi być ponad podłogą + //if (pMovementData->iFrame>0) return; //tylko pierwsza ramka + vTranslateTo=vector3(0.1*pMovementData->f3Vector.x,0.1*pMovementData->f3Vector.z,0.1*pMovementData->f3Vector.y); + if (LengthSquared3(vTranslateTo)>0.0?true:LengthSquared3(vTranslation)>0.0) + {//jeśli ma być przesunięte albo jest przesunięcie + iAnim|=2; //wyłączy się samo + if (fNewSpeed>0.0) + fTranslateSpeed=fNewSpeed; //prędkość jest mnożnikiem, nie podlega skalowaniu + else //za późno na animacje, trzeba przestawić + vTranslation=vTranslateTo; + } + //if ((qCurrent.w<1.0)||(pMovementData->qAngle.w<1.0)) + {//jeśli jest jakiś obrót + if (!mAnim) + {mAnim=new float4x4(); //będzie potrzebna macierz animacji + mAnim->Identity(); //jedynkowanie na początek + } + iAnim|=4; //animacja kwaternionowa + qStart=qCurrent; //potrzebna początkowa do interpolacji + //---+ - też niby dobrze, ale nie tak trąca włosy na początku (macha w dół) + //-+-+ - dłoń ma w górze zamiast na pasie w pozycji początkowej + //+--+ - głowa do tyłu (broda w górę) w pozycji początkowej + //--++ - pozycja początkowa dobra, trąca u góry, ale z rękami jakoś nie tak, kółko w przeciwną stronę + //++++ - kładzie się brzuchem do góry + //-+++ - ręce w górze na początku, zamiast w dół, łokieć jakby w przeciwną stronę + //+-++ - nie podnosi ręki do głowy + //++-+ - dłoń ma w górze zamiast na pasie + qDesired=Normalize(float4(-pMovementData->qAngle.x,-pMovementData->qAngle.z,-pMovementData->qAngle.y,pMovementData->qAngle.w)); //tu trzeba będzie osie zamienić + if (fNewSpeed>0.0) + {fAngleSpeed=fNewSpeed; //wtedy animować za pomocą interpolacji + fAngleCurrent=0.0; //początek interpolacji + } + else + {//za późno na animację, można tylko przestawić w docelowe miejsce + fAngleSpeed=0.0; + fAngleCurrent=1.0; //interpolacja zakończona + qCurrent=qDesired; + } + } + //if (!strcmp(pSubModel->pName,"?Z?“?^?[")) //jak główna kość + //if (!strcmp(pSubModel->pName,"Ť¶‚‚Ü?ć‚h‚j")) //IK lewej stopy + // WriteLog(AnsiString(pMovementData->iFrame)+": "+AnsiString(pMovementData->f3Vector.x)+" "+AnsiString(pMovementData->f3Vector.y)+" "+AnsiString(pMovementData->f3Vector.z)); +} + +void __fastcall TAnimContainer::UpdateModel() +{//przeliczanie animacji wykonać tylko raz na model + if (pSubModel) //pozbyć się tego - sprawdzać wcześniej + { + if (fTranslateSpeed!=0.0) + { + vector3 dif=vTranslateTo-vTranslation; //wektor w kierunku docelowym + double l=LengthSquared3(dif); //długość wektora potrzebnego przemieszczenia + if (l>=0.0001) + {//jeśli do przemieszczenia jest ponad 1cm + vector3 s=SafeNormalize(dif); //jednostkowy wektor kierunku + s=s*(fTranslateSpeed*Timer::GetDeltaTime()); //przemieszczenie w podanym czasie z daną prędkością + if (LengthSquared3(s)0) + fAngle= fDesiredAngle; + else + fAngle+= s; + + while (fAngle>360) fAngle-= 360; + while (fAngle<-360) fAngle+= 360; + pSubModel->SetRotate(vRotateAxis,fAngle); +*/ + + bool anim=false; + vector3 dif=vDesiredAngles-vRotateAngles; + double s; + s=fRotateSpeed*sign(dif.x)*Timer::GetDeltaTime(); + if (fabs(s)>=fabs(dif.x)) + vRotateAngles.x=vDesiredAngles.x; + else + {vRotateAngles.x+=s; anim=true;} + s=fRotateSpeed*sign(dif.y)*Timer::GetDeltaTime(); + if (fabs(s)>=fabs(dif.y)) + vRotateAngles.y=vDesiredAngles.y; + else + {vRotateAngles.y+=s; anim=true;} + s=fRotateSpeed*sign(dif.z)*Timer::GetDeltaTime(); + if (fabs(s)>=fabs(dif.z)) + vRotateAngles.z=vDesiredAngles.z; + else + {vRotateAngles.z+=s; anim=true;} + while (vRotateAngles.x>= 360) vRotateAngles.x-=360; + while (vRotateAngles.x<=-360) vRotateAngles.x+=360; + while (vRotateAngles.y>= 360) vRotateAngles.y-=360; + while (vRotateAngles.y<=-360) vRotateAngles.y+=360; + while (vRotateAngles.z>= 360) vRotateAngles.z-=360; + while (vRotateAngles.z<=-360) vRotateAngles.z+=360; + if (vRotateAngles.x==0.0) + if (vRotateAngles.y==0.0) + if (vRotateAngles.z==0.0) + iAnim&=~1; //kąty są zerowe + if (!anim) + {//nie potrzeba przeliczać już + fRotateSpeed=0.0; + if (evDone) Global::AddToQuery(evDone,NULL); //wykonanie eventu informującego o zakończeniu + } + } + if (fAngleSpeed!=0.0) + {//obrót kwaternionu (interpolacja) + } + } +}; + +void __fastcall TAnimContainer::PrepareModel() +{//tutaj zostawić tylko ustawienie submodelu, przeliczanie ma być w UpdateModel() + if (pSubModel) //pozbyć się tego - sprawdzać wcześniej + { + //nanoszenie animacji na wzorzec + if (iAnim&1) //zmieniona pozycja względem początkowej + pSubModel->SetRotateXYZ(vRotateAngles); //ustawia typ animacji + if (iAnim&2) //zmieniona pozycja względem początkowej + pSubModel->SetTranslate(vTranslation); + if (iAnim&4) //zmieniona pozycja względem początkowej + { + if (fAngleSpeed>0.0f) + {fAngleCurrent+=fAngleSpeed*Timer::GetDeltaTime(); //aktualny parametr interpolacji + if (fAngleCurrent>=1.0f) + {//interpolacja zakończona, ustawienie na pozycję końcową + qCurrent=qDesired; + fAngleSpeed=0.0; //wyłączenie przeliczania wektora + if (evDone) Global::AddToQuery(evDone,NULL); //wykonanie eventu informującego o zakończeniu + } + else + {//obliczanie pozycji pośredniej + //normalizacja jest wymagana do interpolacji w następnej animacji + qCurrent=Normalize(Slerp(qStart,qDesired,fAngleCurrent)); //interpolacja sferyczna kąta + //qCurrent=Slerp(qStart,qDesired,fAngleCurrent); //interpolacja sferyczna kąta + if (qCurrent.w==1.0) //rozpoznać brak obrotu i wyłączyć w iAnim w takim przypadku + iAnim&=~4; //kąty są zerowe + } + } + mAnim->Quaternion(&qCurrent); //wypełnienie macierzy (wymaga normalizacji?) + pSubModel->mAnimMatrix=mAnim; //użyczenie do submodelu (na czas renderowania!) + } + } + //if (!strcmp(pSubModel->pName,"?Z?“?^?[")) //jak główna kość + // WriteLog(AnsiString(pMovementData->iFrame)+": "+AnsiString(iAnim)+" "+AnsiString(vTranslation.x)+" "+AnsiString(vTranslation.y)+" "+AnsiString(vTranslation.z)); +} + +void __fastcall TAnimContainer::UpdateModelIK() +{//odwrotna kinematyka wyliczana dopiero po ustawieniu macierzy w submodelach + if (pSubModel) //pozbyć się tego - sprawdzać wcześniej + { + if (pSubModel->b_Anim&at_IK) + {//odwrotna kinematyka + float3 d,k; + TSubModel *ch=pSubModel->ChildGet(); + switch (pSubModel->b_Anim) + { + case at_IK11: //stopa: ustawić w kierunku czubka (pierwszy potomny) + d=ch->Translation1Get(); //wektor względem aktualnego układu (nie uwzględnia obrotu) + k=float3(RadToDeg(atan2(d.z,hypot(d.x,d.y))),0.0,-RadToDeg(atan2(d.y,d.x))); //proste skierowanie na punkt + pSubModel->SetRotateIK1(k); + //if (!strcmp(pSubModel->pName,"?Z?“?^?[")) //jak główna kość + // WriteLog("--> "+AnsiString(k.x)+" "+AnsiString(k.y)+" "+AnsiString(k.z)); + //Ra: to już jest dobrze, może być inna ćwiartka i znak + break; + case at_IK22: //udo: ustawić w kierunku pierwszej potomnej pierwszej potomnej (kostki) + //pozycję kostki należy określić względem kości centralnej (+biodro może być pochylone) + //potem wyliczyć ewentualne odchylenie w tej i następnej + //w sumie to proste, jak wyznaczenie kątów w trójkącie o znanej długości boków... + d=ch->Translation2Get(); //wektor względem aktualnego układu (nie uwzględnia obrotu) + //if () + {//kość IK jest dalej niż pozycja spoczynkowa + k=float3(RadToDeg(atan2(d.z,hypot(d.x,d.y))),0.0,-RadToDeg(atan2(d.y,d.x))); //proste skierowanie na punkt + pSubModel->SetRotateIK1(k); + } + break; + } + } + } +} + +bool __fastcall TAnimContainer::InMovement() +{//czy trwa animacja - informacja dla obrotnicy + return (fRotateSpeed!=0.0)||(fTranslateSpeed!=0.0); +} + +void __fastcall TAnimContainer::EventAssign(TEvent *ev) +{//przypisanie eventu wykonywanego po zakończeniu animacji + evDone=ev; +}; + +//------------------------------------------------------------------------------ +//------------------------------------------------------------------------------ +//------------------------------------------------------------------------------ + +__fastcall TAnimModel::TAnimModel() +{ + pRoot=NULL; + pModel=NULL; + iNumLights=0; + fBlinkTimer=0; + ReplacableSkinId[0]=0; + ReplacableSkinId[1]=0; + ReplacableSkinId[2]=0; + ReplacableSkinId[3]=0; + ReplacableSkinId[4]=0; + for (int i=0;igetTokens(); //nazwa modelu + *parser >> token; + str=AnsiString(token.c_str()); + parser->getTokens(1,false); //tekstura (zmienia na małe) + *parser >> token; + if (!Init(str,AnsiString(token.c_str()))) + {if (str!="notload") + {//gdy brak modelu + if (ter) //jeśli teren + {if (str.SubString(str.Length()-3,4)==".t3d") + str[str.Length()-2]='e'; + Global::asTerrainModel=str; + WriteLog(AnsiString("Terrain model \""+str+"\" will be created.")); + } + else + ErrorLog(AnsiString("Missed file: "+str)); + } + } + else + {//wiązanie świateł, o ile model wczytany + LightsOn[0]=pModel->GetFromName("Light_On00"); + LightsOn[1]=pModel->GetFromName("Light_On01"); + LightsOn[2]=pModel->GetFromName("Light_On02"); + LightsOn[3]=pModel->GetFromName("Light_On03"); + LightsOn[4]=pModel->GetFromName("Light_On04"); + LightsOn[5]=pModel->GetFromName("Light_On05"); + LightsOn[6]=pModel->GetFromName("Light_On06"); + LightsOn[7]=pModel->GetFromName("Light_On07"); + LightsOff[0]=pModel->GetFromName("Light_Off00"); + LightsOff[1]=pModel->GetFromName("Light_Off01"); + LightsOff[2]=pModel->GetFromName("Light_Off02"); + LightsOff[3]=pModel->GetFromName("Light_Off03"); + LightsOff[4]=pModel->GetFromName("Light_Off04"); + LightsOff[5]=pModel->GetFromName("Light_Off05"); + LightsOff[6]=pModel->GetFromName("Light_Off06"); + LightsOff[7]=pModel->GetFromName("Light_Off07"); + } + for (int i=0;igetTokens(); + *parser >> token; + + if (token.compare( "lights" ) == 0) + { + parser->getTokens(); + *parser >> token; + str=AnsiString(token.c_str()); + do + { + ti=str.ToDouble(); //stan światła jest liczbą z ułamkiem + LightSet(i,ti); + i++; + parser->getTokens(); + *parser >> token; + str=AnsiString(token.c_str()); + } while (str!="endmodel"); + } + return true; +} + +TAnimContainer* __fastcall TAnimModel::AddContainer(char *pName) +{//dodanie sterowania submodelem dla egzemplarza + if (!pModel) return NULL; + TSubModel *tsb=pModel->GetFromName(pName); + if (tsb) + { + TAnimContainer *tmp=new TAnimContainer(); + tmp->Init(tsb); + tmp->pNext=pRoot; + pRoot=tmp; + return tmp; + } + return NULL; +} + +TAnimContainer* __fastcall TAnimModel::GetContainer(char *pName) +{//szukanie/dodanie sterowania submodelem dla egzemplarza + if (!pName) return pRoot; //pobranie pierwszego (dla obrotnicy) + TAnimContainer *pCurrent; + for (pCurrent=pRoot;pCurrent!=NULL;pCurrent=pCurrent->pNext) + //if (pCurrent->GetName()==pName) + if (stricmp(pCurrent->NameGet(),pName)==0) + return pCurrent; + return AddContainer(pName); +} + +void __fastcall TAnimModel::RaAnimate() +{//przeliczenie animacji - jednorazowo na klatkę + //Ra 2F1I: to by można pomijać dla modeli bez animacji, których jest większość + TAnimContainer *pCurrent; + for (pCurrent=pRoot;pCurrent!=NULL;pCurrent=pCurrent->pNext) + if (!pCurrent->evDone) //jeśli jest bez eventu + pCurrent->UpdateModel(); //przeliczenie animacji każdego submodelu + //if () //tylko dla modeli z IK !!!! + for (pCurrent=pRoot;pCurrent!=NULL;pCurrent=pCurrent->pNext) //albo osobny łańcuch + pCurrent->UpdateModelIK(); //przeliczenie odwrotnej kinematyki +}; + +void __fastcall TAnimModel::RaPrepare() +{//ustawia światła i animacje we wzorcu modelu przed renderowaniem egzemplarza + fBlinkTimer-=Timer::GetDeltaTime(); + if (fBlinkTimer<=0) fBlinkTimer=fOffTime; + bool state; //stan światła + for (int i=0;iiVisible=state; + if (LightsOff[i]) LightsOff[i]->iVisible=!state; + } + TSubModel::iInstance=(int)this; //żeby nie robić cudzych animacji + TSubModel::pasText=&asText; //przekazanie tekstu do wyświetlacza (!!!! do przemyślenia) + if (pAdvanced) //jeśli jest zaawansowana animacja + Advanced(); //wykonać co tam trzeba + TAnimContainer *pCurrent; + for (pCurrent=pRoot;pCurrent!=NULL;pCurrent=pCurrent->pNext) + pCurrent->PrepareModel(); //ustawienie animacji egzemplarza dla każdego submodelu + //if () //tylko dla modeli z IK !!!! + // for (pCurrent=pRoot;pCurrent!=NULL;pCurrent=pCurrent->pNext) //albo osobny łańcuch + // pCurrent->UpdateModelIK(); //przeliczenie odwrotnej kinematyki +} + +void __fastcall TAnimModel::RenderVBO(vector3 pPosition,double fAngle) +{//sprawdza światła i rekurencyjnie renderuje TModel3d + RaAnimate(); //jednorazowe przeliczenie animacji + RaPrepare(); + if (pModel) //renderowanie rekurencyjne submodeli + pModel->RaRender(pPosition,fAngle,ReplacableSkinId,iTexAlpha); +} + +void __fastcall TAnimModel::RenderAlphaVBO(vector3 pPosition,double fAngle) +{ + RaPrepare(); + if (pModel) //renderowanie rekurencyjne submodeli + pModel->RaRenderAlpha(pPosition,fAngle,ReplacableSkinId,iTexAlpha); +}; + +void __fastcall TAnimModel::RenderDL(vector3 pPosition,double fAngle) +{ + RaAnimate(); //jednorazowe przeliczenie animacji + RaPrepare(); + if (pModel) //renderowanie rekurencyjne submodeli + pModel->Render(pPosition,fAngle,ReplacableSkinId,iTexAlpha); +} + +void __fastcall TAnimModel::RenderAlphaDL(vector3 pPosition,double fAngle) +{ + RaPrepare(); + if (pModel) + pModel->RenderAlpha(pPosition,fAngle,ReplacableSkinId,iTexAlpha); +}; + +int __fastcall TAnimModel::Flags() +{//informacja dla TGround, czy ma być w Render, RenderAlpha, czy RenderMixed + int i=pModel?pModel->Flags():0; //pobranie flag całego modelu + if (ReplacableSkinId[1]>0) //jeśli ma wymienną teksturę 0 + i|=(i&0x01010001)*((iTexAlpha&1)?0x20:0x10); + //if (ReplacableSkinId[2]>0) //jeśli ma wymienną teksturę 1 + // i|=(i&0x02020002)*((iTexAlpha&1)?0x10:0x08); + //if (ReplacableSkinId[3]>0) //jeśli ma wymienną teksturę 2 + // i|=(i&0x04040004)*((iTexAlpha&1)?0x08:0x04); + //if (ReplacableSkinId[4]>0) //jeśli ma wymienną teksturę 3 + // i|=(i&0x08080008)*((iTexAlpha&1)?0x04:0x02); + return i; +}; + +//----------------------------------------------------------------------------- +//2011-03-16 cztery nowe funkcje renderowania z możliwością pochylania obiektów +//----------------------------------------------------------------------------- + +void __fastcall TAnimModel::RenderDL(vector3* vPosition) +{ + RaAnimate(); //jednorazowe przeliczenie animacji + RaPrepare(); + if (pModel) //renderowanie rekurencyjne submodeli + pModel->Render(vPosition,&vAngle,ReplacableSkinId,iTexAlpha); +}; +void __fastcall TAnimModel::RenderAlphaDL(vector3* vPosition) +{ + RaPrepare(); + if (pModel) //renderowanie rekurencyjne submodeli + pModel->RenderAlpha(vPosition,&vAngle,ReplacableSkinId,iTexAlpha); +}; +void __fastcall TAnimModel::RenderVBO(vector3* vPosition) +{ + RaAnimate(); //jednorazowe przeliczenie animacji + RaPrepare(); + if (pModel) //renderowanie rekurencyjne submodeli + pModel->RaRender(vPosition,&vAngle,ReplacableSkinId,iTexAlpha); +}; +void __fastcall TAnimModel::RenderAlphaVBO(vector3* vPosition) +{ + RaPrepare(); + if (pModel) //renderowanie rekurencyjne submodeli + pModel->RaRenderAlpha(vPosition,&vAngle,ReplacableSkinId,iTexAlpha); +}; + +//--------------------------------------------------------------------------- +bool __fastcall TAnimModel::TerrainLoaded() +{//zliczanie kwadratów kilometrowych (główna linia po Next) do tworznia tablicy + return (this?pModel!=NULL:false); +}; +int __fastcall TAnimModel::TerrainCount() +{//zliczanie kwadratów kilometrowych (główna linia po Next) do tworznia tablicy + return pModel?pModel->TerrainCount():0; +}; +TSubModel* __fastcall TAnimModel::TerrainSquare(int n) +{//pobieranie wskaźników do pierwszego submodelu + return pModel?pModel->TerrainSquare(n):0; +}; +void __fastcall TAnimModel::TerrainRenderVBO(int n) +{//renderowanie terenu z VBO + if (pModel) pModel->TerrainRenderVBO(n); +}; +//--------------------------------------------------------------------------- + +void __fastcall TAnimModel::Advanced() +{//wykonanie zaawansowanych animacji na submodelach + pAdvanced->fCurrent+=pAdvanced->fFrequency*Timer::GetDeltaTime(); //aktualna ramka zmiennoprzecinkowo + int frame=floor(pAdvanced->fCurrent); //numer klatki jako int + TAnimContainer *pCurrent; + if (pAdvanced->fCurrent>=pAdvanced->fLast) + {//animacja została zakończona + delete pAdvanced; + pAdvanced=NULL; //dalej już nic + for (pCurrent=pRoot;pCurrent!=NULL;pCurrent=pCurrent->pNext) + if (pCurrent->pMovementData) //jeśli obsługiwany tabelką animacji + pCurrent->pMovementData=NULL; //usuwanie wskaźników + } + else + {//coś trzeba poanimować - wszystkie animowane submodele są w tym łańcuchu + for (pCurrent=pRoot;pCurrent!=NULL;pCurrent=pCurrent->pNext) + if (pCurrent->pMovementData) //jeśli obsługiwany tabelką animacji + if (frame>=pCurrent->pMovementData->iFrame) //koniec czekania + if (!strcmp(pCurrent->pMovementData->cBone,(pCurrent->pMovementData+1)->cBone)) + {//jak kolejna ramka dotyczy tego samego submodelu, ustawić animację do kolejnej ramki + ++pCurrent->pMovementData; //kolejna klatka + pCurrent->AnimSetVMD(pAdvanced->fFrequency/(double(pCurrent->pMovementData->iFrame)-pAdvanced->fCurrent)); + } + else + pCurrent->pMovementData=NULL; //inna nazwa, animowanie zakończone w aktualnym położeniu + } +}; + +void __fastcall TAnimModel::AnimationVND(void* pData, double a, double b, double c, double d) +{//rozpoczęcie wykonywania animacji z podanego pliku + //tabela w pliku musi być posortowana wg klatek dla kolejnych kości! + //skrócone nagranie ma 3:42 = 222 sekundy, animacja kończy się na klatce 6518 + //daje to 29.36 (~=30) klatek na sekundę + //w opisach jest podawane 24 albo 36 jako standard => powiedzmy, parametr (d) to FPS animacji + delete pAdvanced; //usunięcie ewentualnego poprzedniego + pAdvanced=NULL; //gdyby się nie udało rozpoznać pliku + if (AnsiString((char*)pData)=="Vocaloid Motion Data 0002") + { + pAdvanced=new TAnimAdvanced(); + pAdvanced->pVocaloidMotionData=(char*)pData; //podczepienie pliku danych + pAdvanced->iMovements=*((int*)(((char*)pData)+50)); //numer ostatniej klatki + pAdvanced->pMovementData=(TAnimVocaloidFrame*)(((char*)pData)+54); //rekordy animacji + //WriteLog(sizeof(TAnimVocaloidFrame)); + pAdvanced->fFrequency=d; + pAdvanced->fCurrent=0.0; //aktualna ramka + pAdvanced->fLast=0.0; //ostatnia ramka +/* + if (0) //jeśli włączone sortowanie plików VMD (trochę się przeciąga) + if (pAdvanced->SortByBone()) //próba posortowania + {//zapisać posortowany plik, jeśli dokonano zmian + TFileStream *fs=new TFileStream("models\\1.vmd",fmCreate); + fs->Write(pData,2198342); //2948728); + delete fs; + } +*/ + + int i,j,k,idx; + AnsiString name; + TAnimContainer *pSub; + for (i=0;iiMovements;++i) + {if (strcmp(pAdvanced->pMovementData[i].cBone,name.c_str())) + {//jeśli pozycja w tabelce nie była wyszukiwana w submodelach + pSub=GetContainer(pAdvanced->pMovementData[i].cBone); //szukanie + if (pSub) //znaleziony + {pSub->pMovementData=pAdvanced->pMovementData+i; //gotów do animowania + pSub->AnimSetVMD(0.0); //usuawienie pozycji początkowej (powinna być zerowa, inaczej będzie skok) + } + name=AnsiString(pAdvanced->pMovementData[i].cBone); //nowa nazwa do pomijania + } + if (pAdvanced->fLastpMovementData[i].iFrame) + pAdvanced->fLast=pAdvanced->pMovementData[i].iFrame; + } +/* + for (i=0;iiMovements;++i) + if (AnsiString(pAdvanced->pMovementData[i+1].cBone)!=AnsiString(pAdvanced->pMovementData[i].cBone)) + {//generowane dla ostatniej klatki danej kości + name=""; + for (j=0;j<15;j++) + name+=IntToHex((unsigned char)pAdvanced->pMovementData[i].cBone[j],2); + WriteLog(name+"," + +AnsiString(pAdvanced->pMovementData[i].cBone)+"," + +AnsiString(idx)+"," //indeks + +AnsiString(i+1-idx)+"," //ile pozycji animacji + +AnsiString(k)+"," //pierwsza klatka + +AnsiString(pAdvanced->pMovementData[i].iFrame)+"," //ostatnia klatka + +AnsiString(pAdvanced->pMovementData[i].f3Vector.x)+"," + +AnsiString(pAdvanced->pMovementData[i].f3Vector.y)+"," + +AnsiString(pAdvanced->pMovementData[i].f3Vector.z)+"," + +AnsiString(pAdvanced->pMovementData[i].fAngle[0])+"," + +AnsiString(pAdvanced->pMovementData[i].fAngle[1])+"," + +AnsiString(pAdvanced->pMovementData[i].fAngle[2])+"," + +AnsiString(pAdvanced->pMovementData[i].fAngle[3]) + + ); + idx=i+1; + k=pAdvanced->pMovementData[i+1].iFrame; //pierwsza klatka następnego + } + else + if (pAdvanced->pMovementData[i].iFrame>0) + if ((k>pAdvanced->pMovementData[i].iFrame)||(k==0)) + k=pAdvanced->pMovementData[i].iFrame; //pierwsza niezerowa ramka +*/ +/* + for (i=0;iiMovements;++i) + if (AnsiString(pAdvanced->pMovementData[i].cBone)=="\x89\x45\x90\x65\x8E\x77\x82\x4F") + {name=""; + for (j=0;j<15;j++) + name+=IntToHex((unsigned char)pAdvanced->pMovementData[i].cBone[j],2); + WriteLog(name+"," + +AnsiString(i)+"," //pozycja w tabeli + +AnsiString(pAdvanced->pMovementData[i].iFrame)+"," //pierwsza klatka + ); + } +*/ + } +}; + +//--------------------------------------------------------------------------- +void __fastcall TAnimModel::LightSet(int n,float v) +{//ustawienie światła (n) na wartość (v) + if (n>=iMaxNumLights) return; //przekroczony zakres + lsLights[n]=TLightState(int(v)); + switch (lsLights[n]) + {//interpretacja ułamka zależnie od typu + case 0: //ustalenie czasu migotania, t<1s (f>1Hz), np. 0.1 => t=0.1 (f=10Hz) + break; + case 1: //ustalenie wypełnienia ułamkiem, np. 1.25 => zapalony przez 1/4 okresu + break; + case 2: //ustalenie częstotliwości migotania, f<1Hz (t>1s), np. 2.2 => f=0.2Hz (t=5s) + break; + case 3: //zapalenie świateł zależne od oświetlenia scenerii + if (v>3.0) + fDark=v-3.0; //ustawienie indywidualnego progu zapalania + else + fDark=0.25; //standardowy próg zaplania + break; + } +}; +//--------------------------------------------------------------------------- +void __fastcall TAnimModel::AnimUpdate(double dt) +{//wykonanie zakolejkowanych animacji, nawet gdy modele nie są aktualnie wyświetlane + TAnimContainer *p=TAnimModel::acAnimList; + while (p) + {//jeśli w ogóle jest co animować + //if ((*p)->fTranslateSpeed==0.0) + // if ((*p)->fRotateSpeed==0.0) + // {//jak się naanimował, to usunąć z listy + // *p=(*p)->ListRemove(); //zwraca wskaźnik do kolejnego z listy + // } + p->UpdateModel(); + p=p->acAnimNext; //na razie bez usuwania z listy, bo głównie obrotnica na nią wchodzi + } +}; +//--------------------------------------------------------------------------- + diff --git a/AnimModel.h b/AnimModel.h new file mode 100644 index 00000000..3d5eed7b --- /dev/null +++ b/AnimModel.h @@ -0,0 +1,148 @@ +//--------------------------------------------------------------------------- + +#ifndef AnimModelH +#define AnimModelH + +#include "Model3d.h" + +const int iMaxNumLights=8; + +//typy stanu świateł +typedef enum { + ls_Off=0, //zgaszone + ls_On=1, //zapalone + ls_Blink=2, //migające + ls_Dark=3 //Ra: zapalajce się automatycznie, gdy zrobi się ciemno +} TLightState; + +class TAnimVocaloidFrame +{//ramka animacji typu Vocaloid Motion Data z programu MikuMikuDance +public: + char cBone[15]; //nazwa kości, może być po japońsku + int iFrame; //numer ramki + float3 f3Vector; //przemieszczenie + float4 qAngle; //kwaternion obrotu + char cBezier[64]; //krzywe Béziera do interpolacji dla x,y,z i obrotu +}; + +class TEvent; + +class TAnimContainer +{//opakowanie submodelu, określające animację egzemplarza - obsługiwane jako lista +friend class TAnimModel; +private: + vector3 vRotateAngles; //dla obrotów Eulera + vector3 vDesiredAngles; + double fRotateSpeed; + vector3 vTranslation; + vector3 vTranslateTo; + double fTranslateSpeed; //może tu dać wektor? + float4 qCurrent; //aktualny interpolowany + float4 qStart; //pozycja początkowa (0 dla interpolacji) + float4 qDesired; //pozycja końcowa (1 dla interpolacji) + float fAngleCurrent; //parametr interpolacyjny: 0=start, 1=docelowy + float fAngleSpeed; //zmiana parametru interpolacji w sekundach + TSubModel *pSubModel; + float4x4 *mAnim; //macierz do animacji kwaternionowych + //dla kinematyki odwróconej używane są kwaterniony + float fLength; //długość kości dla IK + int iAnim; //animacja: +1-obrót Eulera, +2-przesuw, +4-obrót kwaternionem, +8-IK + //+0x80000000: animacja z eventem, wykonywana poza wyświetlaniem + //+0x100: pierwszy stopień IK - obrócić w stronę pierwszego potomnego (dziecka) + //+0x200: drugi stopień IK - dostosować do pozycji potomnego potomnego (wnuka) + union + {//mogą być animacje klatkowe różnego typu, wskaźniki używa AnimModel + TAnimVocaloidFrame *pMovementData; //wskaźnik do klatki + }; + TEvent *evDone; //ewent wykonywany po zakończeniu animacji, np. zapór, obrotnicy +public: + TAnimContainer *pNext; + TAnimContainer *acAnimNext; //lista animacji z eventem, które muszą być przeliczane również bez wyświetlania + __fastcall TAnimContainer(); + __fastcall ~TAnimContainer(); + bool __fastcall Init(TSubModel *pNewSubModel); + //std::string inline __fastcall GetName() { return std::string(pSubModel?pSubModel->asName.c_str():""); }; + //std::string inline __fastcall GetName() { return std::string(pSubModel?pSubModel->pName:""); }; + char* __fastcall NameGet() {return (pSubModel?pSubModel->pName:NULL);}; + //void __fastcall SetRotateAnim(vector3 vNewRotateAxis, double fNewDesiredAngle, double fNewRotateSpeed, bool bResetAngle=false); + void __fastcall SetRotateAnim(vector3 vNewRotateAngles, double fNewRotateSpeed); + void __fastcall SetTranslateAnim(vector3 vNewTranslate, double fNewSpeed); + void __fastcall AnimSetVMD(double fNewSpeed); + void __fastcall PrepareModel(); + void __fastcall UpdateModel(); + void __fastcall UpdateModelIK(); + bool __fastcall InMovement(); //czy w trakcie animacji? + double _fastcall AngleGet() {return vRotateAngles.z;}; //jednak ostatnia, T3D ma inny układ + vector3 _fastcall TransGet() {return vector3(-vTranslation.x,vTranslation.z,vTranslation.y);}; //zmiana, bo T3D ma inny układ + void __fastcall WillBeAnimated() {if (pSubModel) pSubModel->WillBeAnimated();}; + void __fastcall EventAssign(TEvent *ev); + TEvent* __fastcall Event() {return evDone;}; +}; + +class TAnimAdvanced +{//obiekt zaawansowanej animacji submodelu +public: + TAnimVocaloidFrame *pMovementData; + unsigned char *pVocaloidMotionData; //plik animacyjny dla egzemplarza (z eventu) + double fFrequency; //przeliczenie czasu rzeczywistego na klatki animacji + double fCurrent; //klatka animacji wyświetlona w poprzedniej klatce renderingu + double fLast; //klatka kończąca animację + int iMovements; + __fastcall TAnimAdvanced(); + __fastcall ~TAnimAdvanced(); + int __fastcall SortByBone(); +}; + +class TAnimModel +{//opakowanie modelu, określające stan egzemplarza +private: + TAnimContainer *pRoot; //pojemniki sterujące, tylko dla aniomowanych submodeli + TModel3d *pModel; + double fBlinkTimer; + int iNumLights; + TSubModel *LightsOn[iMaxNumLights]; //Ra: te wskaźniki powinny być w ramach TModel3d + TSubModel *LightsOff[iMaxNumLights]; + vector3 vAngle; //bazowe obroty egzemplarza względem osi + int iTexAlpha; //żeby nie sprawdzać za każdym razem, dla 4 wymiennych tekstur + AnsiString asText; //tekst dla wyświetlacza znakowego + TAnimAdvanced *pAdvanced; + void __fastcall Advanced(); + TLightState lsLights[iMaxNumLights]; + float fDark; //poziom zapalanie światła (powinno być chyba powiązane z danym światłem?) + float fOnTime,fOffTime; //były stałymi, teraz mogą być zmienne dla każdego egzemplarza +private: + void __fastcall RaAnimate(); //przeliczenie animacji egzemplarza + void __fastcall RaPrepare(); //ustawienie animacji egzemplarza na wzorcu +public: + GLuint ReplacableSkinId[5]; //McZapkie-020802: zmienialne skory + static TAnimContainer *acAnimList; //lista animacji z eventem, które muszą być przeliczane również bez wyświetlania + __fastcall TAnimModel(); + __fastcall ~TAnimModel(); + bool __fastcall Init(TModel3d *pNewModel); + bool __fastcall Init(AnsiString asName,AnsiString asReplacableTexture); + bool __fastcall Load(cParser *parser, bool ter=false); + TAnimContainer* __fastcall AddContainer(char *pName); + TAnimContainer* __fastcall GetContainer(char *pName); + void __fastcall RenderDL(vector3 pPosition=vector3(0,0,0),double fAngle=0); + void __fastcall RenderAlphaDL(vector3 pPosition=vector3(0,0,0),double fAngle=0); + void __fastcall RenderVBO(vector3 pPosition=vector3(0,0,0),double fAngle=0); + void __fastcall RenderAlphaVBO(vector3 pPosition=vector3(0,0,0),double fAngle=0); + void __fastcall RenderDL(vector3* vPosition); + void __fastcall RenderAlphaDL(vector3* vPosition); + void __fastcall RenderVBO(vector3* vPosition); + void __fastcall RenderAlphaVBO(vector3* vPosition); + int __fastcall Flags(); + void __fastcall RaAnglesSet(double a,double b,double c) + {vAngle.x=a; vAngle.y=b; vAngle.z=c;}; + bool __fastcall TerrainLoaded(); + int __fastcall TerrainCount(); + TSubModel* __fastcall TerrainSquare(int n); + void __fastcall TerrainRenderVBO(int n); + void __fastcall AnimationVND(void* pData, double a, double b, double c, double d); + void __fastcall LightSet(int n,float v); + static void __fastcall AnimUpdate(double dt); +}; +TAnimContainer *TAnimModel::acAnimList=NULL; + +//--------------------------------------------------------------------------- +#endif diff --git a/Button.cpp b/Button.cpp new file mode 100644 index 00000000..06cae4c2 --- /dev/null +++ b/Button.cpp @@ -0,0 +1,70 @@ +//--------------------------------------------------------------------------- + +#include "system.hpp" +#include "classes.hpp" +#pragma hdrstop + +#include "Button.h" +#include "Console.h" + +//--------------------------------------------------------------------------- + +#pragma package(smart_init) + +__fastcall TButton::TButton() +{ + iFeedbackBit=0; + Clear(); +}; + +__fastcall TButton::~TButton() +{ +}; + +void __fastcall TButton::Clear(int i) +{ + pModelOn=NULL; + pModelOff=NULL; + bOn=false; + if (i>=0) FeedbackBitSet(i); + Update(); //kasowanie bitu Feedback, o ile jakiś ustawiony +}; + +void __fastcall TButton::Init(AnsiString asName,TModel3d *pModel,bool bNewOn) +{ + if (!pModel) return; //nie ma w czym szukać + pModelOn=pModel->GetFromName(AnsiString(asName+"_on").c_str()); + pModelOff=pModel->GetFromName(AnsiString(asName+"_off").c_str()); + bOn=bNewOn; + Update(); +}; + +void __fastcall TButton::Load(TQueryParserComp *Parser,TModel3d *pModel1,TModel3d *pModel2) +{ + AnsiString str=Parser->GetNextSymbol().LowerCase(); + if (pModel1) + {//poszukiwanie submodeli w modelu + Init(str,pModel1,false); + if (pModel2) + if (!pModelOn&&!pModelOff) + Init(str,pModel2,false); //może w drugim będzie (jak nie w kabinie, to w zewnętrznym) + } + else + { + pModelOn=NULL; + pModelOff=NULL; + } +}; + +void __fastcall TButton::Update() +{ + if (pModelOn) pModelOn->iVisible=bOn; + if (pModelOff) pModelOff->iVisible=!bOn; + if (iFeedbackBit) //jeżeli generuje informację zwrotną + {if (bOn) //zapalenie + Console::BitsSet(iFeedbackBit); + else + Console::BitsClear(iFeedbackBit); + } +}; + diff --git a/Button.h b/Button.h new file mode 100644 index 00000000..39da15b9 --- /dev/null +++ b/Button.h @@ -0,0 +1,31 @@ +//--------------------------------------------------------------------------- + +#ifndef ButtonH +#define ButtonH + +#include "Model3d.h" +#include "QueryParserComp.hpp" + +class TButton +{//animacja dwustanowa, włącza jeden z dwóch submodeli (jednego z nich może nie być) +private: + TSubModel *pModelOn,*pModelOff; //submodel dla stanu załączonego i wyłączonego + bool bOn; + int iFeedbackBit; //Ra: bit informacji zwrotnej, do wyprowadzenia na pulpit + void __fastcall Update(); +public: + __fastcall TButton(); + __fastcall ~TButton(); + void __fastcall Clear(int i=-1); + inline void FeedbackBitSet(int i) {iFeedbackBit=1<M_PI) + Yaw-=2*M_PI; + else if (Yaw<-M_PI) + Yaw+=2*M_PI; + if (Type==tp_Follow) //jeżeli jazda z pojazdem + { + Fix(Pitch,-M_PI_4,M_PI_4); //ograniczenie kąta spoglądania w dół i w górę + //Fix(Yaw,-M_PI,M_PI); + } +} + +void __fastcall TCamera::Update() +{ + //ABu: zmiana i uniezaleznienie predkosci od FPS + double a= (Console::Pressed(VK_SHIFT)?5.00:1.00); + if (Console::Pressed(VK_CONTROL)) + a=a*100; +// OldVelocity=Velocity; + if (FreeFlyModeFlag==true) + Type=tp_Free; + else + Type=tp_Follow; + if (Type==tp_Free) + { + if (Console::Pressed(Global::Keys[k_MechUp])) Velocity.y+=a; + if (Console::Pressed(Global::Keys[k_MechDown])) Velocity.y-=a; +//McZapkie-170402: zeby nie bylo konfliktow +/* + if (Console::Pressed(VkKeyScan('d'))) + Velocity.x+= a*Timer::GetDeltaTime(); + if (Console::Pressed(VkKeyScan('a'))) + Velocity.x-= a*Timer::GetDeltaTime(); + if (Console::Pressed(VkKeyScan('w'))) + Velocity.z-= a*Timer::GetDeltaTime(); + if (Console::Pressed(VkKeyScan('s'))) + Velocity.z+= a*Timer::GetDeltaTime(); + + if (Console::Pressed(VK_NUMPAD4) || Console::Pressed(VK_NUMPAD7) || Console::Pressed(VK_NUMPAD1)) + Yaw+= +1*M_PI*Timer::GetDeltaTime(); + + if (Console::Pressed(VK_NUMPAD6) || Console::Pressed(VK_NUMPAD9) || Console::Pressed(VK_NUMPAD3)) + Yaw+= -1*M_PI*Timer::GetDeltaTime(); + + if (Pressed(VK_NUMPAD2) || Console::Pressed(VK_NUMPAD1) || Console::Pressed(VK_NUMPAD3)) + Pitch+= -1*M_PI*Timer::GetDeltaTime(); + + if (Console::Pressed(VK_NUMPAD8) || Console::Pressed(VK_NUMPAD7) || Console::Pressed(VK_NUMPAD9)) + Pitch+= +1*M_PI*Timer::GetDeltaTime(); + if (Console::Pressed(VkKeyScan('.'))) + Roll+= -1*M_PI*Timer::GetDeltaTime(); + if (Console::Pressed(VkKeyScan(','))) + Roll+= +1*M_PI*Timer::GetDeltaTime(); + + if (Console::Pressed(VK_NUMPAD5)) + Pitch=Roll= 0.0f; +*/ + +//McZapkie-170402: poruszanie i rozgladanie we free takie samo jak w follow + if (Console::Pressed(Global::Keys[k_MechRight])) Velocity.x+=a; + if (Console::Pressed(Global::Keys[k_MechLeft])) Velocity.x-=a; + if (Console::Pressed(Global::Keys[k_MechForward])) Velocity.z-=a; + if (Console::Pressed(Global::Keys[k_MechBackward])) Velocity.z+=a; +//gora-dol + //if (Console::Pressed(VK_NUMPAD9)) Pos.y+=0.1; + //if (Console::Pressed(VK_NUMPAD3)) Pos.y-=0.1; + +//McZapkie: zeby nie hustalo przy malym FPS: +// Velocity= (Velocity+OldVelocity)/2; +// matrix4x4 mat; + vector3 Vec=Velocity; + Vec.RotateY(Yaw); + Pos=Pos+Vec*Timer::GetDeltaRenderTime(); //czas bez pauzy + Velocity=Velocity/2; //płynne hamowanie ruchu +// double tmp= 10*DeltaTime; +// Velocity+= -Velocity*10 * Timer::GetDeltaTime();//( tmp<1 ? tmp : 1 ); +// Type= tp_Free; + } + +} + +vector3 __fastcall TCamera::GetDirection() +{ + matrix4x4 mat; + vector3 Vec; + Vec= vector3(0,0,1); + Vec.RotateY(Yaw); + + return (Normalize(Vec)); +} + +//bool __fastcall TCamera::GetMatrix(matrix4x4 &Matrix) +bool __fastcall TCamera::SetMatrix() +{ + glRotated(-Roll*180.0f/M_PI,0,0,1); //po wyłączeniu tego kręci się pojazd, a sceneria nie + glRotated(-Pitch*180.0f/M_PI,1,0,0); + glRotated(-Yaw*180.0f/M_PI,0,1,0); //w zewnętrznym widoku: kierunek patrzenia + + if (Type==tp_Follow) + { +// gluLookAt(Pos.x+pOffset.x,Pos.y+pOffset.y,Pos.z+pOffset.z, +// LookAt.x+pOffset.x,LookAt.y+pOffset.y,LookAt.z+pOffset.z,vUp.x,vUp.y,vUp.z); +// gluLookAt(Pos.x+pOffset.x,Pos.y+pOffset.y,Pos.z+pOffset.z, +// LookAt.x+pOffset.x,LookAt.y+pOffset.y,LookAt.z+pOffset.z,vUp.x,vUp.y,vUp.z); + gluLookAt(Pos.x,Pos.y,Pos.z,LookAt.x,LookAt.y,LookAt.z,vUp.x,vUp.y,vUp.z); //Ra: pOffset is zero +// gluLookAt(Pos.x,Pos.y,Pos.z,Pos.x+Velocity.x,Pos.y+Velocity.y,Pos.z+Velocity.z,0,1,0); +// return true; + } + + if (Type==tp_Satelite) + Pitch= M_PI*0.5; + + if (Type!=tp_Follow) + { + glTranslated(-Pos.x,-Pos.y,-Pos.z); //nie zmienia kierunku patrzenia + } + + Global::SetCameraPosition(Pos); //było +pOffset + return true; +} + +void __fastcall TCamera::SetCabMatrix(vector3 &p) +{//ustawienie widoku z kamery bez przesunięcia robionego przez OpenGL - nie powinno tak trząść + glRotated(-Roll*180.0f/M_PI,0,0,1); + glRotated(-Pitch*180.0f/M_PI,1,0,0); + glRotated(-Yaw*180.0f/M_PI,0,1,0); //w zewnętrznym widoku: kierunek patrzenia + if (Type==tp_Follow) + gluLookAt(Pos.x-p.x,Pos.y-p.y,Pos.z-p.z,LookAt.x-p.x,LookAt.y-p.y,LookAt.z-p.z,vUp.x,vUp.y,vUp.z); //Ra: pOffset is zero +} + +void __fastcall TCamera::RaLook() +{//zmiana kierunku patrzenia - przelicza Yaw + vector3 where=LookAt-Pos+vector3(0,3,0); //trochę w górę od szyn + if ((where.x!=0.0)||(where.z!=0.0)) + Yaw=atan2(-where.x,-where.z); //kąt horyzontalny + double l=Length3(where); + if (l>0.0) + Pitch=asin(where.y/l); //kąt w pionie +}; + +void __fastcall TCamera::Stop() +{//wyłącznie bezwładnego ruchu po powrocie do kabiny + Type=tp_Follow; + Velocity=vector3(0,0,0); +}; + + + + diff --git a/Camera.h b/Camera.h new file mode 100644 index 00000000..1a77315e --- /dev/null +++ b/Camera.h @@ -0,0 +1,47 @@ +//--------------------------------------------------------------------------- +#ifndef CameraH +#define CameraH + + +#include "dumb3d.h" +using namespace Math3D; + +//--------------------------------------------------------------------------- +enum TCameraType +{//tryby pracy kamery + tp_Follow, //jazda z pojazdem + tp_Free, //stoi na scenerii + tp_Satelite //widok z góry (nie używany) +}; + +class TCamera +{ +private: + vector3 pOffset; //nie używane (zerowe) +public: //McZapkie: potrzebuje do kiwania na boki + double Pitch; + double Yaw; //w środku: 0=do przodu; na zewnątrz: 0=na południe + double Roll; + TCameraType Type; + vector3 Pos; //współrzędne obserwatora + vector3 LookAt; //współrzędne punktu, na który ma patrzeć + vector3 vUp; + vector3 Velocity; + vector3 OldVelocity; //lepiej usredniac zeby nie bylo rozbiezne przy malym FPS + vector3 CrossPos; + double CrossDist; + void __fastcall Init(vector3 NPos, vector3 NAngle); + void __fastcall Reset() { Pitch=Yaw=Roll= 0; }; + void __fastcall OnCursorMove(double x, double y); + void __fastcall Update(); + vector3 __fastcall GetDirection(); + //vector3 inline __fastcall GetCrossPos() { return Pos+GetDirection()*CrossDist+CrossPos; }; + + bool __fastcall SetMatrix(); + void __fastcall SetCabMatrix(vector3 &p); + void __fastcall RaLook(); + void __fastcall Stop(); + //bool __fastcall GetMatrix(matrix4x4 &Matrix); + vector3 PtNext, PtPrev; +}; +#endif diff --git a/Classes.cpp b/Classes.cpp new file mode 100644 index 00000000..3260cea8 --- /dev/null +++ b/Classes.cpp @@ -0,0 +1,10 @@ +//--------------------------------------------------------------------------- + +#include +#pragma hdrstop + +#include "Classes.h" + +//--------------------------------------------------------------------------- + +#pragma package(smart_init) diff --git a/Classes.h b/Classes.h new file mode 100644 index 00000000..eb617dec --- /dev/null +++ b/Classes.h @@ -0,0 +1,54 @@ +//--------------------------------------------------------------------------- + +#ifndef ClassesH +#define ClassesH +//--------------------------------------------------------------------------- +//Ra: zestaw klas do robienia wskaźników, aby uporządkować nagłówki +//--------------------------------------------------------------------------- +class TTrack; //odcinek trajektorii +class TEvent; +class TTrain; //pojazd sterowany +class TDynamicObject; //pojazd w scenerii +class TGroundNode; //statyczny obiekt scenerii +class TAnimModel; //opakowanie egzemplarz modelu +class TAnimContainer; //fragment opakowania egzemplarza modelu +//class TModel3d; //siatka modelu wspólna dla egzemplarzy +class TSubModel; //fragment modelu (tu do wyświetlania terenu) +class TMemCell; //komórka pamięci +class cParser; +class TRealSound; //dźwięk ze współrzędnymi XYZ +class TTextSound; //dźwięk ze stenogramem +class TEventLauncher; +class TTraction; //drut +class TTractionPowerSource; //zasilanie drutów + +class TMoverParameters; +namespace _mover +{ +class TLocation; +class TRotation; +}; + +namespace Mtable +{ +class TTrainParameters; //rozkład jazdy +}; + +class TController; //obiekt sterujący pociągiem (AI) +class TNames; //obiekt sortujący nazwy + +typedef enum +{//binarne odpowiedniki komend w komórce pamięci + cm_Unknown, //ciąg nierozpoznany (nie jest komendą) + cm_Ready, //W4 zezwala na odjazd, ale semafor może zatrzymać + cm_SetVelocity, + cm_ShuntVelocity, + cm_SetProximityVelocity, + cm_ChangeDirection, + cm_PassengerStopPoint, + cm_OutsideStation, + cm_Shunt, + cm_Command //komenda pobierana z komórki +} TCommandType; + +#endif diff --git a/Console.cpp b/Console.cpp new file mode 100644 index 00000000..e08b0591 --- /dev/null +++ b/Console.cpp @@ -0,0 +1,347 @@ +//--------------------------------------------------------------------------- + +#include +#pragma hdrstop + +#include "Console.h" +#include "Globals.h" +#include "Logs.h" +#include "PoKeys55.h" +#include "LPT.h" + +//--------------------------------------------------------------------------- +#pragma package(smart_init) +//Ra: klasa statyczna gromadząca sygnały sterujące oraz informacje zwrotne +//Ra: stan wejścia zmieniany klawiaturą albo dedykowanym urządzeniem +//Ra: stan wyjścia zmieniany przez symulację (mierniki, kontrolki) + +/******************************* +Do klawisza klawiatury przypisana jest maska bitowa oraz numer wejścia. +Naciśnięcie klawisza powoduje wywołanie procedury ustawienia bitu o podanej +masce na podanym wejściu. Zwonienie klawisza analogicznie wywołuje zerowanie +bitu wg maski. Zasadniczo w masce ustawiony jest jeden bit, ale w razie +potrzeby może być ich więcej. + +Oddzielne wejścia są wprowadzone po to, by można było używać więcej niż 32 +bity do sterowania. Podział na wejścia jest również ze względów organizacyjnych, +np. sterowanie światłami może mieć oddzielny numer wejścia niż przełączanie +radia, ponieważ nie ma potrzeby ich uzależniać (tzn. badać wspólną maskę bitową). + +Do każdego wejścia podpięty jest skrypt binarny, charakterystyczny dla danej +konstrukcji pojazdu. Sprawdza on zależności (w tym uszkodzenia) za pomocą +operacji logicznych na maskach bitowych. Do każdego wejścia jest przypisana +jedna, oddzielna maska 32 bit, ale w razie potrzeby istnieje też możliwość +korzystania z masek innych wejść. Skrypt może też wysyłać maski na inne wejścia, +ale należy unikać rekurencji. + +Definiowanie wejść oraz przeznaczenia ich masek jest w gestii konstruktora +skryptu. Każdy pojazd może mieć inny schemat wejść i masek, ale w miarę możliwości +należy dążyć do unifikacji. Skrypty mogą również używać dodatkowych masek bitowych. +Maski bitowe odpowiadają stanom przełączników, czujników, styczników itd. + +Działanie jest następujące: +- na klawiaturze konsoli naciskany jest przycisk +- naciśnięcie przycisku zamieniane jest na maskę bitową oraz numer wejścia +- wywoływany jest skrypt danego wejścia z ową maską +- skrypt sprawdza zależności i np. modyfikuje własności fizyki albo inne maski +- ewentualnie do wyzwalacza czasowego dodana jest maska i numer wejścia + +/*******************************/ + +/* //kod do przetrawienia: +//aby się nie włączacz wygaszacz ekranu, co jakiś czas naciska się wirtualnie ScrollLock + +[DllImport("user32.dll")] +static extern void keybd_event(byte bVk, byte bScan, uint dwFlags, UIntPtr dwExtraInfo); + +private static void PressScrollLock() +{//przyciska i zwalnia ScrollLock + const byte vkScroll = 0x91; + const byte keyeventfKeyup = 0x2; + keybd_event(vkScroll, 0x45, 0, (UIntPtr)0); + keybd_event(vkScroll, 0x45, keyeventfKeyup, (UIntPtr)0); +}; + +[DllImport("user32.dll")] +private static extern bool SystemParametersInfo(int uAction,int uParam,int &lpvParam,int flags); + +public static Int32 GetScreenSaverTimeout() +{ + Int32 value=0; + SystemParametersInfo(14,0,&value,0); + return value; +}; +*/ + +//Ra: do poprawienia +void SetLedState(char Code,bool bOn) +{//Ra: bajer do migania LED-ami w klawiaturze + if (Win32Platform==VER_PLATFORM_WIN32_NT) + { + //WriteLog(AnsiString(int(GetAsyncKeyState(Code)))); + if (bool(GetAsyncKeyState(Code))!=bOn) + { + keybd_event(Code,MapVirtualKey(Code,0),KEYEVENTF_EXTENDEDKEY,0); + keybd_event(Code,MapVirtualKey(Code,0),KEYEVENTF_EXTENDEDKEY|KEYEVENTF_KEYUP,0); + } + } + else + { + TKeyboardState KBState; + GetKeyboardState(KBState); + KBState[Code]=bOn?1:0; + SetKeyboardState(KBState); + }; +}; + +//--------------------------------------------------------------------------- + +int Console::iBits=0; //zmienna statyczna - obiekt Console jest jednen wspólny +int Console::iMode=0; +int Console::iConfig=0; +TPoKeys55 *Console::PoKeys55[2]={NULL,NULL}; +TLPT *Console::LPT=NULL; +int Console::iSwitch[8]; //bistabilne w kabinie, załączane z [Shift], wyłączane bez +int Console::iButton[8]; //monostabilne w kabinie, załączane podczas trzymania klawisza + +__fastcall Console::Console() +{ + PoKeys55[0]=PoKeys55[1]=NULL; + for (int i=0;i<8;++i) + {//zerowanie przełączników + iSwitch[i]=0; //bity 0..127 - bez [Ctrl], 128..255 - z [Ctrl] + iButton[i]=0; //bity 0..127 - bez [Shift], 128..255 - z [Shift] + } +}; + +__fastcall Console::~Console() +{ + delete PoKeys55[0]; + delete PoKeys55[1]; +}; + +void __fastcall Console::ModeSet(int m,int h) +{//ustawienie trybu pracy + iMode=m; + iConfig=h; +}; + +int __fastcall Console::On() +{//załączenie konsoli (np. nawiązanie komunikacji) + iSwitch[0]=iSwitch[1]=iSwitch[2]=iSwitch[3]=0; //bity 0..127 - bez [Ctrl] + iSwitch[4]=iSwitch[5]=iSwitch[6]=iSwitch[7]=0; //bity 128..255 - z [Ctrl] + switch (iMode) + {case 1: //kontrolki klawiatury + case 2: //kontrolki klawiatury + iConfig=0; //licznik użycia Scroll Lock + break; + case 3: //LPT + LPT=new TLPT(); //otwarcie inpout32.dll + if (LPT?LPT->Connect(iConfig):false) + {//wysłać 0? + BitsUpdate(-1); //aktualizacjia stanów, bo przy wczytywaniu mogło być nieaktywne + WriteLog("Feedback Mode 3: InpOut32.dll OK"); + } + else + {//połączenie nie wyszło, ma być NULL + delete LPT; + LPT=NULL; + } + break; + case 4: //PoKeys + PoKeys55[0]=new TPoKeys55(); + if (PoKeys55[0]?PoKeys55[0]->Connect():false) + {WriteLog("Found "+PoKeys55[0]->Version()); + BitsUpdate(-1); //aktualizacjia stanów, bo przy wczytywaniu mogło być nieaktywne + } + else + {//połączenie nie wyszło, ma być NULL + delete PoKeys55[0]; + PoKeys55[0]=NULL; + } + break; + } + return 0; +}; + +void __fastcall Console::Off() +{//wyłączenie informacji zwrotnych (reset pulpitu) + BitsClear(-1); + if ((iMode==1)||(iMode==2)) + if (iConfig&1) //licznik użycia Scroll Lock + {//bez sensu to jest, ale mi się samo włącza + SetLedState(VK_SCROLL,true); //przyciśnięty + SetLedState(VK_SCROLL,false); //zwolniony + } + delete PoKeys55[0]; PoKeys55[0]=NULL; + delete PoKeys55[1]; PoKeys55[1]=NULL; + delete LPT; LPT=NULL; +}; + +void __fastcall Console::BitsSet(int mask,int entry) +{//ustawienie bitów o podanej masce (mask) na wejściu (entry) + if ((iBits&mask)!=mask) //jeżeli zmiana + {int old=iBits; //poprzednie stany + iBits|=mask; + BitsUpdate(old^iBits); //1 dla bitów zmienionych + } +}; + +void __fastcall Console::BitsClear(int mask,int entry) +{//zerowanie bitów o podanej masce (mask) na wejściu (entry) + if (iBits&mask) //jeżeli zmiana + {int old=iBits; //poprzednie stany + iBits&=~mask; + BitsUpdate(old^iBits); //1 dla bitów zmienionych + } +}; + +void __fastcall Console::BitsUpdate(int mask) +{//aktualizacja stanu interfejsu informacji zwrotnej; (mask) - zakres zmienianych bitów + switch (iMode) + {case 1: //sterowanie światełkami klawiatury: CA/SHP+opory + if (mask&3) //gdy SHP albo CA + SetLedState(VK_CAPITAL,iBits&3); + if (mask&4) //gdy jazda na oporach + {//Scroll Lock ma jakoś dziwnie... zmiana stanu na przeciwny + SetLedState(VK_SCROLL,true); //przyciśnięty + SetLedState(VK_SCROLL,false); //zwolniony + ++iConfig; //licznik użycia Scroll Lock + } + break; + case 2: //sterowanie światełkami klawiatury: CA+SHP + if (mask&2) //gdy CA + SetLedState(VK_CAPITAL,iBits&2); + if (mask&1) //gdy SHP + {//Scroll Lock ma jakoś dziwnie... zmiana stanu na przeciwny + SetLedState(VK_SCROLL,true); //przyciśnięty + SetLedState(VK_SCROLL,false); //zwolniony + ++iConfig; //licznik użycia Scroll Lock + } + break; + case 3: //LPT Marcela z modyfikacją (jazda na oporach zamiast brzęczyka) + if (LPT) + LPT->Out(iBits); + break; + case 4: //PoKeys55 wg Marcela - wersja druga z końca 2012 + if (PoKeys55[0]) + {//pewnie trzeba będzie to dodatkowo buforować i oczekiwać na potwierdzenie + if (mask&0x0001) //b0 gdy SHP + PoKeys55[0]->Write(0x40,23-1,iBits&0x0001?1:0); + if (mask&0x0002) //b1 gdy zmieniony CA + PoKeys55[0]->Write(0x40,24-1,iBits&0x0002?1:0); + if (mask&0x0004) //b2 gdy jazda na oporach + PoKeys55[0]->Write(0x40,32-1,iBits&0x0004?1:0); + if (mask&0x0008) //b3 Lampka WS (wyłącznika szybkiego) + PoKeys55[0]->Write(0x40,25-1,iBits&0x0008?1:0); + if (mask&0x0010) //b4 Lampka przekaźnika nadmiarowego silników trakcyjnych + PoKeys55[0]->Write(0x40,27-1,iBits&0x0010?1:0); + if (mask&0x0020) //b5 Lampka styczników liniowych + PoKeys55[0]->Write(0x40,29-1,iBits&0x0020?1:0); + if (mask&0x0040) //b6 Lampka poślizgu + PoKeys55[0]->Write(0x40,30-1,iBits&0x0040?1:0); + if (mask&0x0080) //b7 Lampka "przetwornicy" + PoKeys55[0]->Write(0x40,28-1,iBits&0x0080?1:0); + if (mask&0x0100) //b8 Kontrolka przekaźnika nadmiarowego sprężarki + PoKeys55[0]->Write(0x40,33-1,iBits&0x0100?1:0); + if (mask&0x0200) //b9 Kontrolka sygnalizacji wentylatorów i oporów + PoKeys55[0]->Write(0x40,26-1,iBits&0x0200?1:0); + if (mask&0x0400) //b10 Kontrolka wysokiego rozruchu + PoKeys55[0]->Write(0x40,31-1,iBits&0x0400?1:0); + if (mask&0x0800) //b11 Kontrolka ogrzewania pociągu + PoKeys55[0]->Write(0x40,34-1,iBits&0x0800?1:0); + if (mask&0x1000) //b12 Ciśnienie w cylindrach do odbijania w haslerze + PoKeys55[0]->Write(0x40,52-1,iBits&0x1000?1:0); + if (mask&0x2000) //b13 Prąd na silnikach do odbijania w haslerze + PoKeys55[0]->Write(0x40,53-1,iBits&0x2000?1:0); + } + break; + } +}; + +bool __fastcall Console::Pressed(int x) +{//na razie tak - czyta się tylko klawiatura + return Global::bActive&&(GetKeyState(x)<0); +}; + +void __fastcall Console::ValueSet(int x,double y) +{//ustawienie wartości (y) na kanale analogowym (x) + if (iMode==4) + if (PoKeys55[0]) + { + PoKeys55[0]->PWM(x,(((Global::fCalibrateOut[x][3]*y)+Global::fCalibrateOut[x][2])*y+Global::fCalibrateOut[x][1])*y+Global::fCalibrateOut[x][0]); //zakres <0;1> + } +}; + +void __fastcall Console::Update() +{//funkcja powinna być wywoływana regularnie, np. raz w każdej ramce ekranowej + if (iMode==4) + if (PoKeys55[0]) + if (PoKeys55[0]->Update((Global::iPause&8)>0)) + {//wykrycie przestawionych przełączników? + Global::iPause&=~8; + } + else + {//błąd komunikacji - zapauzować symulację? + if (!(Global::iPause&8)) //jeśli jeszcze nie oflagowana + Global::iTextMode=VK_F1; //pokazanie czasu/pauzy + Global::iPause|=8; //tak??? + PoKeys55[0]->Connect(); //próba ponownego podłączenia + } +}; + +float __fastcall Console::AnalogGet(int x) +{//pobranie wartości analogowej + if (iMode==4) + if (PoKeys55[0]) + return PoKeys55[0]->fAnalog[x]; + return -1.0; +}; + +unsigned char __fastcall Console::DigitalGet(int x) +{//pobranie wartości cyfrowej + if (iMode==4) + if (PoKeys55[0]) + return PoKeys55[0]->iInputs[x]; + return 0; +}; + +void __fastcall Console::OnKeyDown(int k) +{//naciśnięcie klawisza z powoduje wyłączenie, a + if (k&0x10000) //jeśli [Shift] + {//ustawienie bitu w tabeli przełączników bistabilnych + if (k&0x20000) //jeśli [Ctrl], to zestaw dodatkowy + iSwitch[4+(char(k)>>5)]|=1<<(k&31); //załącz bistabliny dodatkowy + else + {//z [Shift] włączenie bitu bistabilnego i dodatkowego monostabilnego + iSwitch[char(k)>>5]|=1<<(k&31); //załącz bistabliny podstawowy + iButton[4+(char(k)>>5)]|=(1<<(k&31)); //załącz monostabilny dodatkowy + } + } + else + {//zerowanie bitu w tabeli przełączników bistabilnych + if (k&0x20000) //jeśli [Ctrl], to zestaw dodatkowy + iSwitch[4+(char(k)>>5)]&=~(1<<(k&31)); //wyłącz bistabilny dodatkowy + else + {iSwitch[char(k)>>5]&=~(1<<(k&31)); //wyłącz bistabilny podstawowy + iButton[char(k)>>5]|=1<<(k&31); //załącz monostabilny podstawowy + } + } +}; +void __fastcall Console::OnKeyUp(int k) +{//puszczenie klawisza w zasadzie nie ma znaczenia dla iSwitch, ale zeruje iButton + if ((k&0x20000)==0) //monostabilne tylko bez [Ctrl] + if (k&0x10000) //jeśli [Shift] + iButton[4+(char(k)>>5)]&=~(1<<(k&31)); //wyłącz monostabilny dodatkowy + else + iButton[char(k)>>5]&=~(1<<(k&31)); //wyłącz monostabilny podstawowy +}; +int __fastcall Console::KeyDownConvert(int k) +{ + return int(ktTable[k&0x3FF].iDown); +}; +int __fastcall Console::KeyUpConvert(int k) +{ + return int(ktTable[k&0x3FF].iUp); +}; + diff --git a/Console.h b/Console.h new file mode 100644 index 00000000..00d8e3fc --- /dev/null +++ b/Console.h @@ -0,0 +1,55 @@ +//--------------------------------------------------------------------------- + +#ifndef ConsoleH +#define ConsoleH +//--------------------------------------------------------------------------- +class TConsoleDevice; //urządzenie podłączalne za pomocą DLL +class TPoKeys55; +class TLPT; + +//klasy konwersji znaków wprowadzanych z klawiatury +class TKeyTrans +{//przekodowanie kodu naciśnięcia i zwolnienia klawisza +public: + short int iDown,iUp; +}; + +class Console +{//Ra: klasa statyczna gromadząca sygnały sterujące oraz informacje zwrotne + //Ra: stan wejścia zmieniany klawiaturą albo dedykowanym urządzeniem + //Ra: stan wyjścia zmieniany przez symulację (mierniki, kontrolki) +private: + static int iMode; //tryb pracy + static int iConfig; //dodatkowa informacja o sprzęcie (np. numer LPT) + static int iBits; //podstawowy zestaw lampek + static TPoKeys55 *PoKeys55[2]; //może ich być kilka + static TLPT *LPT; + static void __fastcall BitsUpdate(int mask); + //zmienne dla trybu "jednokabinowego", potrzebne do współpracy z pulpitem (PoKeys) + //używając klawiatury, każdy pojazd powinien mieć własny stan przełączników + //bazowym sterowaniem jest wirtualny strumień klawiatury + //przy zmianie kabiny z PoKeys, do kabiny są wysyłane stany tych przycisków + static int iSwitch[8]; //bistabilne w kabinie, załączane z [Shift], wyłączane bez + static int iButton[8]; //monostabilne w kabinie, załączane podczas trzymania klawisza + static TKeyTrans ktTable[4*256]; //tabela wczesnej konwersji klawiatury +public: + __fastcall Console(); + __fastcall ~Console(); + static void __fastcall ModeSet(int m,int h=0); + static void __fastcall BitsSet(int mask,int entry=0); + static void __fastcall BitsClear(int mask,int entry=0); + static int __fastcall On(); + static void __fastcall Off(); + static bool __fastcall Pressed(int x); + static void __fastcall ValueSet(int x,double y); + static void __fastcall Update(); + static float __fastcall AnalogGet(int x); + static unsigned char __fastcall DigitalGet(int x); + static void __fastcall OnKeyDown(int k); + static void __fastcall OnKeyUp(int k); + static int __fastcall KeyDownConvert(int k); + static int __fastcall KeyUpConvert(int k); +}; + +#endif + diff --git a/Console/LPT.cpp b/Console/LPT.cpp new file mode 100644 index 00000000..a83293e0 --- /dev/null +++ b/Console/LPT.cpp @@ -0,0 +1,46 @@ +//--------------------------------------------------------------------------- + +#include "LPT.h" +#include + +//LPT na USB: +//USB\VID_067B&PID_2305&REV_0200 +//{9d7debbc-c85d-11d1-9eb4-006008c3a19a} +//USB\VID_067B&PID_2305\5&1E41AFF0&0&2 +//IEEE-1284 Controller + +HINSTANCE hDLL; +typedef USHORT (__stdcall *InPortType)(USHORT BasePort); +typedef void (__stdcall *OutPortType)(USHORT BasePort, USHORT value); +InPortType InPort; +OutPortType OutPort; + +bool __fastcall TLPT::Connect(int port) +{ + //ladowanie dll-ki + hDLL=LoadLibrary("inpout32.dll"); + if (hDLL) + { + InPort=(InPortType)GetProcAddress(hDLL,"Inp32"); + OutPort=(OutPortType)GetProcAddress(hDLL,"Out32"); + } + else + return false; //MessageBox(NULL,"ERROR","Błąd przy ładowaniu pliku",MB_OK); + address=port; //&0xFFFFFC; //ostatnie 2 bity mają być zerowe -> a niech sobie OUT-ują, gdzie chcą + switch (address) //nie dotyczy 0x3BC + {case 0x0378: + case 0x0278: + OutPort(address+0x402,0); //SPP, czyli jednokierunkowe wyjście + break; + case 0xBC00: + case 0xBD00: + OutPort(address+0x006,0); //0xBC06? czysta improwizacja + } + return bool(OutPort); +}; + +void __fastcall TLPT::Out(int x) +{//wysłanie bajtu do portu + OutPort(address,x); +}; + diff --git a/Console/LPT.h b/Console/LPT.h new file mode 100644 index 00000000..15311eab --- /dev/null +++ b/Console/LPT.h @@ -0,0 +1,15 @@ +//--------------------------------------------------------------------------- + +#ifndef LPTH +#define LPTH +//--------------------------------------------------------------------------- + +class TLPT +{ +private: + int address; +public: + bool __fastcall Connect(int port); + void __fastcall Out(int x); +}; +#endif diff --git a/Console/PoKeys55.cpp b/Console/PoKeys55.cpp new file mode 100644 index 00000000..c4778b37 --- /dev/null +++ b/Console/PoKeys55.cpp @@ -0,0 +1,316 @@ +//--------------------------------------------------------------------------- +#include +#pragma hdrstop + +#include +#include "PoKeys55.h" +//--------------------------------------------------------------------------- +#pragma package(smart_init) +//HIDscaner: http://forum.simflight.com/topic/68257-latest-lua-package-for-fsuipc-and-wideclient/ +//#define MY_DEVICE_ID "Vid_04d8&Pid_003F" +//#define MY_DEVICE_ID "Vid_1dc3&Pid_1001&Rev_1000&MI_01" +//HID\Vid_1dc3&Pid_1001&Rev_1000&MI_01 - MI_01 to jest interfejs komunikacyjny (00-joystick, 02-klawiatura) + +HANDLE WriteHandle=INVALID_HANDLE_VALUE; +HANDLE ReadHandle =INVALID_HANDLE_VALUE; +//GUID InterfaceClassGuid={0x4d1e55b2,0xf16f,0x11cf,0x88,0xcb,0x00,0x11,0x11,0x00,0x00,0x30}; +//{4d1e55b2-f16f-11cf-88cb-001111000030} + +__fastcall TPoKeys55::TPoKeys55() +{ + cRequest=0; + iPWMbits=1; + iFaza=0; + iLastCommand=0; + fAnalog[0]=fAnalog[1]=fAnalog[2]=fAnalog[3]=fAnalog[4]=fAnalog[5]=fAnalog[6]=-1.0; + iPWM[0]=iPWM[1]=iPWM[2]=iPWM[3]=iPWM[4]=iPWM[5]=iPWM[6]=0; + iPWM[7]=4096; + iInputs[0]=0; //czy normalnie są w stanie wysokim? + iRepeats=0; + bNoError=true; +}; +//--------------------------------------------------------------------------- +__fastcall TPoKeys55::~TPoKeys55() +{ + Close(); +}; +//--------------------------------------------------------------------------- +bool __fastcall TPoKeys55::Close() +{//rozłączenie komunikacji + if (WriteHandle!=INVALID_HANDLE_VALUE) + CloseHandle(WriteHandle); + WriteHandle=INVALID_HANDLE_VALUE; + if (ReadHandle!=INVALID_HANDLE_VALUE) + CloseHandle(ReadHandle); + ReadHandle=INVALID_HANDLE_VALUE; +}; +//--------------------------------------------------------------------------- +bool __fastcall TPoKeys55::Connect() +{//Ra: to jest do wyczyszcznia z niepotrzebnych zmiennych i komunikatów + Close(); + GUID InterfaceClassGuid={0x4d1e55b2,0xf16f,0x11cf,0x88,0xcb,0x00,0x11,0x11,0x00,0x00,0x30}; //wszystkie HID tak mają + HDEVINFO DeviceInfoTable; + PSP_DEVICE_INTERFACE_DATA InterfaceDataStructure=new SP_DEVICE_INTERFACE_DATA; + PSP_DEVICE_INTERFACE_DETAIL_DATA DetailedInterfaceDataStructure=new SP_DEVICE_INTERFACE_DETAIL_DATA; + SP_DEVINFO_DATA DevInfoData; + DWORD InterfaceIndex=0; + //DWORD StatusLastError=0; + DWORD dwRegType; + DWORD dwRegSize; + DWORD StructureSize=0; + PBYTE PropertyValueBuffer; + bool MatchFound; + DWORD ErrorStatus; + HDEVINFO hDevInfo; + String DeviceIDFromRegistry; + String DeviceIDToFind="Vid_1dc3&Pid_1001&Rev_1000&MI_01"; + //First populate a list of plugged in devices (by specifying "DIGCF_PRESENT"), which are of the specified class GUID. + DeviceInfoTable=SetupDiGetClassDevs(&InterfaceClassGuid,NULL,NULL,DIGCF_PRESENT|DIGCF_DEVICEINTERFACE); + //Now look through the list we just populated. We are trying to see if any of them match our device. + while (true) + { + InterfaceDataStructure->cbSize=sizeof(SP_DEVICE_INTERFACE_DATA); + if (SetupDiEnumDeviceInterfaces(DeviceInfoTable, NULL, &InterfaceClassGuid, InterfaceIndex, InterfaceDataStructure)) + { + ErrorStatus=GetLastError(); + if (ERROR_NO_MORE_ITEMS==ErrorStatus) //Did we reach the end of the list of matching devices in the DeviceInfoTable? + {//Cound not find the device. Must not have been attached. + SetupDiDestroyDeviceInfoList(DeviceInfoTable); //Clean up the old structure we no longer need. + //ShowMessage("Erreur: Sortie1"); + return false; + } + } + else //Else some other kind of unknown error ocurred... + { + ErrorStatus=GetLastError(); + SetupDiDestroyDeviceInfoList(DeviceInfoTable); //Clean up the old structure we no longer need. + //ShowMessage("Erreur: Sortie2"); + return false; + } + //Now retrieve the hardware ID from the registry. The hardware ID contains the VID and PID, which we will then + //check to see if it is the correct device or not. + //Initialize an appropriate SP_DEVINFO_DATA structure. We need this structure for SetupDiGetDeviceRegistryProperty(). + DevInfoData.cbSize=sizeof(SP_DEVINFO_DATA); + SetupDiEnumDeviceInfo(DeviceInfoTable,InterfaceIndex,&DevInfoData); + //First query for the size of the hardware ID, so we can know how big a buffer to allocate for the data. + SetupDiGetDeviceRegistryProperty(DeviceInfoTable,&DevInfoData,SPDRP_HARDWAREID,&dwRegType,NULL,0,&dwRegSize); + //Allocate a buffer for the hardware ID. + //PropertyValueBuffer=(BYTE*)malloc(dwRegSize); + PropertyValueBuffer=new char[dwRegSize]; + if (PropertyValueBuffer==NULL) //if null,error,couldn't allocate enough memory + {//Can't really recover from this situation,just exit instead. + //ShowMessage("Allocation PropertyValueBuffer impossible"); + SetupDiDestroyDeviceInfoList(DeviceInfoTable); //Clean up the old structure we no longer need. + return false; + } + //Retrieve the hardware IDs for the current device we are looking at. PropertyValueBuffer gets filled with a + //REG_MULTI_SZ (array of null terminated strings). To find a device,we only care about the very first string in the + //buffer,which will be the "device ID". The device ID is a string which contains the VID and PID,in the example + //format "Vid_04d8&Pid_003f". + SetupDiGetDeviceRegistryProperty(DeviceInfoTable,&DevInfoData,SPDRP_HARDWAREID,&dwRegType,PropertyValueBuffer,dwRegSize,NULL); + //Now check if the first string in the hardware ID matches the device ID of my USB device. + //ListBox1->Items->Add((char*)PropertyValueBuffer); + DeviceIDFromRegistry=StrPas((char*)PropertyValueBuffer); + //free(PropertyValueBuffer); //No longer need the PropertyValueBuffer,free the memory to prevent potential memory leaks + delete PropertyValueBuffer; //No longer need the PropertyValueBuffer,free the memory to prevent potential memory leaks + //Convert both strings to lower case. This makes the code more robust/portable accross OS Versions + DeviceIDFromRegistry=DeviceIDFromRegistry.LowerCase(); + DeviceIDToFind=DeviceIDToFind.LowerCase(); + //Now check if the hardware ID we are looking at contains the correct VID/PID + MatchFound=(DeviceIDFromRegistry.AnsiPos(DeviceIDToFind)>0); + if (MatchFound==true) + { + //Device must have been found. Open read and write handles. In order to do this,we will need the actual device path first. + //We can get the path by calling SetupDiGetDeviceInterfaceDetail(),however,we have to call this function twice: The first + //time to get the size of the required structure/buffer to hold the detailed interface data,then a second time to actually + //get the structure (after we have allocated enough memory for the structure.) + DetailedInterfaceDataStructure->cbSize=sizeof(SP_DEVICE_INTERFACE_DETAIL_DATA); + //First call populates "StructureSize" with the correct value + SetupDiGetDeviceInterfaceDetail(DeviceInfoTable,InterfaceDataStructure,NULL,NULL,&StructureSize,NULL); + DetailedInterfaceDataStructure=(PSP_DEVICE_INTERFACE_DETAIL_DATA)(malloc(StructureSize)); //Allocate enough memory + if (DetailedInterfaceDataStructure==NULL) //if null,error,couldn't allocate enough memory + {//Can't really recover from this situation,just exit instead. + SetupDiDestroyDeviceInfoList(DeviceInfoTable); //Clean up the old structure we no longer need. + return false; + } + DetailedInterfaceDataStructure->cbSize=sizeof(SP_DEVICE_INTERFACE_DETAIL_DATA); + //Now call SetupDiGetDeviceInterfaceDetail() a second time to receive the goods. + SetupDiGetDeviceInterfaceDetail(DeviceInfoTable,InterfaceDataStructure,DetailedInterfaceDataStructure,StructureSize,NULL,NULL); + //We now have the proper device path,and we can finally open read and write handles to the device. + //We store the handles in the global variables "WriteHandle" and "ReadHandle",which we will use later to actually communicate. + WriteHandle=CreateFile((DetailedInterfaceDataStructure->DevicePath),GENERIC_WRITE,FILE_SHARE_READ|FILE_SHARE_WRITE,NULL,OPEN_EXISTING,0,0); + ErrorStatus=GetLastError(); + //if (ErrorStatus==ERROR_SUCCESS) + // ToggleLedBtn->Enabled=true;//Make button no longer greyed out + ReadHandle=CreateFile((DetailedInterfaceDataStructure->DevicePath),GENERIC_READ,FILE_SHARE_READ|FILE_SHARE_WRITE,NULL,OPEN_EXISTING,0,0); + ErrorStatus=GetLastError(); + if (ErrorStatus==ERROR_SUCCESS) + { + //GetPushbuttonState->Enabled=true;//Make button no longer greyed out + //StateLabel->Enabled=true;//Make label no longer greyed out + } + SetupDiDestroyDeviceInfoList(DeviceInfoTable); //Clean up the old structure we no longer need. + iRepeats=0; //nowe szanse na podłączenie + return true; + } + InterfaceIndex++; + //Keep looping until we either find a device with matching VID and PID,or until we run out of items. + }//end of while(true) + //ShowMessage("Sortie"); + return false; +} +//--------------------------------------------------------------------------- +bool __fastcall TPoKeys55::Write(unsigned char c,unsigned char b3,unsigned char b4,unsigned char b5) +{ + DWORD BytesWritten=0; + OutputBuffer[0]=0; //The first byte is the "Report ID" and does not get transmitted over the USB bus. Always set=0. + OutputBuffer[1]=0xBB; //0xBB - bajt rozpoznawczy dla PoKeys55 + OutputBuffer[2]=iLastCommand=c; //operacja: 0x31: blokowy odczyt wejść + OutputBuffer[3]=b3; //np. numer pinu (o 1 mniej niż numer na płytce) + OutputBuffer[4]=b4; + OutputBuffer[5]=b5; + OutputBuffer[6]=0; + OutputBuffer[7]=++cRequest; //numer żądania + OutputBuffer[8]=0; + for (int i=0;i<8;++i) + OutputBuffer[8]+=OutputBuffer[i]; //czy sumować też od 9 do 64? + //The basic Windows I/O functions WriteFile() and ReadFile() can be used to read and write to HID class USB devices + //(once we have the read and write handles to the device, which are obtained with CreateFile()). + //The following call to WriteFile() sends 64 bytes of data to the USB device. + WriteFile(WriteHandle,&OutputBuffer,65,&BytesWritten,0); //Blocking function, unless an "overlapped" structure is used + return (BytesWritten==65); + //Read(); //odczyt trzeba zrobić inaczej - w tym miejscu będzie za szybko i nic się nie odczyta +} +//--------------------------------------------------------------------------- + +bool __fastcall TPoKeys55::Read() +{ + DWORD BytesRead=0; + InputBuffer[0]=0; //The first byte is the "Report ID" and does not get transmitted over the USB bus. Always set=0. + //Now get the response packet from the firmware. + //The following call to ReadFIle() retrieves 64 bytes of data from the USB device. + ReadFile(ReadHandle,&InputBuffer,65,&BytesRead,0); //Blocking function,unless an "overlapped" structure is used + //InputPacketBuffer[0] is the report ID, which we don't care about. + //InputPacketBuffer[1] is an echo back of the command. + //InputPacketBuffer[2] contains the I/O port pin value for the pushbutton. + return (BytesRead==65)?InputBuffer[7]==cRequest:false; +} +//--------------------------------------------------------------------------- +bool __fastcall TPoKeys55::ReadLoop(int i) +{//próbuje odczytać (i) razy + do + {if (Read()) return true; + Sleep(1); //trochę poczekać, aż odpowie + } + while (--i); + return false; +} +//--------------------------------------------------------------------------- +AnsiString __fastcall TPoKeys55::Version() +{//zwraca numer wersji, funkcja nieoptymalna czasowo (czeka na odpowiedź) + if (!WriteHandle) return ""; + Write(0x00,0); //0x00 - Read serial number, version + if (ReadLoop(10)) + {//3: serial MSB; 4: serial LSB; 5: software version (v(1+[4-7]).([0-3])); 6: revision number + AnsiString s="PoKeys55 #"+AnsiString((InputBuffer[3]<<8)+InputBuffer[4]); + s+=" v"+AnsiString(1+(InputBuffer[5]>>4))+"."+AnsiString(InputBuffer[5]&15)+"."+AnsiString(InputBuffer[6]); +/* //Ra: pozyskiwanie daty można sobie darować, jest poniekąd bez sensu + Write(0x04,0); //0x04 - Read build date: drugi argument zmieniać od 0 do 2, uzyskując kolejno po 4 znaki + if (ReadLoop(5)) + {//2: 0x04; 3-6: char 1-4, 5-8, 9-11; (83-65-112-32-32-49-32-50-48-49-49-0=="Sep 1 2011") + s+=" ("+AnsiString((char*)InputBuffer+3,4); + Write(0x04,1); //0x04 - Read build date: drugi argument zmieniać od 0 do 2, uzyskując kolejno po 4 znaki + if (ReadLoop(5)) + {s+=AnsiString((char*)InputBuffer+3,4); + Write(0x04,2); //0x04 - Read build date: drugi argument zmieniać od 0 do 2, uzyskując kolejno po 4 znaki + if (ReadLoop(5)) + s+=AnsiString((char*)InputBuffer+3,3); + } + s+=")"; + } +*/ + return s; + } + return ""; +}; + +bool __fastcall TPoKeys55::PWM(int x,float y) +{//ustawienie wskazanego PWM (@12Mhz: 12000=1ms=1000Hz) + //iPWM[7]=1024; //1024==85333.3333333333ns=11718.75Hz + iPWM[x]=int(0.5f+0x0FFF*y)&0x0FFF; //0x0FFF=4095 + return true; +} + +bool __fastcall TPoKeys55::Update(bool pause) +{//funkcja powinna być wywoływana regularnie, np. raz w każdej ramce ekranowej + if (pause) + {//specjalna procedura, jeśli utracone połączenie spowodowało pauzę + iLastCommand=0; //połączenie zostało na nowo otwarte + //iFaza=0; //jeden błąd i podtrzymanie pauzy jest kontynuowane + } + switch (iFaza) + {case 0: //uaktualnienie PWM raz na jakiś czas + OutputBuffer[9]=0x3F; //maska użytych PWM + *((int*)(OutputBuffer+10))=iPWM[0]; //PWM1 (pin 22) + *((int*)(OutputBuffer+14))=iPWM[1]; //PWM2 (pin 21) + *((int*)(OutputBuffer+18))=iPWM[2]; //PWM3 (pin 20) + *((int*)(OutputBuffer+22))=iPWM[3]; //PWM4 (pin 19) + *((int*)(OutputBuffer+26))=iPWM[4]; //PWM5 (pin 18) + *((int*)(OutputBuffer+30))=iPWM[5]; //PWM6 (pin 17) + *((int*)(OutputBuffer+34))=iPWM[7]; //PWM period + if (Write(0xCB,1)) //wysłanie ustawień (1-ustaw, 0-odczyt) + iRepeats=0; //informacja, że poszło dobrze + ++iFaza; //ta faza została zakończona + //iRepeats=0; + break; + case 1: //odczyt wejść analogowych - komenda i przetwarzanie + if (iLastCommand!=0x3A) //asynchroniczne ustawienie kontrolki może namieszać + Write(0x3A,0); //0x3A - Analog inputs reading – all analog inputs in one command + else if (Read()) + {//jest odebrana ramka i zgodność numeru żądania + fAnalog[0]=((InputBuffer[21]<<8)+InputBuffer[22])/4095.0f; //pin 47 + fAnalog[1]=((InputBuffer[19]<<8)+InputBuffer[20])/4095.0f; //pin 46 + fAnalog[2]=((InputBuffer[17]<<8)+InputBuffer[18])/4095.0f; //pin 45 + fAnalog[3]=((InputBuffer[15]<<8)+InputBuffer[16])/4095.0f; //pin 44 + fAnalog[4]=((InputBuffer[13]<<8)+InputBuffer[14])/4095.0f; //pin 43 + fAnalog[5]=((InputBuffer[11]<<8)+InputBuffer[12])/4095.0f; //pin 42 + fAnalog[6]=((InputBuffer[ 9]<<8)+InputBuffer[10])/4095.0f; //pin 41 + ++iFaza; //skoro odczytano, można przejść do kolejnej fazy + iRepeats=0; //zerowanie licznika prób + } + else ++iRepeats; //licznik nieudanych prób + break; + case 2: //odczyt wejść cyfrowych - komenda i przetwarzanie + if (iLastCommand!=0x31) //asynchroniczne ustawienie kontrolki może namieszać + Write(0x31,0); //0x31: blokowy odczyt wejść + else if (Read()) + {//jest odebrana ramka i zgodność numeru żądania + iInputs[0]=*((int*)(InputBuffer+3)); //odczyt 32 bitów + iFaza=3; //skoro odczytano, można kolejny cykl + iRepeats=0; //zerowanie licznika prób + } + else ++iRepeats; //licznik nieudanych prób + break; + case 3: //ustawienie wyjść analogowych, 0..4095 mapować na 0..65520 (<<4) + if (Write(0x41,43-1,(iPWM[6]>>4),(iPWM[6]<<4))) //wysłanie ustawień + iRepeats=0; //informacja, że poszło dobrze + iFaza=0; //++iFaza; //ta faza została zakończona + //powinno jeszcze przyjść potwierdzenie o kodzie 0x41 + break; + default: + iFaza=0; //na wypadek, gdyby zbłądziło po jakichś zmianach w kodzie + //iRepeats=0; + } + if (!iRepeats) + bNoError=true; //jest OK + else if (iRepeats>=10) //youBy 2014-07: przy 5 powtórzeniach sieje mi pauzą po 2 razy na sekundę, a przy 10 jest ok + {//przekroczenie liczby prób wymusza kolejną fazę + ++iFaza; + iRepeats=1; //w nowej fazie nowe szanse, ale nie od 0! + bNoError=false; //zgłosić błąd + } + return (bNoError); //true oznacza prawidłowe działanie + //czy w przypadku błędu komunikacji z PoKeys włączać pauzę? + //dopiero poprawne podłączenie zeruje licznik prób +}; + diff --git a/Console/PoKeys55.h b/Console/PoKeys55.h new file mode 100644 index 00000000..29da7b22 --- /dev/null +++ b/Console/PoKeys55.h @@ -0,0 +1,31 @@ +//--------------------------------------------------------------------------- +#ifndef PoKeys55H +#define PoKeys55H +//--------------------------------------------------------------------------- +class TPoKeys55 +{//komunikacja z PoKeys bez określania przeznaczenia pinów + unsigned char cRequest; //numer żądania do sprawdzania odpowiedzi + unsigned char OutputBuffer[65]; //Allocate a memory buffer equal to our endpoint size + 1 + unsigned char InputBuffer[65]; //Allocate a memory buffer equal to our endpoint size + 1 + int iPWM[8]; //0-5:wyjścia PWM,6:analogowe,7:częstotliwośc PWM + int iPWMbits; + int iLastCommand; + int iFaza; + int iRepeats; //liczba powtórzeń + bool bNoError; //zerowany po przepełnieniu licznika powtórzeń, ustawiany po udanej operacji +public: + float fAnalog[7]; //wejścia analogowe, stan <0.0,1.0> + int iInputs[8]; + __fastcall TPoKeys55(); + __fastcall ~TPoKeys55(); + bool __fastcall Connect(); + bool __fastcall Close(); + bool __fastcall Write(unsigned char c,unsigned char b3,unsigned char b4=0,unsigned char b5=0); + bool __fastcall Read(); + bool __fastcall ReadLoop(int i); + AnsiString __fastcall Version(); + bool __fastcall PWM(int x,float y); + bool __fastcall Update(bool pause); +}; +//--------------------------------------------------------------------------- +#endif diff --git a/Curve.cpp b/Curve.cpp new file mode 100644 index 00000000..85e36dfd --- /dev/null +++ b/Curve.cpp @@ -0,0 +1,141 @@ +//--------------------------------------------------------------------------- + +#include "system.hpp" +#include "classes.hpp" +#pragma hdrstop + +#include "Curve.h" + + +__fastcall TCurve::TCurve() +{ + Values= NULL; + iNumValues= 0; + iNumCols= 0; +} + +__fastcall TCurve::~TCurve() +{ + for (int i=0; i=iNumValues) + return Values[iNumValues-1][c]; + p-= floor(p); + return Values[a][c]*(1.0f-p)+Values[b][c]*(p); +} + +bool __fastcall TCurve::SetValue(int c, float p, float v) +{ + int a= floor(p); + int b= ceil(p); + if (a<0) + return false; + if (b>=iNumValues) + return false; + p-= floor(p); + if (p<0.5) + Values[a][c]= v; + else + Values[b][c]= v; + return true; +} + +bool __fastcall TCurve::Load(TQueryParserComp *Parser) +{ + DecimalSeparator= '.'; + AnsiString Token; + + int n= Parser->GetNextSymbol().ToInt(); + int c= Parser->GetNextSymbol().ToInt(); + Init(n,c); + + n=0; + int i; + while (!Parser->EOF && nGetNextSymbol().ToDouble(); + n++; + } + DecimalSeparator= ','; +} + +bool __fastcall TCurve::LoadFromFile(AnsiString asName) +{ + DecimalSeparator= '.'; + TFileStream *fs; + fs= new TFileStream(asName, fmOpenRead | fmShareCompat ); + AnsiString str= "xxx"; + int size= fs->Size; + str.SetLength(size); + fs->Read(str.c_str(),size); + str+= ""; + delete fs; + TQueryParserComp *Parser; + Parser= new TQueryParserComp(NULL); + Parser->TextToParse= str; + Parser->First(); + Load(Parser); + + delete Parser; + DecimalSeparator= ','; +} + +#include + +bool __fastcall TCurve::SaveToFile(AnsiString asName) +{ + + DecimalSeparator= '.'; + FILE *stream=NULL; + stream = fopen(asName.c_str(), "w"); + + AnsiString str; + str= AnsiString(iNumValues); + fprintf(stream, str.c_str()); + fprintf(stream, "\n"); + for (int i=0; i +#include "DynObj.h" +#include +#include "Globals.h" +#include "Event.h" +#include "Ground.h" +#include "MemCell.h" +#include "World.h" +#include "dir.h" + +#define LOGVELOCITY 0 +#define LOGORDERS 0 +#define LOGSTOPS 1 +#define LOGBACKSCAN 0 +#define LOGPRESS 0 +/* + +Moduł obsługujący sterowanie pojazdami (składami pociągów, samochodami). +Ma działać zarówno jako AI oraz przy prowadzeniu przez człowieka. W tym +drugim przypadku jedynie informuje za pomocą napisów o tym, co by zrobił +w tym pierwszym. Obejmuje zarówno maszynistę jak i kierownika pociągu +(dawanie sygnału do odjazdu). + +Przeniesiona tutaj została zawartość ai_driver.pas przerobiona na C++. +Również niektóre funkcje dotyczące składów z DynObj.cpp. + +Teoria jest wtedy kiedy wszystko wiemy, ale nic nie działa. +Praktyka jest wtedy, kiedy wszystko działa, ale nikt nie wie dlaczego. +Tutaj łączymy teorię z praktyką - tu nic nie działa i nikt nie wie dlaczego… + +*/ + + +//zrobione: +//0. pobieranie komend z dwoma parametrami +//1. przyspieszanie do zadanej predkosci, ew. hamowanie jesli przekroczona +//2. hamowanie na zadanym odcinku do zadanej predkosci (ze stabilizacja przyspieszenia) +//3. wychodzenie z sytuacji awaryjnych: bezpiecznik nadmiarowy, poslizg +//4. przygotowanie pojazdu do drogi, zmiana kierunku ruchu +//5. dwa sposoby jazdy - manewrowy i pociagowy +//6. dwa zestawy psychiki: spokojny i agresywny +//7. przejscie na zestaw spokojny jesli wystepuje duzo poslizgow lub wybic nadmiarowego. +//8. lagodne ruszanie (przedluzony czas reakcji na 2 pierwszych nastawnikach) +//9. unikanie jazdy na oporach rozruchowych +//10. logowanie fizyki //Ra: nie przeniesione do C++ +//11. kasowanie czuwaka/SHP +//12. procedury wspomagajace "patrzenie" na odlegle semafory +//13. ulepszone procedury sterowania +//14. zglaszanie problemow z dlugim staniem na sygnale S1 +//15. sterowanie EN57 +//16. zmiana kierunku //Ra: z przesiadką po ukrotnieniu +//17. otwieranie/zamykanie drzwi +//18. Ra: odczepianie z zahamowaniem i podczepianie +//19. dla Humandriver: tasma szybkosciomierza - zapis do pliku! + +//do zrobienia: +//1. kierownik pociagu +//2. madrzejsze unikanie grzania oporow rozruchowych i silnika +//3. unikanie szarpniec, zerwania pociagu itp +//4. obsluga innych awarii +//5. raportowanie problemow, usterek nie do rozwiazania +//7. samouczacy sie algorytm hamowania + +//stałe +const double EasyReactionTime=0.5; //[s] przebłyski świadomości dla zwykłej jazdy +const double HardReactionTime=0.2; +const double EasyAcceleration=0.5; //[m/ss] +const double HardAcceleration=0.9; +const double PrepareTime =2.0; //[s] przebłyski świadomości przy odpalaniu +bool WriteLogFlag=false; + +AnsiString StopReasonTable[]= +{//przyczyny zatrzymania ruchu AI + "", //stopNone, //nie ma powodu - powinien jechać + "Off", //stopSleep, //nie został odpalony, to nie pojedzie + "Semaphore", //stopSem, //semafor zamknięty + "Time", //stopTime, //czekanie na godzinę odjazdu + "End of track", //stopEnd, //brak dalszej części toru + "Change direction", //stopDir, //trzeba stanąć, by zmienić kierunek jazdy + "Joining", //stopJoin, //zatrzymanie przy (p)odczepianiu + "Block", //stopBlock, //przeszkoda na drodze ruchu + "A command", //stopComm, //otrzymano taką komendę (niewiadomego pochodzenia) + "Out of station", //stopOut, //komenda wyjazdu poza stację (raczej nie powinna zatrzymywać!) + "Radiostop", //stopRadio, //komunikat przekazany radiem (Radiostop) + "External", //stopExt, //przesłany z zewnątrz + "Error", //stopError //z powodu błędu w obliczeniu drogi hamowania +}; + +//--------------------------------------------------------------------------- +//--------------------------------------------------------------------------- +//--------------------------------------------------------------------------- + +void __fastcall TSpeedPos::Clear() +{ + iFlags=0; //brak flag to brak reakcji + fVelNext=-1.0; //prędkość bez ograniczeń + fDist=0.0; + vPos=vector3(0,0,0); + trTrack=NULL; //brak wskaźnika +}; + +void __fastcall TSpeedPos::CommandCheck() +{//sprawdzenie typu komendy w evencie i określenie prędkości + TCommandType command=evEvent->Command(); + double value1=evEvent->ValueGet(1); + double value2=evEvent->ValueGet(2); + if (command==cm_ShuntVelocity) + {//prędkość manewrową zapisać, najwyżej AI zignoruje przy analizie tabelki + fVelNext=value1; //powinno być value2, bo druga określa "za"? + iFlags|=0x200; + } + else if (command==cm_SetVelocity) + {//w semaforze typu "m" jest ShuntVelocity dla Ms2 i SetVelocity dla S1 + //SetVelocity * 0 -> można jechać, ale stanąć przed + //SetVelocity 0 20 -> stanąć przed, potem można jechać 20 (SBL) + //SetVelocity -1 100 -> można jechać, przy następnym ograniczenie (SBL) + //SetVelocity 40 -1 -> PutValues: jechać 40 aż do minięcia (koniec ograniczenia( + fVelNext=value1; + iFlags&=~0xE00; //nie manewrowa, nie przystanek, nie zatrzymać na SBL + if (value1==0.0) //jeśli pierwsza zerowa + if (value2!=0.0) //a druga nie + {//S1 na SBL, można przejechać po zatrzymaniu (tu nie mamy prędkości ani odległości) + fVelNext=value2; //normalnie będzie zezwolenie na jazdę, aby się usunął z tabelki + iFlags|=0x800; //flaga, że ma zatrzymać; na pewno nie zezwoli na manewry + } + } + else if (command==cm_PassengerStopPoint) //nie ma dostępu do rozkładu + {//przystanek, najwyżej AI zignoruje przy analizie tabelki + if ((iFlags&0x400)==0) + fVelNext=0.0; //TrainParams->IsStop()?0.0:-1.0; //na razie tak + iFlags|=0x400; //niestety nie da się w tym miejscu współpracować z rozkładem + } + else if (command==cm_SetProximityVelocity) + {//ignorować + fVelNext=-1; + } + else if (command==cm_OutsideStation) + {//w trybie manewrowym: skanować od niej wstecz i stanąć po wyjechaniu za sygnalizator i zmienić kierunek + //w trybie pociągowym: można przyspieszyć do wskazanej prędkości (po zjechaniu z rozjazdów) + fVelNext=-1; + iFlags|=0x2100; //W5 + } + else + {//inna komenda w evencie skanowanym powoduje zatrzymanie i wysłanie tej komendy + iFlags&=~0xE00; //nie manewrowa, nie przystanek, nie zatrzymać na SBL + fVelNext=0; //jak nieznana komenda w komórce sygnałowej, to ma stać + } +}; + +bool __fastcall TSpeedPos::Update(vector3 *p,vector3 *dir,double &len) +{//przeliczenie odległości od punktu (*p), w kierunku (*dir), zaczynając od pojazdu + //dla kolejnych pozycji podawane są współrzędne poprzedniego obiektu w (*p) + vector3 v=vPos-*p; //wektor od poprzedniego obiektu (albo pojazdu) do punktu zmiany + fDist=v.Length(); //długość wektora to odległość pomiędzy czołem a sygnałem albo początkiem toru + //v.SafeNormalize(); //normalizacja w celu określenia znaku (nie potrzebna?) + if (len==0.0) + {//jeżeli liczymy względem pojazdu + double iska=dir?dir->x*v.x+dir->z*v.z:fDist; //iloczyn skalarny to rzut na chwilową prostą ruchu + if (iska<0.0) //iloczyn skalarny jest ujemny, gdy punkt jest z tyłu + {//jeśli coś jest z tyłu, to dokładna odległość nie ma już większego znaczenia + fDist=-fDist; //potrzebne do badania wyjechania składem poza ograniczenie + if (iFlags&32) //32 ustawione, gdy obiekt już został minięty + {//jeśli minięty (musi być minięty również przez końcówkę składu) + } + else + {iFlags^=32; //32-minięty - będziemy liczyć odległość względem przeciwnego końca toru (nadal może być z przodu i ogdaniczać) + if ((iFlags&0x43)==3) //tylko jeśli (istotny) tor, bo eventy są punktowe + if (trTrack) //może być NULL, jeśli koniec toru (????) + vPos=(iFlags&4)?trTrack->CurrentSegment()->FastGetPoint_0():trTrack->CurrentSegment()->FastGetPoint_1(); //drugi koniec istotny + } + } + else if (fDist<50.0) //przy dużym kącie łuku iloczyn skalarny bardziej zaniży odległość niż cięciwa + fDist=iska; //ale przy małych odległościach rzut na chwilową prostą ruchu da dokładniejsze wartości + } + if (fDist>0.0) //nie może być 0.0, a przypadkiem mogło by się trafić i było by źle + if ((iFlags&32)==0) //32 ustawione, gdy obiekt już został minięty + {//jeśli obiekt nie został minięty, można od niego zliczać narastająco (inaczej może być problem z wektorem kierunku) + len=fDist=len+fDist; //zliczanie dlugości narastająco + *p=vPos; //nowy punkt odniesienia + *dir=Normalize(v); //nowy wektor kierunku od poprzedniego obiektu do aktualnego + } + if (iFlags&2) //jeśli tor + { + if (trTrack) //może być NULL, jeśli koniec toru (???) + {fVelNext=trTrack->VelocityGet(); //aktualizacja prędkości (może być zmieniana eventem) + int i; + if ((i=iFlags&0xF0000000)!=0) + {//jeśli skrzyżowanie, ograniczyć prędkość przy skręcaniu + if (abs(i)>0x10000000) //±1 to jazda na wprost, ±2 nieby też, ale z przecięciem głównej drogi - chyba że jest równorzędne... + fVelNext=30.0; //uzależnić prędkość od promienia; albo niech będzie ograniczona w skrzyżowaniu (velocity z ujemną wartością) + if ((iFlags&32)==0) //jeśli nie wjechał + if (trTrack->iNumDynamics>0) //a skrzyżowanie zawiera pojazd + fVelNext=0.0; //to zabronić wjazdu (chyba że ten z przodu też jedzie prosto) + } + if (iFlags&8) //jeśli odcinek zmienny + {if (bool(trTrack->GetSwitchState()&1)!=bool(iFlags&16)) //czy stan się zmienił? + {//Ra: zakładam, że są tylko 2 możliwe stany + iFlags^=16; + //fVelNext=trTrack->VelocityGet(); //nowa prędkość + if ((iFlags&32)==0) return true; //jeszcze trzeba skanowanie wykonać od tego toru + //problem jest chyba, jeśli zwrotnica się przełoży zaraz po zjechaniu z niej + //na Mydelniczce potrafi skanować na wprost mimo pojechania na bok + } + //poniższe nie dotyczy trybu łączenia? + if ((iFlags&32)?false:trTrack->iNumDynamics>0) //jeśli jeszcze nie wjechano na tor, a coś na nim jest + fDist-=30.0,fVelNext=0.0; //to niech stanie w zwiększonej odległości + //else if (fVelNext==0.0) //jeśli została wyzerowana + // fVelNext=trTrack->VelocityGet(); //odczyt prędkości + } + } + } + else if (iFlags&0x100) //jeśli event + {//odczyt komórki pamięci najlepiej by było zrobić jako notyfikację, czyli zmiana komórki wywoła jakąś podaną funkcję + CommandCheck(); //sprawdzenie typu komendy w evencie i określenie prędkości + } + return false; +}; + +AnsiString __fastcall TSpeedPos::TableText() +{//pozycja tabelki prędkości + if (iFlags&0x1) + {//o ile pozycja istotna + if (iFlags&0x2) //jeśli tor + return "Flags=#"+IntToHex(iFlags,8)+", Dist="+FloatToStrF(fDist,ffFixed,7,1)+", Vel="+AnsiString(fVelNext)+", Track="+trTrack->NameGet(); + else if (iFlags&0x100) //jeśli event + return "Flags=#"+IntToHex(iFlags,8)+", Dist="+FloatToStrF(fDist,ffFixed,7,1)+", Vel="+AnsiString(fVelNext)+", Event="+evEvent->asName; + } + return "Empty"; +} + +bool __fastcall TSpeedPos::Set(TEvent *e,double d) +{//zapamiętanie zdarzenia + fDist=d; + iFlags=0x101; //event+istotny + evEvent=e; + vPos=e->PositionGet(); //współrzędne eventu albo komórki pamięci (zrzutować na tor?) + CommandCheck(); //sprawdzenie typu komendy w evencie i określenie prędkości + return fVelNext==0.0; //true gdy zatrzymanie, wtedy nie ma po co skanować dalej +}; + +void __fastcall TSpeedPos::Set(TTrack *t,double d,int f) +{//zapamiętanie zmiany prędkości w torze + fDist=d; //odległość do początku toru + trTrack=t; //TODO: (t) może być NULL i nie odczytamy końca poprzedniego :/ + if (trTrack) + {iFlags=f|(trTrack->eType==tt_Normal?2:10); //zapamiętanie kierunku wraz z typem + if (iFlags&8) if (trTrack->GetSwitchState()&1) iFlags|=16; + fVelNext=trTrack->VelocityGet(); + if (trTrack->iDamageFlag&128) fVelNext=0.0; //jeśli uszkodzony, to też stój + if (iFlags&64) + fVelNext=(trTrack->iCategoryFlag&1)?0.0:20.0; //jeśli koniec, to pociąg stój, a samochód zwolnij + vPos=(bool(iFlags&4)!=bool(iFlags&64))?trTrack->CurrentSegment()->FastGetPoint_1():trTrack->CurrentSegment()->FastGetPoint_0(); + } +}; + +//--------------------------------------------------------------------------- +//--------------------------------------------------------------------------- +//--------------------------------------------------------------------------- + +void __fastcall TController::TableClear() +{//wyczyszczenie tablicy + iFirst=iLast=0; + iTableDirection=0; //nieznany + for (int i=0;i0)?Track->evEvent2:Track->evEvent1; + if (!e) return NULL; + if (e->bEnabled) return NULL; + //jednak wszystkie W4 do tabelki, bo jej czyszczenie na przystanku wprowadza zamieszanie + return e; +} + +bool __fastcall TController::TableAddNew() +{//zwiększenie użytej tabelki o jeden rekord + iLast=(iLast+1)%iSpeedTableSize; + //TODO: jeszcze sprawdzić, czy się na iFirst nie nałoży + //TODO: wstawić tu wywołanie odtykacza - teraz jest to w TableTraceRoute() + //TODO: jeśli ostatnia pozycja zajęta, ustawiać dodatkowe flagi - teraz jest to w TableTraceRoute() + //TODO: przydało by się też posortować tabelkę wg odległości (ale nie w tym miejscu) + return true; //false gdy się nałoży +}; + +bool __fastcall TController::TableNotFound(TEvent *e) +{//sprawdzenie, czy nie został już dodany do tabelki (np. podwójne W4 robi problemy) + int i,j=(iLast+1)%iSpeedTableSize; //j, aby sprawdzić też ostatnią pozycję + for (i=iFirst;i!=j;i=(i+1)%iSpeedTableSize) + if ((sSpeedTable[i].iFlags&0x101)==0x101) //o ile używana pozycja + if (sSpeedTable[i].evEvent==e) + return false; //już jest, drugi raz dodawać nie ma po co + return true; //nie ma, czyli można dodać +}; + +void __fastcall TController::TableTraceRoute(double fDistance,TDynamicObject *pVehicle) +{//skanowanie trajektorii na odległość (fDistance) od (pVehicle) w kierunku przodu składu i uzupełnianie tabelki + if (!iDirection) //kierunek pojazdu z napędem + {//jeśli kierunek jazdy nie jest okreslony + iTableDirection=0; //czekamy na ustawienie kierunku + } + TTrack *pTrack; //zaczynamy od ostatniego analizowanego toru + //double fDistChVel=-1; //odległość do toru ze zmianą prędkości + double fTrackLength; //długość aktualnego toru (krótsza dla pierwszego) + double fCurrentDistance; //aktualna przeskanowana długość + TEvent *pEvent; + double fLastDir; //kierunek na ostatnim torze + if (iTableDirection!=iDirection) + {//jeśli zmiana kierunku, zaczynamy od toru ze wskazanym pojazdem + pTrack=pVehicle->RaTrackGet(); //odcinek, na którym stoi + fLastDir=pVehicle->DirectionGet()*pVehicle->RaDirectionGet(); //ustalenie kierunku skanowania na torze + fCurrentDistance=0; //na razie nic nie przeskanowano + fTrackLength=pVehicle->RaTranslationGet(); //pozycja na tym torze (odległość od Point1) + if (fLastDir>0) //jeśli w kierunku Point2 toru + fTrackLength=pTrack->Length()-fTrackLength; //przeskanowana zostanie odległość do Point2 + fLastVel=pTrack->VelocityGet(); //aktualna prędkość + iTableDirection=iDirection; //ustalenie w jakim kierunku jest wypełniana tabelka względem pojazdu + iFirst=iLast=0; + tLast=NULL; //żaden nie sprawdzony + } + else + {//kontynuacja skanowania od ostatnio sprawdzonego toru (w ostatniej pozycji zawsze jest tor) + if (sSpeedTable[iLast].iFlags&0x10000) //zatkanie + {//jeśli zapełniła się tabelka + if ((iLast+1)%iSpeedTableSize==iFirst) //jeśli nadal jest zapełniona + return; //nic się nie da zrobić + if ((iLast+2)%iSpeedTableSize==iFirst) //musi być jeszcze miejsce wolne na ewentualny event, bo tor jeszcze nie sprawdzony + return; //już lepiej, ale jeszcze nie tym razem + sSpeedTable[iLast].iFlags&=0xBE; //kontynuować próby doskanowania + } + else + if (VelNext==0) return; //znaleziono semafor lub tor z prędkością zero i nie ma co dalej sprawdzać + pTrack=sSpeedTable[iLast].trTrack; //ostatnio sprawdzony tor + if (!pTrack) return; //koniec toru, to nie ma co sprawdzać (nie ma prawa tak być) + fLastDir=sSpeedTable[iLast].iFlags&4?-1.0:1.0; //flaga ustawiona, gdy Point2 toru jest bliżej + fCurrentDistance=sSpeedTable[iLast].fDist; //aktualna odległość do jego Point1 + fTrackLength=sSpeedTable[iLast].iFlags&0x60?0.0:pTrack->Length(); //nie doliczać długości gdy: 32-minięty początek, 64-jazda do końca toru + } + if (fCurrentDistanceVelocityGet()==0.0) //zatrzymanie + || (pTrack->iAction) //jeśli tor ma własności istotne dla skanowania + || (pTrack->VelocityGet()!=fLastVel)) //następuje zmiana prędkości + {//odcinek dodajemy do tabelki, gdy jest istotny dla ruchu + if (TableAddNew()) + {//teraz dodatkowo zapamiętanie wybranego segmentu dla skrzyżowania + sSpeedTable[iLast].Set(pTrack,fCurrentDistance,fLastDir<0?5:1); //dodanie odcinka do tabelki z flagą kierunku wejścia + if (pTrack->eType==tt_Cross) //na skrzyżowaniach trzeba wybrać segment, po którym pojedzie pojazd + {//dopiero tutaj jest ustalany kierunek segmentu na skrzyżowaniu + sSpeedTable[iLast].iFlags|=(pTrack->CrossSegment((fLastDir<0)?tLast->iPrevDirection:tLast->iNextDirection,iRouteWanted)&15)<<28; //ostatnie 4 bity pola flag + sSpeedTable[iLast].iFlags&=~4; //usunięcie flagi kierunku, bo może być błędna + if (sSpeedTable[iLast].iFlags<0) sSpeedTable[iLast].iFlags|=4; //ustawienie flagi kierunku na podstawie wybranego segmentu + if (int(fLastDir)*sSpeedTable[iLast].iFlags<0) fLastDir=-fLastDir; + if (AIControllFlag) //dla AI na razie losujemy kierunek na kolejnym skrzyżowaniu + iRouteWanted=1+random(3); + } + } + } + else if ((pTrack->fRadius!=0.0) //odległość na łuku lepiej aproksymować cięciwami + || (tLast?tLast->fRadius!=0.0:false)) //koniec łuku też jest istotny + {//albo dla liczenia odległości przy pomocy cięciw - te usuwać po przejechaniu + if (TableAddNew()) + sSpeedTable[iLast].Set(pTrack,fCurrentDistance,fLastDir<0?0x85:0x81); //dodanie odcinka do tabelki + } + } + fCurrentDistance+=fTrackLength; //doliczenie kolejnego odcinka do przeskanowanej długości + tLast=pTrack; //odhaczenie, że sprawdzony + //Track->ScannedFlag=true; //do pokazywania przeskanowanych torów + fLastVel=pTrack->VelocityGet(); //prędkość na poprzednio sprawdzonym odcinku + pTrack=pTrack->Neightbour((pTrack->eType==tt_Cross)?(sSpeedTable[iLast].iFlags>>28):int(fLastDir),fLastDir); //może być NULL +/* + if (fLastDir>0) + {//jeśli szukanie od Point1 w kierunku Point2 + pTrack=pTrack->CurrentNext(); //może być NULL + if (pTrack) //jeśli dalej brakuje toru, to zostajemy na tym samym, z tą samą orientacją + if (tLast->iNextDirection) + fLastDir=-fLastDir; //można by zamiętać i zmienić tylko jeśli jest pTrack + } + else //if (fDirection<0) + {//jeśli szukanie od Point2 w kierunku Point1 + pTrack=pTrack->CurrentPrev(); //może być NULL + if (pTrack) //jeśli dalej brakuje toru, to zostajemy na tym samym, z tą samą orientacją + if (!tLast->iPrevDirection) + fLastDir=-fLastDir; + } +*/ + if (pTrack) + {//jeśli kolejny istnieje + if (tLast) + if (pTrack->VelocityGet()<0?tLast->VelocityGet()>0:pTrack->VelocityGet()>tLast->VelocityGet()) + {//jeśli kolejny ma większą prędkość niż poprzedni, to zapamiętać poprzedni (do czasu wyjechania) + if ((sSpeedTable[iLast].iFlags&3)==3?(sSpeedTable[iLast].trTrack!=tLast):true) //jeśli nie był dodany do tabelki + if (TableAddNew()) + sSpeedTable[iLast].Set(tLast,fCurrentDistance,(fLastDir>0?pTrack->iPrevDirection:pTrack->iNextDirection)?1:5); //zapisanie toru z ograniczeniem prędkości + } + if (((iLast+3)%iSpeedTableSize==iFirst)?true:((iLast+2)%iSpeedTableSize==iFirst)) //czy tabelka się nie zatka? + {//jest ryzyko nieznalezienia ograniczenia - ograniczyć prędkość do pozwalającej na zatrzymanie na końcu przeskanowanej drogi + TablePurger(); //usunąć pilnie zbędne pozycje + if (((iLast+3)%iSpeedTableSize==iFirst)?true:((iLast+2)%iSpeedTableSize==iFirst)) //czy tabelka się nie zatka? + {//jeśli odtykacz nie pomógł (TODO: zwiększyć rozmiar tabelki) + if (TableAddNew()) + sSpeedTable[iLast].Set(pTrack,fCurrentDistance,fLastDir<0?0x10045:0x10041); //zapisanie toru jako końcowego (ogranicza prędkosć) + //zapisać w logu, że należy poprawić scenerię? + return; //nie skanujemy dalej, bo nie ma miejsca + } + } + fTrackLength=pTrack->Length(); //zwiększenie skanowanej odległości tylko jeśli istnieje dalszy tor + } + else + {//definitywny koniec skanowania, chyba że dalej puszczamy samochód po gruncie... + if (TableAddNew()) //kolejny, bo się cofnęliśmy o 1 + sSpeedTable[iLast].Set(tLast,fCurrentDistance,fLastDir<0?0x45:0x41); //zapisanie ostatniego sprawdzonego toru + return; //to ostatnia pozycja, bo NULL nic nie da, a może się podpiąć obrotnica, czy jakieś transportery + } + } + if (TableAddNew()) + sSpeedTable[iLast].Set(pTrack,fCurrentDistance,fLastDir<0?4:0); //zapisanie ostatniego sprawdzonego toru + } +}; + +void __fastcall TController::TableCheck(double fDistance) +{//przeliczenie odległości w tabelce, ewentualnie doskanowanie (bez analizy prędkości itp.) + if (iTableDirection!=iDirection) + TableTraceRoute(fDistance,pVehicles[1]); //jak zmiana kierunku, to skanujemy od końca składu + else if (iTableDirection) + {//trzeba sprawdzić, czy coś się zmieniło + vector3 dir=pVehicles[0]->VectorFront()*pVehicles[0]->DirectionGet(); //wektor kierunku jazdy + vector3 pos=pVehicles[0]->HeadPosition(); //zaczynamy od pozycji pojazdu + //double lastspeed=-1; //prędkość na torze do usunięcia + double len=0.0; //odległość będziemy zliczać narastająco + for (int i=iFirst;i!=iLast;i=(i+1)%iSpeedTableSize) + {//aktualizacja rekordów z wyjątkiem ostatniego + if (sSpeedTable[i].iFlags&1) //jeśli pozycja istotna + {if (sSpeedTable[i].Update(&pos,&dir,len)) + {iLast=i; //wykryta zmiana zwrotnicy - konieczne ponowne przeskanowanie dalszej części + break; //nie kontynuujemy pętli, trzeba doskanować ciąg dalszy + } + if (sSpeedTable[i].iFlags&2) //jeśli odcinek + {if (sSpeedTable[i].fDist<-fLength) //a skład wyjechał całą długością poza + {//degradacja pozycji + sSpeedTable[i].iFlags&=~1; //nie liczy się + } + else if ((sSpeedTable[i].iFlags&0xF0000028)==0x20) //jest z tyłu (najechany) i nie jest zwrotnicą ani skrzyżowaniem + if (sSpeedTable[i].fVelNext<0) //a nie ma ograniczenia prędkości + sSpeedTable[i].iFlags=0; //to nie ma go po co trzymać (odtykacz usunie ze środka) + } + else if (sSpeedTable[i].iFlags&0x100) //jeśli event + {if (sSpeedTable[i].fDist<(sSpeedTable[i].evEvent->Type==tp_PutValues?-fLength:0)) //jeśli jest z tyłu + if ((mvOccupied->CategoryFlag&1)?false:sSpeedTable[i].fDist<-fLength) + {//pociąg staje zawsze, a samochód tylko jeśli nie przejedzie całą długością (może być zaskoczony zmianą) + sSpeedTable[i].iFlags&=~1; //degradacja pozycji dla samochodu; semafory usuwane tylko przy sprawdzaniu, bo wysyłają komendy + } + } + //if (sSpeedTable[i].fDist<-20.0*fLength) //jeśli to coś jest 20 razy dalej niż długość składu + //{sSpeedTable[i].iFlags&=~1; //to jest to jakby błąd w scenerii + // //WriteLog("Error: too distant object in scan table"); + //} + //if (sSpeedTable[i].fDist>20.0*fLength) //jeśli to coś jest 20 razy dalej niż długość składu + //{sSpeedTable[i].iFlags&=~1; //to jest to jakby błąd w scenerii + // //WriteLog("Error: too distant object in scan table"); + //} + } + if (i==iFirst) //jeśli jest pierwszą pozycją tabeli + {//pozbycie się początkowej pozycji + if ((sSpeedTable[i].iFlags&1)==0) //jeśli pozycja istotna (po Update() może się zmienić) + //if (iFirst!=iLast) //ostatnia musi zostać - to załatwia for() + iFirst=(iFirst+1)%iSpeedTableSize; //kolejne sprawdzanie będzie już od następnej pozycji + } + } + sSpeedTable[iLast].Update(&pos,&dir,len); //aktualizacja ostatniego + if (sSpeedTable[iLast].fDist0;--k,i=(i+1)%iSpeedTableSize) + {//sprawdzenie rekordów od (iFirst) do (iLast), o ile są istotne + if (sSpeedTable[i].iFlags&1) //badanie istotności + {//o ile dana pozycja tabelki jest istotna + if (sSpeedTable[i].iFlags&0x400) + {//jeśli przystanek, trzeba obsłużyć wg rozkładu + if (sSpeedTable[i].evEvent->CommandGet()!=asNextStop) + {//jeśli nazwa nie jest zgodna + if (sSpeedTable[i].fDist<-fLength) //jeśli został przejechany + sSpeedTable[i].iFlags=0; //to można usunąć (nie mogą być usuwane w skanowaniu) + continue; //ignorowanie jakby nie było tej pozycji + } + else if (iDrivigFlags&moveStopPoint) //jeśli pomijanie W4, to nie sprawdza czasu odjazdu + {//tylko gdy nazwa zatrzymania się zgadza + if (!TrainParams->IsStop()) + {//jeśli nie ma tu postoju + sSpeedTable[i].fVelNext=-1; //maksymalna prędkość w tym miejscu + if (sSpeedTable[i].fDist<200.0) //przy 160km/h jedzie 44m/s, to da dokładność rzędu 5 sekund + {//zaliczamy posterunek w pewnej odległości przed (choć W4 nie zasłania już semafora) +#if LOGSTOPS + WriteLog(pVehicle->asName+" as "+TrainParams->TrainName+": at "+AnsiString(GlobalTime->hh)+":"+AnsiString(GlobalTime->mm)+" skipped "+asNextStop); //informacja +#endif + fLastStopExpDist=mvOccupied->DistCounter+0.250+0.001*fLength; //przy jakim dystansie (stanie licznika) ma przesunąć na następny postój + TrainParams->UpdateMTable(GlobalTime->hh,GlobalTime->mm,asNextStop.SubString(20,asNextStop.Length())); + TrainParams->StationIndexInc(); //przejście do następnej + asNextStop=TrainParams->NextStop(); //pobranie kolejnego miejsca zatrzymania + //TableClear(); //aby od nowa sprawdziło W4 z inną nazwą już - to nie jest dobry pomysł + sSpeedTable[i].iFlags=0; //nie liczy się już + sSpeedTable[i].fVelNext=-1; //jechać + continue; //nie analizować prędkości + } + } //koniec obsługi przelotu na W4 + else + {//zatrzymanie na W4 + if (!eSignNext) eSignNext=sSpeedTable[i].evEvent; + if (mvOccupied->Vel>0.3) //jeśli jedzie (nie trzeba czekać, aż się drgania wytłumią - drzwi zamykane od 1.0) + sSpeedTable[i].fVelNext=0; //to będzie zatrzymanie + //else if ((iDrivigFlags&moveStopCloser)?sSpeedTable[i].fDist<=fMaxProximityDist*(AIControllFlag?1.0:10.0):true) + else if ((iDrivigFlags&moveStopCloser)?sSpeedTable[i].fDist+fLength<=Max0R(sSpeedTable[i].evEvent->ValueGet(2),fMaxProximityDist+fLength):true) + //Ra 2F1I: odległość plus długość pociągu musi być mniejsza od długości peronu, chyba że pociąg jest dłuższy, to wtedy minimalna + //jeśli długość peronu ((sSpeedTable[i].evEvent->ValueGet(2)) nie podana, przyjąć odległość fMinProximityDist + {//jeśli się zatrzymał przy W4, albo stał w momencie zobaczenia W4 + if (!AIControllFlag) //AI tylko sobie otwiera drzwi + iDrivigFlags&=~moveStopCloser; //w razie przełączenia na AI ma nie podciągać do W4, gdy użytkownik zatrzymał za daleko + if ((iDrivigFlags&moveDoorOpened)==0) + {//drzwi otwierać jednorazowo + iDrivigFlags|=moveDoorOpened; //nie wykonywać drugi raz + if (mvOccupied->DoorOpenCtrl==1) //(mvOccupied->TrainType==dt_EZT) + {//otwieranie drzwi w EZT + if (AIControllFlag) //tylko AI otwiera drzwi EZT, użytkownik musi samodzielnie + if (!mvOccupied->DoorLeftOpened&&!mvOccupied->DoorRightOpened) + {//otwieranie drzwi + int p2=int(floor(sSpeedTable[i].evEvent->ValueGet(2)))%10; //p7=platform side (1:left, 2:right, 3:both) + int lewe=(iDirection>0)?1:2; //jeśli jedzie do tyłu, to drzwi otwiera odwrotnie + int prawe=(iDirection>0)?2:1; + if (p2&lewe) mvOccupied->DoorLeft(true); + if (p2&prawe) mvOccupied->DoorRight(true); + //if (p2&3) //żeby jeszcze poczekał chwilę, zanim zamknie + // WaitingSet(10); //10 sekund (wziąć z rozkładu????) + } + } + else + {//otwieranie drzwi w składach wagonowych - docelowo wysyłać komendę zezwolenia na otwarcie drzwi + int p7,lewe,prawe; //p7=platform side (1:left, 2:right, 3:both) + p7=int(floor(sSpeedTable[i].evEvent->ValueGet(2)))%10; //tu będzie jeszcze długość peronu zaokrąglona do 10m (20m bezpieczniej, bo nie modyfikuje bitu 1) + TDynamicObject *p=pVehicles[0]; //pojazd na czole składu + while (p) + {//otwieranie drzwi w pojazdach - flaga zezwolenia była by lepsza + lewe=(p->DirectionGet()>0)?1:2; //jeśli jedzie do tyłu, to drzwi otwiera odwrotnie + prawe=3-lewe; + p->MoverParameters->BatterySwitch(true); //wagony muszą mieć baterię załączoną do otwarcia drzwi... + if (p7&lewe) p->MoverParameters->DoorLeft(true); + if (p7&prawe) p->MoverParameters->DoorRight(true); + p=p->Next(); //pojazd podłączony z tyłu (patrząc od czoła) + } + //if (p7&3) //żeby jeszcze poczekał chwilę, zanim zamknie + // WaitingSet(10); //10 sekund (wziąć z rozkładu????) + } + if (fStopTime>-5) //na końcu rozkładu się ustawia 60s i tu by było skrócenie + WaitingSet(10); //10 sekund (wziąć z rozkładu????) - czekanie niezależne od sposobu obsługi drzwi, bo opóźnia również kierownika + } + if (TrainParams->UpdateMTable(GlobalTime->hh,GlobalTime->mm,asNextStop.SubString(20,asNextStop.Length()))) + {//to się wykona tylko raz po zatrzymaniu na W4 + if (TrainParams->CheckTrainLatency()<0.0) + iDrivigFlags|=moveLate; //odnotowano spóźnienie + else + iDrivigFlags&=~moveLate; //przyjazd o czasie + if (TrainParams->DirectionChange()) //jeśli "@" w rozkładzie, to wykonanie dalszych komend + {//wykonanie kolejnej komendy, nie dotyczy ostatniej stacji + if (iDrivigFlags&movePushPull) //SN61 ma się też nie ruszać, chyba że ma wagony + {iDrivigFlags|=moveStopHere; //EZT ma stać przy peronie + if (OrderNextGet()!=Change_direction) + {OrderPush(Change_direction); //zmiana kierunku + OrderPush(TrainParams->StationIndexStationCount?Obey_train:Shunt); //to dalej wg rozkładu + } + } + else //a dla lokomotyw... + iDrivigFlags&=~(moveStopPoint|moveStopHere); //pozwolenie na przejechanie za W4 przed czasem i nie ma stać + JumpToNextOrder(); //przejście do kolejnego rozkazu (zmiana kierunku, odczepianie) + iDrivigFlags&=~moveStopCloser; //ma nie podjeżdżać pod W4 po przeciwnej stronie + sSpeedTable[i].iFlags=0; //ten W4 nie liczy się już zupełnie (nie wyśle SetVelocity) + sSpeedTable[i].fVelNext=-1; //jechać + continue; //nie analizować prędkości + } + } + if (OrderCurrentGet()==Shunt) + {OrderNext(Obey_train); //uruchomić jazdę pociągową + CheckVehicles(); //zmienić światła + } + if (TrainParams->StationIndexStationCount) + {//jeśli są dalsze stacje, czekamy do godziny odjazdu + if (TrainParams->IsTimeToGo(GlobalTime->hh,GlobalTime->mm)) + {//z dalszą akcją czekamy do godziny odjazdu + //if (TrainParams->CheckTrainLatency()<0.0) //jak się ma odjazd do czasu odjazdu? + // iDrivigFlags|=moveLate1; //oflagować, gdy odjazd ze spóźnieniem, będzie jechał forsowniej + fLastStopExpDist=mvOccupied->DistCounter+0.050+0.001*fLength; //przy jakim dystansie (stanie licznika) ma przesunąć na następny postój + // Controlled-> //zapisać odległość do przejechania + TrainParams->StationIndexInc(); //przejście do następnej + asNextStop=TrainParams->NextStop(); //pobranie kolejnego miejsca zatrzymania + //TableClear(); //aby od nowa sprawdziło W4 z inną nazwą już - to nie jest dobry pomysł +#if LOGSTOPS + WriteLog(pVehicle->asName+" as "+TrainParams->TrainName+": at "+AnsiString(GlobalTime->hh)+":"+AnsiString(GlobalTime->mm)+" next "+asNextStop); //informacja +#endif + if (int(floor(sSpeedTable[i].evEvent->ValueGet(1)))&1) + iDrivigFlags|=moveStopHere; //nie podjeżdżać do semafora, jeśli droga nie jest wolna + iDrivigFlags|=moveStopCloser; //do następnego W4 podjechać blisko (z dociąganiem) + iDrivigFlags&=~moveStartHorn; //bez trąbienia przed odjazdem + sSpeedTable[i].iFlags=0; //nie liczy się już zupełnie (nie wyśle SetVelocity) + sSpeedTable[i].fVelNext=-1; //można jechać za W4 + if (go==cm_Unknown) //jeśli nie było komendy wcześniej + go=cm_Ready; //gotów do odjazdu z W4 (semafor może zatrzymać) + if (tsGuardSignal) //jeśli mamy głos kierownika, to odegrać + iDrivigFlags|=moveGuardSignal; + continue; //nie analizować prędkości + } //koniec startu z zatrzymania + } //koniec obsługi początkowych stacji + else + {//jeśli dojechaliśmy do końca rozkładu +#if LOGSTOPS + WriteLog(pVehicle->asName+" as "+TrainParams->TrainName+": at "+AnsiString(GlobalTime->hh)+":"+AnsiString(GlobalTime->mm)+" end of route."); //informacja +#endif + asNextStop=TrainParams->NextStop(); //informacja o końcu trasy + TrainParams->NewName("none"); //czyszczenie nieaktualnego rozkładu + //TableClear(); //aby od nowa sprawdziło W4 z inną nazwą już - to nie jest dobry pomysł + iDrivigFlags&=~(moveStopCloser|moveStopPoint); //ma nie podjeżdżać pod W4 i ma je pomijać + sSpeedTable[i].iFlags=0; //W4 nie liczy się już (nie wyśle SetVelocity) + sSpeedTable[i].fVelNext=-1; //można jechać za W4 + fLastStopExpDist=-1.0f; //nie ma rozkładu, nie ma usuwania stacji + WaitingSet(60); //tak ze 2 minuty, aż wszyscy wysiądą + JumpToNextOrder(); //wykonanie kolejnego rozkazu (Change_direction albo Shunt) + iDrivigFlags|=moveStopHere|moveStartHorn; //ma się nie ruszać aż do momentu podania sygnału + continue; //nie analizować prędkości + } //koniec obsługi ostatniej stacji + } //if (MoverParameters->Vel==0.0) + } //koniec obsługi zatrzymania na W4 + } //koniec warunku pomijania W4 podczas zmiany czoła + else + {//skoro pomijanie, to jechać i ignorować W4 + sSpeedTable[i].iFlags=0; //W4 nie liczy się już (nie zatrzymuje jazdy) + sSpeedTable[i].fVelNext=-1; + continue; //nie analizować prędkości + } + } //koniec obsługi W4 + v=sSpeedTable[i].fVelNext; //odczyt prędkości do zmiennej pomocniczej + if (sSpeedTable[i].iFlags&8) //zwrotnice są usuwane z tabelki dopiero po zjechaniu z nich + iDrivigFlags|=moveSwitchFound; //rozjazd z przodu/pod ogranicza np. sens skanowania wstecz + else if (sSpeedTable[i].iFlags&0x100) //W4 może się deaktywować + {//jeżeli event, może być potrzeba wysłania komendy, aby ruszył + if (sSpeedTable[i].iFlags&0x2000) + {//jeśli W5, to reakcja zależna od trybu jazdy + if (OrderCurrentGet()&Obey_train) + {//w trybie pociągowym: można przyspieszyć do wskazanej prędkości (po zjechaniu z rozjazdów) + v=-1.0; //ignorować? + if (sSpeedTable[i].fDist<0.0) //jeśli wskaźnik został minięty + {VelSignal=v; //!!! ustawienie, gdy przejechany jest lepsze niż wcale, ale to jeszcze nie to +// iStationStart=TrainParams->StationIndex; //zaktualizować wyświetlanie rozkładu + } + else if (!(iDrivigFlags&moveSwitchFound)) //jeśli rozjazdy już minięte + VelSignal=v; //!!! to też koniec ograniczenia + } + else + {//w trybie manewrowym: skanować od niego wstecz, stanąć po wyjechaniu za sygnalizator i zmienić kierunek + v=0.0; //zmiana kierunku może być podanym sygnałem, ale wypadało by zmienić światło wcześniej + if (!(iDrivigFlags&moveSwitchFound)) //jeśli nie ma rozjazdu + iDrivigFlags|=moveTrackEnd; //to dalsza jazda trwale ograniczona (W5, koniec toru) + } + } + else if (sSpeedTable[i].iFlags&0x800) + {//jeśli S1 na SBL + if (mvOccupied->Vel<2.0) //stanąć nie musi, ale zwolnić przynajmniej + if (sSpeedTable[i].fDistValueGet(1); //to ma 0 odczytywać + } + if ((mvOccupied->CategoryFlag&1)?sSpeedTable[i].fDist>pVehicles[0]->fTrackBlock-20.0:false) //jak sygnał jest dalej niż zawalidroga + v=0.0; //to może być podany dla tamtego: jechać tak, jakby tam stop był + else + {//zawalidrogi nie ma (albo pojazd jest samochodem), sprawdzić sygnał + if (sSpeedTable[i].iFlags&0x200) //jeśli Tm - w zasadzie to sprawdzić komendę! + {//jeśli podana prędkość manewrowa + if ((OrderCurrentGet()&Obey_train)?v==0.0:false) + {//jeśli tryb pociągowy a tarcze ma ShuntVelocity 0 0 + v=-1; //ignorować, chyba że prędkość stanie się niezerowa + if (sSpeedTable[i].iFlags&0x20) //a jak przejechana + sSpeedTable[i].iFlags=0; //to można usunąć, bo podstawowy automat usuwa tylko niezerowe + } + else + if (go<=cm_Ready) //jeśli jeszcze nie ma komendy + if (v!=0.0) //komenda jest tylko gdy ma jechać, bo stoi na podstawie tabelki + {//jeśli nie było komendy wcześniej - pierwsza się liczy - ustawianie VelSignal + go=cm_ShuntVelocity; //w trybie pociągowym tylko jeśli włącza tryb manewrowy (v!=0.0) + //Ra 2014-06: (VelSignal) nie może być tu ustawiane, bo Tm może być daleko + //VelSignal=v; //nie do końca tak, to jest druga prędkość + if (VelSignal==0.0) VelSignal=v; //aby stojący ruszył + if (sSpeedTable[i].fDist<0.0) //jeśli przejechany + {VelSignal=v; //!!! ustawienie, gdy przejechany jest lepsze niż wcale, ale to jeszcze nie to + sSpeedTable[i].iFlags=0; //to można usunąć (nie mogą być usuwane w skanowaniu) + } + } + } + else //if (sSpeedTable[i].iFlags&0x100) //jeśli semafor !!! Komendę trzeba sprawdzić !!!! + if (go<=cm_Ready) //jeśli nie było komendy wcześniej - pierwsza się liczy - ustawianie VelSignal + if (v<0.0?true:v>=1.0) //bo wartość 0.1 służy do hamowania tylko + {go=cm_SetVelocity; //może odjechać + //Ra 2014-06: (VelSignal) nie może być tu ustawiane, bo semafor może być daleko + //VelSignal=v; //nie do końca tak, to jest druga prędkość; -1 nie wpisywać... + if (VelSignal==0.0) VelSignal=v; //aby stojący ruszył + if (sSpeedTable[i].fDist<0.0) //jeśli przejechany + {VelSignal=v; //!!! ustawienie, gdy przejechany jest lepsze niż wcale, ale to jeszcze nie to + if (sSpeedTable[i].iFlags&0x100) //jeśli semafor + if ((sSpeedTable[i].evEvent!=eSignSkip)?true:(sSpeedTable[i].fVelNext!=0.0)) //ale inny niż ten, na którym minięto S1, chyba że się już zmieniło + iDrivigFlags&=~moveVisibility; //sygnał zezwalający na jazdę wyłącza jazdę na widoczność (S1 na SBL) + sSpeedTable[i].iFlags=0; //to można usunąć (nie mogą być usuwane w skanowaniu) + } + } + else if (sSpeedTable[i].evEvent->StopCommand()) + {//jeśli prędkość jest zerowa, a komórka zawiera komendę + eSignNext=sSpeedTable[i].evEvent; //dla informacji + if (iDrivigFlags&moveStopHere) //jeśli ma stać, dostaje komendę od razu + go=cm_Command; //komenda z komórki, do wykonania po zatrzymaniu + else if (sSpeedTable[i].fDist<=20.0) //jeśli ma dociągnąć, to niech dociąga (moveStopCloser dotyczy dociągania do W4, nie semafora) + go=cm_Command; //komenda z komórki, do wykonania po zatrzymaniu + } + } //jeśli nie ma zawalidrogi + } //jeśli event + if (v>=0.0) + {//pozycje z prędkością -1 można spokojnie pomijać + d=sSpeedTable[i].fDist; + if ((sSpeedTable[i].iFlags&0x20)?false:d>0.0) //sygnał lub ograniczenie z przodu (+32=przejechane) + {//2014-02: jeśli stoi, a ma do przejechania kawałek, to niech jedzie + if ((mvOccupied->Vel==0.0)?((sSpeedTable[i].iFlags&0x501)==0x501)&&(d>fMaxProximityDist):false) + a=(iDrivigFlags&moveStopCloser)?fAcc:0.0; //ma podjechać bliżej - czy na pewno w tym miejscu taki warunek? + else + {a=(v*v-mvOccupied->Vel*mvOccupied->Vel)/(25.92*d); //przyspieszenie: ujemne, gdy trzeba hamować + if (d=1.0) //EU06 się zawieszało po dojechaniu na koniec toru postojowego + if (d<-fLength) + continue; //zapętlenie, jeśli już wyjechał za ten odcinek + if (v1.0 i się tu nie załapuje + //if (mvOccupied->Vel>10.0) + fAcc=a; //zalecane przyspieszenie (nie musi być uwzględniane przez AI) + fNext=v; //istotna jest prędkość na końcu tego odcinka + fDist=d; //dlugość odcinka + } + else if ((fAcc>0)&&(v>0)&&(v<=fNext)) + {//jeśli nie ma wskazań do hamowania, można podać drogę i prędkość na jej końcu + fNext=v; //istotna jest prędkość na końcu tego odcinka + fDist=d; //dlugość odcinka (kolejne pozycje mogą wydłużać drogę, jeśli prędkość jest stała) + } + } //if (v>=0.0) + if (fNext>=0.0) + {//jeśli ograniczenie + if ((sSpeedTable[i].iFlags&0x101)==0x101) //tylko sygnał przypisujemy + if (!eSignNext) //jeśli jeszcze nic nie zapisane tam + eSignNext=sSpeedTable[i].evEvent; //dla informacji + if (fNext==0.0) + break; //nie ma sensu analizować tabelki dalej + } + } //if (sSpeedTable[i].iFlags&1) + } //for + return go; +}; + +void __fastcall TController::TablePurger() +{//odtykacz: usuwa mniej istotne pozycje ze środka tabelki, aby uniknąć zatkania + //(np. brak ograniczenia pomiędzy zwrotnicami, usunięte sygnały, minięte odcinki łuku) + int i,j,k=iLast-iFirst; //może być 15 albo 16 pozycji, ostatniej nie ma co sprawdzać + if (k<0) k+=iSpeedTableSize; //ilość pozycji do przeanalizowania + for (i=iFirst;k>0;--k,i=(i+1)%iSpeedTableSize) + {//sprawdzenie rekordów od (iFirst) do (iLast), o ile są istotne + if ((sSpeedTable[i].iFlags&1)?(sSpeedTable[i].fVelNext<0)&&((sSpeedTable[i].iFlags&0xAB)==0xA3):true) + {//jeśli jest to minięty (0x20) tor (0x03) do liczenia cięciw (0x80), a nie zwrotnica (0x08) + for (;k>0;--k,i=(i+1)%iSpeedTableSize) + sSpeedTable[i]=sSpeedTable[(i+1)%iSpeedTableSize]; //skopiowanie + //WriteLog("Odtykacz usuwa pozycję"); + iLast=(iLast-1+iSpeedTableSize)%iSpeedTableSize; //cofnięcie z zawinięciem + return; + } + } + //jeśli powyższe odtykane nie pomoże, można usunąć coś więcej, albo powiększyć tabelkę + TSpeedPos *t=new TSpeedPos[iSpeedTableSize+16]; //zwiększenie + k=iLast-iFirst+1; //tym razem wszystkie + if (k<0) k+=iSpeedTableSize; //ilość pozycji do przeanalizowania + for (j=-1,i=iFirst;k>0;--k) + {//przepisywanie rekordów iFirst..iLast na 0..k + t[++j]=sSpeedTable[i]; + i=(i+1)%iSpeedTableSize; //kolejna pozycja mogą być zawinięta + } + iFirst=0; //teraz będzie od zera + iLast=j; //ostatnia + delete[] sSpeedTable; //to już nie potrzebne + sSpeedTable=t; //bo jest nowe + iSpeedTableSize+=16; + //WriteLog("Tabelka powiększona do "+AnsiString(iSpeedTableSize)+" pozycji"); +}; +//--------------------------------------------------------------------------- +//--------------------------------------------------------------------------- +//--------------------------------------------------------------------------- + +__fastcall TController::TController +(bool AI, + TDynamicObject *NewControll, + bool InitPsyche, + bool primary //czy ma aktywnie prowadzić? +) +{ + iEngineActive=0; + LastUpdatedTime=0.0; + ElapsedTime=0.0; + //inicjalizacja zmiennych + Psyche=InitPsyche; + VelDesired=0.0; //prędkosć początkowa + VelforDriver=-1; + LastReactionTime=0.0; + HelpMeFlag=false; + //fProximityDist=1; //nie używane + ActualProximityDist=1; + vCommandLocation.x=0; + vCommandLocation.y=0; + vCommandLocation.z=0; + VelSignal=0.0; //normalnie na początku ma stać, no chyba że jedzie + VelLimit=-1.0; //brak ograniczenia prędkości + VelNext=120.0; + AIControllFlag=AI; + pVehicle=NewControll; + ControllingSet(); //utworzenie połączenia do sterowanego pojazdu + pVehicles[0]=pVehicle->GetFirstDynamic(0); //pierwszy w kierunku jazdy (Np. Pc1) + pVehicles[1]=pVehicle->GetFirstDynamic(1); //ostatni w kierunku jazdy (końcówki) +/* + switch (mvOccupied->CabNo) + { + case -1: SendCtrlBroadcast("CabActivisation",1); break; + case 1: SendCtrlBroadcast("CabActivisation",2); break; + default: AIControllFlag:=False; //na wszelki wypadek + } +*/ + iDirection=0; + iDirectionOrder=mvOccupied->CabNo; //1=do przodu (w kierunku sprzęgu 0) + VehicleName=mvOccupied->Name; + //TrainParams=NewTrainParams; + //if (TrainParams) + // asNextStop=TrainParams->NextStop(); + //else + TrainParams=new TTrainParameters("none"); //rozkład jazdy + //OrderCommand=""; + //OrderValue=0; + OrdersClear(); + MaxVelFlag=false; MinVelFlag=false; //Ra: to nie jest używane + iDriverFailCount=0; + Need_TryAgain=false; //true, jeśli druga pozycja w elektryku nie załapała + Need_BrakeRelease=true; + deltalog=0.05;//1.0; + + if (WriteLogFlag) + { + mkdir("physicslog\\"); + LogFile.open(AnsiString("physicslog\\"+VehicleName+".dat").c_str(),std::ios::in | std::ios::out | std::ios::trunc); +#if LOGPRESS==0 + LogFile << AnsiString(" Time [s] Velocity [m/s] Acceleration [m/ss] Coupler.Dist[m] Coupler.Force[N] TractionForce [kN] FrictionForce [kN] BrakeForce [kN] BrakePress [MPa] PipePress [MPa] MotorCurrent [A] MCP SCP BCP LBP DmgFlag Command CVal1 CVal2").c_str() << "\r\n"; +#endif +#if LOGPRESS==1 + LogFile << AnsiString("t\tVel\tAcc\tPP\tVVP\tBP\tBVP\tCVP").c_str() << "\n"; +#endif + LogFile.flush(); + } +/* + if (WriteLogFlag) + { + assignfile(AILogFile,VehicleName+".txt"); + rewrite(AILogFile); + writeln(AILogFile,"AI driver log: started OK"); + close(AILogFile); + } +*/ + + //VelMargin=2; //Controlling->Vmax*0.015; + fWarningDuration=0.0; //nic do wytrąbienia + WaitingExpireTime=31.0; //tyle ma czekać, zanim się ruszy + WaitingTime=0.0; + fMinProximityDist=30.0; //stawanie między 30 a 60 m przed przeszkodą + fMaxProximityDist=50.0; + iVehicleCount=-2; //wartość neutralna + //Prepare2press=false; //bez dociskania + eStopReason=stopSleep; //na początku śpi + fLength=0.0; + fMass=0.0; //[kg] + eSignNext=NULL; //sygnał zmieniający prędkość, do pokazania na [F2] + fShuntVelocity=40; //domyślna prędkość manewrowa + fStopTime=0.0; //czas postoju przed dalszą jazdą (np. na przystanku) + iDrivigFlags=moveStopPoint; //podjedź do W4 możliwie blisko + iDrivigFlags|=moveStopHere; //nie podjeżdżaj do semafora, jeśli droga nie jest wolna + iDrivigFlags|=moveStartHorn; //podaj sygnał po podaniu wolnej drogi + if (primary) + iDrivigFlags|=movePrimary; //aktywnie prowadzące pojazd + Ready=false; + if (mvOccupied->CategoryFlag&2) + {//samochody: na podst. http://www.prawko-kwartnik.info/hamowanie.html + //fDriverBraking=0.0065; //mnożone przez (v^2+40*v) [km/h] daje prawie drogę hamowania [m] + fDriverBraking=0.03; //coś nie hamują te samochody zbyt dobrze + fDriverDist=5.0; //5m - zachowywany odstęp przed kolizją + fVelPlus=10.0; //dopuszczalne przekroczenie prędkości na ograniczeniu bez hamowania + fVelMinus=2.0; //margines prędkości powodujący załączenie napędu + } + else + {//pociągi i statki + fDriverBraking=0.06; //mnożone przez (v^2+40*v) [km/h] daje prawie drogę hamowania [m] + fDriverDist=50.0; //50m - zachowywany odstęp przed kolizją + fVelPlus=5.0; //dopuszczalne przekroczenie prędkości na ograniczeniu bez hamowania + fVelMinus=5.0; //margines prędkości powodujący załączenie napędu + } + SetDriverPsyche(); //na końcu, bo wymaga ustawienia zmiennych + AccDesired=AccPreferred; + fVelMax=-1; //ustalenie prędkości dla składu + fBrakeTime=0.0; //po jakim czasie przekręcić hamulec + iVehicles=0; //na wszelki wypadek + iSpeedTableSize=16; + sSpeedTable=new TSpeedPos[iSpeedTableSize]; + TableClear(); + iRadioChannel=1; //numer aktualnego kanału radiowego + fActionTime=0.0; + eAction=actSleep; + tsGuardSignal=NULL; //komunikat od kierownika + iGuardRadio=0; //nie przez radio + iStationStart=0; //nic? + //fAccThreshold może podlegać uczeniu się - hamowanie powinno być rejestrowane, a potem analizowane + fAccThreshold=(mvOccupied->TrainType&dt_EZT)?-0.6:-0.2; //próg opóźnienia dla zadziałania hamulca + fLastStopExpDist=-1.0f; + iRouteWanted=3; //powiedzmy, że ma jechać prosto (1=w lewo) + iCoupler=0; //sprzęg; niezerowy gdy ma być podłączanie; samo podłączanie w trybie Connect (wcześniej może być np. Prepare_engine) + fOverhead1=3000.0; //informacja o napięciu w sieci trakcyjnej (0=brak drutu, zatrzymaj!) + fOverhead2=-1.0; //informacja o sposobie jazdy (-1=normalnie, 0=bez prądu, >0=z opuszczonym i ograniczeniem prędkości) + iOverheadZero=0; //suma bitowa jezdy bezprądowej, bity ustawiane przez pojazdy z podniesionymi pantografami + iOverheadDown=0; //suma bitowa opuszczenia pantografów, bity ustawiane przez pojazdy z podniesionymi pantografami + fAccDesiredAv=0.0; //uśrednione przyspieszenie z kolejnych przebłysków świadomości, żeby ograniczyć migotanie + fVoltage=0.0; //uśrednione napięcie sieci: przy spadku poniżej wartości minimalnej opóźnić rozruch o losowy czas +}; + +void __fastcall TController::CloseLog() +{ + if (WriteLogFlag) + { + LogFile.close(); + //if WriteLogFlag) + // CloseFile(AILogFile); +/* append(AIlogFile); + writeln(AILogFile,ElapsedTime5:2,": QUIT"); + close(AILogFile); */ + } +}; + +__fastcall TController::~TController() +{//wykopanie mechanika z roboty + delete tsGuardSignal; + delete TrainParams; + delete[] sSpeedTable; + CloseLog(); +}; + +AnsiString __fastcall TController::Order2Str(TOrders Order) +{//zamiana kodu rozkazu na opis + if (Order&Change_direction) return "Change_direction"; //może być nałożona na inną i wtedy ma priorytet + if (Order==Wait_for_orders) return "Wait_for_orders"; + if (Order==Prepare_engine) return "Prepare_engine"; + if (Order==Shunt) return "Shunt"; + if (Order==Connect) return "Connect"; + if (Order==Disconnect) return "Disconnect"; + if (Order==Obey_train) return "Obey_train"; + if (Order==Release_engine) return "Release_engine"; + if (Order==Jump_to_first_order) return "Jump_to_first_order"; +/* Ra: wersja ze switch nie działa prawidłowo (czemu?) + switch (Order) + { + Wait_for_orders: return "Wait_for_orders"; + Prepare_engine: return "Prepare_engine"; + Shunt: return "Shunt"; + Change_direction: return "Change_direction"; + Obey_train: return "Obey_train"; + Release_engine: return "Release_engine"; + Jump_to_first_order: return "Jump_to_first_order"; + } +*/ + return "Undefined!"; +} + +AnsiString __fastcall TController::OrderCurrent() +{//pobranie aktualnego rozkazu celem wyświetlenia + return AnsiString(OrderPos)+". "+Order2Str(OrderList[OrderPos]); +}; + +void __fastcall TController::OrdersClear() +{//czyszczenie tabeli rozkazów na starcie albo po dojściu do końca + OrderPos=0; + OrderTop=1; //szczyt stosu rozkazów + for (int b=0;b OrdersClear"); +#endif +}; + +void __fastcall TController::Activation() +{//umieszczenie obsady w odpowiednim członie, wykonywane wyłącznie gdy steruje AI + iDirection=iDirectionOrder; //kierunek (względem sprzęgów pojazdu z AI) właśnie został ustalony (zmieniony) + if (iDirection) + {//jeśli jest ustalony kierunek + TDynamicObject *old=pVehicle,*d=pVehicle; //w tym siedzi AI + TController *drugi; //jakby były dwa, to zamienić miejscami, a nie robić wycieku pamięci poprzez nadpisanie + int brake=mvOccupied->LocalBrakePos; + while (mvControlling->MainCtrlPos) //samo zapętlenie DecSpeed() nie wystarcza :/ + DecSpeed(true); //wymuszenie zerowania nastawnika jazdy + while (mvOccupied->ActiveDir<0) mvOccupied->DirectionForward(); //kierunek na 0 + while (mvOccupied->ActiveDir>0) mvOccupied->DirectionBackward(); + if (TestFlag(d->MoverParameters->Couplers[iDirectionOrder<0?1:0].CouplingFlag,ctrain_controll)) + {mvControlling->MainSwitch(false); //dezaktywacja czuwaka, jeśli przejście do innego członu + mvOccupied->DecLocalBrakeLevel(10); //zwolnienie hamulca w opuszczanym pojeździe +// mvOccupied->BrakeLevelSet((mvOccupied->BrakeHandle==FVel6)?4:-2); //odcięcie na zaworze maszynisty, FVel6 po drugiej stronie nie luzuje + mvOccupied->BrakeLevelSet(mvOccupied->Handle->GetPos(bh_NP)); //odcięcie na zaworze maszynisty + } + mvOccupied->ActiveCab=mvOccupied->CabNo; //użytkownik moze zmienić ActiveCab wychodząc + mvOccupied->CabDeactivisation(); //tak jest w Train.cpp + //przejście AI na drugą stronę EN57, ET41 itp. + while (TestFlag(d->MoverParameters->Couplers[iDirection<0?1:0].CouplingFlag,ctrain_controll)) + {//jeśli pojazd z przodu jest ukrotniony, to przechodzimy do niego + d=iDirection*d->DirectionGet()<0?d->Next():d->Prev(); //przechodzimy do następnego członu + if (d) + {drugi=d->Mechanik; //zapamiętanie tego, co ewentualnie tam siedzi, żeby w razie dwóch zamienić miejscami + d->Mechanik=this; //na razie bilokacja + d->MoverParameters->SetInternalCommand("",0,0); //usunięcie ewentualnie zalegającej komendy (Change_direction?) + if (d->DirectionGet()!=pVehicle->DirectionGet()) //jeśli są przeciwne do siebie + iDirection=-iDirection; //to będziemy jechać w drugą stronę względem zasiedzianego pojazdu + pVehicle->Mechanik=drugi; //wsadzamy tego, co ewentualnie był (podwójna trakcja) + pVehicle->MoverParameters->CabNo=0; //wyłączanie kabin po drodze + pVehicle->MoverParameters->ActiveCab=0; //i zaznaczenie, że nie ma tam nikogo + pVehicle=d; //a mechu ma nowy pojazd (no, człon) + } + else break; //jak koniec składu, to mechanik dalej nie idzie + } + if (pVehicle!=old) + {//jeśli zmieniony został pojazd prowadzony + Global::pWorld->CabChange(old,pVehicle); //ewentualna zmiana kabiny użytkownikowi + ControllingSet(); //utworzenie połączenia do sterowanego pojazdu (może się zmienić) - silnikowy dla EZT + } + if (mvControlling->EngineType==DieselEngine) //dla 2Ls150 - przed ustawieniem kierunku - można zmienić tryb pracy + if (mvControlling->ShuntModeAllow) + mvControlling->CurrentSwitch((OrderList[OrderPos]&Shunt)||(fMass>224000.0)); //do tego na wzniesieniu może nie dać rady na liniowym + //Ra: to przełączanie poniżej jest tu bez sensu + mvOccupied->ActiveCab=iDirection; //aktywacja kabiny w prowadzonym pojeżdzie (silnikowy może być odwrotnie?) + //mvOccupied->CabNo=iDirection; + //mvOccupied->ActiveDir=0; //żeby sam ustawił kierunek + mvOccupied->CabActivisation(); //uruchomienie kabin w członach + DirectionForward(true); //nawrotnik do przodu + if (brake) //hamowanie tylko jeśli był wcześniej zahamowany (bo możliwe, że jedzie!) + mvOccupied->IncLocalBrakeLevel(brake); //zahamuj jak wcześniej + CheckVehicles(); //sprawdzenie składu, AI zapali światła + TableClear(); //resetowanie tabelki skanowania torów + } +}; + +void __fastcall TController::AutoRewident() +{//autorewident: nastawianie hamulców w składzie + int r=0,g=0,p=0; //ilości wagonów poszczególnych typów + TDynamicObject* d=pVehicles[0]; //pojazd na czele składu + //1. Zebranie informacji o składzie pociągu — przejście wzdłuż składu i odczyt parametrów: + // · ilość wagonów -> są zliczane, wszystkich pojazdów jest (iVehicles) + // · długość (jako suma) -> jest w (fLength) + // · masa (jako suma) -> jest w (fMass) + while (d) + {//klasyfikacja pojazdów wg BrakeDelays i mocy (licznik) + if (d->MoverParameters->Power<1) // - lokomotywa - Power>1 - ale może być nieczynna na końcu... + if (TestFlag(d->MoverParameters->BrakeDelays,bdelay_R)) + ++r; // - wagon pospieszny - jest R + else if (TestFlag(d->MoverParameters->BrakeDelays,bdelay_G)) + ++g; // - wagon towarowy - jest G (nie ma R) + else + ++p; // - wagon osobowy - reszta (bez G i bez R) + d=d->Next(); //kolejny pojazd, podłączony od tyłu (licząc od czoła) + } + //2. Określenie typu pociągu i nastawy: + int ustaw; //+16 dla pasażerskiego + if (r+g+p==0) + ustaw=16+bdelay_R; //lokomotywa luzem (może być wieloczłonowa) + else + {//jeśli są wagony + ustaw=(g0 oraz pospiesze<=towarowe+osobowe to P (0) + //inaczej R (2) + } + else + {//inaczej towarowy - nastawianie towarowego + if ((fLength<300.0)&&(fMass<600000.0)) //[kg] + ustaw|=bdelay_P; //jeżeli długość<300 oraz masa<600 to P (0) + else if ((fLength<500.0)&&(fMass<1300000.0)) + ustaw|=bdelay_R; //jeżeli długość<500 oraz masa<1300 to GP (2) + else + ustaw|=bdelay_G; //inaczej G (1) + } + //zasadniczo na sieci PKP kilka lat temu na P/GP jeździły tylko kontenerowce o + //rozkładowej 90 km/h. Pozostałe jeździły 70 km/h i były nastawione na G. + } + d=pVehicles[0]; //pojazd na czele składu + p=0; //będziemy tu liczyć wagony od lokomotywy dla nastawy GP + while (d) + {//3. Nastawianie + switch (ustaw) + { + case bdelay_P: //towarowy P - lokomotywa na G, reszta na P. + d->MoverParameters->BrakeDelaySwitch(d->MoverParameters->Power>1?bdelay_G:bdelay_P); + break; + case bdelay_G: //towarowy G - wszystko na G, jeśli nie ma to P (powinno się wyłączyć hamulec) + d->MoverParameters->BrakeDelaySwitch(TestFlag(d->MoverParameters->BrakeDelays,bdelay_G)?bdelay_G:bdelay_P); + break; + case bdelay_R: //towarowy GP - lokomotywa oraz 5 pierwszych pojazdów przy niej na G, reszta na P + if (d->MoverParameters->Power>1) + {d->MoverParameters->BrakeDelaySwitch(bdelay_G); + p=0; //a jak będzie druga w środku? + } + else + d->MoverParameters->BrakeDelaySwitch(++p<=5?bdelay_G:bdelay_P); + break; + case 16+bdelay_R: //pasażerski R - na R, jeśli nie ma to P + d->MoverParameters->BrakeDelaySwitch(TestFlag(d->MoverParameters->BrakeDelays,bdelay_R)?bdelay_R:bdelay_P); + break; + case 16+bdelay_P: //pasażerski P - wszystko na P + d->MoverParameters->BrakeDelaySwitch(bdelay_P); + break; + } + d=d->Next(); //kolejny pojazd, podłączony od tyłu (licząc od czoła) + } +}; + +bool __fastcall TController::CheckVehicles(TOrders user) +{//sprawdzenie stanu posiadanych pojazdów w składzie i zapalenie świateł + TDynamicObject* p; //roboczy wskaźnik na pojazd + iVehicles=0; //ilość pojazdów w składzie + int d=mvOccupied->DirAbsolute; //który sprzęg jest z przodu + if (!d) //jeśli nie ma ustalonego kierunku + d=mvOccupied->CabNo; //to jedziemy wg aktualnej kabiny + iDirection=d; //ustalenie kierunku jazdy (powinno zrobić PrepareEngine?) + d=d>=0?0:1; //kierunek szukania czoła (numer sprzęgu) + pVehicles[0]=p=pVehicle->FirstFind(d); //pojazd na czele składu + //liczenie pojazdów w składzie i ustalenie parametrów + int dir=d=1-d; //a dalej będziemy zliczać od czoła do tyłu + fLength=0.0; //długość składu do badania wyjechania za ograniczenie + fMass=0.0; //całkowita masa do liczenia stycznej składowej grawitacji + fVelMax=-1; //ustalenie prędkości dla składu + bool main=true; //czy jest głównym sterującym + iDrivigFlags|=moveOerlikons; //zakładamy, że są same Oerlikony + //Ra 2014-09: ustawić moveMultiControl, jeśli wszystkie są w ukrotnieniu (i skrajne mają kabinę?) + while (p) + {//sprawdzanie, czy jest głównym sterującym, żeby nie było konfliktu + if (p->Mechanik) //jeśli ma obsadę + if (p->Mechanik!=this) //ale chodzi o inny pojazd, niż aktualnie sprawdzający + if (p->Mechanik->iDrivigFlags&movePrimary) //a tamten ma priorytet + if ((iDrivigFlags&movePrimary)&&(mvOccupied->DirAbsolute)&&(mvOccupied->BrakeCtrlPos>=-1)) //jeśli rządzi i ma kierunek + p->Mechanik->iDrivigFlags&=~movePrimary; //dezaktywuje tamtego + else + main=false; //nici z rządzenia + ++iVehicles; //jest jeden pojazd więcej + pVehicles[1]=p; //zapamiętanie ostatniego + fLength+=p->MoverParameters->Dim.L; //dodanie długości pojazdu + fMass+=p->MoverParameters->TotalMass; //dodanie masy łącznie z ładunkiem + if (fVelMax<0?true:p->MoverParameters->VmaxMoverParameters->Vmax; //ustalenie maksymalnej prędkości dla składu +/* //youBy: bez przesady, to jest proteza, napelniac mozna, a nawet trzeba, ale z umiarem! + //uwzględnić jeszcze wyłączenie hamulca + if ((p->MoverParameters->BrakeSystem!=Pneumatic)&&(p->MoverParameters->BrakeSystem!=ElectroPneumatic)) + iDrivigFlags&=~moveOerlikons; //no jednak nie + else if (p->MoverParameters->BrakeSubsystem!=Oerlikon) + iDrivigFlags&=~moveOerlikons; //wtedy też nie */ + p=p->Neightbour(dir); //pojazd podłączony od wskazanej strony + } + if (main) iDrivigFlags|=movePrimary; //nie znaleziono innego, można się porządzić +/* //tabelka z listą pojazdów jest na razie nie potrzebna + delete[] pVehicles; + pVehicles=new TDynamicObject*[iVehicles]; +*/ + ControllingSet(); //ustalenie członu do sterowania (może być inny niż zasiedziany) + int pantmask=1; + if (iDrivigFlags&movePrimary) + {//jeśli jest aktywnie prowadzącym pojazd, może zrobić własny porządek + p=pVehicles[0]; + while (p) + { + if (TrainParams) + if (p->asDestination=="none") + p->DestinationSet(TrainParams->Relation2); //relacja docelowa, jeśli nie było + if (AIControllFlag) //jeśli prowadzi komputer + p->RaLightsSet(0,0); //gasimy światła + if (p->MoverParameters->EnginePowerSource.SourceType==CurrentCollector) + {//jeśli pojazd posiada pantograf, to przydzielamy mu maskę, którą będzie informował o jeździe bezprądowej + p->iOverheadMask=pantmask; + pantmask<<1; //przesunięcie bitów, max. 32 pojazdy z pantografami w składzie + } + d=p->DirectionSet(d?1:-1); //zwraca położenie następnego (1=zgodny,0=odwrócony - względem czoła składu) + p->fScanDist=300.0; //odległość skanowania w poszukiwaniu innych pojazdów + p->ctOwner=this; //dominator oznacza swoje terytorium + p=p->Next(); //pojazd podłączony od tyłu (licząc od czoła) + } + if (AIControllFlag) + {//jeśli prowadzi komputer + if (OrderCurrentGet()==Obey_train) //jeśli jazda pociągowa + {Lights(1+4+16,2+32+64); //światła pociągowe (Pc1) i końcówki (Pc5) +#if LOGPRESS==0 + AutoRewident(); //nastawianie hamulca do jazdy pociągowej +#endif + } + else if (OrderCurrentGet()&(Shunt|Connect)) + {Lights(16,(pVehicles[1]->MoverParameters->CabNo)?1:0); //światła manewrowe (Tb1) na pojeździe z napędem + if (OrderCurrentGet()&Connect) //jeśli łączenie, skanować dalej + pVehicles[0]->fScanDist=5000.0; //odległość skanowania w poszukiwaniu innych pojazdów + } + else if (OrderCurrentGet()==Disconnect) + if (mvOccupied->ActiveDir>0) //jak ma kierunek do przodu + Lights(16,0); //światła manewrowe (Tb1) tylko z przodu, aby nie pozostawić odczepionego ze światłem + else //jak dociska + Lights(0,16); //światła manewrowe (Tb1) tylko z przodu, aby nie pozostawić odczepionego ze światłem + } + else //Ra 2014-02: lepiej tu niż w pętli obsługującej komendy, bo tam się zmieni informacja o składzie + switch (user) //gdy człowiek i gdy nastąpiło połącznie albo rozłączenie + { + case Change_direction: + while (OrderCurrentGet()&(Change_direction)) + JumpToNextOrder(); //zmianę kierunku też można olać, ale zmienić kierunek skanowania! + break; + case Connect: + while (OrderCurrentGet()&(Change_direction)) + JumpToNextOrder(); //zmianę kierunku też można olać, ale zmienić kierunek skanowania! + if (OrderCurrentGet()&(Connect)) + {//jeśli miało być łączenie, zakładamy, że jest dobrze (sprawdzić?) + iCoupler=0; //koniec z doczepianiem + iDrivigFlags&=~moveConnect; //zdjęcie flagi doczepiania + JumpToNextOrder(); //wykonanie następnej komendy + if (OrderCurrentGet()&(Change_direction)) + JumpToNextOrder(); //zmianę kierunku też można olać, ale zmienić kierunek skanowania! + } + break; + case Disconnect: + while (OrderCurrentGet()&(Change_direction)) + JumpToNextOrder(); //zmianę kierunku też można olać, ale zmienić kierunek skanowania! + if (OrderCurrentGet()&(Disconnect)) + {//wypadało by sprawdzić, czy odczepiono wagony w odpowiednim miejscu (iVehicleCount) + JumpToNextOrder(); //wykonanie następnej komendy + if (OrderCurrentGet()&(Change_direction)) + JumpToNextOrder(); //zmianę kierunku też można olać, ale zmienić kierunek skanowania! + } + } + //Ra 2014-09: tymczasowo prymitywne ustawienie warunku pod kątem SN61 + if ((mvOccupied->TrainType==dt_EZT)||(iVehicles==1)) + iDrivigFlags|=movePushPull; //zmiana czoła przez zmianę kabiny + else + iDrivigFlags&=~movePushPull; //zmiana czoła przez manewry + } //blok wykonywany, gdy aktywnie prowadzi + return true; +} + +void __fastcall TController::Lights(int head,int rear) +{//zapalenie świateł w skłądzie + pVehicles[0]->RaLightsSet(head,-1); //zapalenie przednich w pierwszym + pVehicles[1]->RaLightsSet(-1,rear); //zapalenie końcówek w ostatnim +} + +void __fastcall TController::DirectionInitial() +{//ustawienie kierunku po wczytaniu trainset (może jechać na wstecznym + mvOccupied->CabActivisation(); //załączenie rozrządu (wirtualne kabiny) + if (mvOccupied->Vel>0.0) + {//jeśli na starcie jedzie + iDirection=iDirectionOrder=(mvOccupied->V>0?1:-1); //początkowa prędkość wymusza kierunek jazdy + DirectionForward(mvOccupied->V*mvOccupied->CabNo>=0.0); //a dalej ustawienie nawrotnika + } + CheckVehicles(); //sprawdzenie świateł oraz skrajnych pojazdów do skanowania +}; + +int __fastcall TController::OrderDirectionChange(int newdir,TMoverParameters *Vehicle) +{//zmiana kierunku jazdy, niezależnie od kabiny + int testd=newdir; + if (Vehicle->Vel<0.5) + {//jeśli prawie stoi, można zmienić kierunek, musi być wykonane dwukrotnie, bo za pierwszym razem daje na zero + switch (newdir*Vehicle->CabNo) + {//DirectionBackward() i DirectionForward() to zmiany względem kabiny + case -1: //if (!Vehicle->DirectionBackward()) testd=0; break; + DirectionForward(false); break; + case 1: //if (!Vehicle->DirectionForward()) testd=0; break; + DirectionForward(true); break; + } + if (testd==0) + VelforDriver=-1; //kierunek został zmieniony na żądany, można jechać + } + else //jeśli jedzie + VelforDriver=0; //ma się zatrzymać w celu zmiany kierunku + if ((Vehicle->ActiveDir==0)&&(VelforDriverVel)) //Ra: to jest chyba bez sensu + IncBrake(); //niech hamuje + if (Vehicle->ActiveDir==testd*Vehicle->CabNo) + VelforDriver=-1; //można jechać, bo kierunek jest zgodny z żądanym + if (Vehicle->TrainType==dt_EZT) + if (Vehicle->ActiveDir>0) + //if () //tylko jeśli jazda pociągowa (tego nie wiemy w momencie odpalania silnika) + Vehicle->DirectionForward(); //Ra: z przekazaniem do silnikowego + return (int)VelforDriver; //zwraca prędkość mechanika +} + +void __fastcall TController::WaitingSet(double Seconds) +{//ustawienie odczekania po zatrzymaniu (ustawienie w trakcie jazdy zatrzyma) + fStopTime=-Seconds; //ujemna wartość oznacza oczekiwanie (potem >=0.0) +} + +void __fastcall TController::SetVelocity(double NewVel,double NewVelNext,TStopReason r) +{//ustawienie nowej prędkości + WaitingTime=-WaitingExpireTime; //przypisujemy -WaitingExpireTime, a potem porównujemy z zerem + MaxVelFlag=False; //Ra: to nie jest używane + MinVelFlag=False; //Ra: to nie jest używane +/* nie używane + if ((NewVel>NewVelNext) //jeśli oczekiwana większa niż następna + || (NewVelVel)) //albo aktualna jest mniejsza niż aktualna + fProximityDist=-800.0; //droga hamowania do zmiany prędkości + else + fProximityDist=-300.0; //Ra: ujemne wartości są ignorowane +*/ + if (NewVel==0.0) //jeśli ma stanąć + {if (r!=stopNone) //a jest powód podany + eStopReason=r; //to zapamiętać nowy powód + } + else + { + eStopReason=stopNone; //podana prędkość, to nie ma powodów do stania + //to całe poniżej to warunki zatrąbienia przed ruszeniem + if (OrderList[OrderPos]?OrderList[OrderPos]&(Obey_train|Shunt|Connect|Prepare_engine):true) //jeśli jedzie w dowolnym trybie + if ((mvOccupied->Vel<1.0)) //jesli stoi (na razie, bo chyba powinien też, gdy hamuje przed semaforem) + if (iDrivigFlags&moveStartHorn) //jezeli trąbienie włączone + if (!(iDrivigFlags&(moveStartHornDone|moveConnect))) //jeśli nie zatrąbione i nie jest to moment podłączania składu + if (mvOccupied->CategoryFlag&1) //tylko pociągi trąbią (unimogi tylko na torach, więc trzeba raczej sprawdzać tor) + if ((NewVel>=1.0)||(NewVel<0.0)) //o ile prędkość jest znacząca + {//fWarningDuration=0.3; //czas trąbienia + //if (AIControllFlag) //jak siedzi krasnoludek, to włączy trąbienie + // mvOccupied->WarningSignal=pVehicle->iHornWarning; //wysokość tonu (2=wysoki) + //iDrivigFlags|=moveStartHornDone; //nie trąbić aż do ruszenia + iDrivigFlags|=moveStartHornNow; //zatrąb po odhamowaniu + } + } + VelSignal=NewVel; //prędkość zezwolona na aktualnym odcinku + VelNext=NewVelNext; //prędkość przy następnym obiekcie +} + +/* //funkcja do niczego nie potrzebna (ew. do przesunięcia pojazdu o odległość NewDist) +bool __fastcall TController::SetProximityVelocity(double NewDist,double NewVelNext) +{//informacja o prędkości w pewnej odległości +#if 0 + if (NewVelNext==0.0) + WaitingTime=0.0; //nie trzeba już czekać + //if ((NewVelNext>=0)&&((VelNext>=0)&&(NewVelNextCategoryFlag&2) + {WaitingExpireTime=1; //tyle ma czekać samochód, zanim się ruszy + AccPreferred=3.0; //[m/ss] agresywny + } + else + {WaitingExpireTime=61; //tyle ma czekać, zanim się ruszy + AccPreferred=HardAcceleration; //agresywny + } + } + else + { + ReactionTime=EasyReactionTime; //spokojny + if (mvOccupied->CategoryFlag&2) + {WaitingExpireTime=3; //tyle ma czekać samochód, zanim się ruszy + AccPreferred=2.0; //[m/ss] + } + else + {WaitingExpireTime=65; //tyle ma czekać, zanim się ruszy + AccPreferred=EasyAcceleration; + } + } + if (mvControlling&&mvOccupied) + {//with Controlling do + if (mvControlling->MainCtrlPos<3) + ReactionTime=mvControlling->InitialCtrlDelay+ReactionTime; + if (mvOccupied->BrakeCtrlPos>1) + ReactionTime=0.5*ReactionTime; +/* + if (mvOccupied->Vel>0.1) //o ile jedziemy + {//sprawdzenie jazdy na widoczność + TCoupling *c=pVehicles[0]->MoverParameters->Couplers+(pVehicles[0]->DirectionGet()>0?0:1); //sprzęg z przodu składu + if (c->Connected) //a mamy coś z przodu + if (c->CouplingFlag==0) //jeśli to coś jest podłączone sprzęgiem wirtualnym + {//wyliczanie optymalnego przyspieszenia do jazdy na widoczność (Ra: na pewno tutaj?) + double k=c->Connected->Vel; //prędkość pojazdu z przodu (zakładając, że jedzie w tę samą stronę!!!) + if (k<=mvOccupied->Vel) //porównanie modułów prędkości [km/h] + {if (pVehicles[0]->fTrackBlockfTrackBlock-0.5*fabs(mvOccupied->V)-fMaxProximityDist); //bezpieczna odległość za poprzednim + //a=(v2*v2-v1*v1)/(25.92*(d-0.5*v1)) + //(v2*v2-v1*v1)/2 to różnica energii kinetycznych na jednostkę masy + //jeśli v2=50km/h,v1=60km/h,d=200m => k=(192.9-277.8)/(25.92*(200-0.5*16.7)=-0.0171 [m/s^2] + //jeśli v2=50km/h,v1=60km/h,d=100m => k=(192.9-277.8)/(25.92*(100-0.5*16.7)=-0.0357 [m/s^2] + //jeśli v2=50km/h,v1=60km/h,d=50m => k=(192.9-277.8)/(25.92*( 50-0.5*16.7)=-0.0786 [m/s^2] + //jeśli v2=50km/h,v1=60km/h,d=25m => k=(192.9-277.8)/(25.92*( 25-0.5*16.7)=-0.1967 [m/s^2] + if (d>0) //bo jak ujemne, to zacznie przyspieszać, aby się zderzyć + k=(k*k-mvOccupied->Vel*mvOccupied->Vel)/(25.92*d); //energia kinetyczna dzielona przez masę i drogę daje przyspieszenie + else + k=0.0; //może lepiej nie przyspieszać -AccPreferred; //hamowanie + //WriteLog(pVehicle->asName+" "+AnsiString(k)); + } + if (dEnginePowerSource.SourceType==CurrentCollector)/*||(mvOccupied->TrainType==dt_EZT)*/)) + { + if (mvControlling->GetTrainsetVoltage()) //sprawdzanie, czy zasilanie jest może w innym członie + { + voltfront=true; + voltrear=true; + } + } +// begin +// if Couplers[0].Connected<>nil) +// begin +// if Couplers[0].Connected^.PantFrontVolt or Couplers[0].Connected^.PantRearVolt) +// voltfront:=true +// else +// voltfront:=false; +// end +// else +// voltfront:=false; +// if Couplers[1].Connected<>nil) +// begin +// if Couplers[1].Connected^.PantFrontVolt or Couplers[1].Connected^.PantRearVolt) +// voltrear:=true +// else +// voltrear:=false; +// end +// else +// voltrear:=false; +// end + else + //if EnginePowerSource.SourceType<>CurrentCollector) + if (mvOccupied->TrainType!=dt_EZT) + voltfront=true; //Ra 2014-06: to jest wirtualny prąd dla spalinowych??? + if (AIControllFlag) //jeśli prowadzi komputer + {//część wykonawcza dla sterowania przez komputer + mvOccupied->BatterySwitch(true); + if (mvControlling->EnginePowerSource.SourceType==CurrentCollector) + {//jeśli silnikowy jest pantografującym + if (mvControlling->PantPress>4.3) + {//jeżeli jest wystarczające ciśnienie w pantografach + if ((!mvControlling->bPantKurek3)||(mvControlling->PantPress<=mvControlling->ScndPipePress)) //kurek przełączony albo główna już pompuje + mvControlling->PantCompFlag=false; //sprężarkę pantografów można już wyłączyć + mvControlling->PantFront(true); + mvControlling->PantRear(true); + } + else if (mvControlling->PantPress<4.2) //żeby nie załączał zaraz po przekroczeniu 4.0 + {//załączenie małej sprężarki + mvControlling->bPantKurek3=false; //odłączenie zbiornika głównego, bo z nim nie da rady napompować + mvControlling->PantCompFlag=true; //załączenie sprężarki pantografów + } + } + //if (mvOccupied->TrainType==dt_EZT) + //{//Ra 2014-12: po co to tutaj? + // mvControlling->PantFront(true); + // mvControlling->PantRear(true); + //} + //if (mvControlling->EngineType==DieselElectric) + // mvControlling->Battery=true; //Ra: to musi być tak? + } + if (mvControlling->PantFrontVolt||mvControlling->PantRearVolt||voltfront||voltrear) + {//najpierw ustalamy kierunek, jeśli nie został ustalony + if (!iDirection) //jeśli nie ma ustalonego kierunku + if (mvOccupied->V==0) + {//ustalenie kierunku, gdy stoi + iDirection=mvOccupied->CabNo; //wg wybranej kabiny + if (!iDirection) //jeśli nie ma ustalonego kierunku + if ((mvControlling->PantFrontVolt!=0.0)||(mvControlling->PantRearVolt!=0.0)||voltfront||voltrear) + {if (mvOccupied->Couplers[1].CouplingFlag==ctrain_virtual) //jeśli z tyłu nie ma nic + iDirection=-1; //jazda w kierunku sprzęgu 1 + if (mvOccupied->Couplers[0].CouplingFlag==ctrain_virtual) //jeśli z przodu nie ma nic + iDirection=1; //jazda w kierunku sprzęgu 0 + } + } + else //ustalenie kierunku, gdy jedzie + if ((mvControlling->PantFrontVolt!=0.0)||(mvControlling->PantRearVolt!=0.0)||voltfront||voltrear) + if (mvOccupied->V<0) //jedzie do tyłu + iDirection=-1; //jazda w kierunku sprzęgu 1 + else //jak nie do tyłu, to do przodu + iDirection=1; //jazda w kierunku sprzęgu 0 + if (AIControllFlag) //jeśli prowadzi komputer + {//część wykonawcza dla sterowania przez komputer + if (mvControlling->ConvOvldFlag) + {//wywalił bezpiecznik nadmiarowy przetwornicy + while (DecSpeed(true)); //zerowanie napędu + mvControlling->ConvOvldFlag=false; //reset nadmiarowego + } + else if (!mvControlling->Mains) + { + //if TrainType=dt_SN61) + // begin + // OK:=(OrderDirectionChange(ChangeDir,Controlling)=-1); + // OK:=IncMainCtrl(1); + // end; + while (DecSpeed(true)); //zerowanie napędu + OK=mvControlling->MainSwitch(true); + if (mvControlling->EngineType==DieselEngine) + {//Ra 2014-06: dla SN61 trzeba wrzucić pierwszą pozycję - nie wiem, czy tutaj... kiedyś działało... + if (!mvControlling->MainCtrlPos) + {if (mvControlling->RList[0].R==0.0) //gdy na pozycji 0 dawka paliwa jest zerowa, to zgaśnie + mvControlling->IncMainCtrl(1); //dlatego trzeba zwiększyć pozycję + if (!mvControlling->ScndCtrlPos) //jeśli bieg nie został ustawiony + if (!mvControlling->MotorParam[0].AutoSwitch) //gdy biegi ręczne + if (mvControlling->MotorParam[0].mIsat==0.0) //bl,mIsat,fi,mfi + mvControlling->IncScndCtrl(1); //pierwszy bieg + } + } + } + else + {//Ra: iDirection określa, w którą stronę jedzie skład względem sprzęgów pojazdu z AI + OK=(OrderDirectionChange(iDirection,mvOccupied)==-1); + //w EN57 sprężarka w ra jest zasilana z silnikowego + mvControlling->CompressorSwitch(true); + mvControlling->ConverterSwitch(true); + mvControlling->CompressorSwitch(true); + } + } + else OK=mvControlling->Mains; + } + else + OK=false; + OK=OK&&(mvOccupied->ActiveDir!=0)&&(mvControlling->CompressorAllow); + if (OK) + { + if (eStopReason==stopSleep) //jeśli dotychczas spał + eStopReason==stopNone; //teraz nie ma powodu do stania + iEngineActive=1; + return true; + } + else + { + iEngineActive=0; + return false; + } +}; + +bool __fastcall TController::ReleaseEngine() +{//wyłączanie silnika (test wyłączenia, a część wykonawcza tylko jeśli steruje komputer) + bool OK=false; + LastReactionTime=0.0; + ReactionTime=PrepareTime; + if (AIControllFlag) + {//jeśli steruje komputer + if (mvOccupied->DoorOpenCtrl==1) + {//zamykanie drzwi + if (mvOccupied->DoorLeftOpened) mvOccupied->DoorLeft(false); + if (mvOccupied->DoorRightOpened) mvOccupied->DoorRight(false); + } + if (mvOccupied->ActiveDir==0) + if (mvControlling->Mains) + { + mvControlling->CompressorSwitch(false); + mvControlling->ConverterSwitch(false); + if (mvControlling->EnginePowerSource.SourceType==CurrentCollector) + { + mvControlling->PantFront(false); + mvControlling->PantRear(false); + } + OK=mvControlling->MainSwitch(false); + } + else + OK=true; + } + else + if (mvOccupied->ActiveDir==0) + OK=mvControlling->Mains; //tylko to testujemy dla pojazdu człowieka + if (AIControllFlag) + if (!mvOccupied->DecBrakeLevel()) //tu moze zmieniać na -2, ale to bez znaczenia + if (!mvOccupied->IncLocalBrakeLevel(1)) + { + while (DecSpeed(true)); //zerowanie nastawników + while (mvOccupied->ActiveDir>0) + mvOccupied->DirectionBackward(); + while (mvOccupied->ActiveDir<0) + mvOccupied->DirectionForward(); + } + OK=OK&&(mvOccupied->Vel<0.01); + if (OK) + {//jeśli się zatrzymał + iEngineActive=0; + eStopReason=stopSleep; //stoimy z powodu wyłączenia + eAction=actSleep; //śpi (wygaszony) + if (AIControllFlag) + {Lights(0,0); //gasimy światła + mvOccupied->BatterySwitch(false); + } + OrderNext(Wait_for_orders); //żeby nie próbował coś robić dalej + TableClear(); //zapominamy ograniczenia + iDrivigFlags&=~moveActive; //ma nie skanować sygnałów i nie reagować na komendy + } + return OK; +} + +bool __fastcall TController::IncBrake() +{//zwiększenie hamowania + bool OK=false; + switch (mvOccupied->BrakeSystem) + { + case Individual: + OK=mvOccupied->IncLocalBrakeLevel(1+floor(0.5+fabs(AccDesired))); + break; + case Pneumatic: + if ((mvOccupied->Couplers[0].Connected==NULL)&&(mvOccupied->Couplers[1].Connected==NULL)) + OK=mvOccupied->IncLocalBrakeLevel(1+floor(0.5+fabs(AccDesired))); //hamowanie lokalnym bo luzem jedzie + else + {if (mvOccupied->BrakeCtrlPos+1==mvOccupied->BrakeCtrlPosNo) + { + if (AccDesired<-1.5) //hamowanie nagle + OK=mvOccupied->IncBrakeLevel(); + else + OK=false; + } + else + { +/* + if (AccDesired>-0.2) and ((Vel<20) or (Vel-VelNext<10))) + begin + if BrakeCtrlPos>0) + OK:=IncBrakeLevel + else; + OK:=IncLocalBrakeLevel(1); //finezyjne hamowanie lokalnym + end + else +*/ +//dodane dla towarowego + if (mvOccupied->BrakeDelayFlag==bdelay_G?-AccDesired*6.6>Min0R(2,mvOccupied->BrakeCtrlPos):true) + { + OK=mvOccupied->IncBrakeLevel(); + } + else + OK=false; + } + } + if (mvOccupied->BrakeCtrlPos>0) mvOccupied->BrakeReleaser(0); + break; + case ElectroPneumatic: + if(mvOccupied->fBrakeCtrlPos!=mvOccupied->Handle->GetPos(bh_EPB)) + { + mvOccupied->BrakeLevelSet(mvOccupied->Handle->GetPos(bh_EPB)); + if (mvOccupied->Handle->GetPos(bh_EPR)-mvOccupied->Handle->GetPos(bh_EPN)<0.1) + mvOccupied->SwitchEPBrake(1); //to nie chce działać + OK=true; + } + else OK=false; +// if (mvOccupied->BrakeCtrlPosBrakeCtrlPosNo) +// if (mvOccupied->BrakePressureTable[mvOccupied->BrakeCtrlPos+1+2].BrakeType==ElectroPneumatic) //+2 to indeks Pascala +// OK=mvOccupied->IncBrakeLevel(); +// else +// OK=false; + } + return OK; +} + +bool __fastcall TController::DecBrake() +{//zmniejszenie siły hamowania + bool OK=false; + switch (mvOccupied->BrakeSystem) + { + case Individual: + OK=mvOccupied->DecLocalBrakeLevel(1+floor(0.5+fabs(AccDesired))); + break; + case Pneumatic: + if (mvOccupied->BrakeCtrlPos>0) + OK=mvOccupied->DecBrakeLevel(); + if (!OK) + OK=mvOccupied->DecLocalBrakeLevel(2); + if (mvOccupied->PipePress<3.0) + Need_BrakeRelease=true; + break; + case ElectroPneumatic: + if(mvOccupied->fBrakeCtrlPos!=mvOccupied->Handle->GetPos(bh_EPR)) + { + mvOccupied->BrakeLevelSet(mvOccupied->Handle->GetPos(bh_EPR)); + if (mvOccupied->Handle->GetPos(bh_EPR)-mvOccupied->Handle->GetPos(bh_EPN)<0.1) + mvOccupied->SwitchEPBrake(1); + OK=true; + } + else OK=false; + if (!OK) + OK=mvOccupied->DecLocalBrakeLevel(2); + break; + } + return OK; +}; + +bool __fastcall TController::IncSpeed() +{//zwiększenie prędkości; zwraca false, jeśli dalej się nie da zwiększać + if (tsGuardSignal) //jeśli jest dźwięk kierownika + if (tsGuardSignal->GetStatus()&DSBSTATUS_PLAYING) //jeśli gada, to nie jedziemy + return false; + bool OK=true; + if (iDrivigFlags&moveDoorOpened) + Doors(false); //zamykanie drzwi - tutaj wykonuje tylko AI (zmienia fActionTime) + if (fActionTime<0.0) //gdy jest nakaz poczekać z jazdą, to nie ruszać + return false; + if (mvControlling->SlippingWheels) + return false; //jak poślizg, to nie przyspieszamy + switch (mvOccupied->EngineType) + { + case None: //McZapkie-041003: wagon sterowniczy + if (mvControlling->MainCtrlPosNo>0) //jeśli ma czym kręcić + iDrivigFlags|=moveIncSpeed; //ustawienie flagi jazdy + return false; + case ElectricSeriesMotor: + if (mvControlling->EnginePowerSource.SourceType==CurrentCollector) //jeśli pantografujący + {if (fOverhead2>=0.0) //a jazda bezprądowa ustawiana eventami (albo opuszczenie) + return false; //to nici z ruszania + if (iOverheadZero) //jazda bezprądowa z poziomu toru ustawia bity + return false; //to nici z ruszania + } + if (!mvControlling->FuseFlag) //&&mvControlling->StLinFlag) //yBARC + if ((mvControlling->MainCtrlPos==0)||(mvControlling->StLinFlag)) //youBy polecił dodać 2012-09-08 v367 + //na pozycji 0 przejdzie, a na pozostałych będzie czekać, aż się załączą liniowe (zgaśnie DelayCtrlFlag) + if (Ready||(iDrivigFlags&movePress)) + if (fabs(mvControlling->Im)<(fReady<0.4?mvControlling->Imin:mvControlling->IminLo)) + {//Ra: wywalał nadmiarowy, bo Im może być ujemne; jak nie odhamowany, to nie przesadzać z prądem + if ((mvOccupied->Vel<=30)||(mvControlling->Imax>mvControlling->ImaxLo) + || (fVoltage+fVoltageEnginePowerSource.CollectorParameters.MinV+mvControlling->EnginePowerSource.CollectorParameters.MaxV)) + {//bocznik na szeregowej przy ciezkich bruttach albo przy wysokim rozruchu pod górę albo przy niskim napięciu + if (mvControlling->MainCtrlPos?mvControlling->RList[mvControlling->MainCtrlPos].R>0.0:true) //oporowa + { + OK=(mvControlling->DelayCtrlFlag?true:mvControlling->IncMainCtrl(1)); //kręcimy nastawnik jazdy + if ((OK)&&(mvControlling->MainCtrlPos==1)) //czekaj na 1 pozycji, zanim się nie włączą liniowe + iDrivigFlags|=moveIncSpeed; + else + iDrivigFlags&=~moveIncSpeed; //usunięcie flagi czekania + } + else //jeśli bezoporowa (z wyjątekiem 0) + OK=false; //to dać bocznik + } + else + {//przekroczone 30km/h, można wejść na jazdę równoległą + if (mvControlling->ScndCtrlPos) //jeśli ustawiony bocznik + if (mvControlling->MainCtrlPosMainCtrlPosNo-1) //a nie jest ostatnia pozycja + mvControlling->DecScndCtrl(2); //to bocznik na zero po chamsku (ktoś miał to poprawić...) + OK=mvControlling->IncMainCtrl(1); + } + if ((mvControlling->MainCtrlPos>2)&&(mvControlling->Im==0)) //brak prądu na dalszych pozycjach + Need_TryAgain=true; //nie załączona lokomotywa albo wywalił nadmiarowy + else if (!OK) //nie da się wrzucić kolejnej pozycji + OK=mvControlling->IncScndCtrl(1); //to dać bocznik + } + mvControlling->AutoRelayCheck(); //sprawdzenie logiki sterowania + break; + case Dumb: + case DieselElectric: + if (!mvControlling->FuseFlag) + if (Ready||(iDrivigFlags&movePress)) //{(BrakePress<=0.01*MaxBrakePress)} + { + OK=mvControlling->IncMainCtrl(1); + if (!OK) + OK=mvControlling->IncScndCtrl(1); + } + break; + case WheelsDriven: + if (!mvControlling->CabNo) + mvControlling->CabActivisation(); + if (sin(mvControlling->eAngle)>0) + mvControlling->IncMainCtrl(3+3*floor(0.5+fabs(AccDesired))); + else + mvControlling->DecMainCtrl(3+3*floor(0.5+fabs(AccDesired))); + break; + case DieselEngine: + if (mvControlling->ShuntModeAllow) + {//dla 2Ls150 można zmienić tryb pracy, jeśli jest w liniowym i nie daje rady (wymaga zerowania kierunku) + //mvControlling->ShuntMode=(OrderList[OrderPos]&Shunt)||(fMass>224000.0); + } + if ((mvControlling->Vel>mvControlling->dizel_minVelfullengage)&&(mvControlling->RList[mvControlling->MainCtrlPos].Mn>0)) + OK=mvControlling->IncMainCtrl(1); + if (mvControlling->RList[mvControlling->MainCtrlPos].Mn==0) + OK=mvControlling->IncMainCtrl(1); + if (!mvControlling->Mains) + { + mvControlling->MainSwitch(true); + mvControlling->ConverterSwitch(true); + mvControlling->CompressorSwitch(true); + } + break; + } + return OK; +} + +bool __fastcall TController::DecSpeed(bool force) +{//zmniejszenie prędkości (ale nie hamowanie) + bool OK=false; //domyślnie false, aby wyszło z pętli while + switch (mvOccupied->EngineType) + { + case None: //McZapkie-041003: wagon sterowniczy + iDrivigFlags&=~moveIncSpeed; //usunięcie flagi jazdy + if (force) //przy aktywacji kabiny jest potrzeba natychmiastowego wyzerowania + if (mvControlling->MainCtrlPosNo>0) //McZapkie-041003: wagon sterowniczy, np. EZT + mvControlling->DecMainCtrl(1+(mvControlling->MainCtrlPos>2?1:0)); + mvControlling->AutoRelayCheck(); //sprawdzenie logiki sterowania + return false; + case ElectricSeriesMotor: + OK=mvControlling->DecScndCtrl(2); //najpierw bocznik na zero + if (!OK) + OK=mvControlling->DecMainCtrl(1+(mvControlling->MainCtrlPos>2?1:0)); + mvControlling->AutoRelayCheck(); //sprawdzenie logiki sterowania + break; + case Dumb: + case DieselElectric: + OK=mvControlling->DecScndCtrl(2); + if (!OK) + OK=mvControlling->DecMainCtrl(2+(mvControlling->MainCtrlPos/2)); + break; + case WheelsDriven: + if (!mvControlling->CabNo) + mvControlling->CabActivisation(); + if (sin(mvControlling->eAngle)<0) + mvControlling->IncMainCtrl(3+3*floor(0.5+fabs(AccDesired))); + else + mvControlling->DecMainCtrl(3+3*floor(0.5+fabs(AccDesired))); + break; + case DieselEngine: + if ((mvControlling->Vel>mvControlling->dizel_minVelfullengage)) + { + if (mvControlling->RList[mvControlling->MainCtrlPos].Mn>0) + OK=mvControlling->DecMainCtrl(1); + } + else + while ((mvControlling->RList[mvControlling->MainCtrlPos].Mn>0)&&(mvControlling->MainCtrlPos>1)) + OK=mvControlling->DecMainCtrl(1); + if (force) //przy aktywacji kabiny jest potrzeba natychmiastowego wyzerowania + OK=mvControlling->DecMainCtrl(1+(mvControlling->MainCtrlPos>2?1:0)); + break; + } + return OK; +}; + +void __fastcall TController::SpeedSet() +{//Ra: regulacja prędkości, wykonywana w każdym przebłysku świadomości AI + //ma dokręcać do bezoporowych i zdejmować pozycje w przypadku przekroczenia prądu + switch (mvOccupied->EngineType) + { + case None: //McZapkie-041003: wagon sterowniczy + if (fActionTime>=-1.0) + mvOccupied->DepartureSignal=false; //trochę niech pobuczy, zanim pojedzie + if (mvControlling->MainCtrlPosNo>0) + {//jeśli ma czym kręcić + //TODO: sprawdzanie innego czlonu //if (!FuseFlagCheck()) + if ((AccDesiredVel>VelDesired)) //jeśli nie ma przyspieszać + mvControlling->DecMainCtrl(2); //na zero + else + if (fActionTime>=0.0) + {//jak już można coś poruszać, przetok rozłączać od razu + if (iDrivigFlags&moveIncSpeed) + {//jak ma jechać + if (fReady<0.4) //0.05*Controlling->MaxBrakePress) + {//jak jest odhamowany + if (mvOccupied->ActiveDir>0) mvOccupied->DirectionForward(); //żeby EN57 jechały na drugiej nastawie + { + if (mvControlling->MainCtrlPos&&!mvControlling->StLinFlag) //jak niby jedzie, ale ma rozłączone liniowe + mvControlling->DecMainCtrl(2); //to na zero i czekać na przewalenie kułakowego + else + switch (mvControlling->MainCtrlPos) + {//ruch nastawnika uzależniony jest od aktualnie ustawionej pozycji + case 0: + if (mvControlling->MainCtrlActualPos) //jeśli kułakowy nie jest wyzerowany + break; //to czekać na wyzerowanie + mvControlling->IncMainCtrl(1); //przetok; bez "break", bo nie ma czekania na 1. pozycji + case 1: + if (VelDesired>=20) mvControlling->IncMainCtrl(1); //szeregowa + case 2: + if (VelDesired>=50) mvControlling->IncMainCtrl(1); //równoległa + case 3: + if (VelDesired>=80) mvControlling->IncMainCtrl(1); //bocznik 1 + case 4: + if (VelDesired>=90) mvControlling->IncMainCtrl(1); //bocznik 2 + case 5: + if (VelDesired>=100) mvControlling->IncMainCtrl(1); //bocznik 3 + } + if (mvControlling->MainCtrlPos) //jak załączył pozycję + {fActionTime=-5.0; //niech trochę potrzyma + mvControlling->AutoRelayCheck(); //sprawdzenie logiki sterowania + } + } + } + } + else + {while (mvControlling->MainCtrlPos) + mvControlling->DecMainCtrl(1); //na zero + fActionTime=-5.0; //niech trochę potrzyma + mvControlling->AutoRelayCheck(); //sprawdzenie logiki sterowania + } + } + } + break; + case ElectricSeriesMotor: + if ((!mvControlling->StLinFlag)&&(!mvControlling->DelayCtrlFlag)&&(!iDrivigFlags&moveIncSpeed)) //styczniki liniowe rozłączone yBARC +// if (iDrivigFlags&moveIncSpeed) {} //jeśli czeka na załączenie liniowych +// else + while (DecSpeed()); //zerowanie napędu + else + if (Ready||(iDrivigFlags&movePress)) //o ile może jechać + if (fAccGravity<-0.10) //i jedzie pod górę większą niż 10 promil + {//procedura wjeżdżania na ekstremalne wzniesienia + if (fabs(mvControlling->Im)>0.85*mvControlling->Imax) //a prąd jest większy niż 85% nadmiarowego + //if (mvControlling->Imin*mvControlling->Voltage/(fMass*fAccGravity)<-2.8) //a na niskim się za szybko nie pojedzie + if (mvControlling->Imax*mvControlling->Voltage/(fMass*fAccGravity)<-2.8) //a na niskim się za szybko nie pojedzie + {//włączenie wysokiego rozruchu; (I*U)[A*V=W=kg*m*m/sss]/(m[kg]*a[m/ss])=v[m/s]; 2.8m/ss=10km/h + if (mvControlling->RList[mvControlling->MainCtrlPos].Bn>1) + {//jeśli jedzie na równoległym, to zbijamy do szeregowego, aby włączyć wysoki rozruch + if (mvControlling->ScndCtrlPos>0) //jeżeli jest bocznik + mvControlling->DecScndCtrl(2); //wyłączyć bocznik, bo może blokować skręcenie NJ + do //skręcanie do bezoporowej na szeregowym + mvControlling->DecMainCtrl(1); //kręcimy nastawnik jazdy o 1 wstecz + while (mvControlling->MainCtrlPos?mvControlling->RList[mvControlling->MainCtrlPos].Bn>1:false); //oporowa zapętla + } + if (mvControlling->ImaxImaxHi) //jeśli da się na wysokim + mvControlling->CurrentSwitch(true); //rozruch wysoki (za to może się ślizgać) + if (ReactionTime>0.1) + ReactionTime=0.1; //orientuj się szybciej + } //if (Im>Imin) + if (fabs(mvControlling->Im)>0.75*mvControlling->ImaxHi) //jeśli prąd jest duży + mvControlling->SandDoseOn(); //piaskujemy tory, coby się nie ślizgać + if ((fabs(mvControlling->Im)>0.96*mvControlling->Imax)||mvControlling->SlippingWheels) //jeśli prąd jest duży (można 690 na 750) + if (mvControlling->ScndCtrlPos>0) //jeżeli jest bocznik + mvControlling->DecScndCtrl(2); //zmniejszyć bocznik + else + mvControlling->DecMainCtrl(1); //kręcimy nastawnik jazdy o 1 wstecz + } + else //gdy nie jedzie ambitnie pod górę + {//sprawdzenie, czy rozruch wysoki jest potrzebny + if (mvControlling->Imax>mvControlling->ImaxLo) + if (mvOccupied->Vel>=30.0) //jak się rozpędził + if (fAccGravity>-0.02) //a i pochylenie mnijsze niż 2‰ + mvControlling->CurrentSwitch(false); //rozruch wysoki wyłącz + //dokręcanie do bezoporowej, bo IncSpeed() może nie być wywoływane + //if (mvOccupied->Vel-0.1) //nie ma hamować + // if (Controlling->RList[MainCtrlPos].R>0.0) + // if (Im<1.3*Imin) //lekkie przekroczenie miimalnego prądu jest dopuszczalne + // IncMainCtrl(1); //zwieksz nastawnik skoro możesz - tak aby się ustawic na bezoporowej + } + break; + case Dumb: + case DieselElectric: + break; + //WheelsDriven : + // begin + // OK:=False; + // end; + case DieselEngine: + //Ra 2014-06: "automatyczna" skrzynia biegów... + if (!mvControlling->MotorParam[mvControlling->ScndCtrlPos].AutoSwitch) //gdy biegi ręczne + if ((mvControlling->ShuntMode?mvControlling->AnPos:1.0)*mvControlling->Vel>0.6*mvControlling->MotorParam[mvControlling->ScndCtrlPos].mfi) + //if (mvControlling->enrot>0.95*mvControlling->dizel_nMmax) //youBy: jeśli obroty > 0,95 nmax, wrzuć wyższy bieg - Ra: to nie działa + {//jak prędkość większa niż 0.6 maksymalnej na danym biegu, wrzucić wyższy + mvControlling->DecMainCtrl(2); + if (mvControlling->IncScndCtrl(1)) + if (mvControlling->MotorParam[mvControlling->ScndCtrlPos].mIsat==0.0) //jeśli bieg jałowy + mvControlling->IncScndCtrl(1); //to kolejny + } + else if ((mvControlling->ShuntMode?mvControlling->AnPos:1.0)*mvControlling->VelMotorParam[mvControlling->ScndCtrlPos].fi) + {//jak prędkość mniejsza niż minimalna na danym biegu, wrzucić niższy + mvControlling->DecMainCtrl(2); + mvControlling->DecScndCtrl(1); + if (mvControlling->MotorParam[mvControlling->ScndCtrlPos].mIsat==0.0) //jeśli bieg jałowy + if (mvControlling->ScndCtrlPos) //a jeszcze zera nie osiągnięto + mvControlling->DecScndCtrl(1); //to kolejny wcześniejszy + else + mvControlling->IncScndCtrl(1); //a jak zeszło na zero, to powrót + } + break; + } +}; + +void __fastcall TController::Doors(bool what) +{//otwieranie/zamykanie drzwi w składzie albo (tylko AI) EZT + if (what) + {//otwarcie + } + else + {//zamykanie + if (mvOccupied->DoorOpenCtrl==1) + {//jeśli drzwi sterowane z kabiny + if (AIControllFlag) + if (mvOccupied->DoorLeftOpened||mvOccupied->DoorRightOpened) + {//AI zamyka drzwi przed odjazdem + if (mvOccupied->DoorClosureWarning) + mvOccupied->DepartureSignal=true; //załącenie bzyczka + mvOccupied->DoorLeft(false); //zamykanie drzwi + mvOccupied->DoorRight(false); + //Ra: trzeba by ustawić jakiś czas oczekiwania na zamknięcie się drzwi + fActionTime=-1.5-0.1*random(10); //czekanie sekundę, może trochę dłużej + iDrivigFlags&=~moveDoorOpened; //nie wykonywać drugi raz + } + } + else + {//jeśli nie, to zamykanie w składzie wagonowym + TDynamicObject *p=pVehicles[0]; //pojazd na czole składu + while (p) + {//zamykanie drzwi w pojazdach - flaga zezwolenia była by lepsza + p->MoverParameters->DoorLeft(false); //w lokomotywie można by nie zamykać... + p->MoverParameters->DoorRight(false); + p=p->Next(); //pojazd podłączony z tyłu (patrząc od czoła) + } + //WaitingSet(5); //10 sekund tu to za długo, opóźnia odjazd o pół minuty + fActionTime=-1.5-0.1*random(10); //czekanie sekundę, może trochę dłużej + iDrivigFlags&=~moveDoorOpened; //zostały zamknięte - nie wykonywać drugi raz + } + } +}; + +void __fastcall TController::RecognizeCommand() +{//odczytuje i wykonuje komendę przekazaną lokomotywie + TCommand *c=&mvOccupied->CommandIn; + PutCommand(c->Command,c->Value1,c->Value2,c->Location,stopComm); + c->Command=""; //usunięcie obsłużonej komendy +} + + +void __fastcall TController::PutCommand(AnsiString NewCommand,double NewValue1,double NewValue2,const TLocation &NewLocation,TStopReason reason) +{//wysłanie komendy przez event PutValues, jak pojazd ma obsadę, to wysyła tutaj, a nie do pojazdu bezpośrednio + vector3 sl; + sl.x=-NewLocation.X; //zamiana na współrzędne scenerii + sl.z= NewLocation.Y; + sl.y= NewLocation.Z; + if (!PutCommand(NewCommand,NewValue1,NewValue2,&sl,reason)) + mvOccupied->PutCommand(NewCommand,NewValue1,NewValue2,NewLocation); +} + + +bool __fastcall TController::PutCommand(AnsiString NewCommand,double NewValue1,double NewValue2,const vector3 *NewLocation,TStopReason reason) +{//analiza komendy + if (NewCommand=="CabSignal") + {//SHP wyzwalane jest przez człon z obsadą, ale obsługiwane przez silnikowy + //nie jest to najlepiej zrobione, ale bez symulacji obwodów lepiej nie będzie + //Ra 2014-04: jednak przeniosłem do rozrządczego + mvOccupied->PutCommand(NewCommand,NewValue1,NewValue2,mvOccupied->Loc); + mvOccupied->RunInternalCommand(); //rozpoznaj komende bo lokomotywa jej nie rozpoznaje + return true; //załatwione + } + if (NewCommand=="Overhead") + {//informacja o stanie sieci trakcyjnej + fOverhead1=NewValue1; //informacja o napięciu w sieci trakcyjnej (0=brak drutu, zatrzymaj!) + fOverhead2=NewValue2; //informacja o sposobie jazdy (-1=normalnie, 0=bez prądu, >0=z opuszczonym i ograniczeniem prędkości) + return true; //załatwione + } + else if (NewCommand=="Emergency_brake") //wymuszenie zatrzymania, niezależnie kto prowadzi + {//Ra: no nadal nie jest zbyt pięknie + SetVelocity(0,0,reason); + mvOccupied->PutCommand("Emergency_brake",1.0,1.0,mvOccupied->Loc); + return true; //załatwione + } + else if (NewCommand.Pos("Timetable:")==1) + {//przypisanie nowego rozkładu jazdy, również prowadzonemu przez użytkownika + NewCommand.Delete(1,10); //zostanie nazwa pliku z rozkładem +#if LOGSTOPS + WriteLog("New timetable for "+pVehicle->asName+": "+NewCommand); //informacja +#endif + if (!TrainParams) + TrainParams=new TTrainParameters(NewCommand); //rozkład jazdy + else + TrainParams->NewName(NewCommand); //czyści tabelkę przystanków + delete tsGuardSignal; tsGuardSignal=NULL; //wywalenie kierownika + if (NewCommand!="none") + {if (!TrainParams->LoadTTfile(Global::asCurrentSceneryPath,floor(NewValue2+0.5),NewValue1)) //pierwszy parametr to przesunięcie rozkładu w czasie + { + if (ConversionError==-8) + ErrorLog("Missed timetable: "+NewCommand); + WriteLog("Cannot load timetable file "+NewCommand+"\r\nError "+ConversionError+" in position "+TrainParams->StationCount); + NewCommand=""; //puste, dla wymiennej tekstury + } + else + {//inicjacja pierwszego przystanku i pobranie jego nazwy + TrainParams->UpdateMTable(GlobalTime->hh,GlobalTime->mm,TrainParams->NextStationName); + TrainParams->StationIndexInc(); //przejście do następnej + iStationStart=TrainParams->StationIndex; + asNextStop=TrainParams->NextStop(); + iDrivigFlags|=movePrimary; //skoro dostał rozkład, to jest teraz głównym + NewCommand=Global::asCurrentSceneryPath+NewCommand+".wav"; //na razie jeden + if (FileExists(NewCommand)) + {//wczytanie dźwięku odjazdu podawanego bezpośrenido + tsGuardSignal=new TTextSound(); + tsGuardSignal->Init(NewCommand.c_str(),30,pVehicle->GetPosition().x,pVehicle->GetPosition().y,pVehicle->GetPosition().z,false); + //rsGuardSignal->Stop(); + iGuardRadio=0; //nie przez radio + } + else + {NewCommand.Insert("radio",NewCommand.Length()-3); //wstawienie przed kropką + if (FileExists(NewCommand)) + {//wczytanie dźwięku odjazdu w wersji radiowej (słychać tylko w kabinie) + tsGuardSignal=new TTextSound(); + tsGuardSignal->Init(NewCommand.c_str(),-1,pVehicle->GetPosition().x,pVehicle->GetPosition().y,pVehicle->GetPosition().z,false); + iGuardRadio=iRadioChannel; + } + } + NewCommand=TrainParams->Relation2; //relacja docelowa z rozkładu + } + //jeszcze poustawiać tekstury na wyświetlaczach + TDynamicObject *p=pVehicles[0]; + while (p) + { + p->DestinationSet(NewCommand); //relacja docelowa + p=p->Next(); //pojazd podłączony od tyłu (licząc od czoła) + } + } + if (NewLocation) //jeśli podane współrzędne eventu/komórki ustawiającej rozkład (trainset nie podaje) + {vector3 v=*NewLocation-pVehicle->GetPosition(); //wektor do punktu sterującego + vector3 d=pVehicle->VectorFront(); //wektor wskazujący przód + iDirectionOrder=((v.x*d.x+v.z*d.z)*NewValue1>0)?1:-1; //do przodu, gdy iloczyn skalarny i prędkość dodatnie +/* + if (NewValue1!=0.0) //jeśli ma jechać + if (iDirectionOrder==0) //a kierunek nie był określony (normalnie określany przez reardriver/headdriver) + iDirectionOrder=NewValue1>0?1:-1; //ustalenie kierunku jazdy względem sprzęgów + else + if (NewValue1<0) //dla ujemnej prędkości + iDirectionOrder=-iDirectionOrder; //ma jechać w drugą stronę +*/ + if (AIControllFlag) //jeśli prowadzi komputer + Activation(); //umieszczenie obsługi we właściwym członie, ustawienie nawrotnika w przód + } +/* + else + if (!iDirectionOrder) + {//jeśli nie ma kierunku, trzeba ustalić + if (mvOccupied->V!=0.0) + iDirectionOrder=mvOccupied->V>0?1:-1; + else + iDirectionOrder=mvOccupied->ActiveCab; + if (!iDirectionOrder) iDirectionOrder=1; + } +*/ + //jeśli wysyłane z Trainset, to wszystko jest już odpowiednio ustawione + //if (!NewLocation) //jeśli wysyłane z Trainset + // if (mvOccupied->CabNo*mvOccupied->V*NewValue1<0) //jeśli zadana prędkość niezgodna z aktualnym kierunkiem jazdy + // DirectionForward(false); //jedziemy do tyłu (nawrotnik do tyłu) + //CheckVehicles(); //sprawdzenie składu, AI zapali światła + TableClear(); //wyczyszczenie tabelki prędkości, bo na nowo trzeba określić kierunek i sprawdzić przystanki + OrdersInit(fabs(NewValue1)); //ustalenie tabelki komend wg rozkładu oraz prędkości początkowej + //if (NewValue1!=0.0) if (!AIControllFlag) DirectionForward(NewValue1>0.0); //ustawienie nawrotnika użytkownikowi (propaguje się do członów) + //if (NewValue1>0) + // TrainNumber=floor(NewValue1); //i co potem ??? + return true; //załatwione + } + if (NewCommand=="SetVelocity") + { + if (NewLocation) + vCommandLocation=*NewLocation; + if ((NewValue1!=0.0)&&(OrderList[OrderPos]!=Obey_train)) + {//o ile jazda + if (!iEngineActive) + OrderNext(Prepare_engine); //trzeba odpalić silnik najpierw, światła ustawi JumpToNextOrder() + //if (OrderList[OrderPos]!=Obey_train) //jeśli nie pociągowa + OrderNext(Obey_train); //to uruchomić jazdę pociągową (od razu albo po odpaleniu silnika + OrderCheck(); //jeśli jazda pociągowa teraz, to wykonać niezbędne operacje + } + if (NewValue1!=0.0) //jeśli jechać + iDrivigFlags&=~moveStopHere; //podjeżanie do semaforów zezwolone + else + iDrivigFlags|=moveStopHere; //stać do momentu podania komendy jazdy + SetVelocity(NewValue1,NewValue2,reason); //bylo: nic nie rob bo SetVelocity zewnetrznie jest wywolywane przez dynobj.cpp + } + else if (NewCommand=="SetProximityVelocity") + { +/* + if (SetProximityVelocity(NewValue1,NewValue2)) + if (NewLocation) + vCommandLocation=*NewLocation; +*/ + } + else if (NewCommand=="ShuntVelocity") + {//uruchomienie jazdy manewrowej bądź zmiana prędkości + if (NewLocation) + vCommandLocation=*NewLocation; + //if (OrderList[OrderPos]=Obey_train) and (NewValue1<>0)) + if (!iEngineActive) + OrderNext(Prepare_engine); //trzeba odpalić silnik najpierw + OrderNext(Shunt); //zamieniamy w aktualnej pozycji, albo dodajey za odpaleniem silnika + if (NewValue1!=0.0) + { + //if (iVehicleCount>=0) WriteLog("Skasowano ilosć wagonów w ShuntVelocity!"); + iVehicleCount=-2; //wartość neutralna + CheckVehicles(); //zabrać to do OrderCheck() + } + //dla prędkości ujemnej przestawić nawrotnik do tyłu? ale -1=brak ograniczenia !!!! + //if (iDrivigFlags&movePress) WriteLog("Skasowano docisk w ShuntVelocity!"); + iDrivigFlags&=~movePress; //bez dociskania + SetVelocity(NewValue1,NewValue2,reason); + if (NewValue1!=0.0) + iDrivigFlags&=~moveStopHere; //podjeżanie do semaforów zezwolone + else + iDrivigFlags|=moveStopHere; //ma stać w miejscu + if (fabs(NewValue1)>2.0) //o ile wartość jest sensowna (-1 nie jest konkretną wartością) + fShuntVelocity=fabs(NewValue1); //zapamiętanie obowiązującej prędkości dla manewrów + } + else if (NewCommand=="Wait_for_orders") + {//oczekiwanie; NewValue1 - czas oczekiwania, -1 = na inną komendę + if (NewValue1>0.0?NewValue1>fStopTime:false) + fStopTime=NewValue1; //Ra: włączenie czekania bez zmiany komendy + else + OrderList[OrderPos]=Wait_for_orders; //czekanie na komendę (albo dać OrderPos=0) + } + else if (NewCommand=="Prepare_engine") + {//włączenie albo wyłączenie silnika (w szerokim sensie) + OrdersClear(); //czyszczenie tabelki rozkazów, aby nic dalej nie robił + if (NewValue1==0.0) + OrderNext(Release_engine); //wyłączyć silnik (przygotować pojazd do jazdy) + else if (NewValue1>0.0) + OrderNext(Prepare_engine); //odpalić silnik (wyłączyć wszystko, co się da) + //po załączeniu przejdzie do kolejnej komendy, po wyłączeniu na Wait_for_orders + } + else if (NewCommand=="Change_direction") + { + TOrders o=OrderList[OrderPos]; //co robił przed zmianą kierunku + if (!iEngineActive) + OrderNext(Prepare_engine); //trzeba odpalić silnik najpierw + if (NewValue1==0.0) + iDirectionOrder=-iDirection; //zmiana na przeciwny niż obecny + else + if (NewLocation) //jeśli podane współrzędne eventu/komórki ustawiającej rozkład (trainset nie podaje) + {vector3 v=*NewLocation-pVehicle->GetPosition(); //wektor do punktu sterującego + vector3 d=pVehicle->VectorFront(); //wektor wskazujący przód + iDirectionOrder=((v.x*d.x+v.z*d.z)*NewValue1>0)?1:-1; //do przodu, gdy iloczyn skalarny i prędkość dodatnie + //iDirectionOrder=1; else if (NewValue1<0.0) iDirectionOrder=-1; + } + if (iDirectionOrder!=iDirection) + OrderNext(Change_direction); //zadanie komendy do wykonania + if (o>=Shunt) //jeśli jazda manewrowa albo pociągowa + OrderNext(o); //to samo robić po zmianie + else if (!o) //jeśli wcześniej było czekanie + OrderNext(Shunt); //to dalej jazda manewrowa + if (mvOccupied->Vel>=1.0) //jeśli jedzie + iDrivigFlags&=~moveStartHorn; //to bez trąbienia po ruszeniu z zatrzymania + //Change_direction wykona się samo i następnie przejdzie do kolejnej komendy + } + else if (NewCommand=="Obey_train") + { + if (!iEngineActive) + OrderNext(Prepare_engine); //trzeba odpalić silnik najpierw + OrderNext(Obey_train); + //if (NewValue1>0) TrainNumber=floor(NewValue1); //i co potem ??? + OrderCheck(); //jeśli jazda pociągowa teraz, to wykonać niezbędne operacje + } + else if (NewCommand=="Shunt") + {//NewValue1 - ilość wagonów (-1=wszystkie); NewValue2: 0=odczep, 1..63=dołącz, -1=bez zmian + //-3,-y - podłączyć do całego stojącego składu (sprzęgiem y>=1), zmienić kierunek i czekać w trybie pociągowym + //-2,-y - podłączyć do całego stojącego składu (sprzęgiem y>=1), zmienić kierunek i czekać + //-2, y - podłączyć do całego stojącego składu (sprzęgiem y>=1) i czekać + //-1,-y - podłączyć do całego stojącego składu (sprzęgiem y>=1) i jechać w powrotną stronę + //-1, y - podłączyć do całego stojącego składu (sprzęgiem y>=1) i jechać dalej + //-1, 0 - tryb manewrowy bez zmian (odczepianie z pozostawieniem wagonów nie ma sensu) + // 0, 0 - odczepienie lokomotywy + // 1,-y - podłączyć się do składu (sprzęgiem y>=1), a następnie odczepić i zabrać (x) wagonów + // 1, 0 - odczepienie lokomotywy z jednym wagonem + iDrivigFlags&=~moveStopHere; //podjeżanie do semaforów zezwolone + if (!iEngineActive) + OrderNext(Prepare_engine); //trzeba odpalić silnik najpierw + if (NewValue2!=0) //jeśli podany jest sprzęg + {iCoupler=floor(fabs(NewValue2)); //jakim sprzęgiem + OrderNext(Connect); //najpierw połącz pojazdy + if (NewValue1>=0.0) //jeśli ilość wagonów inna niż wszystkie + {//to po podpięciu należy się odczepić + iDirectionOrder=-iDirection; //zmiana na ciągnięcie + OrderPush(Change_direction); //najpierw zmień kierunek, bo odczepiamy z tyłu + OrderPush(Disconnect); //a odczep już po zmianie kierunku + } + else if (NewValue2<0.0) //jeśli wszystkie, a sprzęg ujemny, to tylko zmiana kierunku po podczepieniu + {//np. Shunt -1 -3 + iDirectionOrder=-iDirection; //jak się podczepi, to jazda w przeciwną stronę + OrderNext(Change_direction); + } + WaitingTime=0.0; //nie ma co dalej czekać, można zatrąbić i jechać, chyba że już jedzie + } + else //if (NewValue2==0.0) //zerowy sprzęg + if (NewValue1>=0.0) //jeśli ilość wagonów inna niż wszystkie + {//będzie odczepianie, ale jeśli wagony są z przodu, to trzeba najpierw zmienić kierunek + if ((mvOccupied->Couplers[mvOccupied->DirAbsolute>0?1:0].CouplingFlag==0)? //z tyłu nic + (mvOccupied->Couplers[mvOccupied->DirAbsolute>0?0:1].CouplingFlag>0):false) //a z przodu skład + {iDirectionOrder=-iDirection; //zmiana na ciągnięcie + OrderNext(Change_direction); //najpierw zmień kierunek (zastąpi Disconnect) + OrderPush(Disconnect); //a odczep już po zmianie kierunku + } + else + if (mvOccupied->Couplers[mvOccupied->DirAbsolute>0?1:0].CouplingFlag>0) //z tyłu coś + OrderNext(Disconnect); //jak ciągnie, to tylko odczep (NewValue1) wagonów + WaitingTime=0.0; //nie ma co dalej czekać, można zatrąbić i jechać, chyba że już jedzie + } + if (NewValue1==-1.0) + {iDrivigFlags&=~moveStopHere; //ma jechać + WaitingTime=0.0; //nie ma co dalej czekać, można zatrąbić i jechać + } + if (NewValue1<-1.5) //jeśli -2/-3, czyli czekanie z ruszeniem na sygnał + iDrivigFlags|=moveStopHere; //nie podjeżdżać do semafora, jeśli droga nie jest wolna (nie dotyczy Connect) + if (NewValue1<-2.5) //jeśli + OrderNext(Obey_train); //to potem jazda pociągowa + else + OrderNext(Shunt); //to potem manewruj dalej + CheckVehicles(); //sprawdzić światła + //if ((iVehicleCount>=0)&&(NewValue1<0)) WriteLog("Skasowano ilosć wagonów w Shunt!"); + if (NewValue1!=iVehicleCount) + iVehicleCount=floor(NewValue1); //i co potem ? - trzeba zaprogramowac odczepianie +/* + if (NewValue1!=-1.0) + if (NewValue2!=0.0) + + if (VelDesired==0) + SetVelocity(20,0); //to niech jedzie +*/ + } + else if (NewCommand=="Jump_to_first_order") + JumpToFirstOrder(); + else if (NewCommand=="Jump_to_order") + { + if (NewValue1==-1.0) + JumpToNextOrder(); + else + if ((NewValue1>=0)&&(NewValue1 Jump_to_order"); + OrdersDump(); +#endif + } +/* + if (WriteLogFlag) + { + append(AIlogFile); + writeln(AILogFile,ElapsedTime:5:2," - new order: ",Order2Str( OrderList[OrderPos])," @ ",OrderPos); + close(AILogFile); + } +*/ + } +/* //ta komenda jest teraz skanowana, więc wysyłanie jej eventem nie ma sensu + else if (NewCommand=="OutsideStation") //wskaznik W5 + { + if (OrderList[OrderPos]==Obey_train) + SetVelocity(NewValue1,NewValue2,stopOut); //koniec stacji - predkosc szlakowa + else //manewry - zawracaj + { + iDirectionOrder=-iDirection; //zmiana na przeciwny niż obecny + OrderNext(Change_direction); //zmiana kierunku + OrderNext(Shunt); //a dalej manewry + iDrivigFlags&=~moveStartHorn; //bez trąbienia po zatrzymaniu + } + } +*/ + else if (NewCommand=="Warning_signal") + { + if (AIControllFlag) //poniższa komenda nie jest wykonywana przez użytkownika + if (NewValue1>0) + { + fWarningDuration=NewValue1; //czas trąbienia + mvOccupied->WarningSignal=(NewValue2>1)?2:1; //wysokość tonu + } + } + else if (NewCommand=="Radio_channel") + {//wybór kanału radiowego (którego powinien używać AI, ręczny maszynista musi go ustawić sam) + if (NewValue1>=0) //wartości ujemne są zarezerwowane, -1 = nie zmieniać kanału + {iRadioChannel=NewValue1; + if (iGuardRadio) + iGuardRadio=iRadioChannel; //kierownikowi też zmienić + } + //NewValue2 może zawierać dodatkowo oczekiwany kod odpowiedzi, np. dla W29 "nawiązać łączność radiową z dyżurnym ruchu odcinkowym" + } + else return false; //nierozpoznana - wysłać bezpośrednio do pojazdu + return true; //komenda została przetworzona +}; + +void __fastcall TController::PhysicsLog() +{//zapis logu - na razie tylko wypisanie parametrów + if (LogFile.is_open()) + { +#if LOGPRESS==0 + LogFile << ElapsedTime<<" "<WheelDiameter*mvOccupied->nrot)<<" "; + LogFile << mvControlling->AccS<<" "<Couplers[1].Dist<<" "<Couplers[1].CForce<<" "; + LogFile << mvOccupied->Ft<<" "<Ff<<" "<Fb<<" "<BrakePress<<" "; + LogFile << mvOccupied->PipePress<<" "<Im<<" "<MainCtrlPos)<<" "; + LogFile << int(mvControlling->ScndCtrlPos)<<" "<BrakeCtrlPos)<<" "<LocalBrakePos)<<" "; + LogFile << int(mvControlling->ActiveDir)<<" "<CommandIn.Command.c_str()<<" "<CommandIn.Value1<<" "; + LogFile << mvOccupied->CommandIn.Value2<<" "<SecuritySystem.Status)<<" "<SlippingWheels)<<"\r\n"; +#endif +#if LOGPRESS==1 + LogFile << ElapsedTime<<"\t"<WheelDiameter*mvOccupied->nrot)<<"\t"; + LogFile << Controlling->AccS<<"\t"; + LogFile << mvOccupied->PipePress<<"\t"<CntrlPipePress<<"\t"<BrakePress<<"\t"; + LogFile << mvOccupied->Volume<<"\t"<Hamulec->GetCRP()<<"\n"; +#endif + LogFile.flush(); + } +}; + +bool __fastcall TController::UpdateSituation(double dt) +{//uruchamiać przynajmniej raz na sekundę + if ((iDrivigFlags&movePrimary)==0) return true; //pasywny nic nie robi + double AbsAccS; + //double VelReduced; //o ile km/h może przekroczyć dozwoloną prędkość bez hamowania + bool UpdateOK=false; + if (AIControllFlag) + {//yb: zeby EP nie musial sie bawic z ciesnieniem w PG +// if (mvOccupied->BrakeSystem==ElectroPneumatic) +// mvOccupied->PipePress=0.5; //yB: w SPKS są poprawnie zrobione pozycje + if (mvControlling->SlippingWheels) + { + mvControlling->SandDoseOn(); //piasku! + //Controlling->SlippingWheels=false; //a to tu nie ma sensu, flaga używana w dalszej części + } + } + //ABu-160305 testowanie gotowości do jazdy + //Ra: przeniesione z DynObj, skład użytkownika też jest testowany, żeby mu przekazać, że ma odhamować + Ready=true; //wstępnie gotowy + fReady=0.0; //założenie, że odhamowany + fAccGravity=0.0; //przyspieszenie wynikające z pochylenia + double dy; //składowa styczna grawitacji, w przedziale <0,1> + TDynamicObject *p=pVehicles[0]; //pojazd na czole składu + while (p) + {//sprawdzenie odhamowania wszystkich połączonych pojazdów + if (Ready) //bo jak coś nie odhamowane, to dalej nie ma co sprawdzać + //if (p->MoverParameters->BrakePress>=0.03*p->MoverParameters->MaxBrakePress) + if (p->MoverParameters->BrakePress>=0.4) //wg UIC określone sztywno na 0.04 + {Ready=false; //nie gotowy + //Ra: odluźnianie przeładowanych lokomotyw, ciągniętych na zimno - prowizorka... + if (AIControllFlag) //skład jak dotąd był wyluzowany + {if (mvOccupied->BrakeCtrlPos==0) //jest pozycja jazdy + if ((p->MoverParameters->PipePress-5.0)>-0.1) //jeśli ciśnienie jak dla jazdy + if (p->MoverParameters->Hamulec->GetCRP()>p->MoverParameters->PipePress+0.12) //za dużo w zbiorniku + p->MoverParameters->BrakeReleaser(1); //indywidualne luzowanko + if (p->MoverParameters->Power>0.01) //jeśli ma silnik + if (p->MoverParameters->FuseFlag) //wywalony nadmiarowy + Need_TryAgain=true; //reset jak przy wywaleniu nadmiarowego + } + } + if (fReadyMoverParameters->BrakePress) + fReady=p->MoverParameters->BrakePress; //szukanie najbardziej zahamowanego + if ((dy=p->VectorFront().y)!=0.0) //istotne tylko dla pojazdów na pochyleniu + fAccGravity-=p->DirectionGet()*p->MoverParameters->TotalMassxg*dy; //ciężar razy składowa styczna grawitacji + p=p->Next(); //pojazd podłączony z tyłu (patrząc od czoła) + } + if (iDirection) + fAccGravity/=iDirection*fMass; //siłę generują pojazdy na pochyleniu ale działa ona całość składu, więc a=F/m + if (!Ready) //v367: jeśli wg powyższych warunków skład nie jest odhamowany + if (fAccGravity<-0.05) //jeśli ma pod górę na tyle, by się stoczyć + //if (mvOccupied->BrakePress<0.08) //to wystarczy, że zadziałają liniowe (nie ma ich jeszcze!!!) + if (fReady<0.8) //delikatniejszy warunek, obejmuje wszystkie wagony + Ready=true; //żeby uznać za odhamowany + HelpMeFlag=false; + //Winger 020304 + if (AIControllFlag) + { + if (mvControlling->EnginePowerSource.SourceType==CurrentCollector) + { + if (mvOccupied->ScndPipePress>4.3) //gdy główna sprężarka bezpiecznie nabije ciśnienie + mvControlling->bPantKurek3=true; //to można przestawić kurek na zasilanie pantografów z głównej pneumatyki + fVoltage=0.5*(fVoltage+fabs(mvControlling->RunningTraction.TractionVoltage)); //uśrednione napięcie sieci: przy spadku poniżej wartości minimalnej opóźnić rozruch o losowy czas + if (fVoltageEnginePowerSource.CollectorParameters.MinV) //gdy rozłączenie WS z powodu niskiego napięcia + if (fActionTime>=0) //jeśli czas oczekiwania nie został ustawiony + fActionTime=-2-random(10); //losowy czas oczekiwania przed ponownym załączeniem jazdy + } + if (mvOccupied->Vel>0.0) + {//jeżeli jedzie + if (iDrivigFlags&moveDoorOpened) //jeśli drzwi otwarte + if (mvOccupied->Vel>1.0) //nie zamykać drzwi przy drganiach, bo zatrzymanie na W4 akceptuje niewielkie prędkości + Doors(false); + //przy prowadzeniu samochodu trzeba każdą oś odsuwać oddzielnie, inaczej kicha wychodzi + if (mvOccupied->CategoryFlag&2) //jeśli samochód + //if (fabs(mvOccupied->OffsetTrackH)Dim.W) //Ra: szerokość drogi tu powinna być? + if (!mvOccupied->ChangeOffsetH(-0.01*mvOccupied->Vel*dt)) //ruch w poprzek drogi + mvOccupied->ChangeOffsetH(0.01*mvOccupied->Vel*dt); //Ra: co to miało być, to nie wiem + if (mvControlling->EnginePowerSource.SourceType==CurrentCollector) + { + if ((fOverhead2>=0.0)||iOverheadZero) + {//jeśli jazda bezprądowa albo z opuszczonym pantografem + while (DecSpeed(true)); //zerowanie napędu + } + if ((fOverhead2>0.0)||iOverheadDown) + {//jazda z opuszczonymi pantografami + mvControlling->PantFront(false); + mvControlling->PantRear(false); + } + else + {//jeśli nie trzeba opuszczać pantografów + if (iDirection>=0) //jak jedzie w kierunku sprzęgu 0 + mvControlling->PantRear(true); //jazda na tylnym + else + mvControlling->PantFront(true); + } + if (mvOccupied->Vel>10) //opuszczenie przedniego po rozpędzeniu się + { + if (mvControlling->EnginePowerSource.CollectorParameters.CollectorsNo>1) //o ile jest więcej niż jeden + if (iDirection>=0) //jak jedzie w kierunku sprzęgu 0 + {//poczekać na podniesienie tylnego + if (mvControlling->PantRearVolt!=0.0) //czy jest napięcie zasilające na tylnym? + mvControlling->PantFront(false); //opuszcza od sprzęgu 0 + } + else + {//poczekać na podniesienie przedniego + if (mvControlling->PantFrontVolt!=0.0) //czy jest napięcie zasilające na przednim? + mvControlling->PantRear(false); //opuszcza od sprzęgu 1 + } + } + } + } + if (iDrivigFlags&moveStartHornNow) //czy ma zatrąbić przed ruszeniem? + if (Ready) //gotów do jazdy + if (iEngineActive) //jeszcze się odpalić musi + if (fStopTime>=0) //i nie musi czekać + {//uruchomienie trąbienia + fWarningDuration=0.3; //czas trąbienia + //if (AIControllFlag) //jak siedzi krasnoludek, to włączy trąbienie + mvOccupied->WarningSignal=pVehicle->iHornWarning; //wysokość tonu (2=wysoki) + iDrivigFlags|=moveStartHornDone; //nie trąbić aż do ruszenia + iDrivigFlags&=~moveStartHornNow; //trąbienie zostało zorganizowane + } + } + ElapsedTime+=dt; + WaitingTime+=dt; + fBrakeTime-=dt; //wpisana wartość jest zmniejszana do 0, gdy ujemna należy zmienić nastawę hamulca + fStopTime+=dt; //zliczanie czasu postoju, nie ruszy dopóki ujemne + fActionTime+=dt; //czas używany przy regulacji prędkości i zamykaniu drzwi + if (WriteLogFlag) + { + if (LastUpdatedTime>deltalog) + {//zapis do pliku DAT + PhysicsLog(); + if (fabs(mvOccupied->V)>0.1) //Ra: [m/s] + deltalog=0.05;//0.2; + else deltalog=0.05;//1.0; + LastUpdatedTime=0.0; + } + else + LastUpdatedTime=LastUpdatedTime+dt; + } + //Ra: skanowanie również dla prowadzonego ręcznie, aby podpowiedzieć prędkość + if ((LastReactionTime>Min0R(ReactionTime,2.0))) + { + //Ra: nie wiem czemu ReactionTime potrafi dostać 12 sekund, to jest przegięcie, bo przeżyna STÓJ + //yB: otóż jest to jedna trzecia czasu napełniania na towarowym; może się przydać przy wdrażaniu hamowania, żeby nie ruszało kranem jak głupie + //Ra: ale nie może się budzić co pół minuty, bo przeżyna semafory + //Ra: trzeba by tak: + // 1. Ustalić istotną odległość zainteresowania (np. 3×droga hamowania z V.max). + fBrakeDist=fDriverBraking*mvOccupied->Vel*(40.0+mvOccupied->Vel); //przybliżona droga hamowania + //dla hamowania -0.2 [m/ss] droga wynosi 0.389*Vel*Vel [km/h], czyli 600m dla 40km/h, 3.8km dla 100km/h i 9.8km dla 160km/h + //dla hamowania -0.4 [m/ss] droga wynosi 0.096*Vel*Vel [km/h], czyli 150m dla 40km/h, 1.0km dla 100km/h i 2.5km dla 160km/h + //ogólnie droga hamowania przy stałym opóźnieniu to Vel*Vel/(3.6*3.6*a) [m] + //fBrakeDist powinno być wyznaczane dla danego składu za pomocą sieci neuronowych, w zależności od prędkości i siły (ciśnienia) hamowania + //następnie w drugą stronę, z drogi hamowania i chwilowej prędkości powinno być wyznaczane zalecane ciśnienie + if (fMass>1000000.0) fBrakeDist*=2.0; //korekta dla ciężkich, bo przeżynają - da to coś? + if (mvOccupied->BrakeDelayFlag==bdelay_G) fBrakeDist=fBrakeDist+2*mvOccupied->Vel; //dla nastawienia G koniecznie należy wydłużyć drogę na czas reakcji + //double scanmax=(mvOccupied->Vel>0.0)?3*fDriverDist+fBrakeDist:10.0*fDriverDist; + double scanmax=(mvOccupied->Vel>5.0)?400+fBrakeDist:50.0*fDriverDist; //1000m dla stojących pociągów; Ra 2015-01: przy dłuższej drodze skanowania AI jeździ spokojniej + // 2. Sprawdzić, czy tabelka pokrywa założony odcinek (nie musi, jeśli jest STOP). + // 3. Sprawdzić, czy trajektoria ruchu przechodzi przez zwrotnice - jeśli tak, to sprawdzić, czy stan się nie zmienił. + // 4. Ewentualnie uzupełnić tabelkę informacjami o sygnałach i ograniczeniach, jeśli się "zużyła". + TableCheck(scanmax); //wypełnianie tabelki i aktualizacja odległości + // 5. Sprawdzić stany sygnalizacji zapisanej w tabelce, wyznaczyć prędkości. + // 6. Z tabelki wyznaczyć krytyczną odległość i prędkość (najmniejsze przyspieszenie). + // 7. Jeśli jest inny pojazd z przodu, ewentualnie skorygować odległość i prędkość. + // 8. Ustalić częstotliwość świadomości AI (zatrzymanie precyzyjne - częściej, brak atrakcji - rzadziej). + if (AIControllFlag) + {//tu bedzie logika sterowania + if (mvOccupied->CommandIn.Command!="") + if (!mvOccupied->RunInternalCommand()) //rozpoznaj komende bo lokomotywa jej nie rozpoznaje + RecognizeCommand(); //samo czyta komendę wstawioną do pojazdu? + if (mvOccupied->SecuritySystem.Status>1) //jak zadziałało CA/SHP + if (!mvOccupied->SecuritySystemReset()) //to skasuj + //if ((TestFlag(mvOccupied->SecuritySystem.Status,s_ebrake))&&(mvOccupied->BrakeCtrlPos==0)&&(AccDesired>0.0)) + if ((TestFlag(mvOccupied->SecuritySystem.Status,s_SHPebrake)||TestFlag(mvOccupied->SecuritySystem.Status,s_CAebrake))&&(mvOccupied->BrakeCtrlPos==0)&&(AccDesired>0.0)) + mvOccupied->BrakeLevelSet(0); //!!! hm, może po prostu normalnie sterować hamulcem? + } + switch (OrderList[OrderPos]) + {//ustalenie prędkości przy doczepianiu i odczepianiu, dystansów w pozostałych przypadkach + case Connect: //podłączanie do składu + if (iDrivigFlags&moveConnect) + {//jeśli stanął już blisko, unikając zderzenia i można próbować podłączyć + fMinProximityDist=-0.01; fMaxProximityDist=0.0; //[m] dojechać maksymalnie + fVelPlus=0.5; //dopuszczalne przekroczenie prędkości na ograniczeniu bez hamowania + fVelMinus=0.5; //margines prędkości powodujący załączenie napędu + if (AIControllFlag) + {//to robi tylko AI, wersję dla człowieka trzeba dopiero zrobić + //sprzęgi sprawdzamy w pierwszej kolejności, bo jak połączony, to koniec + bool ok; //true gdy się podłączy (uzyskany sprzęg będzie zgodny z żądanym) + if (pVehicles[0]->DirectionGet()>0) //jeśli sprzęg 0 + {//sprzęg 0 - próba podczepienia + if (pVehicles[0]->MoverParameters->Couplers[0].Connected) //jeśli jest coś wykryte (a chyba jest, nie?) + if (pVehicles[0]->MoverParameters->Attach(0,2,pVehicles[0]->MoverParameters->Couplers[0].Connected,iCoupler)) + { + //pVehicles[0]->dsbCouplerAttach->SetVolume(DSBVOLUME_MAX); + //pVehicles[0]->dsbCouplerAttach->Play(0,0,0); + } + //WriteLog("CoupleDist[0]="+AnsiString(pVehicles[0]->MoverParameters->Couplers[0].CoupleDist)+", Connected[0]="+AnsiString(pVehicles[0]->MoverParameters->Couplers[0].CouplingFlag)); + ok=(pVehicles[0]->MoverParameters->Couplers[0].CouplingFlag==iCoupler); //udało się? (mogło częściowo) + } + else //if (pVehicles[0]->MoverParameters->DirAbsolute<0) //jeśli sprzęg 1 + {//sprzęg 1 - próba podczepienia + if (pVehicles[0]->MoverParameters->Couplers[1].Connected) //jeśli jest coś wykryte (a chyba jest, nie?) + if (pVehicles[0]->MoverParameters->Attach(1,2,pVehicles[0]->MoverParameters->Couplers[1].Connected,iCoupler)) + { + //pVehicles[0]->dsbCouplerAttach->SetVolume(DSBVOLUME_MAX); + //pVehicles[0]->dsbCouplerAttach->Play(0,0,0); + } + //WriteLog("CoupleDist[1]="+AnsiString(Controlling->Couplers[1].CoupleDist)+", Connected[0]="+AnsiString(Controlling->Couplers[1].CouplingFlag)); + ok=(pVehicles[0]->MoverParameters->Couplers[1].CouplingFlag==iCoupler); //udało się? (mogło częściowo) + } + if (ok) + {//jeżeli został podłączony + iCoupler=0; //dalsza jazda manewrowa już bez łączenia + iDrivigFlags&=~moveConnect; //zdjęcie flagi doczepiania + SetVelocity(0,0,stopJoin); //wyłączyć przyspieszanie + CheckVehicles(); //sprawdzić światła nowego składu + JumpToNextOrder(); //wykonanie następnej komendy + } + else + SetVelocity(2.0,0.0); //jazda w ustawionym kierunku z prędkością 2 (18s) + } //if (AIControllFlag) //koniec zblokowania, bo była zmienna lokalna +/* //Ra 2014-02: lepiej tam, bo jak tam się odźwieży skład, to tu pVehicles[0] będzie czymś innym + else + {//jeśli człowiek ma podłączyć, to czekamy na zmianę stanu sprzęgów na końcach dotychczasowego składu + bool ok; //true gdy się podłączy (uzyskany sprzęg będzie zgodny z żądanym) + if (pVehicles[0]->DirectionGet()>0) //jeśli sprzęg 0 + ok=(pVehicles[0]->MoverParameters->Couplers[0].CouplingFlag>0); //==iCoupler); //udało się? (mogło częściowo) + else //if (pVehicles[0]->MoverParameters->DirAbsolute<0) //jeśli sprzęg 1 + ok=(pVehicles[0]->MoverParameters->Couplers[1].CouplingFlag>0); //==iCoupler); //udało się? (mogło częściowo) + if (ok) + {//jeżeli został podłączony + iDrivigFlags&=~moveConnect; //zdjęcie flagi doczepiania + JumpToNextOrder(); //wykonanie następnej komendy + } + } +*/ + } + else + {//jak daleko, to jazda jak dla Shunt na kolizję + fMinProximityDist=0.0; fMaxProximityDist=5.0; //[m] w takim przedziale odległości powinien stanąć + fVelPlus=2.0; //dopuszczalne przekroczenie prędkości na ograniczeniu bez hamowania + fVelMinus=1.0; //margines prędkości powodujący załączenie napędu + //VelReduced=5; //[km/h] + //if (mvOccupied->Vel<0.5) //jeśli już prawie stanął + if (pVehicles[0]->fTrackBlock<=20.0) //przy zderzeniu fTrackBlock nie jest miarodajne + iDrivigFlags|=moveConnect; //początek podczepiania, z wyłączeniem sprawdzania fTrackBlock + } + break; + case Disconnect: //20.07.03 - manewrowanie wagonami + fMinProximityDist=1.0; fMaxProximityDist=10.0; //[m] + fVelPlus=1.0; //dopuszczalne przekroczenie prędkości na ograniczeniu bez hamowania + fVelMinus=0.5; //margines prędkości powodujący załączenie napędu + if (AIControllFlag) + {if (iVehicleCount>=0) //jeśli była podana ilość wagonów + { + if (iDrivigFlags&movePress) //jeśli dociskanie w celu odczepienia + {//3. faza odczepiania. + SetVelocity(2,0); //jazda w ustawionym kierunku z prędkością 2 + if ((mvControlling->MainCtrlPos>0)||(mvOccupied->BrakeSystem==ElectroPneumatic)) //jeśli jazda + { + //WriteLog("Odczepianie w kierunku "+AnsiString(mvOccupied->DirAbsolute)); + TDynamicObject *p=pVehicle; //pojazd do odczepienia, w (pVehicle) siedzi AI + int d; //numer sprzęgu, który sprawdzamy albo odczepiamy + int n=iVehicleCount; //ile wagonów ma zostać + do + {//szukanie pojazdu do odczepienia + d=p->DirectionGet()>0?0:1; //numer sprzęgu od strony czoła składu + //if (p->MoverParameters->Couplers[d].CouplerType==Articulated) //jeśli sprzęg typu wózek (za mało) + if (p->MoverParameters->Couplers[d].CouplingFlag&ctrain_depot) //jeżeli sprzęg zablokowany + //if (p->GetTrack()->) //a nie stoi na torze warsztatowym (ustalić po czym poznać taki tor) + ++n; //to liczymy człony jako jeden + p->MoverParameters->BrakeReleaser(1); //wyluzuj pojazd, aby dało się dopychać + p->MoverParameters->BrakeLevelSet(0); //hamulec na zero, aby nie hamował + if (n) + {//jeśli jeszcze nie koniec + p=p->Prev(); //kolejny w stronę czoła składu (licząc od tyłu), bo dociskamy + if (!p) iVehicleCount=-2,n=0; //nie ma co dalej sprawdzać, doczepianie zakończone + } + } while (n--); + if (p?p->MoverParameters->Couplers[d].CouplingFlag==0:true) + iVehicleCount=-2; //odczepiono, co było do odczepienia + else + if (!p->Dettach(d)) //zwraca maskę bitową połączenia; usuwa własność pojazdów + {//tylko jeśli odepnie + //WriteLog("Odczepiony od strony "); + iVehicleCount=-2; + } //a jak nie, to dociskać dalej + } + if (iVehicleCount>=0) //zmieni się po odczepieniu + if (!mvOccupied->DecLocalBrakeLevel(1)) + {//dociśnij sklad + //WriteLog("Dociskanie"); + //mvOccupied->BrakeReleaser(); //wyluzuj lokomotywę + //Ready=true; //zamiast sprawdzenia odhamowania całego składu + IncSpeed(); //dla (Ready)==false nie ruszy + } + } + if ((mvOccupied->Vel==0.0)&&!(iDrivigFlags&movePress)) + {//2. faza odczepiania: zmień kierunek na przeciwny i dociśnij + //za radą yB ustawiamy pozycję 3 kranu (ruszanie kranem w innych miejscach powino zostać wyłączone) + //WriteLog("Zahamowanie składu"); + //while ((mvOccupied->BrakeCtrlPos>3)&&mvOccupied->DecBrakeLevel()); + //while ((mvOccupied->BrakeCtrlPos<3)&&mvOccupied->IncBrakeLevel()); + mvOccupied->BrakeLevelSet(mvOccupied->BrakeSystem==ElectroPneumatic?1:3); + double p=mvOccupied->BrakePressureActual.PipePressureVal; //tu może być 0 albo -1 nawet + if (p<3.9) p=3.9; //TODO: zabezpieczenie przed dziwnymi CHK do czasu wyjaśnienia sensu 0 oraz -1 w tym miejscu + if (mvOccupied->BrakeSystem==ElectroPneumatic?mvOccupied->BrakePress>2:mvOccupied->PipePressBrakeSystem==ElectroPneumatic) + mvOccupied->BrakeLevelSet(0); //wyłączenie EP, gdy wystarczy (może nie być potrzebne, bo na początku jest) + //WriteLog("Luzowanie lokomotywy i zmiana kierunku"); + mvOccupied->BrakeReleaser(1); //wyluzuj lokomotywę; a ST45? + mvOccupied->DecLocalBrakeLevel(10); //zwolnienie hamulca + iDrivigFlags|=movePress; //następnie będzie dociskanie + DirectionForward(mvOccupied->ActiveDir<0); //zmiana kierunku jazdy na przeciwny (dociskanie) + CheckVehicles(); //od razu zmienić światła (zgasić) - bez tego się nie odczepi + fStopTime=0.0; //nie ma na co czekać z odczepianiem + } + } + } //odczepiania + else //to poniżej jeśli ilość wagonów ujemna + if (iDrivigFlags&movePress) + {//4. faza odczepiania: zwolnij i zmień kierunek + SetVelocity(0,0,stopJoin); //wyłączyć przyspieszanie + if (!DecSpeed()) //jeśli już bardziej wyłączyć się nie da + {//ponowna zmiana kierunku + //WriteLog("Ponowna zmiana kierunku"); + DirectionForward(mvOccupied->ActiveDir<0); //zmiana kierunku jazdy na właściwy + iDrivigFlags&=~movePress; //koniec dociskania + JumpToNextOrder(); //zmieni światła + TableClear(); //skanowanie od nowa + iDrivigFlags&=~moveStartHorn; //bez trąbienia przed ruszeniem + SetVelocity(fShuntVelocity,fShuntVelocity); //ustawienie prędkości jazdy + } + } + } + break; + case Shunt: + //na jaką odleglość i z jaką predkością ma podjechać + fMinProximityDist=2.0; fMaxProximityDist=4.0; //[m] + fVelPlus=2.0; //dopuszczalne przekroczenie prędkości na ograniczeniu bez hamowania + fVelMinus=3.0; //margines prędkości powodujący załączenie napędu + if (fVelMinus>0.1*fShuntVelocity) + fVelMinus=0.1*fShuntVelocity; //były problemy z jazdą np. 3km/h podczas ładowania wagonów + break; + case Obey_train: + //na jaka odleglosc i z jaka predkoscia ma podjechac do przeszkody + if (mvOccupied->CategoryFlag&1) //jeśli pociąg + { + fMinProximityDist=10.0; + fMaxProximityDist=(mvOccupied->Vel>0.0)?20.0:50.0; //[m] jak stanie za daleko, to niech nie dociąga paru metrów + if (iDrivigFlags&moveLate) + {fVelMinus=1.0; //jeśli spóźniony, to gna + fVelPlus=5.0; //dopuszczalne przekroczenie prędkości na ograniczeniu bez hamowania + } + else + {//gdy nie musi się sprężać + fVelMinus=int(0.05*VelDesired); //margines prędkości powodujący załączenie napędu + if (fVelMinus>5.0) fVelMinus=5.0; + else if (fVelMinus<1.0) fVelMinus=1.0; //żeby nie ruszał przy 0.1 + fVelPlus=int(0.5+0.05*VelDesired); //normalnie dopuszczalne przekroczenie to 5% prędkości + if (fVelPlus>5.0) fVelPlus=5.0; //ale nie więcej niż 5km/h + } + } + else //samochod (sokista też) + { + fMinProximityDist=7.0; fMaxProximityDist=10.0; //[m] + fVelPlus=10.0; //dopuszczalne przekroczenie prędkości na ograniczeniu bez hamowania + fVelMinus=2.0; //margines prędkości powodujący załączenie napędu + } + //VelReduced=4; //[km/h] + break; + default: + fMinProximityDist=0.01; fMaxProximityDist=2.0; //[m] + fVelPlus=2.0; //dopuszczalne przekroczenie prędkości na ograniczeniu bez hamowania + fVelMinus=5.0; //margines prędkości powodujący załączenie napędu + } //switch + switch (OrderList[OrderPos]) + {//co robi maszynista + case Prepare_engine: //odpala silnik + //if (AIControllFlag) + if (PrepareEngine()) //dla użytkownika tylko sprawdza, czy uruchomił + {//gotowy do drogi? + SetDriverPsyche(); + //OrderList[OrderPos]:=Shunt; //Ra: to nie może tak być, bo scenerie robią Jump_to_first_order i przechodzi w manewrowy + JumpToNextOrder(); //w następnym jest Shunt albo Obey_train, moze też być Change_direction, Connect albo Disconnect + //if OrderList[OrderPos]<>Wait_for_Orders) + // if BrakeSystem=Pneumatic) //napelnianie uderzeniowe na wstepie + // if BrakeSubsystem=Oerlikon) + // if (BrakeCtrlPos=0)) + // DecBrakeLevel; + } + break; + case Release_engine: + if (ReleaseEngine()) //zdana maszyna? + JumpToNextOrder(); + break; + case Jump_to_first_order: + if (OrderPos>1) + OrderPos=1; //w zerowym zawsze jest czekanie + else + ++OrderPos; +#if LOGORDERS + WriteLog("--> Jump_to_first_order"); + OrdersDump(); +#endif + break; + case Wait_for_orders: //jeśli czeka, też ma skanować, żeby odpalić się od semafora +/* + if ((mvOccupied->ActiveDir!=0)) + {//jeśli jest wybrany kierunek jazdy, można ustalić prędkość jazdy + VelDesired=fVelMax; //wstępnie prędkość maksymalna dla pojazdu(-ów), będzie następnie ograniczana + SetDriverPsyche(); //ustawia AccPreferred (potrzebne tu?) + //Ra: odczyt (ActualProximityDist), (VelNext) i (AccPreferred) z tabelki prędkosci + AccDesired=AccPreferred; //AccPreferred wynika z osobowości mechanika + VelNext=VelDesired; //maksymalna prędkość wynikająca z innych czynników niż trajektoria ruchu + ActualProximityDist=scanmax; //funkcja Update() może pozostawić wartości bez zmian + //hm, kiedyś semafory wysyłały SetVelocity albo ShuntVelocity i ustawły tak VelSignal - a teraz jak to zrobić? + TCommandType comm=TableUpdate(mvOccupied->Vel,VelDesired,ActualProximityDist,VelNext,AccDesired); //szukanie optymalnych wartości + } +*/ + //break; + case Shunt: + case Obey_train: + case Connect: + case Disconnect: + case Change_direction: //tryby wymagające jazdy + case Change_direction|Shunt: //zmiana kierunku podczas manewrów + case Change_direction|Connect: //zmiana kierunku podczas podłączania + if (OrderList[OrderPos]!=Obey_train) //spokojne manewry + { + VelSignal=Min0R(VelSignal,40); //jeśli manewry, to ograniczamy prędkość + if (AIControllFlag) + {//to poniżej tylko dla AI + if (iVehicleCount>=0) //jeśli jest co odczepić + if (!(iDrivigFlags&movePress)) + if (mvOccupied->Vel>0.0) + if (!iCoupler) //jeśli nie ma wcześniej potrzeby podczepienia + {SetVelocity(0,0,stopJoin); //1. faza odczepiania: zatrzymanie + //WriteLog("Zatrzymanie w celu odczepienia"); + } + } + } + else + SetDriverPsyche(); //Ra: było w PrepareEngine(), potrzebne tu? + //no albo przypisujemy -WaitingExpireTime, albo porównujemy z WaitingExpireTime + //if ((VelSignal==0.0)&&(WaitingTime>WaitingExpireTime)&&(mvOccupied->RunningTrack.Velmax!=0.0)) + if (OrderList[OrderPos]&(Shunt|Obey_train|Connect)) //odjechać sam może tylko jeśli jest w trybie jazdy + {//automatyczne ruszanie po odstaniu albo spod SBL + if ((VelSignal==0.0)&&(WaitingTime>0.0)&&(mvOccupied->RunningTrack.Velmax!=0.0)) + {//jeśli stoi, a upłynął czas oczekiwania i tor ma niezerową prędkość +/* + if (WriteLogFlag) + { + append(AIlogFile); + writeln(AILogFile,ElapsedTime:5:2,": ",Name," V=0 waiting time expired! (",WaitingTime:4:1,")"); + close(AILogFile); + } +*/ + if ((OrderList[OrderPos]&(Obey_train|Shunt))?(iDrivigFlags&moveStopHere):false) + WaitingTime=-WaitingExpireTime; //zakaz ruszania z miejsca bez otrzymania wolnej drogi + else if (mvOccupied->CategoryFlag&1) + {//jeśli pociąg + if (AIControllFlag) + {PrepareEngine(); //zmieni ustawiony kierunek + SetVelocity(20,20); //jak się nastał, to niech jedzie 20km/h + WaitingTime=0.0; + fWarningDuration=1.5; //a zatrąbić trochę + mvOccupied->WarningSignal=1; + } + else + SetVelocity(20,20); //użytkownikowi zezwalamy jechać + } + else + {//samochód ma stać, aż dostanie odjazd, chyba że stoi przez kolizję + if (eStopReason==stopBlock) + if (pVehicles[0]->fTrackBlock>fDriverDist) + if (AIControllFlag) + {PrepareEngine(); //zmieni ustawiony kierunek + SetVelocity(-1,-1); //jak się nastał, to niech jedzie + WaitingTime=0.0; + } + else + SetVelocity(-1,-1); //użytkownikowi pozwalamy jechać (samochodem?) + } + } + else if ((VelSignal==0.0)&&(VelNext>0.0)&&(mvOccupied->Vel<1.0)) + if (iCoupler?true:(iDrivigFlags&moveStopHere)==0) //Ra: tu jest coś nie tak, bo bez tego warunku ruszało w manewrowym !!!! + SetVelocity(VelNext,VelNext,stopSem); //omijanie SBL + } //koniec samoistnego odjeżdżania + if (AIControllFlag) + if ((HelpMeFlag)||(mvControlling->DamageFlag>0)) + { + HelpMeFlag=false; +/* + if (WriteLogFlag) + with Controlling do + { + append(AIlogFile); + writeln(AILogFile,ElapsedTime:5:2,": ",Name," HelpMe! (",DamageFlag,")"); + close(AILogFile); + } +*/ + } + if (AIControllFlag) + if (OrderList[OrderPos]&Change_direction) //może być zmieszane z jeszcze jakąś komendą + {//sprobuj zmienic kierunek + SetVelocity(0,0,stopDir); //najpierw trzeba się zatrzymać + if (mvOccupied->Vel<0.1) + {//jeśli się zatrzymał, to zmieniamy kierunek jazdy, a nawet kabinę/człon + Activation(); //ustawienie zadanego wcześniej kierunku i ewentualne przemieszczenie AI + PrepareEngine(); + JumpToNextOrder(); //następnie robimy, co jest do zrobienia (Shunt albo Obey_train) + if (OrderList[OrderPos]&(Shunt|Connect)) //jeśli dalej mamy manewry + if ((iDrivigFlags&moveStopHere)==0) //o ile nie stać w miejscu + {//jechać od razu w przeciwną stronę i nie trąbić z tego tytułu + iDrivigFlags&=~moveStartHorn; //bez trąbienia przed ruszeniem + SetVelocity(fShuntVelocity,fShuntVelocity); //to od razu jedziemy + } + //iDrivigFlags|=moveStartHorn; //a później już można trąbić +/* + if (WriteLogFlag) + { + append(AIlogFile); + writeln(AILogFile,ElapsedTime:5:2,": ",Name," Direction changed!"); + close(AILogFile); + } +*/ + } + //else + // VelSignal:=0.0; //na wszelki wypadek niech zahamuje + } //Change_direction (tylko dla AI) + //ustalanie zadanej predkosci + if (AIControllFlag) //jeśli prowadzi AI + if (!iEngineActive) //jeśli silnik nie odpalony, to próbować naprawić + if (OrderList[OrderPos]&(Change_direction|Connect|Disconnect|Shunt|Obey_train)) //jeśli coś ma robić + PrepareEngine(); //to niech odpala do skutku + if (iDrivigFlags&moveActive) //jeśli może skanować sygnały i reagować na komendy + {//jeśli jest wybrany kierunek jazdy, można ustalić prędkość jazdy + //Ra: tu by jeszcze trzeba było wstawić uzależnienie (VelDesired) od odległości od przeszkody + // no chyba żeby to uwzgldnić już w (ActualProximityDist) + VelDesired=fVelMax; //wstępnie prędkość maksymalna dla pojazdu(-ów), będzie następnie ograniczana + if (TrainParams) //jeśli ma rozkład + if (TrainParams->TTVmax>0.0) //i ograniczenie w rozkładzie + VelDesired=Min0R(VelDesired,TrainParams->TTVmax); //to nie przekraczać rozkladowej + SetDriverPsyche(); //ustawia AccPreferred (potrzebne tu?) + //Ra: odczyt (ActualProximityDist), (VelNext) i (AccPreferred) z tabelki prędkosci + AccDesired=AccPreferred; //AccPreferred wynika z osobowości mechanika + VelNext=VelDesired; //maksymalna prędkość wynikająca z innych czynników niż trajektoria ruchu + ActualProximityDist=scanmax; //funkcja Update() może pozostawić wartości bez zmian + //hm, kiedyś semafory wysyłały SetVelocity albo ShuntVelocity i ustawły tak VelSignal - a teraz jak to zrobić? + TCommandType comm=TableUpdate(VelDesired,ActualProximityDist,VelNext,AccDesired); //szukanie optymalnych wartości + //if (VelSignal!=VelDesired) //jeżeli prędkość zalecana jest inna (ale tryb też może być inny) + switch (comm) + {//ustawienie VelSignal - trochę proteza = do przemyślenia + case cm_Ready: //W4 zezwolił na jazdę + TableCheck(scanmax); //ewentualne doskanowanie trasy za W4, który zezwolił na jazdę + TableUpdate(VelDesired,ActualProximityDist,VelNext,AccDesired); //aktualizacja po skanowaniu + //if (comm!=cm_SetVelocity) //jeśli dalej jest kolejny W4, to ma zwrócić cm_SetVelocity + if (VelNext==0.0) break; //ale jak coś z przodu zamyka, to ma stać + if (iDrivigFlags&moveStopCloser) + VelSignal=VelDesired; //niech jedzie, jak W4 puściło - nie, ma czekać na sygnał z sygnalizatora! + case cm_SetVelocity: //od wersji 357 semafor nie budzi wyłączonej lokomotywy + if (!(OrderList[OrderPos]&~(Obey_train|Shunt))) //jedzie w dowolnym trybie albo Wait_for_orders + if (fabs(VelSignal)>=1.0) //0.1 nie wysyła się do samochodow, bo potem nie ruszą + PutCommand("SetVelocity",VelSignal,VelNext,NULL); //komenda robi dodatkowe operacje + break; + case cm_ShuntVelocity: //od wersji 357 Tm nie budzi wyłączonej lokomotywy + if (!(OrderList[OrderPos]&~(Obey_train|Shunt))) //jedzie w dowolnym trybie albo Wait_for_orders + PutCommand("ShuntVelocity",VelSignal,VelNext,NULL); + else if (iCoupler) //jeśli jedzie w celu połączenia + SetVelocity(VelSignal,VelNext); + break; + case cm_Command: //komenda z komórki + if (!(OrderList[OrderPos]&~(Obey_train|Shunt))) //jedzie w dowolnym trybie albo Wait_for_orders + if (mvOccupied->Vel<0.1) //dopiero jak stanie + //iDrivigFlags|=moveStopHere moveStopCloser) //chyba że stanął za daleko (SU46 w WK staje za daleko) + {PutCommand(eSignNext->CommandGet(),eSignNext->ValueGet(1),eSignNext->ValueGet(2),NULL); + eSignNext->StopCommandSent(); //się wykonało już + } + break; + } + if (VelNext==0.0) + if (!(OrderList[OrderPos]&~(Shunt|Connect))) //jedzie w Shunt albo Connect, albo Wait_for_orders + {//jeżeli wolnej drogi nie ma, a jest w trybie manewrowym albo oczekiwania + //if ((OrderList[OrderPos]&Connect)?pVehicles[0]->fTrackBlock>ActualProximityDist:true) //pomiar odległości nie działa dobrze? + //w trybie Connect skanować do tyłu tylko jeśli przed kolejnym sygnałem nie ma taboru do podłączenia + //Ra 2F1H: z tym (fTrackBlock) to nie jest najlepszy pomysł, bo lepiej by było porównać z odległością od sygnalizatora z przodu + if ((OrderList[OrderPos]|Connect)?pVehicles[0]->fTrackBlock>2000:true) + if ((comm=BackwardScan())!=cm_Unknown) //jeśli w drugą można jechać + {//należy sprawdzać odległość od znalezionego sygnalizatora, + //aby w przypadku prędkości 0.1 wyciągnąć najpierw skład za sygnalizator + //i dopiero wtedy zmienić kierunek jazdy, oczekując podania prędkości >0.5 + if (comm==cm_Command) //jeśli komenda Shunt + iDrivigFlags|=moveStopHere; //to ją odbierz bez przemieszczania się (np. odczep wagony po dopchnięciu do końca toru) + iDirectionOrder=-iDirection; //zmiana kierunku jazdy + OrderList[OrderPos]=TOrders(OrderList[OrderPos]|Change_direction); //zmiana kierunku bez psucia kolejnych komend + } + } + double vel=mvOccupied->Vel; //prędkość w kierunku jazdy + if (iDirection*mvOccupied->V<0) vel=-vel; //ujemna, gdy jedzie w przeciwną stronę, niż powinien + if (VelDesired<0.0) VelDesired=fVelMax; //bo VelDesired<0 oznacza prędkość maksymalną + //Ra: jazda na widoczność + if (pVehicles[0]->fTrackBlock<1000.0) //przy 300m stał z zapamiętaną kolizją + {//Ra 2F3F: przy jeździe pociągowej nie powinien dojeżdżać do poprzedzającego składu + if ((mvOccupied->CategoryFlag&1)?((OrderCurrentGet()&(Connect|Obey_train))==Obey_train):false) //jeśli jesteśmy pociągiem a jazda pociągowa i nie ściąganie ze szlaku + {pVehicles[0]->ABuScanObjects(pVehicles[0]->DirectionGet(),1000.0); //skanowanie sprawdzające + //Ra 2F3F: i jest problem, jak droga za semaforem kieruje na jakiś pojazd (np. w Skwarkach na ET22) + if (pVehicles[0]->fTrackBlock<1000.0) //i jeśli nadal coś jest + if (VelNext!=0.0) //a następny sygnał zezwala na jazdę + if (pVehicles[0]->fTrackBlockABuScanObjects(pVehicles[0]->DirectionGet(),300.0); //skanowanie sprawdzające + } + //if (mvOccupied->Vel>=0.1) //o ile jedziemy; jak stoimy to też trzeba jakoś zatrzymywać + if ((iDrivigFlags&moveConnect)==0) //przy końcówce podłączania nie hamować + {//sprawdzenie jazdy na widoczność + TCoupling *c=pVehicles[0]->MoverParameters->Couplers+(pVehicles[0]->DirectionGet()>0?0:1); //sprzęg z przodu składu + if (c->Connected) //a mamy coś z przodu + if (c->CouplingFlag==0) //jeśli to coś jest podłączone sprzęgiem wirtualnym + {//wyliczanie optymalnego przyspieszenia do jazdy na widoczność + double k=c->Connected->Vel; //prędkość pojazdu z przodu (zakładając, że jedzie w tę samą stronę!!!) + if (kfTrackBlock-0.5*vel-fMaxProximityDist; //odległość bezpieczna zależy od prędkości + if (d<0) //jeśli odległość jest zbyt mała + {//AccPreferred=-0.9; //hamowanie maksymalne, bo jest za blisko + if (k<10.0) //k - prędkość tego z przodu + {//jeśli tamten porusza się z niewielką prędkością albo stoi + if (OrderCurrentGet()&Connect) + {//jeśli spinanie, to jechać dalej + AccPreferred=0.2; //nie hamuj + VelNext=VelDesired=2.0; //i pakuj się na tamtego + } + else //a normalnie to hamować + {AccPreferred=-1.0; //to hamuj maksymalnie + VelNext=VelDesired=0.0; //i nie pakuj się na tamtego + } + } + else //jeśli oba jadą, to przyhamuj lekko i ogranicz prędkość + {if (kfAccThreshold) AccPreferred=fAccThreshold; //to przyhamuj troszkę + VelNext=VelDesired=int(k); //to chyba już sobie dohamuje według uznania + } + } + ReactionTime=0.1; //orientuj się, bo jest goraco + } + else + {//jeśli odległość jest większa, ustalić maksymalne możliwe przyspieszenie (hamowanie) + k=(k*k-vel*vel)/(25.92*d); //energia kinetyczna dzielona przez masę i drogę daje przyspieszenie + if (k>0.0) k*=1.5; //jedź szybciej, jeśli możesz + //double ak=(c->Connected->V>0?1.0:-1.0)*c->Connected->AccS; //przyspieszenie tamtego + if (dc->Connected->Vel) + {VelNext=c->Connected->Vel; //ograniczenie do prędkości tamtego + ActualProximityDist=d; //i odległość od tamtego jest istotniejsza + } + ReactionTime=0.2; //zwiększ czujność + } +#if LOGVELOCITY + WriteLog("Collision: AccPreferred="+AnsiString(k)); +#endif + } + } + } + } + //sprawdzamy możliwe ograniczenia prędkości + if (OrderCurrentGet()&(Shunt|Obey_train)) //w Connect nie, bo moveStopHere odnosi się do stanu po połączeniu + if (iDrivigFlags&moveStopHere) //jeśli ma czekać na wolną drogę + if (vel==0.0) //a stoi + if (VelNext==0.0) //a wyjazdu nie ma + VelDesired=0.0; //to ma stać + if (fStopTime<0) //czas postoju przed dalszą jazdą (np. na przystanku) + VelDesired=0.0; //jak ma czekać, to nie ma jazdy + //else if (VelSignal<0) + //VelDesired=fVelMax; //ile fabryka dala (Ra: uwzględione wagony) + else + if (VelSignal>=0) //VelSignal>0 jest ograniczeniem prędkości (z semafora) + VelDesired=Min0R(VelDesired,VelSignal); + if (mvOccupied->RunningTrack.Velmax>=0) //ograniczenie prędkości z trajektorii ruchu + VelDesired=Min0R(VelDesired,mvOccupied->RunningTrack.Velmax); //uwaga na ograniczenia szlakowej! + if (VelforDriver>=0) //tu jest zero przy zmianie kierunku jazdy + VelDesired=Min0R(VelDesired,VelforDriver); //Ra: tu może być 40, jeśli mechanik nie ma znajomości szlaaku, albo kierowca jeździ 70 + if (TrainParams) + if (TrainParams->CheckTrainLatency()<5.0) + if (TrainParams->TTVmax>0.0) + VelDesired=Min0R(VelDesired,TrainParams->TTVmax); //jesli nie spozniony to nie przekraczać rozkladowej + if (VelDesired>0.0) + if (VelNext>0.0) + {//jeśli można jechać, to odpalić dźwięk kierownika oraz zamknąć drzwi w składzie + if (iDrivigFlags&moveGuardSignal) + {//komunikat od kierownika tu, bo musi być wolna droga i odczekany czas stania + iDrivigFlags&=~moveGuardSignal; //tylko raz nadać + tsGuardSignal->Stop(); + //w zasadzie to powinien mieć flagę, czy jest dźwiękiem radiowym, czy bezpośrednim + //albo trzeba zrobić dwa dźwięki, jeden bezpośredni, słyszalny w pobliżu, a drugi radiowy, słyszalny w innych lokomotywach + //na razie zakładam, że to nie jest dźwięk radiowy, bo trzeba by zrobić obsługę kanałów radiowych itd. + if (!iGuardRadio) //jeśli nie przez radio + tsGuardSignal->Play(1.0,0,!FreeFlyModeFlag,pVehicle->GetPosition()); //dla true jest głośniej + else + //if (iGuardRadio==iRadioChannel) //zgodność kanału + //if (!FreeFlyModeFlag) //obserwator musi być w środku pojazdu (albo może mieć radio przenośne) - kierownik mógłby powtarzać przy braku reakcji + if (SquareMagnitude(pVehicle->GetPosition()-Global::pCameraPosition)<2000*2000) //w odległości mniejszej niż 2km + tsGuardSignal->Play(1.0,0,true,pVehicle->GetPosition()); //dźwięk niby przez radio + } + if (iDrivigFlags&moveDoorOpened) //jeśli drzwi otwarte + if (!mvOccupied->DoorOpenCtrl) //jeśli drzwi niesterowane przez maszynistę + Doors(false); //a EZT zamknie dopiero po odegraniu komunikatu kierownika + } + if (mvOccupied->V==0.0) AbsAccS=fAccGravity; //Ra 2014-03: jesli skład stoi, to działa na niego składowa styczna grawitacji + else AbsAccS=iDirection*mvOccupied->AccS; //przyspieszenie chwilowe, liczone jako różnica skierowanej prędkości w czasie + //if (mvOccupied->V<0.0) AbsAccS=-AbsAccS; //Ra 2014-03: to trzeba przemyśleć + //if (vel<0) //jeżeli się stacza w tył; 2014-03: to jest bez sensu, bo vel>=0 + // AbsAccS=-AbsAccS; //to przyspieszenie też działa wtedy w nieodpowiednią stronę + //AbsAccS+=fAccGravity; //wypadkowe przyspieszenie (czy to ma sens?) +#if LOGVELOCITY + //WriteLog("VelDesired="+AnsiString(VelDesired)+", VelSignal="+AnsiString(VelSignal)); + WriteLog("Vel="+AnsiString(vel)+", AbsAccS="+AnsiString(AbsAccS)+", AccGrav="+AnsiString(fAccGravity)); +#endif + //ustalanie zadanego przyspieszenia + //(ActualProximityDist) - odległość do miejsca zmniejszenia prędkości + //(AccPreferred) - wynika z psychyki oraz uwzglęnia już ewentualne zderzenie z pojazdem z przodu, ujemne gdy należy hamować + //(AccDesired) - uwzględnia sygnały na drodze ruchu, ujemne gdy należy hamować + //(fAccGravity) - chwilowe przspieszenie grawitacyjne, ujemne działa przeciwnie do zadanego kierunku jazdy + //(AbsAccS) - chwilowe przyspieszenie pojazu (uwzględnia grawitację), ujemne działa przeciwnie do zadanego kierunku jazdy + //(AccDesired) porównujemy z (fAccGravity) albo (AbsAccS) + //if ((VelNext>=0.0)&&(ActualProximityDist>=0)&&(mvOccupied->Vel>=VelNext)) //gdy zbliza sie i jest za szybko do NOWEGO + if ((VelNext>=0.0)&&(ActualProximityDist<=scanmax)&&(vel>=VelNext)) + {//gdy zbliża się i jest za szybki do nowej prędkości, albo stoi na zatrzymaniu + if (vel>0.0) + {//jeśli jedzie + if ((velfMaxProximityDist*(1+0.1*vel)):false) //dojedz do semafora/przeszkody + {//jeśli jedzie wolniej niż można i jest wystarczająco daleko, to można przyspieszyć + if (AccPreferred>0.0) //jeśli nie ma zawalidrogi + AccDesired=AccPreferred; + //VelDesired:=Min0R(VelDesired,VelReduced+VelNext); + } + else if (ActualProximityDist>fMinProximityDist) + {//jedzie szybciej, niż trzeba na końcu ActualProximityDist, ale jeszcze jest daleko + if (velfBrakeDist) + {//jeśli ma stanąć, a mieści się w drodze hamowania + if (vel<10.0) //jeśli prędkość jest łatwa do zatrzymania + {//tu jest trochę problem, bo do punktu zatrzymania dobija na raty + //AccDesired=AccDesired<0.0?0.0:0.1*AccPreferred; + AccDesired=AccPreferred; //proteza trochę; jak tu wychodzi 0.05, to loki mają problem utrzymać takie przyspieszenie + } + else if (vel<=30.0) //trzymaj 30 km/h + AccDesired=Min0R(0.5*AccDesired,AccPreferred); //jak jest tu 0.5, to samochody się dobijają do siebie + else + AccDesired=0.0; + } + else //25.92 (=3.6*3.6*2) - przelicznik z km/h na m/s + if (velBrakeDelay[2+2*mvOccupied->BrakeDelayFlag]; //aby szybkosc hamowania zalezala od przyspieszenia i opoznienia hamulcow + //fBrakeTime=0.5*mvOccupied->BrakeDelay[2+2*mvOccupied->BrakeDelayFlag]; //aby szybkosc hamowania zalezala od przyspieszenia i opoznienia hamulcow + } + else + {//jest bliżej niż fMinProximityDist + VelDesired=Min0R(VelDesired,VelNext); //utrzymuj predkosc bo juz blisko + if (vel0.0)||(ActualProximityDist>fMaxProximityDist*1.2)) + if (VelNext>0.0) + AccDesired=AccPreferred; //można jechać + else //jeśli daleko jechać nie można + if (ActualProximityDist>fMaxProximityDist) //ale ma kawałek do sygnalizatora + {//if ((iDrivigFlags&moveStopHere)?false:AccPreferred>0) + if (AccPreferred>0) + AccDesired=AccPreferred; //dociagnij do semafora; + else + VelDesired=0.0;//,AccDesired=-fabs(fAccGravity); //stoj (hamuj z siłą równą składowej stycznej grawitacji) + } + else + VelDesired=0.0; //VelNext=0 i stoi bliżej niż fMaxProximityDist + } + else //gdy jedzie wolniej niż potrzeba, albo nie ma przeszkód na drodze + AccDesired=(VelDesired!=0.0?AccPreferred:-0.01); //normalna jazda + //koniec predkosci nastepnej + if ((VelDesired>=0.0)&&(vel>VelDesired)) //jesli jedzie za szybko do AKTUALNEGO + if (VelDesired==0.0) //jesli stoj, to hamuj, ale i tak juz za pozno :) + AccDesired=-0.9; //hamuj solidnie + else + if ((vel0.0)) + AccDesired=0.0; + } + else + AccDesired=fAccThreshold; //hamuj tak średnio + //koniec predkosci aktualnej + if (fAccThreshold>-0.3) //bez sensu, ale dla towarowych korzystnie + {//Ra 2014-03: to nie uwzględnia odległości i zaczyna hamować, jak tylko zobaczy W4 + if ((AccDesired>0.0)&&(VelNext>=0.0)) //wybieg bądź lekkie hamowanie, warunki byly zamienione + if (vel>VelNext+100.0) //lepiej zaczac hamowac + AccDesired=fAccThreshold; + else + if (vel>VelNext+70.0) + AccDesired=0.0; //nie spiesz się, bo będzie hamowanie + //koniec wybiegu i hamowania + } + if (AIControllFlag) + {//część wykonawcza tylko dla AI, dla człowieka jedynie napisy + if (mvControlling->ConvOvldFlag||!mvControlling->Mains) //WS może wywalić z powodu błędu w drutach + {//wywalił bezpiecznik nadmiarowy przetwornicy + //while (DecSpeed()); //zerowanie napędu + //Controlling->ConvOvldFlag=false; //reset nadmiarowego + PrepareEngine(); //próba ponownego załączenia + } + //włączanie bezpiecznika + if ((mvControlling->EngineType==ElectricSeriesMotor)||(mvControlling->TrainType&dt_EZT)||(mvControlling->EngineType==DieselElectric)) + if (mvControlling->FuseFlag||Need_TryAgain) + {Need_TryAgain=false; //true, jeśli druga pozycja w elektryku nie załapała + //if (!Controlling->DecScndCtrl(1)) //kręcenie po mału + // if (!Controlling->DecMainCtrl(1)) //nastawnik jazdy na 0 + mvControlling->DecScndCtrl(2); //nastawnik bocznikowania na 0 + mvControlling->DecMainCtrl(2); //nastawnik jazdy na 0 + mvControlling->MainSwitch(true); //Ra: dodałem, bo EN57 stawały po wywaleniu + if (!mvControlling->FuseOn()) + HelpMeFlag=true; + else + { + ++iDriverFailCount; + if (iDriverFailCount>maxdriverfails) + Psyche=Easyman; + if (iDriverFailCount>maxdriverfails*2) + SetDriverPsyche(); + } + } + if (mvOccupied->BrakeSystem==Pneumatic) //napełnianie uderzeniowe + if (mvOccupied->BrakeHandle==FV4a) + { + if (mvOccupied->BrakeCtrlPos==-2) + mvOccupied->BrakeLevelSet(0); +// if ((mvOccupied->BrakeCtrlPos<0)&&(mvOccupied->PipeBrakePress<0.01))//{(CntrlPipePress-(Volume/BrakeVVolume/10)<0.01)}) +// mvOccupied->IncBrakeLevel(); + if ((mvOccupied->PipePress<3.0)&&(AccDesired>-0.03)) mvOccupied->BrakeReleaser(1); + if ((mvOccupied->BrakeCtrlPos==0)&&(AbsAccS<0.0)&&(AccDesired>-0.03)) + //if FuzzyLogicAI(CntrlPipePress-PipePress,0.01,1)) +// if ((mvOccupied->BrakePress>0.5)&&(mvOccupied->LocalBrakePos<0.5))//{((Volume/BrakeVVolume/10)<0.485)}) + if ((mvOccupied->EqvtPipePress<4.95)&&(fReady>0.35))//{((Volume/BrakeVVolume/10)<0.485)}) + {if (iDrivigFlags&moveOerlikons) //a reszta składu jest na to gotowa + mvOccupied->BrakeLevelSet(-1); //napełnianie w Oerlikonie + } + else + if (Need_BrakeRelease) + { + Need_BrakeRelease=false; + mvOccupied->BrakeReleaser(1); + //DecBrakeLevel(); //z tym by jeszcze miało jakiś sens + } +// if ((mvOccupied->BrakeCtrlPos<0)&&(mvOccupied->BrakePress<0.3))//{(CntrlPipePress-(Volume/BrakeVVolume/10)<0.01)}) + if ((mvOccupied->BrakeCtrlPos<0)&&(mvOccupied->EqvtPipePress>(fReady<0.25?5.1:5.2)))//{(CntrlPipePress-(Volume/BrakeVVolume/10)<0.01)}) + mvOccupied->IncBrakeLevel(); + } +#if LOGVELOCITY + WriteLog("Dist="+FloatToStrF(ActualProximityDist,ffFixed,7,1)+", VelDesired="+FloatToStrF(VelDesired,ffFixed,7,1)+", AccDesired="+FloatToStrF(AccDesired,ffFixed,7,3)+", VelSignal="+AnsiString(VelSignal)+", VelNext="+AnsiString(VelNext)); +#endif + if (AccDesired>0.1) + if (vel<10.0) //Ra 2F1H: jeśli prędkość jest mała, a można przyspieszać, to nie ograniczać przyspieszenia do 0.5m/ss + AccDesired=0.9; //przy małych prędkościach może być trudno utrzymać małe przyspieszenie + //Ra 2F1I: wyłączyć kiedyś to uśrednianie i przeanalizować skanowanie, czemu migocze + if (AccDesired>-0.15) //hamowania lepeiej nie uśredniać + AccDesired=fAccDesiredAv=0.2*AccDesired+0.8*fAccDesiredAv; //uśrednione, żeby ograniczyć migotanie + if (VelDesired==0.0) if (AccDesired>=-0.01) AccDesired=-0.01; //Ra 2F1J: jeszcze jedna prowizoryczna łatka + if (AccDesired>=0.0) + if (iDrivigFlags&movePress) + mvOccupied->BrakeReleaser(1); //wyluzuj lokomotywę - może być więcej! + else + if (OrderList[OrderPos]!=Disconnect) //przy odłączaniu nie zwalniamy tu hamulca + if ((AccDesired>0.0)||(fAccGravity*fAccGravity<0.001)) //luzuj tylko na plaskim lub przy ruszaniu + {while (DecBrake()); //jeśli przyspieszamy, to nie hamujemy + if (mvOccupied->BrakePress>0.4) + mvOccupied->BrakeReleaser(1); //wyluzuj lokomotywę, to szybciej ruszymy + } + //margines dla prędkości jest doliczany tylko jeśli oczekiwana prędkość jest większa od 5km/h + if (!(iDrivigFlags&movePress)) + {//jeśli nie dociskanie + if (AccDesired<-0.1) + while (DecSpeed()); //jeśli hamujemy, to nie przyspieszamy + else if (((fAccGravity<-0.01)?AccDesired<0.0:AbsAccS>AccDesired)||(vel>VelDesired)) //jak za bardzo przyspiesza albo prędkość przekroczona + DecSpeed(); //pojedyncze cofnięcie pozycji, bo na zero to przesada + } + //yB: usunięte różne dziwne warunki, oddzielamy część zadającą od wykonawczej + //zwiekszanie predkosci + //Ra 2F1H: jest konflikt histerezy pomiędzy nastawioną pozycją a uzyskiwanym przyspieszeniem - utrzymanie pozycji powoduje przekroczenie przyspieszenia + if (AbsAccSfMaxProximityDist)?true:(vel0) and (EngineType=ElectricSeriesMotor) + // and (RList[MainCtrlPos].R>0.0) and (not DelayCtrlFlag)) + // if (ImTrainType&dt_EZT) //właściwie, to warunek powinien być na działający EP + {//Ra: to dobrze hamuje EP w EZT + if ((AccDesired<=fAccThreshold)? //jeśli hamować - u góry ustawia się hamowanie na fAccThreshold + ((AbsAccS>AccDesired)||(mvOccupied->BrakeCtrlPos<0)):false) //hamować bardziej, gdy aktualne opóźnienie hamowania mniejsze niż (AccDesired) + IncBrake(); + else + if (OrderList[OrderPos]!=Disconnect) //przy odłączaniu nie zwalniamy tu hamulca + if (AbsAccSBrakeCtrlPos>=0) + DecBrake(); //tutaj zmniejszało o 1 przy odczepianiu + } + else if (mvOccupied->Handle->TimeEP) + { + if (mvOccupied->Handle->GetPos(bh_EPR)-mvOccupied->Handle->GetPos(bh_EPN)<0.1) + mvOccupied->SwitchEPBrake(0); + else + mvOccupied->BrakeLevelSet(mvOccupied->Handle->GetPos(bh_EPN)); + } +// else if (mvOccupied->BrakeCtrlPos<0) IncBrake(); //ustawienie jazdy (pozycja 0) +// else if (mvOccupied->BrakeCtrlPos>0) DecBrake(); + } + else + {//a stara wersja w miarę dobrze działa na składy wagonowe +// if (mvOccupied->Handle->Time) +// mvOccupied->BrakeLevelSet(mvOccupied->Handle->GetPos(bh_MB)); //najwyzej sobie przestawi + if (((fAccGravity<-0.05)&&(vel<0))||((AccDesiredAccDesired+0.05))) //u góry ustawia się hamowanie na fAccThreshold + //if not MinVelFlag) + if (fBrakeTime<0?true:(AccDesiredBrakeCtrlPos<=0)) + if (!IncBrake()) //jeśli upłynął czas reakcji hamulca, chyba że nagłe albo luzował + MinVelFlag=true; + else + {MinVelFlag=false; + fBrakeTime=3+0.5*(mvOccupied->BrakeDelay[2+2*mvOccupied->BrakeDelayFlag]-3); + //Ra: ten czas należy zmniejszyć, jeśli czas dojazdu do zatrzymania jest mniejszy + fBrakeTime*=0.5; //Ra: tymczasowo, bo przeżyna S1 + } + if ((AccDesiredBrakeDelay[1+2*mvOccupied->BrakeDelayFlag])/3.0; + fBrakeTime*=0.5; //Ra: tymczasowo, bo przeżyna S1 + } + } + //Mietek-end1 + SpeedSet(); //ciągla regulacja prędkości +#if LOGVELOCITY + WriteLog("BrakePos="+AnsiString(mvOccupied->BrakeCtrlPos)+", MainCtrl="+AnsiString(mvControlling->MainCtrlPos)); +#endif + +/* //Ra: mamy teraz wskażnik na człon silnikowy, gorzej jak są dwa w ukrotnieniu... + //zapobieganie poslizgowi w czlonie silnikowym; Ra: Couplers[1] powinno być + if (Controlling->Couplers[0].Connected!=NULL) + if (TestFlag(Controlling->Couplers[0].CouplingFlag,ctrain_controll)) + if (Controlling->Couplers[0].Connected->SlippingWheels) + if (Controlling->ScndCtrlPos>0?!Controlling->DecScndCtrl(1):true) + { + if (!Controlling->DecMainCtrl(1)) + if (mvOccupied->BrakeCtrlPos==mvOccupied->BrakeCtrlPosNo) + mvOccupied->DecBrakeLevel(); + ++iDriverFailCount; + } +*/ + //zapobieganie poslizgowi u nas + if (mvControlling->SlippingWheels) + { + if (!mvControlling->DecScndCtrl(2)) //bocznik na zero + mvControlling->DecMainCtrl(1); + if (mvOccupied->BrakeCtrlPos==mvOccupied->BrakeCtrlPosNo) //jeśli ostatnia pozycja hamowania + mvOccupied->DecBrakeLevel(); //to cofnij hamulec + else + mvControlling->AntiSlippingButton(); + ++iDriverFailCount; + mvControlling->SlippingWheels=false; //flaga już wykorzystana + } + if (iDriverFailCount>maxdriverfails) + { + Psyche=Easyman; + if (iDriverFailCount>maxdriverfails*2) + SetDriverPsyche(); + } + } //if (AIControllFlag) + else + {//tu mozna dać komunikaty tekstowe albo słowne: przyspiesz, hamuj (lekko, średnio, mocno) + } + } //kierunek różny od zera + else + {//tutaj, gdy pojazd jest wyłączony + if (!AIControllFlag) //jeśli sterowanie jest w gestii użytkownika + if (mvOccupied->Battery) //czy użytkownik załączył baterię? + if (mvOccupied->ActiveDir) //czy ustawił kierunek + {//jeśli tak, to uruchomienie skanowania + CheckVehicles(); //sprawdzić skład + TableClear(); //resetowanie tabelki skanowania + PrepareEngine(); //uruchomienie + } + } + if (AIControllFlag) + {//odhamowywanie składu po zatrzymaniu i zabezpieczanie lokomotywy + if ((OrderList[OrderPos]&(Disconnect|Connect))==0) //przy (p)odłączaniu nie zwalniamy tu hamulca + if ((mvOccupied->V==0.0)&&((VelDesired==0.0)||(AccDesired==0.0))) + if ((mvOccupied->BrakeCtrlPos<1)||!mvOccupied->DecBrakeLevel()) + mvOccupied->IncLocalBrakeLevel(1); //dodatkowy na pozycję 1 + } + break; //rzeczy robione przy jezdzie + } //switch (OrderList[OrderPos]) + //kasowanie licznika czasu + LastReactionTime=0.0; + UpdateOK=true; + } //if ((LastReactionTime>Min0R(ReactionTime,2.0))) + else + LastReactionTime+=dt; + + if((fLastStopExpDist>0.0)&&(mvOccupied->DistCounter>fLastStopExpDist)) + { + iStationStart=TrainParams->StationIndex; //zaktualizować wyświetlanie rozkładu + fLastStopExpDist=-1.0f; //usunąć licznik + } + + if (AIControllFlag) + { + if (fWarningDuration>0.0) //jeśli pozostało coś do wytrąbienia + {//trąbienie trwa nadal + fWarningDuration=fWarningDuration-dt; + if (fWarningDuration<0.05) + mvOccupied->WarningSignal=0; //a tu się kończy + if (ReactionTime>fWarningDuration) + ReactionTime=fWarningDuration; //wcześniejszy przebłysk świadomości, by zakończyć trąbienie + } + if (mvOccupied->Vel>=3.0) //jesli jedzie, można odblokować trąbienie, bo się wtedy nie włączy + {iDrivigFlags&=~moveStartHornDone; //zatrąbi dopiero jak następnym razem stanie + iDrivigFlags|=moveStartHorn; //i trąbić przed następnym ruszeniem + } + return UpdateOK; + } + else //if (AIControllFlag) + return false; //AI nie obsługuje +} + +void __fastcall TController::JumpToNextOrder() +{//wykonanie kolejnej komendy z tablicy rozkazów + if (OrderList[OrderPos]!=Wait_for_orders) + { + if (OrderList[OrderPos]&Change_direction) //jeśli zmiana kierunku + if (OrderList[OrderPos]!=Change_direction) //ale nałożona na coś + {OrderList[OrderPos]=TOrders(OrderList[OrderPos]&~Change_direction); //usunięcie zmiany kierunku z innej komendy + OrderCheck(); + return; + } + if (OrderPos JumpToNextOrder"); + OrdersDump(); //normalnie nie ma po co tego wypisywać +#endif +}; + +void __fastcall TController::JumpToFirstOrder() +{//taki relikt + OrderPos=1; + if (OrderTop==0) OrderTop=1; + OrderCheck(); +#if LOGORDERS + WriteLog("--> JumpToFirstOrder"); + OrdersDump(); //normalnie nie ma po co tego wypisywać +#endif +}; + +void __fastcall TController::OrderCheck() +{//reakcja na zmianę rozkazu + if (OrderList[OrderPos]&(Shunt|Connect|Obey_train)) + CheckVehicles(); //sprawdzić światła + if (OrderList[OrderPos]&Change_direction) //może być nałożona na inną i wtedy ma priorytet + iDirectionOrder=-iDirection; //trzeba zmienić jawnie, bo się nie domyśli + else if (OrderList[OrderPos]==Obey_train) + iDrivigFlags|=moveStopPoint; //W4 są widziane + else if (OrderList[OrderPos]==Disconnect) + iVehicleCount=iVehicleCount<0?0:iVehicleCount; //odczepianie lokomotywy + else if (OrderList[OrderPos]==Connect) + iDrivigFlags&=~moveStopPoint; //podczas jazdy na połączenie nie zwracać uwagi na W4 + else if (OrderList[OrderPos]==Wait_for_orders) + OrdersClear(); //czyszczenie rozkazów i przeskok do zerowej pozycji +} + +void __fastcall TController::OrderNext(TOrders NewOrder) +{//ustawienie rozkazu do wykonania jako następny + if (OrderList[OrderPos]==NewOrder) + return; //jeśli robi to, co trzeba, to koniec + if (!OrderPos) OrderPos=1; //na pozycji zerowej pozostaje czekanie + OrderTop=OrderPos; //ale może jest czymś zajęty na razie + if (NewOrder>=Shunt) //jeśli ma jechać + {//ale może być zajęty chwilowymi operacjami + while (OrderList[OrderTop]?OrderList[OrderTop] OrderNext"); + OrdersDump(); //normalnie nie ma po co tego wypisywać +#endif +} + +void __fastcall TController::OrderPush(TOrders NewOrder) +{//zapisanie na stosie kolejnego rozkazu do wykonania + if (OrderPos==OrderTop) //jeśli miałby być zapis na aktalnej pozycji + if (OrderList[OrderPos] zapis na kolejnej + if (OrderList[OrderTop]!=NewOrder) //jeśli jest to samo, to nie dodajemy + OrderList[OrderTop++]=NewOrder; //dodanie rozkazu na stos + //if (OrderTop=maxorders) + ErrorLog("Commands overflow: The program will now crash"); +#if LOGORDERS + WriteLog("--> OrderPush"); + OrdersDump(); //normalnie nie ma po co tego wypisywać +#endif +} + +void __fastcall TController::OrdersDump() +{//wypisanie kolejnych rozkazów do logu + WriteLog("Orders for "+pVehicle->asName+":"); + for (int b=0;bOrderPush(Wait_for_orders); //czekanie na lepsze czasy + //OrderPos=OrderTop=0; //wypełniamy od pozycji 0 + OrdersClear(); //usunięcie poprzedniej tabeli + OrderPush(Prepare_engine); //najpierw odpalenie silnika + if (TrainParams->TrainName==AnsiString("none")) + {//brak rozkładu to jazda manewrowa + if (fVel>0.05) //typowo 0.1 oznacza gotowość do jazdy, 0.01 tylko załączenie silnika + OrderPush(Shunt); //jeśli nie ma rozkładu, to manewruje + } + else + {//jeśli z rozkładem, to jedzie na szlak + if ((fVel>0.0)&&(fVel<0.02)) + OrderPush(Shunt); //dla prędkości 0.01 włączamy jazdę manewrową + else if (TrainParams? + (TrainParams->TimeTable[1].StationWare.Pos("@")? //jeśli obrót na pierwszym przystanku + ((iDrivigFlags&movePushPull)? //SZT również! SN61 zależnie od wagonów... + (TrainParams->TimeTable[1].StationName==TrainParams->Relation1):false):false):true) + OrderPush(Shunt); //a teraz start będzie w manewrowym, a tryb pociągowy włączy W4 + else + //jeśli start z pierwszej stacji i jednocześnie jest na niej zmiana kierunku, to EZT ma mieć Shunt + OrderPush(Obey_train); //dla starych scenerii start w trybie pociagowym + if (DebugModeFlag) //normalnie nie ma po co tego wypisywać + WriteLog("/* Timetable: "+TrainParams->ShowRelation()); + TMTableLine *t; + for (int i=0;i<=TrainParams->StationCount;++i) + {t=TrainParams->TimeTable+i; + if (DebugModeFlag) //normalnie nie ma po co tego wypisywać + WriteLog(AnsiString(t->StationName)+" "+AnsiString((int)t->Ah)+":"+AnsiString((int)t->Am)+", "+AnsiString((int)t->Dh)+":"+AnsiString((int)t->Dm)+" "+AnsiString(t->StationWare)); + if (AnsiString(t->StationWare).Pos("@")) + {//zmiana kierunku i dalsza jazda wg rozkładu + if (iDrivigFlags&movePushPull) //SZT również! SN61 zależnie od wagonów... + {//jeśli skład zespolony, wystarczy zmienić kierunek jazdy + OrderPush(Change_direction); //zmiana kierunku + } + else + {//dla zwykłego składu wagonowego odczepiamy lokomotywę + OrderPush(Disconnect); //odczepienie lokomotywy + OrderPush(Shunt); //a dalej manewry + if (i<=TrainParams->StationCount) //130827: to się jednak nie sprawdza + {//"@" na ostatniej robi tylko odpięcie + //OrderPush(Change_direction); //zmiana kierunku + //OrderPush(Shunt); //jazda na drugą stronę składu + //OrderPush(Change_direction); //zmiana kierunku + //OrderPush(Connect); //jazda pod wagony + } + } + if (iStationCount) //jak nie ostatnia stacja + OrderPush(Obey_train); //to dalej wg rozkładu + } + } + if (DebugModeFlag) //normalnie nie ma po co tego wypisywać + WriteLog("*/"); + OrderPush(Shunt); //po wykonaniu rozkładu przełączy się na manewry + } + //McZapkie-100302 - to ma byc wyzwalane ze scenerii + if (fVel==0.0) + SetVelocity(0,0,stopSleep); //jeśli nie ma prędkości początkowej, to śpi + else + {//jeśli podana niezerowa prędkość + if ((fVel>=1.0)||(fVel<0.02)) //jeśli ma jechać - dla 0.01 ma podjechać manewrowo po podaniu sygnału + iDrivigFlags=(iDrivigFlags&~moveStopHere)|moveStopCloser; //to do następnego W4 ma podjechać blisko + else + iDrivigFlags|=moveStopHere; //czekać na sygnał + JumpToFirstOrder(); + if (fVel>=1.0) //jeśli ma jechać + SetVelocity(fVel,-1); //ma ustawić żądaną prędkość + else + SetVelocity(0,0,stopSleep); //prędkość w przedziale (0;1) oznacza, że ma stać + } +#if LOGORDERS + WriteLog("--> OrdersInit"); +#endif + if (DebugModeFlag) //normalnie nie ma po co tego wypisywać + OrdersDump(); //wypisanie kontrolne tabelki rozkazów + //McZapkie! - zeby w ogole AI ruszyl to musi wykonac powyzsze rozkazy + //Ale mozna by je zapodac ze scenerii +}; + + +AnsiString __fastcall TController::StopReasonText() +{//informacja tekstowa o przyczynie zatrzymania + if (eStopReason!=7) //zawalidroga będzie inaczej + return StopReasonTable[eStopReason]; + else + return "Blocked by "+(pVehicles[0]->PrevAny()->GetName()); +}; + +//---------------------------------------------------------------------------------------------------------------------- +//McZapkie: skanowanie semaforów +//Ra: stare funkcje skanujące, używane podczas manewrów do szukania sygnalizatora z tyłu +//- nie reagują na PutValues, bo nie ma takiej potrzeby +//- rozpoznają tylko zerową prędkość (jako koniec toru i brak podstaw do dalszego skanowania) +//---------------------------------------------------------------------------------------------------------------------- + +/* //nie używane +double __fastcall TController::Distance(vector3 &p1,vector3 &n,vector3 &p2) +{//Ra:obliczenie odległości punktu (p1) od płaszczyzny o wektorze normalnym (n) przechodzącej przez (p2) + return n.x*(p1.x-p2.x)+n.y*(p1.y-p2.y)+n.z*(p1.z-p2.z); //ax1+by1+cz1+d, gdzie d=-(ax2+by2+cz2) +}; +*/ + +bool __fastcall TController::BackwardTrackBusy(TTrack *Track) +{//najpierw sprawdzamy, czy na danym torze są pojazdy z innego składu + if (Track->iNumDynamics) + {//jeśli tylko z własnego składu, to tor jest wolny + for (int i=0;iiNumDynamics;++i) + if (Track->Dynamics[i]->ctOwner!=this) //jeśli jest jakiś cudzy + return true; //to tor jest zajęty i skanowanie nie obowiązuje + } + return false; //wolny +}; + +TEvent* __fastcall TController::CheckTrackEventBackward(double fDirection,TTrack *Track) +{//sprawdzanie eventu w torze, czy jest sygnałowym - skanowanie do tyłu + TEvent* e=(fDirection>0)?Track->evEvent2:Track->evEvent1; + if (e) + if (!e->bEnabled) //jeśli sygnałowy (nie dodawany do kolejki) + if (e->Type==tp_GetValues) //PutValues nie może się zmienić + return e; + return NULL; +}; + +TTrack* __fastcall TController::BackwardTraceRoute(double &fDistance,double &fDirection,TTrack *Track,TEvent*&Event) +{//szukanie sygnalizatora w kierunku przeciwnym jazdy (eventu odczytu komórki pamięci) + TTrack *pTrackChVel=Track; //tor ze zmianą prędkości + TTrack *pTrackFrom; //odcinek poprzedni, do znajdywania końca dróg + double fDistChVel=-1; //odległość do toru ze zmianą prędkości + double fCurrentDistance=pVehicle->RaTranslationGet(); //aktualna pozycja na torze + double s=0; + if (fDirection>0) //jeśli w kierunku Point2 toru + fCurrentDistance=Track->Length()-fCurrentDistance; + if (BackwardTrackBusy(Track)) + {//jak tor zajęty innym składem, to nie ma po co skanować + fDistance=0; //to na tym torze stoimy + return NULL; //stop, skanowanie nie dało sensownych rezultatów + } + if ((Event=CheckTrackEventBackward(fDirection,Track))!=NULL) + {//jeśli jest semafor na tym torze + fDistance=0; //to na tym torze stoimy + return Track; + } + if ((Track->VelocityGet()==0.0)||(Track->iDamageFlag&128)) + {//jak prędkosć 0 albo uszkadza, to nie ma po co skanować + fDistance=0; //to na tym torze stoimy + return NULL; //stop, skanowanie nie dało sensownych rezultatów + } + while (sScannedFlag=true; //do pokazywania przeskanowanych torów + pTrackFrom=Track; //zapamiętanie aktualnego odcinka + s+=fCurrentDistance; //doliczenie kolejnego odcinka do przeskanowanej długości + if (fDirection>0) + {//jeśli szukanie od Point1 w kierunku Point2 + if (Track->iNextDirection) + fDirection=-fDirection; + Track=Track->CurrentNext(); //może być NULL + } + else //if (fDirection<0) + {//jeśli szukanie od Point2 w kierunku Point1 + if (!Track->iPrevDirection) + fDirection=-fDirection; + Track=Track->CurrentPrev(); //może być NULL + } + if (Track==pTrackFrom) Track=NULL; //koniec, tak jak dla torów + if (Track?(Track->VelocityGet()==0.0)||(Track->iDamageFlag&128)||BackwardTrackBusy(Track):true) + {//gdy dalej toru nie ma albo zerowa prędkość, albo uszkadza pojazd + fDistance=s; + return NULL; //zwraca NULL, że skanowanie nie dało sensownych rezultatów + } + fCurrentDistance=Track->Length(); + if ((Event=CheckTrackEventBackward(fDirection,Track))!=NULL) + {//znaleziony tor z eventem + fDistance=s; + return Track; + } + } + Event=NULL; //jak dojdzie tu, to nie ma semafora + if (fDistChVel<0) + {//zwraca ostatni sprawdzony tor + fDistance=s; + return Track; + } + fDistance=fDistChVel; //odległość do zmiany prędkości + return pTrackChVel; //i tor na którym się zmienia +} + + +//sprawdzanie zdarzeń semaforów i ograniczeń szlakowych +void __fastcall TController::SetProximityVelocity(double dist,double vel,const vector3 *pos) +{//Ra:przeslanie do AI prędkości +/* + //!!!! zastąpić prawidłową reakcją AI na SetProximityVelocity !!!! + if (vel==0) + {//jeśli zatrzymanie, to zmniejszamy dystans o 10m + dist-=10.0; + }; + if (dist<0.0) dist=0.0; + if ((vel<0)?true:dist>0.1*(MoverParameters->Vel*MoverParameters->Vel-vel*vel)+50) + {//jeśli jest dalej od umownej drogi hamowania +*/ + PutCommand("SetProximityVelocity",dist,vel,pos); +/* + } + else + {//jeśli jest zagrożenie, że przekroczy + Mechanik->SetVelocity(floor(0.2*sqrt(dist)+vel),vel,stopError); + } + */ +} + +TCommandType __fastcall TController::BackwardScan() +{//sprawdzanie zdarzeń semaforów z tyłu pojazdu, zwraca komendę + //dzięki temu będzie można stawać za wskazanym sygnalizatorem, a zwłaszcza jeśli będzie jazda na kozioł + //ograniczenia prędkości nie są wtedy istotne, również koniec toru jest do niczego nie przydatny + //zwraca true, jeśli należy odwrócić kierunek jazdy pojazdu + if ((OrderList[OrderPos]&~(Shunt|Connect))) + return cm_Unknown; //skanowanie sygnałów tylko gdy jedzie w trybie manewrowym albo czeka na rozkazy + vector3 sl; + int startdir=-pVehicles[0]->DirectionGet(); //kierunek jazdy względem sprzęgów pojazdu na czele + if (startdir==0) //jeśli kabina i kierunek nie jest określony + return cm_Unknown; //nie robimy nic + double scandir=startdir*pVehicles[0]->RaDirectionGet(); //szukamy od pierwszej osi w wybranym kierunku + if (scandir!=0.0) //skanowanie toru w poszukiwaniu eventów GetValues (PutValues nie są przydatne) + {//Ra: przy wstecznym skanowaniu prędkość nie ma znaczenia + //scanback=pVehicles[1]->NextDistance(fLength+1000.0); //odległość do następnego pojazdu, 1000 gdy nic nie ma + double scanmax=1000; //1000m do tyłu, żeby widział przeciwny koniec stacji + double scandist=scanmax; //zmodyfikuje na rzeczywiście przeskanowane + TEvent *e=NULL; //event potencjalnie od semafora + //opcjonalnie może być skanowanie od "wskaźnika" z przodu, np. W5, Tm=Ms1, koniec toru + TTrack *scantrack=BackwardTraceRoute(scandist,scandir,pVehicles[0]->RaTrackGet(),e); //wg drugiej osi w kierunku ruchu + vector3 dir=startdir*pVehicles[0]->VectorFront(); //wektor w kierunku jazdy/szukania + if (!scantrack) //jeśli wstecz wykryto koniec toru + return cm_Unknown; //to raczej nic się nie da w takiej sytuacji zrobić + else + {//a jeśli są dalej tory + double vmechmax; //prędkość ustawiona semaforem + if (e) + {//jeśli jest jakiś sygnał na widoku +#if LOGBACKSCAN + AnsiString edir=pVehicle->asName+" - "+AnsiString((scandir>0)?"Event2 ":"Event1 "); +#endif + //najpierw sprawdzamy, czy semafor czy inny znak został przejechany + vector3 pos=pVehicles[1]->RearPosition(); //pozycja tyłu + vector3 sem; //wektor do sygnału + if (e->Type==tp_GetValues) + {//przesłać info o zbliżającym się semaforze +#if LOGBACKSCAN + edir+="("+(e->Params[8].asGroundNode->asName)+"): "; +#endif + sl=e->PositionGet(); //położenie komórki pamięci + sem=sl-pos; //wektor do komórki pamięci od końca składu + //sem=e->Params[8].asGroundNode->pCenter-pos; //wektor do komórki pamięci + if (dir.x*sem.x+dir.z*sem.z<0) //jeśli został minięty + //if ((mvOccupied->CategoryFlag&1)?(VelNext!=0.0):true) //dla pociągu wymagany sygnał zezwalający + {//iloczyn skalarny jest ujemny, gdy sygnał stoi z tyłu +#if LOGBACKSCAN + WriteLog(edir+"- ignored as not passed yet"); +#endif + return cm_Unknown; //nic + } + vmechmax=e->ValueGet(1); //prędkość przy tym semaforze + //przeliczamy odległość od semafora - potrzebne by były współrzędne początku składu + //scandist=(pos-e->Params[8].asGroundNode->pCenter).Length()-0.5*mvOccupied->Dim.L-10; //10m luzu + scandist=sem.Length()-2; //2m luzu przy manewrach wystarczy + if (scandist<0) scandist=0; //ujemnych nie ma po co wysyłać + bool move=false; //czy AI w trybie manewerowym ma dociągnąć pod S1 + if (e->Command()==cm_SetVelocity) + if ((vmechmax==0.0)?(OrderCurrentGet()&(Shunt|Connect)):(OrderCurrentGet()&Connect)) //przy podczepianiu ignorować wyjazd? + move=true; //AI w trybie manewerowym ma dociągnąć pod S1 + else + {// + if ((scandist>fMinProximityDist)?(mvOccupied->Vel>0.0)&&(OrderCurrentGet()!=Shunt):false) + {//jeśli semafor jest daleko, a pojazd jedzie, to informujemy o zmianie prędkości + //jeśli jedzie manewrowo, musi dostać SetVelocity, żeby sie na pociągowy przełączył + //Mechanik->PutCommand("SetProximityVelocity",scandist,vmechmax,sl); +#if LOGBACKSCAN + //WriteLog(edir+"SetProximityVelocity "+AnsiString(scandist)+" "+AnsiString(vmechmax)); + WriteLog(edir); +#endif + //SetProximityVelocity(scandist,vmechmax,&sl); + return (vmechmax>0)?cm_SetVelocity:cm_Unknown; + } + else //ustawiamy prędkość tylko wtedy, gdy ma ruszyć, stanąć albo ma stać + //if ((MoverParameters->Vel==0.0)||(vmechmax==0.0)) //jeśli stoi lub ma stanąć/stać + {//semafor na tym torze albo lokomtywa stoi, a ma ruszyć, albo ma stanąć, albo nie ruszać + //stop trzeba powtarzać, bo inaczej zatrąbi i pojedzie sam + //PutCommand("SetVelocity",vmechmax,e->Params[9].asMemCell->Value2(),&sl,stopSem); +#if LOGBACKSCAN + WriteLog(edir+"SetVelocity "+AnsiString(vmechmax)+" "+AnsiString(e->Params[9].asMemCell->Value2())); +#endif + return (vmechmax>0)?cm_SetVelocity:cm_Unknown; + } + } + if (OrderCurrentGet()?OrderCurrentGet()&(Shunt|Connect):true) //w Wait_for_orders też widzi tarcze + {//reakcja AI w trybie manewrowym dodatkowo na sygnały manewrowe + if (move?true:e->Command()==cm_ShuntVelocity) + {//jeśli powyżej było SetVelocity 0 0, to dociągamy pod S1 + if ((scandist>fMinProximityDist)?(mvOccupied->Vel>0.0)||(vmechmax==0.0):false) + {//jeśli tarcza jest daleko, to: + //- jesli pojazd jedzie, to informujemy o zmianie prędkości + //- jeśli stoi, to z własnej inicjatywy może podjechać pod zamkniętą tarczę + if (mvOccupied->Vel>0.0) //tylko jeśli jedzie + {//Mechanik->PutCommand("SetProximityVelocity",scandist,vmechmax,sl); +#if LOGBACKSCAN + //WriteLog(edir+"SetProximityVelocity "+AnsiString(scandist)+" "+AnsiString(vmechmax)); + WriteLog(edir); +#endif + //SetProximityVelocity(scandist,vmechmax,&sl); + return (iDrivigFlags&moveTrackEnd)?cm_ChangeDirection:cm_Unknown; //jeśli jedzie na W5 albo koniec toru, to można zmienić kierunek + } + } + else //ustawiamy prędkość tylko wtedy, gdy ma ruszyć, albo stanąć albo ma stać pod tarczą + {//stop trzeba powtarzać, bo inaczej zatrąbi i pojedzie sam + //if ((MoverParameters->Vel==0.0)||(vmechmax==0.0)) //jeśli jedzie lub ma stanąć/stać + {//nie dostanie komendy jeśli jedzie i ma jechać + //PutCommand("ShuntVelocity",vmechmax,e->Params[9].asMemCell->Value2(),&sl,stopSem); +#if LOGBACKSCAN + WriteLog(edir+"ShuntVelocity "+AnsiString(vmechmax)+" "+AnsiString(e->ValueGet(2))); +#endif + return (vmechmax>0)?cm_ShuntVelocity:cm_Unknown; + } + } + if ((vmechmax!=0.0)&&(scandist<100.0)) + {//jeśli Tm w odległości do 100m podaje zezwolenie na jazdę, to od razu ją ignorujemy, aby móc szukać kolejnej + //eSignSkip=e; //wtedy uznajemy ignorowaną przy poszukiwaniu nowej +#if LOGBACKSCAN + WriteLog(edir+"- will be ignored due to Ms2"); +#endif + return (vmechmax>0)?cm_ShuntVelocity:cm_Unknown; + } + } //if (move?... + } //if (OrderCurrentGet()==Shunt) + if (!e->bEnabled) //jeśli skanowany + if (e->StopCommand()) //a podłączona komórka ma komendę + return cm_Command; //to też się obrócić + } //if (e->Type==tp_GetValues) + } //if (e) + } //if (scantrack) + } //if (scandir!=0.0) + return cm_Unknown; //nic +}; + +AnsiString __fastcall TController::NextStop() +{//informacja o następnym zatrzymaniu, wyświetlane pod [F1] + if (asNextStop.Length()<20) return ""; //nie zawiera nazwy stacji, gdy dojechał do końca + //dodać godzinę odjazdu + if (!TrainParams) + return ""; //tu nie powinno nigdy wejść + TMTableLine *t=TrainParams->TimeTable+TrainParams->StationIndex; + if (t->Dh>=0) //jeśli jest godzina odjazdu + return + asNextStop.SubString(20,30) + +AnsiString(" ") + +AnsiString(int(t->Dh)) + +AnsiString(":") + +AnsiString(int(100+t->Dm)).SubString(2,2); //odjazd + else if (t->Ah>=0) //przyjazd + return + asNextStop.SubString(20,30) + +AnsiString(" (") + +AnsiString(int(t->Ah)) + +AnsiString(":") + +AnsiString(int(100+t->Am)).SubString(2,2) + +AnsiString(")"); //przyjazd + return ""; +}; + +//-----------koniec skanowania semaforow + +void __fastcall TController::TakeControl(bool yes) +{//przejęcie kontroli przez AI albo oddanie + if (AIControllFlag==yes) return; //już jest jak ma być + if (yes) //żeby nie wykonywać dwa razy + {//teraz AI prowadzi + AIControllFlag=AIdriver; + pVehicle->Controller=AIdriver; + iDirection=0; //kierunek jazdy trzeba dopiero zgadnąć + //gdy zgaszone światła, flaga podjeżdżania pod semafory pozostaje bez zmiany + if (OrderCurrentGet()) //jeśli coś robi + PrepareEngine(); //niech sprawdzi stan silnika + else //jeśli nic nie robi + if (pVehicle->iLights[mvOccupied->CabNo<0?1:0]&21) //któreś ze świateł zapalone? + {//od wersji 357 oczekujemy podania komend dla AI przez scenerię + OrderNext(Prepare_engine); + if (pVehicle->iLights[mvOccupied->CabNo<0?1:0]&4) //górne światło zapalone + OrderNext(Obey_train); //jazda pociągowa + else + OrderNext(Shunt); //jazda manewrowa + if (mvOccupied->Vel>=1.0) //jeśli jedzie (dla 0.1 ma stać) + iDrivigFlags&=~moveStopHere; //to ma nie czekać na sygnał, tylko jechać + else + iDrivigFlags|=moveStopHere; //a jak stoi, to niech czeka + } +/* od wersji 357 oczekujemy podania komend dla AI przez scenerię + if (OrderCurrentGet()) + {if (OrderCurrentGet()iLights[mvOccupied->CabNo<0?1:0]&4) //górne światło + OrderNext(Obey_train); //jazda pociągowa + else + OrderNext(Shunt); //jazda manewrowa + } + } + else //jeśli jest w stanie Wait_for_orders + JumpToFirstOrder(); //uruchomienie? + // czy dac ponizsze? to problematyczne + //SetVelocity(pVehicle->GetVelocity(),-1); //utrzymanie dotychczasowej? + if (pVehicle->GetVelocity()>0.0) + SetVelocity(-1,-1); //AI ustali sobie odpowiednią prędkość +*/ + //Activation(); //przeniesie użytkownika w ostatnio wybranym kierunku + CheckVehicles(); //ustawienie świateł + TableClear(); //ponowne utworzenie tabelki, bo człowiek mógł pojechać niezgodnie z sygnałami + } + else + {//a teraz użytkownik + AIControllFlag=Humandriver; + pVehicle->Controller=Humandriver; + } +}; + +void __fastcall TController::DirectionForward(bool forward) +{//ustawienie jazdy do przodu dla true i do tyłu dla false (zależy od kabiny) + while (mvControlling->MainCtrlPos) //samo zapętlenie DecSpeed() nie wystarcza + DecSpeed(true); //wymuszenie zerowania nastawnika jazdy, inaczej się może zawiesić + if (forward) + while (mvOccupied->ActiveDir<=0) + mvOccupied->DirectionForward(); //do przodu w obecnej kabinie + else + while (mvOccupied->ActiveDir>=0) + mvOccupied->DirectionBackward(); //do tyłu w obecnej kabinie + if (mvOccupied->EngineType==DieselEngine) //specjalnie dla SN61 + if (iDrivigFlags&moveActive) //jeśli był już odpalony + if (mvControlling->RList[mvControlling->MainCtrlPos].Mn==0) + mvControlling->IncMainCtrl(1); //żeby nie zgasł +}; + +AnsiString __fastcall TController::Relation() +{//zwraca relację pociągu + return TrainParams->ShowRelation(); +}; + +AnsiString __fastcall TController::TrainName() +{//zwraca relację pociągu + return TrainParams->TrainName; +}; + +int __fastcall TController::StationCount() +{//zwraca ilość stacji (miejsc zatrzymania) + return TrainParams->StationCount; +}; + +int __fastcall TController::StationIndex() +{//zwraca indeks aktualnej stacji (miejsca zatrzymania) + return TrainParams->StationIndex; +}; + +bool __fastcall TController::IsStop() +{//informuje, czy jest zatrzymanie na najbliższej stacji + return TrainParams->IsStop(); +}; + +void __fastcall TController::MoveTo(TDynamicObject *to) +{//przesunięcie AI do innego pojazdu (przy zmianie kabiny) + //mvOccupied->CabDeactivisation(); //wyłączenie kabiny w opuszczanym + pVehicle->Mechanik=to->Mechanik; //żeby się zamieniły, jak jest jakieś drugie + pVehicle=to; + ControllingSet(); //utworzenie połączenia do sterowanego pojazdu + pVehicle->Mechanik=this; + //iDirection=0; //kierunek jazdy trzeba dopiero zgadnąć +}; + +void __fastcall TController::ControllingSet() +{//znajduje człon do sterowania w EZT będzie to silnikowy + //problematyczne jest sterowanie z członu biernego, dlatego damy AI silnikowy + //dzięki temu będzie wirtualna kabina w silnikowym, działająca w rozrządczym + //w plikach FIZ zostały zgubione ujemne maski sprzęgów, stąd problemy z EZT + mvOccupied=pVehicle->MoverParameters; //domyślny skrót do obiektu parametrów + mvControlling=pVehicle->ControlledFind()->MoverParameters; //poszukiwanie członu sterowanego +}; + +AnsiString __fastcall TController::TableText(int i) +{//pozycja tabelki prędkości + i=(iFirst+i)%iSpeedTableSize; //numer pozycji + if (i!=iLast) //w (iLast) znajduje się kolejny tor do przeskanowania, ale nie jest ona aktywną + return sSpeedTable[i].TableText(); + return ""; //wskaźnik końca +}; + +int __fastcall TController::CrossRoute(TTrack *tr) +{//zwraca numer segmentu dla skrzyżowania (tr) + //pożądany numer segmentu jest określany podczas skanowania drogi + //droga powinna być określona sposobem przejazdu przez skrzyżowania albo współrzędnymi miejsca docelowego + for (int i=iFirst;i!=iLast;i=(i+1)%iSpeedTableSize) + {//trzeba przejrzeć tabelę skanowania w poszukiwaniu (tr) + //i jak się znajdzie, to zwrócić zapamiętany numer segmentu i kierunek przejazdu (-6..-1,1..6) + if ((sSpeedTable[i].iFlags&3)==3) //jeśli pozycja istotna (1) oraz odcinek (2) + if (sSpeedTable[i].trTrack==tr) //jeśli pozycja odpowiadająca skrzyżowaniu (tr) + return (sSpeedTable[i].iFlags>>28); //najstarsze 4 bity jako liczba -8..7 + } + return 0; //nic nie znaleziono? +}; + +void __fastcall TController::RouteSwitch(int d) +{//ustawienie kierunku jazdy z kabiny + d&=3; + if (d) + if (iRouteWanted!=d) + {//nowy kierunek + iRouteWanted=d; //zapamiętanie + if (mvOccupied->CategoryFlag&2) //jeśli samochód + for (int i=iFirst;i!=iLast;i=(i+1)%iSpeedTableSize) + {//szukanie pierwszego skrzyżowania i resetowanie kierunku na nim + if ((sSpeedTable[i].iFlags&3)==3) //jeśli pozycja istotna (1) oraz odcinek (2) + if ((sSpeedTable[i].iFlags&32)==0) //odcinek nie może być miniętym + if (sSpeedTable[i].trTrack->eType==tt_Cross) //jeśli skrzyżowanie + {//obcięcie tabelki skanowania przed skrzyżowaniem, aby ponownie wybrać drogę + iLast=i-1; //ponowne skanowanie skrzyżowania (w zwrotnicach jest iLast=i, ale tam jest prościej) + if (iLast<0) iLast+=iSpeedTableSize; //bo tabelka jest zapętlona + return; + } + } + } +}; +AnsiString __fastcall TController::OwnerName() +{ + return pVehicle?pVehicle->MoverParameters->Name:AnsiString("none"); +}; + diff --git a/Driver.h b/Driver.h new file mode 100644 index 00000000..d3b72c88 --- /dev/null +++ b/Driver.h @@ -0,0 +1,320 @@ +//--------------------------------------------------------------------------- + +#ifndef DriverH +#define DriverH + +#include "Classes.h" +#include "dumb3d.h" +#include +using namespace Math3D; + +enum TOrders +{//rozkazy dla AI + Wait_for_orders=0, //czekanie na dostarczenie następnych rozkazów + //operacje tymczasowe + Prepare_engine=1, //włączenie silnika + Release_engine=2, //wyłączenie silnika + Change_direction=4, //zmiana kierunku (bez skanowania sygnalizacji) + Connect=8, //podłączanie wagonów (z częściowym skanowaniem sygnalizacji) + Disconnect=0x10, //odłączanie wagonów (bez skanowania sygnalizacji) + //jazda + Shunt=0x20, //tryb manewrowy + Obey_train=0x40, //tryb pociągowy + Jump_to_first_order=0x60 //zapęlenie do pierwszej pozycji (po co?) +}; + +enum TMovementStatus +{//flagi bitowe ruchu (iDrivigFlags) + moveStopCloser=1, //podjechać blisko W4 (nie podjeżdżać na początku ani po zmianie czoła) + moveStopPoint=2, //stawać na W4 (wyłączone podczas zmiany czoła) + moveActive=4, //pojazd jest załączony i skanuje + movePress=8, //dociskanie przy odłączeniu (zamiast zmiennej Prepare2press) + moveConnect=0x10, //jest blisko innego pojazdu i można próbować podłączyć + movePrimary=0x20, //ma priorytet w składzie (master) + moveLate=0x40, //flaga spóźnienia, włączy bardziej + moveStopHere=0x80, //nie podjeżdżać do semafora, jeśli droga nie jest wolna + moveStartHorn=0x100, //podawaj sygnał po podaniu wolnej drogi + moveStartHornNow=0x200, //podaj sygnał po odhamowaniu + moveStartHornDone=0x400, //podano sygnał po podaniu wolnej drogi + moveOerlikons=0x800, //skład wyłącznie z zaworami? Oerlikona + moveIncSpeed=0x1000, //załączenie jazdy (np. dla EZT) + moveTrackEnd=0x2000, //dalsza jazda do przodu trwale ograniczona (W5, koniec toru) + moveSwitchFound=0x4000, //na drodze skanowania do przodu jest rozjazd + moveGuardSignal=0x8000, //sygnał od kierownika (minął czas postoju) + moveVisibility=0x10000, //jazda na widoczność po przejechaniu S1 na SBL + moveDoorOpened=0x20000, //drzwi zostały otwarte - doliczyć czas na zamknięcie + movePushPull=0x40000 //zmiana czoła przez zmianę kabiny - nie odczepiać przy zmianie kierunku +}; + +enum TStopReason +{//powód zatrzymania, dodawany do SetVelocity 0 - w zasadzie do usunięcia + stopNone, //nie ma powodu - powinien jechać + stopSleep, //nie został odpalony, to nie pojedzie + stopSem, //semafor zamknięty + stopTime, //czekanie na godzinę odjazdu + stopEnd, //brak dalszej części toru + stopDir, //trzeba stanąć, by zmienić kierunek jazdy + stopJoin, //stoi w celu połączenia wagonów + stopBlock, //przeszkoda na drodze ruchu + stopComm, //otrzymano taką komendę (niewiadomego pochodzenia) + stopOut, //komenda wyjazdu poza stację (raczej nie powinna zatrzymywać!) + stopRadio, //komunikat przekazany radiem (Radiostop) + stopExt, //komenda z zewnątrz + stopError //z powodu błędu w obliczeniu drogi hamowania +}; + +enum TAction +{//przechowanie aktualnego stanu AI od poprzedniego przebłysku świadomości + actUnknown, //stan nieznany (domyślny na początku) + actPantUp, //podnieś pantograf (info dla użytkownika) + actConv, //załącz przetwornicę (info dla użytkownika) + actCompr, //załącz sprężarkę (info dla użytkownika) + actSleep, //śpi (wygaszony) + actDrive, //jazda + actGo, //ruszanie z miejsca + actSlow, //przyhamowanie przed ograniczeniem + sctStop, //hamowanie w celu precyzyjnego zatrzymania + actIdle, //luzowanie składu przed odjazdem + actRelease, //luzowanie składu po zmniejszeniu prędkości + actConnect, //dojazd w celu podczepienia + actWait, //czekanie na przystanku + actReady, //zgłoszona gotowość do odjazdu od kierownika + actEmergency, //hamowanie awaryjne + actGoUphill, //ruszanie pod górę + actTest, //hamowanie kontrolne (podczas jazdy) + actTrial //próba hamulca (na postoju) +}; + +class TSpeedPos +{//pozycja tabeli prędkości dla AI +public: + double fDist; //aktualna odległość (ujemna gdy minięte) + double fVelNext; //prędkość obowiązująca od tego miejsca + //double fAcc; + int iFlags; + //1=istotny,2=tor,4=odwrotnie,8-zwrotnica (może się zmienić),16-stan zwrotnicy,32-minięty,64=koniec,128=łuk + //0x100=event,0x200=manewrowa,0x400=przystanek,0x800=SBL,0x1000=wysłana komenda,0x2000=W5 + //0x10000=zatkanie + vector3 vPos; //współrzędne XYZ do liczenia odległości + struct + { + TTrack *trTrack; //wskaźnik na tor o zmiennej prędkości (zwrotnica, obrotnica) + TEvent *evEvent; //połączenie z eventem albo komórką pamięci + }; + void __fastcall CommandCheck(); +public: + void __fastcall Clear(); + bool __fastcall Update(vector3 *p,vector3 *dir,double &len); + bool __fastcall Set(TEvent *e,double d); + void __fastcall Set(TTrack *t,double d,int f); + AnsiString __fastcall TableText(); +}; + +//---------------------------------------------------------------------------- +static const bool Aggressive=true; +static const bool Easyman=false; +static const bool AIdriver=true; +static const bool Humandriver=false; +static const int maxorders=32; //ilość rozkazów w tabelce +static const int maxdriverfails=4; //ile błędów może zrobić AI zanim zmieni nastawienie +extern bool WriteLogFlag; //logowanie parametrów fizycznych +//---------------------------------------------------------------------------- + +class TController +{ +private: //obsługa tabelki prędkości (musi mieć możliwość odhaczania stacji w rozkładzie) + TSpeedPos *sSpeedTable; //najbliższe zmiany prędkości + int iSpeedTableSize; //wielkość tabelki + int iFirst; //aktualna pozycja w tabeli (modulo iSpeedTableSize) + int iLast; //ostatnia wypełniona pozycja w tabeli 0:przeliczać do punktu, <0:podana wartość +public: + double ActualProximityDist; //odległość brana pod uwagę przy wyliczaniu prędkości i przyspieszenia +private: + vector3 vCommandLocation; //polozenie wskaznika, sygnalizatora lub innego obiektu do ktorego odnosi sie komenda + TOrders OrderList[maxorders]; //lista rozkazów + int OrderPos,OrderTop; //rozkaz aktualny oraz wolne miejsce do wstawiania nowych + std::ofstream LogFile; //zapis parametrow fizycznych + std::ofstream AILogFile; //log AI + bool MaxVelFlag; + bool MinVelFlag; + int iDirection; //kierunek jazdy względem sprzęgów pojazdu, w którym siedzi AI (1=przód,-1=tył) + int iDirectionOrder; //żadany kierunek jazdy (służy do zmiany kierunku) + int iVehicleCount; //ilość pojazdów do odłączenia albo zabrania ze składu (-1=wszystkie) + int iCoupler; //maska sprzęgu, jaką należy użyć przy łączeniu (po osiągnięciu trybu Connect), 0 gdy jazda bez łączenia + int iDriverFailCount; //licznik błędów AI + bool Need_TryAgain; //true, jeśli druga pozycja w elektryku nie załapała + bool Need_BrakeRelease; +public: + double fMinProximityDist; //minimalna oległość do przeszkody, jaką należy zachować + double fOverhead1; //informacja o napięciu w sieci trakcyjnej (0=brak drutu, zatrzymaj!) + double fOverhead2; //informacja o sposobie jazdy (-1=normalnie, 0=bez prądu, >0=z opuszczonym i ograniczeniem prędkości) + int iOverheadZero; //suma bitowa jezdy bezprądowej, bity ustawiane przez pojazdy z podniesionymi pantografami + int iOverheadDown; //suma bitowa opuszczenia pantografów, bity ustawiane przez pojazdy z podniesionymi pantografami + double fVoltage; //uśrednione napięcie sieci: przy spadku poniżej wartości minimalnej opóźnić rozruch o losowy czas +private: + double fMaxProximityDist; //akceptowalna odległość stanięcia przed przeszkodą + TStopReason eStopReason; //powód zatrzymania przy ustawieniu zerowej prędkości + AnsiString VehicleName; + double fVelPlus; //dopuszczalne przekroczenie prędkości na ograniczeniu bez hamowania + double fVelMinus; //margines obniżenia prędkości, powodujący załączenie napędu + double fWarningDuration; //ile czasu jeszcze trąbić + double fStopTime; //czas postoju przed dalszą jazdą (np. na przystanku) + double WaitingTime; //zliczany czas oczekiwania do samoistnego ruszenia + double WaitingExpireTime; //maksymlany czas oczekiwania do samoistnego ruszenia + //TEvent* eSignLast; //ostatnio znaleziony sygnał, o ile nie minięty +private: //---//---//---//---// koniec zmiennych, poniżej metody //---//---//---//---// + void __fastcall SetDriverPsyche(); + bool __fastcall PrepareEngine(); + bool __fastcall ReleaseEngine(); + bool __fastcall IncBrake(); + bool __fastcall DecBrake(); + bool __fastcall IncSpeed(); + bool __fastcall DecSpeed(bool force=false); + void __fastcall SpeedSet(); + void __fastcall Doors(bool what); + void __fastcall RecognizeCommand(); //odczytuje komende przekazana lokomotywie + void __fastcall Activation(); //umieszczenie obsady w odpowiednim członie + void __fastcall ControllingSet(); //znajduje człon do sterowania + void __fastcall AutoRewident(); //ustawia hamulce w składzie +public: + Mtable::TTrainParameters* __fastcall Timetable() {return TrainParams;}; + void __fastcall PutCommand(AnsiString NewCommand,double NewValue1,double NewValue2,const _mover::TLocation &NewLocation,TStopReason reason=stopComm); + bool __fastcall PutCommand(AnsiString NewCommand,double NewValue1,double NewValue2,const vector3 *NewLocation,TStopReason reason=stopComm); + bool __fastcall UpdateSituation(double dt); //uruchamiac przynajmniej raz na sekundę + //procedury dotyczace rozkazow dla maszynisty + void __fastcall SetVelocity(double NewVel,double NewVelNext,TStopReason r=stopNone); //uaktualnia informacje o prędkości + bool __fastcall SetProximityVelocity(double NewDist,double NewVelNext); //uaktualnia informacje o prędkości przy nastepnym semaforze +public: + void __fastcall JumpToNextOrder(); + void __fastcall JumpToFirstOrder(); + void __fastcall OrderPush(TOrders NewOrder); + void __fastcall OrderNext(TOrders NewOrder); + TOrders __fastcall OrderCurrentGet(); + TOrders __fastcall OrderNextGet(); + bool __fastcall CheckVehicles(TOrders user=Wait_for_orders); +private: + void __fastcall CloseLog(); + void __fastcall OrderCheck(); +public: + void __fastcall OrdersInit(double fVel); + void __fastcall OrdersClear(); + void __fastcall OrdersDump(); + __fastcall TController + (bool AI, + TDynamicObject *NewControll, + bool InitPsyche, + bool primary=true //czy ma aktywnie prowadzić? + ); + AnsiString __fastcall OrderCurrent(); + void __fastcall WaitingSet(double Seconds); +private: + AnsiString __fastcall Order2Str(TOrders Order); + void __fastcall DirectionForward(bool forward); + int __fastcall OrderDirectionChange(int newdir,TMoverParameters *Vehicle); + void __fastcall Lights(int head,int rear); + double __fastcall Distance(vector3 &p1,vector3 &n,vector3 &p2); +private: //Ra: metody obsługujące skanowanie toru + TEvent* __fastcall CheckTrackEvent(double fDirection,TTrack *Track); + bool __fastcall TableCheckEvent(TEvent *e); + bool __fastcall TableAddNew(); + bool __fastcall TableNotFound(TEvent *e); + void __fastcall TableClear(); + TEvent* __fastcall TableCheckTrackEvent(double fDirection,TTrack *Track); + void __fastcall TableTraceRoute(double fDistance,TDynamicObject *pVehicle=NULL); + void __fastcall TableCheck(double fDistance); + TCommandType __fastcall TableUpdate(double &fVelDes,double &fDist,double &fNext,double &fAcc); + void __fastcall TablePurger(); +private: //Ra: stare funkcje skanujące, używane do szukania sygnalizatora z tyłu + bool __fastcall BackwardTrackBusy(TTrack *Track); + TEvent* __fastcall CheckTrackEventBackward(double fDirection,TTrack *Track); + TTrack* __fastcall BackwardTraceRoute(double &fDistance,double &fDirection,TTrack *Track,TEvent*&Event); + void __fastcall SetProximityVelocity(double dist,double vel,const vector3 *pos); + TCommandType __fastcall BackwardScan(); +public: + void __fastcall PhysicsLog(); + AnsiString __fastcall StopReasonText(); + __fastcall ~TController(); + AnsiString __fastcall NextStop(); + void __fastcall TakeControl(bool yes); + AnsiString __fastcall Relation(); + AnsiString __fastcall TrainName(); + int __fastcall StationCount(); + int __fastcall StationIndex(); + bool __fastcall IsStop(); + bool __fastcall Primary() {return this?bool(iDrivigFlags&movePrimary):false;}; + int inline __fastcall DrivigFlags() {return iDrivigFlags;}; + void __fastcall MoveTo(TDynamicObject *to); + void __fastcall DirectionInitial(); + AnsiString __fastcall TableText(int i); + int __fastcall CrossRoute(TTrack *tr); + void __fastcall RouteSwitch(int d); + AnsiString __fastcall OwnerName(); +}; + +#endif diff --git a/DynObj.cpp b/DynObj.cpp new file mode 100644 index 00000000..051d1731 --- /dev/null +++ b/DynObj.cpp @@ -0,0 +1,4358 @@ +//--------------------------------------------------------------------------- +/* + MaSzyna EU07 locomotive simulator + Copyright (C) 2001-2004 Marcin Wozniak, Maciej Czapkiewicz and others + +*/ + + +#include "system.hpp" +#include "classes.hpp" +#pragma hdrstop + +#include "DynObj.h" + +#include "Timer.h" +#include "Usefull.h" +//McZapkie-260202 +#include "Globals.h" +#include "Texture.h" +#include "AirCoupler.h" + +#include "TractionPower.h" +#include "Ground.h" //bo Global::pGround->bDynamicRemove +#include "Event.h" +#include "Driver.h" +#include "Camera.h" //bo likwidujemy trzęsienie +#include "Console.h" +#include "Traction.h" +#pragma package(smart_init) + +//Ra: taki zapis funkcjonuje lepiej, ale może nie jest optymalny +#define vWorldFront vector3(0,0,1) +#define vWorldUp vector3(0,1,0) +#define vWorldLeft CrossProduct(vWorldUp,vWorldFront) + +//Ra: bo te poniżej to się powielały w każdym module odobno +//vector3 vWorldFront=vector3(0,0,1); +//vector3 vWorldUp=vector3(0,1,0); +//vector3 vWorldLeft=CrossProduct(vWorldUp,vWorldFront); + +#define M_2PI 6.283185307179586476925286766559; +const float maxrot=(M_PI/3.0); //60° + +//--------------------------------------------------------------------------- +void __fastcall TAnimPant::AKP_4E() +{//ustawienie wymiarów dla pantografu AKP-4E + vPos=vector3(0,0,0); //przypisanie domyśnych współczynników do pantografów + fLenL1=1.22; //1.176289 w modelach + fLenU1=1.755; //1.724482197 w modelach + fHoriz=0.535; //0.54555075 przesunięcie ślizgu w długości pojazdu względem osi obrotu dolnego ramienia + fHeight=0.07; //wysokość ślizgu ponad oś obrotu + fWidth=0.635; //połowa szerokości ślizgu, 0.635 dla AKP-1 i AKP-4E + fAngleL0=DegToRad(2.8547285515689267247882521833308); + fAngleL=fAngleL0; //początkowy kąt dolnego ramienia + //fAngleU0=acos((1.22*cos(fAngleL)+0.535)/1.755); //górne ramię + fAngleU0=acos((fLenL1*cos(fAngleL)+fHoriz)/fLenU1); //górne ramię + fAngleU=fAngleU0; //początkowy kąt + //PantWys=1.22*sin(fAngleL)+1.755*sin(fAngleU); //wysokość początkowa + PantWys=fLenL1*sin(fAngleL)+fLenU1*sin(fAngleU)+fHeight; //wysokość początkowa + PantTraction=PantWys; + hvPowerWire=NULL; + fWidthExtra=0.381; //(2.032m-1.027)/2 + //poza obszarem roboczym jest aproksymacja łamaną o 5 odcinkach + fHeightExtra[0]= 0.0; //+0.0762 + fHeightExtra[1]=-0.01; //+0.1524 + fHeightExtra[2]=-0.03; //+0.2286 + fHeightExtra[3]=-0.07; //+0.3048 + fHeightExtra[4]=-0.15; //+0.3810 +}; +//--------------------------------------------------------------------------- +int __fastcall TAnim::TypeSet(int i,int fl) +{//ustawienie typu animacji i zależnej od niego ilości animowanych submodeli + fMaxDist=-1.0; //normalnie nie pokazywać + switch (i) + {//maska 0x000F: ile używa wskaźników na submodele (0 gdy jeden, wtedy bez tablicy) + //maska 0x00F0: 0-osie,1-drzwi,2-obracane,3-zderzaki,4-wózki,5-pantografy,6-tłoki + //maska 0xFF00: ile używa liczb float dla współczynników i stanu + case 0: iFlags=0x000; break; //0-oś + case 1: iFlags=0x010; break; //1-drzwi + case 2: iFlags=0x020; + fParam=fl?new float[fl]:NULL; + iFlags+=fl<<8; + break; //2-wahacz, dźwignia itp. + case 3: iFlags=0x030; break; //3-zderzak + case 4: iFlags=0x040; break; //4-wózek + case 5: //5-pantograf - 5 submodeli + iFlags=0x055; + fParamPants=new TAnimPant(); + fParamPants->AKP_4E(); + break; + case 6: iFlags=0x068; break; //6-tłok i rozrząd - 8 submodeli + default: iFlags=0; + } + yUpdate=NULL; + return iFlags&15; //ile wskaźników rezerwować dla danego typu animacji +}; +__fastcall TAnim::TAnim() +{//potrzebne to w ogóle? + iFlags=-1; //nieznany typ - destruktor nic nie usuwa +}; +__fastcall TAnim::~TAnim() +{//usuwanie animacji + switch (iFlags&0xF0) + {//usuwanie struktur, zależnie ile zostało stworzonych + case 0x20: //2-wahacz, dźwignia itp. + delete fParam; + break; + case 0x50: //5-pantograf + delete fParamPants; + break; + case 0x60: //6-tłok i rozrząd + break; + } +}; +void __fastcall TAnim::Parovoz() +{//animowanie tłoka i rozrządu parowozu +}; +//--------------------------------------------------------------------------- +TDynamicObject* __fastcall TDynamicObject::FirstFind(int &coupler_nr) +{//szukanie skrajnego połączonego pojazdu w pociagu + //od strony sprzegu (coupler_nr) obiektu (start) + TDynamicObject* temp=this; + for (int i=0;i<300;i++) //ograniczenie do 300 na wypadek zapętlenia składu + { + if (!temp) + return NULL; //Ra: zabezpieczenie przed ewentaulnymi błędami sprzęgów + if (temp->MoverParameters->Couplers[coupler_nr].CouplingFlag==0) + return temp; //nic nie ma już dalej podłączone + if (coupler_nr==0) + {//jeżeli szukamy od sprzęgu 0 + if (temp->PrevConnected) //jeśli mamy coś z przodu + { + if (temp->PrevConnectedNo==0) //jeśli pojazd od strony sprzęgu 0 jest odwrócony + coupler_nr=1-coupler_nr; //to zmieniamy kierunek sprzęgu + temp=temp->PrevConnected; //ten jest od strony 0 + } + else + return temp; //jeśli jednak z przodu nic nie ma + } + else + { + if (temp->NextConnected) + {if (temp->NextConnectedNo==1) //jeśli pojazd od strony sprzęgu 1 jest odwrócony + coupler_nr=1-coupler_nr; //to zmieniamy kierunek sprzęgu + temp=temp->NextConnected; //ten pojazd jest od strony 1 + } + else + return temp; //jeśli jednak z tyłu nic nie ma + } + } + return NULL; //to tylko po wyczerpaniu pętli +}; + +//--------------------------------------------------------------------------- +float __fastcall TDynamicObject::GetEPP() +{//szukanie skrajnego połączonego pojazdu w pociagu + //od strony sprzegu (coupler_nr) obiektu (start) + TDynamicObject* temp=this; + int coupler_nr=0; + float eq=0,am=0; + + for (int i=0;i<300;i++) //ograniczenie do 300 na wypadek zapętlenia składu + { + if (!temp) + break; //Ra: zabezpieczenie przed ewentaulnymi błędami sprzęgów + eq+=temp->MoverParameters->PipePress*temp->MoverParameters->Dim.L; + am+=temp->MoverParameters->Dim.L; + if ((temp->MoverParameters->Couplers[coupler_nr].CouplingFlag&2)!=2) + break; //nic nie ma już dalej podłączone + if (coupler_nr==0) + {//jeżeli szukamy od sprzęgu 0 + if (temp->PrevConnected) //jeśli mamy coś z przodu + { + if (temp->PrevConnectedNo==0) //jeśli pojazd od strony sprzęgu 0 jest odwrócony + coupler_nr=1-coupler_nr; //to zmieniamy kierunek sprzęgu + temp=temp->PrevConnected; //ten jest od strony 0 + } + else + break; //jeśli jednak z przodu nic nie ma + } + else + { + if (temp->NextConnected) + {if (temp->NextConnectedNo==1) //jeśli pojazd od strony sprzęgu 1 jest odwrócony + coupler_nr=1-coupler_nr; //to zmieniamy kierunek sprzęgu + temp=temp->NextConnected; //ten pojazd jest od strony 1 + } + else + break; //jeśli jednak z tyłu nic nie ma + } + } + + temp=this; + coupler_nr=1; + for (int i=0;i<300;i++) //ograniczenie do 300 na wypadek zapętlenia składu + { + if (!temp) + break; //Ra: zabezpieczenie przed ewentaulnymi błędami sprzęgów + eq+=temp->MoverParameters->PipePress*temp->MoverParameters->Dim.L; + am+=temp->MoverParameters->Dim.L; + if ((temp->MoverParameters->Couplers[coupler_nr].CouplingFlag&2)!=2) + break; //nic nie ma już dalej podłączone + if (coupler_nr==0) + {//jeżeli szukamy od sprzęgu 0 + if (temp->PrevConnected) //jeśli mamy coś z przodu + { + if (temp->PrevConnectedNo==0) //jeśli pojazd od strony sprzęgu 0 jest odwrócony + coupler_nr=1-coupler_nr; //to zmieniamy kierunek sprzęgu + temp=temp->PrevConnected; //ten jest od strony 0 + } + else + break; //jeśli jednak z przodu nic nie ma + } + else + { + if (temp->NextConnected) + {if (temp->NextConnectedNo==1) //jeśli pojazd od strony sprzęgu 1 jest odwrócony + coupler_nr=1-coupler_nr; //to zmieniamy kierunek sprzęgu + temp=temp->NextConnected; //ten pojazd jest od strony 1 + } + else + break; //jeśli jednak z tyłu nic nie ma + } + } + eq-=MoverParameters->PipePress*MoverParameters->Dim.L; + am-=MoverParameters->Dim.L; + return eq/am; +}; + + +//--------------------------------------------------------------------------- +TDynamicObject* __fastcall TDynamicObject::GetFirstDynamic(int cpl_type) +{//Szukanie skrajnego połączonego pojazdu w pociagu + //od strony sprzegu (cpl_type) obiektu szukajacego + //Ra: wystarczy jedna funkcja do szukania w obu kierunkach + return FirstFind(cpl_type); //używa referencji +}; + +/* +TDynamicObject* __fastcall TDynamicObject::GetFirstCabDynamic(int cpl_type) +{//ZiomalCl: szukanie skrajnego obiektu z kabiną + TDynamicObject* temp=this; + int coupler_nr=cpl_type; + for (int i=0;i<300;i++) //ograniczenie do 300 na wypadek zapętlenia składu + { + if (!temp) + return NULL; //Ra: zabezpieczenie przed ewentaulnymi błędami sprzęgów + if (temp->MoverParameters->CabNo!=0&&temp->MoverParameters->SandCapacity!=0) + return temp; //nic nie ma już dalej podłączone + if (temp->MoverParameters->Couplers[coupler_nr].CouplingFlag==0) + return NULL; + if (coupler_nr==0) + {//jeżeli szukamy od sprzęgu 0 + if (temp->PrevConnectedNo==0) //jeśli pojazd od strony sprzęgu 0 jest odwrócony + coupler_nr=1-coupler_nr; //to zmieniamy kierunek sprzęgu + if (temp->PrevConnected) + temp=temp->PrevConnected; //ten jest od strony 0 + } + else + { + if (temp->NextConnectedNo==1) //jeśli pojazd od strony sprzęgu 1 jest odwrócony + coupler_nr=1-coupler_nr; //to zmieniamy kierunek sprzęgu + if (temp->NextConnected) + temp=temp->NextConnected; //ten pojazd jest od strony 1 + } + } + return NULL; //to tylko po wyczerpaniu pętli +}; +*/ + +void TDynamicObject::ABuSetModelShake(vector3 mShake) +{ + modelShake=mShake; +}; + +int __fastcall TDynamicObject::GetPneumatic(bool front, bool red) +{ + int x,y,z; //1=prosty, 2=skośny + if (red) + { + if (front) + { + x=btCPneumatic1.GetStatus(); + y=btCPneumatic1r.GetStatus(); + } + else + { + x=btCPneumatic2.GetStatus(); + y=btCPneumatic2r.GetStatus(); + } + } + else + if (front) + { + x=btPneumatic1.GetStatus(); + y=btPneumatic1r.GetStatus(); + } + else + { + x=btPneumatic2.GetStatus(); + y=btPneumatic2r.GetStatus(); + } + z=0; //brak węży? + if ((x==1)&&(y==1)) z=3; //dwa proste + if ((x==2)&&(y==0)) z=1; //lewy skośny, brak prawego + if ((x==0)&&(y==2)) z=2; //brak lewego, prawy skośny + + return z; +} + +void __fastcall TDynamicObject::SetPneumatic(bool front,bool red) +{ + int x=0,ten,tamten; + ten=GetPneumatic(front,red); //1=lewy skos,2=prawy skos,3=dwa proste + if (front) + if (PrevConnected) //pojazd od strony sprzęgu 0 + tamten=PrevConnected->GetPneumatic((PrevConnectedNo==0?true:false),red); + if (!front) + if (NextConnected) //pojazd od strony sprzęgu 1 + tamten=NextConnected->GetPneumatic((NextConnectedNo==0?true:false),red); + if (ten==tamten) //jeśli układ jest symetryczny + switch (ten) + { + case 1: x=2; break; //mamy lewy skos, dać lewe skosy + case 2: x=3; break; //mamy prawy skos, dać prawe skosy + case 3: //wszystkie cztery na prosto + if (MoverParameters->Couplers[front?0:1].Render) x=1; else x=4; + break; + } + else + { + if (ten==2) x=4; + if (ten==1) x=1; + if (ten==3) if (tamten==1) x=4; else x=1; + } + if (front) + {if (red) cp1=x; else sp1=x;} //który pokazywać z przodu + else + {if (red) cp2=x; else sp2=x;} //który pokazywać z tyłu +} + +void TDynamicObject::UpdateAxle(TAnim *pAnim) +{//animacja osi + pAnim->smAnimated->SetRotate(float3(1,0,0),*pAnim->dWheelAngle); +}; + +void TDynamicObject::UpdateBoogie(TAnim *pAnim) +{//animacja wózka + pAnim->smAnimated->SetRotate(float3(1,0,0),*pAnim->dWheelAngle); +}; + +void TDynamicObject::UpdateDoorTranslate(TAnim *pAnim) +{//animacja drzwi - przesuw + //WriteLog("Dla drzwi nr:", i); + //WriteLog("Wspolczynnik", DoorSpeedFactor[i]); + //Ra: te współczynniki są bez sensu, bo modyfikują wektor przesunięcia + //w efekcie drzwi otwierane na zewnątrz będą odlatywac dowolnie daleko :) + //ograniczyłem zakres ruchu funkcją max + if (pAnim->smAnimated) + { + if (pAnim->iNumber&1) + pAnim->smAnimated->SetTranslate(vector3(0,0,Max0R(dDoorMoveR*pAnim->fSpeed,dDoorMoveR))); + else + pAnim->smAnimated->SetTranslate(vector3(0,0,Max0R(dDoorMoveL*pAnim->fSpeed,dDoorMoveL))); + } +}; + +void TDynamicObject::UpdateDoorRotate(TAnim *pAnim) +{//animacja drzwi - obrót + if (pAnim->smAnimated) + {//if (MoverParameters->DoorOpenMethod==2) //obrotowe albo dwójłomne (trzeba kombinowac submodelami i ShiftL=90,R=180) + if (pAnim->iNumber&1) + pAnim->smAnimated->SetRotate(float3(1,0,0),dDoorMoveR); + else + pAnim->smAnimated->SetRotate(float3(1,0,0),dDoorMoveL); + } +}; + +void TDynamicObject::UpdateDoorFold(TAnim *pAnim) +{//animacja drzwi - obrót + if (pAnim->smAnimated) + {//if (MoverParameters->DoorOpenMethod==2) //obrotowe albo dwójłomne (trzeba kombinowac submodelami i ShiftL=90,R=180) + if (pAnim->iNumber&1) + {pAnim->smAnimated->SetRotate(float3(0,0,1),dDoorMoveR); + TSubModel *sm=pAnim->smAnimated->ChildGet(); //skrzydło mniejsze + if (sm) + {sm->SetRotate(float3(0,0,1),-dDoorMoveR-dDoorMoveR); //skrzydło większe + sm=sm->ChildGet(); + if (sm) + sm->SetRotate(float3(0,1,0),dDoorMoveR); //podnóżek? + } + } + else + {pAnim->smAnimated->SetRotate(float3(0,0,1),dDoorMoveL); + //SubModel->SetRotate(float3(0,1,0),fValue*360.0); + TSubModel *sm=pAnim->smAnimated->ChildGet(); //skrzydło mniejsze + if (sm) + {sm->SetRotate(float3(0,0,1),-dDoorMoveL-dDoorMoveL); //skrzydło większe + sm=sm->ChildGet(); + if (sm) + sm->SetRotate(float3(0,1,0),dDoorMoveL); //podnóżek? + } + } + } +}; + +void TDynamicObject::UpdatePant(TAnim *pAnim) +{//animacja pantografu - 4 obracane ramiona, ślizg piąty + float a,b,c; + a=RadToDeg(pAnim->fParamPants->fAngleL-pAnim->fParamPants->fAngleL0); + b=RadToDeg(pAnim->fParamPants->fAngleU-pAnim->fParamPants->fAngleU0); + c=a+b; + if (pAnim->smElement[0]) pAnim->smElement[0]->SetRotate(float3(-1,0,0),a); //dolne ramię + if (pAnim->smElement[1]) pAnim->smElement[1]->SetRotate(float3(1,0,0),a); + if (pAnim->smElement[2]) pAnim->smElement[2]->SetRotate(float3(1,0,0),c); //górne ramię + if (pAnim->smElement[3]) pAnim->smElement[3]->SetRotate(float3(-1,0,0),c); + if (pAnim->smElement[4]) pAnim->smElement[4]->SetRotate(float3(-1,0,0),b); //ślizg +}; + +void TDynamicObject::UpdateLeverDouble(TAnim *pAnim) +{//animacja gałki zależna od double + pAnim->smAnimated->SetRotate(float3(1,0,0),pAnim->fSpeed**pAnim->fDoubleBase); +}; +void TDynamicObject::UpdateLeverFloat(TAnim *pAnim) +{//animacja gałki zależna od float + pAnim->smAnimated->SetRotate(float3(1,0,0),pAnim->fSpeed**pAnim->fFloatBase); +}; +void TDynamicObject::UpdateLeverInt(TAnim *pAnim) +{//animacja gałki zależna od int + pAnim->smAnimated->SetRotate(float3(1,0,0),pAnim->fSpeed**pAnim->iIntBase); +}; +void TDynamicObject::UpdateLeverEnum(TAnim *pAnim) +{//ustawienie kąta na wartość wskazaną przez int z tablicy fParam + //pAnim->fParam[0]; - dodać lepkość + pAnim->smAnimated->SetRotate(float3(1,0,0),pAnim->fParam[*pAnim->iIntBase]); +}; + + +//ABu 29.01.05 przeklejone z render i renderalpha: ********************* +void __inline TDynamicObject::ABuLittleUpdate(double ObjSqrDist) +{//ABu290105: pozbierane i uporzadkowane powtarzajace sie rzeczy z Render i RenderAlpha + //dodatkowy warunek, if (ObjSqrDist<...) zeby niepotrzebnie nie zmianiec w obiektach, + //ktorych i tak nie widac + //NBMX wrzesien, MC listopad: zuniwersalnione + btnOn=false; //czy przywrócić stan domyślny po renderowaniu + + if (mdLoad) //tymczasowo ładunek na poziom podłogi + if (vFloor.z>0.0) + mdLoad->GetSMRoot()->SetTranslate(modelShake+vFloor); + + if (ObjSqrDist<160000) //gdy bliżej niż 400m + { + for (int i=0;iGetSMRoot()->SetTranslate(modelShake); + if (mdKabina) + mdKabina->GetSMRoot()->SetTranslate(modelShake); + if (mdLoad) + mdLoad->GetSMRoot()->SetTranslate(modelShake+vFloor); + if (mdLowPolyInt) + mdLowPolyInt->GetSMRoot()->SetTranslate(modelShake); + if (mdPrzedsionek) + mdPrzedsionek->GetSMRoot()->SetTranslate(modelShake); + //ABu: koniec rzucania + //ABu011104: liczenie obrotow wozkow + ABuBogies(); + //Mczapkie-100402: rysowanie lub nie - sprzegow + //ABu-240105: Dodatkowy warunek: if (...).Render, zeby rysowal tylko jeden + //z polaczonych sprzegow + if ((TestFlag(MoverParameters->Couplers[0].CouplingFlag,ctrain_coupler)) + &&(MoverParameters->Couplers[0].Render)) + {btCoupler1.TurnOn(); btnOn=true;} + //else btCoupler1.TurnOff(); + if ((TestFlag(MoverParameters->Couplers[1].CouplingFlag,ctrain_coupler)) + &&(MoverParameters->Couplers[1].Render)) + {btCoupler2.TurnOn(); btnOn=true;} + //else btCoupler2.TurnOff(); + //******************************************************************************** + //przewody powietrzne j.w., ABu: decyzja czy rysowac tylko na podstawie 'render' - juz nie + //przewody powietrzne, yB: decyzja na podstawie polaczen w t3d + if (Global::bnewAirCouplers) + { + SetPneumatic(false,false); //wczytywanie z t3d ulozenia wezykow + SetPneumatic(true,false); //i zapisywanie do zmiennej + SetPneumatic(true,true); //ktore z nich nalezy + SetPneumatic(false,true); //wyswietlic w tej klatce + + if (TestFlag(MoverParameters->Couplers[0].CouplingFlag,ctrain_pneumatic)) + { + switch (cp1) + { + case 1: btCPneumatic1.TurnOn(); break; + case 2: btCPneumatic1.TurnxOn(); break; + case 3: btCPneumatic1r.TurnxOn(); break; + case 4: btCPneumatic1r.TurnOn(); break; + } + btnOn=true; + } + //else + //{ + // btCPneumatic1.TurnOff(); + // btCPneumatic1r.TurnOff(); + //} + + if (TestFlag(MoverParameters->Couplers[1].CouplingFlag,ctrain_pneumatic)) + { + switch (cp2) + { + case 1: btCPneumatic2.TurnOn(); break; + case 2: btCPneumatic2.TurnxOn(); break; + case 3: btCPneumatic2r.TurnxOn(); break; + case 4: btCPneumatic2r.TurnOn(); break; + } + btnOn=true; + } + //else + //{ + // btCPneumatic2.TurnOff(); + // btCPneumatic2r.TurnOff(); + //} + + //przewody zasilajace, j.w. (yB) + if (TestFlag(MoverParameters->Couplers[0].CouplingFlag,ctrain_scndpneumatic)) + { + switch (sp1) + { + case 1: btPneumatic1.TurnOn(); break; + case 2: btPneumatic1.TurnxOn(); break; + case 3: btPneumatic1r.TurnxOn(); break; + case 4: btPneumatic1r.TurnOn(); break; + } + btnOn=true; + } + //else + //{ + // btPneumatic1.TurnOff(); + // btPneumatic1r.TurnOff(); + //} + + if (TestFlag(MoverParameters->Couplers[1].CouplingFlag,ctrain_scndpneumatic)) + { + switch (sp2) + { + case 1: btPneumatic2.TurnOn(); break; + case 2: btPneumatic2.TurnxOn(); break; + case 3: btPneumatic2r.TurnxOn(); break; + case 4: btPneumatic2r.TurnOn(); break; + } + btnOn=true; + } + //else + //{ + // btPneumatic2.TurnOff(); + // btPneumatic2r.TurnOff(); + //} + } +//*********************************************************************************/ + else //po staremu ABu'oewmu + { + //przewody powietrzne j.w., ABu: decyzja czy rysowac tylko na podstawie 'render' + if (TestFlag(MoverParameters->Couplers[0].CouplingFlag,ctrain_pneumatic)) + { + if (MoverParameters->Couplers[0].Render) + btCPneumatic1.TurnOn(); + else + btCPneumatic1r.TurnOn(); + btnOn=true; + } + //else + //{ + // btCPneumatic1.TurnOff(); + // btCPneumatic1r.TurnOff(); + //} + + if (TestFlag(MoverParameters->Couplers[1].CouplingFlag,ctrain_pneumatic)) + { + if (MoverParameters->Couplers[1].Render) + btCPneumatic2.TurnOn(); + else + btCPneumatic2r.TurnOn(); + btnOn=true; + } + //else + //{ + // btCPneumatic2.TurnOff(); + // btCPneumatic2r.TurnOff(); + //} + + //przewody powietrzne j.w., ABu: decyzja czy rysowac tylko na podstawie 'render' //yB - zasilajace + if (TestFlag(MoverParameters->Couplers[0].CouplingFlag,ctrain_scndpneumatic)) + { + if (MoverParameters->Couplers[0].Render) + btPneumatic1.TurnOn(); + else + btPneumatic1r.TurnOn(); + btnOn=true; + } + //else + //{ + // btPneumatic1.TurnOff(); + // btPneumatic1r.TurnOff(); + //} + + if (TestFlag(MoverParameters->Couplers[1].CouplingFlag,ctrain_scndpneumatic)) + { + if (MoverParameters->Couplers[1].Render) + btPneumatic2.TurnOn(); + else + btPneumatic2r.TurnOn(); + btnOn=true; + } + //else + //{ + // btPneumatic2.TurnOff(); + // btPneumatic2r.TurnOff(); + //} + } + //*************************************************************/// koniec wezykow + // uginanie zderzakow + for (int i=0; i<2; i++) + { + double dist=MoverParameters->Couplers[i].Dist/2.0; + if (smBuforLewy[i]) + if (dist<0) + smBuforLewy[i]->SetTranslate(vector3(dist,0,0)); + if (smBuforPrawy[i]) + if (dist<0) + smBuforPrawy[i]->SetTranslate(vector3(dist,0,0)); + } + } + + //Winger 160204 - podnoszenie pantografow + + //przewody sterowania ukrotnionego + if (TestFlag(MoverParameters->Couplers[0].CouplingFlag,ctrain_controll)) + {btCCtrl1.TurnOn(); btnOn=true;} + //else btCCtrl1.TurnOff(); + if (TestFlag(MoverParameters->Couplers[1].CouplingFlag,ctrain_controll)) + {btCCtrl2.TurnOn(); btnOn=true;} + //else btCCtrl2.TurnOff(); + //McZapkie-181103: mostki przejsciowe + if (TestFlag(MoverParameters->Couplers[0].CouplingFlag,ctrain_passenger)) + {btCPass1.TurnOn(); btnOn=true;} + //else btCPass1.TurnOff(); + if (TestFlag(MoverParameters->Couplers[1].CouplingFlag,ctrain_passenger)) + {btCPass2.TurnOn(); btnOn=true;} + //else btCPass2.TurnOff(); + if (MoverParameters->Battery) + {//sygnaly konca pociagu + if (btEndSignals1.Active()) + { + if (TestFlag(iLights[0],2) + ||TestFlag(iLights[0],32)) + {btEndSignals1.TurnOn(); btnOn=true;} + //else btEndSignals1.TurnOff(); + } + else + { + if (TestFlag(iLights[0],2)) + {btEndSignals11.TurnOn(); btnOn=true;} + //else btEndSignals11.TurnOff(); + if (TestFlag(iLights[0],32)) + {btEndSignals13.TurnOn(); btnOn=true;} + //else btEndSignals13.TurnOff(); + } + if (btEndSignals2.Active()) + { + if (TestFlag(iLights[1],2) + ||TestFlag(iLights[1],32)) + {btEndSignals2.TurnOn(); btnOn=true;} + //else btEndSignals2.TurnOff(); + } + else + { + if (TestFlag(iLights[1],2)) + {btEndSignals21.TurnOn(); btnOn=true;} + //else btEndSignals21.TurnOff(); + if (TestFlag(iLights[1],32)) + {btEndSignals23.TurnOn(); btnOn=true;} + //else btEndSignals23.TurnOff(); + } + } + //tablice blaszane: + if (TestFlag(iLights[0],64)) + {btEndSignalsTab1.TurnOn(); btnOn=true;} + //else btEndSignalsTab1.TurnOff(); + if (TestFlag(iLights[1],64)) + {btEndSignalsTab2.TurnOn(); btnOn=true;} + //else btEndSignalsTab2.TurnOff(); + //McZapkie-181002: krecenie wahaczem (korzysta z kata obrotu silnika) + if (iAnimType[ANIM_LEVERS]) + for (int i=0;i<4;++i) + if (smWahacze[i]) + smWahacze[i]->SetRotate(float3(1,0,0),fWahaczeAmp*cos(MoverParameters->eAngle)); + if (Mechanik&&(Controller!=Humandriver)) + {//rysowanie figurki mechanika + if (smMechanik0) //mechanik od strony sprzęgu 0 + if (smMechanik1) //jak jest drugi, to pierwszego jedynie pokazujemy + smMechanik0->iVisible=MoverParameters->ActiveCab>0; + else + {//jak jest tylko jeden, to do drugiej kabiny go obracamy + smMechanik0->iVisible=(MoverParameters->ActiveCab!=0); + smMechanik0->SetRotate(float3(0,0,1),MoverParameters->ActiveCab>=0?0:180); //obrót względem osi Z + } + if (smMechanik1) //mechanik od strony sprzęgu 1 + smMechanik1->iVisible=MoverParameters->ActiveCab<0; + } + //ABu: Przechyly na zakretach + //Ra: przechyłkę załatwiamy na etapie przesuwania modelu + //if (ObjSqrDist<80000) ABuModelRoll(); //przechyłki od 400m + } + if (MoverParameters->Battery) + {//sygnały czoła pociagu //Ra: wyświetlamy bez ograniczeń odległości, by były widoczne z daleka + if (TestFlag(iLights[0],1)) + {btHeadSignals11.TurnOn(); btnOn=true;} + //else btHeadSignals11.TurnOff(); + if (TestFlag(iLights[0],4)) + {btHeadSignals12.TurnOn(); btnOn=true;} + //else btHeadSignals12.TurnOff(); + if (TestFlag(iLights[0],16)) + {btHeadSignals13.TurnOn(); btnOn=true;} + //else btHeadSignals13.TurnOff(); + if (TestFlag(iLights[1],1)) + {btHeadSignals21.TurnOn(); btnOn=true;} + //else btHeadSignals21.TurnOff(); + if (TestFlag(iLights[1],4)) + {btHeadSignals22.TurnOn(); btnOn=true;} + //else btHeadSignals22.TurnOff(); + if (TestFlag(iLights[1],16)) + {btHeadSignals23.TurnOn(); btnOn=true;} + //else btHeadSignals23.TurnOff(); + } +} +//ABu 29.01.05 koniec przeklejenia ************************************* + +double __fastcall ABuAcos(const vector3 &calc_temp) +{ //Odpowiednik funkcji Arccos, bo cos mi tam nie dzialalo. + return atan2(-calc_temp.x,calc_temp.z); //Ra: tak prościej +} + +TDynamicObject* __fastcall TDynamicObject::ABuFindNearestObject(TTrack *Track,TDynamicObject *MyPointer,int &CouplNr) +{//zwraca wskaznik do obiektu znajdujacego sie na torze (Track), którego sprzęg jest najblizszy kamerze + //służy np. do łączenia i rozpinania sprzęgów + //WE: Track - tor, na ktorym odbywa sie poszukiwanie + // MyPointer - wskaznik do obiektu szukajacego + //WY: CouplNr - który sprzęg znalezionego obiektu jest bliższy kamerze + + //Uwaga! Jesli CouplNr==-2 to szukamy njblizszego obiektu, a nie sprzegu!!! + + if ((Track->iNumDynamics)>0) + {//o ile w ogóle jest co przeglądać na tym torze + //vector3 poz; //pozycja pojazdu XYZ w scenerii + //vector3 kon; //wektor czoła względem środka pojazdu wzglęem początku toru + vector3 tmp; //wektor pomiędzy kamerą i sprzęgiem + double dist; //odległość + for (int i=0;iiNumDynamics;i++) + { + if (CouplNr==-2) + {//wektor [kamera-obiekt] - poszukiwanie obiektu + tmp=Global::GetCameraPosition()-Track->Dynamics[i]->vPosition; + dist=tmp.x*tmp.x+tmp.y*tmp.y+tmp.z*tmp.z; //odległość do kwadratu + if (dist<100.0) //10 metrów + return Track->Dynamics[i]; + } + else //jeśli (CouplNr) inne niz -2, szukamy sprzęgu + {//wektor [kamera-sprzeg0], potem [kamera-sprzeg1] + //Powinno byc wyliczone, ale nie zaszkodzi drugi raz: + //(bo co, jesli nie wykonuje sie obrotow wozkow?) - Ra: ale zawsze są liczone współrzędne sprzęgów + //Track->Dynamics[i]->modelRot.z=ABuAcos(Track->Dynamics[i]->Axle0.pPosition-Track->Dynamics[i]->Axle1.pPosition); + //poz=Track->Dynamics[i]->vPosition; //pozycja środka pojazdu + //kon=vector3( //położenie przodu względem środka + // -((0.5*Track->Dynamics[i]->MoverParameters->Dim.L)*sin(Track->Dynamics[i]->modelRot.z)), + // 0, //yyy... jeśli duże pochylenie i długi pojazd, to może być problem + // +((0.5*Track->Dynamics[i]->MoverParameters->Dim.L)*cos(Track->Dynamics[i]->modelRot.z)) + //); + tmp=Global::GetCameraPosition()-Track->Dynamics[i]->vCoulpler[0]; //Ra: pozycje sprzęgów też są zawsze liczone + dist=tmp.x*tmp.x+tmp.y*tmp.y+tmp.z*tmp.z; //odległość do kwadratu + if (dist<25.0) //5 metrów + { + CouplNr=0; + return Track->Dynamics[i]; + } + tmp=Global::GetCameraPosition()-Track->Dynamics[i]->vCoulpler[1]; + dist=tmp.x*tmp.x+tmp.y*tmp.y+tmp.z*tmp.z; //odległość do kwadratu + if (dist<25.0) //5 metrów + { + CouplNr=1; + return Track->Dynamics[i]; + } + } + } + return NULL; + } + return NULL; +} + + + +TDynamicObject* __fastcall TDynamicObject::ABuScanNearestObject(TTrack *Track,double ScanDir,double ScanDist,int &CouplNr) +{//skanowanie toru w poszukiwaniu obiektu najblizszego kamerze + //double MyScanDir=ScanDir; //Moja orientacja na torze. //Ra: nie używane + if (ABuGetDirection()<0) ScanDir=-ScanDir; + TDynamicObject* FoundedObj; + FoundedObj=ABuFindNearestObject(Track,this,CouplNr); //zwraca numer sprzęgu znalezionego pojazdu + if (FoundedObj==NULL) + { + double ActDist; //Przeskanowana odleglosc. + double CurrDist=0; //Aktualna dlugosc toru. + if (ScanDir>=0) ActDist=Track->Length()-RaTranslationGet(); //???-przesunięcie wózka względem Point1 toru + else ActDist=RaTranslationGet(); //przesunięcie wózka względem Point1 toru + while (ActDist0) //do przodu + { + if (Track->iNextDirection) + { + Track=Track->CurrentNext(); + ScanDir=-ScanDir; + } + else + Track=Track->CurrentNext(); + } + else //do tyłu + { + if (Track->iPrevDirection) + Track=Track->CurrentPrev(); + else + { + Track=Track->CurrentPrev(); + ScanDir=-ScanDir; + } + } + if (Track!=NULL) + { //jesli jest kolejny odcinek toru + CurrDist=Track->Length(); + FoundedObj=ABuFindNearestObject(Track, this, CouplNr); + if (FoundedObj!=NULL) + ActDist=ScanDist; + } + else //Jesli nie ma, to wychodzimy. + ActDist=ScanDist; + } + } //Koniec szukania najblizszego toru z jakims obiektem. + return FoundedObj; +} + +//ABu 01.11.04 poczatek wyliczania przechylow pudla ********************** +void __fastcall TDynamicObject::ABuModelRoll() +{//ustawienie przechyłki pojazdu i jego zawartości +// Ra: przechyłkę załatwiamy na etapie przesuwania modelu +} + +//ABu 06.05.04 poczatek wyliczania obrotow wozkow ********************** + +void __fastcall TDynamicObject::ABuBogies() +{//Obracanie wozkow na zakretach. Na razie uwzględnia tylko zakręty, + //bez zadnych gorek i innych przeszkod. + if ((smBogie[0]!=NULL)&&(smBogie[1]!=NULL)) + { + //modelRot.z=ABuAcos(Axle0.pPosition-Axle1.pPosition); //kąt obrotu pojazdu [rad] + //bogieRot[0].z=ABuAcos(Axle0.pPosition-Axle3.pPosition); + bogieRot[0].z=Axle0.vAngles.z; + bogieRot[0]=RadToDeg(modelRot-bogieRot[0]); //mnożenie wektora przez stałą + smBogie[0]->SetRotateXYZ(bogieRot[0]); + //bogieRot[1].z=ABuAcos(Axle2.pPosition-Axle1.pPosition); + bogieRot[1].z=Axle1.vAngles.z; + bogieRot[1]=RadToDeg(modelRot-bogieRot[1]); + smBogie[1]->SetRotateXYZ(bogieRot[1]); + } +}; +//ABu 06.05.04 koniec wyliczania obrotow wozkow ************************ + +//ABu 16.03.03 sledzenie toru przed obiektem: ************************** +void __fastcall TDynamicObject::ABuCheckMyTrack() +{//Funkcja przypisujaca obiekt prawidlowej tablicy Dynamics, + //bo gdzies jest jakis blad i wszystkie obiekty z danego + //pociagu na poczatku stawiane sa na jednym torze i wpisywane + //do jednej tablicy. Wykonuje sie tylko raz - po to 'ABuChecked' + TTrack* OldTrack=MyTrack; + TTrack* NewTrack=Axle0.GetTrack(); + if ((NewTrack!=OldTrack)&&OldTrack) + { + OldTrack->RemoveDynamicObject(this); + NewTrack->AddDynamicObject(this); + } + iAxleFirst=0; //pojazd powiązany z przednią osią - Axle0 +} + +//Ra: w poniższej funkcji jest problem ze sprzęgami +TDynamicObject* __fastcall TDynamicObject::ABuFindObject(TTrack *Track,int ScanDir,Byte &CouplFound,double &dist) +{//Zwraca wskaźnik najbliższego obiektu znajdującego się + //na torze w określonym kierunku, ale tylko wtedy, kiedy + //obiekty mogą się zderzyć, tzn. nie mijają się. + + //WE: Track - tor, na ktorym odbywa sie poszukiwanie, + // MyPointer - wskaznik do obiektu szukajacego. //Ra: zamieniłem na "this" + // ScanDir - kierunek szukania na torze (+1:w stronę Point2, -1:w stronę Point1) + // MyScanDir - kierunek szukania obiektu szukajacego (na jego torze); Ra: nie potrzebne + // MyCouplFound - nr sprzegu obiektu szukajacego; Ra: nie potrzebne + + //WY: wskaznik do znalezionego obiektu. + // CouplFound - nr sprzegu znalezionego obiektu + if (Track->iNumDynamics>0) + {//sens szukania na tym torze jest tylko, gdy są na nim pojazdy + double ObjTranslation; //pozycja najblizszego obiektu na torze + double MyTranslation; //pozycja szukającego na torze + double MinDist=Track->Length(); //najmniejsza znaleziona odleglość (zaczynamy od długości toru) + double TestDist; //robocza odległość od kolejnych pojazdów na danym odcinku + int iMinDist=-1; //indeks wykrytego obiektu + //if (Track->iNumDynamics>1) + // iMinDist+=0; //tymczasowo pułapka + if (MyTrack==Track) //gdy szukanie na tym samym torze + MyTranslation=RaTranslationGet(); //położenie wózka względem Point1 toru + else //gdy szukanie na innym torze + if (ScanDir>0) + MyTranslation=0; //szukanie w kierunku Point2 (od zera) - jesteśmy w Point1 + else + MyTranslation=MinDist; //szukanie w kierunku Point1 (do zera) - jesteśmy w Point2 + if (ScanDir>=0) + {//jeśli szukanie w kierunku Point2 + for (int i=0;iiNumDynamics;i++) + {//pętla po pojazdach + if (Track->Dynamics[i]!=this) //szukający się nie liczy + { + TestDist=(Track->Dynamics[i]->RaTranslationGet())-MyTranslation; //odległogłość tamtego od szukającego + if ((TestDist>0)&&(TestDist<=MinDist)) + {//gdy jest po właściwej stronie i bliżej niż jakiś wcześniejszy + CouplFound=(Track->Dynamics[i]->RaDirectionGet()>0)?1:0; //to, bo (ScanDir>=0) + if (Track->iCategoryFlag&254) //trajektoria innego typu niż tor kolejowy + {//dla torów nie ma sensu tego sprawdzać, rzadko co jedzie po jednej szynie i się mija + //Ra: mijanie samochodów wcale nie jest proste + // Przesuniecie wzgledne pojazdow. Wyznaczane, zeby sprawdzic, + // czy pojazdy faktycznie sie zderzaja (moga byc przesuniete + // w/m siebie tak, ze nie zachodza na siebie i wtedy sie mijaja). + double RelOffsetH; //wzajemna odległość poprzeczna + if (CouplFound) //my na tym torze byśmy byli w kierunku Point2 + //dla CouplFound=1 są zwroty zgodne - istotna różnica przesunięć + RelOffsetH=(MoverParameters->OffsetTrackH-Track->Dynamics[i]->MoverParameters->OffsetTrackH); + else + //dla CouplFound=0 są zwroty przeciwne - przesunięcia sumują się + RelOffsetH=(MoverParameters->OffsetTrackH+Track->Dynamics[i]->MoverParameters->OffsetTrackH); + if (RelOffsetH<0) RelOffsetH=-RelOffsetH; + if (RelOffsetH+RelOffsetH>MoverParameters->Dim.W+Track->Dynamics[i]->MoverParameters->Dim.W) + continue; //odległość większa od połowy sumy szerokości - kolizji nie będzie + //jeśli zahaczenie jest niewielkie, a jest miejsce na poboczu, to zjechać na pobocze + } + iMinDist=i; //potencjalna kolizja + MinDist=TestDist; //odleglość pomiędzy aktywnymi osiami pojazdów + } + } + } + } + else //(ScanDir<0) + { + for (int i=0;iiNumDynamics;i++) + { + if (Track->Dynamics[i]!=this) + { + TestDist=MyTranslation-(Track->Dynamics[i]->RaTranslationGet()); //???-przesunięcie wózka względem Point1 toru + if ((TestDist>0)&&(TestDistDynamics[i]->RaDirectionGet()>0)?0:1; //odwrotnie, bo (ScanDir<0) + if (Track->iCategoryFlag&254) //trajektoria innego typu niż tor kolejowy + {//dla torów nie ma sensu tego sprawdzać, rzadko co jedzie po jednej szynie i się mija + //Ra: mijanie samochodów wcale nie jest proste + // Przesunięcie względne pojazdów. Wyznaczane, żeby sprawdzić, + // czy pojazdy faktycznie się zderzają (mogą być przesunięte + // w/m siebie tak, że nie zachodzą na siebie i wtedy sie mijają). + double RelOffsetH; //wzajemna odległość poprzeczna + if (CouplFound) //my na tym torze byśmy byli w kierunku Point1 + //dla CouplFound=1 są zwroty zgodne - istotna różnica przesunięć + RelOffsetH=(MoverParameters->OffsetTrackH-Track->Dynamics[i]->MoverParameters->OffsetTrackH); + else + //dla CouplFound=0 są zwroty przeciwne - przesunięcia sumują się + RelOffsetH=(MoverParameters->OffsetTrackH+Track->Dynamics[i]->MoverParameters->OffsetTrackH); + if (RelOffsetH<0) RelOffsetH=-RelOffsetH; + if (RelOffsetH+RelOffsetH>MoverParameters->Dim.W+Track->Dynamics[i]->MoverParameters->Dim.W) + continue; //odległość większa od połowy sumy szerokości - kolizji nie będzie + } + iMinDist=i; //potencjalna kolizja + MinDist=TestDist; //odleglość pomiędzy aktywnymi osiami pojazdów + } + } + } + } + dist+=MinDist; //doliczenie odległości przeszkody albo długości odcinka do przeskanowanej odległości + return (iMinDist>=0)?Track->Dynamics[iMinDist]:NULL; + } + dist+=Track->Length(); //doliczenie długości odcinka do przeskanowanej odległości + return NULL; //nie ma pojazdów na torze, to jest NULL +} + +int TDynamicObject::DettachStatus(int dir) +{//sprawdzenie odległości sprzęgów rzeczywistych od strony (dir): 0=przód,1=tył + //Ra: dziwne, że ta funkcja nie jest używana + if (!MoverParameters->Couplers[dir].CouplingFlag) + return 0; //jeśli nic nie podłączone, to jest OK + return (MoverParameters->DettachStatus(dir)); //czy jest w odpowiedniej odległości? +} + +int TDynamicObject::Dettach(int dir) +{//rozłączenie sprzęgów rzeczywistych od strony (dir): 0=przód,1=tył + //zwraca maskę bitową aktualnych sprzegów (0 jeśli rozłączony) + if (ctOwner) + {//jeśli pojazd ma przypisany obiekt nadzorujący skład, to póki są wskaźniki + TDynamicObject *d=this; + while (d) + { + d->ctOwner=NULL; //usuwanie właściciela + d=d->Prev(); + } + d=Next(); + while (d) + { + d->ctOwner=NULL; //usuwanie właściciela + d=d->Next(); //i w drugą stronę + } + } + if (MoverParameters->Couplers[dir].CouplingFlag) //odczepianie, o ile coś podłączone + MoverParameters->Dettach(dir); + return MoverParameters->Couplers[dir].CouplingFlag; //sprzęg po rozłączaniu (czego się nie da odpiąć +} + +void TDynamicObject::CouplersDettach(double MinDist,int MyScanDir) +{//funkcja rozłączajaca podłączone sprzęgi, jeśli odległość przekracza (MinDist) + //MinDist - dystans minimalny, dla ktorego mozna rozłączać + if (MyScanDir>0) + { + if (PrevConnected) //pojazd od strony sprzęgu 0 + { + if (MoverParameters->Couplers[0].CoupleDist>MinDist) //sprzęgi wirtualne zawsze przekraczają + { + if ((PrevConnectedNo?PrevConnected->NextConnected:PrevConnected->PrevConnected)==this) + {//Ra: nie rozłączamy znalezionego, jeżeli nie do nas podłączony (może jechać w innym kierunku) + PrevConnected->MoverParameters->Couplers[PrevConnectedNo].Connected=NULL; + if (PrevConnectedNo==0) + { + PrevConnected->PrevConnectedNo=2; //sprzęg 0 nie podłączony + PrevConnected->PrevConnected=NULL; + } + else if (PrevConnectedNo==1) + { + PrevConnected->NextConnectedNo=2; //sprzęg 1 nie podłączony + PrevConnected->NextConnected=NULL; + } + } + //za to zawsze odłączamy siebie + PrevConnected=NULL; + PrevConnectedNo=2; //sprzęg 0 nie podłączony + MoverParameters->Couplers[0].Connected=NULL; + } + } + } + else + { + if (NextConnected) //pojazd od strony sprzęgu 1 + { + if (MoverParameters->Couplers[1].CoupleDist>MinDist) //sprzęgi wirtualne zawsze przekraczają + { + if ((NextConnectedNo?NextConnected->NextConnected:NextConnected->PrevConnected)==this) + {//Ra: nie rozłączamy znalezionego, jeżeli nie do nas podłączony (może jechać w innym kierunku) + NextConnected->MoverParameters->Couplers[NextConnectedNo].Connected=NULL; + if (NextConnectedNo==0) + { + NextConnected->PrevConnectedNo=2; //sprzęg 0 nie podłączony + NextConnected->PrevConnected=NULL; + } + else if (NextConnectedNo==1) + { + NextConnected->NextConnectedNo=2; //sprzęg 1 nie podłączony + NextConnected->NextConnected=NULL; + } + } + NextConnected=NULL; + NextConnectedNo=2; //sprzęg 1 nie podłączony + MoverParameters->Couplers[1].Connected=NULL; + } + } + } +} + +void TDynamicObject::ABuScanObjects(int ScanDir,double ScanDist) +{//skanowanie toru w poszukiwaniu kolidujących pojazdów + //ScanDir - określa kierunek poszukiwania zależnie od zwrotu prędkości pojazdu + // ScanDir=1 - od strony Coupler0, ScanDir=-1 - od strony Coupler1 + int MyScanDir=ScanDir; //zapamiętanie kierunku poszukiwań na torze początkowym, względem sprzęgów + TTrackFollower *FirstAxle=(MyScanDir>0?&Axle0:&Axle1); //można by to trzymać w trainset + TTrack *Track=FirstAxle->GetTrack(); //tor na którym "stoi" skrajny wózek (może być inny niż tor pojazdu) + if (FirstAxle->GetDirection()<0) //czy oś jest ustawiona w stronę Point1? + ScanDir=-ScanDir; //jeśli tak, to kierunek szukania będzie przeciwny (teraz względem toru) + Byte MyCouplFound; //numer sprzęgu do podłączenia w obiekcie szukajacym + MyCouplFound=(MyScanDir<0)?1:0; + Byte CouplFound; //numer sprzęgu w znalezionym obiekcie (znaleziony wypełni) + TDynamicObject *FoundedObj; //znaleziony obiekt + double ActDist=0; //przeskanowana odleglość; odległość do zawalidrogi + FoundedObj=ABuFindObject(Track,ScanDir,CouplFound,ActDist); //zaczynamy szukać na tym samym torze + +/* + if (FoundedObj) //jak coś znajdzie, to śledzimy + {//powtórzenie wyszukiwania tylko do zastawiania pułepek podczas testów + if (ABuGetDirection()<0) ScanDir=ScanDir; //ustalenie kierunku względem toru + FoundedObj=ABuFindObject(Track,this,ScanDir,CouplFound); + } +*/ + + if (DebugModeFlag) + if (FoundedObj) //kod służący do logowania błędów + if (CouplFound==0) + { + if (FoundedObj->PrevConnected) + if (FoundedObj->PrevConnected!=this) //odświeżenie tego samego się nie liczy + WriteLog("0! Coupler warning on "+asName+":"+AnsiString(MyCouplFound)+" - "+FoundedObj->asName+":0 connected to "+FoundedObj->PrevConnected->asName+":"+AnsiString(FoundedObj->PrevConnectedNo)); + } + else + { + if (FoundedObj->NextConnected) + if (FoundedObj->NextConnected!=this) //odświeżenie tego samego się nie liczy + WriteLog("0! Coupler warning on "+asName+":"+AnsiString(MyCouplFound)+" - "+FoundedObj->asName+":1 connected to "+FoundedObj->NextConnected->asName+":"+AnsiString(FoundedObj->NextConnectedNo)); + } + + + if (FoundedObj==NULL) //jeśli nie ma na tym samym, szukamy po okolicy + {//szukanie najblizszego toru z jakims obiektem + //praktycznie przeklejone z TraceRoute()... + //double CurrDist=0; //aktualna dlugosc toru + if (ScanDir>=0) //uwzględniamy kawalek przeanalizowanego wcześniej toru + ActDist=Track->Length()-FirstAxle->GetTranslation(); //odległość osi od Point2 toru + else + ActDist=FirstAxle->GetTranslation(); //odległość osi od Point1 toru + while (ActDist0) //w kierunku Point2 toru + { + if (Track?Track->iNextDirection:false) //jeśli następny tor jest podpięty od Point2 + ScanDir=-ScanDir; //to zmieniamy kierunek szukania na tym torze + Track=Track->CurrentNext(); //potem dopiero zmieniamy wskaźnik + } + else //w kierunku Point1 + { + if (Track?!Track->iPrevDirection:true) //jeśli poprzedni tor nie jest podpięty od Point2 + ScanDir=-ScanDir; //to zmieniamy kierunek szukania na tym torze + Track=Track->CurrentPrev(); //potem dopiero zmieniamy wskaźnik + } + if (Track) + {//jesli jest kolejny odcinek toru + //CurrDist=Track->Length(); //doliczenie tego toru do przejrzanego dystandu + FoundedObj=ABuFindObject(Track,ScanDir,CouplFound,ActDist); //przejrzenie pojazdów tego toru + if (FoundedObj) + { + //ActDist=ScanDist; //wyjście z pętli poszukiwania + break; + } + } + else //jeśli toru nie ma, to wychodzimy + { + ActDist=ScanDist+1.0; //koniec przeglądania torów + break; + } + } + } // Koniec szukania najbliższego toru z jakimś obiektem. + //teraz odczepianie i jeśli coś się znalazło, doczepianie. + if (MyScanDir>0?PrevConnected:NextConnected) + if ((MyScanDir>0?PrevConnected:NextConnected)!=FoundedObj) + CouplersDettach(1.0,MyScanDir); //odłączamy, jeśli dalej niż metr + // i łączenie sprzęgiem wirtualnym + if (FoundedObj) + {//siebie można bezpiecznie podłączyć jednostronnie do znalezionego + MoverParameters->Attach(MyCouplFound,CouplFound,FoundedObj->MoverParameters,ctrain_virtual); + //MoverParameters->Couplers[MyCouplFound].Render=false; //wirtualnego nie renderujemy + if (MyCouplFound==0) + { + PrevConnected=FoundedObj; //pojazd od strony sprzęgu 0 + PrevConnectedNo=CouplFound; + } + else + { + NextConnected=FoundedObj; //pojazd od strony sprzęgu 1 + NextConnectedNo=CouplFound; + } + if (FoundedObj->MoverParameters->Couplers[CouplFound].CouplingFlag==ctrain_virtual) + {//Ra: wpinamy się wirtualnym tylko jeśli znaleziony ma wirtualny sprzęg + FoundedObj->MoverParameters->Attach(CouplFound,MyCouplFound,this->MoverParameters,ctrain_virtual); + if (CouplFound==0) //jeśli widoczny sprzęg 0 znalezionego + { + if (DebugModeFlag) + if (FoundedObj->PrevConnected) + if (FoundedObj->PrevConnected!=this) + WriteLog("1! Coupler warning on "+asName+":"+AnsiString(MyCouplFound)+" - "+FoundedObj->asName+":0 connected to "+FoundedObj->PrevConnected->asName+":"+AnsiString(FoundedObj->PrevConnectedNo)); + FoundedObj->PrevConnected=this; + FoundedObj->PrevConnectedNo=MyCouplFound; + } + else //jeśli widoczny sprzęg 1 znalezionego + { + if (DebugModeFlag) + if (FoundedObj->NextConnected) + if (FoundedObj->NextConnected!=this) + WriteLog("1! Coupler warning on "+asName+":"+AnsiString(MyCouplFound)+" - "+FoundedObj->asName+":1 connected to "+FoundedObj->NextConnected->asName+":"+AnsiString(FoundedObj->NextConnectedNo)); + FoundedObj->NextConnected=this; + FoundedObj->NextConnectedNo=MyCouplFound; + } + } + //Ra: jeśli dwa samochody się mijają na odcinku przed zawrotką, to odległość między nimi nie może być liczona w linii prostej! + fTrackBlock=MoverParameters->Couplers[MyCouplFound].CoupleDist; //odległość do najbliższego pojazdu w linii prostej + if (Track->iCategoryFlag>1) //jeśli samochód + if (ActDist>MoverParameters->Dim.L+FoundedObj->MoverParameters->Dim.L) //przeskanowana odległość większa od długości pojazdów + //else if (ActDistasName); + } + else //nic nie znalezione, to nie ma przeszkód + fTrackBlock=10000.0; +} +//----------ABu: koniec skanowania pojazdow + +__fastcall TDynamicObject::TDynamicObject() +{ + modelShake=vector3(0,0,0); + fTrackBlock=10000.0; //brak przeszkody na drodze + btnOn=false; + vUp=vWorldUp; + vFront=vWorldFront; + vLeft=vWorldLeft; + iNumAxles=0; + MoverParameters=NULL; + Mechanik=NULL; + MechInside=false; + //McZapkie-270202 + Controller=AIdriver; + bDisplayCab=false; //030303 + bBrakeAcc=false; + NextConnected=PrevConnected=NULL; + NextConnectedNo=PrevConnectedNo=2; //ABu: Numery sprzegow. 2=nie podłączony + CouplCounter=50; //będzie sprawdzać na początku + asName=""; + bEnabled=true; + MyTrack=NULL; + //McZapkie-260202 + dRailLength=25.0; + for (int i=0;iiLights; //wskaźnik na stan własnych świateł (zmienimy dla rozrządczych EZT) + //McZapkie: TypeName musi byc nazwą CHK/MMD pojazdu + if (!MoverParameters->LoadChkFile(asBaseDir)) + {//jak wczytanie CHK się nie uda, to błąd + if (ConversionError==-8) + ErrorLog("Missed file: "+BaseDir+"\\"+Type_Name+".fiz"); + Error("Cannot load dynamic object "+asName+" from:\r\n"+BaseDir+"\\"+Type_Name+".fiz\r\nError "+ConversionError+" in line "+LineCount); + return 0.0; //zerowa długość to brak pojazdu + } + bool driveractive=(fVel!=0.0); //jeśli prędkość niezerowa, to aktywujemy ruch + if (!MoverParameters->CheckLocomotiveParameters(driveractive,(fVel>0?1:-1)*Cab*(iDirection?1:-1))) //jak jedzie lub obsadzony to gotowy do drogi + { + Error("Parameters mismatch: dynamic object "+asName+" from\n"+BaseDir+"\\"+Type_Name); + return 0.0; //zerowa długość to brak pojazdu + } + MoverParameters->BrakeLevelSet(MoverParameters->BrakeCtrlPos); //poprawienie hamulca po ewentualnym przestawieniu przez Pascal + +//dodatkowe parametry yB + MoreParams+="."; //wykonuje o jedną iterację za mało, więc trzeba mu dodać kropkę na koniec + int kropka=MoreParams.Pos("."); //znajdź kropke + AnsiString ActPar; //na parametry + while (kropka>0) //jesli sa kropki jeszcze + { + int dlugosc=MoreParams.Length(); + ActPar=MoreParams.SubString(1,kropka-1).UpperCase(); //pierwszy parametr; + MoreParams=MoreParams.SubString(kropka+1,dlugosc-kropka); //reszta do dalszej obrobki + kropka=MoreParams.Pos("."); + + if(ActPar.SubString(1,1)=="B") //jesli hamulce + { //sprawdzanie kolejno nastaw + WriteLog("Wpis hamulca: " + ActPar); + if (ActPar.Pos("G")>0) {MoverParameters->BrakeDelaySwitch(bdelay_G);} + if (ActPar.Pos("P")>0) {MoverParameters->BrakeDelaySwitch(bdelay_P);} + if (ActPar.Pos("R")>0) {MoverParameters->BrakeDelaySwitch(bdelay_R);} + if (ActPar.Pos("M")>0) {MoverParameters->BrakeDelaySwitch(bdelay_R); MoverParameters->BrakeDelaySwitch(bdelay_R+bdelay_M);} + //wylaczanie hamulca + if (ActPar.Pos("<>")>0) //wylaczanie na probe hamowania naglego + { + MoverParameters->BrakeStatus|=128; //wylacz + } + if (ActPar.Pos("0")>0) //wylaczanie na sztywno + { + MoverParameters->BrakeStatus|=128; //wylacz + MoverParameters->Hamulec->ForceEmptiness(); + MoverParameters->BrakeReleaser(1); //odluznij automatycznie + } + if (ActPar.Pos("E")>0) //oprozniony + { + MoverParameters->Hamulec->ForceEmptiness(); + MoverParameters->BrakeReleaser(1); //odluznij automatycznie + MoverParameters->Pipe->CreatePress(0); + MoverParameters->Pipe2->CreatePress(0); + } + if (ActPar.Pos("Q")>0) //oprozniony + { +// MoverParameters->Hamulec->ForceEmptiness(); //TODO: sprawdzic, dlaczego pojawia sie blad przy uzyciu tej linijki w lokomotywie + MoverParameters->BrakeReleaser(1); //odluznij automatycznie + MoverParameters->Pipe->CreatePress(0.0); + MoverParameters->PipePress=0.0; + MoverParameters->Pipe2->CreatePress(0.0); + MoverParameters->ScndPipePress=0.0; + MoverParameters->PantVolume=1; + MoverParameters->PantPress=0; + MoverParameters->CompressedVolume=0; + } + + if (ActPar.Pos("1")>0) //wylaczanie 10% + { + if (random(10)<1) //losowanie 1/10 + { + MoverParameters->BrakeStatus|=128; //wylacz + MoverParameters->Hamulec->ForceEmptiness(); + MoverParameters->BrakeReleaser(1); //odluznij automatycznie + } + } + if (ActPar.Pos("X")>0) //agonalny wylaczanie 20%, usrednienie przekladni + { + if (random(100)<20) //losowanie 20/100 + { + MoverParameters->BrakeStatus|=128; //wylacz + MoverParameters->Hamulec->ForceEmptiness(); + MoverParameters->BrakeReleaser(1); //odluznij automatycznie + } + if (MoverParameters->BrakeCylMult[2]*MoverParameters->BrakeCylMult[1]>0.01) //jesli jest nastawiacz mechaniczny PL + { + float rnd=random(100); + if (rnd<20) //losowanie 20/100 usrednienie + { + MoverParameters->BrakeCylMult[2]=MoverParameters->BrakeCylMult[1]=(MoverParameters->BrakeCylMult[2]+MoverParameters->BrakeCylMult[1])/2; + } + else + if (rnd<70) //losowanie 70/100-20/100 oslabienie + { + MoverParameters->BrakeCylMult[1]=MoverParameters->BrakeCylMult[1]*0.50; + MoverParameters->BrakeCylMult[2]=MoverParameters->BrakeCylMult[2]*0.75; + } + else + if (rnd<80) //losowanie 80/100-70/100 tylko prozny + { + MoverParameters->BrakeCylMult[2]=MoverParameters->BrakeCylMult[1]; + } + else //tylko ladowny + { + MoverParameters->BrakeCylMult[1]=MoverParameters->BrakeCylMult[2]; + } + } + } + //nastawianie ladunku + if (ActPar.Pos("T")>0) //prozny + { MoverParameters->DecBrakeMult(); MoverParameters->DecBrakeMult(); } //dwa razy w dol + if (ActPar.Pos("H")>0) //ladowny I (dla P-Ł dalej prozny) + { MoverParameters->IncBrakeMult(); MoverParameters->IncBrakeMult(); MoverParameters->DecBrakeMult(); } //dwa razy w gore i obniz + if (ActPar.Pos("F")>0) //ladowny II + { MoverParameters->IncBrakeMult(); MoverParameters->IncBrakeMult(); } //dwa razy w gore + if (ActPar.Pos("N")>0) //parametr neutralny + { } + } //koniec hamulce + else if(ActPar.SubString(1,1)=="") //tu mozna wpisac inny prefiks i inne rzeczy + { + //jakies inne prefiksy + } + + } //koniec while kropka + + if (MoverParameters->CategoryFlag&2) //jeśli samochód + {//ustawianie samochodow na poboczu albo na środku drogi + if (Track->fTrackWidth<3.5) //jeśli droga wąska + MoverParameters->OffsetTrackH=0.0; //to stawiamy na środku, niezależnie od stanu ruchu + else + if (driveractive) //od 3.5m do 8.0m jedzie po środku pasa, dla szerszych w odległości 1.5m + MoverParameters->OffsetTrackH=Track->fTrackWidth<=8.0?-Track->fTrackWidth*0.25:-1.5; + else //jak stoi, to kołem na poboczu i pobieramy szerokość razem z poboczem, ale nie z chodnikiem + MoverParameters->OffsetTrackH=-0.5*(Track->WidthTotal()-MoverParameters->Dim.W)+0.05; + iHornWarning=0; //nie będzie trąbienia po podaniu zezwolenia na jazdę + if (fDist<0.0) //-0.5*MoverParameters->Dim.L) //jeśli jest przesunięcie do tyłu + if (!Track->CurrentPrev()) //a nie ma tam odcinka i trzeba by coś wygenerować + fDist=-fDist; //to traktujemy, jakby przesunięcie było w drugą stronę + } + //w wagonie tez niech jedzie + //if (MoverParameters->MainCtrlPosNo>0 && + // if (MoverParameters->CabNo!=0) + if (DriverType!="") + {//McZapkie-040602: jeśli coś siedzi w pojeździe + if (Name==AnsiString(Global::asHumanCtrlVehicle)) //jeśli pojazd wybrany do prowadzenia + { + if (DebugModeFlag?false:MoverParameters->EngineType!=Dumb) //jak nie Debugmode i nie jest dumbem + Controller=Humandriver; //wsadzamy tam sterującego + else //w przeciwnym razie trzeba włączyć pokazywanie kabiny + bDisplayCab=true; + } + //McZapkie-151102: rozkład jazdy czytany z pliku *.txt z katalogu w którym jest sceneria + if (DriverType.Pos("1")||DriverType.Pos("2")) + {//McZapkie-110303: mechanik i rozklad tylko gdy jest obsada + //MoverParameters->ActiveCab=MoverParameters->CabNo; //ustalenie aktywnej kabiny (rozrząd) + Mechanik=new TController(Controller,this,Aggressive); + if (TrainName.IsEmpty()) //jeśli nie w składzie + { + Mechanik->DirectionInitial(); //załączenie rozrządu (wirtualne kabiny) itd. + Mechanik->PutCommand("Timetable:",iDirection?-fVel:fVel,0,NULL); //tryb pociągowy z ustaloną prędkością (względem sprzęgów) + } + //if (TrainName!="none") + // Mechanik->PutCommand("Timetable:"+TrainName,fVel,0,NULL); + } + else + if (DriverType=="p") + {//obserwator w charakterze pasażera + //Ra: to jest niebezpieczne, bo w razie co będzie pomagał hamulcem bezpieczeństwa + Mechanik=new TController(Controller,this,Easyman,false); + } + } + // McZapkie-250202 + iAxles=(MaxAxlesNAxles)?MaxAxles:MoverParameters->NAxles; //ilość osi + //wczytywanie z pliku nazwatypu.mmd, w tym model + LoadMMediaFile(asBaseDir,Type_Name,asReplacableSkin); + //McZapkie-100402: wyszukiwanie submodeli sprzegów + btCoupler1.Init("coupler1",mdModel,false); //false - ma być wyłączony + btCoupler2.Init("coupler2",mdModel,false); + btCPneumatic1.Init("cpneumatic1",mdModel); + btCPneumatic2.Init("cpneumatic2",mdModel); + btCPneumatic1r.Init("cpneumatic1r",mdModel); + btCPneumatic2r.Init("cpneumatic2r",mdModel); + btPneumatic1.Init("pneumatic1",mdModel); + btPneumatic2.Init("pneumatic2",mdModel); + btPneumatic1r.Init("pneumatic1r",mdModel); + btPneumatic2r.Init("pneumatic2r",mdModel); + btCCtrl1.Init("cctrl1",mdModel,false); + btCCtrl2.Init("cctrl2",mdModel,false); + btCPass1.Init("cpass1",mdModel,false); + btCPass2.Init("cpass2",mdModel,false); + //sygnaly + //ABu 060205: Zmiany dla koncowek swiecacych: + btEndSignals11.Init("endsignal13",mdModel,false); + btEndSignals21.Init("endsignal23",mdModel,false); + btEndSignals13.Init("endsignal12",mdModel,false); + btEndSignals23.Init("endsignal22",mdModel,false); + iInventory|=btEndSignals11.Active() ?0x01:0; //informacja, czy ma poszczególne światła + iInventory|=btEndSignals21.Active() ?0x02:0; + iInventory|=btEndSignals13.Active() ?0x04:0; + iInventory|=btEndSignals23.Active() ?0x08:0; + //ABu: to niestety zostawione dla kompatybilnosci modeli: + btEndSignals1.Init("endsignals1",mdModel,false); + btEndSignals2.Init("endsignals2",mdModel,false); + btEndSignalsTab1.Init("endtab1",mdModel,false); + btEndSignalsTab2.Init("endtab2",mdModel,false); + iInventory|=btEndSignals1.Active() ?0x10:0; + iInventory|=btEndSignals2.Active() ?0x20:0; + iInventory|=btEndSignalsTab1.Active()?0x40:0; //tabliczki blaszane + iInventory|=btEndSignalsTab2.Active()?0x80:0; + //ABu Uwaga! tu zmienic w modelu! + btHeadSignals11.Init("headlamp13",mdModel,false); //lewe + btHeadSignals12.Init("headlamp11",mdModel,false); //górne + btHeadSignals13.Init("headlamp12",mdModel,false); //prawe + btHeadSignals21.Init("headlamp23",mdModel,false); + btHeadSignals22.Init("headlamp21",mdModel,false); + btHeadSignals23.Init("headlamp22",mdModel,false); + TurnOff(); //resetowanie zmiennych submodeli + //wyszukiwanie zderzakow + if (mdModel) //jeśli ma w czym szukać + for (int i=0;i<2;i++) + { + asAnimName=AnsiString("buffer_left0")+(i+1); + smBuforLewy[i]=mdModel->GetFromName(asAnimName.c_str()); + if (smBuforLewy[i]) + smBuforLewy[i]->WillBeAnimated(); //ustawienie flagi animacji + asAnimName=AnsiString("buffer_right0")+(i+1); + smBuforPrawy[i]=mdModel->GetFromName(asAnimName.c_str()); + if (smBuforPrawy[i]) + smBuforPrawy[i]->WillBeAnimated(); + } + for (int i=0;iDim.L))+fDist; + //McZapkie-250202 end. + Track->AddDynamicObject(this); //wstawiamy do toru na pozycję 0, a potem przesuniemy + //McZapkie: zmieniono na ilosc osi brane z chk + //iNumAxles=(MoverParameters->NAxles>3 ? 4 : 2 ); + iNumAxles=2; + //McZapkie-090402: odleglosc miedzy czopami skretu lub osiami + fAxleDist=Max0R(MoverParameters->BDist,MoverParameters->ADist); + if (fAxleDist<0.2) fAxleDist=0.2; //żeby się dało wektory policzyć + if (fAxleDist>MoverParameters->Dim.L-0.2) //nie mogą być za daleko + fAxleDist=MoverParameters->Dim.L-0.2; //bo będzie "walenie w mur" + double fAxleDistHalf=fAxleDist*0.5; + //WriteLog("Dynamic "+Type_Name+" of length "+MoverParameters->Dim.L+" at "+AnsiString(fDist)); + //if (Cab) //jeśli ma obsadę - zgodność wstecz, jeśli tor startowy ma Event0 + // if (Track->Event0) //jeśli tor ma Event0 + // if (fDist>=0.0) //jeśli jeśli w starych sceneriach początek składu byłby wysunięty na ten tor + // if (fDist<=0.5*MoverParameters->Dim.L+0.2) //ale nie jest wysunięty + // fDist+=0.5*MoverParameters->Dim.L+0.2; //wysunąć go na ten tor + //przesuwanie pojazdu tak, aby jego początek był we wskazanym miejcu + fDist-=0.5*MoverParameters->Dim.L; //dodajemy pół długości pojazdu, bo ustawiamy jego środek (zliczanie na minus) + switch (iNumAxles) + {//Ra: pojazdy wstawiane są na tor początkowy, a potem przesuwane + case 2: //ustawianie osi na torze + Axle0.Init(Track,this,iDirection?1:-1); + Axle0.Move((iDirection?fDist:-fDist)+fAxleDistHalf,false); + Axle1.Init(Track,this,iDirection?1:-1); + Axle1.Move((iDirection?fDist:-fDist)-fAxleDistHalf,false); //false, żeby nie generować eventów + //Axle2.Init(Track,this,iDirection?1:-1); + //Axle2.Move((iDirection?fDist:-fDist)-fAxleDistHalft+0.01),false); + //Axle3.Init(Track,this,iDirection?1:-1); + //Axle3.Move((iDirection?fDist:-fDist)+fAxleDistHalf-0.01),false); + break; + case 4: + Axle0.Init(Track,this,iDirection?1:-1); + Axle0.Move((iDirection?fDist:-fDist)+(fAxleDistHalf+MoverParameters->ADist*0.5),false); + Axle1.Init(Track,this,iDirection?1:-1); + Axle1.Move((iDirection?fDist:-fDist)-(fAxleDistHalf+MoverParameters->ADist*0.5),false); + //Axle2.Init(Track,this,iDirection?1:-1); + //Axle2.Move((iDirection?fDist:-fDist)-(fAxleDistHalf-MoverParameters->ADist*0.5),false); + //Axle3.Init(Track,this,iDirection?1:-1); + //Axle3.Move((iDirection?fDist:-fDist)+(fAxleDistHalf-MoverParameters->ADist*0.5),false); + break; + } + Move(0.0001); //potrzebne do wyliczenia aktualnej pozycji; nie może być zero, bo nie przeliczy pozycji + //teraz jeszcze trzeba przypisać pojazdy do nowego toru, bo przesuwanie początkowe osi nie zrobiło tego + ABuCheckMyTrack(); //zmiana toru na ten, co oś Axle0 (oś z przodu) + TLocation loc; //Ra: ustawienie pozycji do obliczania sprzęgów + loc.X=-vPosition.x; + loc.Y=vPosition.z; + loc.Z=vPosition.y; + MoverParameters->Loc=loc; //normalnie przesuwa ComputeMovement() w Update() + //pOldPos4=Axle1.pPosition; //Ra: nie używane + //pOldPos1=Axle0.pPosition; + //ActualTrack= GetTrack(); //McZapkie-030303 + //ABuWozki 060504 + if (mdModel) //jeśli ma w czym szukać + { + smBogie[0]=mdModel->GetFromName("bogie1"); //Ra: bo nazwy są małymi + smBogie[1]=mdModel->GetFromName("bogie2"); + if (!smBogie[0]) + smBogie[0]=mdModel->GetFromName("boogie01"); //Ra: alternatywna nazwa + if (!smBogie[1]) + smBogie[1]=mdModel->GetFromName("boogie02"); //Ra: alternatywna nazwa + if (smBogie[0]) + smBogie[0]->WillBeAnimated(); + if (smBogie[1]) + smBogie[1]->WillBeAnimated(); + } + //ABu: zainicjowanie zmiennej, zeby nic sie nie ruszylo + //w pierwszej klatce, potem juz liczona prawidlowa wartosc masy + MoverParameters->ComputeConstans(); + /*Ra: to nie działa - Event0 musi być wykonywany ciągle + if (fVel==0.0) //jeśli stoi + if (MoverParameters->CabNo!=0) //i ma kogoś w kabinie + if (Track->Event0) //a jest w tym torze event od stania + RaAxleEvent(Track->Event0); //dodanie eventu stania do kolejki + */ + vFloor=vector3(0,0,MoverParameters->Floor); //wektor podłogi dla wagonów, przesuwa ładunek + return MoverParameters->Dim.L; //długość większa od zera oznacza OK; 2mm docisku? +} + +void __fastcall TDynamicObject::FastMove(double fDistance) +{ + MoverParameters->dMoveLen=MoverParameters->dMoveLen+fDistance; +} + +void __fastcall TDynamicObject::Move(double fDistance) +{//przesuwanie pojazdu po trajektorii polega na przesuwaniu poszczególnych osi + //Ra: wartość prędkości 2km/h ma ograniczyć aktywację eventów w przypadku drgań + if (Axle0.GetTrack()==Axle1.GetTrack()) //przed przesunięciem + {//powiązanie pojazdu z osią można zmienić tylko wtedy, gdy skrajne osie są na tym samym torze + if (MoverParameters->Vel>2) //|[km/h]| nie ma sensu zmiana osi, jesli pojazd drga na postoju + iAxleFirst=(MoverParameters->V>=0.0)?1:0; //[m/s] ?1:0 - aktywna druga oś w kierunku jazdy + //aktualnie eventy aktywuje druga oś, żeby AI nie wyłączało sobie semafora za szybko + } + if (fDistance>0.0) + {//gdy ruch w stronę sprzęgu 0, doliczyć korektę do osi 1 + bEnabled&=Axle0.Move(fDistance,!iAxleFirst); //oś z przodu pojazdu + bEnabled&=Axle1.Move(fDistance/*-fAdjustment*/,iAxleFirst); //oś z tyłu pojazdu + } + else if (fDistance<0.0) + {//gdy ruch w stronę sprzęgu 1, doliczyć korektę do osi 0 + bEnabled&=Axle1.Move(fDistance,iAxleFirst); //oś z tyłu pojazdu prusza się pierwsza + bEnabled&=Axle0.Move(fDistance/*-fAdjustment*/,!iAxleFirst); //oś z przodu pojazdu + } + //Axle2.Move(fDistance,false); //te nigdy pierwsze nie są + //Axle3.Move(fDistance,false); + if (fDistance!=0.0) //nie liczyć ponownie, jeśli stoi + {//liczenie pozycji pojazdu tutaj, bo jest używane w wielu miejscach + vPosition=0.5*(Axle1.pPosition+Axle0.pPosition); //środek między skrajnymi osiami + vFront=Axle0.pPosition-Axle1.pPosition; //wektor pomiędzy skrajnymi osiami + //Ra 2F1J: to nie jest stabilne (powoduje rzucanie taborem) i wymaga dopracowania + fAdjustment=vFront.Length()-fAxleDist; //na łuku będzie ujemny + //if (fabs(fAdjustment)>0.02) //jeśli jest zbyt dużo, to rozłożyć na kilka przeliczeń (wygasza drgania?) + //{//parę centymetrów trzeba by już skorygować; te błędy mogą się też generować na ostrych łukach + // fAdjustment*=0.5; //w jednym kroku korygowany jest ułamek błędu + //} + //else + // fAdjustment=0.0; + vFront=Normalize(vFront); //kierunek ustawienia pojazdu (wektor jednostkowy) + vLeft=Normalize(CrossProduct(vWorldUp,vFront)); //wektor poziomy w lewo, normalizacja potrzebna z powodu pochylenia (vFront) + vUp=CrossProduct(vFront,vLeft); //wektor w górę, będzie jednostkowy + modelRot.z=atan2(-vFront.x,vFront.z); //kąt obrotu pojazdu [rad]; z ABuBogies() + double a=((Axle1.GetRoll()+Axle0.GetRoll())); //suma przechyłek + if (a!=0.0) + {//wyznaczanie przechylenia tylko jeśli jest przechyłka + //można by pobrać wektory normalne z toru... + mMatrix.Identity(); //ta macierz jest potrzebna głównie do wyświetlania + mMatrix.Rotation(a*0.5,vFront); //obrót wzdłuż osi o przechyłkę + vUp=mMatrix*vUp; //wektor w górę pojazdu (przekręcenie na przechyłce) + //vLeft=mMatrix*DynamicObject->vLeft; + //vUp=CrossProduct(vFront,vLeft); //wektor w górę + //vLeft=Normalize(CrossProduct(vWorldUp,vFront)); //wektor w lewo + vLeft=Normalize(CrossProduct(vUp,vFront)); //wektor w lewo + //vUp=CrossProduct(vFront,vLeft); //wektor w górę + } + mMatrix.Identity(); //to też można by od razu policzyć, ale potrzebne jest do wyświetlania + mMatrix.BasisChange(vLeft,vUp,vFront); //przesuwanie jest jednak rzadziej niż renderowanie + mMatrix=Inverse(mMatrix); //wyliczenie macierzy dla pojazdu (potrzebna tylko do wyświetlania?) + //if (MoverParameters->CategoryFlag&2) + {//przesunięcia są używane po wyrzuceniu pociągu z toru + vPosition.x+=MoverParameters->OffsetTrackH*vLeft.x; //dodanie przesunięcia w bok + vPosition.z+=MoverParameters->OffsetTrackH*vLeft.z; //vLeft jest wektorem poprzecznym + //if () na przechyłce będzie dodatkowo zmiana wysokości samochodu + vPosition.y+=MoverParameters->OffsetTrackV; //te offsety są liczone przez moverparam + } + //Ra: skopiowanie pozycji do fizyki, tam potrzebna do zrywania sprzęgów + //MoverParameters->Loc.X=-vPosition.x; //robi to {Fast}ComputeMovement() + //MoverParameters->Loc.Y= vPosition.z; + //MoverParameters->Loc.Z= vPosition.y; + //obliczanie pozycji sprzęgów do liczenia zderzeń + vector3 dir=(0.5*MoverParameters->Dim.L)*vFront; //wektor sprzęgu + vCoulpler[0]=vPosition+dir; //współrzędne sprzęgu na początku + vCoulpler[1]=vPosition-dir; //współrzędne sprzęgu na końcu + MoverParameters->vCoulpler[0]=vCoulpler[0]; //tymczasowo kopiowane na inny poziom + MoverParameters->vCoulpler[1]=vCoulpler[1]; + //bCameraNear= + //if (bCameraNear) //jeśli istotne są szczegóły (blisko kamery) + {//przeliczenie cienia + TTrack *t0=Axle0.GetTrack(); //już po przesunięciu + TTrack *t1=Axle1.GetTrack(); + if ((t0->eEnvironment==e_flat)&&(t1->eEnvironment==e_flat)) //może być e_bridge... + fShade=0.0; //standardowe oświetlenie + else + {//jeżeli te tory mają niestandardowy stopień zacienienia (e_canyon, e_tunnel) + if (t0->eEnvironment==t1->eEnvironment) + {switch (t0->eEnvironment) + {//typ zmiany oświetlenia + case e_canyon: fShade=0.65; break; //zacienienie w kanionie + case e_tunnel: fShade=0.20; break; //zacienienie w tunelu + } + } + else //dwa różne + {//liczymy proporcję + double d=Axle0.GetTranslation(); //aktualne położenie na torze + if (Axle0.GetDirection()<0) + d=t0->fTrackLength-d; //od drugiej strony liczona długość + d/=fAxleDist; //rozsataw osi procentowe znajdowanie się na torze + switch (t0->eEnvironment) + {//typ zmiany oświetlenia - zakładam, że drugi tor ma e_flat + case e_canyon: fShade=(d*0.65)+(1.0-d); break; //zacienienie w kanionie + case e_tunnel: fShade=(d*0.20)+(1.0-d); break; //zacienienie w tunelu + } + switch (t1->eEnvironment) + {//typ zmiany oświetlenia - zakładam, że pierwszy tor ma e_flat + case e_canyon: fShade=d+(1.0-d)*0.65; break; //zacienienie w kanionie + case e_tunnel: fShade=d+(1.0-d)*0.20; break; //zacienienie w tunelu + } + } + } + } + } +}; + +void __fastcall TDynamicObject::AttachPrev(TDynamicObject *Object, int iType) +{//Ra: doczepia Object na końcu składu (nazwa funkcji może być myląca) + //Ra: używane tylko przy wczytywaniu scenerii + /* + //Ra: po wstawieniu pojazdu do scenerii nie miał on ustawionej pozycji, teraz już ma + TLocation loc; + loc.X=-vPosition.x; + loc.Y=vPosition.z; + loc.Z=vPosition.y; + MoverParameters->Loc=loc; //Ra: do obliczania sprzęgów, na starcie nie są przesunięte + loc.X=-Object->vPosition.x; + loc.Y=Object->vPosition.z; + loc.Z=Object->vPosition.y; + Object->MoverParameters->Loc=loc; //ustawienie dodawanego pojazdu + */ + MoverParameters->Attach(iDirection,Object->iDirection^1,Object->MoverParameters,iType,true); + MoverParameters->Couplers[iDirection].Render=false; + Object->MoverParameters->Attach(Object->iDirection^1,iDirection,MoverParameters,iType,true); + Object->MoverParameters->Couplers[Object->iDirection^1].Render=true; //rysowanie sprzęgu w dołączanym + if (iDirection) + {//łączenie standardowe + NextConnected=Object; //normalnie doczepiamy go sobie do sprzęgu 1 + NextConnectedNo=Object->iDirection^1; + } + else + {//łączenie odwrotne + PrevConnected=Object; //doczepiamy go sobie do sprzęgu 0, gdy stoimy odwrotnie + PrevConnectedNo=Object->iDirection^1; + } + if (Object->iDirection) + {//dołączany jest normalnie ustawiany + Object->PrevConnected=this; //on ma nas z przodu + Object->PrevConnectedNo=iDirection; + } + else + {//dołączany jest odwrotnie ustawiany + Object->NextConnected=this; //on ma nas z tyłu + Object->NextConnectedNo=iDirection; + } + if (MoverParameters->TrainType&dt_EZT) //w przypadku łączenia członów, światła w rozrządczym zależą od stanu w silnikowym + if (MoverParameters->Couplers[iDirection].AllowedFlag&ctrain_depot) //gdy sprzęgi łączone warsztatowo (powiedzmy) + if ((MoverParameters->Power<1.0)&&(Object->MoverParameters->Power>1.0)) //my nie mamy mocy, ale ten drugi ma + iLights=Object->MoverParameters->iLights; //to w tym z mocą będą światła załączane, a w tym bez tylko widoczne + else if ((MoverParameters->Power>1.0)&&(Object->MoverParameters->Power<1.0)) //my mamy moc, ale ten drugi nie ma + Object->iLights=MoverParameters->iLights; //to w tym z mocą będą światła załączane, a w tym bez tylko widoczne + return; + //SetPneumatic(1,1); //Ra: to i tak się nie wykonywało po return + //SetPneumatic(1,0); + //SetPneumatic(0,1); + //SetPneumatic(0,0); +} + +bool __fastcall TDynamicObject::UpdateForce(double dt, double dt1, bool FullVer) +{ + if (!bEnabled) + return false; + if (dt>0) + MoverParameters->ComputeTotalForce(dt,dt1,FullVer); //wywalenie WS zależy od ustawienia kierunku + return true; +} + +void __fastcall TDynamicObject::LoadUpdate() +{//przeładowanie modelu ładunku + // Ra: nie próbujemy wczytywać modeli miliony razy podczas renderowania!!! + if ((mdLoad==NULL)&&(MoverParameters->Load>0)) + { + AnsiString asLoadName=asBaseDir+MoverParameters->LoadType+".t3d"; //zapamiętany katalog pojazdu + //asLoadName=MoverParameters->LoadType; + //if (MoverParameters->LoadType!=AnsiString("passengers")) + Global::asCurrentTexturePath=asBaseDir; //bieżąca ścieżka do tekstur to dynamic/... + mdLoad=TModelsManager::GetModel(asLoadName.c_str()); //nowy ładunek + Global::asCurrentTexturePath=AnsiString(szTexturePath); //z powrotem defaultowa sciezka do tekstur + //Ra: w MMD można by zapisać położenie modelu ładunku (np. węgiel) w zależności od załadowania + } + else if (MoverParameters->Load==0) + mdLoad=NULL; //nie ma ładunku + //if ((mdLoad==NULL)&&(MoverParameters->Load>0)) + // { + // mdLoad=NULL; //Ra: to jest tu bez sensu - co autor miał na myśli? + // } + MoverParameters->LoadStatus&=3; //po zakończeniu będzie równe zero +}; + +/* +double __fastcall ComputeRadius(double p1x, double p1z, double p2x, double p2z, + double p3x, double p3z, double p4x, double p4z) +{ + + double v1z= p1x-p2x; + double v1x= p1z-p2z; + double v4z= p3x-p4x; + double v4x= p3z-p4z; + double A1= p2z-p1z; + double B1= p1x-p2x; + double C1= -p1z*B1-p1x*A1; + double A2= p4z-p3z; + double B2= p3x-p4x; + double C2= -p3z*B1-p3x*A1; + double y= (A1*C2/A2-C1)/(B1-A1*B2/A2); + double x= (-B2*y-C2)/A2; +} +*/ +double __fastcall TDynamicObject::ComputeRadius(vector3 p1, vector3 p2, vector3 p3, vector3 p4) +{ +// vector3 v1 + +// TLine l1= TLine(p1,p1-p2); +// TLine l4= TLine(p4,p4-p3); +// TPlane p1= l1.GetPlane(); +// vector3 pt; +// CrossPoint(pt,l4,p1); + double R= 0.0; + vector3 p12= p1-p2; + vector3 p34= p3-p4; + p12= CrossProduct(p12,vector3(0.0,0.1,0.0)); + p12=Normalize(p12); + p34= CrossProduct(p34,vector3(0.0,0.1,0.0)); + p34=Normalize(p34); + if (fabs(p1.x-p2.x)>0.01) + { + if (fabs(p12.x-p34.x)>0.001) + R=(p1.x-p4.x)/(p34.x-p12.x); + } + else + { + if (fabs(p12.z-p34.z)>0.001) + R=(p1.z-p4.z)/(p34.z-p12.z); + } + return(R); +} + +/* +double __fastcall TDynamicObject::ComputeRadius() +{ + double L=0; + double d=0; + d=sqrt(SquareMagnitude(Axle0.pPosition-Axle1.pPosition)); + L=Axle1.GetLength(Axle1.pPosition,Axle1.pPosition-Axle2.pPosition,Axle0.pPosition-Axle3.pPosition,Axle0.pPosition); + + double eps=0.01; + double R= 0; + double L_d; + if ((L>0) || (d>0)) + { + L_d= L-d; + if (L_d>eps) + { + R=L*sqrt(L/(24*(L_d))); + } + } + return R; +} +*/ + +/* Ra: na razie nie potrzebne +void __fastcall TDynamicObject::UpdatePos() +{ + MoverParameters->Loc.X= -vPosition.x; + MoverParameters->Loc.Y= vPosition.z; + MoverParameters->Loc.Z= vPosition.y; +} +*/ + +/* +Ra: + Powinny być dwie funkcje wykonujące aktualizację fizyki. Jedna wykonująca +krok obliczeń, powtarzana odpowiednią liczbę razy, a druga wykonująca zbiorczą +aktualzację mniej istotnych elementów. + Ponadto należało by ustalić odległość składów od kamery i jeśli przekracza +ona np. 10km, to traktować składy jako uproszczone, np. bez wnikania w siły +na sprzęgach, opóźnienie działania hamulca itp. Oczywiście musi mieć to pewną +histerezę czasową, aby te tryby pracy nie przełączały się zbyt szybko. +*/ + + +bool __fastcall TDynamicObject::Update(double dt, double dt1) +{ + if (dt==0) return true; //Ra: pauza + if (!MoverParameters->PhysicActivation&&!MechInside) //to drugie, bo będąc w maszynowym blokuje się fizyka + return true; //McZapkie: wylaczanie fizyki gdy nie potrzeba + if (!MyTrack) + return false; //pojazdy postawione na torach portalowych mają MyTrack==NULL + if (!bEnabled) + return false; //a normalnie powinny mieć bEnabled==false + +//Ra: przeniosłem - no już lepiej tu, niż w wyświetlaniu! +//if ((MoverParameters->ConverterFlag==false) && (MoverParameters->TrainType!=dt_ET22)) +//Ra: to nie może tu być, bo wyłącza sprężarkę w rozrządczym EZT! +//if ((MoverParameters->ConverterFlag==false)&&(MoverParameters->CompressorPower!=0)) +// MoverParameters->CompressorFlag=false; +//if (MoverParameters->CompressorPower==2) +// MoverParameters->CompressorAllow=MoverParameters->ConverterFlag; + + //McZapkie-260202 + if ((MoverParameters->EnginePowerSource.SourceType==CurrentCollector)&&(MoverParameters->Power>1.0)) //aby rozrządczy nie opuszczał silnikowemu + if ((MechInside)||(MoverParameters->TrainType==dt_EZT)) + { + //if ((!MoverParameters->PantCompFlag)&&(MoverParameters->CompressedVolume>=2.8)) + // MoverParameters->PantVolume=MoverParameters->CompressedVolume; + if (MoverParameters->PantPress<(MoverParameters->TrainType==dt_EZT?2.4:3.5)) + {// 3.5 wg http://www.transportszynowy.pl/eu06-07pneumat.php + //"Wyłączniki ciśnieniowe odbieraków prądu wyłączają sterowanie wyłącznika szybkiego oraz uniemożliwiają podniesienie odbieraków prądu, gdy w instalacji rozrządu ciśnienie spadnie poniżej wartości 3,5 bara." + //Ra 2013-12: Niebugocław mówi, że w EZT podnoszą się przy 2.5 + //if (!MoverParameters->PantCompFlag) + // MoverParameters->PantVolume=MoverParameters->CompressedVolume; + MoverParameters->PantFront(false); //opuszczenie pantografów przy niskim ciśnieniu + MoverParameters->PantRear(false); //to idzie w ukrotnieniu, a nie powinno... + } + //Winger - automatyczne wylaczanie malej sprezarki + else if (MoverParameters->PantPress>=4.8) + MoverParameters->PantCompFlag=false; + } //Ra: do Mover to trzeba przenieść, żeby AI też mogło sobie podpompować + + double dDOMoveLen; + + TLocation l; + l.X=-vPosition.x; //przekazanie pozycji do fizyki + l.Y=vPosition.z; + l.Z=vPosition.y; + TRotation r; + r.Rx=r.Ry=r.Rz=0; +//McZapkie: parametry powinny byc pobierane z toru + + //TTrackShape ts; + //ts.R=MyTrack->fRadius; + //if (ABuGetDirection()<0) ts.R=-ts.R; +// ts.R=MyTrack->fRadius; //ujemne promienie są już zamienione przy wczytywaniu + if (Axle0.vAngles.z!=Axle1.vAngles.z) + {//wyliczenie promienia z obrotów osi - modyfikację zgłosił youBy + ts.R=Axle0.vAngles.z-Axle1.vAngles.z; //różnica może dawać stałą ±M_2PI + if (ts.R>M_PI) ts.R-=M_2PI else if (ts.R<-M_PI) ts.R+=M_2PI; //normalizacja +// ts.R=fabs(0.5*MoverParameters->BDist/sin(ts.R*0.5)); + ts.R=-0.5*MoverParameters->BDist/sin(ts.R*0.5); + if ((ts.R>15000.0)||(ts.R<-15000.0)) ts.R=0.0; //szkoda czasu na zbyt duże promienie, 4km to promień nie wymagający przechyłki + } + else ts.R=0.0; + //ts.R=ComputeRadius(Axle1.pPosition,Axle2.pPosition,Axle3.pPosition,Axle0.pPosition); + //Ra: składową pochylenia wzdłużnego mamy policzoną w jednostkowym wektorze vFront + ts.Len=1.0; //Max0R(MoverParameters->BDist,MoverParameters->ADist); + ts.dHtrack=-vFront.y; //Axle1.pPosition.y-Axle0.pPosition.y; //wektor między skrajnymi osiami (!!!odwrotny) + ts.dHrail=(Axle1.GetRoll()+Axle0.GetRoll())*0.5; //średnia przechyłka pudła + //TTrackParam tp; + tp.Width=MyTrack->fTrackWidth; +//McZapkie-250202 + tp.friction=MyTrack->fFriction*Global::fFriction; + tp.CategoryFlag=MyTrack->iCategoryFlag&15; + tp.DamageFlag=MyTrack->iDamageFlag; + tp.QualityFlag=MyTrack->iQualityFlag; + if ((MoverParameters->Couplers[0].CouplingFlag>0) + &&(MoverParameters->Couplers[1].CouplingFlag>0)) + { + MoverParameters->InsideConsist=true; + } + else + { + MoverParameters->InsideConsist=false; + } + //napiecie sieci trakcyjnej + //Ra 15-01: przeliczenie poboru prądu powinno być robione wcześniej, żeby na tym etapie były znane napięcia + //TTractionParam tmpTraction; + //tmpTraction.TractionVoltage=0; + if (MoverParameters->EnginePowerSource.SourceType==CurrentCollector) + {//dla EZT tylko silnikowy + //if (Global::bLiveTraction) + {//Ra 2013-12: to niżej jest chyba trochę bez sensu + double v=MoverParameters->PantRearVolt; + if (v==0.0) + {v=MoverParameters->PantFrontVolt; + if (v==0.0) + if (MoverParameters->TrainType&(dt_EZT|dt_ET40|dt_ET41|dt_ET42)) //dwuczłony mogą mieć sprzęg WN + v=MoverParameters->GetTrainsetVoltage(); //ostatnia szansa + } + if (v!=0.0) + {//jeśli jest zasilanie + NoVoltTime=0; + tmpTraction.TractionVoltage=v; + } + else + { +/* + if (MoverParameters->Vel>0.1f) //jeśli jedzie + if (NoVoltTime==0.0) //tylko przy pierwszym zaniku napięcia + if (MoverParameters->PantFrontUp||MoverParameters->PantRearUp) + //if ((pants[0].fParamPants->PantTraction>1.0)||(pants[1].fParamPants->PantTraction>1.0)) + {//wspomagacz usuwania problemów z siecią + if (!Global::iPause) + {//Ra: tymczasowa teleportacja do miejsca, gdzie brakuje prądu + Global::SetCameraPosition(vPosition+vector3(0,0,5)); //nowa pozycja dla generowania obiektów + Global::pCamera->Init(vPosition+vector3(0,0,5),Global::pFreeCameraInitAngle[0]); //przestawienie + } + Global:l::pGround->Silence(Global::pCamera->Pos); //wyciszenie wszystkiego z poprzedniej pozycji + Globa:iPause|=1; //tymczasowe zapauzowanie, gdy problem z siecią + } +*/ + NoVoltTime=NoVoltTime+dt; + if (NoVoltTime>0.2) //jeśli brak zasilania dłużej niż 0.2 sekundy (25km/h pod izolatorem daje 0.15s) + {//Ra 2F1H: prowizorka, trzeba przechować napięcie, żeby nie wywalało WS pod izolatorem + if (MoverParameters->Vel>0.5) //jeśli jedzie + if (MoverParameters->PantFrontUp||MoverParameters->PantRearUp) //Ra 2014-07: doraźna blokada logowania zimnych lokomotyw - zrobić to trzeba inaczej + //if (NoVoltTime>0.02) //tu można ograniczyć czas rozłączenia + //if (DebugModeFlag) //logowanie nie zawsze + if (MoverParameters->Mains) + {//Ra 15-01: logować tylko, jeśli WS załączony + //if (MoverParameters->PantFrontUp&&pants) + //Ra 15-01: bezwzględne współrzędne pantografu nie są dostępne, więc lepiej się tego nie zaloguje + ErrorLog("Voltage loss: by "+MoverParameters->Name+" at "+FloatToStrF(vPosition.x,ffFixed,7,2)+" "+FloatToStrF(vPosition.y,ffFixed,7,2)+" "+FloatToStrF(vPosition.z,ffFixed,7,2)+", time "+FloatToStrF(NoVoltTime,ffFixed,7,2)); + //if (MoverParameters->PantRearUp) + // if (iAnimType[ANIM_PANTS]>1) + // if (pants[1]) + // ErrorLog("Voltage loss: by "+MoverParameters->Name+" at "+FloatToStrF(vPosition.x,ffFixed,7,2)+" "+FloatToStrF(vPosition.y,ffFixed,7,2)+" "+FloatToStrF(vPosition.z,ffFixed,7,2)+", time "+FloatToStrF(NoVoltTime,ffFixed,7,2)); + } + //Ra 2F1H: nie było sensu wpisywać tu zera po upływie czasu, bo zmienna była tymczasowa, a napięcie zerowane od razu + tmpTraction.TractionVoltage=0; //Ra 2013-12: po co tak? + //pControlled->MainSwitch(false); //może tak? + } + } + } + //else //Ra: nie no, trzeba podnieść pantografy, jak nie będzie drutu, to będą miały prąd po osiągnięciu 1.4m + // tmpTraction.TractionVoltage=0.95*MoverParameters->EnginePowerSource.MaxVoltage; + } + else + tmpTraction.TractionVoltage=0.95*MoverParameters->EnginePowerSource.MaxVoltage; + tmpTraction.TractionFreq=0; + tmpTraction.TractionMaxCurrent=7500; //Ra: chyba za dużo? powinno wywalać przy 1500 + tmpTraction.TractionResistivity=0.3; + +//McZapkie: predkosc w torze przekazac do TrackParam +//McZapkie: Vel ma wymiar [km/h] (absolutny), V ma wymiar [m/s], taka przyjalem notacje + tp.Velmax=MyTrack->VelocityGet(); + + if (Mechanik) + {//Ra 2F3F: do Driver.cpp to przenieść? + MoverParameters->EqvtPipePress=GetEPP(); //srednie cisnienie w PG + if ((Mechanik->Primary())&&(MoverParameters->EngineType==ElectricInductionMotor)) //jesli glowny i z asynchronami, to niech steruje + { //hamulcem lacznie dla calego pociagu/ezt + //1. ustal wymagana sile hamowania calego pociagu + // - opoznienie moze byc ustalane na podstawie charakterystyki + // - opoznienie moze byc ustalane na podstawie mas i cisnien granicznych + // + + //2. ustal mozliwa do realizacji sile hamowania ED + // - w szczegolnosci powinien brac pod uwage rozne sily hamowania + float FED=0; +// for(TDynamicObject *p=GetFirstDynamic(4);p;p->NextC(4)) +// FED+=p->MoverParameters->eimv[eimv_Fmax]; + //3. ustaw pojazdom sile hamowania ED + // - proporcjonalnie do mozliwosci + + //4. ustal potrzebne dohamowanie pneumatyczne + // - od sily zadanej trzeba odjac realizowana przez ED + //5. w razie potrzeby wlacz hamulec utrzymujacy + // - gdy zahamowany ma ponizej 2 km/h + //6. ustaw pojazdom sile hamowania ep + // - proporcjonalnie do masy, do liczby osi, rowne cisnienia - jak bedzie, tak bedzie dobrze + } + +//yB: cos (AI) tu jest nie kompatybilne z czyms (hamulce) +// if (Controller!=Humandriver) +// if (Mechanik->LastReactionTime>0.5) +// { +// MoverParameters->BrakeCtrlPos=0; +// Mechanik->LastReactionTime=0; +// } + + Mechanik->UpdateSituation(dt1); //przebłyski świadomości AI + } + + //fragment "z EXE Kursa" + if (MoverParameters->Mains) //nie wchodzić w funkcję bez potrzeby + if ((!MoverParameters->Battery)&&(Controller==Humandriver)&&(MoverParameters->EngineType!=DieselEngine)&&(MoverParameters->EngineType!=WheelsDriven)) + {//jeśli bateria wyłączona, a nie diesel ani drezyna reczna + if (MoverParameters->MainSwitch(false)) //wyłączyć zasilanie + MoverParameters->EventFlag=true; + } + if (MoverParameters->TrainType==dt_ET42) + {//powinny być wszystkie dwuczłony oraz EZT +/* + //Ra: to jest bez sensu, bo wyłącza WS przy przechodzeniu przez "wewnętrzne" kabiny (z powodu ActiveCab) + //trzeba to zrobić inaczej, np. dla członu A sprawdzać, czy jest B + //albo sprawdzać w momencie załączania WS i zmiany w sprzęgach + if (((TestFlag(MoverParameters->Couplers[1].CouplingFlag,ctrain_controll))&&(MoverParameters->ActiveCab>0)&&(NextConnected->MoverParameters->TrainType!=dt_ET42))||((TestFlag(MoverParameters->Couplers[0].CouplingFlag,ctrain_controll))&&(MoverParameters->ActiveCab<0)&&(PrevConnected->MoverParameters->TrainType!=dt_ET42))) + {//sprawdzenie, czy z tyłu kabiny mamy drugi człon + if (MoverParameters->MainSwitch(false)) + MoverParameters->EventFlag=true; + } + if ((!(TestFlag(MoverParameters->Couplers[1].CouplingFlag,ctrain_controll))&&(MoverParameters->ActiveCab>0))||(!(TestFlag(MoverParameters->Couplers[0].CouplingFlag,ctrain_controll))&&(MoverParameters->ActiveCab<0))) + { + if (MoverParameters->MainSwitch(false)) + MoverParameters->EventFlag=true; + } +*/ + } + + +//McZapkie-260202 - dMoveLen przyda sie przy stukocie kol + dDOMoveLen=GetdMoveLen()+MoverParameters->ComputeMovement(dt,dt1,ts,tp,tmpTraction,l,r); + //yB: zeby zawsze wrzucalo w jedna strone zakretu + MoverParameters->AccN*=-ABuGetDirection(); + //if (dDOMoveLen!=0.0) //Ra: nie może być, bo blokuje Event0 + Move(dDOMoveLen); + if (!bEnabled) //usuwane pojazdy nie mają toru + {//pojazd do usunięcia + Global::pGround->bDynamicRemove=true; //sprawdzić + return false; + } + Global::ABuDebug=dDOMoveLen/dt1; + ResetdMoveLen(); +//McZapkie-260202 +//tupot mew, tfu, stukot kol: + DWORD stat; +//taka prowizorka zeby sciszyc stukot dalekiej lokomotywy + double ObjectDist; + double vol=0; + //double freq; //Ra: nie używane + ObjectDist=SquareMagnitude(Global::pCameraPosition-vPosition); +//McZapkie-270202 + if (MyTrack->fSoundDistance!=-1) + { + if (ObjectDistiDamageFlag)/21; + if (MyTrack->eEnvironment==e_tunnel) + { + vol*=1.1; + //freq=1.02; + } + else + if (MyTrack->eEnvironment==e_bridge) + { + vol*=1.2; + //freq=0.99; //MC: stukot w zaleznosci od tego gdzie jest tor + } + if (MyTrack->fSoundDistance!=dRailLength) + { + dRailLength=MyTrack->fSoundDistance; + for (int i=0; iDim.L; + } + } + if (dRailLength!=-1) + { + if (abs(MoverParameters->V)>0) + { + for (int i=0; iAccV+= 0.5*GetVelocity()/(1+MoverParameters->Vmax); + } + else + {rsStukot[i+1].Stop();} + rsStukot[i].Play(vol,0,MechInside,vPosition); //poprawic pozycje o uklad osi + if (i==1) + MoverParameters->AccV-= 0.5*GetVelocity()/(1+MoverParameters->Vmax); + dRailPosition[i]+=dRailLength; + } + } + } + } + } + } +//McZapkie-260202 end + +//yB: przyspieszacz (moze zadziala, ale dzwiek juz jest) +int flag=MoverParameters->Hamulec->GetSoundFlag(); +if ((bBrakeAcc)&&(TestFlag(flag,sf_Acc))&&(ObjectDist<2500)) + { + sBrakeAcc->SetVolume(-ObjectDist*3-(FreeFlyModeFlag?0:2000)); + sBrakeAcc->Play(0,0,0); + sBrakeAcc->SetPan(10000*sin(ModCamRot)); + } +if ((rsUnbrake.AM!=0)&&(ObjectDist<5000)) + { + if ((TestFlag(flag,sf_CylU)) && ((MoverParameters->BrakePress*MoverParameters->MaxBrakePress[3])>0.05)) + { + vol=Min0R(0.2+1.6*sqrt((MoverParameters->BrakePress>0?MoverParameters->BrakePress:0)/MoverParameters->MaxBrakePress[3]),1); + vol=vol+(FreeFlyModeFlag?0:-0.5)-ObjectDist/5000; + rsUnbrake.SetPan(10000*sin(ModCamRot)); + rsUnbrake.Play(vol,DSBPLAY_LOOPING,MechInside,GetPosition()); + } + else + rsUnbrake.Stop(); + } + + + //fragment z EXE Kursa + /* if (MoverParameters->TrainType==dt_ET42) + { + if ((MoverParameters->DynamicBrakeType=dbrake_switch) && ((MoverParameters->BrakePress > 0.2) || ( MoverParameters->PipePress < 0.36 ))) + { + MoverParameters->StLinFlag=true; + } + else + if ((MoverParameters->DynamicBrakeType=dbrake_switch) && (MoverParameters->BrakePress < 0.1)) + { + MoverParameters->StLinFlag=false; + + } + } */ + if ((MoverParameters->TrainType==dt_ET40) || (MoverParameters->TrainType==dt_EP05)) + {//dla ET40 i EU05 automatyczne cofanie nastawnika - i tak nie będzie to działać dobrze... + /* if ((MoverParameters->MainCtrlPos>MoverParameters->MainCtrlActualPos)&&(abs(MoverParameters->Im)>MoverParameters->IminHi)) + { + MoverParameters->DecMainCtrl(1); + } */ + if (( !Console::Pressed(Global::Keys[k_IncMainCtrl]))&&(MoverParameters->MainCtrlPos>MoverParameters->MainCtrlActualPos)) + { + MoverParameters->DecMainCtrl(1); + } + if (( !Console::Pressed(Global::Keys[k_DecMainCtrl]))&&(MoverParameters->MainCtrlPosMainCtrlActualPos)) + { + MoverParameters->IncMainCtrl(1); //Ra 15-01: a to nie miało być tylko cofanie? + } + } + + + + if (MoverParameters->Vel!=0) + {//McZapkie-050402: krecenie kolami: + dWheelAngle[0]+=114.59155902616464175359630962821*MoverParameters->V*dt1/MoverParameters->WheelDiameterL; //przednie toczne + dWheelAngle[1]+=MoverParameters->nrot*dt1*360.0; //napędne + dWheelAngle[2]+=114.59155902616464175359630962821*MoverParameters->V*dt1/MoverParameters->WheelDiameterT; //tylne toczne + if (dWheelAngle[0]>360.0) dWheelAngle[0]-=360.0; //a w drugą stronę jak się kręcą? + if (dWheelAngle[1]>360.0) dWheelAngle[1]-=360.0; + if (dWheelAngle[2]>360.0) dWheelAngle[2]-=360.0; + } + if (pants) //pantograf może być w wagonie kuchennym albo pojeździe rewizyjnym (np. SR61) + {//przeliczanie kątów dla pantografów + double k; //tymczasowy kąt + double PantDiff; + TAnimPant *p; //wskaźnik do obiektu danych pantografu + double fCurrent=(MoverParameters->DynamicBrakeFlag&&MoverParameters->ResistorsFlag?0:fabs(MoverParameters->Itot))+MoverParameters->TotalCurrent; //prąd pobierany przez pojazd - bez sensu z tym (TotalCurrent) + //fCurrent+=fabs(MoverParameters->Voltage)*1e-6; //prąd płynący przez woltomierz, rozładowuje kondensator orgromowy 4µF + double fPantCurrent=fCurrent; //normalnie cały prąd przez jeden pantograf + if (pants) + if (iAnimType[ANIM_PANTS]>1) //a jeśli są dwa pantografy //Ra 1014-11: proteza, trzeba zrobić sensowniej + if (pants[0].fParamPants->hvPowerWire&&pants[1].fParamPants->hvPowerWire) //i oba podłączone do drutów + fPantCurrent=fCurrent*0.5; //to dzielimy prąd równo na oba (trochę bez sensu, ale lepiej tak niż podwoić prąd) + for (int i=0;iPantWys<0) + {//patograf został połamany, liczony nie będzie + if (p->fAngleL>p->fAngleL0) + p->fAngleL-=0.2*dt1; //nieco szybciej niż jak dla opuszczania + if (p->fAngleLfAngleL0) + p->fAngleL=p->fAngleL0; //kąt graniczny + if (p->fAngleUfAngleU+=0.5*dt1; //górne się musi ruszać szybciej. + if (p->fAngleU>M_PI) + p->fAngleU=M_PI; + if (i&1) //zgłoszono, że po połamaniu potrafi zostać zasilanie + MoverParameters->PantRearVolt=0.0; + else + MoverParameters->PantFrontVolt=0.0; + continue; //reszta wtedy nie jest wykonywana + } + PantDiff=p->PantTraction-p->PantWys; //docelowy-aktualny + switch (i) //numer pantografu + {//trzeba usunąć to rozróżnienie + case 0: + if (Global::bLiveTraction?false:!p->hvPowerWire) //jeśli nie ma drutu, może pooszukiwać + MoverParameters->PantFrontVolt=(p->PantWys>=1.2)?0.95*MoverParameters->EnginePowerSource.MaxVoltage:0.0; + else + if (MoverParameters->PantFrontUp?(PantDiff<0.01):false) //tolerancja niedolegania + { + if ((MoverParameters->PantFrontVolt==0.0)&&(MoverParameters->PantRearVolt==0.0)) + sPantUp.Play(vol,0,MechInside,vPosition); + if (p->hvPowerWire) //TODO: wyliczyć trzeba prąd przypadający na pantograf i wstawić do GetVoltage() + {MoverParameters->PantFrontVolt=p->hvPowerWire->VoltageGet(MoverParameters->Voltage,fPantCurrent); + fCurrent-=fPantCurrent; //taki prąd płynie przez powyższy pantograf + } + else + MoverParameters->PantFrontVolt=0.0; + } + else + MoverParameters->PantFrontVolt=0.0; + break; + case 1: + if (Global::bLiveTraction?false:!p->hvPowerWire) //jeśli nie ma drutu, może pooszukiwać + MoverParameters->PantRearVolt=(p->PantWys>=1.2)?0.95*MoverParameters->EnginePowerSource.MaxVoltage:0.0; + else + if (MoverParameters->PantRearUp?(PantDiff<0.01):false) + { + if ((MoverParameters->PantRearVolt==0.0)&&(MoverParameters->PantFrontVolt==0.0)) + sPantUp.Play(vol,0,MechInside,vPosition); + if (p->hvPowerWire) //TODO: wyliczyć trzeba prąd przypadający na pantograf i wstawić do GetVoltage() + {MoverParameters->PantRearVolt=p->hvPowerWire->VoltageGet(MoverParameters->Voltage,fPantCurrent); + fCurrent-=fPantCurrent; //taki prąd płynie przez powyższy pantograf + } + else + MoverParameters->PantRearVolt=0.0; + } + else + MoverParameters->PantRearVolt=0.0; + break; + } //pozostałe na razie nie obsługiwane + if (MoverParameters->PantPress>(MoverParameters->TrainType==dt_EZT?2.5:3.3)) //Ra 2013-12: Niebugocław mówi, że w EZT podnoszą się przy 2.5 + pantspeedfactor=0.015*(MoverParameters->PantPress)*dt1; //z EXE Kursa //Ra: wysokość zależy od ciśnienia !!! + else + pantspeedfactor=0.0; + if (pantspeedfactor<0) pantspeedfactor=0; + k=p->fAngleL; + if (i?MoverParameters->PantRearUp:MoverParameters->PantFrontUp) //jeśli ma być podniesiony + {if (PantDiff>0.001) //jeśli nie dolega do drutu + {//jeśli poprzednia wysokość jest mniejsza niż pożądana, zwiększyć kąt dolnego ramienia zgodnie z ciśnieniem + if (pantspeedfactor>0.55*PantDiff) //0.55 to około pochodna kąta po wysokości + k+=0.55*PantDiff; //ograniczenie "skoku" w danej klatce + else + k+=pantspeedfactor; //dolne ramię + //jeśli przekroczono kąt graniczny, zablokować pantograf (wymaga interwencji pociągu sieciowego) + } + else if (PantDiff<-0.001) + {//drut się obniżył albo pantograf podniesiony za wysoko + //jeśli wysokość jest zbyt duża, wyznaczyć zmniejszenie kąta + //jeśli zmniejszenie kąta jest zbyt duże, przejść do trybu łamania pantografu + //if (PantFrontDiff<-0.05) //skok w dół o 5cm daje złąmanie pantografu + k+=0.4*PantDiff; //mniej niż pochodna kąta po wysokości + } //jeśli wysokość jest dobra, nic więcej nie liczyć + } + else + {//jeśli ma być na dole + if (k>p->fAngleL0) //jeśli wyżej niż położenie wyjściowe + k-=0.15*dt1; //ruch w dół + if (kfAngleL0) + k=p->fAngleL0; //położenie minimalne + } + if (k!=p->fAngleL) + {//żeby nie liczyć w kilku miejscach ani gdy nie potrzeba + if (k+p->fAngleUfAngleL=k; //zmieniony kąt + //wyliczyć kąt górnego ramienia z wzoru (a)cosinusowego + //=acos((b*cos()+c)/a) + //p->dPantAngleT=acos((1.22*cos(k)+0.535)/1.755); //górne ramię + p->fAngleU=acos((p->fLenL1*cos(k)+p->fHoriz)/p->fLenU1); //górne ramię + //wyliczyć aktualną wysokość z wzoru sinusowego + //h=a*sin()+b*sin() + p->PantWys=p->fLenL1*sin(k)+p->fLenU1*sin(p->fAngleU)+p->fHeight; //wysokość całości + } + } + } //koniec pętli po pantografach + if ((MoverParameters->PantFrontSP==false)&&(MoverParameters->PantFrontUp==false)) + { + sPantDown.Play(vol,0,MechInside,vPosition); + MoverParameters->PantFrontSP=true; + } + if ((MoverParameters->PantRearSP==false)&&(MoverParameters->PantRearUp==false)) + { + sPantDown.Play(vol,0,MechInside,vPosition); + MoverParameters->PantRearSP=true; + } + if (MoverParameters->EnginePowerSource.SourceType==CurrentCollector) + {//Winger 240404 - wylaczanie sprezarki i przetwornicy przy braku napiecia + if (tmpTraction.TractionVoltage==0) + {//to coś wyłączało dźwięk silnika w ST43! + MoverParameters->ConverterFlag=false; + MoverParameters->CompressorFlag=false; //Ra: to jest wątpliwe - wyłączenie sprężarki powinno być w jednym miejscu! + } + } + } + else if (MoverParameters->EnginePowerSource.SourceType==InternalSource) + if (MoverParameters->EnginePowerSource.PowerType==SteamPower) + //if (smPatykird1[0]) + {//Ra: animacja rozrządu parowozu, na razie nieoptymalizowane +/* //Ra: tymczasowo wyłączone ze względu na porządkowanie animacji pantografów + double fi,dx,c2,ka,kc; + double sin_fi,cos_fi; + double L1=1.6688888888888889; + double L2=5.6666666666666667; //2550/450 + double Lc=0.4; + double L=5.686422222; //2558.89/450 + double G1,G2,G3,ksi,sin_ksi,gam; + double G1_2,G2_2,G3_2; //kwadraty + //ruch tłoków oraz korbowodów + for (int i=0;i<=1;++i) + {//obie strony w ten sam sposób + fi=DegToRad(dWheelAngle[1]+(i?pant2x:pant1x)); //kąt obrotu koła dla tłoka 1 + sin_fi=sin(fi); + cos_fi=cos(fi); + dx=panty*cos_fi+sqrt(panth*panth-panty*panty*sin_fi*sin_fi)-panth; //nieoptymalne + if (smPatykird1[i]) //na razie zabezpieczenie + smPatykird1[i]->SetTranslate(float3(dx,0,0)); + ka=-asin(panty/panth)*sin_fi; + if (smPatykirg1[i]) //na razie zabezpieczenie + smPatykirg1[i]->SetRotateXYZ(vector3(RadToDeg(ka),0,0)); + //smPatykirg1[0]->SetRotate(float3(0,1,0),RadToDeg(fi)); //obracamy + //ruch drążka mimośrodkowego oraz jarzma + //korzystałem z pliku PDF "mm.pdf" (opis czworoboku korbowo-wahaczowego): + //"MECHANIKA MASZYN. Szkic wykładu i laboratorium komputerowego." + //Prof. dr hab. inż. Jerzy Zajączkowski, 2007, Politechnika Łódzka + //L1 - wysokość (w pionie) osi jarzma ponad osią koła + //L2 - odległość w poziomie osi jarzma od osi koła + //Lc - długość korby mimośrodu na kole + //Lr - promień jarzma =1.0 (pozostałe przeliczone proporcjonalnie) + //L - długość drążka mimośrodowego + //fi - kąt obrotu koła + //ksi - kąt obrotu jarzma (od pionu) + //gam - odchylenie drążka mimośrodowego od poziomu + //G1=(Lr*Lr+L1*L1+L2*L2+Kc*Lc-L*L-2.0*Lc*L2*cos(fi)+2.0*Lc*L1*sin(fi))/(Lr*Lr); + //G2=2.0*(L2-Lc*cos(fi))/Lr; + //G3=2.0*(L1-Lc*sin(fi))/Lr; + fi=DegToRad(dWheelAngle[1]+(i?pant2x:pant1x)-96.77416667); //kąt obrotu koła dla tłoka 1 + //1) dla dWheelAngle[1]=0° korba jest w dół, a mimośród w stronę jarzma, czyli fi=-7° + //2) dla dWheelAngle[1]=90° korba jest do tyłu, a mimośród w dół, czyli fi=83° + sin_fi=sin(fi); + cos_fi=cos(fi); + G1=(1.0+L1*L1+L2*L2+Lc*Lc-L*L-2.0*Lc*L2*cos_fi+2.0*Lc*L1*sin_fi); + G1_2=G1*G1; + G2=2.0*(L2-Lc*cos_fi); + G2_2=G2*G2; + G3=2.0*(L1-Lc*sin_fi); + G3_2=G3*G3; + sin_ksi=(G1*G2-G3*_fm_sqrt(G2_2+G3_2-G1_2))/(G2_2+G3_2); //x1 (minus delta) + ksi=asin(sin_ksi); //kąt jarzma + if (smPatykirg2[i]) + smPatykirg2[i]->SetRotateXYZ(vector3(RadToDeg(ksi),0,0)); //obrócenie jarzma + //1) ksi=-23°, gam= + //2) ksi=10°, gam= + //gam=acos((L2-sin_ksi-Lc*cos_fi)/L); //kąt od poziomu, liczony względem poziomu + //gam=asin((L1-cos_ksi-Lc*sin_fi)/L); //kąt od poziomu, liczony względem pionu + gam=atan2((L1-cos(ksi)+Lc*sin_fi),(L2-sin_ksi+Lc*cos_fi)); //kąt od poziomu + if (smPatykird2[i]) //na razie zabezpieczenie + smPatykird2[i]->SetRotateXYZ(vector3(RadToDeg(-gam-ksi),0,0)); //obrócenie drążka mimośrodowego + } +*/ + } + +//NBMX Obsluga drzwi, MC: zuniwersalnione + if ((dDoorMoveLDoorMaxShiftL) && (MoverParameters->DoorLeftOpened)) + dDoorMoveL+=dt1*0.5*MoverParameters->DoorOpenSpeed; + if ((dDoorMoveL>0) && (!MoverParameters->DoorLeftOpened)) + { + dDoorMoveL-=dt1*MoverParameters->DoorCloseSpeed; + if (dDoorMoveL<0) + dDoorMoveL=0; + } + if ((dDoorMoveRDoorMaxShiftR) && (MoverParameters->DoorRightOpened)) + dDoorMoveR+=dt1*0.5*MoverParameters->DoorOpenSpeed; + if ((dDoorMoveR>0) && (!MoverParameters->DoorRightOpened)) + { + dDoorMoveR-=dt1*MoverParameters->DoorCloseSpeed; + if (dDoorMoveR<0) + dDoorMoveR=0; + } + + +//ABu-160303 sledzenie toru przed obiektem: ******************************* + //Z obserwacji: v>0 -> Coupler 0; v<0 ->coupler1 (Ra: prędkość jest związana z pojazdem) + //Rozroznienie jest tutaj, zeby niepotrzebnie nie skakac do funkcji. Nie jest uzaleznione + //od obecnosci AI, zeby uwzglednic np. jadace bez lokomotywy wagony. + //Ra: można by przenieść na poziom obiektu reprezentującego skład, aby nie sprawdzać środkowych + if (CouplCounter>25) //licznik, aby nie robić za każdym razem + {//poszukiwanie czegoś do zderzenia się + fTrackBlock=10000.0; //na razie nie ma przeszkód (na wypadek nie uruchomienia skanowania) + //jeśli nie ma zwrotnicy po drodze, to tylko przeliczyć odległość? + if (MoverParameters->V>0.03) //[m/s] jeśli jedzie do przodu (w kierunku Coupler 0) + {if (MoverParameters->Couplers[0].CouplingFlag==ctrain_virtual) //brak pojazdu podpiętego? + {ABuScanObjects(1,fScanDist); //szukanie czegoś do podłączenia + //WriteLog(asName+" - block 0: "+AnsiString(fTrackBlock)); + } + } + else if (MoverParameters->V<-0.03) //[m/s] jeśli jedzie do tyłu (w kierunku Coupler 1) + if (MoverParameters->Couplers[1].CouplingFlag==ctrain_virtual) //brak pojazdu podpiętego? + {ABuScanObjects(-1,fScanDist); + //WriteLog(asName+" - block 1: "+AnsiString(fTrackBlock)); + } + CouplCounter=random(20); //ponowne sprawdzenie po losowym czasie + } + if (MoverParameters->Vel>0.1) //[km/h] + ++CouplCounter; //jazda sprzyja poszukiwaniu połączenia + else + {CouplCounter=25; //a bezruch nie, ale trzeba zaktualizować odległość, bo zawalidroga może sobie pojechać + } + if (MoverParameters->DerailReason>0) + {switch (MoverParameters->DerailReason) + {case 1: ErrorLog("Bad driving: "+asName+" derailed due to end of track"); break; + case 2: ErrorLog("Bad driving: "+asName+" derailed due to too high speed"); break; + case 3: ErrorLog("Bad dynamic: "+asName+" derailed due to track width"); break; //błąd w scenerii + case 4: ErrorLog("Bad dynamic: "+asName+" derailed due to wrong track type"); break; //błąd w scenerii + } + MoverParameters->DerailReason=0; //żeby tylko raz + } + if (MoverParameters->LoadStatus) + LoadUpdate(); //zmiana modelu ładunku + return true; //Ra: chyba tak? +} + +bool __fastcall TDynamicObject::FastUpdate(double dt) +{ + if (dt==0.0) return true; //Ra: pauza + double dDOMoveLen; + if (!MoverParameters->PhysicActivation) + return true; //McZapkie: wylaczanie fizyki gdy nie potrzeba + + if (!bEnabled) + return false; + + TLocation l; + l.X=-vPosition.x; + l.Y=vPosition.z; + l.Z=vPosition.y; + TRotation r; + r.Rx=r.Ry=r.Rz= 0; + +//McZapkie: parametry powinny byc pobierane z toru + //ts.R=MyTrack->fRadius; + //ts.Len= Max0R(MoverParameters->BDist,MoverParameters->ADist); + //ts.dHtrack=Axle1.pPosition.y-Axle0.pPosition.y; + //ts.dHrail=((Axle1.GetRoll())+(Axle0.GetRoll()))*0.5f; + //tp.Width=MyTrack->fTrackWidth; + //McZapkie-250202 + //tp.friction= MyTrack->fFriction; + //tp.CategoryFlag= MyTrack->iCategoryFlag&15; + //tp.DamageFlag=MyTrack->iDamageFlag; + //tp.QualityFlag=MyTrack->iQualityFlag; + dDOMoveLen=MoverParameters->FastComputeMovement(dt,ts,tp,l,r); // ,ts,tp,tmpTraction); + //Move(dDOMoveLen); + //ResetdMoveLen(); + FastMove(dDOMoveLen); + + if (MoverParameters->LoadStatus) + LoadUpdate(); //zmiana modelu ładunku + return true; //Ra: chyba tak? +} + +//McZapkie-040402: liczenie pozycji uwzgledniajac wysokosc szyn itp. +//vector3 __fastcall TDynamicObject::GetPosition() +//{//Ra: pozycja pojazdu jest liczona zaraz po przesunięciu +// return vPosition; +//}; + +void __fastcall TDynamicObject::TurnOff() +{//wyłączenie rysowania submodeli zmiennych dla egemplarza pojazdu + btnOn=false; + btCoupler1.TurnOff(); + btCoupler2.TurnOff(); + btCPneumatic1.TurnOff(); + btCPneumatic1r.TurnOff(); + btCPneumatic2.TurnOff(); + btCPneumatic2r.TurnOff(); + btPneumatic1.TurnOff(); + btPneumatic1r.TurnOff(); + btPneumatic2.TurnOff(); + btPneumatic2r.TurnOff(); + btCCtrl1.TurnOff(); + btCCtrl2.TurnOff(); + btCPass1.TurnOff(); + btCPass2.TurnOff(); + btEndSignals11.TurnOff(); + btEndSignals13.TurnOff(); + btEndSignals21.TurnOff(); + btEndSignals23.TurnOff(); + btEndSignals1.TurnOff(); + btEndSignals2.TurnOff(); + btEndSignalsTab1.TurnOff(); + btEndSignalsTab2.TurnOff(); + btHeadSignals11.TurnOff(); + btHeadSignals12.TurnOff(); + btHeadSignals13.TurnOff(); + btHeadSignals21.TurnOff(); + btHeadSignals22.TurnOff(); + btHeadSignals23.TurnOff(); +}; + +void __fastcall TDynamicObject::Render() +{//rysowanie elementów nieprzezroczystych + //youBy - sprawdzamy, czy jest sens renderowac + double modelrotate; + vector3 tempangle; + // zmienne + renderme=false; + //przeklejka + double ObjSqrDist=SquareMagnitude(Global::pCameraPosition-vPosition); + //koniec przeklejki + if (ObjSqrDist<500) //jak jest blisko - do 70m + modelrotate=0.01; //mały kąt, żeby nie znikało + else + {//Global::pCameraRotation to kąt bewzględny w świecie (zero - na północ) + tempangle=(vPosition-Global::pCameraPosition); //wektor od kamery + modelrotate=ABuAcos(tempangle); //określenie kąta + //if (modelrotate>M_PI) modelrotate-=(2*M_PI); + modelrotate+=Global::pCameraRotation; + } + if (modelrotate>M_PI) modelrotate-=(2*M_PI); + if (modelrotate<-M_PI) modelrotate+=(2*M_PI); + ModCamRot=modelrotate; + + modelrotate=abs(modelrotate); + + if (modelrotate) //tu trzeba by ustawić animacje na modelu zewnętrznym + glLoadIdentity(); //zacząć od macierzy jedynkowej + Global::pCamera->SetCabMatrix(vPosition); //specjalne ustawienie kamery + } + else + glTranslated(vPosition.x,vPosition.y,vPosition.z); //standardowe przesunięcie względem początku scenerii + glMultMatrixd(mMatrix.getArray()); + if (fShade>0.0) + {//Ra: zmiana oswietlenia w tunelu, wykopie + GLfloat ambientLight[4]= {0.5f,0.5f,0.5f,1.0f}; + GLfloat diffuseLight[4]= {0.5f,0.5f,0.5f,1.0f}; + GLfloat specularLight[4]={0.5f,0.5f,0.5f,1.0f}; + //trochę problem z ambientem w wykopie... + for (int li=0;li<3;li++) + { + ambientLight[li]= Global::ambientDayLight[li]*fShade; + diffuseLight[li]= Global::diffuseDayLight[li]*fShade; + specularLight[li]=Global::specularDayLight[li]*fShade; + } + glLightfv(GL_LIGHT0,GL_AMBIENT,ambientLight); + glLightfv(GL_LIGHT0,GL_DIFFUSE,diffuseLight); + glLightfv(GL_LIGHT0,GL_SPECULAR,specularLight); + } + if (Global::bUseVBO) + {//wersja VBO + if (mdLowPolyInt) + if (FreeFlyModeFlag?true:!mdKabina||!bDisplayCab) + mdLowPolyInt->RaRender(ObjSqrDist,ReplacableSkinID,iAlpha); + mdModel->RaRender(ObjSqrDist,ReplacableSkinID,iAlpha); + if (mdLoad) //renderowanie nieprzezroczystego ładunku + mdLoad->RaRender(ObjSqrDist,ReplacableSkinID,iAlpha); + if (mdPrzedsionek) + mdPrzedsionek->RaRender(ObjSqrDist,ReplacableSkinID,iAlpha); + } + else + {//wersja Display Lists + if (mdLowPolyInt) + if (FreeFlyModeFlag?true:!mdKabina||!bDisplayCab) + mdLowPolyInt->Render(ObjSqrDist,ReplacableSkinID,iAlpha); + mdModel->Render(ObjSqrDist,ReplacableSkinID,iAlpha); + if (mdLoad) //renderowanie nieprzezroczystego ładunku + mdLoad->Render(ObjSqrDist,ReplacableSkinID,iAlpha); + if (mdPrzedsionek) + mdPrzedsionek->Render(ObjSqrDist,ReplacableSkinID,iAlpha); + } + + //Ra: czy ta kabina tu ma sens? + //Ra: czy nie renderuje się dwukrotnie? + //Ra: dlaczego jest zablokowana w przezroczystych? + if (mdKabina) //jeśli ma model kabiny + if ((mdKabina!=mdModel) && bDisplayCab && FreeFlyModeFlag) + {//rendering kabiny gdy jest oddzielnym modelem i ma byc wyswietlana + //ABu: tylko w trybie FreeFly, zwykly tryb w world.cpp + //Ra: świetła są ustawione dla zewnętrza danego pojazdu + //oswietlenie kabiny + GLfloat ambientCabLight[4]= { 0.5f, 0.5f, 0.5f, 1.0f }; + GLfloat diffuseCabLight[4]= { 0.5f, 0.5f, 0.5f, 1.0f }; + GLfloat specularCabLight[4]= { 0.5f, 0.5f, 0.5f, 1.0f }; + for (int li=0; li<3; li++) + { + ambientCabLight[li]= Global::ambientDayLight[li]*0.9; + diffuseCabLight[li]= Global::diffuseDayLight[li]*0.5; + specularCabLight[li]=Global::specularDayLight[li]*0.5; + } + switch (MyTrack->eEnvironment) + { + case e_canyon: + { + for (int li=0; li<3; li++) + { + diffuseCabLight[li]*= 0.6; + specularCabLight[li]*= 0.7; + } + } + break; + case e_tunnel: + { + for (int li=0; li<3; li++) + { + ambientCabLight[li]*= 0.3; + diffuseCabLight[li]*= 0.1; + specularCabLight[li]*= 0.2; + } + } + break; + } + glLightfv(GL_LIGHT0,GL_AMBIENT,ambientCabLight); + glLightfv(GL_LIGHT0,GL_DIFFUSE,diffuseCabLight); + glLightfv(GL_LIGHT0,GL_SPECULAR,specularCabLight); + if (Global::bUseVBO) + mdKabina->RaRender(ObjSqrDist,0); + else + mdKabina->Render(ObjSqrDist,0); + glLightfv(GL_LIGHT0,GL_AMBIENT,Global::ambientDayLight); + glLightfv(GL_LIGHT0,GL_DIFFUSE,Global::diffuseDayLight); + glLightfv(GL_LIGHT0,GL_SPECULAR,Global::specularDayLight); + } + if (fShade!=0.0) //tylko jeśli było zmieniane + {//przywrócenie standardowego oświetlenia + glLightfv(GL_LIGHT0,GL_AMBIENT,Global::ambientDayLight); + glLightfv(GL_LIGHT0,GL_DIFFUSE,Global::diffuseDayLight); + glLightfv(GL_LIGHT0,GL_SPECULAR,Global::specularDayLight); + } + glPopMatrix(); + if (btnOn) TurnOff(); //przywrócenie domyślnych pozycji submodeli + } //yB - koniec mieszania z grafika +}; + +void __fastcall TDynamicObject::RenderSounds() +{//przeliczanie dźwięków, bo będzie słychać bez wyświetlania sektora z pojazdem + //McZapkie-010302: ulepszony dzwiek silnika + double freq; + double vol=0; + double dt=Timer::GetDeltaTime(); + +// double sounddist; +// sounddist=SquareMagnitude(Global::pCameraPosition-vPosition); + + if (MoverParameters->Power>0) + { + if ((rsSilnik.AM!=0) && ((MoverParameters->Mains) || (MoverParameters->EngineType==DieselEngine))) //McZapkie-280503: zeby dla dumb dzialal silnik na jalowych obrotach + { + if ((fabs(MoverParameters->enrot)>0.01) || (MoverParameters->EngineType==Dumb)) //&& (MoverParameters->EnginePower>0.1)) + { + freq=rsSilnik.FM*fabs(MoverParameters->enrot)+rsSilnik.FA; + if (MoverParameters->EngineType==Dumb) + freq=freq-0.2*MoverParameters->EnginePower/(1+MoverParameters->Power*1000); + rsSilnik.AdjFreq(freq,dt); + if (MoverParameters->EngineType==DieselEngine) + { + if (MoverParameters->enrot>0) + { + if (MoverParameters->EnginePower>0) + vol=rsSilnik.AM*MoverParameters->dizel_fill+rsSilnik.AA; + else + vol=rsSilnik.AM*fabs(MoverParameters->enrot/MoverParameters->nmax)+rsSilnik.AA*0.9; + } + else + vol=0; + } + else if (MoverParameters->EngineType==DieselElectric) + vol=rsSilnik.AM*(MoverParameters->EnginePower/1000/MoverParameters->Power)+0.2*(MoverParameters->enrot*60)/(MoverParameters->DElist[MoverParameters->MainCtrlPosNo].RPM)+rsSilnik.AA; + else if (MoverParameters->EngineType==ElectricInductionMotor) + vol=rsSilnik.AM*(MoverParameters->EnginePower+fabs(MoverParameters->enrot*2))+rsSilnik.AA; + else + vol=rsSilnik.AM*(MoverParameters->EnginePower/1000+fabs(MoverParameters->enrot)*60.0)+rsSilnik.AA; +// McZapkie-250302 - natezenie zalezne od obrotow i mocy + if ((vol<1) && (MoverParameters->EngineType==ElectricSeriesMotor) && (MoverParameters->EnginePower<100)) + { + float volrnd=random(100)*MoverParameters->enrot/(1+MoverParameters->nmax); + if (volrnd<2) + vol=vol+volrnd/200.0; + } + switch (MyTrack->eEnvironment) + { + case e_tunnel: + { + vol+=0.1; + } + break; + case e_canyon: + { + vol+=0.05; + } + break; + } + if ((MoverParameters->DynamicBrakeFlag) && (MoverParameters->EnginePower>0.1) && (MoverParameters->EngineType==ElectricSeriesMotor)) //Szociu - 29012012 - jeżeli uruchomiony jest hamulec elektrodynamiczny, odtwarzany jest dźwięk silnika + vol +=0.8; + + if (enginevolume>0.0001) + if (MoverParameters->EngineType!=DieselElectric) + { rsSilnik.Play(enginevolume,DSBPLAY_LOOPING,MechInside,GetPosition()); } + else + { + sConverter.UpdateAF(vol,freq,MechInside,GetPosition()); + + float fincvol; + fincvol=0; + if ((MoverParameters->ConverterFlag)&&(MoverParameters->enrot*60>MoverParameters->DElist[0].RPM)) + { + fincvol=(MoverParameters->DElist[MoverParameters->MainCtrlPos].RPM-(MoverParameters->enrot*60)); + fincvol/=(0.05*MoverParameters->DElist[0].RPM); + }; + if (fincvol>0.02) + rsDiesielInc.Play(fincvol,DSBPLAY_LOOPING,MechInside,GetPosition()); + else + rsDiesielInc.Stop(); + } + } + else + rsSilnik.Stop(); + } + enginevolume=(enginevolume+vol)/2; + if (enginevolume<0.01) + rsSilnik.Stop(); + if ((MoverParameters->EngineType==ElectricSeriesMotor)||(MoverParameters->EngineType==ElectricInductionMotor) && rsWentylator.AM!=0) + { + if (MoverParameters->RventRot>0.1) + { + freq=rsWentylator.FM*MoverParameters->RventRot+rsWentylator.FA; + rsWentylator.AdjFreq(freq,dt); + if (MoverParameters->EngineType==ElectricInductionMotor) + vol=rsWentylator.AM*sqrt(fabs(MoverParameters->dizel_fill))+rsWentylator.AA; + else + vol=rsWentylator.AM*MoverParameters->RventRot+rsWentylator.AA; + rsWentylator.Play(vol,DSBPLAY_LOOPING,MechInside,GetPosition()); + } + else + rsWentylator.Stop(); + } + if (MoverParameters->TrainType==dt_ET40) + { + if (MoverParameters->Vel>0.1) + { + freq=rsPrzekladnia.FM*(MoverParameters->Vel)+rsPrzekladnia.FA; + rsPrzekladnia.AdjFreq(freq,dt); + vol=rsPrzekladnia.AM*(MoverParameters->Vel)+rsPrzekladnia.AA; + rsPrzekladnia.Play(vol,DSBPLAY_LOOPING,MechInside,GetPosition()); + } + else + rsPrzekladnia.Stop(); + } + } + +//youBy: dzwiek ostrych lukow i ciasnych zwrotek + + if ((ts.R*ts.R>1)&&(MoverParameters->Vel>0)) + vol=MoverParameters->AccN*MoverParameters->AccN; + else + vol=0; +// vol+=(50000/ts.R*ts.R); + + if (vol>0.001) + { + rscurve.Play(2*vol,DSBPLAY_LOOPING,MechInside,GetPosition()); + } + else + rscurve.Stop(); + +//McZapkie-280302 - pisk mocno zacisnietych hamulcow - trzeba jeszcze zabezpieczyc przed brakiem deklaracji w mmedia.dta + if (rsPisk.AM!=0) + { + if ((MoverParameters->Vel>(rsPisk.GetStatus()!=0?0.01:0.5)) && (!MoverParameters->SlippingWheels) && (MoverParameters->UnitBrakeForce>rsPisk.AM)) + { + vol=MoverParameters->UnitBrakeForce/(rsPisk.AM+1)+rsPisk.AA; + rsPisk.Play(vol,DSBPLAY_LOOPING,MechInside,GetPosition()); + } + else + rsPisk.Stop(); + } + +//if ((MoverParameters->ConverterFlag==false) && (MoverParameters->TrainType!=dt_ET22)) +//if ((MoverParameters->ConverterFlag==false)&&(MoverParameters->CompressorPower!=0)) +// MoverParameters->CompressorFlag=false; //Ra: wywalić to stąd, tu tylko dla wyświetlanych! +//Ra: no to już wiemy, dlaczego pociągi jeżdżą lepiej, gdy się na nie patrzy! +//if (MoverParameters->CompressorPower==2) +// MoverParameters->CompressorAllow=MoverParameters->ConverterFlag; + +// McZapkie! - dzwiek compressor.wav tylko gdy dziala sprezarka + if (MoverParameters->VeselVolume!=0) + { + if (MoverParameters->CompressorFlag) + sCompressor.TurnOn(MechInside,GetPosition()); + else + sCompressor.TurnOff(MechInside,GetPosition()); + sCompressor.Update(MechInside,GetPosition()); + } + if (MoverParameters->PantCompFlag) // Winger 160404 - dzwiek malej sprezarki + sSmallCompressor.TurnOn(MechInside,GetPosition()); + else + sSmallCompressor.TurnOff(MechInside,GetPosition()); + sSmallCompressor.Update(MechInside,GetPosition()); + +//youBy - przenioslem, bo diesel tez moze miec turbo +if ((MoverParameters->MainCtrlPos)>=(MoverParameters->TurboTest)) //hunter-250312: dlaczego zakomentowane? Ra: bo nie działało dobrze +{ + //udawanie turbo: (6.66*(eng_vol-0.85)) + if (eng_turbo>6.66*(enginevolume-0.8)+0.2*dt) + eng_turbo=eng_turbo-0.2*dt; //0.125 + else + if (eng_turbo<6.66*(enginevolume-0.8)-0.4*dt) + eng_turbo=eng_turbo+0.4*dt; //0.333 + else + eng_turbo=6.66*(enginevolume-0.8); + + sTurbo.TurnOn(MechInside,GetPosition()); + //sTurbo.UpdateAF(eng_turbo,0.7+(eng_turbo*0.6),MechInside,GetPosition()); + sTurbo.UpdateAF(3*eng_turbo-1,0.4+eng_turbo*0.4,MechInside,GetPosition()); +// eng_vol_act=enginevolume; + //eng_frq_act=eng_frq; +} +else sTurbo.TurnOff(MechInside,GetPosition()); + + + + if (MoverParameters->TrainType==dt_PseudoDiesel) + { + //ABu: udawanie woodwarda dla lok. spalinowych + //jesli silnik jest podpiety pod dzwiek przetwornicy + if (MoverParameters->ConverterFlag) //NBMX dzwiek przetwornicy + { + sConverter.TurnOn(MechInside,GetPosition()); + } + else + sConverter.TurnOff(MechInside,GetPosition()); + + //glosnosc zalezy od stosunku mocy silnika el. do mocy max + double eng_vol; + if (MoverParameters->Power>1) + //0.85+0.000015*(...) + eng_vol=0.8+0.00002*(MoverParameters->EnginePower/MoverParameters->Power); + else + eng_vol=1; + + eng_dfrq=eng_dfrq+(eng_vol_act-eng_vol); + if(eng_dfrq>0) + { + eng_dfrq=eng_dfrq-0.025*dt; + if(eng_dfrq<0.025*dt) + eng_dfrq=0; + } + else + if(eng_dfrq<0) + { + eng_dfrq=eng_dfrq+0.025*dt; + if(eng_dfrq>-0.025*dt) + eng_dfrq=0; + } + double defrot; + if (MoverParameters->MainCtrlPos!=0) + { + double CtrlPos=MoverParameters->MainCtrlPos; + double CtrlPosNo=MoverParameters->MainCtrlPosNo; + //defrot=1+0.4*(CtrlPos/CtrlPosNo); + defrot=1+0.5*(CtrlPos/CtrlPosNo); + } + else + defrot=1; + + if (eng_frq_actMainCtrlPos==1) eng_frq_act=eng_frq_act+0.1*dt; + eng_frq_act=eng_frq_act+0.4*dt; //0.05 + if (eng_frq_act>defrot-0.4*dt) + eng_frq_act=defrot; + } + else + if (eng_frq_act>defrot) + { + eng_frq_act=eng_frq_act-0.1*dt; //0.05 + if (eng_frq_act6.66*(eng_vol-0.8)+0.2*dt) + eng_turbo=eng_turbo-0.2*dt; //0.125 + else + if (eng_turbo<6.66*(eng_vol-0.8)-0.4*dt) + eng_turbo=eng_turbo+0.4*dt; //0.333 + else + eng_turbo=6.66*(eng_vol-0.8); + + sTurbo.TurnOn(MechInside,GetPosition()); + //sTurbo.UpdateAF(eng_turbo,0.7+(eng_turbo*0.6),MechInside,GetPosition()); + sTurbo.UpdateAF(3*eng_turbo-1,0.4+eng_turbo*0.4,MechInside,GetPosition()); + eng_vol_act=eng_vol; + //eng_frq_act=eng_frq; + } + else + { + if (MoverParameters->ConverterFlag) //NBMX dzwiek przetwornicy + sConverter.TurnOn(MechInside,GetPosition()); + else + sConverter.TurnOff(MechInside,GetPosition()); + sConverter.Update(MechInside,GetPosition()); + } + if (MoverParameters->WarningSignal>0) + { + if (TestFlag(MoverParameters->WarningSignal,1)) + sHorn1.TurnOn(MechInside,GetPosition()); + else + sHorn1.TurnOff(MechInside,GetPosition()); + if (TestFlag(MoverParameters->WarningSignal,2)) + sHorn2.TurnOn(MechInside,GetPosition()); + else + sHorn2.TurnOff(MechInside,GetPosition()); + } + else + { + sHorn1.TurnOff(MechInside,GetPosition()); + sHorn2.TurnOff(MechInside,GetPosition()); + } + if (MoverParameters->DoorClosureWarning) + { + if (MoverParameters->DepartureSignal) //NBMX sygnal odjazdu, MC: pod warunkiem ze jest zdefiniowane w chk + sDepartureSignal.TurnOn(MechInside,GetPosition()); + else + sDepartureSignal.TurnOff(MechInside,GetPosition()); + sDepartureSignal.Update(MechInside,GetPosition()); + } + sHorn1.Update(MechInside,GetPosition()); + sHorn2.Update(MechInside,GetPosition()); + //McZapkie: w razie wykolejenia + if (MoverParameters->EventFlag) + { + if (TestFlag(MoverParameters->DamageFlag,dtrain_out) && GetVelocity()>0) + rsDerailment.Play(1,0,true,GetPosition()); + if (GetVelocity()==0) + rsDerailment.Stop(); + } +/* //Ra: dwa razy? + if (MoverParameters->EventFlag) + { + if (TestFlag(MoverParameters->DamageFlag,dtrain_out) && GetVelocity()>0) + rsDerailment.Play(1,0,true,GetPosition()); + if (GetVelocity()==0) + rsDerailment.Stop(); + } +*/ +}; + +void __fastcall TDynamicObject::RenderAlpha() +{//rysowanie elementów półprzezroczystych + if (renderme) + { + TSubModel::iInstance=(int)this; //żeby nie robić cudzych animacji + double ObjSqrDist=SquareMagnitude(Global::pCameraPosition-vPosition); + ABuLittleUpdate(ObjSqrDist); //ustawianie zmiennych submodeli dla wspólnego modelu + glPushMatrix(); + if (this==Global::pUserDynamic) + {//specjalne ustawienie, aby nie trzęsło + if (Global::bSmudge) + {//jak smuga, to rysować po smudze + glPopMatrix(); //to trzeba zebrać przed wyściem + return; + } + glLoadIdentity(); //zacząć od macierzy jedynkowej + Global::pCamera->SetCabMatrix(vPosition); //specjalne ustawienie kamery + } + else + glTranslated(vPosition.x,vPosition.y,vPosition.z); //standardowe przesunięcie względem początku scenerii + glMultMatrixd(mMatrix.getArray()); + if (fShade>0.0) + {//Ra: zmiana oswietlenia w tunelu, wykopie + GLfloat ambientLight[4]= {0.5f,0.5f,0.5f,1.0f}; + GLfloat diffuseLight[4]= {0.5f,0.5f,0.5f,1.0f}; + GLfloat specularLight[4]={0.5f,0.5f,0.5f,1.0f}; + //trochę problem z ambientem w wykopie... + for (int li=0;li<3;li++) + { + ambientLight[li]= Global::ambientDayLight[li]*fShade; + diffuseLight[li]= Global::diffuseDayLight[li]*fShade; + specularLight[li]=Global::specularDayLight[li]*fShade; + } + glLightfv(GL_LIGHT0,GL_AMBIENT,ambientLight); + glLightfv(GL_LIGHT0,GL_DIFFUSE,diffuseLight); + glLightfv(GL_LIGHT0,GL_SPECULAR,specularLight); + } + if (Global::bUseVBO) + {//wersja VBO + if (mdLowPolyInt) + if (FreeFlyModeFlag?true:!mdKabina||!bDisplayCab) + mdLowPolyInt->RaRenderAlpha(ObjSqrDist,ReplacableSkinID,iAlpha); + mdModel->RaRenderAlpha(ObjSqrDist,ReplacableSkinID,iAlpha); + if (mdLoad) + mdLoad->RaRenderAlpha(ObjSqrDist,ReplacableSkinID,iAlpha); + //if (mdPrzedsionek) //Ra: przedsionków tu wcześniej nie było - włączyć? + // mdPrzedsionek->RaRenderAlpha(ObjSqrDist,ReplacableSkinID,iAlpha); + } + else + {//wersja Display Lists + if (mdLowPolyInt) + if (FreeFlyModeFlag?true:!mdKabina||!bDisplayCab) + mdLowPolyInt->RenderAlpha(ObjSqrDist,ReplacableSkinID,iAlpha); + mdModel->RenderAlpha(ObjSqrDist,ReplacableSkinID,iAlpha); + if (mdLoad) + mdLoad->RenderAlpha(ObjSqrDist,ReplacableSkinID,iAlpha); + //if (mdPrzedsionek) //Ra: przedsionków tu wcześniej nie było - włączyć? + // mdPrzedsionek->RenderAlpha(ObjSqrDist,ReplacableSkinID,iAlpha); + } +/* skoro false to można wyciąc + //ABu: Tylko w trybie freefly + if (false)//((mdKabina!=mdModel) && bDisplayCab && FreeFlyModeFlag) + { +//oswietlenie kabiny + GLfloat ambientCabLight[4]= { 0.5f, 0.5f, 0.5f, 1.0f }; + GLfloat diffuseCabLight[4]= { 0.5f, 0.5f, 0.5f, 1.0f }; + GLfloat specularCabLight[4]= { 0.5f, 0.5f, 0.5f, 1.0f }; + for (int li=0; li<3; li++) + { + ambientCabLight[li]= Global::ambientDayLight[li]*0.9; + diffuseCabLight[li]= Global::diffuseDayLight[li]*0.5; + specularCabLight[li]= Global::specularDayLight[li]*0.5; + } + switch (MyTrack->eEnvironment) + { + case e_canyon: + { + for (int li=0; li<3; li++) + { + diffuseCabLight[li]*= 0.6; + specularCabLight[li]*= 0.8; + } + } + break; + case e_tunnel: + { + for (int li=0; li<3; li++) + { + ambientCabLight[li]*= 0.3; + diffuseCabLight[li]*= 0.1; + specularCabLight[li]*= 0.2; + } + } + break; + } +// dorobic swiatlo od drugiej strony szyby + + glLightfv(GL_LIGHT0,GL_AMBIENT,ambientCabLight); + glLightfv(GL_LIGHT0,GL_DIFFUSE,diffuseCabLight); + glLightfv(GL_LIGHT0,GL_SPECULAR,specularCabLight); + + mdKabina->RenderAlpha(ObjSqrDist,0); +//smierdzi +// mdModel->RenderAlpha(SquareMagnitude(Global::pCameraPosition-pos),0); + + glLightfv(GL_LIGHT0,GL_AMBIENT,Global::ambientDayLight); + glLightfv(GL_LIGHT0,GL_DIFFUSE,Global::diffuseDayLight); + glLightfv(GL_LIGHT0,GL_SPECULAR,Global::specularDayLight); + } +*/ + if (fShade!=0.0) //tylko jeśli było zmieniane + {//przywrócenie standardowego oświetlenia + glLightfv(GL_LIGHT0,GL_AMBIENT,Global::ambientDayLight); + glLightfv(GL_LIGHT0,GL_DIFFUSE,Global::diffuseDayLight); + glLightfv(GL_LIGHT0,GL_SPECULAR,Global::specularDayLight); + } + glPopMatrix(); + if (btnOn) TurnOff(); //przywrócenie domyślnych pozycji submodeli + } + return; +} //koniec renderalpha + + +//McZapkie-250202 +//wczytywanie pliku z danymi multimedialnymi (dzwieki) +void __fastcall TDynamicObject::LoadMMediaFile(AnsiString BaseDir,AnsiString TypeName,AnsiString ReplacableSkin) +{ + double dSDist; + TFileStream *fs; + //asBaseDir=BaseDir; + Global::asCurrentDynamicPath=BaseDir; + AnsiString asFileName=BaseDir+TypeName+".mmd"; + AnsiString asLoadName=BaseDir+MoverParameters->LoadType+".t3d"; + if (!FileExists(asFileName)) + { + ErrorLog("Missed file: "+asFileName); //brak MMD + return; + } + fs=new TFileStream(asFileName,fmOpenRead|fmShareCompat); + if (!fs) return; + int size=fs->Size; + if (!size) {return delete fs;}; + AnsiString asAnimName; + bool Stop_InternalData=false; + char* buf=new char[size+1]; //ciąg bajtów o długości równej rozmiwarowi pliku + buf[size]='\0'; //zakończony zerem na wszelki wypadek + fs->Read(buf,size); + delete fs; + TQueryParserComp *Parser; + Parser=new TQueryParserComp(NULL); + Parser->TextToParse=AnsiString(buf); + delete[] buf; + AnsiString str; + //Parser->LoadStringToParse(asFile); + Parser->First(); + //DecimalSeparator= '.'; + pants=NULL; //wskaźnik pierwszego obiektu animującego dla pantografów + int i; + while (!Parser->EndOfFile && !Stop_InternalData) + { + str=Parser->GetNextSymbol().LowerCase(); + if (str==AnsiString("models:")) //modele i podmodele + { + iMultiTex=0; //czy jest wiele tekstur wymiennych? + asModel=Parser->GetNextSymbol().LowerCase(); + if (asModel.Pos("#")==asModel.Length()) //Ra 2015-01: nie podoba mi się to + {//model wymaga wielu tekstur wymiennych + iMultiTex=1; + asModel=asModel.SubString(1,asModel.Length()-1); + } + if ((i=asModel.Pos(","))>0) + {//Ra 2015-01: może szukać przecinka w nazwie modelu, a po przecinku była by liczba tekstur? + if (i1) iMultiTex=1; //na razie ustawiamy na 1 + } + asModel=BaseDir+asModel; //McZapkie 2002-07-20: dynamics maja swoje modele w dynamics/basedir + Global::asCurrentTexturePath=BaseDir; //biezaca sciezka do tekstur to dynamic/... + mdModel=TModelsManager::GetModel(asModel.c_str(),true); + if (ReplacableSkin!=AnsiString("none")) + {//tekstura wymienna jest raczej jedynie w "dynamic\" + ReplacableSkin=Global::asCurrentTexturePath+ReplacableSkin; //skory tez z dynamic/... + if ((i=ReplacableSkin.Pos("|"))>0) //replacable dzielone + {iMultiTex=-1; + ReplacableSkinID[-iMultiTex]=TTexturesManager::GetTextureID(NULL,NULL,ReplacableSkin.SubString(1,i-1).c_str(),Global::iDynamicFiltering); + ReplacableSkin.Delete(1,i); //usunięcie razem z pionową kreską + ReplacableSkin=Global::asCurrentTexturePath+ReplacableSkin; //odtworzenie początku ścieżki + //sprawdzić, ile jest i ustawić iMultiTex na liczbę podanych tekstur + if (!ReplacableSkin.IsEmpty()) + {//próba wycięcia drugiej nazwy + iMultiTex=-2; //skoro zostało coś po kresce, to są co najmniej dwie + if ((i=ReplacableSkin.Pos("|"))==0) //gdy nie ma już kreski + ReplacableSkinID[-iMultiTex]=TTexturesManager::GetTextureID(NULL,NULL,ReplacableSkin.SubString(1,i-1).c_str(),Global::iDynamicFiltering); + else + {//jak jest kreska, to wczytać drugą i próbować trzecią + ReplacableSkinID[-iMultiTex]=TTexturesManager::GetTextureID(NULL,NULL,ReplacableSkin.SubString(1,i-1).c_str(),Global::iDynamicFiltering); + ReplacableSkin.Delete(1,i); //usunięcie razem z pionową kreską + ReplacableSkin=Global::asCurrentTexturePath+ReplacableSkin; //odtworzenie początku ścieżki + if (!ReplacableSkin.IsEmpty()) + {//próba wycięcia trzeciej nazwy + iMultiTex=-3; //skoro zostało coś po kresce, to są co najmniej trzy + if ((i=ReplacableSkin.Pos("|"))==0) //gdy nie ma już kreski + ReplacableSkinID[-iMultiTex]=TTexturesManager::GetTextureID(NULL,NULL,ReplacableSkin.SubString(1,i-1).c_str(),Global::iDynamicFiltering); + else + {//jak jest kreska, to wczytać trzecią i próbować czwartą + ReplacableSkinID[-iMultiTex]=TTexturesManager::GetTextureID(NULL,NULL,ReplacableSkin.SubString(1,i-1).c_str(),Global::iDynamicFiltering); + ReplacableSkin.Delete(1,i); //usunięcie razem z pionową kreską + ReplacableSkin=Global::asCurrentTexturePath+ReplacableSkin; //odtworzenie początku ścieżki + if (!ReplacableSkin.IsEmpty()) + {//próba wycięcia trzeciej nazwy + iMultiTex=-4; //skoro zostało coś po kresce, to są co najmniej cztery + ReplacableSkinID[-iMultiTex]=TTexturesManager::GetTextureID(NULL,NULL,ReplacableSkin.SubString(1,i-1).c_str(),Global::iDynamicFiltering); + //więcej na razie nie zadziała, a u tak trzeba to do modeli przenieść + } + } + } + } + } + } + if (iMultiTex>0) + {//jeśli model ma 4 tekstury + ReplacableSkinID[1]=TTexturesManager::GetTextureID(NULL,NULL,(ReplacableSkin+",1").c_str(),Global::iDynamicFiltering); + if (ReplacableSkinID[1]) + {//pierwsza z zestawu znaleziona + ReplacableSkinID[2]=TTexturesManager::GetTextureID(NULL,NULL,(ReplacableSkin+",2").c_str(),Global::iDynamicFiltering); + if (ReplacableSkinID[2]) + {iMultiTex=2; //już są dwie + ReplacableSkinID[3]=TTexturesManager::GetTextureID(NULL,NULL,(ReplacableSkin+",3").c_str(),Global::iDynamicFiltering); + if (ReplacableSkinID[3]) + {iMultiTex=3; //a teraz nawet trzy + ReplacableSkinID[4]=TTexturesManager::GetTextureID(NULL,NULL,(ReplacableSkin+",4").c_str(),Global::iDynamicFiltering); + if (ReplacableSkinID[4]) iMultiTex=4; //jak są cztery, to blokujemy podmianę tekstury rozkładem + } + } + } + else + {//zestaw nie zadziałał, próbujemy normanie + iMultiTex=0; + ReplacableSkinID[1]=TTexturesManager::GetTextureID(NULL,NULL,ReplacableSkin.c_str(),Global::iDynamicFiltering); + } + } + else + ReplacableSkinID[1]=TTexturesManager::GetTextureID(NULL,NULL,ReplacableSkin.c_str(),Global::iDynamicFiltering); + if (TTexturesManager::GetAlpha(ReplacableSkinID[1])) + iAlpha=0x31310031; //tekstura -1 z kanałem alfa - nie renderować w cyklu nieprzezroczystych + else + iAlpha=0x30300030; //wszystkie tekstury nieprzezroczyste - nie renderować w cyklu przezroczystych + if (ReplacableSkinID[2]) + if (TTexturesManager::GetAlpha(ReplacableSkinID[2])) + iAlpha|=0x02020002; //tekstura -2 z kanałem alfa - nie renderować w cyklu nieprzezroczystych + if (ReplacableSkinID[3]) + if (TTexturesManager::GetAlpha(ReplacableSkinID[3])) + iAlpha|=0x04040004; //tekstura -3 z kanałem alfa - nie renderować w cyklu nieprzezroczystych + if (ReplacableSkinID[4]) + if (TTexturesManager::GetAlpha(ReplacableSkinID[4])) + iAlpha|=0x08080008; //tekstura -4 z kanałem alfa - nie renderować w cyklu nieprzezroczystych + } + //Winger 040304 - ladowanie przedsionkow dla EZT + if (MoverParameters->TrainType==dt_EZT) + { + asModel="przedsionki.t3d"; + asModel=BaseDir+asModel; + mdPrzedsionek=TModelsManager::GetModel(asModel.c_str(),true); + } + if (!MoverParameters->LoadAccepted.IsEmpty()) + //if (MoverParameters->LoadAccepted!=AnsiString("")); // && MoverParameters->LoadType!=AnsiString("passengers")) + if (MoverParameters->EnginePowerSource.SourceType==CurrentCollector) + {//wartość niby "pantstate" - nazwa dla formalności, ważna jest ilość + if (MoverParameters->Load==1) + MoverParameters->PantFront(true); + else if (MoverParameters->Load==2) + MoverParameters->PantRear(true); + else if (MoverParameters->Load==3) + { + MoverParameters->PantFront(true); + MoverParameters->PantRear(true); + } + else if (MoverParameters->Load==4) + MoverParameters->DoubleTr=-1; + else if (MoverParameters->Load==5) + { + MoverParameters->DoubleTr=-1; + MoverParameters->PantRear(true); + } + else if (MoverParameters->Load==6) + { + MoverParameters->DoubleTr=-1; + MoverParameters->PantFront(true); + } + else if (MoverParameters->Load==7) + { + MoverParameters->DoubleTr=-1; + MoverParameters->PantFront(true); + MoverParameters->PantRear(true); + } + } + else //Ra: tu wczytywanie modelu ładunku jest w porządku + mdLoad=TModelsManager::GetModel(asLoadName.c_str(),true); //ladunek + Global::asCurrentTexturePath=AnsiString(szTexturePath); //z powrotem defaultowa sciezka do tekstur + while (!Parser->EndOfFile && str!=AnsiString("endmodels")) + { + str=Parser->GetNextSymbol().LowerCase(); + if (str==AnsiString("animations:")) + {//Ra: ustawienie ilości poszczególnych animacji - musi być jako pierwsze, inaczej ilości będą domyślne + if (!pAnimations) + {//jeśli nie ma jeszcze tabeli animacji, można odczytać nowe ilości + int co=0,ile; + iAnimations=0; + do + {//kolejne liczby to ilość animacj, -1 to znacznik końca + ile=Parser->GetNextSymbol().ToIntDef(-1); //ilość danego typu animacji + //if (co==ANIM_PANTS) + // if (!Global::bLoadTraction) + // if (!DebugModeFlag) //w debugmode pantografy mają "niby działać" + // ile=0; //wyłączenie animacji pantografów + if (co=0) + {iAnimType[co]=ile; //zapamiętanie + iAnimations+=ile; //ogólna ilość animacji + } + ++co; + } while (ile>=0); //-1 to znacznik końca + while (coGetNextSymbol().LowerCase(); + } + //WriteLog("Total animations: "+AnsiString(iAnimations)); + } + if (!pAnimations) + {//Ra: tworzenie tabeli animacji, jeśli jeszcze nie było + if (!iAnimations) //jeśli nie podano jawnie, ile ma być animacji + iAnimations=28; //tyle było kiedyś w każdym pojeździe (2 wiązary wypadły) + /* //pojazd może mieć pantograf do innych celów niż napęd + if (MoverParameters->EnginePowerSource.SourceType!=CurrentCollector) + {//nie będzie pantografów, to się trochę uprości + iAnimations-=iAnimType[ANIM_PANTS]; //domyślnie były 2 pantografy + iAnimType[ANIM_PANTS]=0; + } + */ + pAnimations=new TAnim[iAnimations]; + int i,j,k=0,sm=0; + for (j=0;jGetNextSymbol().LowerCase(); + asModel=BaseDir+asModel; //McZapkie-200702 - dynamics maja swoje modele w dynamic/basedir + Global::asCurrentTexturePath=BaseDir; //biezaca sciezka do tekstur to dynamic/... + mdLowPolyInt=TModelsManager::GetModel(asModel.c_str(),true); + //Global::asCurrentTexturePath=AnsiString(szTexturePath); //kiedyś uproszczone wnętrze mieszało tekstury nieba + } + if (str==AnsiString("brakemode:")) + {//Ra 15-01: gałka nastawy hamulca + asAnimName=Parser->GetNextSymbol().LowerCase(); + smBrakeMode=mdModel->GetFromName(asAnimName.c_str()); + //jeszcze wczytać kąty obrotu dla poszczególnych ustawień + } + if (str==AnsiString("loadmode:")) + {//Ra 15-01: gałka nastawy hamulca + asAnimName=Parser->GetNextSymbol().LowerCase(); + smLoadMode=mdModel->GetFromName(asAnimName.c_str()); + //jeszcze wczytać kąty obrotu dla poszczególnych ustawień + } + else if (str==AnsiString("animwheelprefix:")) + {//prefiks kręcących się kół + int i,j,k,m; + str=Parser->GetNextSymbol(); + for (i=0;iGetFromName(asAnimName.c_str()); //ustalenie submodelu + if (pAnimations[i].smAnimated) + {//++iAnimatedAxles; + pAnimations[i].smAnimated->WillBeAnimated(); //wyłączenie optymalizacji transformu + pAnimations[i].yUpdate=UpdateAxle; //animacja osi + pAnimations[i].fMaxDist=50*MoverParameters->WheelDiameter; //nie kręcić w większej odległości + pAnimations[i].fMaxDist*=pAnimations[i].fMaxDist*MoverParameters->WheelDiameter; //50m do kwadratu, a średnica do trzeciej + pAnimations[i].fMaxDist*=Global::fDistanceFactor; //współczynnik przeliczeniowy jakości ekranu + } + } + //Ra: ustawianie indeksów osi + for (i=0;iWheelDiameterL!=MoverParameters->WheelDiameter)||(MoverParameters->WheelDiameterT!=MoverParameters->WheelDiameter)) + {//obsługa różnych średnic, o ile występują + while ((iAxleArangement.Length())) + {//wersja ze wskaźnikami jest bardziej elastyczna na nietypowe układy + if ((k>='A')&&(k<='J')) //10 chyba maksimum? + {pAnimations[i++].dWheelAngle=dWheelAngle+1; //obrót osi napędzających + --k; //następna będzie albo taka sama, albo bierzemy kolejny znak + m=2; //następujące toczne będą miały inną średnicę + } + else if ((k>='1')&&(k<='9')) + {pAnimations[i++].dWheelAngle=dWheelAngle+m; //obrót osi tocznych + --k; //następna będzie albo taka sama, albo bierzemy kolejny znak + } + else + k=MoverParameters->AxleArangement[j++]; //pobranie kolejnego znaku + } + } + } + //else if (str==AnsiString("animrodprefix:")) //prefiks wiazarow dwoch + // { + // str= Parser->GetNextSymbol(); + // for (int i=1; i<=2; i++) + // {//McZapkie-050402: wyszukiwanie max 2 wiazarow o nazwie str* + // asAnimName=str+i; + // smWiazary[i-1]=mdModel->GetFromName(asAnimName.c_str()); + // smWiazary[i-1]->WillBeAnimated(); + // } + // } + else if (str==AnsiString("animpantprefix:")) + {//Ra: pantografy po nowemu mają literki i numerki + } +//Pantografy - Winger 160204 + if (str==AnsiString("animpantrd1prefix:")) + {//prefiks ramion dolnych 1 + str=Parser->GetNextSymbol(); + float4x4 m; //macierz do wyliczenia pozycji i wektora ruchu pantografu + TSubModel *sm; + if (pants) + for (int i=0;iGetFromName(asAnimName.c_str()); + pants[i].smElement[0]=sm; //jak NULL, to nie będzie animowany + if (sm) + {//w EP09 wywalało się tu z powodu NULL + sm->WillBeAnimated(); + sm->ParentMatrix(&m); //pobranie macierzy transformacji + //m(3)[1]=m[3][1]+0.054; //w górę o wysokość ślizgu (na razie tak) + if ((mdModel->Flags()&0x8000)==0) //jeśli wczytano z T3D + m.InitialRotate(); //może być potrzebny dodatkowy obrót, jeśli wczytano z T3D, tzn. przed wykonaniem Init() + pants[i].fParamPants->vPos.z=m[3][0]; //przesunięcie w bok (asymetria) + pants[i].fParamPants->vPos.y=m[3][1]; //przesunięcie w górę odczytane z modelu + if ((sm=pants[i].smElement[0]->ChildGet())!=NULL) + {//jeśli ma potomny, można policzyć długość (odległość potomnego od osi obrotu) + m=float4x4(*sm->GetMatrix()); //wystarczyłby wskaźnik, nie trzeba kopiować + //może trzeba: pobrać macierz dolnego ramienia, wyzerować przesunięcie, przemnożyć przez macierz górnego + pants[i].fParamPants->fHoriz=-fabs(m[3][1]); + pants[i].fParamPants->fLenL1=hypot(m[3][1],m[3][2]); //po osi OX nie potrzeba + pants[i].fParamPants->fAngleL0=atan2(fabs(m[3][2]),fabs(m[3][1])); + //if (pants[i].fParamPants->fAngleL0fAngleL0+=M_PI; //gdyby w odwrotną stronę wyszło + //if ((pants[i].fParamPants->fAngleL0<0.03)||(pants[i].fParamPants->fAngleL0>0.09)) //normalnie ok. 0.05 + // pants[i].fParamPants->fAngleL0=pants[i].fParamPants->fAngleL; + pants[i].fParamPants->fAngleL=pants[i].fParamPants->fAngleL0; //początkowy kąt dolnego ramienia + if ((sm=sm->ChildGet())!=NULL) + {//jeśli dalej jest ślizg, można policzyć długość górnego ramienia + m=float4x4(*sm->GetMatrix()); //wystarczyłby wskaźnik, nie trzeba kopiować + //trzeba by uwzględnić macierz dolnego ramienia, żeby uzyskać kąt do poziomu... + pants[i].fParamPants->fHoriz+=fabs(m(3)[1]); //różnica długości rzutów ramion na płaszczyznę podstawy (jedna dodatnia, druga ujemna) + pants[i].fParamPants->fLenU1=hypot(m[3][1],m[3][2]); //po osi OX nie potrzeba + //pants[i].fParamPants->pantu=acos((1.22*cos(pants[i].fParamPants->fAngleL)+0.535)/1.755); //górne ramię + //pants[i].fParamPants->fAngleU0=acos((1.176289*cos(pants[i].fParamPants->fAngleL)+0.54555075)/1.724482197); //górne ramię + pants[i].fParamPants->fAngleU0=atan2(fabs(m[3][2]),fabs(m[3][1])); //początkowy kąt górnego ramienia, odczytany z modelu + //if (pants[i].fParamPants->fAngleU0fAngleU0+=M_PI; //gdyby w odwrotną stronę wyszło + //if (pants[i].fParamPants->fAngleU0<0) + // pants[i].fParamPants->fAngleU0=-pants[i].fParamPants->fAngleU0; + //if ((pants[i].fParamPants->fAngleU0<0.00)||(pants[i].fParamPants->fAngleU0>0.09)) //normalnie ok. 0.07 + // pants[i].fParamPants->fAngleU0=acos((pants[i].fParamPants->fLenL1*cos(pants[i].fParamPants->fAngleL)+pants[i].fParamPants->fHoriz)/pants[i].fParamPants->fLenU1); + pants[i].fParamPants->fAngleU=pants[i].fParamPants->fAngleU0; //początkowy kąt + //Ra: ze względu na to, że niektóre modele pantografów są zrąbane, ich mierzenie ma obecnie ograniczony sens + sm->ParentMatrix(&m); //pobranie macierzy transformacji pivota ślizgu względem wstawienia pojazdu + if ((mdModel->Flags()&0x8000)==0) //jeśli wczytano z T3D + m.InitialRotate(); //może być potrzebny dodatkowy obrót, jeśli wczytano z T3D, tzn. przed wykonaniem Init() + float det=Det(m); + if (fabs(det-1.0)<0.001) //dopuszczamy 1 promil błędu na skalowaniu ślizgu + {//skalowanie jest w normie, można pobrać wymiary z modelu + pants[i].fParamPants->fHeight=sm->MaxY(m); //przeliczenie maksimum wysokości wierzchołków względem macierzy + pants[i].fParamPants->fHeight-=m[3][1]; //odjęcie wysokości pivota ślizgu + pants[i].fParamPants->vPos.x=m[3][2]; //przy okazji odczytać z modelu pozycję w długości + //ErrorLog("Model OK: "+asModel+", height="+pants[i].fParamPants->fHeight); + //ErrorLog("Model OK: "+asModel+", pos.x="+pants[i].fParamPants->vPos.x); + } + else + {//gdy ktoś przesadził ze skalowaniem + pants[i].fParamPants->fHeight=0.0; //niech będzie odczyt z pantfactors: + ErrorLog("Bad model: "+asModel+", scale of "+AnsiString(sm->pName)+" is "+AnsiString(100.0*det)+"%"); + } + } + } + } + else + ErrorLog("Bad model: "+asFileName+" - missed submodel "+asAnimName); //brak ramienia + } + } + else if (str==AnsiString("animpantrd2prefix:")) + {//prefiks ramion dolnych 2 + str=Parser->GetNextSymbol(); + float4x4 m; //macierz do wyliczenia pozycji i wektora ruchu pantografu + TSubModel *sm; + if (pants) + for (int i=0;iGetFromName(asAnimName.c_str()); + pants[i].smElement[1]=sm; //jak NULL, to nie będzie animowany + if (sm) + {//w EP09 wywalało się tu z powodu NULL + sm->WillBeAnimated(); + if (pants[i].fParamPants->vPos.y==0.0) + {//jeśli pierwsze ramię nie ustawiło tej wartości, próbować drugim + //!!!! docelowo zrobić niezależną animację ramion z każdej strony + m=float4x4(*sm->GetMatrix()); //skopiowanie, bo będziemy mnożyć + m(3)[1]=m[3][1]+0.054; //w górę o wysokość ślizgu (na razie tak) + while (sm->Parent) + { + if (sm->Parent->GetMatrix()) + m=*sm->Parent->GetMatrix()*m; + sm=sm->Parent; + } + pants[i].fParamPants->vPos.z=m[3][0]; //przesunięcie w bok (asymetria) + pants[i].fParamPants->vPos.y=m[3][1]; //przesunięcie w górę odczytane z modelu + } + } + else + ErrorLog("Bad model: "+asFileName+" - missed submodel "+asAnimName); //brak ramienia + } + } + else if (str==AnsiString("animpantrg1prefix:")) + {//prefiks ramion górnych 1 + str=Parser->GetNextSymbol(); + if (pants) + for (int i=0;iGetFromName(asAnimName.c_str()); + pants[i].smElement[2]->WillBeAnimated(); + } + } + else + if (str==AnsiString("animpantrg2prefix:")) + {//prefiks ramion górnych 2 + str=Parser->GetNextSymbol(); + if (pants) + for (int i=0;iGetFromName(asAnimName.c_str()); + pants[i].smElement[3]->WillBeAnimated(); + } + } + else if (str==AnsiString("animpantslprefix:")) + {//prefiks ślizgaczy + str=Parser->GetNextSymbol(); + if (pants) + for (int i=0;iGetFromName(asAnimName.c_str()); + pants[i].smElement[4]->WillBeAnimated(); + pants[i].yUpdate=UpdatePant; + pants[i].fMaxDist=300*300; //nie podnosić w większej odległości + pants[i].iNumber=i; + } + } + else if (str==AnsiString("pantfactors:")) + {//Winger 010304: parametry pantografow + double pant1x=Parser->GetNextSymbol().ToDouble(); + double pant2x=Parser->GetNextSymbol().ToDouble(); + double pant1h=Parser->GetNextSymbol().ToDouble(); //wysokość pierwszego ślizgu + double pant2h=Parser->GetNextSymbol().ToDouble(); //wysokość drugiego ślizgu + if (pant1h>0.5) pant1h=pant2h; //tu może być zbyt duża wartość + if ((pant1x<0)&&(pant2x>0)) //pierwsza powinna być dodatnia, a druga ujemna + {pant1x=-pant1x; pant2x=-pant2x;} + if (pants) + for (int i=0;ifAngleL=pants[i].fParamPants->fAngleL0; //początkowy kąt dolnego ramienia + pants[i].fParamPants->fAngleU=pants[i].fParamPants->fAngleU0; //początkowy kąt + //pants[i].fParamPants->PantWys=1.22*sin(pants[i].fParamPants->fAngleL)+1.755*sin(pants[i].fParamPants->fAngleU); //wysokość początkowa + //pants[i].fParamPants->PantWys=1.176289*sin(pants[i].fParamPants->fAngleL)+1.724482197*sin(pants[i].fParamPants->fAngleU); //wysokość początkowa + if (pants[i].fParamPants->fHeight==0.0) //gdy jest nieprawdopodobna wartość (np. nie znaleziony ślizg) + {//gdy pomiary modelu nie udały się, odczyt podanych parametrów z MMD + pants[i].fParamPants->vPos.x=(i&1)?pant2x:pant1x; + pants[i].fParamPants->fHeight=(i&1)?pant2h:pant1h; //wysokość ślizgu jest zapisana w MMD + } + pants[i].fParamPants->PantWys=pants[i].fParamPants->fLenL1*sin(pants[i].fParamPants->fAngleL)+pants[i].fParamPants->fLenU1*sin(pants[i].fParamPants->fAngleU)+pants[i].fParamPants->fHeight; //wysokość początkowa + //pants[i].fParamPants->vPos.y=panty-panth-pants[i].fParamPants->PantWys; //np. 4.429-0.097=4.332=~4.335 + //pants[i].fParamPants->vPos.z=0; //niezerowe dla pantografów asymetrycznych + pants[i].fParamPants->PantTraction=pants[i].fParamPants->PantWys; + pants[i].fParamPants->fWidth=0.5*MoverParameters->EnginePowerSource.CollectorParameters.CSW; //połowa szerokości ślizgu; jest w "Power: CSW=" + } + } + else if (str==AnsiString("animpistonprefix:")) + {//prefiks tłoczysk - na razie używamy modeli pantografów + str=Parser->GetNextSymbol(); + for (int i=1;i<=2;i++) + { + //asAnimName=str+i; + //smPatykird1[i-1]=mdModel->GetFromName(asAnimName.c_str()); + //smPatykird1[i-1]->WillBeAnimated(); + } + } + else if (str==AnsiString("animconrodprefix:")) + {//prefiks korbowodów - na razie używamy modeli pantografów + str=Parser->GetNextSymbol(); + for (int i=1;i<=2;i++) + { + //asAnimName=str+i; + //smPatykirg1[i-1]=mdModel->GetFromName(asAnimName.c_str()); + //smPatykirg1[i-1]->WillBeAnimated(); + } + } + else if (str==AnsiString("pistonfactors:")) + {//Ra: parametry silnika parowego (tłoka) +/* //Ra: tymczasowo wyłączone ze względu na porządkowanie animacji pantografów + pant1x=Parser->GetNextSymbol().ToDouble(); //kąt przesunięcia dla pierwszego tłoka + pant2x=Parser->GetNextSymbol().ToDouble(); //kąt przesunięcia dla drugiego tłoka + panty=Parser->GetNextSymbol().ToDouble(); //długość korby (r) + panth=Parser->GetNextSymbol().ToDouble(); //długoś korbowodu (k) +*/ + MoverParameters->EnginePowerSource.PowerType=SteamPower; //Ra: po chamsku, ale z CHK nie działa + } + else if (str==AnsiString("animreturnprefix:")) + {//prefiks drążka mimośrodowego - na razie używamy modeli pantografów + str=Parser->GetNextSymbol(); + for (int i=1;i<=2;i++) + { + //asAnimName=str+i; + //smPatykird2[i-1]=mdModel->GetFromName(asAnimName.c_str()); + //smPatykird2[i-1]->WillBeAnimated(); + } + } + else if (str==AnsiString("animexplinkprefix:")) //animreturnprefix: + {//prefiks jarzma - na razie używamy modeli pantografów + str=Parser->GetNextSymbol(); + for (int i=1;i<=2;i++) + { + //asAnimName=str+i; + //smPatykirg2[i-1]=mdModel->GetFromName(asAnimName.c_str()); + //smPatykirg2[i-1]->WillBeAnimated(); + } + } + else if (str==AnsiString("animpendulumprefix:")) + {//prefiks wahaczy + str=Parser->GetNextSymbol(); + asAnimName=""; + for (int i=1; i<=4; i++) + {//McZapkie-050402: wyszukiwanie max 4 wahaczy o nazwie str* + asAnimName=str+AnsiString(i); + smWahacze[i-1]=mdModel->GetFromName(asAnimName.c_str()); + smWahacze[i-1]->WillBeAnimated(); + } + str=Parser->GetNextSymbol().LowerCase(); + if (str==AnsiString("pendulumamplitude:")) + fWahaczeAmp=Parser->GetNextSymbol().ToDouble(); + } + else + if (str==AnsiString("engineer:")) + {//nazwa submodelu maszynisty + str=Parser->GetNextSymbol(); + smMechanik0=mdModel->GetFromName(str.c_str()); + if (!smMechanik0) + {//jak nie ma bez numerka, to może jest z numerkiem? + smMechanik0=mdModel->GetFromName(AnsiString(str+"1").c_str()); + smMechanik1=mdModel->GetFromName(AnsiString(str+"2").c_str()); + } + //aby dało się go obracać, musi mieć włączoną animację w T3D! + //if (!smMechanik1) //jeśli drugiego nie ma + // if (smMechanik0) //a jest pierwszy + // smMechanik0->WillBeAnimated(); //to będziemy go obracać + } + else if (str==AnsiString("animdoorprefix:")) + {//nazwa animowanych drzwi + int i,j,k,m; + str=Parser->GetNextSymbol(); + for (i=0,j=0;iGetFromName(asAnimName.c_str()); //ustalenie submodelu + if (pAnimations[i+j].smAnimated) + {//++iAnimatedDoors; + pAnimations[i+j].smAnimated->WillBeAnimated(); //wyłączenie optymalizacji transformu + switch (MoverParameters->DoorOpenMethod) + {//od razu zapinamy potrzebny typ animacji + case 1: pAnimations[i+j].yUpdate=UpdateDoorTranslate; break; + case 2: pAnimations[i+j].yUpdate=UpdateDoorRotate; break; + case 3: pAnimations[i+j].yUpdate=UpdateDoorFold; break; //obrót 3 kolejnych submodeli + } + pAnimations[i+j].iNumber=i; //parzyste działają inaczej niż nieparzyste + pAnimations[i+j].fMaxDist=300*300; //drzwi to z daleka widać + pAnimations[i+j].fSpeed=random(150); //oryginalny koncept z DoorSpeedFactor + pAnimations[i+j].fSpeed=(pAnimations[i+j].fSpeed+100)/100; + //Ra: te współczynniki są bez sensu, bo modyfikują wektor przesunięcia + } + } + } + } + } + else + if (str==AnsiString("sounds:")) //dzwieki + while (!Parser->EndOfFile && str!=AnsiString("endsounds")) + { + str= Parser->GetNextSymbol().LowerCase(); + if (str==AnsiString("wheel_clatter:")) //polozenia osi w/m srodka pojazdu + { + dSDist=Parser->GetNextSymbol().ToDouble(); + for (int i=0; iGetNextSymbol(); + dWheelsPosition[i]=str.ToDouble(); + str= Parser->GetNextSymbol().LowerCase(); + if (str!=AnsiString("end")) + rsStukot[i].Init(str.c_str(),dSDist,GetPosition().x,GetPosition().y+dWheelsPosition[i],GetPosition().z,true); + } + if (str!=AnsiString("end")) + str= Parser->GetNextSymbol(); + } + else + if ((str==AnsiString("engine:")) && (MoverParameters->Power>0)) //plik z dzwiekiem silnika, mnozniki i ofsety amp. i czest. + { + str= Parser->GetNextSymbol(); + rsSilnik.Init(str.c_str(),Parser->GetNextSymbol().ToDouble(),GetPosition().x,GetPosition().y,GetPosition().z,true,true); + if (rsSilnik.GetWaveTime()==0) + ErrorLog("Missed sound: \""+str+"\" for "+asFileName); + if (MoverParameters->EngineType==DieselEngine) + rsSilnik.AM=Parser->GetNextSymbol().ToDouble()/(MoverParameters->Power+MoverParameters->nmax*60); + else if (MoverParameters->EngineType==DieselElectric) + rsSilnik.AM=Parser->GetNextSymbol().ToDouble()/(MoverParameters->Power*3); + else + rsSilnik.AM=Parser->GetNextSymbol().ToDouble()/(MoverParameters->Power+MoverParameters->nmax*60+MoverParameters->Power+MoverParameters->Power); + rsSilnik.AA=Parser->GetNextSymbol().ToDouble(); + rsSilnik.FM=Parser->GetNextSymbol().ToDouble();//MoverParameters->nmax; + rsSilnik.FA=Parser->GetNextSymbol().ToDouble(); + } + else + if (((str==AnsiString("ventilator:")) && ((MoverParameters->EngineType==ElectricSeriesMotor)||(MoverParameters->EngineType==ElectricInductionMotor)))) //plik z dzwiekiem wentylatora, mnozniki i ofsety amp. i czest. + { + str= Parser->GetNextSymbol(); + rsWentylator.Init(str.c_str(),Parser->GetNextSymbol().ToDouble(),GetPosition().x,GetPosition().y,GetPosition().z,true,true); + rsWentylator.AM=Parser->GetNextSymbol().ToDouble()/MoverParameters->RVentnmax; + rsWentylator.AA=Parser->GetNextSymbol().ToDouble(); + rsWentylator.FM=Parser->GetNextSymbol().ToDouble()/MoverParameters->RVentnmax; + rsWentylator.FA=Parser->GetNextSymbol().ToDouble(); + } + else + if ((str==AnsiString("transmission:")) && (MoverParameters->EngineType==ElectricSeriesMotor)) //plik z dzwiekiem, mnozniki i ofsety amp. i czest. + { + str= Parser->GetNextSymbol(); + rsPrzekladnia.Init(str.c_str(),Parser->GetNextSymbol().ToDouble(),GetPosition().x,GetPosition().y,GetPosition().z,true); + rsPrzekladnia.AM=0.029; + rsPrzekladnia.AA=0.1; + rsPrzekladnia.FM=0.005; + rsPrzekladnia.FA=1.0; + } + else + if (str==AnsiString("brake:")) //plik z piskiem hamulca, mnozniki i ofsety amplitudy. + { + str= Parser->GetNextSymbol(); + rsPisk.Init(str.c_str(),Parser->GetNextSymbol().ToDouble(),GetPosition().x,GetPosition().y,GetPosition().z,true); + rsPisk.AM=Parser->GetNextSymbol().ToDouble(); + rsPisk.AA=Parser->GetNextSymbol().ToDouble()*(105-random(10))/100; + rsPisk.FM=1.0; + rsPisk.FA=0.0; + } + else + if (str==AnsiString("brakeacc:")) //plik z przyspieszaczem (upust po zlapaniu hamowania) + { + str= Parser->GetNextSymbol(); +// sBrakeAcc.Init(str.c_str(),Parser->GetNextSymbol().ToDouble(),GetPosition().x,GetPosition().y,GetPosition().z,true); + sBrakeAcc=TSoundsManager::GetFromName(str.c_str(),true); + bBrakeAcc=true; +// sBrakeAcc.AM=1.0; +// sBrakeAcc.AA=0.0; +// sBrakeAcc.FM=1.0; +// sBrakeAcc.FA=0.0; + } + else + if (str==AnsiString("unbrake:")) //plik z piskiem hamulca, mnozniki i ofsety amplitudy. + { + str= Parser->GetNextSymbol(); + rsUnbrake.Init(str.c_str(),Parser->GetNextSymbol().ToDouble(),GetPosition().x,GetPosition().y,GetPosition().z,true); + rsUnbrake.AM=1.0; + rsUnbrake.AA=0.0; + rsUnbrake.FM=1.0; + rsUnbrake.FA=0.0; + } + else + if (str==AnsiString("derail:")) //dzwiek przy wykolejeniu + { + str= Parser->GetNextSymbol(); + rsDerailment.Init(str.c_str(),Parser->GetNextSymbol().ToDouble(),GetPosition().x,GetPosition().y,GetPosition().z,true); + rsDerailment.AM=1.0; + rsDerailment.AA=0.0; + rsDerailment.FM=1.0; + rsDerailment.FA=0.0; + } + else + if (str==AnsiString("dieselinc:")) //dzwiek przy wlazeniu na obroty woodwarda + { + str= Parser->GetNextSymbol(); + rsDiesielInc.Init(str.c_str(),Parser->GetNextSymbol().ToDouble(),GetPosition().x,GetPosition().y,GetPosition().z,true); + rsDiesielInc.AM=1.0; + rsDiesielInc.AA=0.0; + rsDiesielInc.FM=1.0; + rsDiesielInc.FA=0.0; + } + else + if (str==AnsiString("curve:")) + { + str= Parser->GetNextSymbol(); + rscurve.Init(str.c_str(),Parser->GetNextSymbol().ToDouble(),GetPosition().x,GetPosition().y,GetPosition().z,true); + rscurve.AM=1.0; + rscurve.AA=0.0; + rscurve.FM=1.0; + rscurve.FA=0.0; + } + else + if (str==AnsiString("horn1:")) //pliki z trabieniem + { + sHorn1.Load(Parser,GetPosition()); + } + if (str==AnsiString("horn2:")) //pliki z trabieniem wysokoton. + { + sHorn2.Load(Parser,GetPosition()); + if (iHornWarning) iHornWarning=2; //numer syreny do użycia po otrzymaniu sygnału do jazdy + } + if (str==AnsiString("departuresignal:")) //pliki z sygnalem odjazdu + { + sDepartureSignal.Load(Parser,GetPosition()); + } + if (str==AnsiString("pantographup:")) //pliki dzwiekow pantografow + { + str=Parser->GetNextSymbol(); + sPantUp.Init(str.c_str(),50,GetPosition().x,GetPosition().y,GetPosition().z,true); + sPantUp.AM=50000; + sPantUp.AA=-1*(105-random(10))/100; + sPantUp.FM=1.0; + sPantUp.FA=0.0; + } + if (str==AnsiString("pantographdown:")) //pliki dzwiekow pantografow + { + str= Parser->GetNextSymbol(); + sPantDown.Init(str.c_str(),50,GetPosition().x,GetPosition().y,GetPosition().z,true); + sPantDown.AM=50000; + sPantDown.AA=-1*(105-random(10))/100; + sPantDown.FM=1.0; + sPantDown.FA=0.0; + } + else if (str==AnsiString("compressor:")) //pliki ze sprezarka + { + sCompressor.Load(Parser,GetPosition()); + } + else if (str==AnsiString("converter:")) //pliki z przetwornica + { + //if (MoverParameters->EngineType==DieselElectric) //będzie modulowany? + sConverter.Load(Parser,GetPosition()); + } + else if (str==AnsiString("turbo:")) //pliki z turbogeneratorem + { + sTurbo.Load(Parser,GetPosition()); + } + else if (str==AnsiString("small-compressor:")) //pliki z przetwornica + { + sSmallCompressor.Load(Parser,GetPosition()); + } + else if (str==AnsiString("dooropen:")) + { + str=Parser->GetNextSymbol(); + rsDoorOpen.Init(str.c_str(),50,GetPosition().x,GetPosition().y,GetPosition().z,true); + rsDoorOpen.AM=50000; + rsDoorOpen.AA=-1*(105-random(10))/100; + rsDoorOpen.FM=1.0; + rsDoorOpen.FA=0.0; + } + else if (str==AnsiString("doorclose:")) + { + str=Parser->GetNextSymbol(); + rsDoorClose.Init(str.c_str(),50,GetPosition().x,GetPosition().y,GetPosition().z,true); + rsDoorClose.AM=50000; + rsDoorClose.AA=-1*(105-random(10))/100; + rsDoorClose.FM=1.0; + rsDoorClose.FA=0.0; + } + } + else + if (str==AnsiString("internaldata:")) //dalej nie czytaj + {while (!Parser->EndOfFile) + {//zbieranie informacji o kabinach + str=Parser->GetNextSymbol().LowerCase(); + if (str=="cab0model:") + {str=Parser->GetNextSymbol(); + if (str!="none") iCabs=2; + } + else if (str=="cab1model:") + {str=Parser->GetNextSymbol(); + if (str!="none") iCabs=1; + } + else if (str=="cab2model:") + {str=Parser->GetNextSymbol(); + if (str!="none") iCabs=4; + } + } + Stop_InternalData=true; + } + } + //ABu 050205 - tego wczesniej nie bylo i uciekala pamiec: + delete Parser; + if (mdModel) mdModel->Init(); //obrócenie modelu oraz optymalizacja, również zapisanie binarnego + if (mdLoad) mdLoad->Init(); + if (mdPrzedsionek) mdPrzedsionek->Init(); + if (mdLowPolyInt) mdLowPolyInt->Init(); + //sHorn2.CopyIfEmpty(sHorn1); //żeby jednak trąbił też drugim + Global::asCurrentTexturePath=AnsiString(szTexturePath); //kiedyś uproszczone wnętrze mieszało tekstury nieba +} + +//--------------------------------------------------------------------------- +void __fastcall TDynamicObject::RadioStop() +{//zatrzymanie pojazdu + if (Mechanik) //o ile ktoś go prowadzi + if (MoverParameters->SecuritySystem.RadioStop) //jeśli pojazd ma RadioStop i jest on aktywny + Mechanik->PutCommand("Emergency_brake",1.0,1.0,&vPosition,stopRadio); +}; + +void __fastcall TDynamicObject::RaLightsSet(int head,int rear) +{//zapalenie świateł z przodu i z tyłu, zależne od kierunku pojazdu + if (!MoverParameters) return; //może tego nie być na początku + if (rear==2+32+64) + {//jeśli koniec pociągu, to trzeba ustalić, czy jest tam czynna lokomotywa + //EN57 może nie mieć końcówek od środka członu + if (MoverParameters->Power>1.0) //jeśli ma moc napędową + if (!MoverParameters->ActiveDir) //jeśli nie ma ustawionego kierunku + {//jeśli ma zarówno światła jak i końcówki, ustalić, czy jest w stanie aktywnym + //np. lokomotywa na zimno będzie mieć końcówki a nie światła + rear=64; //tablice blaszane + //trzeba to uzależnić od "załączenia baterii" w pojeździe + } + if (rear==2+32+64) //jeśli nadal obydwie możliwości + if (iInventory&(iDirection?0x2A:0x15)) //czy ma jakieś światła czerowone od danej strony + rear=2+32; //dwa światła czerwone + else + rear=64; //tablice blaszane + } + if (iDirection) //w zależności od kierunku pojazdu w składzie + {//jesli pojazd stoi sprzęgiem 0 w stronę czoła + if (head>=0) iLights[0]=head; + if (rear>=0) iLights[1]=rear; + } + else + {//jak jest odwrócony w składzie (-1), to zapalamy odwrotnie + if (head>=0) iLights[1]=head; + if (rear>=0) iLights[0]=rear; + } +}; + +int __fastcall TDynamicObject::DirectionSet(int d) +{//ustawienie kierunku w składzie (wykonuje AI) + iDirection=d>0?1:0; //d:1=zgodny,-1=przeciwny; iDirection:1=zgodny,0=przeciwny; + CouplCounter=20; //żeby normalnie skanować kolizje, to musi ruszyć z miejsca + if (MyTrack) + {//podczas wczytywania wstawiane jest AI, ale może jeszcze nie być toru + //AI ustawi kierunek ponownie po uruchomieniu silnika + if (iDirection) //jeśli w kierunku Coupler 0 + {if (MoverParameters->Couplers[0].CouplingFlag==ctrain_virtual) //brak pojazdu podpiętego? + ABuScanObjects(1,300); //szukanie czegoś do podłączenia + } + else + if (MoverParameters->Couplers[1].CouplingFlag==ctrain_virtual) //brak pojazdu podpiętego? + ABuScanObjects(-1,300); + } + return 1-(iDirection?NextConnectedNo:PrevConnectedNo); //informacja o położeniu następnego +}; + +TDynamicObject* __fastcall TDynamicObject::PrevAny() +{//wskaźnik na poprzedni, nawet wirtualny + return iDirection?PrevConnected:NextConnected; +}; +TDynamicObject* __fastcall TDynamicObject::Prev() +{ + if (MoverParameters->Couplers[iDirection^1].CouplingFlag) + return iDirection?PrevConnected:NextConnected; + return NULL; //gdy sprzęg wirtualny, to jakby nic nie było +}; +TDynamicObject* __fastcall TDynamicObject::Next() +{ + if (MoverParameters->Couplers[iDirection].CouplingFlag) + return iDirection?NextConnected:PrevConnected; + return NULL; //gdy sprzęg wirtualny, to jakby nic nie było +}; +TDynamicObject* __fastcall TDynamicObject::NextC(int C) +{ + if (MoverParameters->Couplers[iDirection].CouplingFlag&C) + return iDirection?NextConnected:PrevConnected; + return NULL; //gdy sprzęg inny, to jakby nic nie było +}; +double __fastcall TDynamicObject::NextDistance(double d) +{//ustalenie odległości do następnego pojazdu, potrzebne do wstecznego skanowania + if (!MoverParameters->Couplers[iDirection].Connected) + return d; //jeśli nic nie ma, zwrócenie domyślnej wartości + if ((d<=0.0)||(MoverParameters->Couplers[iDirection].CoupleDistCouplers[iDirection].Dist; + else + return d; +}; + +TDynamicObject* __fastcall TDynamicObject::Neightbour(int &dir) +{//ustalenie następnego (1) albo poprzedniego (0) w składzie bez względu na prawidłowość iDirection + int d=dir; //zapamiętanie kierunku + dir=1-(dir?NextConnectedNo:PrevConnectedNo); //nowa wartość + return (d?(MoverParameters->Couplers[1].CouplingFlag?NextConnected:NULL):(MoverParameters->Couplers[0].CouplingFlag?PrevConnected:NULL)); +}; + +void __fastcall TDynamicObject::CoupleDist() +{//obliczenie odległości sprzęgów + if (MyTrack?(MyTrack->iCategoryFlag&1):true) //jeśli nie ma przypisanego toru, to liczyć jak dla kolei + {//jeśli jedzie po szynach (również unimog), liczenie kul wystarczy + MoverParameters->SetCoupleDist(); + } + else + {//na drodze trzeba uwzględnić wektory ruchu + double d0=MoverParameters->Couplers[0].CoupleDist; + //double d1=MoverParameters->Couplers[1].CoupleDist; //sprzęg z tyłu samochodu można olać, dopóki nie jeździ na wstecznym + vector3 p1,p2; + double d,w; //dopuszczalny dystans w poprzek + MoverParameters->SetCoupleDist(); //liczenie standardowe + if (MoverParameters->Couplers[0].Connected) //jeśli cokolwiek podłączone + if (MoverParameters->Couplers[0].CouplingFlag==0) //jeśli wirtualny + if (MoverParameters->Couplers[0].CoupleDist<300.0) //i mniej niż 300m + {//przez MoverParameters->Couplers[0].Connected nie da się dostać do DynObj, stąd prowizorka + //WriteLog("Collision of "+AnsiString(MoverParameters->Couplers[0].CoupleDist)+"m detected by "+asName+":0."); + w=0.5*(MoverParameters->Couplers[0].Connected->Dim.W+MoverParameters->Dim.W); //minimalna odległość minięcia + d=-DotProduct(vLeft,vCoulpler[0]); //odległość prostej ruchu od początku układu współrzędnych + d=fabs(DotProduct(vLeft,((TMoverParameters*)(MoverParameters->Couplers[0].Connected))->vCoulpler[MoverParameters->Couplers[0].ConnectedNr])+d); + //WriteLog("Distance "+AnsiString(d)+"m from "+asName+":0."); + if (d>w) + MoverParameters->Couplers[0].CoupleDist=(d0<10?50:d0); //przywrócenie poprzedniej + } + if (MoverParameters->Couplers[1].Connected) //jeśli cokolwiek podłączone + if (MoverParameters->Couplers[1].CouplingFlag==0) //jeśli wirtualny + if (MoverParameters->Couplers[1].CoupleDist<300.0) //i mniej niż 300m + { + //WriteLog("Collision of "+AnsiString(MoverParameters->Couplers[1].CoupleDist)+"m detected by "+asName+":1."); + w=0.5*(MoverParameters->Couplers[1].Connected->Dim.W+MoverParameters->Dim.W); //minimalna odległość minięcia + d=-DotProduct(vLeft,vCoulpler[1]); //odległość prostej ruchu od początku układu współrzędnych + d=fabs(DotProduct(vLeft,((TMoverParameters*)(MoverParameters->Couplers[1].Connected))->vCoulpler[MoverParameters->Couplers[1].ConnectedNr])+d); + //WriteLog("Distance "+AnsiString(d)+"m from "+asName+":1."); + if (d>w) + MoverParameters->Couplers[0].CoupleDist=(d0<10?50:d0); //przywrócenie poprzedniej + } + } +}; + +TDynamicObject* __fastcall TDynamicObject::ControlledFind() +{//taka proteza: chcę podłączyć kabinę EN57 bezpośrednio z silnikowym, aby nie robić tego przez ukrotnienie + //drugi silnikowy i tak musi być ukrotniony, podobnie jak kolejna jednostka + //lepiej by było przesyłać komendy sterowania, co jednak wymaga przebudowy transmisji komend (LD) + //problem się robi ze światłami, które będą zapalane w silnikowym, ale muszą świecić się w rozrządczych + //dla EZT światłą czołowe będą "zapalane w silnikowym", ale widziane z rozrządczych + //również wczytywanie MMD powinno dotyczyć aktualnego członu + //problematyczna może być kwestia wybranej kabiny (w silnikowym...) + //jeśli silnikowy będzie zapięty odwrotnie (tzn. -1), to i tak powinno jeździć dobrze + //również hamowanie wykonuje się zaworem w członie, a nie w silnikowym... + TDynamicObject *d=this; //zaczynamy od aktualnego + if (d->MoverParameters->TrainType&dt_EZT) //na razie dotyczy to EZT + if (d->NextConnected?d->MoverParameters->Couplers[1].AllowedFlag&ctrain_depot:false) + {//gdy jest człon od sprzęgu 1, a sprzęg łączony warsztatowo (powiedzmy) + if ((d->MoverParameters->Power<1.0)&&(d->NextConnected->MoverParameters->Power>1.0)) //my nie mamy mocy, ale ten drugi ma + d=d->NextConnected; //będziemy sterować tym z mocą + } + else if (d->PrevConnected?d->MoverParameters->Couplers[0].AllowedFlag&ctrain_depot:false) + {//gdy jest człon od sprzęgu 0, a sprzęg łączony warsztatowo (powiedzmy) + if ((d->MoverParameters->Power<1.0)&&(d->PrevConnected->MoverParameters->Power>1.0)) //my nie mamy mocy, ale ten drugi ma + d=d->PrevConnected; //będziemy sterować tym z mocą + } + return d; +}; +//--------------------------------------------------------------------------- + +void __fastcall TDynamicObject::ParamSet(int what,int into) +{//ustawienie lokalnego parametru (what) na stan (into) + switch (what&0xFF00) + { + case 0x0100: //to np. są drzwi, bity 0..7 określają numer 1..254 albo maskę dla 8 różnych + if (what&1) //na razie mamy lewe oraz prawe, czyli używamy maskę 1=lewe, 2=prawe, 3=wszystkie + if (MoverParameters->DoorLeftOpened) + {//są otwarte + if (!into) //jeśli zamykanie + { + //dźwięk zamykania + } + } + else + {//są zamknięte + if (into) //jeśli otwieranie + { + //dźwięk otwierania + } + } + if (what&2) //prawe działają niezależnie od lewych + if (MoverParameters->DoorRightOpened) + {//są otwarte + if (!into) //jeśli zamykanie + { + //dźwięk zamykania + } + } + else + {//są zamknięte + if (into) //jeśli otwieranie + { + //dźwięk otwierania + } + } + break; + } +}; + +int __fastcall TDynamicObject::RouteWish(TTrack *tr) +{//zapytanie do AI, po którym segmencie (-6..6) jechać na skrzyżowaniu (tr) + return Mechanik?Mechanik->CrossRoute(tr):0; //wg AI albo prosto +}; + +AnsiString __fastcall TDynamicObject::TextureTest(AnsiString &name) +{//Ra 2015-01: sprawdzenie dostępności tekstury o podanej nazwie + AnsiString x=name+".dds"; //na razie prymitywnie + if (FileExists(x)) + return x; + else + {x=name+".tga"; //w zasadzie to należałoby uwzględnić deklarowaną kolejność + if (FileExists(x)) + return x; + else + {x=name+".bmp"; + if (FileExists(x)) + return x; + } + } + return ""; //nie znaleziona +}; + +void __fastcall TDynamicObject::DestinationSet(AnsiString to) +{//ustawienie stacji docelowej oraz wymiennej tekstury 4, jeśli istnieje plik + //w zasadzie, to każdy wagon mógłby mieć inną stację docelową + //zwłaszcza w towarowych, pod kątem zautomatyzowania maewrów albo pracy górki + //ale to jeszcze potrwa, zanim będzie możliwe, na razie można wpisać stację z rozkładu + if (abs(iMultiTex)>=4) return; //jak są 4 tekstury wymienne, to nie zmieniać rozkładem + asDestination=to; + to=Global::Bezogonkow(to); //do szukania pliku obcinamy ogonki + AnsiString x; + if (to.IsEmpty()) to="nowhere"; + x=TextureTest(asBaseDir+to+"@"+MoverParameters->TypeName); //w pierwszej kolejności z nazwą FIZ/MMD + if (!x.IsEmpty()) + { + ReplacableSkinID[4]=TTexturesManager::GetTextureID(NULL,NULL,x.c_str(),9); //rozmywania 0,1,4,5 nie nadają się + return; + } + x=TextureTest(asBaseDir+to); //na razie prymitywnie + if (!x.IsEmpty()) + ReplacableSkinID[4]=TTexturesManager::GetTextureID(NULL,NULL,x.c_str(),9); //rozmywania 0,1,4,5 nie nadają się + else + ReplacableSkinID[4]=0; //0 to brak? -1 odpada, bo inaczej się będzie mapować + //Ra 2015-01: żeby zalogować błąd, trzeba by mieć pewność, że model używa tekstury nr 4 +}; + +void __fastcall TDynamicObject::OverheadTrack(float o) +{//ewentualne wymuszanie jazdy bezprądowej z powodu informacji w torze + if (ctOwner) //jeśli ma obiekt nadzorujący + {//trzeba zaktualizować mapę flag bitowych jazdy bezprądowej + if (o<0.0) + {//normalna jazda po tym torze + ctOwner->iOverheadZero&=~iOverheadMask; //zerowanie bitu - może pobierać prąd + ctOwner->iOverheadDown&=~iOverheadMask; //zerowanie bitu - może podnieść pantograf + } + else if (o>0.0) + {//opuszczenie pantografów + ctOwner->iOverheadZero|=iOverheadMask; //ustawienie bitu - ma jechać bez pobierania prądu + ctOwner->iOverheadDown|=iOverheadMask; //ustawienie bitu - ma opuścić pantograf + } + else + {//jazda bezprądowa z podniesionym pantografem + ctOwner->iOverheadZero|=iOverheadMask; //ustawienie bitu - ma jechać bez pobierania prądu + ctOwner->iOverheadDown&=~iOverheadMask; //zerowanie bitu - może podnieść pantograf + } + } +}; + diff --git a/DynObj.h b/DynObj.h new file mode 100644 index 00000000..87096d59 --- /dev/null +++ b/DynObj.h @@ -0,0 +1,440 @@ +//--------------------------------------------------------------------------- + +#ifndef DynObjH +#define DynObjH + +#include "Classes.h" +#include "TrkFoll.h" +#include "QueryParserComp.hpp" +#include "Mover.h" +#include "TractionPower.h" +//McZapkie: +#include "MdlMngr.h" +#include "RealSound.h" +#include "AdvSound.h" +#include "Button.h" +#include "AirCoupler.h" +//--------------------------------------------------------------------------- +//--------------------------------------------------------------------------- +//--------------------------------------------------------------------------- +const ANIM_TYPES=7; //Ra: ilość typów animacji +const ANIM_WHEELS =0; //koła +const ANIM_DOORS =1; //drzwi +const ANIM_LEVERS =2; //elementy obracane (wycieraczki, koła skrętne, przestawiacze, klocki ham.) +const ANIM_BUFFERS=3; //elementy przesuwane (zderzaki) +const ANIM_BOOGIES=4; //wózki (są skręcane w dwóch osiach) +const ANIM_PANTS =5; //pantografy +const ANIM_STEAMS =6; //napęd parowozu + +class TAnim; +typedef void (__closure *TUpdate)(TAnim *pAnim); //typ funkcji aktualizującej położenie submodeli + +//McZapkie-250202 +const MaxAxles=16; //ABu 280105: zmienione z 8 na 16 +//const MaxAnimatedAxles=16; //i to tez. +//const MaxAnimatedDoors=16; //NBMX wrzesien 2003 +/* +Ra: Utworzyć klasę wyposażenia opcjonalnego, z której będą dziedziczyć klasy drzwi, +pantografów, napędu parowozu i innych ruchomych części pojazdów. Klasy powinny być +pseudo-wirtualne, bo wirtualne mogą obniżać wydajnosść. +Przy wczytywaniu MMD utworzyć tabelę wskaźnikow na te dodatki. Przy wyświetlaniu +pojazdu wykonywać Update() na kolejnych obiektach wyposażenia. +Rozważyć użycie oddzielnych modeli dla niektórych pojazdów (np. lokomotywy), co +zaoszczędziło by czas ustawiania animacji na modelu wspólnym dla kilku pojazdów, +szczególnie dla pojazdów w danej chwili nieruchomych (przy dużym zagęszczeniu +modeli na stacjach na ogół przewaga jest tych nieruchomych). +*/ +class TAnimValveGear +{//współczynniki do animacji parowozu (wartości przykładowe dla Pt47) + int iValues; //ilość liczb (wersja): + float fKorbowodR; //długość korby (pół skoku tłoka) [m]: 0.35 + float fKorbowodL; //długość korbowodu [m]: 3.8 + float fDrazekR; //promień mimośrodu (drążka) [m]: 0.18 + float fDrazekL; //dł. drążka mimośrodowego [m]: 2.55889 + float fJarzmoV; //wysokość w pionie osi jarzma od osi koła [m]: 0.751 + float fJarzmoH; //odległość w poziomie osi jarzma od osi koła [m]: 2.550 + float fJarzmoR; //promień jarzma do styku z drążkiem [m]: 0.450 + float fJarzmoA; //kąt mimośrodu względem kąta koła [°]: -96.77416667 + float fWdzidloL; //długość wodzidła [m]: 2.0 + float fWahaczH; //długość wahacza (góra) [m]: 0.14 + float fSuwakH; //wysokość osi suwaka ponad osią koła [m]: 0.62 + float fWahaczL; //długość wahacza (dół) [m]: 0.84 + float fLacznikL; //długość łącznika wahacza [m]: 0.75072 + float fRamieL; //odległość ramienia krzyżulca od osi koła [m]: 0.192 + float fSuwakL; //odległość środka tłoka/suwaka od osi koła [m]: 5.650 +//dołożyć parametry drążka nastawnicy +//albo nawet zrobić dynamiczną tablicę float[] i w nią pakować wszelkie współczynniki, potem używać indeksów +//współczynniki mogą być wspólne dla 2-4 tłoków, albo każdy tłok może mieć odrębne +}; + +class TAnimPant +{//współczynniki do animacji pantografu +public: + vector3 vPos; //Ra: współrzędne punktu zerowego pantografu (X dodatnie dla przedniego) + double fLenL1; //długość dolnego ramienia 1, odczytana z modelu + double fLenU1; //długość górnego ramienia 1, odczytana z modelu + double fLenL2; //długość dolnego ramienia 2, odczytana z modelu + double fLenU2; //długość górnego ramienia 2, odczytana z modelu + double fHoriz; //przesunięcie ślizgu w długości pojazdu względem osi obrotu dolnego ramienia + double fHeight; //wysokość ślizgu ponad oś obrotu, odejmowana od wysokości drutu + double fWidth; //połowa szerokości roboczej ślizgu, do wykrycia ześlizgnięcia się drutu + double fAngleL0; //Ra: początkowy kąt dolnego ramienia (odejmowany przy animacji) + double fAngleU0; //Ra: początkowy kąt górnego ramienia (odejmowany przy animacji) + double PantTraction; //Winger 170204: wysokość drutu ponad punktem na wysokości vPos.y p.g.s. + double PantWys; //Ra: aktualna wysokość uniesienia ślizgu do porównania z wysokością drutu + double fAngleL; //Winger 160204: aktualny kąt ramienia dolnego + double fAngleU; //Ra: aktualny kąt ramienia górnego + double NoVoltTime; //czas od utraty kontaktu z drutem + TTraction *hvPowerWire; //aktualnie podczepione druty, na razie tu + float fWidthExtra; //dodatkowy rozmiar poziomy poza część roboczą (fWidth) + float fHeightExtra[5]; //łamana symulująca kształt nabieżnika + //double fHorizontal; //Ra 2015-01: położenie drutu względem osi pantografu + void __fastcall AKP_4E(); +}; + +class TAnim +{//klasa animowanej części pojazdu (koła, drzwi, pantografy, burty, napęd parowozu, siłowniki itd.) +public: + union + { + TSubModel *smAnimated; //animowany submodel (jeśli tylko jeden, np. oś) + TSubModel **smElement; //jeśli animowanych elementów jest więcej (pantograf, napęd parowozu) + int iShift; //przesunięcie przed przydzieleniem wskaźnika + }; + union + {//parametry animacji + TAnimValveGear *pValveGear; //współczynniki do animacji parowozu + double *dWheelAngle; //wskaźnik na kąt obrotu osi + float *fParam; //różne parametry dla animacji + TAnimPant *fParamPants; //różne parametry dla animacji + }; + union + {//wskaźnik na obiekt odniesienia + double *fDoubleBase; //jakiś double w fizyce + float *fFloatBase; //jakiś float w fizyce + int *iIntBase; //jakiś int w fizyce + }; + //void _fastcall Update(); //wskaźnik do funkcji aktualizacji animacji + int iFlags; //flagi animacji + float fMaxDist; //do jakiej odległości wykonywana jest animacja + float fSpeed; //parametr szybkości animacji + int iNumber; //numer kolejny obiektu +public: + __fastcall TAnim(); + __fastcall ~TAnim(); + TUpdate yUpdate; //metoda TDynamicObject aktualizująca animację + int __fastcall TypeSet(int i,int fl=0); //ustawienie typu + void __fastcall Parovoz(); //wykonanie obliczeń animacji +}; + +//--------------------------------------------------------------------------- +//--------------------------------------------------------------------------- +//--------------------------------------------------------------------------- + +class TDynamicObject +{//klasa pojazdu +private: //położenie pojazdu w świecie oraz parametry ruchu + vector3 vPosition; //Ra: pozycja pojazdu liczona zaraz po przesunięciu + vector3 vCoulpler[2]; //współrzędne sprzęgów do liczenia zderzeń czołowych + vector3 vUp,vFront,vLeft; //wektory jednostkowe ustawienia pojazdu + int iDirection; //kierunek pojazdu względem czoła składu (1=zgodny,0=przeciwny) + TTrackShape ts; //parametry toru przekazywane do fizyki + TTrackParam tp; //parametry toru przekazywane do fizyki + TTrackFollower Axle0; //oś z przodu (od sprzęgu 0) + TTrackFollower Axle1; //oś z tyłu (od sprzęgu 1) + int iAxleFirst; //numer pierwszej osi w kierunku ruchu (oś wiążąca pojazd z torem i wyzwalająca eventy) + float fAxleDist; //rozstaw wózków albo osi do liczenia proporcji zacienienia + vector3 modelRot; //obrot pudła względem świata - do przeanalizowania, czy potrzebne!!! + //bool bCameraNear; //blisko kamer są potrzebne dodatkowe obliczenia szczegółów + TDynamicObject* __fastcall ABuFindNearestObject(TTrack *Track,TDynamicObject *MyPointer,int &CouplNr); +public: //parametry położenia pojazdu dostępne publicznie + AnsiString asTrack; //nazwa toru początkowego; wywalić? + AnsiString asDestination; //dokąd pojazd ma być kierowany "(stacja):(tor)" + matrix4x4 mMatrix; //macierz przekształcenia do renderowania modeli + TMoverParameters *MoverParameters; //parametry fizyki ruchu oraz przeliczanie + //TMoverParameters *pControlled; //wskaźnik do sterowanego członu silnikowego + TDynamicObject *NextConnected; //pojazd podłączony od strony sprzęgu 1 (kabina -1) + TDynamicObject *PrevConnected; //pojazd podłączony od strony sprzęgu 0 (kabina 1) + int NextConnectedNo; //numer sprzęgu podłączonego z tyłu + int PrevConnectedNo; //numer sprzęgu podłączonego z przodu + double fScanDist; //odległość skanowania torów na obecność innych pojazdów + +public: //modele składowe pojazdu + TModel3d *mdModel; //model pudła + TModel3d *mdLoad; //model zmiennego ładunku + TModel3d *mdPrzedsionek; //model przedsionków dla EZT - może użyć mdLoad zamiast? + TModel3d *mdKabina; //model kabiny dla użytkownika; McZapkie-030303: to z train.h + TModel3d *mdLowPolyInt; //ABu 010305: wnetrze lowpoly + float fShade; //zacienienie: 0:normalnie, -1:w ciemności, +1:dodatkowe światło (brak koloru?) + +private: //zmienne i metody do animacji submodeli; Ra: sprzatam animacje w pojeździe +public: //tymczasowo udostępnione do wyszukiwania drutu + int iAnimType[ANIM_TYPES]; //0-osie,1-drzwi,2-obracane,3-zderzaki,4-wózki,5-pantografy,6-tłoki +private: + int iAnimations; //liczba obiektów animujących + TAnim *pAnimations; //obiekty animujące (zawierają wskaźnik do funkcji wykonującej animację) + TSubModel **pAnimated; //lista animowanych submodeli (może być ich więcej niż obiektów animujących) + double dWheelAngle[3]; //kąty obrotu kół: 0=przednie toczne, 1=napędzające i wiązary, 2=tylne toczne + void UpdateNone(TAnim *pAnim) {}; //animacja pusta (funkcje ustawiania submodeli, gdy blisko kamery) + void UpdateAxle(TAnim *pAnim); //animacja osi + void UpdateBoogie(TAnim *pAnim); //animacja wózka + void UpdateDoorTranslate(TAnim *pAnim); //animacja drzwi - przesuw + void UpdateDoorRotate(TAnim *pAnim); //animacja drzwi - obrót + void UpdateDoorFold(TAnim *pAnim); //animacja drzwi - składanie + void UpdatePant(TAnim *pAnim); //animacja pantografu + void UpdateLeverDouble(TAnim *pAnim); //animacja gałki zależna od double + void UpdateLeverFloat(TAnim *pAnim); //animacja gałki zależna od float + void UpdateLeverInt(TAnim *pAnim); //animacja gałki zależna od int (wartość) + void UpdateLeverEnum(TAnim *pAnim); //animacja gałki zależna od int (lista kątów) +private: //Ra: ciąg dalszy animacji, dopiero do ogarnięcia + //ABuWozki 060504 + vector3 bogieRot[2]; //Obroty wozkow w/m korpusu + TSubModel *smBogie[2]; //Wyszukiwanie max 2 wozkow + TSubModel *smWahacze[4]; //wahacze (np. nogi, dźwignia w drezynie) + TSubModel *smBrakeMode; //Ra 15-01: nastawa hamulca też + TSubModel *smLoadMode; //Ra 15-01: nastawa próżny/ładowny + double fWahaczeAmp; + //Winger 160204 - pantografy + double pantspeedfactor; + //animacje typu przesuw + TSubModel *smBuforLewy[2]; + TSubModel *smBuforPrawy[2]; + TAnimValveGear *pValveGear; + vector3 vFloor; //podłoga dla ładunku +public: + TAnim *pants; //indeks obiektu animującego dla pantografu 0 + double NoVoltTime; //czas od utraty zasilania + double dDoorMoveL; //NBMX + double dDoorMoveR; //NBMX + TSubModel *smBrakeSet; //nastawa hamulca (wajcha) + TSubModel *smLoadSet; //nastawa ładunku (wajcha) + TSubModel *smWiper; //wycieraczka (poniekąd też wajcha) +//Ra: koneic animacji do ogarnięcia + +private: + void ABuLittleUpdate(double ObjSqrDist); + bool btnOn; //ABu: czy byly uzywane buttony, jesli tak, to po renderingu wylacz + //bo ten sam model moze byc jeszcze wykorzystany przez inny obiekt! + double __fastcall ComputeRadius(vector3 p1,vector3 p2,vector3 p3,vector3 p4); + + TButton btCoupler1; //sprzegi + TButton btCoupler2; + TAirCoupler btCPneumatic1; //sprzegi powietrzne //yB - zmienione z Button na AirCoupler - krzyzyki + TAirCoupler btCPneumatic2; + TAirCoupler btCPneumatic1r; //ABu: to zeby nie bylo problemow przy laczeniu wagonow, + TAirCoupler btCPneumatic2r; // jesli beda polaczone sprzegami 1<->1 lub 0<->0 + TAirCoupler btPneumatic1; //ABu: sprzegi powietrzne zolte + TAirCoupler btPneumatic2; + TAirCoupler btPneumatic1r; //ABu: analogicznie jak 4 linijki wyzej + TAirCoupler btPneumatic2r; + + TButton btCCtrl1; //sprzegi sterowania + TButton btCCtrl2; + TButton btCPass1; //mostki przejsciowe + TButton btCPass2; + char cp1, sp1, cp2, sp2; //ustawienia węży + + TButton btEndSignals11; //sygnalu konca pociagu + TButton btEndSignals13; + TButton btEndSignals21; + TButton btEndSignals23; + TButton btEndSignals1; //zeby bylo kompatybilne ze starymi modelami... + TButton btEndSignals2; + TButton btEndSignalsTab1; //sygnaly konca pociagu (blachy) + TButton btEndSignalsTab2; + TButton btHeadSignals11; //oswietlenie czolowe - przod + TButton btHeadSignals12; + TButton btHeadSignals13; + TButton btHeadSignals21; //oswietlenie czolowe - tyl + TButton btHeadSignals22; + TButton btHeadSignals23; + TSubModel *smMechanik0; //Ra: mechanik wbudowany w model jako submodel? + TSubModel *smMechanik1; //mechanik od strony sprzęgu 1 + double enginevolume; //MC: pomocnicze zeby gladziej silnik buczal + + int iAxles; //McZapkie: to potem mozna skasowac i zastapic iNumAxles + double dRailLength; + double dRailPosition[MaxAxles]; //licznik pozycji osi w/m szyny + double dWheelsPosition[MaxAxles]; //pozycja osi w/m srodka pojazdu + TRealSound rsStukot[MaxAxles]; //dzwieki poszczegolnych osi //McZapkie-270202 + TRealSound rsSilnik; //McZapkie-010302 - silnik + TRealSound rsWentylator; //McZapkie-030302 + TRealSound rsPisk; //McZapkie-260302 + TRealSound rsDerailment; //McZapkie-051202 + TRealSound rsPrzekladnia; + TAdvancedSound sHorn1; + TAdvancedSound sHorn2; + TAdvancedSound sCompressor; //NBMX wrzesien 2003 + TAdvancedSound sConverter; + TAdvancedSound sSmallCompressor; + TAdvancedSound sDepartureSignal; + TAdvancedSound sTurbo; + +//Winger 010304 +// TRealSound rsPanTup; //PSound sPantUp; + TRealSound sPantUp; + TRealSound sPantDown; + TRealSound rsDoorOpen; //Ra: przeniesione z kabiny + TRealSound rsDoorClose; + + double eng_vol_act; + double eng_frq_act; + double eng_dfrq; + double eng_turbo; + void __fastcall ABuBogies(); + void __fastcall ABuModelRoll(); + vector3 modelShake; + + bool renderme; //yB - czy renderowac + //TRealSound sBrakeAcc; //dźwięk przyspieszacza + PSound sBrakeAcc; + bool bBrakeAcc; + TRealSound rsUnbrake; //yB - odglos luzowania + float ModCamRot; + int iInventory; //flagi bitowe posiadanych submodeli (np. świateł) + void __fastcall TurnOff(); +public: + int iHornWarning; //numer syreny do użycia po otrzymaniu sygnału do jazdy + bool bEnabled; //Ra: wyjechał na portal i ma być usunięty +protected: + + //TTrackFollower Axle2; //dwie osie z czterech (te są protected) + //TTrackFollower Axle3; //Ra: wyłączyłem, bo kąty są liczone w Segment.cpp + int iNumAxles; //ilość osi + int CouplCounter; + AnsiString asModel; +public: + void ABuScanObjects(int ScanDir,double ScanDist); +protected: + TDynamicObject* __fastcall ABuFindObject(TTrack *Track,int ScanDir,Byte &CouplFound,double &dist); + void __fastcall ABuCheckMyTrack(); + +public: + int *iLights; //wskaźnik na bity zapalonych świateł (własne albo innego członu) + double fTrackBlock; //odległość do przeszkody do dalszego ruchu (wykrywanie kolizji z innym pojazdem) + TDynamicObject* __fastcall PrevAny(); + TDynamicObject* __fastcall Prev(); + TDynamicObject* __fastcall Next(); + TDynamicObject* __fastcall NextC(int C); + double __fastcall NextDistance(double d=-1.0); + void __fastcall SetdMoveLen(double dMoveLen) {MoverParameters->dMoveLen=dMoveLen;} + void __fastcall ResetdMoveLen() {MoverParameters->dMoveLen=0;} + double __fastcall GetdMoveLen() {return MoverParameters->dMoveLen;} + + int __fastcall GetPneumatic(bool front, bool red); + void __fastcall SetPneumatic(bool front, bool red); + AnsiString asName; + AnsiString __fastcall GetName() + { + return this?asName:AnsiString(""); + }; + + TRealSound rsDiesielInc; //youBy + TRealSound rscurve; //youBy +// std::ofstream PneuLogFile; //zapis parametrow pneumatycznych +//youBy - dym + //TSmoke Smog; + //float EmR; + //vector3 smokeoffset; + + TDynamicObject* __fastcall ABuScanNearestObject(TTrack *Track, double ScanDir, double ScanDist, int &CouplNr); + TDynamicObject* __fastcall GetFirstDynamic(int cpl_type); + //TDynamicObject* __fastcall GetFirstCabDynamic(int cpl_type); + void ABuSetModelShake(vector3 mShake); + + +//McZapkie-010302 + TController *Mechanik; + TController *ctOwner; //wskażnik na obiekt zarządzający składem + bool MechInside; +//McZapkie-270202 + bool Controller; + bool bDisplayCab; //czy wyswietlac kabine w train.cpp + int iCabs; //maski bitowe modeli kabin + TTrack *MyTrack; //McZapkie-030303: tor na ktorym stoi, ABu + AnsiString asBaseDir; + GLuint ReplacableSkinID[5]; //McZapkie:zmienialne nadwozie + int iAlpha; //maska przezroczystości tekstur + int iMultiTex; //<0 tekstury wskazane wpisem, >0 tekstury z przecinkami, =0 jedna + int iOverheadMask; //maska przydzielana przez AI pojazdom posiadającym pantograf, aby wymuszały jazdę bezprądową + TTractionParam tmpTraction; + double fAdjustment; //korekcja - docelowo przenieść do TrkFoll.cpp wraz z odległością od poprzedniego + __fastcall TDynamicObject(); + __fastcall ~TDynamicObject(); + double __fastcall TDynamicObject::Init + (//zwraca długość pojazdu albo 0, jeśli błąd + AnsiString Name, AnsiString BaseDir, AnsiString asReplacableSkin, AnsiString Type_Name, + TTrack *Track, double fDist, AnsiString DriverType, double fVel, AnsiString TrainName, + float Load, AnsiString LoadType,bool Reversed, AnsiString + ); + void __fastcall AttachPrev(TDynamicObject *Object, int iType= 1); + bool __fastcall UpdateForce(double dt, double dt1, bool FullVer); + void __fastcall LoadUpdate(); + bool __fastcall Update(double dt, double dt1); + bool __fastcall FastUpdate(double dt); + void __fastcall Move(double fDistance); + void __fastcall FastMove(double fDistance); + void __fastcall Render(); + void __fastcall RenderAlpha(); + void __fastcall RenderSounds(); + inline vector3 __fastcall GetPosition() {return vPosition;}; + inline vector3 __fastcall HeadPosition() {return vCoulpler[iDirection^1];}; //pobranie współrzędnych czoła + inline vector3 __fastcall RearPosition() {return vCoulpler[iDirection];}; //pobranie współrzędnych tyłu + inline vector3 __fastcall AxlePositionGet() {return iAxleFirst?Axle1.pPosition:Axle0.pPosition;}; + inline vector3 __fastcall VectorFront() {return vFront;}; + inline vector3 __fastcall VectorUp() {return vUp;}; + inline vector3 __fastcall VectorLeft() {return vLeft;}; + inline double* __fastcall Matrix() {return mMatrix.getArray();}; + inline double __fastcall GetVelocity() { return MoverParameters->Vel; }; + inline double __fastcall GetLength() { return MoverParameters->Dim.L; }; + inline double __fastcall GetWidth() { return MoverParameters->Dim.W; }; + inline TTrack* __fastcall GetTrack() { return (iAxleFirst?Axle1.GetTrack():Axle0.GetTrack()); }; + //void __fastcall UpdatePos(); + + + //McZapkie-260202 + void __fastcall LoadMMediaFile(AnsiString BaseDir, AnsiString TypeName, AnsiString ReplacableSkin); + + inline double __fastcall ABuGetDirection() //ABu. + { + return (Axle1.GetTrack()==MyTrack?Axle1.GetDirection():Axle0.GetDirection()); + }; +// inline double __fastcall ABuGetTranslation() //ABu. +// {//zwraca przesunięcie wózka względem Point1 toru +// return (Axle1.GetTrack()==MyTrack?Axle1.GetTranslation():Axle0.GetTranslation()); +// }; + inline double __fastcall RaDirectionGet() + {//zwraca kierunek pojazdu na torze z aktywną osą + return iAxleFirst?Axle1.GetDirection():Axle0.GetDirection(); + }; + inline double __fastcall RaTranslationGet() + {//zwraca przesunięcie wózka względem Point1 toru z aktywną osią + return iAxleFirst?Axle1.GetTranslation():Axle0.GetTranslation(); + }; + inline TTrack* __fastcall RaTrackGet() + {//zwraca tor z aktywną osią + return iAxleFirst?Axle1.GetTrack():Axle0.GetTrack(); + }; + void CouplersDettach(double MinDist,int MyScanDir); + void __fastcall RadioStop(); + void __fastcall RaLightsSet(int head,int rear); + //void __fastcall RaAxleEvent(TEvent *e); + TDynamicObject* __fastcall FirstFind(int &coupler_nr); + float __fastcall GetEPP(); //wyliczanie sredniego cisnienia w PG + int __fastcall DirectionSet(int d); //ustawienie kierunku w składzie + int __fastcall DirectionGet() {return iDirection+iDirection-1;}; //odczyt kierunku w składzie + int DettachStatus(int dir); + int Dettach(int dir); + TDynamicObject* __fastcall Neightbour(int &dir); + void __fastcall CoupleDist(); + TDynamicObject* __fastcall ControlledFind(); + void __fastcall ParamSet(int what,int into); + int __fastcall RouteWish(TTrack *tr); //zapytanie do AI, po którym segmencie skrzyżowania jechać + void __fastcall DestinationSet(AnsiString to); + AnsiString __fastcall TextureTest(AnsiString &name); + void __fastcall OverheadTrack(float o); +}; + + +//--------------------------------------------------------------------------- +#endif diff --git a/EU07.bpr b/EU07.bpr new file mode 100644 index 00000000..2be34889 --- /dev/null +++ b/EU07.bpr @@ -0,0 +1,137 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +[Version Info] +IncludeVerInfo=1 +AutoIncBuild=0 +MajorVer=15 +MinorVer=3 +Release=1166 +Build=469 +Debug=1 +PreRelease=0 +Special=0 +Private=0 +DLL=0 +Locale=1045 +CodePage=1250 + +[Version Info Keys] +CompanyName=EU07 Team +FileDescription=MaSzyna EU07-424 +FileVersion=15.3.1166.469 +InternalName=9th by Ra + SPKS + MP +LegalCopyright= +LegalTrademarks= +OriginalFilename=eu07.exe +ProductName=MaSzyna EU07-424 +ProductVersion=15.3 +Comments= + +[HistoryLists\hlIncludePath] +Count=1 +Item0=Console;opengl;McZapkie;$(BCB)\include;$(BCB)\include\vcl + +[HistoryLists\hlLibraryPath] +Count=1 +Item0=Console;opengl;McZapkie;$(BCB)\lib\obj;$(BCB)\lib + +[HistoryLists\hlDebugSourcePath] +Count=2 +Item0=McZapkie\ +Item1=$(BCB)\source\vcl + +[HistoryLists\hlConditionals] +Count=8 +Item0=GLEW_STATIC;_DEBUG +Item1=GLEW_STATIC;_DEBUG;USE_VBO +Item2=GLEW_STATIC;_DEBUG;_USE_OLD_RW_STL +Item3=GLEW_STATIC +Item4=GLEW_STATIC;USE_VERTEX_ARRAYS;_DEBUG +Item5=GLEW_STATIC;USE_VERTEX_ARRAYS +Item6=GLEW_STATIC;_DEBUG;USE_VERTEX_ARRAYS +Item7=_DEBUG + +[HistoryLists\hlFinalOutputDir] +Count=2 +Item0=D:\EU07\ +Item1=E:\EU07\ + +[Debugging] +DebugSourceDirs=McZapkie\ + +[Parameters] +RunParams= +HostApplication= +RemoteHost= +RemotePath= +RemoteDebug=0 + +[Compiler] +ShowInfoMsgs=0 +LinkDebugVcl=0 +LinkCGLIB=0 + +[CORBA] +AddServerUnit=1 +AddClientUnit=1 +PrecompiledHeaders=1 + +[Language] +ActiveLang= +ProjectLang= +RootDir= + + \ No newline at end of file diff --git a/EU07.cpp b/EU07.cpp new file mode 100644 index 00000000..7655e990 --- /dev/null +++ b/EU07.cpp @@ -0,0 +1,725 @@ +//--------------------------------------------------------------------------- +/* + MaSzyna EU07 locomotive simulator + Copyright (C) 2001-2004 Marcin Wozniak, Maciej Czapkiewicz and others + +*/ + +#include "opengl/glew.h" +#include "opengl/glut.h" +#include "opengl/ARB_Multisample.h" + +#include "system.hpp" +#include "classes.hpp" +#include "Globals.h" +#include "Console.h" +#include "QueryParserComp.hpp" +#include "Mover.h" +#include "Logs.h" +#pragma hdrstop + +#include //_clear87() itp. + +USERES("EU07.res"); +USEUNIT("dumb3d.cpp"); +USEUNIT("Camera.cpp"); +USEUNIT("Texture.cpp"); +USEUNIT("World.cpp"); +USELIB("opengl\glut32.lib"); +USEUNIT("Model3d.cpp"); +USEUNIT("MdlMngr.cpp"); +USEUNIT("Train.cpp"); +USEUNIT("wavread.cpp"); +USEUNIT("Timer.cpp"); +USEUNIT("Event.cpp"); +USEUNIT("MemCell.cpp"); +USEUNIT("Logs.cpp"); +USELIB("DirectX\Dsound.lib"); +USEUNIT("Spring.cpp"); +USEUNIT("Button.cpp"); +USEUNIT("Globals.cpp"); +USEUNIT("Gauge.cpp"); +USEUNIT("AnimModel.cpp"); +USEUNIT("Ground.cpp"); +USEUNIT("TrkFoll.cpp"); +USEUNIT("Segment.cpp"); +USEUNIT("Sound.cpp"); +USEUNIT("AdvSound.cpp"); +USEUNIT("Track.cpp"); +USEUNIT("DynObj.cpp"); +USEUNIT("RealSound.cpp"); +USEUNIT("EvLaunch.cpp"); +USEUNIT("QueryParserComp.pas"); +USEUNIT("FadeSound.cpp"); +USEUNIT("Traction.cpp"); +USEUNIT("TractionPower.cpp"); +USEUNIT("parser.cpp"); +USEUNIT("sky.cpp"); +USEUNIT("AirCoupler.cpp"); +USEUNIT("opengl\glew.c"); +USEUNIT("ResourceManager.cpp"); +USEUNIT("VBO.cpp"); +USEUNIT("McZapkie\mtable.pas"); +USEUNIT("TextureDDS.cpp"); +USEUNIT("opengl\ARB_Multisample.cpp"); +USEUNIT("Float3d.cpp"); +USEUNIT("Classes.cpp"); +USEUNIT("Driver.cpp"); +USEUNIT("Names.cpp"); +USEUNIT("Console.cpp"); +USEUNIT("Mover.cpp"); +USEUNIT("McZapkie\_mover.pas"); +USEUNIT("McZapkie\hamulce.pas"); +USEUNIT("Console\PoKeys55.cpp"); +USEUNIT("Forth.cpp"); +USEUNIT("Console\LPT.cpp"); +//--------------------------------------------------------------------------- +#include "World.h" + +HDC hDC=NULL; // Private GDI Device Context +HGLRC hRC=NULL; // Permanent Rendering Context +HWND hWnd=NULL; // Holds Our Window Handle + +TWorld World; + + +//bool active=TRUE; //window active flag set to TRUE by default +bool fullscreen=TRUE; //fullscreen flag set to fullscreen mode by default +int WindowWidth= 800; +int WindowHeight= 600; +int Bpp= 32; + +LRESULT CALLBACK WndProc(HWND, UINT, WPARAM, LPARAM); // Declaration For WndProc + +//#include "dbgForm.h" +//--------------------------------------------------------------------------- + +int InitGL(GLvoid) // All Setup For OpenGL Goes Here +{ + _clear87(); + _control87(MCW_EM,MCW_EM); + glewInit(); + //hunter-271211: przeniesione + //AllocConsole(); + //SetConsoleTextAttribute(GetStdHandle(STD_OUTPUT_HANDLE),FOREGROUND_GREEN); + + // ShaXbee-121209: Wlaczenie obslugi tablic wierzcholkow + glEnableClientState(GL_VERTEX_ARRAY); + glEnableClientState(GL_NORMAL_ARRAY); + glEnableClientState(GL_TEXTURE_COORD_ARRAY); + Global::pWorld=&World; //Ra: wskaźnik potrzebny do usuwania pojazdów + return World.Init(hWnd,hDC); //true jeśli wszystko pójdzie dobrze +} +//--------------------------------------------------------------------------- + +GLvoid ReSizeGLScene(GLsizei width,GLsizei height) // resize and initialize the GL Window +{ + WindowWidth=width; + WindowHeight=height; + if (height==0) // prevent a divide by zero by + height=1; // making height equal one + glViewport(0,0,width,height); // Reset The Current Viewport + glMatrixMode(GL_PROJECTION); // select the Projection Matrix + glLoadIdentity(); // reset the Projection Matrix + //calculate the aspect ratio of the window + gluPerspective(45.0f,(GLdouble)width/(GLdouble)height,0.2f,2500.0f); + glMatrixMode(GL_MODELVIEW); // select the Modelview Matrix + glLoadIdentity(); // reset the Modelview Matrix +} + +//--------------------------------------------------------------------------- +GLvoid KillGLWindow(GLvoid) // properly kill the window +{ + if (hRC) // Do We Have A Rendering Context? + { + if (!wglMakeCurrent(NULL,NULL)) // are we able to release the DC and RC contexts? + { + ErrorLog("Fail: window releasing"); + MessageBox(NULL,"Release of DC and RC failed.","SHUTDOWN ERROR",MB_OK | MB_ICONINFORMATION); + } + + if (!wglDeleteContext(hRC)) // are we able to delete the RC? + { + ErrorLog("Fail: rendering context releasing"); + MessageBox(NULL,"Release rendering context failed.","SHUTDOWN ERROR",MB_OK | MB_ICONINFORMATION); + } + hRC=NULL; // set RC to NULL + } + + if (hDC && !ReleaseDC(hWnd,hDC)) // are we able to release the DC? + { + ErrorLog("Fail: device context releasing"); + MessageBox(NULL,"Release device context failed.","SHUTDOWN ERROR",MB_OK | MB_ICONINFORMATION); + hDC=NULL; // set DC to NULL + } + + if (hWnd && !DestroyWindow(hWnd)) // are we able to destroy the window? + { + ErrorLog("Fail: window destroying"); + MessageBox(NULL,"Could not release hWnd.","SHUTDOWN ERROR",MB_OK | MB_ICONINFORMATION); + hWnd=NULL; // set hWnd to NULL + } + + if (fullscreen) // Are We In Fullscreen Mode? + { + ChangeDisplaySettings(NULL,0); // if so switch back to the desktop + ShowCursor(TRUE); // show mouse pointer + } +// KillFont(); +} + +/* This code creates our OpenGL Window. Parameters are: * + * title - title to appear at the top of the window * + * width - width of the GL Window or fullscreen mode * + * height - height of the GL Window or fullscreen mode * + * bits - number of bits to use for color (8/16/24/32) * + * fullscreenflag - use fullscreen mode (TRUE) or windowed mode (FALSE) */ + +BOOL CreateGLWindow(char* title, int width, int height, int bits, bool fullscreenflag) +{ + GLuint PixelFormat; // holds the results after searching for a match + HINSTANCE hInstance; // holds the instance of the application + WNDCLASS wc; // windows class structure + DWORD dwExStyle; // window extended style + DWORD dwStyle; // window style + RECT WindowRect; // grabs rectangle upper left / lower right values + WindowRect.left=(long)0; // set left value to 0 + WindowRect.right=(long)width; // set right value to requested width + WindowRect.top=(long)0; // set top value to 0 + WindowRect.bottom=(long)height; // set bottom value to requested height + + fullscreen=fullscreenflag; // set the global fullscreen flag + + hInstance =GetModuleHandle(NULL); // grab an instance for our window + wc.style =CS_HREDRAW | CS_VREDRAW | CS_OWNDC; // redraw on size, and own DC for window. + wc.lpfnWndProc =(WNDPROC) WndProc; // wndproc handles messages + wc.cbClsExtra =0; // no extra window data + wc.cbWndExtra =0; // no extra window data + wc.hInstance =hInstance; // set the instance + wc.hIcon =LoadIcon(NULL, IDI_WINLOGO); // load the default icon + wc.hCursor =LoadCursor(NULL, IDC_ARROW); // load the arrow pointer + wc.hbrBackground=NULL; // no background required for GL + wc.lpszMenuName =NULL; // we don't want a menu + wc.lpszClassName="EU07"; //nazwa okna do komunikacji zdalnej // Set The Class Name + + if (!arbMultisampleSupported) //tylko dla pierwszego okna + if (!RegisterClass(&wc)) // Attempt To Register The Window Class + { + ErrorLog("Fail: window class registeration"); + MessageBox(NULL,"Failed to register the window class.","ERROR",MB_OK|MB_ICONEXCLAMATION); + return FALSE; // Return FALSE + } + + if (fullscreen) // Attempt Fullscreen Mode? + { + DEVMODE dmScreenSettings; // device mode + memset(&dmScreenSettings,0,sizeof(dmScreenSettings)); // makes sure memory's cleared + dmScreenSettings.dmSize=sizeof(dmScreenSettings); // size of the devmode structure + + //tolaris-240403: poprawka na odswiezanie monitora + // locate primary monitor... + if (Global::bAdjustScreenFreq) + { + POINT point; point.x=0; point.y=0; + MONITORINFOEX monitorinfo; monitorinfo.cbSize=sizeof(MONITORINFOEX); + ::GetMonitorInfo( ::MonitorFromPoint(point,MONITOR_DEFAULTTOPRIMARY),&monitorinfo); + // ..and query for highest supported refresh rate + unsigned int refreshrate=0; + int i=0; + while (::EnumDisplaySettings(monitorinfo.szDevice,i,&dmScreenSettings)) + { + if (i>0) + if (dmScreenSettings.dmPelsWidth==(unsigned int)width) + if (dmScreenSettings.dmPelsHeight==(unsigned int)height) + if (dmScreenSettings.dmBitsPerPel==(unsigned int)bits) + if (dmScreenSettings.dmDisplayFrequency>refreshrate) + refreshrate=dmScreenSettings.dmDisplayFrequency; + ++i; + } + // fill refresh rate info for screen mode change + dmScreenSettings.dmDisplayFrequency=refreshrate; + dmScreenSettings.dmFields=DM_DISPLAYFREQUENCY; + } + dmScreenSettings.dmPelsWidth =width; // selected screen width + dmScreenSettings.dmPelsHeight=height; // selected screen height + dmScreenSettings.dmBitsPerPel=bits; // selected bits per pixel + dmScreenSettings.dmFields=dmScreenSettings.dmFields|DM_BITSPERPEL|DM_PELSWIDTH|DM_PELSHEIGHT; + + // Try to set selected mode and get results. NOTE: CDS_FULLSCREEN gets rid of start bar. + if (ChangeDisplaySettings(&dmScreenSettings,CDS_FULLSCREEN)!=DISP_CHANGE_SUCCESSFUL) + { + // If the mode fails, offer two options. Quit or use windowed mode. + ErrorLog("Fail: full screen"); + if (MessageBox(NULL,"The requested fullscreen mode is not supported by\nyour video card. Use windowed mode instead?","EU07",MB_YESNO|MB_ICONEXCLAMATION)==IDYES) + { + fullscreen=FALSE; // Windowed Mode Selected. Fullscreen = FALSE + } + else + { + // Pop Up A Message Box Letting User Know The Program Is Closing. + Error("Program will now close."); + return FALSE; // Return FALSE + } + } + } + + if (fullscreen) // Are We Still In Fullscreen Mode? + { + dwExStyle=WS_EX_APPWINDOW; // Window Extended Style + dwStyle=WS_POPUP | WS_CLIPSIBLINGS | WS_CLIPCHILDREN; // Windows Style + ShowCursor(FALSE); // Hide Mouse Pointer + } + else + { + dwExStyle=WS_EX_APPWINDOW | WS_EX_WINDOWEDGE; // Window Extended Style + dwStyle=WS_OVERLAPPEDWINDOW | WS_CLIPSIBLINGS | WS_CLIPCHILDREN; // Windows Style + } + + AdjustWindowRectEx(&WindowRect,dwStyle,FALSE,dwExStyle); // Adjust Window To True Requested Size + + // Create The Window + if (NULL==(hWnd=CreateWindowEx(dwExStyle, // Extended Style For The Window + "EU07", // Class Name + title, // Window Title + dwStyle | // Defined Window Style + WS_CLIPSIBLINGS | // Required Window Style + WS_CLIPCHILDREN, // Required Window Style + 0, 0, // Window Position + WindowRect.right-WindowRect.left, // Calculate Window Width + WindowRect.bottom-WindowRect.top, // Calculate Window Height + NULL, // No Parent Window + NULL, // No Menu + hInstance, // Instance + NULL))) // Dont Pass Anything To WM_CREATE + { + KillGLWindow(); // Reset The Display + ErrorLog("Fail: window creation"); + MessageBox(NULL,"Window creation error.","ERROR",MB_OK|MB_ICONEXCLAMATION); + return FALSE; // Return FALSE + } + + static PIXELFORMATDESCRIPTOR pfd= // pfd Tells Windows How We Want Things To Be + { + sizeof(PIXELFORMATDESCRIPTOR), // Size Of This Pixel Format Descriptor + 1, // Version Number + PFD_DRAW_TO_WINDOW | // Format Must Support Window + PFD_SUPPORT_OPENGL | // Format Must Support OpenGL + PFD_DOUBLEBUFFER, // Must Support Double Buffering + PFD_TYPE_RGBA, // Request An RGBA Format + bits, // Select Our Color Depth + 0, 0, 0, 0, 0, 0, // Color Bits Ignored + 0, // No Alpha Buffer + 0, // Shift Bit Ignored + 0, // No Accumulation Buffer + 0, 0, 0, 0, // Accumulation Bits Ignored + 24, // 32Bit Z-Buffer (Depth Buffer) + 0, // No Stencil Buffer + 0, // No Auxiliary Buffer + PFD_MAIN_PLANE, // Main Drawing Layer + 0, // Reserved + 0, 0, 0 // Layer Masks Ignored + }; + + if (NULL==(hDC=GetDC(hWnd))) // Did We Get A Device Context? + { + KillGLWindow(); // Reset The Display + ErrorLog("Fail: device context"); + MessageBox(NULL,"Can't create a GL device context.","ERROR",MB_OK|MB_ICONEXCLAMATION); + return FALSE; // Return FALSE + } + +/* + Our first pass, Multisampling hasn't been created yet, so we create a window normally + If it is supported, then we're on our second pass + that means we want to use our pixel format for sampling + so set PixelFormat to arbMultiSampleformat instead +*/ + if (!arbMultisampleSupported) + { + if (NULL==(PixelFormat=ChoosePixelFormat(hDC,&pfd))) // Did Windows Find A Matching Pixel Format? + { + KillGLWindow(); // Reset The Display + ErrorLog("Fail: pixelformat"); + MessageBox(NULL,"Can't find a suitable pixelformat.","ERROR",MB_OK|MB_ICONEXCLAMATION); + return FALSE; // Return FALSE + } + } + else + PixelFormat=arbMultisampleFormat; + + if (!SetPixelFormat(hDC,PixelFormat,&pfd)) // Are We Able To Set The Pixel Format? + { + KillGLWindow(); // Reset The Display + ErrorLog("Fail: pixelformat"); + MessageBox(NULL,"Can't set the pixelformat.","ERROR",MB_OK|MB_ICONEXCLAMATION); + return FALSE; // Return FALSE + } + + if (NULL==(hRC=wglCreateContext(hDC))) // Are We Able To Get A Rendering Context? + { + KillGLWindow(); // Reset The Display + ErrorLog("Fail: OpenGL rendering context creation"); + MessageBox(NULL,"Can't create a GL rendering context.","ERROR",MB_OK|MB_ICONEXCLAMATION); + return FALSE; // Return FALSE + } + + if (!wglMakeCurrent(hDC,hRC)) // Try To Activate The Rendering Context + { + KillGLWindow(); // Reset The Display + ErrorLog("Fail: OpenGL rendering context activation"); + MessageBox(NULL,"Can't activate the GL rendering context.","ERROR",MB_OK|MB_ICONEXCLAMATION); + return FALSE; // Return FALSE + } + + /* + Now that our window is created, we want to queary what samples are available + we call our InitMultiSample window + if we return a valid context, we want to destroy our current window + and create a new one using the multisample interface. + */ + if (Global::iMultisampling) + if (!arbMultisampleSupported) + if ((Global::iMultisampling=InitMultisample(hInstance,hWnd,pfd,1<dwData=='EU07') //sygnatura danych + World.OnCommandGet((DaneRozkaz*)(pDane->lpData)); + break; + case WM_ACTIVATE: //watch for window activate message + //case WM_ACTIVATEAPP: + {//Ra: uzależnienie aktywności od bycia na wierzchu + Global::bActive=(LOWORD(wParam)!=WA_INACTIVE); + if (Global::bInactivePause) //jeśli ma być pauzowanie okna w tle + if (Global::bActive) + Global::iPause&=~4; //odpauzowanie, gdy jest na pierwszym planie + else + Global::iPause|=4; //włączenie pauzy, gdy nieaktywy + if (Global::bActive) + SetCursorPos(mx,my); + ShowCursor(!Global::bActive); +/* + if (!HIWORD(wParam)) //check minimization state + active=TRUE; //program is active + else + active=FALSE; //program is no longer active +*/ + return 0; // return to the message loop + } + case WM_SYSCOMMAND: //intercept system commands + { + switch (wParam) //check system calls + { + case 61696: //F10 + World.OnKeyDown(VK_F10); + return 0; + case SC_SCREENSAVE: //screensaver trying to start? + case SC_MONITORPOWER: //monitor trying to enter powersave? + return 0; //prevent from happening + } + break; //exit + } + case WM_CLOSE: // did we receive a close message? + { + PostQuitMessage(0); //send a quit message [Alt]+[F4] + return 0; //jump back + } + case WM_MOUSEMOVE: + { + //mx= 100;//Global::iWindowWidth/2; + //my= 100;//Global::iWindowHeight/2; + //SetCursorPos(Global::iWindowWidth/2,Global::iWindowHeight/2); + //m_x= LOWORD(lParam); + //m_y= HIWORD(lParam); + GetCursorPos(&mouse); + if (Global::bActive && ((mouse.x!=mx) || (mouse.y!=my))) + { + World.OnMouseMove(double(mouse.x-mx)*0.005,double(mouse.y-my)*0.01); + SetCursorPos(mx,my); + } + return 0; // jump back + } + case WM_KEYUP : + if (Global::bActive) + { + World.OnKeyUp(wParam); + return 0; + } + case WM_KEYDOWN : + if (Global::bActive) + { + if (wParam!=17) //bo naciśnięcia [Ctrl] nie ma po co przekazywać + if (wParam!=145) //[Scroll Lock] też nie + World.OnKeyDown(wParam); + switch (wParam) + { + case VK_ESCAPE: //[Esc] pauzuje tylko bez Debugmode + if (DebugModeFlag) break; + case 19: //[Pause] + if (Global::iPause&1) //jeśli pauza startowa + Global::iPause&=~1; //odpauzowanie, gdy po wczytaniu miało nie startować + else if (!(Global::iMultiplayer&2)) //w multiplayerze pauza nie ma sensu + if (!Console::Pressed(VK_CONTROL)) //z [Ctrl] to radiostop jest + //Ra: poniższe nie ma sensu, bo brak komunikacji natychmiast zapauzuje ponownie + //if (Global::iPause&8) //jeśli pauza związana z brakiem komunikacji z PoKeys + // Global::iPause&=~10; //odpauzowanie pauzy PoKeys (chyba nic nie da) i ewentualnie klawiszowej również + //else + Global::iPause^=2; //zmiana stanu zapauzowania + if (Global::iPause) //jak pauza + Global::iTextMode=VK_F1; //to wyświetlić zegar i informację + break; + case VK_F7: + if (DebugModeFlag) + {//siatki wyświetlane tyko w trybie testowym + Global::bWireFrame=!Global::bWireFrame; + ++Global::iReCompile; //odświeżyć siatki + //Ra: jeszcze usunąć siatki ze skompilowanych obiektów! + } + break; + } + } + return 0; // jump back + case WM_CHAR: + { +/* + switch ((TCHAR) wParam) + { + // case 'q': + // done= true; + // KillGLWindow(); + // PostQuitMessage(0); + // DestroyWindow( hWnd ); + // break; + }; +*/ + return 0; + } + case WM_SIZE: //resize the OpenGL window + { + ReSizeGLScene(LOWORD(lParam),HIWORD(lParam)); // LoWord=Width, HiWord=Height + if (GetWindowRect(hWnd,&rect)) + {//Ra: zmiana rozmiaru okna bez przesuwania myszy + //mx=WindowWidth/2+rect.left; // horizontal position + //my=WindowHeight/2+rect.top; // vertical position + //SetCursorPos(mx,my); + } + return 0; //jump back + } + case WM_MOVE: //przesuwanie okna? + { + mx=WindowWidth/2+LOWORD(lParam); // horizontal position + my=WindowHeight/2+HIWORD(lParam); // vertical position + //SetCursorPos(mx,my); + break; + } + case WM_PAINT: + {//odrysowanie okna + break; + } + //case WM_ERASEBKGND: //Process this message to keep Windows from erasing background. + case MM_JOY1BUTTONDOWN: + { + //WriteLog("Joystick button "+AnsiString(wParam)); + break; + } + case WM_CREATE: + /* Capture the joystick. If this fails, beep and display + * error, then quit. + */ + if (joySetCapture(hWnd,JOYSTICKID1,0,FALSE)) + { + //MessageBeep(MB_ICONEXCLAMATION); + //MessageBox(hWnd,"Couldn't capture the joystick",NULL,MB_OK|MB_ICONEXCLAMATION); + //return -1; + } + break; + } + // pass all unhandled messages to DefWindowProc + return DefWindowProc(hWnd,uMsg,wParam,lParam); +}; + + + + +int WINAPI WinMain( HINSTANCE hInstance, //instance + HINSTANCE hPrevInstance, //previous instance + LPSTR lpCmdLine, //command line parameters + int nCmdShow) //window show state +{ + MSG msg; //windows message structure + BOOL done=FALSE; //bool variable to exit loop + fullscreen=true; + DecimalSeparator= '.'; +/* //Ra: tutaj to nie działa - zwraca NULL + //najpierw ustalmy wersję OpenGL + AnsiString glver=((char*)glGetString(GL_VERSION)); + while (glver.LastDelimiter(".")>glver.Pos(".")) + glver=glver.SubString(1,glver.LastDelimiter(".")-1); //obcięcie od drugiej kropki + try {Global::fOpenGL=glver.ToDouble();} catch (...) {Global::fOpenGL=0.0;} + Global::bOpenGL_1_5=(Global::fOpenGL>=1.5); +*/ + DeleteFile("errors.txt"); //usunięcie starego + Global::LoadIniFile("eu07.ini"); //teraz dopiero można przejrzeć plik z ustawieniami + Global::InitKeys("keys.ini"); //wczytanie mapowania klawiszy - jest na stałe + + //hunter-271211: ukrywanie konsoli + if (Global::iWriteLogEnabled&2) + { + AllocConsole(); + SetConsoleTextAttribute(GetStdHandle(STD_OUTPUT_HANDLE),FOREGROUND_GREEN); + } + AnsiString str=lpCmdLine; //parametry uruchomienia + if (!str.IsEmpty()) + {//analizowanie parametrów + TQueryParserComp *Parser; + Parser=new TQueryParserComp(NULL); + Parser->TextToParse=lpCmdLine; + Parser->First(); + while (!Parser->EndOfFile) + { + str=Parser->GetNextSymbol().LowerCase(); + if (str==AnsiString("-s")) + {//nazwa scenerii + str=Parser->GetNextSymbol().LowerCase(); + strcpy(Global::szSceneryFile,str.c_str()); + } + else if (str==AnsiString("-v")) + {//nazwa wybranego pojazdu + str=Parser->GetNextSymbol().LowerCase(); + Global::asHumanCtrlVehicle=str; + } + else if (str==AnsiString("-modifytga")) + {//wykonanie modyfikacji wszystkich plików TGA + Global::iModifyTGA=-1; //specjalny tryb wykonania totalnej modyfikacji + } + else if (str==AnsiString("-e3d")) + {//wygenerowanie wszystkich plików E3D + if (Global::iConvertModels>0) + Global::iConvertModels=-Global::iConvertModels; //specjalny tryb + else + Global::iConvertModels=-7; //z optymalizacją, bananami i prawidłowym Opacity + } + else + Error("Program usage: EU07 [-s sceneryfilepath] [-v vehiclename] [-modifytga] [-e3d]",!Global::iWriteLogEnabled); + } + delete Parser; //ABu 050205: tego wczesniej nie bylo + } +/* MC: usunalem tymczasowo bo sie gryzlo z nowym parserem - 8.6.2003 + AnsiString csp=AnsiString(Global::szSceneryFile); + csp=csp.Delete(csp.Pos(AnsiString(strrchr(Global::szSceneryFile,'/')))+1,csp.Length()); + Global::asCurrentSceneryPath=csp; +*/ + + fullscreen=Global::bFullScreen; + WindowWidth=Global::iWindowWidth; + WindowHeight=Global::iWindowHeight; + Bpp=Global::iBpp; + if (Bpp!=32) Bpp=16; + //create our OpenGL window + if (!CreateGLWindow(Global::asHumanCtrlVehicle.c_str(),WindowWidth,WindowHeight,Bpp,fullscreen)) + return 0; //quit if window was not created + SetForegroundWindow(hWnd); + //McZapkie: proba przeplukania klawiatury + Console *pConsole=new Console(); //Ra: nie wiem, czy ma to sens, ale jakoś zainicjowac trzeba + while (Console::Pressed(VK_F10)) + Error("Keyboard buffer problem - press F10"); //na Windows 98 lubi się to pojawiać + int iOldSpeed, iOldDelay; + SystemParametersInfo(SPI_GETKEYBOARDSPEED,0,&iOldSpeed,0); + SystemParametersInfo(SPI_GETKEYBOARDDELAY,0,&iOldDelay,0); + SystemParametersInfo(SPI_SETKEYBOARDSPEED,20,NULL,0); + //SystemParametersInfo(SPI_SETKEYBOARDDELAY,10,NULL,0); + if (!joyGetNumDevs()) + WriteLog("No joystick"); + if (Global::iModifyTGA<0) + {//tylko modyfikacja TGA, bez uruchamiania symulacji + Global::iMaxTextureSize=64; //żeby nie zamulać pamięci + World.ModifyTGA(); //rekurencyjne przeglądanie katalogów + } + else + {if (Global::iConvertModels<0) + {Global::iConvertModels=-Global::iConvertModels; + World.CreateE3D("models\\"); //rekurencyjne przeglądanie katalogów + World.CreateE3D("dynamic\\",true); + } //po zrobieniu E3D odpalamy normalnie scenerię, by ją zobaczyć + //else + //{//główna pętla programu + Console::On(); //włączenie konsoli + while (!done) //loop that runs while done=FALSE + { + if (PeekMessage(&msg,NULL,0,0,PM_REMOVE)) //is there a message waiting? + { + if (msg.message==WM_QUIT) //have we received a quit message? + done=TRUE; //if so + else //if not, deal with window messages + { + //if (msg.message==WM_CHAR) + //World.OnKeyDown(msg.wParam); + TranslateMessage(&msg); //translate the message + DispatchMessage(&msg); //dispatch the message + } + } + else //if there are no messages + { + //draw the scene, watch for quit messages + //DrawGLScene() + //if (!pause) + //if (Global::bInactivePause?Global::bActive:true) //tak nie, bo spada z góry + if (World.Update()) // Was There A Quit Received? + SwapBuffers(hDC); // Swap Buffers (Double Buffering) + else + done=true; //[F10] or DrawGLScene signalled a quit + } + } + Console::Off(); //wyłączenie konsoli (komunikacji zwrotnej) + } + SystemParametersInfo(SPI_SETKEYBOARDSPEED,iOldSpeed,NULL,0); + SystemParametersInfo(SPI_SETKEYBOARDDELAY,iOldDelay,NULL,0); + delete pConsole; //deaktywania sterownika + //shutdown + KillGLWindow(); //kill the window + return (msg.wParam); //exit the program +} + + diff --git a/EU07.res b/EU07.res new file mode 100644 index 00000000..b7e359bd Binary files /dev/null and b/EU07.res differ diff --git a/EvLaunch.cpp b/EvLaunch.cpp new file mode 100644 index 00000000..2561bd03 --- /dev/null +++ b/EvLaunch.cpp @@ -0,0 +1,184 @@ +//--------------------------------------------------------------------------- + +/* + MaSzyna EU07 locomotive simulator + Copyright (C) 2001-2004 Marcin Wozniak and others + +*/ + +#include "system.hpp" +#pragma hdrstop + +#include "mtable.hpp" +#include "Timer.h" +#include "Globals.h" +#include "EvLaunch.h" +#include "Event.h" + +#include "Usefull.h" +#include "MemCell.h" +#include "parser.h" +#include "Console.h" + + + +//--------------------------------------------------------------------------- + +__fastcall TEventLauncher::TEventLauncher() +{//ustawienie początkowych wartości dla wszystkich zmiennych + iKey=0; + DeltaTime=-1; + UpdatedTime=0; + fVal1=fVal2=0; + szText=NULL; + iHour=iMinute=-1; //takiego czasu nigdy nie będzie + dRadius=0; + Event1=Event2=NULL; + MemCell=NULL; + iCheckMask=0; +} + +__fastcall TEventLauncher::~TEventLauncher() +{ + SafeDeleteArray(szText); +} + +void __fastcall TEventLauncher::Init() +{ +} + +bool __fastcall TEventLauncher::Load(cParser *parser) +{//wczytanie wyzwalacza zdarzeń + AnsiString str; + std::string token; + parser->getTokens(); + *parser >> dRadius; //promień działania + if (dRadius>0.0) + dRadius*=dRadius; //do kwadratu, pod warunkiem, że nie jest ujemne + parser->getTokens(); //klawisz sterujący + *parser >> token; + str=AnsiString(token.c_str()); + if (str!="none") + { + if (str.Length()==1) + iKey=VkKeyScan(str[1]); //jeden znak jest konwertowany na kod klawisza + else + iKey=str.ToIntDef(0); //a jak więcej, to jakby numer klawisza jest + } + parser->getTokens(); + *parser >> DeltaTime; + if (DeltaTime<0) + DeltaTime=-DeltaTime; //dla ujemnego zmieniamy na dodatni + else if (DeltaTime>0) + {//wartość dodatnia oznacza wyzwalanie o określonej godzinie + iMinute=int(DeltaTime)%100; //minuty są najmłodszymi cyframi dziesietnymi + iHour=int(DeltaTime-iMinute)/100; //godzina to setki + DeltaTime=0; //bez powtórzeń + WriteLog("EventLauncher at "+IntToStr(iHour)+":"+IntToStr(iMinute)); //wyświetlenie czasu + } + parser->getTokens(); + *parser >> token; + asEvent1Name=AnsiString(token.c_str()); //pierwszy event + parser->getTokens(); + *parser >> token; + asEvent2Name=AnsiString(token.c_str()); //drugi event + if ((asEvent2Name=="end")||(asEvent2Name=="condition")) + {//drugiego eventu może nie być, bo są z tym problemy, ale ciii... + str=asEvent2Name; //rozpoznane słowo idzie do dalszego przetwarzania + asEvent2Name="none"; //a drugiego eventu nie ma + } + else + {//gdy są dwa eventy + parser->getTokens(); + *parser >> token; + str=AnsiString(token.c_str()); + } + if (str==AnsiString("condition")) + {//obsługa wyzwalania warunkowego + parser->getTokens(); + *parser >> token; + asMemCellName=AnsiString(token.c_str()); + parser->getTokens(); + *parser >> token; + SafeDeleteArray(szText); + szText=new char[256]; + strcpy(szText,token.c_str()); + if (token.compare("*")!=0) //*=nie brać command pod uwagę + iCheckMask|=conditional_memstring; + parser->getTokens(); + *parser >> token; + if (token.compare("*")!=0) //*=nie brać wartości 1. pod uwagę + { + iCheckMask|=conditional_memval1; + str=AnsiString(token.c_str()); + fVal1=str.ToDouble(); + } + else fVal1=0; + parser->getTokens(); + *parser >> token; + if (token.compare("*")!=0) //*=nie brać wartości 2. pod uwagę + { + iCheckMask|=conditional_memval2; + str=AnsiString(token.c_str()); + fVal2=str.ToDouble(); + } + else fVal2=0; + parser->getTokens(); //słowo zamykające + *parser >> token; + } + return true; +}; + +bool __fastcall TEventLauncher::Render() +{//"renderowanie" wyzwalacza + bool bCond=false; + if (iKey!=0) + { + if (Global::bActive) //tylko jeśli okno jest aktywne + bCond=(Console::Pressed(iKey)); //czy klawisz wciśnięty + } + if (DeltaTime>0) + { + if (UpdatedTime>DeltaTime) + { + UpdatedTime=0; //naliczanie od nowa + bCond=true; + } + else + UpdatedTime+=Timer::GetDeltaTime(); //aktualizacja naliczania czasu + } + else + {//jeśli nie cykliczny, to sprawdzić czas + if (GlobalTime->hh==iHour) + {if (GlobalTime->mm==iMinute) + {//zgodność czasu uruchomienia + if (UpdatedTime<10) + { + UpdatedTime=20; //czas do kolejnego wyzwolenia? + bCond=true; + } + } + } + else + UpdatedTime=1; + } + if (bCond) //jeśli spełniony został warunek + { + if ((iCheckMask!=0)&&MemCell) //sprawdzanie warunku na komórce pamięci + bCond=MemCell->Compare(szText,fVal1,fVal2,iCheckMask); + } + return bCond; //sprawdzanie dRadius w Ground.cpp +} + +bool __fastcall TEventLauncher::IsGlobal() +{//sprawdzenie, czy jest globalnym wyzwalaczem czasu + if (DeltaTime==0) + if (iHour>=0) + if (iMinute>=0) + if (dRadius<0.0) //bez ograniczenia zasięgu + return true; + return false; +}; +//--------------------------------------------------------------------------- + +#pragma package(smart_init) diff --git a/EvLaunch.h b/EvLaunch.h new file mode 100644 index 00000000..04b45b49 --- /dev/null +++ b/EvLaunch.h @@ -0,0 +1,36 @@ +//--------------------------------------------------------------------------- + +#ifndef EvLaunchH +#define EvLaunchH + +#include "Classes.h" + +class TEventLauncher +{ +private: + int iKey; + double DeltaTime; + double UpdatedTime; + double fVal1; + double fVal2; + char *szText; + int iHour,iMinute; //minuta uruchomienia +public: + double dRadius; + AnsiString asEvent1Name; + AnsiString asEvent2Name; + AnsiString asMemCellName; + TEvent *Event1; + TEvent *Event2; + TMemCell *MemCell; + int iCheckMask; + __fastcall TEventLauncher(); + __fastcall ~TEventLauncher(); + void __fastcall Init(); + bool __fastcall Load(cParser *parser); + bool __fastcall Render(); + bool __fastcall IsGlobal(); +}; + +//--------------------------------------------------------------------------- +#endif diff --git a/Event.cpp b/Event.cpp new file mode 100644 index 00000000..b679b080 --- /dev/null +++ b/Event.cpp @@ -0,0 +1,626 @@ +//--------------------------------------------------------------------------- + +/* + MaSzyna EU07 locomotive simulator + Copyright (C) 2001-2004 Marcin Wozniak and others + +*/ + +#include "system.hpp" +#include "classes.hpp" +#pragma hdrstop + +#include "Event.h" +#include "parser.h" +#include "Timer.h" +#include "Usefull.h" +#include "MemCell.h" +#include "Globals.h" +#include "Ground.h" +#pragma package(smart_init) + +__fastcall TEvent::TEvent(AnsiString m) +{ + //asName=""; //czy nazwa eventu jest niezbędna w tym przypadku? chyba nie + evNext=evNext2=NULL; + bEnabled=false; //false dla eventów używanych do skanowania sygnałów (nie dodawane do kolejki) + asNodeName=m; //nazwa obiektu powiązanego + iQueued=0; //nie został dodany do kolejki + //bIsHistory=false; + fDelay=0; + fStartTime=0; //0 nie ma sensu + Type=m.IsEmpty()?tp_Unknown:tp_GetValues; //utworzenie niejawnego odczytu komórki pamięci w torze + for (int i=0;i<13;i++) + Params[i].asPointer=NULL; + evJoined=NULL; //nie ma kolejnego z tą samą nazwą, usuwane są wg listy Next2 + Activator=NULL; + iFlags=0; + //event niejawny jest tworzony przed fazą InitEvents, która podmienia nazwę komórki pamięci na wskaźnik + //Current->Params[8].asGroundNode=m; //to się ustawi w InitEvents + //Current->Params[9].asMemCell=m->MemCell; + fRandomDelay=0.0; //standardowo nie będzie dodatkowego losowego opóźnienia +}; + +__fastcall TEvent::~TEvent() +{ + switch (Type) + {//sprzątanie + case tp_Multiple: + //SafeDeleteArray(Params[9].asText); //nie usuwać - nazwa obiektu powiązanego zamieniana na wskaźnik + if (iFlags&conditional_memstring) //o ile jest łańcuch do porównania w memcompare + SafeDeleteArray(Params[10].asText); + break; + case tp_UpdateValues: + case tp_AddValues: + SafeDeleteArray(Params[0].asText); + if (iFlags&conditional_memstring) //o ile jest łańcuch do porównania w memcompare + SafeDeleteArray(Params[10].asText); + break; + case tp_Animation: //nic + //SafeDeleteArray(Params[9].asText); //nie usuwać - nazwa jest zamieniana na wskaźnik do submodelu + if (Params[0].asInt==4) //jeśli z pliku VMD + delete[] Params[8].asPointer; //zwolnić obszar + case tp_GetValues: //nic + break; + } + evJoined=NULL; //nie usuwać podczepionych tutaj +}; + +void __fastcall TEvent::Init() +{ + +}; + +void __fastcall TEvent::Conditions(cParser* parser,AnsiString s) +{//przetwarzanie warunków, wspólne dla Multiple i UpdateValues + if (s=="condition") + {//jesli nie "endevent" + std::string token; + AnsiString str; + if (!asNodeName.IsEmpty()) + {//podczepienie łańcucha, jeśli nie jest pusty + Params[9].asText=new char[asNodeName.Length()+1]; //usuwane i zamieniane na wskaźnik + strcpy(Params[9].asText,asNodeName.c_str()); + } + parser->getTokens(); + *parser >> token; + str=AnsiString(token.c_str()); + if (str==AnsiString("trackoccupied")) + iFlags|=conditional_trackoccupied; + else if (str==AnsiString("trackfree")) + iFlags|=conditional_trackfree; + else if (str==AnsiString("propability")) + { + iFlags|=conditional_propability; + parser->getTokens(); + *parser >> Params[10].asdouble; + } + else if (str==AnsiString("memcompare")) + { + iFlags|=conditional_memcompare; + parser->getTokens(1,false); //case sensitive + *parser >> token; + str=AnsiString(token.c_str()); + if (str!="*") //"*" - nie brac command pod uwage + {//zapamiętanie łańcucha do porównania + Params[10].asText=new char[255]; + strcpy(Params[10].asText,str.c_str()); + iFlags|=conditional_memstring; + } + parser->getTokens(); + *parser >> token; + str=AnsiString(token.c_str()); + if (str!="*") //"*" - nie brac val1 pod uwage + { + Params[11].asdouble=str.ToDouble(); + iFlags|=conditional_memval1; + } + parser->getTokens(); + *parser >> token; + str=AnsiString(token.c_str()); + if (str!=AnsiString("*")) //"*" - nie brac val2 pod uwage + { + Params[12].asdouble=str.ToDouble(); + iFlags|=conditional_memval2; + } + } + parser->getTokens(); *parser >> token; + s=AnsiString(token.c_str()); //ewentualnie dalej losowe opóźnienie + } + if (s=="randomdelay") + {//losowe opóźnienie + std::string token; + parser->getTokens(); + *parser >> fRandomDelay; //Ra 2014-03-11 + parser->getTokens(); *parser >> token; //endevent + } +}; + +void __fastcall TEvent::Load(cParser* parser,vector3 *org) +{ + int i; + int ti; + double tf; + std::string token; + AnsiString str; + char *ptr; + + bEnabled=true; //zmieniane na false dla eventów używanych do skanowania sygnałów + + parser->getTokens(); + *parser >> token; + asName=AnsiString(token.c_str()).LowerCase(); //użycie parametrów może dawać wielkie + + parser->getTokens(); + *parser >> token; + str=AnsiString(token.c_str()); + + if (str==AnsiString("exit")) + Type=tp_Exit; + else if (str==AnsiString("updatevalues")) + Type=tp_UpdateValues; + else if (str==AnsiString("getvalues")) + Type=tp_GetValues; + else if (str==AnsiString("putvalues")) + Type=tp_PutValues; + else if (str==AnsiString("disable")) + Type=tp_Disable; + else if (str==AnsiString("sound")) + Type=tp_Sound; + else if (str==AnsiString("velocity")) + Type=tp_Velocity; + else if (str==AnsiString("animation")) + Type=tp_Animation; + else if (str==AnsiString("lights")) + Type=tp_Lights; + else if (str==AnsiString("visible")) + Type=tp_Visible; //zmiana wyświetlania obiektu + else if (str==AnsiString("switch")) + Type=tp_Switch; + else if (str==AnsiString("dynvel")) + Type=tp_DynVel; + else if (str==AnsiString("trackvel")) + Type=tp_TrackVel; + else if (str==AnsiString("multiple")) + Type=tp_Multiple; + else if (str==AnsiString("addvalues")) + Type=tp_AddValues; + else if (str==AnsiString("copyvalues")) + Type=tp_CopyValues; + else if (str==AnsiString("whois")) + Type=tp_WhoIs; + else if (str==AnsiString("logvalues")) + Type=tp_LogValues; + else if (str==AnsiString("voltage")) + Type=tp_Voltage; //zmiana napięcia w zasilaczu (TractionPowerSource) + else if (str==AnsiString("message")) + Type=tp_Message; //wyświetlenie komunikatu + else if (str==AnsiString("friction")) + Type=tp_Friction; //zmiana tarcia na scenerii + else + Type=tp_Unknown; + + parser->getTokens(); + *parser >> fDelay; + + parser->getTokens(); + *parser >> token; + str=AnsiString(token.c_str()); + + if (str!="none") asNodeName=str; //nazwa obiektu powiązanego + + if (asName.SubString(1,5)=="none_") + Type=tp_Ignored; //Ra: takie są ignorowane + + switch (Type) + { + case tp_AddValues: + iFlags=update_memadd; //dodawanko + case tp_UpdateValues: + //if (Type==tp_UpdateValues) iFlags=0; //co modyfikować + parser->getTokens(1,false); //case sensitive + *parser >> token; + str=AnsiString(token.c_str()); + Params[0].asText=new char[str.Length()+1]; + strcpy(Params[0].asText,str.c_str()); + if (str!="*") //czy ma zostać bez zmian? + iFlags|=update_memstring; + parser->getTokens(); + *parser >> token; + str=AnsiString(token.c_str()); + if (str!="*") //czy ma zostać bez zmian? + { + Params[1].asdouble=str.ToDouble(); + iFlags|=update_memval1; + } + else + Params[1].asdouble=0; + parser->getTokens(); + *parser >> token; + str=AnsiString(token.c_str()); + if (str!="*") //czy ma zostać bez zmian? + { + Params[2].asdouble=str.ToDouble(); + iFlags|=update_memval2; + } + else + Params[2].asdouble=0; + parser->getTokens(); + *parser >> token; + Conditions(parser,token.c_str()); //sprawdzanie warunków + break; + case tp_CopyValues: + Params[9].asText=NULL; + iFlags=update_memstring|update_memval1|update_memval2; //normalanie trzy + i=0; + parser->getTokens(); + *parser >> token; //nazwa drugiej komórki (źródłowej) + while (token.compare("endevent")!=0) + { + switch (++i) + {//znaczenie kolejnych parametrów + case 1: //nazwa drugiej komórki (źródłowej) + Params[9].asText=new char[token.length()+1]; //usuwane i zamieniane na wskaźnik + strcpy(Params[9].asText,token.c_str()); + break; + case 2: //maska wartości + iFlags=AnsiString(token.c_str()).ToIntDef(update_memstring|update_memval1|update_memval2); + break; + } + parser->getTokens(); + *parser >> token; + } + break; + case tp_WhoIs: + iFlags=update_memstring|update_memval1|update_memval2; //normalanie trzy + i=0; + parser->getTokens(); + *parser >> token; //nazwa drugiej komórki (źródłowej) + while (token.compare("endevent")!=0) + { + switch (++i) + {//znaczenie kolejnych parametrów + case 1: //maska wartości + iFlags=AnsiString(token.c_str()).ToIntDef(update_memstring|update_memval1|update_memval2); + break; + } + parser->getTokens(); + *parser >> token; + } + break; + case tp_GetValues: + case tp_LogValues: + parser->getTokens(); //"endevent" + *parser >> token; + break; + case tp_PutValues: + parser->getTokens(3); + *parser >> Params[3].asdouble >> Params[4].asdouble >> Params[5].asdouble; //położenie X,Y,Z + if (org) + {//przesunięcie + //tmp->pCenter.RotateY(aRotate.y/180.0*M_PI); //Ra 2014-11: uwzględnienie rotacji + Params[3].asdouble+=org->x; //współrzędne w scenerii + Params[4].asdouble+=org->y; + Params[5].asdouble+=org->z; + } + //Params[12].asInt=0; + parser->getTokens(1,false); //komendy 'case sensitive' + *parser >> token; + str=AnsiString(token.c_str()); + if (str.SubString(1,19)=="PassengerStopPoint:") + {if (str.Pos("#")) str=str.SubString(1,str.Pos("#")-1); //obcięcie unikatowości + bEnabled=false; //nie do kolejki (dla SetVelocity też, ale jak jest do toru dowiązany) + Params[6].asCommand=cm_PassengerStopPoint; + } + else if (str=="SetVelocity") + {bEnabled=false; + Params[6].asCommand=cm_SetVelocity; + } + else if (str=="ShuntVelocity") + {bEnabled=false; + Params[6].asCommand=cm_ShuntVelocity; + } + else if (str=="SetProximityVelocity") + {bEnabled=false; + Params[6].asCommand=cm_SetProximityVelocity; + } + else if (str=="OutsideStation") + {bEnabled=false; //ma być skanowny, aby AI nie przekraczało W5 + Params[6].asCommand=cm_OutsideStation; + } + else + Params[6].asCommand=cm_Unknown; + Params[0].asText=new char[str.Length()+1]; + strcpy(Params[0].asText,str.c_str()); + parser->getTokens(); + *parser >> token; + str=AnsiString(token.c_str()); + if (str=="none") + Params[1].asdouble=0.0; + else + try + {Params[1].asdouble=str.ToDouble();} + catch (...) + {Params[1].asdouble=0.0; + WriteLog("Error: number expected in PutValues event, found: "+str); + } + parser->getTokens(); + *parser >> token; + str=AnsiString(token.c_str()); + if (str=="none") + Params[2].asdouble=0.0; + else + try + {Params[2].asdouble=str.ToDouble();} + catch (...) + {Params[2].asdouble=0.0; + WriteLog("Error: number expected in PutValues event, found: "+str); + } + parser->getTokens(); + *parser >> token; + break; + case tp_Lights: + i=0; + do + { + parser->getTokens(); + *parser >> token; + if (token.compare("endevent")!=0) + { + str=AnsiString(token.c_str()); + if (i<8) + Params[i].asdouble=str.ToDouble(); //teraz może mieć ułamek + i++; + } + } + while (token.compare("endevent")!=0); + break; + case tp_Visible: //zmiana wyświetlania obiektu + parser->getTokens(); + *parser >> token; + str=AnsiString(token.c_str()); + Params[0].asInt=str.ToInt(); + parser->getTokens(); *parser >> token; + break; + case tp_Velocity: + parser->getTokens(); + *parser >> token; + str=AnsiString(token.c_str()); + Params[0].asdouble=str.ToDouble()*0.28; + parser->getTokens(); *parser >> token; + break; + case tp_Sound: + //Params[0].asRealSound->Init(asNodeName.c_str(),Parser->GetNextSymbol().ToDouble(),Parser->GetNextSymbol().ToDouble(),Parser->GetNextSymbol().ToDouble(),Parser->GetNextSymbol().ToDouble()); + //McZapkie-070502: dzwiek przestrzenny (ale do poprawy) + //Params[1].asdouble=Parser->GetNextSymbol().ToDouble(); + //Params[2].asdouble=Parser->GetNextSymbol().ToDouble(); + //Params[3].asdouble=Parser->GetNextSymbol().ToDouble(); //polozenie X,Y,Z - do poprawy! + parser->getTokens(); + *parser >> Params[0].asInt; //0: wylaczyc, 1: wlaczyc; -1: wlaczyc zapetlone + parser->getTokens(); *parser >> token; + break; + case tp_Exit: + while ((ptr=strchr(asNodeName.c_str(),'_'))!=NULL) + *ptr=' '; + parser->getTokens(); *parser >> token; + break; + case tp_Disable: + parser->getTokens(); *parser >> token; + break; + case tp_Animation: + parser->getTokens(); + *parser >> token; + Params[0].asInt=0; //na razie nieznany typ + if (token.compare("rotate")==0) + {//obrót względem osi + parser->getTokens(); + *parser >> token; + Params[9].asText=new char[255]; //nazwa submodelu + strcpy(Params[9].asText,token.c_str()); + Params[0].asInt=1; + parser->getTokens(4); + *parser >> Params[1].asdouble >> Params[2].asdouble >> Params[3].asdouble >> Params[4].asdouble; + } + else if (token.compare("translate")==0) + {//przesuw o wektor + parser->getTokens(); + *parser >> token; + Params[9].asText=new char[255]; //nazwa submodelu + strcpy(Params[9].asText,token.c_str()); + Params[0].asInt=2; + parser->getTokens(4); + *parser >> Params[1].asdouble >> Params[2].asdouble >> Params[3].asdouble >> Params[4].asdouble; + } + else if (token.compare("digital")==0) + {//licznik cyfrowy + parser->getTokens(); + *parser >> token; + Params[9].asText=new char[255]; //nazwa submodelu + strcpy(Params[9].asText,token.c_str()); + Params[0].asInt=8; + parser->getTokens(4); //jaki ma być sens tych parametrów? + *parser >> Params[1].asdouble >> Params[2].asdouble >> Params[3].asdouble >> Params[4].asdouble; + } + else if (token.substr(token.length()-4,4)==".vmd") //na razie tu, może będzie inaczej + {//animacja z pliku VMD + TFileStream *fs=new TFileStream("models\\"+AnsiString(token.c_str()),fmOpenRead); + Params[7].asInt=fs->Size; + Params[8].asPointer=new char[fs->Size]; + fs->Read(Params[8].asPointer,fs->Size); //wczytanie pliku + delete fs; + parser->getTokens(); + *parser >> token; + Params[9].asText=new char[255]; //nazwa submodelu + strcpy(Params[9].asText,token.c_str()); + Params[0].asInt=4; //rodzaj animacji + parser->getTokens(4); + *parser >> Params[1].asdouble >> Params[2].asdouble >> Params[3].asdouble >> Params[4].asdouble; + } + parser->getTokens(); *parser >> token; + break; + case tp_Switch: + parser->getTokens(); *parser >> Params[0].asInt; + parser->getTokens(); *parser >> token; + str=AnsiString(token.c_str()); + if (str!="endevent") + {Params[1].asdouble=str.ToDouble(); //prędkość liniowa ruchu iglic + parser->getTokens(); *parser >> token; + str=AnsiString(token.c_str()); + } + else + Params[1].asdouble=-1.0; //użyć domyślnej + if (str!="endevent") + {Params[2].asdouble=str.ToDouble(); //dodatkowy ruch drugiej iglicy (zamknięcie nastawnicze) + parser->getTokens(); *parser >> token; + } + else + Params[2].asdouble=-1.0; //użyć domyślnej + break; + case tp_DynVel: + parser->getTokens(); + *parser >> Params[0].asdouble; //McZapkie-090302 *0.28; + parser->getTokens(); *parser >> token; + break; + case tp_TrackVel: + parser->getTokens(); + *parser >> Params[0].asdouble; //McZapkie-090302 *0.28; + parser->getTokens(); *parser >> token; + break; + case tp_Multiple: + i=0; + ti=0; //flaga dla else + parser->getTokens(); + *parser >> token; + str=AnsiString(token.c_str()); + while (str!=AnsiString("endevent") && str!=AnsiString("condition") && str!=AnsiString("randomdelay")) + { + if ((str.SubString(1,5)!="none_")?(i<8):false) + {//eventy rozpoczynające się od "none_" są ignorowane + if (str!="else") + {Params[i].asText=new char[255]; + strcpy(Params[i].asText,str.c_str()); + if (ti) iFlags|=conditional_else<=8) + ErrorLog("Bad event: \""+str+"\" ignored in multiple \""+asName+"\"!"); + else + WriteLog("Event \""+str+"\" ignored in multiple \""+asName+"\"!"); + parser->getTokens(); + *parser >> token; + str=AnsiString(token.c_str()); + } + Conditions(parser,str); //sprawdzanie warunków + break; + case tp_Voltage: //zmiana napięcia w zasilaczu (TractionPowerSource) + case tp_Friction: //zmiana przyczepnosci na scenerii + parser->getTokens(); + *parser >> Params[0].asdouble; //Ra 2014-01-27 + parser->getTokens(); *parser >> token; + break; + case tp_Message: //wyświetlenie komunikatu + do + {parser->getTokens(); + *parser >> token; + str=AnsiString(token.c_str()); + } while (str!="endevent"); + break; + case tp_Ignored: //ignorowany + case tp_Unknown: //nieznany + do + {parser->getTokens(); + *parser >> token; + str=AnsiString(token.c_str()); + } while (str!="endevent"); + WriteLog("Bad event: \""+asName+(Type==tp_Unknown?"\" has unknown type.":"\" is ignored.")); + break; + } +}; + +void __fastcall TEvent::AddToQuery(TEvent *e) +{//dodanie eventu do kolejki + if (evNext?(e->fStartTime>=evNext->fStartTime):false) + evNext->AddToQuery(e); //sortowanie wg czasu + else + {//dodanie z przodu + e->evNext=evNext; + evNext=e; + } +} + +//--------------------------------------------------------------------------- + +AnsiString __fastcall TEvent::CommandGet() +{//odczytanie komendy z eventu + switch (Type) + {//to się wykonuje również składu jadącego bez obsługi + case tp_GetValues: + return String(Params[9].asMemCell->Text()); + case tp_PutValues: + return String(Params[0].asText); + } + return ""; //inne eventy się nie liczą +}; + +TCommandType __fastcall TEvent::Command() +{//odczytanie komendy z eventu + switch (Type) + {//to się wykonuje również dla składu jadącego bez obsługi + case tp_GetValues: + return Params[9].asMemCell->Command(); + case tp_PutValues: + return Params[6].asCommand; //komenda zakodowana binarnie + } + return cm_Unknown; //inne eventy się nie liczą +}; + +double __fastcall TEvent::ValueGet(int n) +{//odczytanie komendy z eventu + n&=1; //tylko 1 albo 2 jest prawidłowy + switch (Type) + {//to się wykonuje również składu jadącego bez obsługi + case tp_GetValues: + return n?Params[9].asMemCell->Value1():Params[9].asMemCell->Value2(); + case tp_PutValues: + return Params[2-n].asdouble; + } + return 0.0; //inne eventy się nie liczą +}; + +vector3 __fastcall TEvent::PositionGet() +{//pobranie współrzędnych eventu + switch (Type) + {// + case tp_GetValues: + return Params[9].asMemCell->Position(); //współrzędne podłączonej komórki pamięci + case tp_PutValues: + return vector3(Params[3].asdouble,Params[4].asdouble,Params[5].asdouble); + } + return vector3(0,0,0); //inne eventy się nie liczą +}; + +bool __fastcall TEvent::StopCommand() +{// + if (Type==tp_GetValues) + return Params[9].asMemCell->StopCommand(); //info o komendzie z komórki + return false; +}; + +void __fastcall TEvent::StopCommandSent() +{ + if (Type==tp_GetValues) + Params[9].asMemCell->StopCommandSent(); //komenda z komórki została wysłana +}; + +void __fastcall TEvent::Append(TEvent *e) +{//doczepienie kolejnych z tą samą nazwą + if (evJoined) + evJoined->Append(e); //rekurencja! - góra kilkanaście eventów będzie potrzebne + else + {evJoined=e; + e->bEnabled=true; //ten doczepiony może być tylko kolejkowany + } +}; diff --git a/Event.h b/Event.h new file mode 100644 index 00000000..f89bf13f --- /dev/null +++ b/Event.h @@ -0,0 +1,91 @@ +//--------------------------------------------------------------------------- + +#ifndef EventH +#define EventH + +#include "Classes.h" +#include "dumb3d.h" +using namespace Math3D; + +typedef enum { tp_Unknown, tp_Sound, tp_SoundPos, tp_Exit, + tp_Disable, tp_Velocity, tp_Animation, tp_Lights, + tp_UpdateValues, tp_GetValues, tp_PutValues, + tp_Switch, tp_DynVel, tp_TrackVel, tp_Multiple, + tp_AddValues, tp_Ignored, tp_CopyValues, tp_WhoIs, + tp_LogValues, tp_Visible, + tp_Voltage, tp_Message, tp_Friction + } TEventType; + +const int update_memstring =0x0000001; //zmodyfikować tekst (UpdateValues) +const int update_memval1 =0x0000002; //zmodyfikować pierwszą wartosć +const int update_memval2 =0x0000004; //zmodyfikować drugą wartosć +const int update_memadd =0x0000008; //dodać do poprzedniej zawartości +const int update_load =0x0000010; //odczytać ładunek +const int update_only =0x00000FF; //wartość graniczna +const int conditional_memstring =0x0000100; //porównanie tekstu +const int conditional_memval1 =0x0000200; //porównanie pierwszej wartości liczbowej +const int conditional_memval2 =0x0000400; //porównanie drugiej wartości +const int conditional_else =0x0010000; //flaga odwrócenia warunku (przesuwana bitowo) +const int conditional_anyelse =0x0FF0000; //do sprawdzania, czy są odwrócone warunki +const int conditional_trackoccupied =0x1000000; //jeśli tor zajęty +const int conditional_trackfree =0x2000000; //jeśli tor wolny +const int conditional_propability =0x4000000; //zależnie od generatora lizcb losowych +const int conditional_memcompare =0x8000000; //porównanie zawartości + +union TParam +{ + void *asPointer; + TMemCell *asMemCell; + TGroundNode *nGroundNode; + TTrack *asTrack; + TAnimModel *asModel; + TAnimContainer *asAnimContainer; + TTrain *asTrain; + TDynamicObject *asDynamic; + TEvent *asEvent; + bool asBool; + double asdouble; + int asInt; + TTextSound *tsTextSound; + char *asText; + TCommandType asCommand; + TTractionPowerSource *psPower; +}; + +class TEvent //zmienne: ev* +{//zdarzenie +private: + void __fastcall Conditions(cParser* parser,AnsiString s); +public: + AnsiString asName; + bool bEnabled; //false gdy ma nie być dodawany do kolejki (skanowanie sygnałów) + int iQueued; //ile razy dodany do kolejki + //bool bIsHistory; + TEvent *evNext; //następny w kolejce + TEvent *evNext2; + TEventType Type; + double fStartTime; + double fDelay; + TDynamicObject *Activator; + TParam Params[13]; //McZapkie-070502 //Ra: zamienić to na union/struct + unsigned int iFlags; //zamiast Params[8] z flagami warunku + AnsiString asNodeName; //McZapkie-100302 - dodalem zeby zapamietac nazwe toru + TEvent *evJoined; //kolejny event z tą samą nazwą - od wersji 378 + double fRandomDelay; //zakres dodatkowego opóźnienia +public: //metody + __fastcall TEvent(AnsiString m=""); + __fastcall ~TEvent(); + void __fastcall Init(); + void __fastcall Load(cParser* parser,vector3 *org); + void __fastcall AddToQuery(TEvent *e); + AnsiString __fastcall CommandGet(); + TCommandType __fastcall Command(); + double __fastcall ValueGet(int n); + vector3 __fastcall PositionGet(); + bool __fastcall StopCommand(); + void __fastcall StopCommandSent(); + void __fastcall Append(TEvent *e); +}; + +//--------------------------------------------------------------------------- +#endif diff --git a/FadeSound.cpp b/FadeSound.cpp new file mode 100644 index 00000000..7eb6b8ef --- /dev/null +++ b/FadeSound.cpp @@ -0,0 +1,105 @@ +//--------------------------------------------------------------------------- +/* + MaSzyna EU07 locomotive simulator + Copyright (C) 2001-2004 Marcin Wozniak and others + +*/ + +#include "system.hpp" +#include "classes.hpp" +#pragma hdrstop + +#include "Timer.h" +#include "FadeSound.h" + + +__fastcall TFadeSound::TFadeSound() +{ + Sound= NULL; + fFade= 0; + dt= 0; + fTime= 0; +} + + +__fastcall TFadeSound::~TFadeSound() +{ + Free(); +} + +void __fastcall TFadeSound::Free() +{ +} + +void __fastcall TFadeSound::Init(char *Name, float fNewFade) +{ + Sound= TSoundsManager::GetFromName(Name,false); + if (Sound) + Sound->SetVolume(0); + fFade= fNewFade; + fTime= 0; +} + +void __fastcall TFadeSound::TurnOn() +{ + State= ss_Starting; + Sound->Play(0,0,DSBPLAY_LOOPING); + fTime= fFade; + +} + +void __fastcall TFadeSound::TurnOff() +{ + State= ss_ShuttingDown; +} + +void __fastcall TFadeSound::Update() +{ + + if (State==ss_Starting) + { + fTime+= Timer::GetDeltaTime(); +// SoundStart->SetVolume(-1000*(4-fTime)/4); + if (fTime>=fFade) + { + fTime= fFade; + State= ss_Commencing; + Sound->SetVolume(-2000*(fFade-fTime)/fFade); + Sound->SetFrequency(44100-500+500*(fTime)/fFade); + } + else + if (Timer::GetSoundTimer()) + { + Sound->SetVolume(-2000*(fFade-fTime)/fFade); + Sound->SetFrequency(44100-500+500*(fTime)/fFade); + } + } + else + if (State==ss_ShuttingDown) + { + fTime-= Timer::GetDeltaTime(); + + if (fTime<=0) + { + State= ss_Off; + fTime= 0; + Sound->Stop(); + } + if (Timer::GetSoundTimer()) + { //DSBVOLUME_MIN + Sound->SetVolume(-2000*(fFade-fTime)/fFade); + Sound->SetFrequency(44100-500+500*fTime/fFade); + } + } +} +void __fastcall TFadeSound::Volume(long vol) +{ + float glos= 1; + Sound->SetVolume(vol*glos); +} + +//--------------------------------------------------------------------------- + +#pragma package(smart_init) + + diff --git a/FadeSound.h b/FadeSound.h new file mode 100644 index 00000000..6c9f8d45 --- /dev/null +++ b/FadeSound.h @@ -0,0 +1,29 @@ +//--------------------------------------------------------------------------- + +#ifndef FadeSoundH +#define FadeSoundH + +#include "Sound.h" +#include "AdvSound.h" + +class TFadeSound +{ + PSound Sound; + float fFade; + float dt,fTime; + TSoundState State; +public: + __fastcall TFadeSound(); + __fastcall ~TFadeSound(); + void __fastcall Init(char *Name, float fNewFade); + void __fastcall TurnOn(); + void __fastcall TurnOff(); + bool __fastcall Playing() {return (State==ss_Commencing || State==ss_Starting); }; + void __fastcall Free(); + void __fastcall Update(); + void __fastcall Volume(long vol); + +}; + +//--------------------------------------------------------------------------- +#endif diff --git a/Float3d.cpp b/Float3d.cpp new file mode 100644 index 00000000..26253a85 --- /dev/null +++ b/Float3d.cpp @@ -0,0 +1,27 @@ +//--------------------------------------------------------------------------- + +#include +#pragma hdrstop + +#include "float3d.h" + +//--------------------------------------------------------------------------- + +#pragma package(smart_init) + +void __fastcall float4x4::Quaternion(float4 *q) +{//konwersja kwaternionu obrotu na macierz obrotu + float xx=q->x*q->x,yy=q->y*q->y,zz=q->z*q->z; + float xy=q->x*q->y,xz=q->x*q->z,yz=q->y*q->z; + float wx=q->w*q->x,wy=q->w*q->y,wz=q->w*q->z; + e[ 0]=1.0f-yy-yy-zz-zz; + e[ 1]=xy+xy+wz+wz; + e[ 2]=xz+xz-wy-wy; + e[ 4]=xy+xy-wz-wz; + e[ 5]=1.0f-xx-xx-zz-zz; + e[ 6]=yz+yz+wx+wx; + e[ 8]=xz+xz+wy+wy; + e[ 9]=yz+yz-wx-wx; + e[10]=1.0f-xx-xx-yy-yy; + //czwartej kolumny i czwartego wiersza nie ruszamy +}; diff --git a/Float3d.h b/Float3d.h new file mode 100644 index 00000000..388f8f6f --- /dev/null +++ b/Float3d.h @@ -0,0 +1,269 @@ +//--------------------------------------------------------------------------- + +#ifndef float3dH +#define float3dH +#include +//--------------------------------------------------------------------------- + +class float3 +{//wapółrzędne wierchołka 3D o pojedynczej precyzji +public: + float x,y,z; + float3(void) {}; + __fastcall float3(float a,float b,float c) {x=a;y=b;z=c;}; + double inline __fastcall Length() const; +}; + +inline bool operator==(const float3& v1,const float3& v2) +{return (v1.x==v2.x&&v1.y==v2.y&&v1.z==v2.z); +}; +inline float3& operator+=(float3& v1,const float3& v2) +{v1.x+=v2.x; v1.y+=v2.y; v1.z+=v2.z; + return v1; +}; +inline float3 operator-(const float3& v) +{return float3(-v.x,-v.y,-v.z); +}; +inline float3 operator-(const float3 &v1,const float3 &v2) +{return float3(v1.x-v2.x,v1.y-v2.y,v1.z-v2.z); +}; +inline float3 operator+(const float3 &v1,const float3 &v2) +{return float3(v1.x+v2.x,v1.y+v2.y,v1.z+v2.z); +}; +double inline __fastcall float3::Length() const +{return sqrt(x*x+y*y+z*z); +}; +inline float3 operator/(const float3& v, double k) +{return float3(v.x/k,v.y/k,v.z/k); +}; +inline float3 SafeNormalize(const float3 &v) +{//bezpieczna normalizacja (wektor długości 1.0) + double l=v.Length(); + float3 retVal; + if (l==0) + retVal.x=retVal.y=retVal.z=0; + else + retVal=v/l; + return retVal; +}; +inline float3 CrossProduct(const float3& v1,const float3& v2) +{return float3(v1.y*v2.z-v1.z*v2.y,v2.x*v1.z-v2.z*v1.x,v1.x*v2.y-v1.y*v2.x); +} + +class float4 +{//kwaternion obrotu +public: + float x,y,z,w; + __fastcall float4() {x=y=z=0.f;w=1.f;}; + __fastcall float4(float a,float b,float c,float d) {x=a;y=b;z=c;w=d;}; + double inline float4::LengthSquared() const + {return x*x+y*y+z*z+w*w;}; + double inline float4::Length() const + {return sqrt(x*x+y*y+z*z+w*w);}; +}; +inline float4 operator*(const float4 &q1,const float4 &q2) +{//mnożenie to prawie jak mnożenie macierzy + return float4 + (q1.w*q2.x+q1.x*q2.w+q1.y*q2.z-q1.z*q2.y, + q1.w*q2.y+q1.y*q2.w+q1.z*q2.x-q1.x*q2.z, + q1.w*q2.z+q1.z*q2.w+q1.x*q2.y-q1.y*q2.x, + q1.w*q2.w-q1.x*q2.x-q1.y*q2.y-q1.z*q2.z + ); +} +inline float4 operator-(const float4& q) +{//sprzężony; odwrotny tylko dla znormalizowanych! + return float4(-q.x,-q.y,-q.z,q.w); +}; +inline float4 operator-(const float4 &q1,const float4 &q2) +{//z odejmowaniem nie ma lekko + return (-q1)*q2; //inwersja tylko dla znormalizowanych! +}; +inline float4 operator+(const float4 &v1,const float4 &v2) +{return float4(v1.x+v2.x,v1.y+v2.y,v1.z+v2.z,v1.w+v2.w);}; +inline float4 operator/(const float4& v, double k) +{return float4(v.x/k,v.y/k,v.z/k,v.w/k);}; +inline float4 Normalize(const float4 &v) +{//bezpieczna normalizacja (wektor długości 1.0) + double l=v.LengthSquared(); + if (l==1.0) + return v; + if (l==0.0) + return float4(); //wektor zerowy, w=1 + else + return v/sqrt(l); //pierwiastek liczony tylko jeśli trzeba wykonać dzielenia +}; +float Dot(const float4 &q1,const float4 &q2) +{//iloczyn skalarny + return q1.x*q2.x+q1.y*q2.y+q1.z*q2.z+q1.w*q2.w; +} +inline float4& operator*=(float4& v1,double d) +{//mnożenie przez skalar, jaki ma sens? + v1.x*=d; v1.y*=d; v1.z*=d; v1.w*=d; + return v1; +}; +inline float4 Slerp(const float4 &q0,const float4 &q1,float t) +//void Slerp(QUATERNION *Out, const QUATERNION &q0, const QUATERNION &q1, float t) +{//interpolacja sweryczna + float cosOmega=Dot(q0,q1); + float4 new_q1(q1); + if (cosOmega<0.0f) + {//jeżeli są niezgodne kierunki, jeden z nich trzeba zanegować + new_q1.x=-new_q1.x; + new_q1.y=-new_q1.y; + new_q1.z=-new_q1.z; + new_q1.w=-new_q1.w; + cosOmega=-cosOmega; + } + double k0,k1; + if (cosOmega>0.9999f) + {//jeśli jesteśmy z (t) na maksimum kosinusa, to tam prawie liniowo jest + k0=1.0f-t; + k1=t; + } + else + {//a w ogólnym przypadku trzeba liczyć na trygonometrię + double sinOmega=sqrt(1.0f-cosOmega*cosOmega); //sinus z jedynki tryg. + double omega=atan2(sinOmega,cosOmega); //wyznaczenie kąta + double oneOverSinOmega=1.0f/sinOmega; //odwrotność sinusa, bo sinus w mianowniku + k0=sin((1.0f-t)*omega)*oneOverSinOmega; + k1=sin(t*omega)*oneOverSinOmega; + } + return float4 + (q0.x*k0+new_q1.x*k1, + q0.y*k0+new_q1.y*k1, + q0.z*k0+new_q1.z*k1, + q0.w*k0+new_q1.w*k1 + ); +} + + +struct float8 +{//wierchołek 3D z wektorem normalnym i mapowaniem, pojedyncza precyzja +public: + float3 Point; + float3 Normal; + float tu,tv; +}; + +class float4x4 +{//macierz transformacji pojedynczej precyzji + float e[16]; +public: + float4x4(void) {}; + float4x4(float f[16]) {for (int i=0;i<16;++i) e[i]=f[i];}; + float* __fastcall operator() (int i) { return &e[i<<2]; } + const float* __fastcall readArray(void) { return e; } + void __fastcall Identity() + {for (int i=0;i<16;++i) + e[i]=0; + e[0]=e[5]=e[10]=e[15]=1.0f; + } + const float* operator[](int i) const {return &e[i<<2];}; + void __fastcall InitialRotate() + {//taka specjalna rotacja, nie ma co ciągać trygonometrii + float f; + for (int i=0;i<16;i+=4) + {e[i]=-e[i]; //zmiana znaku X + f=e[i+1]; e[i+1]=e[i+2]; e[i+2]=f; //zamiana Y i Z + } + }; + inline float4x4& Rotation(double angle,float3 axis); + inline bool IdentityIs() + {//sprawdzenie jednostkowości + for (int i=0;i<16;++i) + if (e[i]!=((i%5)?0.0:1.0)) //jedynki tylko na 0, 5, 10 i 15 + return false; + return true; + } + void __fastcall Quaternion(float4 *q); + inline float3* TranslationGet() + {return (float3*)(e+12);} +}; + +inline float3 operator*(const float4x4& m,const float3& v) +{//mnożenie wektora przez macierz + return float3( + v.x*m[0][0]+v.y*m[1][0]+v.z*m[2][0]+m[3][0], + v.x*m[0][1]+v.y*m[1][1]+v.z*m[2][1]+m[3][1], + v.x*m[0][2]+v.y*m[1][2]+v.z*m[2][2]+m[3][2] + ); +} + +inline float4x4& float4x4::Rotation(double angle,float3 axis) +{ + double c=cos(angle); + double s=sin(angle); + // One minus c (short name for legibility of formulai) + double omc=(1-c); + if (axis.Length()!=1.0f) axis=SafeNormalize(axis); + double x = axis.x; + double y = axis.y; + double z = axis.z; + double xs = x * s; + double ys = y * s; + double zs = z * s; + double xyomc = x * y * omc; + double xzomc = x * z * omc; + double yzomc = y * z * omc; + e[0] =x*x*omc+c; + e[1] =xyomc+zs; + e[2] =xzomc-ys; + e[3] =0; + e[4] =xyomc-zs; + e[5] =y*y*omc+c; + e[6] =yzomc+xs; + e[7] =0; + e[8] =xzomc+ys; + e[9] =yzomc-xs; + e[10]=z*z*omc+c; + e[11]=0; + e[12]=0; + e[13]=0; + e[14]=0; + e[15]=1; + return *this; +}; + +inline float4x4 operator*(const float4x4& m1, const float4x4& m2) +{//iloczyn macierzy + float4x4 retVal; + for (int x=0;x<4;++x) + for (int y=0;y<4;++y) + { + retVal(x)[y]=0; + for (int i=0;i<4;++i) + retVal(x)[y]+=m1[i][y]*m2[x][i]; + } + return retVal; +}; + +// From code in Graphics Gems; p. 766 +inline float Det2x2(float a,float b,float c,float d) +{//obliczenie wyznacznika macierzy 2×2 + return a*d-b*c; +}; + +inline float Det3x3(float a1,float a2,float a3, + float b1,float b2,float b3, + float c1,float c2,float c3) +{//obliczenie wyznacznika macierzy 3×3 + return + +a1*Det2x2(b2,b3,c2,c3) + -b1*Det2x2(a2,a3,c2,c3) + +c1*Det2x2(a2,a3,b2,b3); +}; + +float Det(const float4x4 &m) +{//obliczenie wyznacznika macierzy 4×4 + float a1=m[0][0],a2=m[1][0],a3=m[2][0],a4=m[3][0]; + float b1=m[0][1],b2=m[1][1],b3=m[2][1],b4=m[3][1]; + float c1=m[0][2],c2=m[1][2],c3=m[2][2],c4=m[3][2]; + float d1=m[0][3],d2=m[1][3],d3=m[2][3],d4=m[3][3]; + return + +a1*Det3x3(b2,b3,b4,c2,c3,c4,d2,d3,d4) + -b1*Det3x3(a2,a3,a4,c2,c3,c4,d2,d3,d4) + +c1*Det3x3(a2,a3,a4,b2,b3,b4,d2,d3,d4) + -d1*Det3x3(a2,a3,a4,b2,b3,b4,c2,c3,c4); +}; + +#endif diff --git a/Forth.cpp b/Forth.cpp new file mode 100644 index 00000000..30faf4ea --- /dev/null +++ b/Forth.cpp @@ -0,0 +1,45 @@ +//--------------------------------------------------------------------------- + +#include +#pragma hdrstop + +#include "Forth.h" + +//--------------------------------------------------------------------------- + +#pragma package(smart_init) + +/* Ra: Forth jest prostym językiem programowania, funkcjonującym na dosyć +niskim poziomie. Może być zarówno interpretowany jak i kompilowany, co +pozwala szybko działać skompilowanym programom, jak również wykonywać +polecenia wprowadzane z klawiatury. Za pomocą zdefiniowanych kompilatorów +można definiować nowe funkcje, można również tworzyć nowe struktury jezyka, +np. wykraczające poza dotychczasową składnię. Prostota i wydajność są okupione +nieco specyficzną składnią, wynikającą z użycia stosu do obliczeń (tzw. odwrotna +notacja polska). + +Forth ma być używany jako: + 1. Alternatywna postać eventów. Dotychczasowe eventy w sceneriach mogą być +traktowane jako funkcje języka Forth. Jednocześnie można uzyskać uelastycznienie +składni, poprzez np. połączenie w jednym wpisie różnych typów eventów wraz z +dodaniem warunków dostępnych tylko dla Multiple. Również można będzie używać +wyrażeń języka Forth, czyli dokonywać obliczeń. + 2. Jako docelowa postać schematów obwodów Ladder Diagram. Można zrobić tak, by +program źródłowy w Forth (przy pewnych ograniczeniach) był wyświetlany graficznie +jako Ladder Diagram. Jednocześnie graficzne modyfikacje schematu można by +przełożyć na postać tekstową Forth i skompilować na kod niskiego poziomu. + 3. Jako algorytm funkcjonowania AI, możliwy do zaprogramowania na zewnątzr EXE. +Każdy użytkownik będzie mógł swój własny styl jazdy. + 4. Jako algorytm sterowania ruchem (zależności na stacji). + 5. Jako AI stacji, zarządzające ruchem na stacji zależnie w czasie rzeczywistym. + +Względem pierwotnego języka Forth, użyty tutaj będzie miał pewne odstępstwa: + 1. Operacje na liczbach czterobajtowych float. Należy we własnym zakresie dbać +o zgodność użytych funkcji z typem argumentu na stosie. + 2. Jedynym typem całkowitym jest czterobajtowy int. + 3. Do wyszukiwania obiektów w scenerii po nazwie (torów, eventów), używane jest +drzewo zamiast listy. + +Wpisy w scenerii, przetwarzane jako komendy Forth, nie mogą używać średnika jako +separatora słów. Uniemożliwia to używanie średnika jako słowa. +*/ diff --git a/Forth.h b/Forth.h new file mode 100644 index 00000000..93a8d3e2 --- /dev/null +++ b/Forth.h @@ -0,0 +1,10 @@ +//--------------------------------------------------------------------------- + +#ifndef ForthH +#define ForthH +//--------------------------------------------------------------------------- + +class Forth +{//klasa obsługi języka +}; +#endif diff --git a/Gauge.cpp b/Gauge.cpp new file mode 100644 index 00000000..2358264d --- /dev/null +++ b/Gauge.cpp @@ -0,0 +1,217 @@ +//--------------------------------------------------------------------------- + +/* + MaSzyna EU07 locomotive simulator + Copyright (C) 2001-2004 Marcin Wozniak + +*/ + +#include "system.hpp" +#include "classes.hpp" +#pragma hdrstop + +#include "Timer.h" +#include "QueryParserComp.hpp" +#include "Model3d.h" +#include "Gauge.h" +#include "Console.h" + +__fastcall TGauge::TGauge() +{ + eType=gt_Unknown; + fFriction=0.0; + fDesiredValue=0.0; + fValue=0.0; + fOffset=0.0; + fScale=1.0; + fStepSize=5; + //iChannel=-1; //kanał analogowej komunikacji zwrotnej + SubModel=NULL; +}; + +__fastcall TGauge::~TGauge() +{ +}; + +void __fastcall TGauge::Clear() +{ + SubModel=NULL; + eType=gt_Unknown; + fValue=0; + fDesiredValue=0; +}; + +void __fastcall TGauge::Init(TSubModel *NewSubModel,TGaugeType eNewType,double fNewScale,double fNewOffset,double fNewFriction,double fNewValue) +{//ustawienie parametrów animacji submodelu + if (NewSubModel) + {//warunek na wszelki wypadek, gdyby się submodel nie podłączył + fFriction=fNewFriction; + fValue=fNewValue; + fOffset=fNewOffset; + fScale=fNewScale; + SubModel=NewSubModel; + eType=eNewType; + if (eType==gt_Digital) + { + TSubModel *sm=SubModel->ChildGet(); + do + {//pętla po submodelach potomnych i obracanie ich o kąt zależy od cyfry w (fValue) + if (sm->pName) + {//musi mieć niepustą nazwę + if ((*sm->pName)>='0') + if ((*sm->pName)<='9') + sm->WillBeAnimated(); //wyłączenie optymalizacji + } + sm=sm->NextGet(); + } while (sm); + } + else //a banan może być z optymalizacją? + NewSubModel->WillBeAnimated(); //wyłączenie ignowania jedynkowego transformu + } +}; + +bool __fastcall TGauge::Load(TQueryParserComp *Parser,TModel3d *md1,TModel3d *md2,double mul) +{ + AnsiString str1=Parser->GetNextSymbol(); + AnsiString str2=Parser->GetNextSymbol().LowerCase(); + double val3=Parser->GetNextSymbol().ToDouble()*mul; + double val4=Parser->GetNextSymbol().ToDouble(); + double val5=Parser->GetNextSymbol().ToDouble(); + TSubModel *sm=md1->GetFromName(str1.c_str()); + if (sm) //jeśli nie znaleziony + md2=NULL; //informacja, że znaleziony + else + if (md2) //a jest podany drugi model (np. zewnętrzny) + sm=md2->GetFromName(str1.c_str()); //to może tam będzie, co za różnica gdzie + if (str2=="mov") + Init(sm,gt_Move,val3,val4,val5); + else if (str2=="wip") + Init(sm,gt_Wiper,val3,val4,val5); + else if (str2=="dgt") + Init(sm,gt_Digital,val3,val4,val5); + else + Init(sm,gt_Rotate,val3,val4,val5); + return (md2); //true, gdy podany model zewnętrzny, a w kabinie nie było +}; + + +void __fastcall TGauge::PermIncValue(double fNewDesired) +{ + fDesiredValue=fDesiredValue+fNewDesired*fScale+fOffset; + if (fDesiredValue-fOffset>360/fScale) + { + fDesiredValue=fDesiredValue-(360/fScale); + fValue=fValue-(360/fScale); + } +}; + +void __fastcall TGauge::IncValue(double fNewDesired) +{//używane tylko dla uniwersali + fDesiredValue=fDesiredValue+fNewDesired*fScale+fOffset; + if (fDesiredValue>fScale+fOffset) + fDesiredValue=fScale+fOffset; +}; + +void __fastcall TGauge::DecValue(double fNewDesired) +{//używane tylko dla uniwersali + fDesiredValue=fDesiredValue-fNewDesired*fScale+fOffset; + if (fDesiredValue<0) fDesiredValue=0; +}; + +void __fastcall TGauge::UpdateValue(double fNewDesired) +{//ustawienie wartości docelowej + fDesiredValue=fNewDesired*fScale+fOffset; +}; + +void __fastcall TGauge::PutValue(double fNewDesired) +{//McZapkie-281102: natychmiastowe wpisanie wartosci + fDesiredValue=fNewDesired*fScale+fOffset; + fValue=fDesiredValue; +}; + +void __fastcall TGauge::Update() +{ + float dt=Timer::GetDeltaTime(); + if ((fFriction>0)&&(dt<0.5*fFriction)) //McZapkie-281102: zabezpieczenie przed oscylacjami dla dlugich czasow + fValue+=dt*(fDesiredValue-fValue)/fFriction; + else + fValue=fDesiredValue; + if (SubModel) + {//warunek na wszelki wypadek, gdyby się submodel nie podłączył + TSubModel *sm; + switch (eType) + { + case gt_Rotate: + SubModel->SetRotate(float3(0,1,0),fValue*360.0); + break; + case gt_Move: + SubModel->SetTranslate(float3(0,0,fValue)); + break; + case gt_Wiper: + SubModel->SetRotate(float3(0,1,0),fValue*360.0); + sm=SubModel->ChildGet(); + if (sm) + {sm->SetRotate(float3(0,1,0),fValue*360.0); + sm=sm->ChildGet(); + if (sm) + sm->SetRotate(float3(0,1,0),fValue*360.0); + } + break; + case gt_Digital: //Ra 2014-07: licznik cyfrowy + sm=SubModel->ChildGet(); + AnsiString n=FormatFloat("0000000000",floor(fValue)); //na razie tak trochę bez sensu + do + {//pętla po submodelach potomnych i obracanie ich o kąt zależy od cyfry w (fValue) + if (sm->pName) + {//musi mieć niepustą nazwę + if ((*sm->pName)>='0') + if ((*sm->pName)<='9') + sm->SetRotate(float3(0,1,0),-36.0*(n['0'+10-(*sm->pName)]-'0')); + } + sm=sm->NextGet(); + } while (sm); + break; + } + } +}; + +void __fastcall TGauge::Render() +{ +}; + +void __fastcall TGauge::AssignFloat(float* fValue) +{ + cDataType='f'; + fData=fValue; +}; +void __fastcall TGauge::AssignDouble(double* dValue) +{ + cDataType='d'; + dData=dValue; +}; +void __fastcall TGauge::AssignInt(int* iValue) +{ + cDataType='i'; + iData=iValue; +}; +void __fastcall TGauge::UpdateValue() +{//ustawienie wartości docelowej z parametru + switch (cDataType) + {//to nie jest zbyt optymalne, można by zrobić osobne funkcje + case 'f': + fDesiredValue=(*fData)*fScale+fOffset; + break; + case 'd': + fDesiredValue=(*dData)*fScale+fOffset; + break; + case 'i': + fDesiredValue=(*iData)*fScale+fOffset; + break; + } +}; + + + +//--------------------------------------------------------------------------- + +#pragma package(smart_init) diff --git a/Gauge.h b/Gauge.h new file mode 100644 index 00000000..69cd8924 --- /dev/null +++ b/Gauge.h @@ -0,0 +1,61 @@ +//--------------------------------------------------------------------------- + +#ifndef GaugeH +#define GaugeH + +//#include "Classes.h" +#include "QueryParserComp.hpp" +//class Queryparsercomp::TQueryParserComp; +class TSubModel; +class TModel3d; + +typedef enum +{//typ ruchu + gt_Unknown, //na razie nie znany + gt_Rotate, //obrót + gt_Move, //przesunięcie równoległe + gt_Wiper, //obrót trzech kolejnych submodeli o ten sam kąt (np. wycieraczka, drzwi harmonijkowe) + gt_Digital //licznik cyfrowy, np. kilometrów +} TGaugeType; + +class TGauge //zmienne "gg" +{//animowany wskaźnik, mogący przyjmować wiele stanów pośrednich +private: + TGaugeType eType; //typ ruchu + double fFriction; //hamowanie przy zliżaniu się do zadanej wartości + double fDesiredValue; //wartość docelowa + double fValue; //wartość obecna + double fOffset; //wartość początkowa ("0") + double fScale; //wartość końcowa ("1") + double fStepSize; //nie używane + char cDataType; //typ zmiennej parametru: f-float, d-double, i-int + union + {//wskaźnik na parametr pokazywany przez animację + float* fData; + double* dData; + int* iData; + }; +public: + __fastcall TGauge(); + __fastcall ~TGauge(); + void __fastcall Clear(); + void __fastcall Init(TSubModel *NewSubModel,TGaugeType eNewTyp,double fNewScale=1,double fNewOffset=0,double fNewFriction=0,double fNewValue=0); + bool __fastcall Load(TQueryParserComp *Parser,TModel3d *md1,TModel3d *md2=NULL,double mul=1.0); + void __fastcall PermIncValue(double fNewDesired); + void __fastcall IncValue(double fNewDesired); + void __fastcall DecValue(double fNewDesired); + void __fastcall UpdateValue(double fNewDesired); + void __fastcall PutValue(double fNewDesired); + float GetValue() {return fValue;}; + void __fastcall Update(); + void __fastcall Render(); + void __fastcall AssignFloat(float* fValue); + void __fastcall AssignDouble(double* dValue); + void __fastcall AssignInt(int* iValue); + void __fastcall UpdateValue(); + TSubModel *SubModel; //McZapkie-310302: zeby mozna bylo sprawdzac czy zainicjowany poprawnie +}; + +//--------------------------------------------------------------------------- +#endif + diff --git a/Geom.cpp b/Geom.cpp new file mode 100644 index 00000000..90926d31 --- /dev/null +++ b/Geom.cpp @@ -0,0 +1,119 @@ +//--------------------------------------------------------------------------- + +#include "system.hpp" +#include "classes.hpp" +#include +#include +#include "opengl/glut.h" +#pragma hdrstop + +#include "Texture.h" +#include "usefull.h" +#include "Globals.h" +#include "Geom.h" + + +__fastcall TGeometry::TGeometry() +{ +} + +__fastcall TGeometry::~TGeometry() +{ +} + +bool __fastcall TGeometry::Init() +{ +} + + +vector3 __fastcall TGeometry::Load(TQueryParserComp *Parser) +{ + str= Parser->GetNextSymbol().LowerCase(); + tmp->TextureID= TTexturesManager::GetTextureID(str.c_str()); + + i=0; + do + { + tf= Parser->GetNextSymbol().ToDouble(); + TempVerts[i].Point.x= tf; + tf= Parser->GetNextSymbol().ToDouble(); + TempVerts[i].Point.y= tf; + tf= Parser->GetNextSymbol().ToDouble(); + TempVerts[i].Point.z= tf; + tf= Parser->GetNextSymbol().ToDouble(); + TempVerts[i].Normal.x= tf; + tf= Parser->GetNextSymbol().ToDouble(); + TempVerts[i].Normal.y= tf; + tf= Parser->GetNextSymbol().ToDouble(); + TempVerts[i].Normal.z= tf; + + str= Parser->GetNextSymbol().LowerCase(); + if (str=="x") + TempVerts[i].tu= (TempVerts[i].Point.x+Parser->GetNextSymbol().ToDouble())/Parser->GetNextSymbol().ToDouble(); + else + if (str=="y") + TempVerts[i].tu= (TempVerts[i].Point.y+Parser->GetNextSymbol().ToDouble())/Parser->GetNextSymbol().ToDouble(); + else + if (str=="z") + TempVerts[i].tu= (TempVerts[i].Point.z+Parser->GetNextSymbol().ToDouble())/Parser->GetNextSymbol().ToDouble(); + else + TempVerts[i].tu= str.ToDouble();; + + str= Parser->GetNextSymbol().LowerCase(); + if (str=="x") + TempVerts[i].tv= (TempVerts[i].Point.x+Parser->GetNextSymbol().ToDouble())/Parser->GetNextSymbol().ToDouble(); + else + if (str=="y") + TempVerts[i].tv= (TempVerts[i].Point.y+Parser->GetNextSymbol().ToDouble())/Parser->GetNextSymbol().ToDouble(); + else + if (str=="z") + TempVerts[i].tv= (TempVerts[i].Point.z+Parser->GetNextSymbol().ToDouble())/Parser->GetNextSymbol().ToDouble(); + else + TempVerts[i].tv= str.ToDouble();; + +// tf= Parser->GetNextSymbol().ToDouble(); + // TempVerts[i].tu= tf; + // tf= Parser->GetNextSymbol().ToDouble(); + // TempVerts[i].tv= tf; + + TempVerts[i].Point.RotateZ(aRotate.z/180*M_PI); + TempVerts[i].Point.RotateX(aRotate.x/180*M_PI); + TempVerts[i].Point.RotateY(aRotate.y/180*M_PI); + TempVerts[i].Normal.RotateZ(aRotate.z/180*M_PI); + TempVerts[i].Normal.RotateX(aRotate.x/180*M_PI); + TempVerts[i].Normal.RotateY(aRotate.y/180*M_PI); + + TempVerts[i].Point+= pOrigin; + tmp->pCenter+= TempVerts[i].Point; + + i++; + +// } + } while ( Parser->GetNextSymbol().LowerCase()!="endtri" ); + + nv= i; + tmp->Init(nv); + tmp->pCenter/= (nv>0?nv:1); + +// memcpy(tmp->Vertices,TempVerts,nv*sizeof(TGroundVertex)); + + r= 0; + for (int i=0; iVertices[i]= TempVerts[i]; + tf= SquareMagnitude(tmp->Vertices[i].Point-tmp->pCenter); + if (tf>r) + r= tf; + } + +// tmp->fSquareRadius= 2000*2000+r; + tmp->fSquareRadius+= r; + +} + +bool __fastcall TGeometry::Render() +{ +} +//--------------------------------------------------------------------------- + +#pragma package(smart_init) diff --git a/Geom.h b/Geom.h new file mode 100644 index 00000000..24398462 --- /dev/null +++ b/Geom.h @@ -0,0 +1,38 @@ +//--------------------------------------------------------------------------- + +#ifndef GeomH +#define GeomH + +#include +#include "QueryParserComp.hpp" + +struct TGeomVertex +{ + vector3 Point; + vector3 Normal; + double tu,tv; +}; + +class TGeometry +{ +private: + GLuint iType; + union + { + int iNumVerts; + int iNumPts; + }; + GLuint TextureID; + TMaterialColor Ambient; + TMaterialColor Diffuse; + TMaterialColor Specular; +public: + __fastcall TGeometry(); + __fastcall ~TGeometry(); + bool __fastcall Init(); + vector3 __fastcall Load(TQueryParserComp *Parser); + bool __fastcall Render(); +}; + +//--------------------------------------------------------------------------- +#endif diff --git a/Globals.cpp b/Globals.cpp new file mode 100644 index 00000000..bd001006 --- /dev/null +++ b/Globals.cpp @@ -0,0 +1,778 @@ +//--------------------------------------------------------------------------- +/* + MaSzyna EU07 locomotive simulator + Copyright (C) 2001-2004 Marcin Wozniak, Maciej Czapkiewicz and others + +*/ + +#include "system.hpp" +#pragma hdrstop + + +#include "Globals.h" +#include "QueryParserComp.hpp" +#include "usefull.h" +#include "Mover.h" +#include "Driver.h" +#include "Console.h" +#include //do odczytu daty +#include "World.h" + + + +//namespace Global { + +//parametry do użytku wewnętrznego +//double Global::tSinceStart=0; +TGround *Global::pGround=NULL; +//char Global::CreatorName1[30]="2001-2004 Maciej Czapkiewicz "; +//char Global::CreatorName2[30]="2001-2003 Marcin Woźniak "; +//char Global::CreatorName3[20]="2004-2005 Adam Bugiel "; +//char Global::CreatorName4[30]="2004 Arkadiusz Ślusarczyk "; +//char Global::CreatorName5[30]="2003-2009 Łukasz Kirchner "; +AnsiString Global::asCurrentSceneryPath="scenery/"; +AnsiString Global::asCurrentTexturePath=AnsiString(szTexturePath); +AnsiString Global::asCurrentDynamicPath=""; +int Global::iSlowMotion=0; //info o malym FPS: 0-OK, 1-wyłączyć multisampling, 3-promień 1.5km, 7-1km +TDynamicObject *Global::changeDynObj=NULL; //info o zmianie pojazdu +bool Global::detonatoryOK; //info o nowych detonatorach +double Global::ABuDebug=0; +AnsiString Global::asSky="1"; +double Global::fOpenGL=0.0; //wersja OpenGL - do sprawdzania obecności rozszerzeń +bool Global::bOpenGL_1_5=false; //czy są dostępne funkcje OpenGL 1.5 +double Global::fLuminance=1.0; //jasność światła do automatycznego zapalania +int Global::iReCompile=0; //zwiększany, gdy trzeba odświeżyć siatki +HWND Global::hWnd=NULL; //uchwyt okna +int Global::iCameraLast=-1; +AnsiString Global::asRelease="15.3.1166.469"; +AnsiString Global::asVersion="Compilation 2015-03-25, release "+Global::asRelease+"."; //tutaj, bo wysyłany +int Global::iViewMode=0; //co aktualnie widać: 0-kabina, 1-latanie, 2-sprzęgi, 3-dokumenty +int Global::iTextMode=0; //tryb pracy wyświetlacza tekstowego +int Global::iScreenMode[12]={0,0,0,0,0,0,0,0,0,0,0,0}; //numer ekranu wyświetlacza tekstowego +double Global::fSunDeclination=0.0; //deklinacja Słońca +double Global::fTimeAngleDeg=0.0; //godzina w postaci kąta +float Global::fClockAngleDeg[6]; //kąty obrotu cylindrów dla zegara cyfrowego +char* Global::szTexturesTGA[4]={"tga","dds","tex","bmp"}; //lista tekstur od TGA +char* Global::szTexturesDDS[4]={"dds","tga","tex","bmp"}; //lista tekstur od DDS +int Global::iKeyLast=0; //ostatnio naciśnięty klawisz w celu logowania +GLuint Global::iTextureId=0; //ostatnio użyta tekstura 2D +int Global::iPause=0x10; //globalna pauza ruchu +bool Global::bActive=true; //czy jest aktywnym oknem +int Global::iErorrCounter=0; //licznik sprawdzań do śledzenia błędów OpenGL +int Global::iTextures=0; //licznik użytych tekstur +TWorld* Global::pWorld=NULL; +Queryparsercomp::TQueryParserComp *Global::qParser=NULL; +cParser *Global::pParser=NULL; +int Global::iSegmentsRendered=90; //ilość segmentów do regulacji wydajności +TCamera* Global::pCamera=NULL; //parametry kamery +TDynamicObject *Global::pUserDynamic=NULL; //pojazd użytkownika, renderowany bez trzęsienia +bool Global::bSmudge=false; //czy wyświetlać smugę, a pojazd użytkownika na końcu +AnsiString Global::asTranscript[5]; //napisy na ekranie (widoczne) +TTranscripts Global::tranTexts; //obiekt obsługujący stenogramy dźwięków na ekranie + +//parametry scenerii +vector3 Global::pCameraPosition; +double Global::pCameraRotation; +double Global::pCameraRotationDeg; +vector3 Global::pFreeCameraInit[10]; +vector3 Global::pFreeCameraInitAngle[10]; +double Global::fFogStart=1700; +double Global::fFogEnd=2000; +GLfloat Global::AtmoColor[]={0.423f,0.702f,1.0f}; +GLfloat Global::FogColor[]={0.6f,0.7f,0.8f}; +GLfloat Global::ambientDayLight[] ={0.40f,0.40f,0.45f,1.0f}; //robocze +GLfloat Global::diffuseDayLight[] ={0.55f,0.54f,0.50f,1.0f}; +GLfloat Global::specularDayLight[]={0.95f,0.94f,0.90f,1.0f}; +GLfloat Global::ambientLight[] ={0.80f,0.80f,0.85f,1.0f}; //stałe +GLfloat Global::diffuseLight[] ={0.85f,0.85f,0.80f,1.0f}; +GLfloat Global::specularLight[] ={0.95f,0.94f,0.90f,1.0f}; +GLfloat Global::whiteLight[] ={1.00f,1.00f,1.00f,1.0f}; +GLfloat Global::noLight[] ={0.00f,0.00f,0.00f,1.0f}; +GLfloat Global::darkLight[] ={0.03f,0.03f,0.03f,1.0f}; //śladowe +GLfloat Global::lightPos[4]; +bool Global::bRollFix=true; //czy wykonać przeliczanie przechyłki +bool Global::bJoinEvents=false; //czy grupować eventy o tych samych nazwach +int Global::iHiddenEvents=0; //czy łączyć eventy z torami poprzez nazwę toru + +//parametry użytkowe (jak komu pasuje) +int Global::Keys[MaxKeys]; +int Global::iWindowWidth=800; +int Global::iWindowHeight=600; +float Global::fDistanceFactor=768.0; //baza do przeliczania odległości dla LoD +int Global::iFeedbackMode=1; //tryb pracy informacji zwrotnej +int Global::iFeedbackPort=0; //dodatkowy adres dla informacji zwrotnych +bool Global::bFreeFly=false; +bool Global::bFullScreen=false; +bool Global::bInactivePause=true; //automatyczna pauza, gdy okno nieaktywne +float Global::fMouseXScale=1.5; +float Global::fMouseYScale=0.2; +char Global::szSceneryFile[256]="td.scn"; +AnsiString Global::asHumanCtrlVehicle="EU07-424"; +int Global::iMultiplayer=0; //blokada działania niektórych funkcji na rzecz komunikacji +double Global::fMoveLight=-1; //ruchome światło +double Global::fLatitudeDeg=52.0; //szerokość geograficzna +float Global::fFriction=1.0; //mnożnik tarcia - KURS90 +double Global::fBrakeStep=1.0; //krok zmiany hamulca dla klawiszy [Num3] i [Num9] +AnsiString Global::asLang="pl"; //domyślny język - http://tools.ietf.org/html/bcp47 + + +//parametry wydajnościowe (np. regulacja FPS, szybkość wczytywania) +bool Global::bAdjustScreenFreq=true; +bool Global::bEnableTraction=true; +bool Global::bLoadTraction=true; +bool Global::bLiveTraction=true; +int Global::iDefaultFiltering=9; //domyślne rozmywanie tekstur TGA bez alfa +int Global::iBallastFiltering=9; //domyślne rozmywanie tekstur podsypki +int Global::iRailProFiltering=5; //domyślne rozmywanie tekstur szyn +int Global::iDynamicFiltering=5; //domyślne rozmywanie tekstur pojazdów +bool Global::bUseVBO=false; //czy jest VBO w karcie graficznej (czy użyć) +GLint Global::iMaxTextureSize=16384; //maksymalny rozmiar tekstury +bool Global::bSmoothTraction=false; //wygładzanie drutów starym sposobem +char** Global::szDefaultExt=Global::szTexturesDDS; //domyślnie od DDS +int Global::iMultisampling=2; //tryb antyaliasingu: 0=brak,1=2px,2=4px,3=8px,4=16px +bool Global::bGlutFont=false; //czy tekst generowany przez GLUT32.DLL +int Global::iConvertModels=7; //tworzenie plików binarnych, +2-optymalizacja transformów +int Global::iSlowMotionMask=-1; //maska wyłączanych właściwości dla zwiększenia FPS +int Global::iModifyTGA=7; //czy korygować pliki TGA dla szybszego wczytywania +//bool Global::bTerrainCompact=true; //czy zapisać teren w pliku +TAnimModel *Global::pTerrainCompact=NULL; //do zapisania terenu w pliku +AnsiString Global::asTerrainModel=""; //nazwa obiektu terenu do zapisania w pliku +double Global::fFpsAverage=20.0; //oczekiwana wartosć FPS +double Global::fFpsDeviation=5.0; //odchylenie standardowe FPS +double Global::fFpsMin=0.0; //dolna granica FPS, przy której promień scenerii będzie zmniejszany +double Global::fFpsMax=0.0; //górna granica FPS, przy której promień scenerii będzie zwiększany +double Global::fFpsRadiusMax=3000.0; //maksymalny promień renderowania +int Global::iFpsRadiusMax=225; //maksymalny promień renderowania +double Global::fRadiusFactor=1.1; //współczynnik jednorazowej zmiany promienia scenerii + +//parametry testowe (do testowania scenerii i obiektów) +bool Global::bWireFrame=false; +bool Global::bSoundEnabled=true; +int Global::iWriteLogEnabled=3; //maska bitowa: 1-zapis do pliku, 2-okienko, 4-nazwy torów +bool Global::bManageNodes=true; +bool Global::bDecompressDDS=false; //czy programowa dekompresja DDS + +//parametry do kalibracji +//kolejno współczynniki dla potęg 0, 1, 2, 3 wartości odczytanej z urządzenia +double Global::fCalibrateIn[6][4]={{0,1,0,0},{0,1,0,0},{0,1,0,0},{0,1,0,0},{0,1,0,0},{0,1,0,0}}; +double Global::fCalibrateOut[7][4]={{0,1,0,0},{0,1,0,0},{0,1,0,0},{0,1,0,0},{0,1,0,0},{0,1,0,0},{0,1,0,0}}; + +//parametry przejściowe (do usunięcia) +//bool Global::bTimeChange=false; //Ra: ZiomalCl wyłączył starą wersję nocy +//bool Global::bRenderAlpha=true; //Ra: wywaliłam tę flagę +bool Global::bnewAirCouplers=true; +bool Global::bDoubleAmbient=false; //podwójna jasność ambient +double Global::fTimeSpeed=1.0; //przyspieszenie czasu, zmienna do testów +bool Global::bHideConsole=false; //hunter-271211: ukrywanie konsoli +int Global::iBpp=32; //chyba już nie używa się kart, na których 16bpp coś poprawi + +//--------------------------------------------------------------------------- +//--------------------------------------------------------------------------- +//--------------------------------------------------------------------------- + +AnsiString __fastcall Global::GetNextSymbol() +{//pobranie tokenu z aktualnego parsera + if (qParser) return qParser->EndOfFile?AnsiString("endconfig"):qParser->GetNextSymbol(); + if (pParser) + {std::string token; + pParser->getTokens(); + *pParser >> token; + return AnsiString(token.c_str()); + }; + return ""; +}; + +void __fastcall Global::LoadIniFile(AnsiString asFileName) +{ + int i; + for (i=0;i<10;++i) + {//zerowanie pozycji kamer + pFreeCameraInit[i]=vector3(0,0,0); //współrzędne w scenerii + pFreeCameraInitAngle[i]=vector3(0,0,0); //kąty obrotu w radianach + } + TFileStream *fs; + fs=new TFileStream(asFileName,fmOpenRead|fmShareCompat); + if (!fs) return; + AnsiString str=""; + int size=fs->Size; + str.SetLength(size); + fs->Read(str.c_str(),size); + //str+=""; + delete fs; + TQueryParserComp *Parser; + Parser=new TQueryParserComp(NULL); + Parser->TextToParse=str; + //Parser->LoadStringToParse(asFile); + Parser->First(); + ConfigParse(Parser); + delete Parser; //Ra: tego jak zwykle nie było wcześniej :] +}; + +void __fastcall Global::ConfigParse(TQueryParserComp *qp,cParser *cp) +{//Ra: trzeba by przerobić na cParser, żeby to działało w scenerii + pParser=cp; + qParser=qp; + AnsiString str; + int i; + do + { + str=GetNextSymbol().LowerCase(); + if (str==AnsiString("sceneryfile")) + { + str=GetNextSymbol().LowerCase(); + strcpy(szSceneryFile,str.c_str()); + } + else + if (str==AnsiString("humanctrlvehicle")) + { + str=GetNextSymbol().LowerCase(); + asHumanCtrlVehicle=str; + } + else if (str==AnsiString("width")) + iWindowWidth=GetNextSymbol().ToInt(); + else if (str==AnsiString("height")) + iWindowHeight=GetNextSymbol().ToInt(); + else if (str==AnsiString("heightbase")) + fDistanceFactor=GetNextSymbol().ToInt(); + else if (str==AnsiString("bpp")) + iBpp=((GetNextSymbol().LowerCase()==AnsiString("32")) ? 32 : 16 ); + else if (str==AnsiString("fullscreen")) + bFullScreen=(GetNextSymbol().LowerCase()==AnsiString("yes")); + else if (str==AnsiString("freefly")) //Mczapkie-130302 + { + bFreeFly=(GetNextSymbol().LowerCase()==AnsiString("yes")); + pFreeCameraInit[0].x=GetNextSymbol().ToDouble(); + pFreeCameraInit[0].y=GetNextSymbol().ToDouble(); + pFreeCameraInit[0].z=GetNextSymbol().ToDouble(); + } + else if (str==AnsiString("wireframe")) + bWireFrame=(GetNextSymbol().LowerCase()==AnsiString("yes")); + else if (str==AnsiString("debugmode")) //McZapkie! - DebugModeFlag uzywana w mover.pas, warto tez blokowac cheaty gdy false + DebugModeFlag=(GetNextSymbol().LowerCase()==AnsiString("yes")); + else if (str==AnsiString("soundenabled")) //McZapkie-040302 - blokada dzwieku - przyda sie do debugowania oraz na komp. bez karty dzw. + bSoundEnabled=(GetNextSymbol().LowerCase()==AnsiString("yes")); + //else if (str==AnsiString("renderalpha")) //McZapkie-1312302 - dwuprzebiegowe renderowanie + // bRenderAlpha=(GetNextSymbol().LowerCase()==AnsiString("yes")); + else if (str==AnsiString("physicslog")) //McZapkie-030402 - logowanie parametrow fizycznych dla kazdego pojazdu z maszynista + WriteLogFlag=(GetNextSymbol().LowerCase()==AnsiString("yes")); + else if (str==AnsiString("physicsdeactivation")) //McZapkie-291103 - usypianie fizyki + PhysicActivationFlag=(GetNextSymbol().LowerCase()==AnsiString("yes")); + else if (str==AnsiString("debuglog")) + {//McZapkie-300402 - wylaczanie log.txt + str=GetNextSymbol().LowerCase(); + if (str=="yes") iWriteLogEnabled=3; + else if (str=="no") iWriteLogEnabled=0; + else iWriteLogEnabled=str.ToIntDef(3); + } + else if (str==AnsiString("adjustscreenfreq")) + {//McZapkie-240403 - czestotliwosc odswiezania ekranu + str=GetNextSymbol(); + bAdjustScreenFreq=(str.LowerCase()==AnsiString("yes")); + } + else if (str==AnsiString("mousescale")) + {//McZapkie-060503 - czulosc ruchu myszy (krecenia glowa) + str=GetNextSymbol(); + fMouseXScale=str.ToDouble(); + str=GetNextSymbol(); + fMouseYScale=str.ToDouble(); + } + else if (str==AnsiString("enabletraction")) + {//Winger 040204 - 'zywe' patyki dostosowujace sie do trakcji; Ra 2014-03: teraz łamanie + bEnableTraction=(GetNextSymbol().LowerCase()==AnsiString("yes")); + } + else if (str==AnsiString("loadtraction")) + {//Winger 140404 - ladowanie sie trakcji + bLoadTraction=(GetNextSymbol().LowerCase()==AnsiString("yes")); + } + else if (str==AnsiString("friction")) //mnożnik tarcia - KURS90 + fFriction=GetNextSymbol().ToDouble(); + else if (str==AnsiString("livetraction")) + {//Winger 160404 - zaleznosc napiecia loka od trakcji; Ra 2014-03: teraz prąd przy braku sieci + bLiveTraction=(GetNextSymbol().LowerCase()==AnsiString("yes")); + } + else if (str==AnsiString("skyenabled")) + {//youBy - niebo + if (GetNextSymbol().LowerCase()==AnsiString("yes")) + asSky="1"; else asSky="0"; + } + else if (str==AnsiString("managenodes")) + { + bManageNodes=(GetNextSymbol().LowerCase()==AnsiString("yes")); + } + else if (str==AnsiString("decompressdds")) + { + bDecompressDDS=(GetNextSymbol().LowerCase()==AnsiString("yes")); + } +// ShaXbee - domyslne rozszerzenie tekstur + else if (str==AnsiString("defaultext")) + {str=GetNextSymbol().LowerCase(); //rozszerzenie + if (str=="tga") + szDefaultExt=szTexturesTGA; //domyślnie od TGA + //szDefaultExt=std::string(Parser->GetNextSymbol().LowerCase().c_str()); + } + else if (str==AnsiString("newaircouplers")) + bnewAirCouplers=(GetNextSymbol().LowerCase()==AnsiString("yes")); + else if (str==AnsiString("defaultfiltering")) + iDefaultFiltering=GetNextSymbol().ToIntDef(-1); + else if (str==AnsiString("ballastfiltering")) + iBallastFiltering=GetNextSymbol().ToIntDef(-1); + else if (str==AnsiString("railprofiltering")) + iRailProFiltering=GetNextSymbol().ToIntDef(-1); + else if (str==AnsiString("dynamicfiltering")) + iDynamicFiltering=GetNextSymbol().ToIntDef(-1); + else if (str==AnsiString("usevbo")) + bUseVBO=(GetNextSymbol().LowerCase()==AnsiString("yes")); + else if (str==AnsiString("feedbackmode")) + iFeedbackMode=GetNextSymbol().ToIntDef(1); //domyślnie 1 + else if (str==AnsiString("feedbackport")) + iFeedbackPort=GetNextSymbol().ToIntDef(0); //domyślnie 0 + else if (str==AnsiString("multiplayer")) + iMultiplayer=GetNextSymbol().ToIntDef(0); //domyślnie 0 + else if (str==AnsiString("maxtexturesize")) + {//wymuszenie przeskalowania tekstur + i=GetNextSymbol().ToIntDef(16384); //domyślnie duże + if (i<= 64) iMaxTextureSize= 64; else + if (i<= 128) iMaxTextureSize= 128; else + if (i<= 256) iMaxTextureSize= 256; else + if (i<= 512) iMaxTextureSize= 512; else + if (i<=1024) iMaxTextureSize=1024; else + if (i<=2048) iMaxTextureSize=2048; else + if (i<=4096) iMaxTextureSize=4096; else + if (i<=8192) iMaxTextureSize=8192; else + iMaxTextureSize=16384; + } + else if (str==AnsiString("doubleambient")) //podwójna jasność ambient + bDoubleAmbient=(GetNextSymbol().LowerCase()==AnsiString("yes")); + else if (str==AnsiString("movelight")) //numer dnia w roku albo -1 + {fMoveLight=GetNextSymbol().ToIntDef(-1); //numer dnia 1..365 + if (fMoveLight==0.0) + {//pobranie daty z systemu + unsigned short y,m,d; + TDate date=Now(); + date.DecodeDate(&y,&m,&d); + fMoveLight=(double)date-(double)TDate(y,1,1)+1; //numer bieżącego dnia w roku + } + if (fMoveLight>0.0) //tu jest nadal zwiększone o 1 + {//obliczenie deklinacji wg: + //http://naturalfrequency.com/Tregenza_Sharples/Daylight_Algorithms/algorithm_1_11.htm + //Spencer J W Fourier series representation of the position of the sun Search 2 (5) 172 (1971) + fMoveLight=M_PI/182.5*(Global::fMoveLight-1.0); //numer dnia w postaci kąta + fSunDeclination=0.006918-0.3999120*cos( fMoveLight)+0.0702570*sin( fMoveLight) + -0.0067580*cos(2*fMoveLight)+0.0009070*sin(2*fMoveLight) + -0.0026970*cos(3*fMoveLight)+0.0014800*sin(3*fMoveLight); + } + } + else if (str==AnsiString("smoothtraction")) //podwójna jasność ambient + bSmoothTraction=(GetNextSymbol().LowerCase()==AnsiString("yes")); + else if (str==AnsiString("timespeed")) //przyspieszenie czasu, zmienna do testów + fTimeSpeed=GetNextSymbol().ToIntDef(1); + else if (str==AnsiString("multisampling")) //tryb antyaliasingu: 0=brak,1=2px,2=4px + iMultisampling=GetNextSymbol().ToIntDef(2); //domyślnie 2 + else if (str==AnsiString("glutfont")) //tekst generowany przez GLUT + bGlutFont=(GetNextSymbol().LowerCase()==AnsiString("yes")); + else if (str==AnsiString("latitude")) //szerokość geograficzna + fLatitudeDeg=GetNextSymbol().ToDouble(); + else if (str==AnsiString("convertmodels")) //tworzenie plików binarnych + iConvertModels=GetNextSymbol().ToIntDef(7); //domyślnie 7 + else if (str==AnsiString("inactivepause")) //automatyczna pauza, gdy okno nieaktywne + bInactivePause=(GetNextSymbol().LowerCase()==AnsiString("yes")); + else if (str==AnsiString("slowmotion")) //tworzenie plików binarnych + iSlowMotionMask=GetNextSymbol().ToIntDef(-1); //domyślnie -1 + else if (str==AnsiString("modifytga")) //czy korygować pliki TGA dla szybszego wczytywania + iModifyTGA=GetNextSymbol().ToIntDef(0); //domyślnie 0 + else if (str==AnsiString("hideconsole")) //hunter-271211: ukrywanie konsoli + bHideConsole=(GetNextSymbol().LowerCase()==AnsiString("yes")); + else if (str==AnsiString("rollfix")) //Ra: poprawianie przechyłki, aby wewnętrzna szyna była "pozioma" + bRollFix=(GetNextSymbol().LowerCase()==AnsiString("yes")); + else if (str==AnsiString("fpsaverage")) //oczekiwana wartosć FPS + fFpsAverage=GetNextSymbol().ToDouble(); + else if (str==AnsiString("fpsdeviation")) //odchylenie standardowe FPS + fFpsDeviation=GetNextSymbol().ToDouble(); + else if (str==AnsiString("fpsradiusmax")) //maksymalny promień renderowania + fFpsRadiusMax=GetNextSymbol().ToDouble(); + else if (str==AnsiString("calibratein")) //parametry kalibracji wejść + {// + i=GetNextSymbol().ToIntDef(-1); //numer wejścia + if ((i<0)||(i>5)) i=5; //na ostatni, bo i tak trzeba pominąć wartości + fCalibrateIn[i][0]=GetNextSymbol().ToDouble(); //wyraz wolny + fCalibrateIn[i][1]=GetNextSymbol().ToDouble(); //mnożnik + fCalibrateIn[i][2]=GetNextSymbol().ToDouble(); //mnożnik dla kwadratu + fCalibrateIn[i][3]=GetNextSymbol().ToDouble(); //mnożnik dla sześcianu + } + else if (str==AnsiString("calibrateout")) //parametry kalibracji wyjść + {// + i=GetNextSymbol().ToIntDef(-1); //numer wejścia + if ((i<0)||(i>6)) i=6; //na ostatni, bo i tak trzeba pominąć wartości + fCalibrateOut[i][0]=GetNextSymbol().ToDouble(); //wyraz wolny + fCalibrateOut[i][1]=GetNextSymbol().ToDouble(); //mnożnik liniowy + fCalibrateOut[i][2]=GetNextSymbol().ToDouble(); //mnożnik dla kwadratu + fCalibrateOut[i][3]=GetNextSymbol().ToDouble(); //mnożnik dla sześcianu + } + else if (str==AnsiString("brakestep")) //krok zmiany hamulca dla klawiszy [Num3] i [Num9] + fBrakeStep=GetNextSymbol().ToDouble(); + else if (str==AnsiString("joinduplicatedevents")) //czy grupować eventy o tych samych nazwach + bJoinEvents=(GetNextSymbol().LowerCase()==AnsiString("yes")); + else if (str==AnsiString("hiddenevents")) //czy łączyć eventy z torami poprzez nazwę toru + iHiddenEvents=GetNextSymbol().ToIntDef(0); + else if (str==AnsiString("pause")) //czy po wczytaniu ma być pauza? + iPause|=(GetNextSymbol().LowerCase()==AnsiString("yes"))?1:0; + else if (str==AnsiString("lang")) + asLang=GetNextSymbol(); //domyślny język - http://tools.ietf.org/html/bcp47 + else if (str==AnsiString("opengl")) //deklarowana wersja OpenGL, żeby powstrzymać błędy + fOpenGL=GetNextSymbol().ToDouble(); //wymuszenie wersji OpenGL + } + while (str!="endconfig"); //(!Parser->EndOfFile) + //na koniec trochę zależności + if (!bLoadTraction) //wczytywanie drutów i słupów + {//tutaj wyłączenie, bo mogą nie być zdefiniowane w INI + bEnableTraction=false; //false = pantograf się nie połamie + bLiveTraction=false; //false = pantografy zawsze zbierają 95% MaxVoltage + } + //if (fMoveLight>0) bDoubleAmbient=false; //wtedy tylko jedno światło ruchome + //if (fOpenGL<1.3) iMultisampling=0; //można by z góry wyłączyć, ale nie mamy jeszcze fOpenGL + if (iMultisampling) + {//antyaliasing całoekranowy wyłącza rozmywanie drutów + bSmoothTraction=false; + } + if (iMultiplayer>0) + {bInactivePause=false; //okno "w tle" nie może pauzować, jeśli włączona komunikacja + //pauzowanie jest zablokowane dla (iMultiplayer&2)>0, więc iMultiplayer=1 da się zapauzować (tryb instruktora) + } + fFpsMin=fFpsAverage-fFpsDeviation; //dolna granica FPS, przy której promień scenerii będzie zmniejszany + fFpsMax=fFpsAverage+fFpsDeviation; //górna granica FPS, przy której promień scenerii będzie zwiększany + if (iPause) iTextMode=VK_F1; //jak pauza, to pokazać zegar + if (qp) + {//to poniżej wykonywane tylko raz, jedynie po wczytaniu eu07.ini + Console::ModeSet(iFeedbackMode,iFeedbackPort); //tryb pracy konsoli sterowniczej + iFpsRadiusMax=0.000025*fFpsRadiusMax*fFpsRadiusMax; //maksymalny promień renderowania 3000.0 -> 225 + if (iFpsRadiusMax>400) iFpsRadiusMax=400; + if (fDistanceFactor>1.0) + {//dla 1.0 specjalny tryb bez przeliczania + fDistanceFactor=iWindowHeight/fDistanceFactor; //fDistanceFactor>1.0 dla rozdzielczości większych niż bazowa + fDistanceFactor*=(iMultisampling+1.0)*fDistanceFactor; //do kwadratu, bo większość odległości to ich kwadraty + } + } +} + +void __fastcall Global::InitKeys(AnsiString asFileName) +{ +// if (FileExists(asFileName)) +// { +// Error("Chwilowo plik keys.ini nie jest obsługiwany. Ładuję standardowe ustawienia.\nKeys.ini file is temporarily not functional, loading default keymap..."); +/* TQueryParserComp *Parser; + Parser=new TQueryParserComp(NULL); + Parser->LoadStringToParse(asFileName); + + for (int keycount=0; keycountGetNextSymbol().ToInt(); + } + + delete Parser; +*/ +// } +// else + { + Keys[k_IncMainCtrl]=VK_ADD; + Keys[k_IncMainCtrlFAST]=VK_ADD; + Keys[k_DecMainCtrl]=VK_SUBTRACT; + Keys[k_DecMainCtrlFAST]=VK_SUBTRACT; + Keys[k_IncScndCtrl]=VK_DIVIDE; + Keys[k_IncScndCtrlFAST]=VK_DIVIDE; + Keys[k_DecScndCtrl]=VK_MULTIPLY; + Keys[k_DecScndCtrlFAST]=VK_MULTIPLY; +///*NORMALNE + Keys[k_IncLocalBrakeLevel]=VK_NUMPAD1; //VK_NUMPAD7; + //Keys[k_IncLocalBrakeLevelFAST]=VK_END; //VK_HOME; + Keys[k_DecLocalBrakeLevel]=VK_NUMPAD7; //VK_NUMPAD1; + //Keys[k_DecLocalBrakeLevelFAST]=VK_HOME; //VK_END; + Keys[k_IncBrakeLevel]=VK_NUMPAD3; //VK_NUMPAD9; + Keys[k_DecBrakeLevel]=VK_NUMPAD9; //VK_NUMPAD3; + Keys[k_Releaser]=VK_NUMPAD6; + Keys[k_EmergencyBrake]=VK_NUMPAD0; + Keys[k_Brake3]=VK_NUMPAD8; + Keys[k_Brake2]=VK_NUMPAD5; + Keys[k_Brake1]=VK_NUMPAD2; + Keys[k_Brake0]=VK_NUMPAD4; + Keys[k_WaveBrake]=VK_DECIMAL; +//*/ +/*MOJE + Keys[k_IncLocalBrakeLevel]=VK_NUMPAD3; //VK_NUMPAD7; + Keys[k_IncLocalBrakeLevelFAST]=VK_NUMPAD3; //VK_HOME; + Keys[k_DecLocalBrakeLevel]=VK_DECIMAL; //VK_NUMPAD1; + Keys[k_DecLocalBrakeLevelFAST]=VK_DECIMAL; //VK_END; + Keys[k_IncBrakeLevel]=VK_NUMPAD6; //VK_NUMPAD9; + Keys[k_DecBrakeLevel]=VK_NUMPAD9; //VK_NUMPAD3; + Keys[k_Releaser]=VK_NUMPAD5; + Keys[k_EmergencyBrake]=VK_NUMPAD0; + Keys[k_Brake3]=VK_NUMPAD2; + Keys[k_Brake2]=VK_NUMPAD1; + Keys[k_Brake1]=VK_NUMPAD4; + Keys[k_Brake0]=VK_NUMPAD7; + Keys[k_WaveBrake]=VK_NUMPAD8; +*/ + Keys[k_AntiSlipping]=VK_RETURN; + Keys[k_Sand]=VkKeyScan('s'); + Keys[k_Main]=VkKeyScan('m'); + Keys[k_Active]=VkKeyScan('w'); + Keys[k_Battery]=VkKeyScan('j'); + Keys[k_DirectionForward]=VkKeyScan('d'); + Keys[k_DirectionBackward]=VkKeyScan('r'); + Keys[k_Fuse]=VkKeyScan('n'); + Keys[k_Compressor]=VkKeyScan('c'); + Keys[k_Converter]=VkKeyScan('x'); + Keys[k_MaxCurrent]=VkKeyScan('f'); + Keys[k_CurrentAutoRelay]=VkKeyScan('g'); + Keys[k_BrakeProfile]=VkKeyScan('b'); + Keys[k_CurrentNext]=VkKeyScan('z'); + + Keys[k_Czuwak]=VkKeyScan(' '); + Keys[k_Horn]=VkKeyScan('a'); + Keys[k_Horn2]=VkKeyScan('a'); + + Keys[k_FailedEngineCutOff]=VkKeyScan('e'); + + Keys[k_MechUp]=VK_PRIOR; + Keys[k_MechDown]=VK_NEXT ; + Keys[k_MechLeft]=VK_LEFT ; + Keys[k_MechRight]=VK_RIGHT; + Keys[k_MechForward]=VK_UP; + Keys[k_MechBackward]=VK_DOWN; + + Keys[k_CabForward]=VK_HOME; + Keys[k_CabBackward]=VK_END; + + Keys[k_Couple]=VK_INSERT; + Keys[k_DeCouple]=VK_DELETE; + + Keys[k_ProgramQuit]=VK_F10; + //Keys[k_ProgramPause]=VK_F3; + Keys[k_ProgramHelp]=VK_F1; + //Keys[k_FreeFlyMode]=VK_F4; + Keys[k_WalkMode]=VK_F5; + + Keys[k_OpenLeft]=VkKeyScan(','); + Keys[k_OpenRight]=VkKeyScan('.'); + Keys[k_CloseLeft]=VkKeyScan(','); + Keys[k_CloseRight]=VkKeyScan('.'); + Keys[k_DepartureSignal]=VkKeyScan('/'); + +//Winger 160204 - obsluga pantografow + Keys[k_PantFrontUp]=VkKeyScan('p'); //Ra: zamieniony przedni z tylnym + Keys[k_PantFrontDown]=VkKeyScan('p'); + Keys[k_PantRearUp]=VkKeyScan('o'); + Keys[k_PantRearDown]=VkKeyScan('o'); +//Winger 020304 - ogrzewanie + Keys[k_Heating]=VkKeyScan('h'); + Keys[k_LeftSign]=VkKeyScan('y'); + Keys[k_UpperSign]=VkKeyScan('u'); + Keys[k_RightSign]=VkKeyScan('i'); + Keys[k_EndSign]=VkKeyScan('t'); + + Keys[k_SmallCompressor]=VkKeyScan('v'); + Keys[k_StLinOff]=VkKeyScan('l'); +//ABu 090305 - przyciski uniwersalne, do roznych bajerow :) + Keys[k_Univ1]=VkKeyScan('['); + Keys[k_Univ2]=VkKeyScan(']'); + Keys[k_Univ3]=VkKeyScan(';'); + Keys[k_Univ4]=VkKeyScan('\''); + } +} +/* +vector3 __fastcall Global::GetCameraPosition() +{ + return pCameraPosition; +} +*/ +void __fastcall Global::SetCameraPosition(vector3 pNewCameraPosition) +{ + pCameraPosition=pNewCameraPosition; +} + +void __fastcall Global::SetCameraRotation(double Yaw) +{//ustawienie bezwzględnego kierunku kamery z korekcją do przedziału <-M_PI,M_PI> + pCameraRotation=Yaw; + while (pCameraRotation<-M_PI) pCameraRotation+=2*M_PI; + while (pCameraRotation> M_PI) pCameraRotation-=2*M_PI; + pCameraRotationDeg=pCameraRotation*180.0/M_PI; +} + +void __fastcall Global::BindTexture(GLuint t) +{//ustawienie aktualnej tekstury, tylko gdy się zmienia + if (t!=iTextureId) + {iTextureId=t; + } +}; + +void __fastcall Global::TrainDelete(TDynamicObject *d) +{//usunięcie pojazdu prowadzonego przez użytkownika + if (pWorld) pWorld->TrainDelete(d); +}; + +TDynamicObject* __fastcall Global::DynamicNearest() +{//ustalenie pojazdu najbliższego kamerze + return pGround->DynamicNearest(pCamera->Pos); +}; + +TDynamicObject* __fastcall Global::CouplerNearest() +{//ustalenie pojazdu najbliższego kamerze + return pGround->CouplerNearest(pCamera->Pos); +}; + +bool __fastcall Global::AddToQuery(TEvent *event,TDynamicObject *who) +{ + return pGround->AddToQuery(event,who); +}; +//--------------------------------------------------------------------------- + +bool __fastcall Global::DoEvents() +{//wywoływać czasem, żeby nie robił wrażenia zawieszonego + MSG msg; + while (PeekMessage(&msg, NULL, 0, 0, PM_REMOVE)) + { + if (msg.message==WM_QUIT) + return FALSE; + TranslateMessage(&msg); + DispatchMessage(&msg); + } + return TRUE; +} +//--------------------------------------------------------------------------- + +__fastcall TTranscripts::TTranscripts() +{ + iCount=0; //brak linijek do wyświetlenia + iStart=0; //wypełniać od linijki 0 + for (int i=0;i=0)?(aLines[aLines[i].iNext].fShow<=show):false) //póki nie koniec i wcześniej puszczane + i=aLines[i].iNext; //przejście do kolejnej linijki + //(i) wskazuje na linię, po której należy wstawić dany tekst, chyba że + while (txt?*txt:false) + for (j=0;j0) + {//jak jest podział linijki na wiersze + aLines[j].asText=aLines[j].asText.SubString(1,k-1); + txt+=k; + i=j; //kolejna linijka dopisywana będzie na koniec właśnie dodanej + } + else + txt=NULL; //koniec dodawania + if (fRefreshTime>show) //jeśli odświeżacz ustawiony jest na później + fRefreshTime=show; //to odświeżyć wcześniej + break; //więcej już nic + } +}; +void __fastcall TTranscripts::Add(char *txt,float len,bool backgorund) +{//dodanie tekstów, długość dźwięku, czy istotne + if (!txt) return; //pusty tekst + int i=0,j=int(0.5+10.0*len); //[0.1s] + if (*txt=='[') + {//powinny być dwa nawiasy + while (*++txt?*txt!=']':false) + if ((*txt>='0')&&(*txt<='9')) + i=10*i+int(*txt-'0'); //pierwsza liczba aż do ] + if (*txt?*++txt=='[':false) + {j=0; //drugi nawias określa czas zakończenia wyświetlania + while (*++txt?*txt!=']':false) + if ((*txt>='0')&&(*txt<='9')) + j=10*j+int(*txt-'0'); //druga liczba aż do ] + if (*txt) ++txt; //pominięcie drugiego ] + } + } + AddLine(txt,0.1*i,0.1*j,false); +}; +void __fastcall TTranscripts::Update() +{//usuwanie niepotrzebnych (nie częściej niż 10 razy na sekundę) + if (fRefreshTime>Global::fTimeAngleDeg) + return; //nie czas jeszcze na zmiany + //czas odświeżenia można ustalić wg tabelki, kiedy coś się w niej zmienia + fRefreshTime=Global::fTimeAngleDeg+360.0; //wartość zaporowa + int i=iStart,j=-1; //od czegoś trzeba zacząć + bool change=false; //czy zmieniać napisy? + do + { + if (aLines[i].fHide>=0.0) //o ile aktywne + if (aLines[i].fHide=0?aLines[i].iNext:0; //przestawienie pierwszego + else if (j>=0) + aLines[j].iNext=aLines[i].iNext; //usunięcie ze środka + change=true; + } + else + {//gdy ma być pokazane + if (aLines[i].fShow>Global::fTimeAngleDeg) //będzie pokazane w przyszłości + if (fRefreshTime>aLines[i].fShow) //a nie ma nic wcześniej + fRefreshTime=aLines[i].fShow; + if (fRefreshTime>aLines[i].fHide) + fRefreshTime=aLines[i].fHide; + } + //można by jeszcze wykrywać, które nowe mają być pokazane + j=i; + i=aLines[i].iNext; //kolejna linijka + } while (i>=0); //póki po tablicy + change=true; //bo na razie nie ma warunku, że coś się dodało + if (change) + {//aktualizacja linijek ekranowych + i=iStart; j=-1; + do + { + if (aLines[i].fHide>0.0) //jeśli nie ukryte + if (aLines[i].fShow=0); //póki po tablicy + for (++j;j<5;++j) + Global::asTranscript[j]=""; //i czyszczenie nieużywanych linijek + } +}; + +//Ra: tymczasowe rozwiązanie kwestii zagranicznych (czeskich) napisów +char bezogonkowo[128]= + "E?,?\"_++?%Sstzz" + " ^^L$A|S^CS<--RZo±,l'uP.,as>L\"lz" + "RAAAALCCCEEEEIIDDNNOOOOxRUUUUYTB" + "raaaalccceeeeiiddnnoooo-ruuuuyt?"; + +AnsiString __fastcall Global::Bezogonkow(AnsiString str, bool _) +{//wycięcie liter z ogonkami, bo OpenGL nie umie wyświetlić + for (int i=1;i<=str.Length();++i) + if (str[i]&0x80) + str[i]=bezogonkowo[str[i]&0x7F]; + else if (str[i]<' ') //znaki sterujące nie są obsługiwane + str[i]=' '; + else if (_) if (str[i]=='_') //nazwy stacji nie mogą zawierać spacji + str[i]=' '; //więc trzeba wyświetlać inaczej + return str; +} + +#pragma package(smart_init) diff --git a/Globals.h b/Globals.h new file mode 100644 index 00000000..58096103 --- /dev/null +++ b/Globals.h @@ -0,0 +1,306 @@ +//--------------------------------------------------------------------------- + +#ifndef GlobalsH +#define GlobalsH + +#include +#include "system.hpp" +#include "opengl/glew.h" +#include "dumb3d.h" +//#include "Classes.h" + +using namespace Math3D; + +//definicje klawiszy +const int k_IncMainCtrl= 0; //[Num+] +const int k_IncMainCtrlFAST= 1; //[Num+] [Shift] +const int k_DecMainCtrl= 2; //[Num-] +const int k_DecMainCtrlFAST= 3; //[Num-] [Shift] +const int k_IncScndCtrl= 4; //[Num/] +const int k_IncScndCtrlFAST= 5; +const int k_DecScndCtrl= 6; +const int k_DecScndCtrlFAST= 7; +const int k_IncLocalBrakeLevel= 8; +const int k_IncLocalBrakeLevelFAST= 9; +const int k_DecLocalBrakeLevel=10 ; +const int k_DecLocalBrakeLevelFAST= 11; +const int k_IncBrakeLevel= 12; +const int k_DecBrakeLevel= 13; +const int k_Releaser= 14; +const int k_EmergencyBrake= 15; +const int k_Brake3= 16; +const int k_Brake2= 17; +const int k_Brake1= 18; +const int k_Brake0= 19; +const int k_WaveBrake= 20; +const int k_AntiSlipping= 21; +const int k_Sand= 22; + +const int k_Main= 23; +const int k_DirectionForward= 24; +const int k_DirectionBackward= 25; + +const int k_Fuse= 26; +const int k_Compressor= 27; +const int k_Converter= 28; +const int k_MaxCurrent= 29; +const int k_CurrentAutoRelay= 30; +const int k_BrakeProfile= 31; + +const int k_Czuwak= 32; +const int k_Horn= 33; +const int k_Horn2= 34; + +const int k_FailedEngineCutOff= 35; + +const int k_MechUp= 36; +const int k_MechDown= 37; +const int k_MechLeft= 38; +const int k_MechRight= 39; +const int k_MechForward= 40; +const int k_MechBackward= 41; + +const int k_CabForward= 42; +const int k_CabBackward= 43; + +const int k_Couple= 44; +const int k_DeCouple= 45; + +const int k_ProgramQuit= 46; +//const int k_ProgramPause= 47; +const int k_ProgramHelp= 48; + //NBMX +const int k_OpenLeft= 49; +const int k_OpenRight= 50; +const int k_CloseLeft= 51; +const int k_CloseRight= 52; +const int k_DepartureSignal= 53; + //NBMX +const int k_PantFrontUp= 54; +const int k_PantRearUp= 55; +const int k_PantFrontDown= 56; +const int k_PantRearDown= 57; + +const int k_Heating= 58; + +//const int k_FreeFlyMode= 59; + +const int k_LeftSign = 60; +const int k_UpperSign= 61; +const int k_RightSign= 62; + +const int k_SmallCompressor= 63; + +const int k_StLinOff= 64; + +const int k_CurrentNext=65; + +const int k_Univ1=66; +const int k_Univ2=67; +const int k_Univ3=68; +const int k_Univ4=69; +const int k_EndSign=70; + +const int k_Active=71; + //Winger 020304 +const int k_Battery=72; +const int k_WalkMode=73; +const int MaxKeys= 74; + +//klasy dla wskaźników globalnych +class TGround; +class TWorld; +class TCamera; +class TDynamicObject; +class TAnimModel; //obiekt terenu +namespace Queryparsercomp +{ +class TQueryParserComp; //stary(?) parser +} +class cParser; //nowy (powolny!) parser +class TEvent; +class TTextSound; + +class TTranscript +{//klasa obsługująca linijkę napisu do dźwięku +public: + float fShow; //czas pokazania + float fHide; //czas ukrycia/usunięcia + AnsiString asText; //tekst gotowy do wyświetlenia (usunięte znaczniki czasu) + bool bItalic; //czy kursywa (dźwięk nieistotny dla prowadzącego) + int iNext; //następna używana linijka, żeby nie przestawiać fizycznie tabeli +}; + +#define MAX_TRANSCRIPTS 30 +class TTranscripts +{//klasa obsługująca napisy do dźwięków + TTranscript aLines[MAX_TRANSCRIPTS]; //pozycje na napisy do wyświetlenia + int iCount; //liczba zajętych pozycji + int iStart; //pierwsza istotna pozycja w tabeli, żeby sortować przestawiając numerki + float fRefreshTime; +public: + __fastcall TTranscripts(); + __fastcall ~TTranscripts(); + void __fastcall AddLine(char *txt,float show,float hide,bool it); + void __fastcall Add(char *txt,float len,bool backgorund=false); //dodanie tekstów, długość dźwięku, czy istotne + void __fastcall Update(); //usuwanie niepotrzebnych (ok. 10 razy na sekundę) +}; + +class Global +{ +private: + static GLuint iTextureId; //ostatnio użyta tekstura 2D +public: + //double Global::tSinceStart; + static int Keys[MaxKeys]; + static vector3 pCameraPosition; //pozycja kamery w świecie + static double pCameraRotation; //kierunek bezwzględny kamery w świecie: 0=północ, 90°=zachód (-azymut) + static double pCameraRotationDeg; //w stopniach, dla animacji billboard + static vector3 pFreeCameraInit[10]; //pozycje kamery + static vector3 pFreeCameraInitAngle[10]; + static int iWindowWidth; + static int iWindowHeight; + static float fDistanceFactor; + static int iBpp; + static bool bFullScreen; + static bool bFreeFly; + //float RunningTime; + static bool bWireFrame; + static bool bSoundEnabled; + //McZapkie-131202 + //static bool bRenderAlpha; + static bool bAdjustScreenFreq; + static bool bEnableTraction; + static bool bLoadTraction; + static float fFriction; + static bool bLiveTraction; + static bool bManageNodes; + static bool bDecompressDDS; + // bool WFreeFly; + static float Global::fMouseXScale; + static float Global::fMouseYScale; + static double fFogStart; + static double fFogEnd; + static TGround *pGround; + static char** szDefaultExt; + static char szSceneryFile[256]; + static char CreatorName1[20]; + static char CreatorName2[20]; + static char CreatorName3[20]; + static char CreatorName4[30]; + static char CreatorName5[30]; + static AnsiString asCurrentSceneryPath; + static AnsiString asCurrentTexturePath; + static AnsiString asCurrentDynamicPath; + //McZapkie-170602: zewnetrzna definicja pojazdu uzytkownika + static AnsiString asHumanCtrlVehicle; + static void __fastcall LoadIniFile(AnsiString asFileName); + static void __fastcall InitKeys(AnsiString asFileName); + inline static vector3 __fastcall GetCameraPosition() + {return pCameraPosition;}; + static void __fastcall SetCameraPosition(vector3 pNewCameraPosition); + static void __fastcall SetCameraRotation(double Yaw); + static int iWriteLogEnabled; //maska bitowa: 1-zapis do pliku, 2-okienko + //McZapkie-221002: definicja swiatla dziennego + static GLfloat AtmoColor[]; + static GLfloat FogColor[]; + //static bool bTimeChange; + static GLfloat ambientDayLight[]; + static GLfloat diffuseDayLight[]; + static GLfloat specularDayLight[]; + static GLfloat ambientLight[]; + static GLfloat diffuseLight[]; + static GLfloat specularLight[]; + static GLfloat whiteLight[]; + static GLfloat noLight[]; + static GLfloat darkLight[]; + static GLfloat lightPos[4]; + static int iSlowMotion; + static TDynamicObject *changeDynObj; + static double ABuDebug; + static bool detonatoryOK; + static AnsiString asSky; + static bool bnewAirCouplers; + //Ra: nowe zmienne globalne + static int iDefaultFiltering; //domyślne rozmywanie tekstur TGA + static int iBallastFiltering; //domyślne rozmywanie tekstury podsypki + static int iRailProFiltering; //domyślne rozmywanie tekstury szyn + static int iDynamicFiltering; //domyślne rozmywanie tekstur pojazdów + static int iReCompile; //zwiększany, gdy trzeba odświeżyć siatki + static bool bUseVBO; //czy jest VBO w karcie graficznej + static int iFeedbackMode; //tryb pracy informacji zwrotnej + static int iFeedbackPort; //dodatkowy adres dla informacji zwrotnych + static double fOpenGL; //wersja OpenGL - przyda się + static bool bOpenGL_1_5; //czy są dostępne funkcje OpenGL 1.5 + static double fLuminance; //jasność światła do automatycznego zapalania + static int iMultiplayer; //blokada działania niektórych eventów na rzecz kominikacji + static HWND hWnd; //uchwyt okna + static int iCameraLast; + static AnsiString asRelease; //numer + static AnsiString asVersion; //z opisem + static int iViewMode; //co aktualnie widać: 0-kabina, 1-latanie, 2-sprzęgi, 3-dokumenty, 4-obwody + static GLint iMaxTextureSize; //maksymalny rozmiar tekstury + static int iTextMode; //tryb pracy wyświetlacza tekstowego + static int iScreenMode[12]; //numer ekranu wyświetlacza tekstowego + static bool bDoubleAmbient; //podwójna jasność ambient + static double fMoveLight; //numer dnia w roku albo -1 + static bool bSmoothTraction; //wygładzanie drutów + static double fSunDeclination; //deklinacja Słońca + static double fTimeSpeed; //przyspieszenie czasu, zmienna do testów + static double fTimeAngleDeg; //godzina w postaci kąta + static float fClockAngleDeg[6]; //kąty obrotu cylindrów dla zegara cyfrowego + static double fLatitudeDeg; //szerokość geograficzna + static char* szTexturesTGA[4]; //lista tekstur od TGA + static char* szTexturesDDS[4]; //lista tekstur od DDS + static int iMultisampling; //tryb antyaliasingu: 0=brak,1=2px,2=4px,3=8px,4=16px + static bool bGlutFont; //tekst generowany przez GLUT + static int iKeyLast; //ostatnio naciśnięty klawisz w celu logowania + static int iPause; //globalna pauza ruchu: b0=start,b1=klawisz,b2=tło,b3=lagi,b4=wczytywanie + static bool bActive; //czy jest aktywnym oknem + static void __fastcall BindTexture(GLuint t); + static int iConvertModels; //tworzenie plików binarnych + static int iErorrCounter; //licznik sprawdzań do śledzenia błędów OpenGL + static bool bInactivePause; //automatyczna pauza, gdy okno nieaktywne + static int iTextures; //licznik użytych tekstur + static int iSlowMotionMask; //maska wyłączanych właściwości + static int iModifyTGA; //czy korygować pliki TGA dla szybszego wczytywania + static bool bHideConsole; //hunter-271211: ukrywanie konsoli + static TWorld *pWorld; //wskaźnik na świat do usuwania pojazdów + static TAnimModel *pTerrainCompact; //obiekt terenu do ewentualnego zapisania w pliku + static AnsiString asTerrainModel; //nazwa obiektu terenu do zapisania w pliku + static bool bRollFix; //czy wykonać przeliczanie przechyłki + static Queryparsercomp::TQueryParserComp *qParser; + static cParser *pParser; + static int iSegmentsRendered; //ilość segmentów do regulacji wydajności + static double fFpsAverage; //oczekiwana wartosć FPS + static double fFpsDeviation; //odchylenie standardowe FPS + static double fFpsMin; //dolna granica FPS, przy której promień scenerii będzie zmniejszany + static double fFpsMax; //górna granica FPS, przy której promień scenerii będzie zwiększany + static double fFpsRadiusMax; //maksymalny promień renderowania + static int iFpsRadiusMax; //maksymalny promień renderowania w rozmiarze tabeli sektorów + static double fRadiusFactor; //współczynnik zmiany promienia + static TCamera *pCamera; //parametry kamery + static TDynamicObject *pUserDynamic; //pojazd użytkownika, renderowany bez trzęsienia + static double fCalibrateIn[6][4]; //parametry kalibracyjne wejść z pulpitu + static double fCalibrateOut[7][4]; //parametry kalibracyjne wyjść dla pulpitu + static double fBrakeStep; //krok zmiany hamulca dla klawiszy [Num3] i [Num9] + static bool bJoinEvents; //czy grupować eventy o tych samych nazwach + static bool bSmudge; //czy wyświetlać smugę, a pojazd użytkownika na końcu + static AnsiString asTranscript[5]; //napisy na ekranie (widoczne) + static TTranscripts tranTexts; //obiekt obsługujący stenogramy dźwięków na ekranie + static AnsiString asLang; //domyślny język - http://tools.ietf.org/html/bcp47 + static int iHiddenEvents; //czy łączyć eventy z torami poprzez nazwę toru + static TTextSound *tsRadioBusy[10]; //zajętość kanałów radiowych (wskaźnik na odgrywany dźwięk) + //metody + static void __fastcall TrainDelete(TDynamicObject *d); + static void __fastcall ConfigParse(Queryparsercomp::TQueryParserComp *qp,cParser *cp=NULL); + static AnsiString __fastcall GetNextSymbol(); + static TDynamicObject* __fastcall DynamicNearest(); + static TDynamicObject* __fastcall CouplerNearest(); + static bool __fastcall AddToQuery(TEvent *event,TDynamicObject *who); + static bool __fastcall DoEvents(); + static AnsiString __fastcall Bezogonkow(AnsiString str, bool _=false); +}; + +//--------------------------------------------------------------------------- +#endif diff --git a/Ground.cpp b/Ground.cpp new file mode 100644 index 00000000..e35864a3 --- /dev/null +++ b/Ground.cpp @@ -0,0 +1,4511 @@ +//--------------------------------------------------------------------------- + +/* + MaSzyna EU07 locomotive simulator + Copyright (C) 2001-2004 Marcin Wozniak and others + +*/ + +#include "system.hpp" +#include "classes.hpp" + +#include "opengl/glew.h" +#include "opengl/glut.h" + +#pragma hdrstop + +#include "Timer.h" +#include "Texture.h" +#include "Ground.h" +#include "Globals.h" +#include "Event.h" +#include "EvLaunch.h" +#include "TractionPower.h" +#include "Traction.h" +#include "Track.h" +#include "RealSound.h" +#include "AnimModel.h" +#include "MemCell.h" +#include "mtable.hpp" +#include "DynObj.h" +#include "Data.h" +#include "parser.h" //Tolaris-010603 +#include "Driver.h" +#include "Console.h" +#include "Names.h" + + +#define _PROBLEND 1 +//--------------------------------------------------------------------------- +#pragma package(smart_init) + + +bool bCondition; //McZapkie: do testowania warunku na event multiple +AnsiString LogComment; + +//--------------------------------------------------------------------------- +// Obiekt renderujący siatkę jest sztucznie tworzonym obiektem pomocniczym, +// grupującym siatki obiektów dla danej tekstury. Obiektami składowymi mogą +// byc trójkąty terenu, szyny, podsypki, a także proste modele np. słupy. +// Obiekty składowe dodane są do listy TSubRect::nMeshed z listą zrobioną na +// TGroundNode::nNext3, gdzie są posortowane wg tekstury. Obiekty renderujące +// są wpisane na listę TSubRect::nRootMesh (TGroundNode::nNext2) oraz na +// odpowiednie listy renderowania, gdzie zastępują obiekty składowe (nNext3). +// Problematyczne są tory/drogi/rzeki, gdzie używane sa 2 tekstury. Dlatego +// tory są zdublowane jako TP_TRACK oraz TP_DUMMYTRACK. Jeśli tekstura jest +// tylko jedna (np. zwrotnice), nie jest używany TP_DUMMYTRACK. +//--------------------------------------------------------------------------- +__fastcall TGroundNode::TGroundNode() +{//nowy obiekt terenu - pusty + iType=GL_POINTS; + Vertices=NULL; + nNext=nNext2=NULL; + pCenter=vector3(0,0,0); + iCount=0; //wierzchołków w trójkącie + //iNumPts=0; //punktów w linii + TextureID=0; + iFlags=0; //tryb przezroczystości nie zbadany + DisplayListID=0; + Pointer=NULL; //zerowanie wskaźnika kontekstowego + bVisible=false; //czy widoczny + fSquareRadius=10000*10000; + fSquareMinRadius=0; + asName=""; + //Color= TMaterialColor(1); + //fAngle=0; //obrót dla modelu + //fLineThickness=1.0; //mm dla linii + for (int i=0;i<3;i++) + { + Ambient[i]=Global::whiteLight[i]*255; + Diffuse[i]=Global::whiteLight[i]*255; + Specular[i]=Global::noLight[i]*255; + } + nNext3=NULL; //nie wyświetla innych + iVboPtr=-1; //indeks w VBO sektora (-1: nie używa VBO) + iVersion=0; //wersja siatki +} + +__fastcall TGroundNode::~TGroundNode() +{ + //if (iFlags&0x200) //czy obiekt został utworzony? + switch (iType) + {case TP_MEMCELL: SafeDelete(MemCell); break; + case TP_EVLAUNCH: SafeDelete(EvLaunch); break; + case TP_TRACTION: SafeDelete(hvTraction); break; + case TP_TRACTIONPOWERSOURCE: + SafeDelete(psTractionPowerSource); break; + case TP_TRACK: SafeDelete(pTrack); break; + case TP_DYNAMIC: SafeDelete(DynamicObject); break; + case TP_MODEL: + if (iFlags&0x200) //czy model został utworzony? + delete Model; + Model=NULL; + break; + case TP_TERRAIN: + {//pierwsze nNode zawiera model E3D, reszta to trójkąty + for (int i=1;iVertices=NULL; //zerowanie wskaźników w kolejnych elementach, bo nie są do usuwania + delete[] nNode; //usunięcie tablicy i pierwszego elementu + } + case TP_SUBMODEL: //dla formalności, nie wymaga usuwania + break; + case GL_LINES: + case GL_LINE_STRIP: + case GL_LINE_LOOP: + SafeDeleteArray(Points); + break; + case GL_TRIANGLE_STRIP: + case GL_TRIANGLE_FAN: + case GL_TRIANGLES: + SafeDeleteArray(Vertices); + break; + } +} + +void __fastcall TGroundNode::Init(int n) +{//utworzenie tablicy wierzchołków + bVisible=false; + iNumVerts=n; + Vertices=new TGroundVertex[iNumVerts]; +} + +__fastcall TGroundNode::TGroundNode(TGroundNodeType t,int n) +{//utworzenie obiektu + TGroundNode(); //domyślne ustawienia + iNumVerts=n; + if (iNumVerts) Vertices=new TGroundVertex[iNumVerts]; + iType=t; + switch (iType) + {//zależnie od typu + case TP_TRACK: + pTrack=new TTrack(this); + break; + } +} + +void __fastcall TGroundNode::InitCenter() +{//obliczenie środka ciężkości obiektu + for (int i=0;ipPoint1+=pPosition; + hvTraction->pPoint2+=pPosition; + hvTraction->pPoint3+=pPosition; + hvTraction->pPoint4+=pPosition; + hvTraction->Optimize(); + break; + case TP_MODEL: + case TP_DYNAMIC: + case TP_MEMCELL: + case TP_EVLAUNCH: + break; + case TP_TRACK: + pTrack->MoveMe(pPosition); + break; + case TP_SOUND: //McZapkie - dzwiek zapetlony w zaleznosci od odleglosci + tsStaticSound->vSoundPosition+=pPosition; + break; + case GL_LINES: + case GL_LINE_STRIP: + case GL_LINE_LOOP: + for (int i=0; ifSquareRadius || (mgnRaRenderVBO(iVboPtr); return; + case TP_MODEL: Model->RenderVBO(&pCenter); return; + //case TP_SOUND: //McZapkie - dzwiek zapetlony w zaleznosci od odleglosci + // if ((pStaticSound->GetStatus()&DSBSTATUS_PLAYING)==DSBPLAY_LOOPING) + // { + // pStaticSound->Play(1,DSBPLAY_LOOPING,true,pStaticSound->vSoundPosition); + // pStaticSound->AdjFreq(1.0,Timer::GetDeltaTime()); + // } + // return; //Ra: TODO sprawdzić, czy dźwięki nie są tylko w RenderHidden + case TP_MEMCELL: return; + case TP_EVLAUNCH: + if (EvLaunch->Render()) + if ((EvLaunch->dRadius<0)||(mgndRadius)) + { + if (Console::Pressed(VK_SHIFT) && EvLaunch->Event2!=NULL) + Global::AddToQuery(EvLaunch->Event2,NULL); + else + if (EvLaunch->Event1!=NULL) + Global::AddToQuery(EvLaunch->Event1,NULL); + } + return; + case GL_LINES: + case GL_LINE_STRIP: + case GL_LINE_LOOP: + if (iNumPts) + {float linealpha=255000*fLineThickness/(mgn+1.0); + if (linealpha>255) linealpha=255; + float r,g,b; + r=floor(Diffuse[0]*Global::ambientDayLight[0]); //w zaleznosci od koloru swiatla + g=floor(Diffuse[1]*Global::ambientDayLight[1]); + b=floor(Diffuse[2]*Global::ambientDayLight[2]); + glColor4ub(r,g,b,linealpha); //przezroczystosc dalekiej linii + //glDisable(GL_LIGHTING); //nie powinny świecić + glDrawArrays(iType,iVboPtr,iNumPts); //rysowanie linii + //glEnable(GL_LIGHTING); + } + return; + default: + if (iVboPtr>=0) + RaRenderVBO(); + }; + return; +}; + +void __fastcall TGroundNode::RenderAlphaVBO() +{//renderowanie obiektu z VBO - faza przezroczystych + double mgn=SquareMagnitude(pCenter-Global::pCameraPosition); + float r,g,b; + if (mgnfSquareRadius) return; + int i,a; +#ifdef _PROBLEND + if ((PROBLEND)) // sprawdza, czy w nazwie nie ma @ //Q: 13122011 - Szociu: 27012012 + { + glDisable(GL_BLEND); + glAlphaFunc(GL_GREATER,0.45); // im mniejsza wartość, tym większa ramka, domyślnie 0.1f + }; +#endif + switch (iType) + { + case TP_TRACTION: + if (bVisible) + { +#ifdef _PROBLEND + glEnable(GL_BLEND); + glAlphaFunc(GL_GREATER,0.04); + glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA); +#endif + hvTraction->RenderVBO(mgn,iVboPtr); + } + return; + case TP_MODEL: +#ifdef _PROBLEND + glEnable(GL_BLEND); + glAlphaFunc(GL_GREATER,0.04); + glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA); +#endif + Model->RenderAlphaVBO(&pCenter); + return; + case GL_LINES: + case GL_LINE_STRIP: + case GL_LINE_LOOP: + if (iNumPts) + {float linealpha=255000*fLineThickness/(mgn+1.0); + if (linealpha>255) linealpha=255; + r=Diffuse[0]*Global::ambientDayLight[0]; //w zaleznosci od koloru swiatla + g=Diffuse[1]*Global::ambientDayLight[1]; + b=Diffuse[2]*Global::ambientDayLight[2]; + glColor4ub(r,g,b,linealpha); //przezroczystosc dalekiej linii + //glDisable(GL_LIGHTING); //nie powinny świecić + glDrawArrays(iType,iVboPtr,iNumPts); //rysowanie linii + //glEnable(GL_LIGHTING); +#ifdef _PROBLEND + glEnable(GL_BLEND); + glAlphaFunc(GL_GREATER,0.04); + glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA); +#endif + } +#ifdef _PROBLEND + glEnable(GL_BLEND); + glAlphaFunc(GL_GREATER,0.04); + glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA); +#endif + return; + default: + if (iVboPtr>=0) + {RaRenderVBO(); +#ifdef _PROBLEND + glEnable(GL_BLEND); + glAlphaFunc(GL_GREATER,0.04); + glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA); +#endif + return; + } + } +#ifdef _PROBLEND + glEnable(GL_BLEND); + glAlphaFunc(GL_GREATER,0.04); + glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA); +#endif + return; +} + +void __fastcall TGroundNode::Compile(bool many) +{//tworzenie skompilowanej listy w wyświetlaniu DL + if (!many) + {//obsługa pojedynczej listy + if (DisplayListID) Release(); + if (Global::bManageNodes) + { + DisplayListID=glGenLists(1); + glNewList(DisplayListID,GL_COMPILE); + iVersion=Global::iReCompile; //aktualna wersja siatek (do WireFrame) + } + } + if ((iType==GL_LINES)||(iType==GL_LINE_STRIP)||(iType==GL_LINE_LOOP)) + { +#ifdef USE_VERTEX_ARRAYS + glVertexPointer(3,GL_DOUBLE,sizeof(vector3),&Points[0].x); +#endif + glBindTexture(GL_TEXTURE_2D,0); +#ifdef USE_VERTEX_ARRAYS + glDrawArrays(iType,0,iNumPts); +#else + glBegin(iType); + for (int i=0;iVertices[0].Point.x); + glNormalPointer(GL_DOUBLE, sizeof(TGroundVertex), &tri->Vertices[0].Normal.x); + glTexCoordPointer(2, GL_FLOAT, sizeof(TGroundVertex), &tri->Vertices[0].tu); +#endif + glColor3ub(tri->Diffuse[0],tri->Diffuse[1],tri->Diffuse[2]); + glBindTexture(GL_TEXTURE_2D,Global::bWireFrame?0:tri->TextureID); +#ifdef USE_VERTEX_ARRAYS + glDrawArrays(Global::bWireFrame?GL_LINE_LOOP:tri->iType,0,tri->iNumVerts); +#else + glBegin(Global::bWireFrame?GL_LINE_LOOP:tri->iType); + for (int i=0;iiNumVerts;i++) + { + glNormal3d(tri->Vertices[i].Normal.x,tri->Vertices[i].Normal.y,tri->Vertices[i].Normal.z); + glTexCoord2f(tri->Vertices[i].tu,tri->Vertices[i].tv); + glVertex3dv(&tri->Vertices[i].Point.x); + }; + glEnd(); +#endif +/* + if (tri->pTriGroup) //jeśli z grupy + {tri=tri->pNext2; //następny w sektorze + while (tri?!tri->pTriGroup:false) tri=tri->pNext2; //szukamy kolejnego należącego do grupy + } + else +*/ + tri=NULL; //a jak nie, to koniec + } while (tri); + } + else if (iType==TP_MESH) + {//grupa ze wspólną teksturą - wrzucanie do wspólnego Display List + if (TextureID) + glBindTexture(GL_TEXTURE_2D,TextureID); // Ustaw aktywną teksturę + TGroundNode *n=nNode; + while (n?n->TextureID==TextureID:false) + {//wszystkie obiekty o tej samej testurze + switch (n->iType) + {//poszczególne typy różnie się tworzy + case TP_TRACK: + case TP_DUMMYTRACK: + n->pTrack->Compile(TextureID); //dodanie trójkątów dla podanej tekstury + break; + } + n=n->nNext3; //następny z listy + } + } + if (!many) + if (Global::bManageNodes) + glEndList(); +}; + +void TGroundNode::Release() +{ + if (DisplayListID) + glDeleteLists(DisplayListID,1); + DisplayListID=0; +}; + +void __fastcall TGroundNode::RenderHidden() +{//renderowanie obiektów niewidocznych + double mgn=SquareMagnitude(pCenter-Global::pCameraPosition); + switch (iType) + { + case TP_SOUND: //McZapkie - dzwiek zapetlony w zaleznosci od odleglosci + if ((tsStaticSound->GetStatus()&DSBSTATUS_PLAYING)==DSBPLAY_LOOPING) + { + tsStaticSound->Play(1,DSBPLAY_LOOPING,true,tsStaticSound->vSoundPosition); + tsStaticSound->AdjFreq(1.0,Timer::GetDeltaTime()); + } + return; + case TP_EVLAUNCH: + if (EvLaunch->Render()) + if ((EvLaunch->dRadius<0)||(mgndRadius)) + { + WriteLog("Eventlauncher "+asName); + if (Console::Pressed(VK_SHIFT)&&(EvLaunch->Event2)) + Global::AddToQuery(EvLaunch->Event2,NULL); + else + if (EvLaunch->Event1) + Global::AddToQuery(EvLaunch->Event1,NULL); + } + return; + } +}; + +void __fastcall TGroundNode::RenderDL() +{//wyświetlanie obiektu przez Display List + switch (iType) + {//obiekty renderowane niezależnie od odległości + case TP_SUBMODEL: + TSubModel::fSquareDist=0; + return smTerrain->RenderDL(); + } + //if (pTriGroup) if (pTriGroup!=this) return; //wyświetla go inny obiekt + double mgn=SquareMagnitude(pCenter-Global::pCameraPosition); + if ((mgn>fSquareRadius)||(mgnRender(); + case TP_MODEL: + return Model->RenderDL(&pCenter); + } + // TODO: sprawdzic czy jest potrzebny warunek fLineThickness < 0 + //if ((iNumVerts&&(iFlags&0x10))||(iNumPts&&(fLineThickness<0))) + if ((iFlags&0x10)||(fLineThickness<0)) + { + if (!DisplayListID||(iVersion!=Global::iReCompile)) //Ra: wymuszenie rekompilacji + { + Compile(); + if (Global::bManageNodes) + ResourceManager::Register(this); + }; + + if ((iType==GL_LINES)||(iType==GL_LINE_STRIP)||(iType==GL_LINE_LOOP)) + //if (iNumPts) + {//wszelkie linie są rysowane na samym końcu + float r,g,b; + r=Diffuse[0]*Global::ambientDayLight[0]; //w zaleznosci od koloru swiatla + g=Diffuse[1]*Global::ambientDayLight[1]; + b=Diffuse[2]*Global::ambientDayLight[2]; + glColor4ub(r,g,b,1.0); + glCallList(DisplayListID); + //glColor4fv(Diffuse); //przywrócenie koloru + //glColor3ub(Diffuse[0],Diffuse[1],Diffuse[2]); + } + // GL_TRIANGLE etc + else + glCallList(DisplayListID); + SetLastUsage(Timer::GetSimulationTime()); + }; +}; + +void __fastcall TGroundNode::RenderAlphaDL() +{ +// SPOSOB NA POZBYCIE SIE RAMKI DOOKOLA TEXTURY ALPHA DLA OBIEKTOW ZAGNIEZDZONYCH W SCN JAKO NODE + +//W GROUND.H dajemy do klasy TGroundNode zmienna bool PROBLEND to samo robimy w klasie TGround +//nastepnie podczas wczytywania textury dla TRIANGLES w TGround::AddGroundNode +//sprawdzamy czy w nazwie jest @ i wg tego +//ustawiamy PROBLEND na true dla wlasnie wczytywanego trojkata (kazdy trojkat jest osobnym nodem) +//nastepnie podczas renderowania w bool __fastcall TGroundNode::RenderAlpha() +//na poczatku ustawiamy standardowe GL_GREATER = 0.04 +//pozniej sprawdzamy czy jest wlaczony PROBLEND dla aktualnie renderowanego noda TRIANGLE, wlasciwie dla kazdego node'a +//i jezeli tak to odpowiedni GL_GREATER w przeciwnym wypadku standardowy 0.04 + + + //if (pTriGroup) if (pTriGroup!=this) return; //wyświetla go inny obiekt + double mgn=SquareMagnitude(pCenter-Global::pCameraPosition); + float r,g,b; + if (mgnfSquareRadius) + return; + int i,a; + switch (iType) + { + case TP_TRACTION: + if (bVisible) + hvTraction->RenderDL(mgn); + return; + case TP_MODEL: + Model->RenderAlphaDL(&pCenter); + return; + case TP_TRACK: + //pTrack->RenderAlpha(); + return; + }; + + // TODO: sprawdzic czy jest potrzebny warunek fLineThickness < 0 + if ( + (iNumVerts && (iFlags&0x20)) || + (iNumPts && (fLineThickness > 0))) + { +#ifdef _PROBLEND + if ((PROBLEND) ) // sprawdza, czy w nazwie nie ma @ //Q: 13122011 - Szociu: 27012012 + { + glDisable(GL_BLEND); + glAlphaFunc(GL_GREATER,0.45); // im mniejsza wartość, tym większa ramka, domyślnie 0.1f + }; +#endif + if (!DisplayListID) //||Global::bReCompile) //Ra: wymuszenie rekompilacji + { + Compile(); + if (Global::bManageNodes) + ResourceManager::Register(this); + }; + + // GL_LINE, GL_LINE_STRIP, GL_LINE_LOOP + if (iNumPts) + { + float linealpha=255000*fLineThickness/(mgn+1.0); + if (linealpha>255) + linealpha= 255; + r=Diffuse[0]*Global::ambientDayLight[0]; //w zaleznosci od koloru swiatla + g=Diffuse[1]*Global::ambientDayLight[1]; + b=Diffuse[2]*Global::ambientDayLight[2]; + glColor4ub(r,g,b,linealpha); //przezroczystosc dalekiej linii + glCallList(DisplayListID); + } + // GL_TRIANGLE etc + else + glCallList(DisplayListID); + SetLastUsage(Timer::GetSimulationTime()); + }; +#ifdef _PROBLEND + if ((PROBLEND)) // sprawdza, czy w nazwie nie ma @ //Q: 13122011 - Szociu: 27012012 + {glEnable(GL_BLEND); + glAlphaFunc(GL_GREATER,0.04); + glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA); + }; +#endif +} + +//------------------------------------------------------------------------------ +//------------------ Podstawowy pojemnik terenu - sektor ----------------------- +//------------------------------------------------------------------------------ +__fastcall TSubRect::TSubRect() +{ + nRootNode=NULL; //lista wszystkich obiektów jest pusta + nRenderHidden=nRenderRect=nRenderRectAlpha=nRender=nRenderMixed=nRenderAlpha=nRenderWires=NULL; + tTrackAnim=NULL; //nic nie animujemy + tTracks=NULL; //nie ma jeszcze torów + nRootMesh=nMeshed=NULL; //te listy też są puste + iNodeCount=0; //licznik obiektów + iTracks=0; //licznik torów +} +__fastcall TSubRect::~TSubRect() +{ + if (Global::bManageNodes) //Ra: tu się coś sypie + ResourceManager::Unregister(this); //wyrejestrowanie ze sprzątacza + //TODO: usunąć obiekty z listy (nRootMesh), bo są one tworzone dla sektora +} + +void __fastcall TSubRect::NodeAdd(TGroundNode *Node) +{//przyczepienie obiektu do sektora, wstępna kwalifikacja na listy renderowania + if (!this) return; //zabezpiecznie przed obiektami przekraczającymi obszar roboczy + //Ra: sortowanie obiektów na listy renderowania: + //nRenderHidden - lista obiektów niewidocznych, "renderowanych" również z tyłu + //nRenderRect - lista grup renderowanych z sektora + //nRenderRectAlpha - lista grup renderowanych z sektora z przezroczystością + //nRender - lista grup renderowanych z własnych VBO albo DL + //nRenderAlpha - lista grup renderowanych z własnych VBO albo DL z przezroczystością + //nRenderWires - lista grup renderowanych z własnych VBO albo DL - druty i linie + //nMeshed - obiekty do pogrupowania wg tekstur + GLuint t; //pomocniczy kod tekstury + switch (Node->iType) + {case TP_SOUND: //te obiekty są sprawdzanie niezależnie od kierunku patrzenia + case TP_EVLAUNCH: + Node->nNext3=nRenderHidden; nRenderHidden=Node; //do listy koniecznych + break; + case TP_TRACK: //TODO: tory z cieniem (tunel, canyon) też dać bez łączenia? + ++iTracks; //jeden tor więcej + Node->pTrack->RaOwnerSet(this); //do którego sektora ma zgłaszać animację + //if (Global::bUseVBO?false:!Node->pTrack->IsGroupable()) + if (Global::bUseVBO?true:!Node->pTrack->IsGroupable()) //TODO: tymczasowo dla VBO wyłączone + RaNodeAdd(Node); //tory ruchome nie są grupowane przy Display Lists (wymagają odświeżania DL) + else + {//tory nieruchome mogą być pogrupowane wg tekstury, przy VBO wszystkie + Node->TextureID=Node->pTrack->TextureGet(0); //pobranie tekstury do sortowania + t=Node->pTrack->TextureGet(1); + if (Node->TextureID) //jeżeli jest pierwsza + {if (t&&(Node->TextureID!=t)) + {//jeśli są dwie różne tekstury, dodajemy drugi obiekt dla danego toru + TGroundNode *n=new TGroundNode(); + n->iType=TP_DUMMYTRACK; //obiekt renderujący siatki dla tekstury + n->TextureID=t; + n->pTrack=Node->pTrack; //wskazuje na ten sam tor + n->pCenter=Node->pCenter; + n->fSquareRadius=Node->fSquareRadius; + n->fSquareMinRadius=Node->fSquareMinRadius; + n->iFlags=Node->iFlags; + n->nNext2=nRootMesh; nRootMesh=n; //podczepienie do listy, żeby usunąć na końcu + n->nNext3=nMeshed; nMeshed=n; + } + } + else + Node->TextureID=t; //jest tylko druga tekstura + if (Node->TextureID) + {Node->nNext3=nMeshed; nMeshed=Node;} //do podzielenia potem + } + break; + case GL_TRIANGLE_STRIP: + case GL_TRIANGLE_FAN: + case GL_TRIANGLES: + //Node->nNext3=nMeshed; nMeshed=Node; //do podzielenia potem + if (Node->iFlags&0x20) //czy jest przezroczyste? + {Node->nNext3=nRenderRectAlpha; nRenderRectAlpha=Node;} //DL: do przezroczystych z sektora + else + if (Global::bUseVBO) + {Node->nNext3=nRenderRect; nRenderRect=Node;} //VBO: do nieprzezroczystych z sektora + else + {Node->nNext3=nRender; nRender=Node;} //DL: do nieprzezroczystych wszelakich +/* + //Ra: na razie wyłączone do testów VBO + //if ((Node->iType==GL_TRIANGLE_STRIP)||(Node->iType==GL_TRIANGLE_FAN)||(Node->iType==GL_TRIANGLES)) + if (Node->fSquareMinRadius==0.0) //znikające z bliska nie mogą być optymalizowane + if (Node->fSquareRadius>=160000.0) //tak od 400m to już normalne trójkąty muszą być + //if (Node->iFlags&0x10) //i nieprzezroczysty + {if (pTriGroup) //jeżeli był już jakiś grupujący + {if (pTriGroup->fSquareRadius>Node->fSquareRadius) //i miał większy zasięg + Node->fSquareRadius=pTriGroup->fSquareRadius; //zwiększenie zakresu widoczności grupującego + pTriGroup->pTriGroup=Node; //poprzedniemu doczepiamy nowy + } + Node->pTriGroup=Node; //nowy lider ma się sam wyświetlać - wskaźnik na siebie + pTriGroup=Node; //zapamiętanie lidera + } +*/ + break; + case TP_TRACTION: + case GL_LINES: + case GL_LINE_STRIP: + case GL_LINE_LOOP: //te renderowane na końcu, żeby nie łapały koloru nieba + Node->nNext3=nRenderWires; nRenderWires=Node; //lista drutów + break; + case TP_MODEL: //modele zawsze wyświetlane z własnego VBO + //jeśli model jest prosty, można próbować zrobić wspólną siatkę (słupy) + if ((Node->iFlags&0x20200020)==0) //czy brak przezroczystości? + {Node->nNext3=nRender; nRender=Node;} //do nieprzezroczystych + else if ((Node->iFlags&0x10100010)==0) //czy brak nieprzezroczystości? + {Node->nNext3=nRenderAlpha; nRenderAlpha=Node;} //do przezroczystych + else //jak i take i takie, to będzie dwa razy renderowane... + {Node->nNext3=nRenderMixed; nRenderMixed=Node;} //do mieszanych + //Node->nNext3=nMeshed; //dopisanie do listy sortowania + //nMeshed=Node; + break; + case TP_MEMCELL: + case TP_TRACTIONPOWERSOURCE: //a te w ogóle pomijamy +// case TP_ISOLATED: //lista torów w obwodzie izolowanym - na razie ignorowana + break; + case TP_DYNAMIC: + return; //tych nie dopisujemy wcale + } + Node->nNext2=nRootNode; //dopisanie do ogólnej listy + nRootNode=Node; + ++iNodeCount; //licznik obiektów +} + +void __fastcall TSubRect::RaNodeAdd(TGroundNode *Node) +{//finalna kwalifikacja na listy renderowania, jeśli nie obsługiwane grupowo + switch (Node->iType) + {case TP_TRACK: + if (Global::bUseVBO) + {Node->nNext3=nRenderRect; nRenderRect=Node;} //VBO: do nieprzezroczystych z sektora + else + {Node->nNext3=nRender; nRender=Node;} //DL: do nieprzezroczystych + break; + case GL_TRIANGLE_STRIP: + case GL_TRIANGLE_FAN: + case GL_TRIANGLES: + if (Node->iFlags&0x20) //czy jest przezroczyste? + {Node->nNext3=nRenderRectAlpha; nRenderRectAlpha=Node;} //DL: do przezroczystych z sektora + else + if (Global::bUseVBO) + {Node->nNext3=nRenderRect; nRenderRect=Node;} //VBO: do nieprzezroczystych z sektora + else + {Node->nNext3=nRender; nRender=Node;} //DL: do nieprzezroczystych wszelakich + break; + case TP_MODEL: //modele zawsze wyświetlane z własnego VBO + if ((Node->iFlags&0x20200020)==0) //czy brak przezroczystości? + {Node->nNext3=nRender; nRender=Node;} //do nieprzezroczystych + else if ((Node->iFlags&0x10100010)==0) //czy brak nieprzezroczystości? + {Node->nNext3=nRenderAlpha; nRenderAlpha=Node;} //do przezroczystych + else //jak i take i takie, to będzie dwa razy renderowane... + {Node->nNext3=nRenderMixed; nRenderMixed=Node;} //do mieszanych + break; + case TP_MESH: //grupa ze wspólną teksturą + //{Node->nNext3=nRenderRect; nRenderRect=Node;} //do nieprzezroczystych z sektora + {Node->nNext3=nRender; nRender=Node;} //do nieprzezroczystych + break; + case TP_SUBMODEL: //submodele terenu w kwadracie kilometrowym idą do nRootMesh + //WriteLog("nRootMesh was "+AnsiString(nRootMesh?"not null ":"null ")+IntToHex(int(this),8)); + Node->nNext3=nRootMesh; //przy VBO musi być inaczej + nRootMesh=Node; + break; + } +} + +void __fastcall TSubRect::Sort() +{//przygotowanie sektora do renderowania + TGroundNode **n0,*n1,*n2; //wskaźniki robocze + delete[] tTracks; //usunięcie listy + tTracks=iTracks?new TTrack*[iTracks]:NULL; //tworzenie tabeli torów do renderowania pojazdów + if (tTracks) + {//wypełnianie tabeli torów + int i=0; + for (n1=nRootNode;n1;n1=n1->nNext2) //kolejne obiekty z sektora + if (n1->iType==TP_TRACK) + tTracks[i++]=n1->pTrack; + } + //sortowanie obiektów w sektorze na listy renderowania + if (!nMeshed) return; //nie ma nic do sortowania + bool sorted=false; + while (!sorted) + {//sortowanie bąbelkowe obiektów wg tekstury + sorted=true; //zakładamy posortowanie + n0=&nMeshed; //wskaźnik niezbędny do zamieniania obiektów + n1=nMeshed; //lista obiektów przetwarzanych na statyczne siatki + while (n1) + {//sprawdzanie stanu posortowania obiektów i ewentualne zamiany + n2=n1->nNext3; //kolejny z tej listy + if (n2) //jeśli istnieje + if (n1->TextureID>n2->TextureID) + {//zamiana elementów miejscami + *n0=n2; //drugi będzie na początku + n1->nNext3=n2->nNext3; //ten zza drugiego będzie za pierwszym + n2->nNext3=n1; //a za drugim będzie pierwszy + sorted=false; //potrzebny kolejny przebieg + } + n0=&(n1->nNext3); + n1=n2; + }; + } + //wyrzucenie z listy obiektów pojedynczych (nie ma z czym ich grupować) + //nawet jak są pojedyncze, to i tak lepiej, aby były w jednym Display List +/* + else + {//dodanie do zwykłej listy renderowania i usunięcie z grupowego + *n0=n2; //drugi będzie na początku + RaNodeAdd(n1); //nie ma go z czym zgrupować; (n1->nNext3) zostanie nadpisane + n1=n2; //potrzebne do ustawienia (n0) + } +*/ + //... + //przeglądanie listy i tworzenie obiektów renderujących dla danej tekstury + GLuint t=0; //pomocniczy kod tekstury + n1=nMeshed; //lista obiektów przetwarzanych na statyczne siatki + while (n1) + {//dla każdej tekstury powinny istnieć co najmniej dwa obiekty, ale dla DL nie ma to znaczenia + if (tTextureID) //jeśli (n1) ma inną teksturę niż poprzednie + {//można zrobić obiekt renderujący + t=n1->TextureID; + n2=new TGroundNode(); + n2->nNext2=nRootMesh; nRootMesh=n2; //podczepienie na początku listy + nRootMesh->iType=TP_MESH; //obiekt renderujący siatki dla tekstury + nRootMesh->TextureID=t; + nRootMesh->nNode=n1; //pierwszy element z listy + nRootMesh->pCenter=n1->pCenter; + nRootMesh->fSquareRadius=1e8; //widać bez ograniczeń + nRootMesh->fSquareMinRadius=0.0; + nRootMesh->iFlags=0x10; + RaNodeAdd(nRootMesh); //dodanie do odpowiedniej listy renderowania + } + n1=n1->nNext3; //kolejny z tej listy + }; +} + +TTrack* __fastcall TSubRect::FindTrack(vector3 *Point,int &iConnection,TTrack *Exclude) +{//szukanie toru, którego koniec jest najbliższy (*Point) + TTrack *Track; + for (int i=0;iTestPoint(Point); + if (iConnection>=0) return tTracks[i]; //szukanie TGroundNode nie jest potrzebne + } +/* + TGroundNode *Current; + for (Current=nRootNode;Current;Current=Current->Next) + if ((Current->iType==TP_TRACK)&&(Current->pTrack!=Exclude)) //można użyć tabelę torów + { + iConnection=Current->pTrack->TestPoint(Point); + if (iConnection>=0) return Current; + } +*/ + return NULL; +}; + +bool __fastcall TSubRect::RaTrackAnimAdd(TTrack *t) +{//aktywacja animacji torów w VBO (zwrotnica, obrotnica) + if (m_nVertexCount<0) return true; //nie ma animacji, gdy nie widać + if (tTrackAnim) + tTrackAnim->RaAnimListAdd(t); + else + tTrackAnim=t; + return false; //będzie animowane... +} + +void __fastcall TSubRect::RaAnimate() +{//wykonanie animacji + if (!tTrackAnim) return; //nie ma nic do animowania + if (Global::bUseVBO) + {//odświeżenie VBO sektora + if (Global::bOpenGL_1_5) //modyfikacje VBO są dostępne od OpenGL 1.5 + glBindBufferARB(GL_ARRAY_BUFFER_ARB,m_nVBOVertices); + else //dla OpenGL 1.4 z GL_ARB_vertex_buffer_object odświeżenie całego sektora + Release(); //opróżnienie VBO sektora, aby się odświeżył z nowymi ustawieniami + } + tTrackAnim=tTrackAnim->RaAnimate(); //przeliczenie animacji kolejnego +}; + +TTraction* __fastcall TSubRect::FindTraction(vector3 *Point,int &iConnection,TTraction *Exclude) +{//szukanie przęsła w sektorze, którego koniec jest najbliższy (*Point) + TGroundNode *Current; + for (Current=nRenderWires;Current;Current=Current->nNext3) + if ((Current->iType==TP_TRACTION)&&(Current->hvTraction!=Exclude)) + { + iConnection=Current->hvTraction->TestPoint(Point); + if (iConnection>=0) return Current->hvTraction; + } + return NULL; +}; + +void __fastcall TSubRect::LoadNodes() +{//utworzenie siatek VBO dla wszystkich node w sektorze + if (m_nVertexCount>=0) return; //obiekty były już sprawdzone + m_nVertexCount=0; //-1 oznacza, że nie sprawdzono listy obiektów + if (!nRootNode) return; + TGroundNode *n=nRootNode; + while (n) + {switch (n->iType) + {case GL_TRIANGLE_STRIP: + case GL_TRIANGLE_FAN: + case GL_TRIANGLES: + n->iVboPtr=m_nVertexCount; //nowy początek + m_nVertexCount+=n->iNumVerts; + break; + case GL_LINES: + case GL_LINE_STRIP: + case GL_LINE_LOOP: + n->iVboPtr=m_nVertexCount; //nowy początek + m_nVertexCount+=n->iNumPts; //miejsce w tablicach normalnych i teksturowania się zmarnuje... + break; + case TP_TRACK: + n->iVboPtr=m_nVertexCount; //nowy początek + n->iNumVerts=n->pTrack->RaArrayPrepare(); //zliczenie wierzchołków + m_nVertexCount+=n->iNumVerts; + break; + case TP_TRACTION: + n->iVboPtr=m_nVertexCount; //nowy początek + n->iNumVerts=n->hvTraction->RaArrayPrepare(); //zliczenie wierzchołków + m_nVertexCount+=n->iNumVerts; + break; + } + n=n->nNext2; //następny z sektora + } + if (!m_nVertexCount) return; //jeśli nie ma obiektów do wyświetlenia z VBO, to koniec + if (Global::bUseVBO) + {//tylko liczenie wierzchołów, gdy nie ma VBO + MakeArray(m_nVertexCount); + n=nRootNode; + int i; + while (n) + {if (n->iVboPtr>=0) + switch (n->iType) + {case GL_TRIANGLE_STRIP: + case GL_TRIANGLE_FAN: + case GL_TRIANGLES: + for (i=0;iiNumVerts;++i) + {//Ra: trójkąty można od razu wczytywać do takich tablic... to może poczekać + m_pVNT[n->iVboPtr+i].x=n->Vertices[i].Point.x; + m_pVNT[n->iVboPtr+i].y=n->Vertices[i].Point.y; + m_pVNT[n->iVboPtr+i].z=n->Vertices[i].Point.z; + m_pVNT[n->iVboPtr+i].nx=n->Vertices[i].Normal.x; + m_pVNT[n->iVboPtr+i].ny=n->Vertices[i].Normal.y; + m_pVNT[n->iVboPtr+i].nz=n->Vertices[i].Normal.z; + m_pVNT[n->iVboPtr+i].u=n->Vertices[i].tu; + m_pVNT[n->iVboPtr+i].v=n->Vertices[i].tv; + } + break; + case GL_LINES: + case GL_LINE_STRIP: + case GL_LINE_LOOP: + for (i=0;iiNumPts;++i) + { + m_pVNT[n->iVboPtr+i].x=n->Points[i].x; + m_pVNT[n->iVboPtr+i].y=n->Points[i].y; + m_pVNT[n->iVboPtr+i].z=n->Points[i].z; + //miejsce w tablicach normalnych i teksturowania się marnuje... + } + break; + case TP_TRACK: + if (n->iNumVerts) //bo tory zabezpieczające są niewidoczne + n->pTrack->RaArrayFill(m_pVNT+n->iVboPtr,m_pVNT); + break; + case TP_TRACTION: + if (n->iNumVerts) //druty mogą być niewidoczne...? + n->hvTraction->RaArrayFill(m_pVNT+n->iVboPtr); + break; + } + n=n->nNext2; //następny z sektora + } + BuildVBOs(); + } + if (Global::bManageNodes) + ResourceManager::Register(this); //dodanie do automatu zwalniającego pamięć +} + +bool __fastcall TSubRect::StartVBO() +{//początek rysowania elementów z VBO w sektorze + SetLastUsage(Timer::GetSimulationTime()); //te z tyłu będą niepotrzebnie zwalniane + return CMesh::StartVBO(); +}; + +void TSubRect::Release() +{//wirtualne zwolnienie zasobów przez sprzątacz albo destruktor + if (Global::bUseVBO) + CMesh::Clear(); //usuwanie buforów +}; + +void __fastcall TSubRect::RenderDL() +{//renderowanie nieprzezroczystych (DL) + TGroundNode *node; + RaAnimate(); //przeliczenia animacji torów w sektorze + for (node=nRender;node;node=node->nNext3) + node->RenderDL(); //nieprzezroczyste obiekty (oprócz pojazdów) + for (node=nRenderMixed;node;node=node->nNext3) + node->RenderDL(); //nieprzezroczyste z mieszanych modeli + for (int j=0;jRenderDyn(); //nieprzezroczyste fragmenty pojazdów na torach +}; + +void __fastcall TSubRect::RenderAlphaDL() +{//renderowanie przezroczystych modeli oraz pojazdów (DL) + TGroundNode *node; + for (node=nRenderMixed;node;node=node->nNext3) + node->RenderAlphaDL(); //przezroczyste z mieszanych modeli + for (node=nRenderAlpha;node;node=node->nNext3) + node->RenderAlphaDL(); //przezroczyste modele + //for (node=tmp->nRender;node;node=node->nNext3) + // if (node->iType==TP_TRACK) + // node->pTrack->RenderAlpha(); //przezroczyste fragmenty pojazdów na torach + for (int j=0;jRenderDynAlpha(); //przezroczyste fragmenty pojazdów na torach +}; + +void __fastcall TSubRect::RenderVBO() +{//renderowanie nieprzezroczystych (VBO) + TGroundNode *node; + RaAnimate(); //przeliczenia animacji torów w sektorze + LoadNodes(); //czemu tutaj? + if (StartVBO()) + {for (node=nRenderRect;node;node=node->nNext3) + if (node->iVboPtr>=0) + node->RenderVBO(); //nieprzezroczyste obiekty terenu + EndVBO(); + } + for (node=nRender;node;node=node->nNext3) + node->RenderVBO(); //nieprzezroczyste obiekty (oprócz pojazdów) + for (node=nRenderMixed;node;node=node->nNext3) + node->RenderVBO(); //nieprzezroczyste z mieszanych modeli + for (int j=0;jRenderDyn(); //nieprzezroczyste fragmenty pojazdów na torach +}; + +void __fastcall TSubRect::RenderAlphaVBO() +{//renderowanie przezroczystych modeli oraz pojazdów (VBO) + TGroundNode *node; + for (node=nRenderMixed;node;node=node->nNext3) + node->RenderAlphaVBO(); //przezroczyste z mieszanych modeli + for (node=nRenderAlpha;node;node=node->nNext3) + node->RenderAlphaVBO(); //przezroczyste modele + //for (node=tmp->nRender;node;node=node->nNext3) + // if (node->iType==TP_TRACK) + // node->pTrack->RenderAlpha(); //przezroczyste fragmenty pojazdów na torach + for (int j=0;jRenderDynAlpha(); //przezroczyste fragmenty pojazdów na torach +}; + +void __fastcall TSubRect::RenderSounds() +{//aktualizacja dźwięków w pojazdach sektora (sektor może nie być wyświetlany) + for (int j=0;jRenderDynSounds(); //dźwięki pojazdów idą niezależnie od wyświetlania +}; +//--------------------------------------------------------------------------- +//------------------ Kwadrat kilometrowy ------------------------------------ +//--------------------------------------------------------------------------- +int TGroundRect::iFrameNumber=0; //licznik wyświetlanych klatek + +__fastcall TGroundRect::TGroundRect() +{ + pSubRects=NULL; + nTerrain=NULL; +}; + +__fastcall TGroundRect::~TGroundRect() +{ + SafeDeleteArray(pSubRects); +}; + +void __fastcall TGroundRect::RenderDL() +{//renderowanie kwadratu kilometrowego (DL), jeśli jeszcze nie zrobione + if (iLastDisplay!=iFrameNumber) + {//tylko jezeli dany kwadrat nie był jeszcze renderowany + //for (TGroundNode* node=pRender;node;node=node->pNext3) + // node->Render(); //nieprzezroczyste trójkąty kwadratu kilometrowego + if (nRender) + {//łączenie trójkątów w jedną listę - trochę wioska + if (!nRender->DisplayListID||(nRender->iVersion!=Global::iReCompile)) + {//jeżeli nie skompilowany, kompilujemy wszystkie trójkąty w jeden + nRender->fSquareRadius=5000.0*5000.0; //aby agregat nigdy nie znikał + nRender->DisplayListID=glGenLists(1); + glNewList(nRender->DisplayListID,GL_COMPILE); + nRender->iVersion=Global::iReCompile; //aktualna wersja siatek + for (TGroundNode* node=nRender;node;node=node->nNext3) //następny tej grupy + node->Compile(true); + glEndList(); + } + nRender->RenderDL(); //nieprzezroczyste trójkąty kwadratu kilometrowego + } + if (nRootMesh) + nRootMesh->RenderDL(); + iLastDisplay=iFrameNumber; //drugi raz nie potrzeba + } +}; + +void __fastcall TGroundRect::RenderVBO() +{//renderowanie kwadratu kilometrowego (VBO), jeśli jeszcze nie zrobione + if (iLastDisplay!=iFrameNumber) + {//tylko jezeli dany kwadrat nie był jeszcze renderowany + LoadNodes(); //ewentualne tworzenie siatek + if (StartVBO()) + {for (TGroundNode* node=nRenderRect;node;node=node->nNext3) //następny tej grupy + node->RaRenderVBO(); //nieprzezroczyste trójkąty kwadratu kilometrowego + EndVBO(); + iLastDisplay=iFrameNumber; + } + if (nTerrain) + nTerrain->smTerrain->iVisible=iFrameNumber; //ma się wyświetlić w tej ramce + } +}; + +//--------------------------------------------------------------------------- +//--------------------------------------------------------------------------- +//--------------------------------------------------------------------------- + +void __fastcall TGround::MoveGroundNode(vector3 pPosition) +{//Ra: to wymaga gruntownej reformy +/* + TGroundNode *Current; + for (Current=RootNode;Current!=NULL;Current=Current->Next) + Current->MoveMe(pPosition); + + TGroundRect *Rectx=new TGroundRect; //kwadrat kilometrowy + for(int i=0;iNext) + {//rozłożenie obiektów na mapie + if (Current->iType!=TP_DYNAMIC) + {//pojazdów to w ogóle nie dotyczy + if ((Current->iType!=GL_TRIANGLES)&&(Current->iType!=GL_TRIANGLE_STRIP)?true //~czy trójkąt? + :(Current->iFlags&0x20)?true //~czy teksturę ma nieprzezroczystą? + //:(Current->iNumVerts!=3)?true //~czy tylko jeden trójkąt? + :(Current->fSquareMinRadius!=0.0)?true //~czy widoczny z bliska? + :(Current->fSquareRadius<=90000.0)) //~czy widoczny z daleka? + GetSubRect(Current->pCenter.x,Current->pCenter.z)->AddNode(Current); + else //dodajemy do kwadratu kilometrowego + GetRect(Current->pCenter.x,Current->pCenter.z)->AddNode(Current); + } + } + for (Current=RootDynamic;Current!=NULL;Current=Current->Next) + { + Current->pCenter+=pPosition; + Current->DynamicObject->UpdatePos(); + } + for (Current=RootDynamic;Current!=NULL;Current=Current->Next) + Current->DynamicObject->MoverParameters->Physic_ReActivation(); +*/ +} + +__fastcall TGround::TGround() +{ + //RootNode=NULL; + nRootDynamic=NULL; + QueryRootEvent=NULL; + tmpEvent=NULL; + tmp2Event=NULL; + OldQRE=NULL; + RootEvent=NULL; + iNumNodes=0; + //pTrain=NULL; + Global::pGround=this; + bInitDone=false; //Ra: żeby nie robiło dwa razy FirstInit + for (int i=0;ievNext2; + delete tmp; + } + TGroundNode *tmpn; + for (int i=0;inNext; + delete tmpn; + } + nRootOfType[i]=NULL; + } + for (TGroundNode *Current=nRootDynamic;Current;) + { + tmpn=Current; + Current=Current->nNext; + delete tmpn; + } + iNumNodes=0; + //RootNode=NULL; + nRootDynamic=NULL; + delete sTracks; +} + +TGroundNode* __fastcall TGround::DynamicFindAny(AnsiString asNameToFind) +{//wyszukanie pojazdu o podanej nazwie, szukanie po wszystkich (użyć drzewa!) + for (TGroundNode *Current=nRootDynamic;Current;Current=Current->nNext) + if ((Current->asName==asNameToFind)) + return Current; + return NULL; +}; + +TGroundNode* __fastcall TGround::DynamicFind(AnsiString asNameToFind) +{//wyszukanie pojazdu z obsadą o podanej nazwie (użyć drzewa!) + for (TGroundNode *Current=nRootDynamic;Current;Current=Current->nNext) + if (Current->DynamicObject->Mechanik) + if ((Current->asName==asNameToFind)) + return Current; + return NULL; +}; + +void __fastcall TGround::DynamicList(bool all) +{//odesłanie nazw pojazdów dostępnych na scenerii (nazwy, szczególnie wagonów, mogą się powtarzać!) + for (TGroundNode *Current=nRootDynamic;Current;Current=Current->nNext) + if (all||Current->DynamicObject->Mechanik) + WyslijString(Current->asName,6); //same nazwy pojazdów + WyslijString("none",6); //informacja o końcu listy +}; + +TGroundNode* __fastcall TGround::FindGroundNode(AnsiString asNameToFind,TGroundNodeType iNodeType) +{//wyszukiwanie obiektu o podanej nazwie i konkretnym typie + if ((iNodeType==TP_TRACK)||(iNodeType==TP_MEMCELL)||(iNodeType==TP_MODEL)) + {//wyszukiwanie w drzewie binarnym + return (TGroundNode*)sTracks->Find(iNodeType,asNameToFind.c_str()); + } + //standardowe wyszukiwanie liniowe + TGroundNode *Current; + for (Current=nRootOfType[iNodeType];Current;Current=Current->nNext) + if (Current->asName==asNameToFind) + return Current; + return NULL; +} + + +double fTrainSetVel=0; +double fTrainSetDir=0; +double fTrainSetDist=0; //odległość składu od punktu 1 w stronę punktu 2 +AnsiString asTrainSetTrack=""; +int iTrainSetConnection=0; +bool bTrainSet=false; +AnsiString asTrainName=""; +int iTrainSetWehicleNumber=0; +TGroundNode *nTrainSetNode=NULL; //poprzedni pojazd do łączenia +TGroundNode *nTrainSetDriver=NULL; //pojazd, któremu zostanie wysłany rozkład + +TGroundVertex TempVerts[10000]; //tu wczytywane są trójkąty +Byte TempConnectionType[200]; //Ra: sprzęgi w składzie; ujemne, gdy odwrotnie + +void __fastcall TGround::RaTriangleDivider(TGroundNode* node) +{//tworzy dodatkowe trójkąty i zmiejsza podany + //to jest wywoływane przy wczytywaniu trójkątów + //dodatkowe trójkąty są dodawane do głównej listy trójkątów + //podział trójkątów na sektory i kwadraty jest dokonywany później w FirstInit + if (node->iType!=GL_TRIANGLES) return; //tylko pojedyncze trójkąty + if (node->iNumVerts!=3) return; //tylko gdy jeden trójkąt + double x0=1000.0*floor(0.001*node->pCenter.x)-200.0; double x1=x0+1400.0; + double z0=1000.0*floor(0.001*node->pCenter.z)-200.0; double z1=z0+1400.0; + if ( + (node->Vertices[0].Point.x>=x0) && (node->Vertices[0].Point.x<=x1) && + (node->Vertices[0].Point.z>=z0) && (node->Vertices[0].Point.z<=z1) && + (node->Vertices[1].Point.x>=x0) && (node->Vertices[1].Point.x<=x1) && + (node->Vertices[1].Point.z>=z0) && (node->Vertices[1].Point.z<=z1) && + (node->Vertices[2].Point.x>=x0) && (node->Vertices[2].Point.x<=x1) && + (node->Vertices[2].Point.z>=z0) && (node->Vertices[2].Point.z<=z1)) + return; //trójkąt wystający mniej niż 200m z kw. kilometrowego jest do przyjęcia + //Ra: przerobić na dzielenie na 2 trójkąty, podział w przecięciu z siatką kilometrową + //Ra: i z rekurencją będzie dzielić trzy trójkąty, jeśli będzie taka potrzeba + int divide=-1; //bok do podzielenia: 0=AB, 1=BC, 2=CA; +4=podział po OZ; +8 na x1/z1 + double min=0,mul; //jeśli przechodzi przez oś, iloczyn będzie ujemny + x0+=200.0; x1-=200.0; //przestawienie na siatkę + z0+=200.0; z1-=200.0; + mul=(node->Vertices[0].Point.x-x0)*(node->Vertices[1].Point.x-x0); //AB na wschodzie + if (mulVertices[1].Point.x-x0)*(node->Vertices[2].Point.x-x0); //BC na wschodzie + if (mulVertices[2].Point.x-x0)*(node->Vertices[0].Point.x-x0); //CA na wschodzie + if (mulVertices[0].Point.x-x1)*(node->Vertices[1].Point.x-x1); //AB na zachodzie + if (mulVertices[1].Point.x-x1)*(node->Vertices[2].Point.x-x1); //BC na zachodzie + if (mulVertices[2].Point.x-x1)*(node->Vertices[0].Point.x-x1); //CA na zachodzie + if (mulVertices[0].Point.z-z0)*(node->Vertices[1].Point.z-z0); //AB na południu + if (mulVertices[1].Point.z-z0)*(node->Vertices[2].Point.z-z0); //BC na południu + if (mulVertices[2].Point.z-z0)*(node->Vertices[0].Point.z-z0); //CA na południu + if (mulVertices[0].Point.z-z1)*(node->Vertices[1].Point.z-z1); //AB na północy + if (mulVertices[1].Point.z-z1)*(node->Vertices[2].Point.z-z1); //BC na północy + if (mulVertices[2].Point.z-z1)*(node->Vertices[0].Point.z-z1); //CA na północy + if (muliType=GL_TRIANGLES; //kopiowanie parametrów, przydałby się konstruktor kopiujący + ntri->Init(3); + ntri->TextureID=node->TextureID; + ntri->iFlags=node->iFlags; + for (int j=0;j<4;++j) + {ntri->Ambient[j]=node->Ambient[j]; + ntri->Diffuse[j]=node->Diffuse[j]; + ntri->Specular[j]=node->Specular[j]; + } + ntri->asName=node->asName; + ntri->fSquareRadius=node->fSquareRadius; + ntri->fSquareMinRadius=node->fSquareMinRadius; + ntri->bVisible=node->bVisible; //a są jakieś niewidoczne? + ntri->nNext=nRootOfType[GL_TRIANGLES]; + nRootOfType[GL_TRIANGLES]=ntri; //dopisanie z przodu do listy + iNumNodes++; + switch (divide&3) + {//podzielenie jednego z boków, powstaje wierzchołek D + case 0: //podział AB (0-1) -> ADC i DBC + ntri->Vertices[2]=node->Vertices[2]; //wierzchołek C jest wspólny + ntri->Vertices[1]=node->Vertices[1]; //wierzchołek B przechodzi do nowego + //node->Vertices[1].HalfSet(node->Vertices[0],node->Vertices[1]); //na razie D tak + if (divide&4) + node->Vertices[1].SetByZ(node->Vertices[0],node->Vertices[1],divide&8?z1:z0); + else + node->Vertices[1].SetByX(node->Vertices[0],node->Vertices[1],divide&8?x1:x0); + ntri->Vertices[0]=node->Vertices[1]; //wierzchołek D jest wspólny + break; + case 1: //podział BC (1-2) -> ABD i ADC + ntri->Vertices[0]=node->Vertices[0]; //wierzchołek A jest wspólny + ntri->Vertices[2]=node->Vertices[2]; //wierzchołek C przechodzi do nowego + //node->Vertices[2].HalfSet(node->Vertices[1],node->Vertices[2]); //na razie D tak + if (divide&4) + node->Vertices[2].SetByZ(node->Vertices[1],node->Vertices[2],divide&8?z1:z0); + else + node->Vertices[2].SetByX(node->Vertices[1],node->Vertices[2],divide&8?x1:x0); + ntri->Vertices[1]=node->Vertices[2]; //wierzchołek D jest wspólny + break; + case 2: //podział CA (2-0) -> ABD i DBC + ntri->Vertices[1]=node->Vertices[1]; //wierzchołek B jest wspólny + ntri->Vertices[2]=node->Vertices[2]; //wierzchołek C przechodzi do nowego + //node->Vertices[2].HalfSet(node->Vertices[2],node->Vertices[0]); //na razie D tak + if (divide&4) + node->Vertices[2].SetByZ(node->Vertices[2],node->Vertices[0],divide&8?z1:z0); + else + node->Vertices[2].SetByX(node->Vertices[2],node->Vertices[0],divide&8?x1:x0); + ntri->Vertices[0]=node->Vertices[2]; //wierzchołek D jest wspólny + break; + } + //przeliczenie środków ciężkości obu + node->pCenter=(node->Vertices[0].Point+node->Vertices[1].Point+node->Vertices[2].Point)/3.0; + ntri->pCenter=(ntri->Vertices[0].Point+ntri->Vertices[1].Point+ntri->Vertices[2].Point)/3.0; + RaTriangleDivider(node); //rekurencja, bo nawet na TD raz nie wystarczy + RaTriangleDivider(ntri); +}; + +TGroundNode* __fastcall TGround::AddGroundNode(cParser* parser) +{//wczytanie wpisu typu "node" + //parser->LoadTraction=Global::bLoadTraction; //Ra: tu nie potrzeba powtarzać + AnsiString str,str1,str2,str3,str4,Skin,DriverType,asNodeName; + int nv,ti,i,n; + double tf,r,rmin,tf1,tf2,tf3,tf4,l,dist,mgn; + int int1,int2; + bool bError=false,curve; + vector3 pt,front,up,left,pos,tv; + matrix4x4 mat2,mat1,mat; + GLuint TexID; + TGroundNode *tmp1; + TTrack *Track; + TTextSound *tmpsound; + std::string token; + parser->getTokens(2); + *parser >> r >> rmin; + parser->getTokens(); + *parser >> token; + asNodeName=AnsiString(token.c_str()); + parser->getTokens(); + *parser >> token; + str=AnsiString(token.c_str()); + TGroundNode *tmp,*tmp2; + tmp=new TGroundNode(); + tmp->asName=(asNodeName==AnsiString("none")?AnsiString(""):asNodeName); + if (r>=0) tmp->fSquareRadius=r*r; + tmp->fSquareMinRadius=rmin*rmin; + if (str=="triangles") tmp->iType=GL_TRIANGLES; + else if (str=="triangle_strip") tmp->iType=GL_TRIANGLE_STRIP; + else if (str=="triangle_fan") tmp->iType=GL_TRIANGLE_FAN; + else if (str=="lines") tmp->iType=GL_LINES; + else if (str=="line_strip") tmp->iType=GL_LINE_STRIP; + else if (str=="line_loop") tmp->iType=GL_LINE_LOOP; + else if (str=="model") tmp->iType=TP_MODEL; + //else if (str=="terrain") tmp->iType=TP_TERRAIN; //tymczasowo do odwołania + else if (str=="dynamic") tmp->iType=TP_DYNAMIC; + else if (str=="sound") tmp->iType=TP_SOUND; + else if (str=="track") tmp->iType=TP_TRACK; + else if (str=="memcell") tmp->iType=TP_MEMCELL; + else if (str=="eventlauncher") tmp->iType=TP_EVLAUNCH; + else if (str=="traction") tmp->iType=TP_TRACTION; + else if (str=="tractionpowersource") tmp->iType=TP_TRACTIONPOWERSOURCE; +// else if (str=="isolated") tmp->iType=TP_ISOLATED; + else bError=true; + //WriteLog("-> node "+str+" "+tmp->asName); + if (bError) + { + Error(AnsiString("Scene parse error near "+str).c_str()); + for (int i=0;i<60;++i) + {//Ra: skopiowanie dalszej części do logu - taka prowizorka, lepsza niż nic + parser->getTokens(); //pobranie linijki tekstu nie działa + *parser >> token; + WriteLog(token.c_str()); + } + //if (tmp==RootNode) RootNode=NULL; + delete tmp; + return NULL; + } + switch (tmp->iType) + { + case TP_TRACTION : + tmp->hvTraction=new TTraction(); + parser->getTokens(); + *parser >> token; + tmp->hvTraction->asPowerSupplyName=AnsiString(token.c_str()); //nazwa zasilacza + parser->getTokens(3); + *parser >> tmp->hvTraction->NominalVoltage >> tmp->hvTraction->MaxCurrent >> tmp->hvTraction->fResistivity; + if (tmp->hvTraction->fResistivity==0.01) //tyle jest w sceneriach [om/km] + tmp->hvTraction->fResistivity=0.075; //taka sensowniejsza wartość za http://www.ikolej.pl/fileadmin/user_upload/Seminaria_IK/13_05_07_Prezentacja_Kruczek.pdf + tmp->hvTraction->fResistivity*=0.001; //teraz [om/m] + parser->getTokens(); + *parser >> token; + //Ra 2014-02: a tutaj damy symbol sieci i jej budowę, np.: + // SKB70-C, CuCd70-2C, KB95-2C, C95-C, C95-2C, YC95-2C, YpC95-2C, YC120-2C + // YpC120-2C, YzC120-2C, YwsC120-2C, YC150-C150, YC150-2C150, C150-C150 + // C120-2C, 2C120-2C, 2C120-2C-1, 2C120-2C-2, 2C120-2C-3, 2C120-2C-4 + if (token.compare("none")==0) + tmp->hvTraction->Material=0; + else if (token.compare("al")==0) + tmp->hvTraction->Material=2; //1=aluminiowa, rysuje się na czarno + else + tmp->hvTraction->Material=1; //1=miedziana, rysuje się na zielono albo czerwono + parser->getTokens(); + *parser >> tmp->hvTraction->WireThickness; + parser->getTokens(); + *parser >> tmp->hvTraction->DamageFlag; + parser->getTokens(3); + *parser >> tmp->hvTraction->pPoint1.x >> tmp->hvTraction->pPoint1.y >> tmp->hvTraction->pPoint1.z; + tmp->hvTraction->pPoint1+=pOrigin; + parser->getTokens(3); + *parser >> tmp->hvTraction->pPoint2.x >> tmp->hvTraction->pPoint2.y >> tmp->hvTraction->pPoint2.z; + tmp->hvTraction->pPoint2+=pOrigin; + parser->getTokens(3); + *parser >> tmp->hvTraction->pPoint3.x >> tmp->hvTraction->pPoint3.y >> tmp->hvTraction->pPoint3.z; + tmp->hvTraction->pPoint3+=pOrigin; + parser->getTokens(3); + *parser >> tmp->hvTraction->pPoint4.x >> tmp->hvTraction->pPoint4.y >> tmp->hvTraction->pPoint4.z; + tmp->hvTraction->pPoint4+=pOrigin; + parser->getTokens(); + *parser >> tf1; + tmp->hvTraction->fHeightDifference= + (tmp->hvTraction->pPoint3.y-tmp->hvTraction->pPoint1.y+ + tmp->hvTraction->pPoint4.y-tmp->hvTraction->pPoint2.y)*0.5f-tf1; + parser->getTokens(); + *parser >> tf1; + if (tf1>0) + tmp->hvTraction->iNumSections=(tmp->hvTraction->pPoint1-tmp->hvTraction->pPoint2).Length()/tf1; + else tmp->hvTraction->iNumSections=0; + parser->getTokens(); + *parser >> tmp->hvTraction->Wires; + parser->getTokens(); + *parser >> tmp->hvTraction->WireOffset; + parser->getTokens(); + *parser >> token; + tmp->bVisible=(token.compare("vis")==0); + parser->getTokens(); + *parser >> token; + if (token.compare("parallel")==0) + {//jawne wskazanie innego przęsła, na które może przestawić się pantograf + parser->getTokens(); + *parser >> token; //wypadało by to zapamiętać... + tmp->hvTraction->asParallel=AnsiString(token.c_str()); + parser->getTokens(); + *parser >> token; //a tu już powinien być koniec + } + if (token.compare("endtraction")!=0) + Error("ENDTRACTION delimiter missing! "+str2+" found instead."); + tmp->hvTraction->Init(); //przeliczenie parametrów + //if (Global::bLoadTraction) + // tmp->hvTraction->Optimize(); //generowanie DL dla wszystkiego przy wczytywaniu? + tmp->pCenter=(tmp->hvTraction->pPoint2+tmp->hvTraction->pPoint1)*0.5f; + //if (!Global::bLoadTraction) SafeDelete(tmp); //Ra: tak być nie może, bo NULL to błąd + break; + case TP_TRACTIONPOWERSOURCE: + parser->getTokens(3); + *parser >> tmp->pCenter.x >> tmp->pCenter.y >> tmp->pCenter.z; + tmp->pCenter+=pOrigin; + tmp->psTractionPowerSource=new TTractionPowerSource(); + tmp->psTractionPowerSource->gMyNode=tmp; //Ra 2015-03: znowu prowizorka, aby mieć nazwę do logowania + tmp->psTractionPowerSource->Load(parser); + break; + case TP_MEMCELL: + parser->getTokens(3); + *parser >> tmp->pCenter.x >> tmp->pCenter.y >> tmp->pCenter.z; + tmp->pCenter.RotateY(aRotate.y/180.0*M_PI); //Ra 2014-11: uwzględnienie rotacji + tmp->pCenter+=pOrigin; + tmp->MemCell=new TMemCell(&tmp->pCenter); + tmp->MemCell->Load(parser); + if (!tmp->asName.IsEmpty()) //jest pusta gdy "none" + {//dodanie do wyszukiwarki + if (sTracks->Update(TP_MEMCELL,tmp->asName.c_str(),tmp)) //najpierw sprawdzić, czy już jest + {//przy zdublowaniu wskaźnik zostanie podmieniony w drzewku na późniejszy (zgodność wsteczna) + ErrorLog("Duplicated memcell: "+tmp->asName); //to zgłaszać duplikat + } + else + sTracks->Add(TP_MEMCELL,tmp->asName.c_str(),tmp); //nazwa jest unikalna + } + break; + case TP_EVLAUNCH: + parser->getTokens(3); + *parser >> tmp->pCenter.x >> tmp->pCenter.y >> tmp->pCenter.z; + tmp->pCenter.RotateY(aRotate.y/180.0*M_PI); //Ra 2014-11: uwzględnienie rotacji + tmp->pCenter+=pOrigin; + tmp->EvLaunch=new TEventLauncher(); + tmp->EvLaunch->Load(parser); + break; + case TP_TRACK : + tmp->pTrack=new TTrack(tmp); + if (Global::iWriteLogEnabled&4) + if (!tmp->asName.IsEmpty()) + WriteLog(tmp->asName.c_str()); + tmp->pTrack->Load(parser,pOrigin,tmp->asName); //w nazwie może być nazwa odcinka izolowanego + if (!tmp->asName.IsEmpty()) //jest pusta gdy "none" + {//dodanie do wyszukiwarki + if (sTracks->Update(TP_TRACK,tmp->asName.c_str(),tmp)) //najpierw sprawdzić, czy już jest + {//przy zdublowaniu wskaźnik zostanie podmieniony w drzewku na późniejszy (zgodność wsteczna) + if (tmp->pTrack->iCategoryFlag&1) //jeśli jest zdublowany tor kolejowy + ErrorLog("Duplicated track: "+tmp->asName); //to zgłaszać duplikat + } + else + sTracks->Add(TP_TRACK,tmp->asName.c_str(),tmp); //nazwa jest unikalna + } + tmp->pCenter=(tmp->pTrack->CurrentSegment()->FastGetPoint_0()+ + tmp->pTrack->CurrentSegment()->FastGetPoint(0.5)+ + tmp->pTrack->CurrentSegment()->FastGetPoint_1() )/3.0; + break; + case TP_SOUND : + tmp->tsStaticSound=new TTextSound; + parser->getTokens(3); + *parser >> tmp->pCenter.x >> tmp->pCenter.y >> tmp->pCenter.z; + tmp->pCenter.RotateY(aRotate.y/180.0*M_PI); //Ra 2014-11: uwzględnienie rotacji + tmp->pCenter+=pOrigin; + parser->getTokens(); + *parser >> token; + str=AnsiString(token.c_str()); + tmp->tsStaticSound->Init(str.c_str(),sqrt(tmp->fSquareRadius),tmp->pCenter.x,tmp->pCenter.y,tmp->pCenter.z,false,rmin); + if (rmin<0.0) rmin=0.0; //przywrócenie poprawnej wartości, jeśli służyła do wyłączenia efektu Dopplera + +// tmp->pDirectSoundBuffer=TSoundsManager::GetFromName(str.c_str()); +// tmp->iState=(Parser->GetNextSymbol().LowerCase()=="loop"?DSBPLAY_LOOPING:0); + parser->getTokens(); *parser >> token; + break; + case TP_DYNAMIC: + tmp->DynamicObject=new TDynamicObject(); + //tmp->DynamicObject->Load(Parser); + parser->getTokens(); + *parser >> token; + str1=AnsiString(token.c_str()); //katalog + //McZapkie: doszedl parametr ze zmienialna skora + parser->getTokens(); + *parser >> token; + Skin=AnsiString(token.c_str()); //tekstura wymienna + parser->getTokens(); + *parser >> token; + str3=AnsiString(token.c_str()); //McZapkie-131102: model w MMD + if (bTrainSet) + {//jeśli pojazd jest umieszczony w składzie + str=asTrainSetTrack; + parser->getTokens(); + *parser >> tf1; //Ra: -1 oznacza odwrotne wstawienie, normalnie w składzie 0 + parser->getTokens(); + *parser >> token; + DriverType=AnsiString(token.c_str()); //McZapkie:010303 - w przyszlosci rozne konfiguracje mechanik/pomocnik itp + tf3=fTrainSetVel; //prędkość + parser->getTokens(); + *parser >> token; + str4=AnsiString(token.c_str()); + int2=str4.Pos("."); //yB: wykorzystuje tutaj zmienna, ktora potem bedzie ladunkiem + if (int2>0) //yB: jesli znalazl kropke, to ja przetwarza jako parametry + { + int dlugosc= str4.Length(); + int1=str4.SubString(1, int2-1).ToInt(); //niech sprzegiem bedzie do kropki cos + str4=str4.SubString(int2+1, dlugosc-int2); + } + else + { + int1=str4.ToInt(); + str4=""; + } + int2=0; //zeruje po wykorzystaniu +// *parser >> int1; //yB: nastawy i takie tam TUTAJ!!!!! + if (int1<0) int1=(-int1)|ctrain_depot; //sprzęg zablokowany (pojazdy nierozłączalne przy manewrach) + if (tf1!=-1.0) + if (fabs(tf1)>0.5) //maksymalna odległość między sprzęgami - do przemyślenia + int1=0; //likwidacja sprzęgu, jeśli odległość zbyt duża - to powinno być uwzględniane w fizyce sprzęgów... + TempConnectionType[iTrainSetWehicleNumber]=int1; //wartość dodatnia + } + else + {//pojazd wstawiony luzem + fTrainSetDist=0; //zerowanie dodatkowego przesunięcia + asTrainName=""; //puste oznacza jazdę pojedynczego bez rozkładu, "none" jest dla składu (trainset) + parser->getTokens(); + *parser >> token; + str=AnsiString(token.c_str()); //track + parser->getTokens(); + *parser >> tf1; //Ra: -1 oznacza odwrotne wstawienie + parser->getTokens(); + *parser >> token; + DriverType=AnsiString(token.c_str()); //McZapkie:010303: obsada + parser->getTokens(); + *parser >> tf3; //prędkość, niektórzy wpisują tu "3" jako sprzęg, żeby nie było tabliczki + iTrainSetWehicleNumber=0; + TempConnectionType[iTrainSetWehicleNumber]=3; //likwidacja tabliczki na końcu? + } + parser->getTokens(); + *parser >> int2; //ilość ładunku + if (int2>0) + {//jeżeli ładunku jest więcej niż 0, to rozpoznajemy jego typ + parser->getTokens(); + *parser >> token; + str2=AnsiString(token.c_str()); //LoadType + if (str2==AnsiString("enddynamic")) //idiotoodporność: ładunek bez podanego typu + { + str2=""; int2=0; //ilość bez typu się nie liczy jako ładunek + } + } + else + str2=""; //brak ladunku + + tmp1=FindGroundNode(str,TP_TRACK); //poszukiwanie toru + if (tmp1?tmp1->pTrack!=NULL:false) + {//jeśli tor znaleziony + Track=tmp1->pTrack; + if (!iTrainSetWehicleNumber) //jeśli pierwszy pojazd + if (Track->evEvent0) //jeśli tor ma Event0 + if (fabs(fTrainSetVel)<=1.0) //a skład stoi + if (fTrainSetDist>=0.0) //ale może nie sięgać na owy tor + if (fTrainSetDist<8.0) //i raczej nie sięga + fTrainSetDist=8.0; //przesuwamy około pół EU07 dla wstecznej zgodności + //WriteLog("Dynamic shift: "+AnsiString(fTrainSetDist)); +/* //Ra: to jednak robi duże problemy - przesunięcie w dynamic jest przesunięciem do tyłu, odwrotnie niż w trainset + if (!iTrainSetWehicleNumber) //dla pierwszego jest to przesunięcie (ujemne = do tyłu) + if (tf1!=-1.0) //-1 wyjątkowo oznacza odwrócenie + tf1=-tf1; //a dla kolejnych odległość między sprzęgami (ujemne = wbite) +*/ + tf3=tmp->DynamicObject->Init(asNodeName,str1,Skin,str3,Track,(tf1==-1.0?fTrainSetDist:fTrainSetDist-tf1),DriverType,tf3,asTrainName,int2,str2,(tf1==-1.0),str4); + if (tf3!=0.0) //zero oznacza błąd + {fTrainSetDist-=tf3; //przesunięcie dla kolejnego, minus bo idziemy w stronę punktu 1 + tmp->pCenter=tmp->DynamicObject->GetPosition(); + if (TempConnectionType[iTrainSetWehicleNumber]) //jeśli jest sprzęg + if (tmp->DynamicObject->MoverParameters->Couplers[tf1==-1.0?0:1].AllowedFlag&ctrain_depot) //jesli zablokowany + TempConnectionType[iTrainSetWehicleNumber]|=ctrain_depot; //będzie blokada + iTrainSetWehicleNumber++; + } + else + {//LastNode=NULL; + delete tmp; + tmp=NULL; //nie może być tu return, bo trzeba pominąć jeszcze enddynamic + } + } + else + {//gdy tor nie znaleziony + ErrorLog("Missed track: dynamic placed on \""+tmp->DynamicObject->asTrack+"\""); + delete tmp; + tmp=NULL; //nie może być tu return, bo trzeba pominąć jeszcze enddynamic + } + parser->getTokens(); + *parser >> token; + if (token.compare("destination")==0) + {//dokąd wagon ma jechać, uwzględniane przy manewrach + parser->getTokens(); + *parser >> token; + if (tmp) + tmp->DynamicObject->asDestination=AnsiString(token.c_str()); + *parser >> token; + } + if (token.compare("enddynamic")!=0) + Error("enddynamic statement missing"); + break; + case TP_MODEL: + if (rmin<0) + {tmp->iType=TP_TERRAIN; + tmp->fSquareMinRadius=0; //to w ogóle potrzebne? + } + parser->getTokens(3); + *parser >> tmp->pCenter.x >> tmp->pCenter.y >> tmp->pCenter.z; + parser->getTokens(); + *parser >> tf1; + //OlO_EU&KAKISH-030103: obracanie punktow zaczepien w modelu + tmp->pCenter.RotateY(aRotate.y/180.0*M_PI); + //McZapkie-260402: model tez ma wspolrzedne wzgledne + tmp->pCenter+=pOrigin; + //tmp->fAngle+=aRotate.y; // /180*M_PI +/* + if (tmp->iType==TP_MODEL) + {//jeśli standardowy model +*/ + tmp->Model=new TAnimModel(); + tmp->Model->RaAnglesSet(aRotate.x,tf1+aRotate.y,aRotate.z); //dostosowanie do pochylania linii + if (tmp->Model->Load(parser,tmp->iType==TP_TERRAIN)) //wczytanie modelu, tekstury i stanu świateł... + tmp->iFlags=tmp->Model->Flags()|0x200; //ustalenie, czy przezroczysty; flaga usuwania + else + if (tmp->iType!=TP_TERRAIN) + {//model nie wczytał się - ignorowanie node + delete tmp; + tmp=NULL; //nie może być tu return + break; //nie może być tu return? + } +/* + } + else if (tmp->iType==TP_TERRAIN) + {//nie potrzeba nakładki animującej submodele + *parser >> token; + tmp->pModel3D=TModelsManager::GetModel(token.c_str(),false); + do //Ra: z tym to trochę bez sensu jest + {parser->getTokens(); + *parser >> token; + str=AnsiString(token.c_str()); + } while (str!="endterrains"); + } +*/ + if (tmp->iType==TP_TERRAIN) + {//jeśli model jest terenem, trzeba utworzyć dodatkowe obiekty + //po wczytaniu model ma już utworzone DL albo VBO + Global::pTerrainCompact=tmp->Model; //istnieje co najmniej jeden obiekt terenu + tmp->iCount=Global::pTerrainCompact->TerrainCount()+1; //zliczenie submodeli + tmp->nNode=new TGroundNode[tmp->iCount]; //sztuczne node dla kwadratów + tmp->nNode[0].iType=TP_MODEL; //pierwszy zawiera model (dla delete) + tmp->nNode[0].Model=Global::pTerrainCompact; + tmp->nNode[0].iFlags=0x200; //nie wyświetlany, ale usuwany + for (i=1;iiCount;++i) + {//a reszta to submodele + tmp->nNode[i].iType=TP_SUBMODEL; // + tmp->nNode[i].smTerrain=Global::pTerrainCompact->TerrainSquare(i-1); + tmp->nNode[i].iFlags=0x10; //nieprzezroczyste; nie usuwany + tmp->nNode[i].bVisible=true; + tmp->nNode[i].pCenter=tmp->pCenter; //nie przesuwamy w inne miejsce + //tmp->nNode[i].asName= + } + } + else if (!tmp->asName.IsEmpty()) //jest pusta gdy "none" + {//dodanie do wyszukiwarki + if (sTracks->Update(TP_MODEL,tmp->asName.c_str(),tmp)) //najpierw sprawdzić, czy już jest + {//przy zdublowaniu wskaźnik zostanie podmieniony w drzewku na późniejszy (zgodność wsteczna) + ErrorLog("Duplicated model: "+tmp->asName); //to zgłaszać duplikat + } + else + sTracks->Add(TP_MODEL,tmp->asName.c_str(),tmp); //nazwa jest unikalna + } + //str=Parser->GetNextSymbol().LowerCase(); + break; + //case TP_GEOMETRY : + case GL_TRIANGLES : + case GL_TRIANGLE_STRIP : + case GL_TRIANGLE_FAN : + parser->getTokens(); + *parser >> token; + //McZapkie-050702: opcjonalne wczytywanie parametrow materialu (ambient,diffuse,specular) + if (token.compare("material")==0) + { + parser->getTokens(); + *parser >> token; + while (token.compare("endmaterial")!=0) + { + if (token.compare("ambient:")==0) + { + parser->getTokens(); *parser >> tmp->Ambient[0]; + parser->getTokens(); *parser >> tmp->Ambient[1]; + parser->getTokens(); *parser >> tmp->Ambient[2]; + } + else if (token.compare("diffuse:")==0) + {//Ra: coś jest nie tak, bo w jednej linijce nie działa + parser->getTokens(); *parser >> tmp->Diffuse[0]; + parser->getTokens(); *parser >> tmp->Diffuse[1]; + parser->getTokens(); *parser >> tmp->Diffuse[2]; + } + else if (token.compare("specular:")==0) + { + parser->getTokens(); *parser >> tmp->Specular[0]; + parser->getTokens(); *parser >> tmp->Specular[1]; + parser->getTokens(); *parser >> tmp->Specular[2]; + } + else Error("Scene material failure!"); + parser->getTokens(); + *parser >> token; + } + } + if (token.compare("endmaterial")==0) + { + parser->getTokens(); + *parser >> token; + } + str=AnsiString(token.c_str()); +#ifdef _PROBLEND + // PROBLEND Q: 13122011 - Szociu: 27012012 + PROBLEND = true; // domyslnie uruchomione nowe wyświetlanie + tmp->PROBLEND = true; // odwolanie do tgroundnode, bo rendering jest w tej klasie + if (str.Pos("@") > 0) // sprawdza, czy w nazwie tekstury jest znak "@" + { + PROBLEND = false; // jeśli jest, wyswietla po staremu + tmp->PROBLEND = false; + } +#endif + tmp->TextureID=TTexturesManager::GetTextureID(szTexturePath,szSceneryPath,str.c_str()); + tmp->iFlags=TTexturesManager::GetAlpha(tmp->TextureID)?0x220:0x210; //z usuwaniem + if (((tmp->iType==GL_TRIANGLES)&&(tmp->iFlags&0x10))?Global::pTerrainCompact->TerrainLoaded():false) + {//jeśli jest tekstura nieprzezroczysta, a teren załadowany, to pomijamy trójkąty + do + {//pomijanie trójkątów + parser->getTokens(); + *parser >> token; + } while (token.compare("endtri")!=0); + //delete tmp; //nie ma co tego trzymać + //tmp=NULL; //to jest błąd + } + else + {i=0; + do + { + if (i<9999) //3333 trójkąty + {//liczba wierzchołków nie jest nieograniczona + parser->getTokens(3); + *parser >> TempVerts[i].Point.x >> TempVerts[i].Point.y >> TempVerts[i].Point.z; + parser->getTokens(3); + *parser >> TempVerts[i].Normal.x >> TempVerts[i].Normal.y >> TempVerts[i].Normal.z; +/* + str=Parser->GetNextSymbol().LowerCase(); + if (str==AnsiString("x")) + TempVerts[i].tu=(TempVerts[i].Point.x+Parser->GetNextSymbol().ToDouble())/Parser->GetNextSymbol().ToDouble(); + else + if (str==AnsiString("y")) + TempVerts[i].tu=(TempVerts[i].Point.y+Parser->GetNextSymbol().ToDouble())/Parser->GetNextSymbol().ToDouble(); + else + if (str==AnsiString("z")) + TempVerts[i].tu=(TempVerts[i].Point.z+Parser->GetNextSymbol().ToDouble())/Parser->GetNextSymbol().ToDouble(); + else + TempVerts[i].tu=str.ToDouble();; + + str=Parser->GetNextSymbol().LowerCase(); + if (str==AnsiString("x")) + TempVerts[i].tv=(TempVerts[i].Point.x+Parser->GetNextSymbol().ToDouble())/Parser->GetNextSymbol().ToDouble(); + else + if (str==AnsiString("y")) + TempVerts[i].tv=(TempVerts[i].Point.y+Parser->GetNextSymbol().ToDouble())/Parser->GetNextSymbol().ToDouble(); + else + if (str==AnsiString("z")) + TempVerts[i].tv=(TempVerts[i].Point.z+Parser->GetNextSymbol().ToDouble())/Parser->GetNextSymbol().ToDouble(); + else + TempVerts[i].tv=str.ToDouble();; +*/ + parser->getTokens(2); + *parser >> TempVerts[i].tu >> TempVerts[i].tv; + +// tf=Parser->GetNextSymbol().ToDouble(); + // TempVerts[i].tu=tf; + // tf=Parser->GetNextSymbol().ToDouble(); + // TempVerts[i].tv=tf; + + TempVerts[i].Point.RotateZ(aRotate.z/180*M_PI); + TempVerts[i].Point.RotateX(aRotate.x/180*M_PI); + TempVerts[i].Point.RotateY(aRotate.y/180*M_PI); + TempVerts[i].Normal.RotateZ(aRotate.z/180*M_PI); + TempVerts[i].Normal.RotateX(aRotate.x/180*M_PI); + TempVerts[i].Normal.RotateY(aRotate.y/180*M_PI); + TempVerts[i].Point+=pOrigin; + tmp->pCenter+=TempVerts[i].Point; + } + else if (i==9999) + ErrorLog("Bad triangles: too many verices"); + i++; + parser->getTokens(); + *parser >> token; + +// } + + } while (token.compare("endtri")!=0); + nv=i; + tmp->Init(nv); //utworzenie tablicy wierzchołków + tmp->pCenter/=(nv>0?nv:1); + +// memcpy(tmp->Vertices,TempVerts,nv*sizeof(TGroundVertex)); + + r=0; + for (int i=0;iVertices[i]=TempVerts[i]; + tf=SquareMagnitude(tmp->Vertices[i].Point-tmp->pCenter); + if (tf>r) r=tf; + } + +// tmp->fSquareRadius=2000*2000+r; + tmp->fSquareRadius+=r; + RaTriangleDivider(tmp); //Ra: dzielenie trójkątów jest teraz całkiem wydajne + } //koniec wczytywania trójkątów + break; + case GL_LINES : + case GL_LINE_STRIP : + case GL_LINE_LOOP : + parser->getTokens(3); + *parser >> tmp->Diffuse[0] >> tmp->Diffuse[1] >> tmp->Diffuse[2]; +// tmp->Diffuse[0]=Parser->GetNextSymbol().ToDouble()/255; +// tmp->Diffuse[1]=Parser->GetNextSymbol().ToDouble()/255; +// tmp->Diffuse[2]=Parser->GetNextSymbol().ToDouble()/255; + parser->getTokens(); + *parser >> tmp->fLineThickness; + i=0; + parser->getTokens(); + *parser >> token; + do + { + str=AnsiString(token.c_str()); + TempVerts[i].Point.x=str.ToDouble(); + parser->getTokens(2); + *parser >> TempVerts[i].Point.y >> TempVerts[i].Point.z; + TempVerts[i].Point.RotateZ(aRotate.z/180*M_PI); + TempVerts[i].Point.RotateX(aRotate.x/180*M_PI); + TempVerts[i].Point.RotateY(aRotate.y/180*M_PI); + TempVerts[i].Point+=pOrigin; + tmp->pCenter+=TempVerts[i].Point; + i++; + parser->getTokens(); + *parser >> token; + } while (token.compare("endline")!=0); + nv=i; +// tmp->Init(nv); + tmp->Points=new vector3[nv]; + tmp->iNumPts=nv; + tmp->pCenter/=(nv>0?nv:1); + for (int i=0;iPoints[i]=TempVerts[i].Point; + break; + } + return tmp; +} + +TSubRect* __fastcall TGround::FastGetSubRect(int iCol, int iRow) +{ + int br,bc,sr,sc; + br=iRow/iNumSubRects; + bc=iCol/iNumSubRects; + sr=iRow-br*iNumSubRects; + sc=iCol-bc*iNumSubRects; + if ( (br<0) || (bc<0) || (br>=iNumRects) || (bc>=iNumRects) ) return NULL; + return (Rects[br][bc].FastGetRect(sc,sr)); +} + +TSubRect* __fastcall TGround::GetSubRect(int iCol,int iRow) +{//znalezienie małego kwadratu mapy + int br,bc,sr,sc; + br=iRow/iNumSubRects; //współrzędne kwadratu kilometrowego + bc=iCol/iNumSubRects; + sr=iRow-br*iNumSubRects; //współrzędne wzglęne małego kwadratu + sc=iCol-bc*iNumSubRects; + if ( (br<0) || (bc<0) || (br>=iNumRects) || (bc>=iNumRects) ) + return NULL; //jeśli poza mapą + return (Rects[br][bc].SafeGetRect(sc,sr)); //pobranie małego kwadratu +} + +TEvent* __fastcall TGround::FindEvent(const AnsiString &asEventName) +{ + return (TEvent*)sTracks->Find(0,asEventName.c_str()); //wyszukiwanie w drzewie +/* //powolna wyszukiwarka + for (TEvent *Current=RootEvent;Current;Current=Current->Next2) + { + if (Current->asName==asEventName) + return Current; + } + return NULL; +*/ +} + +TEvent* __fastcall TGround::FindEventScan(const AnsiString &asEventName) +{//wyszukanie eventu z opcją utworzenia niejawnego dla komórek skanowanych + TEvent *e=(TEvent*)sTracks->Find(0,asEventName.c_str()); //wyszukiwanie w drzewie eventów + if (e) return e; //jak istnieje, to w porządku + if (asEventName.SubString(asEventName.Length()-4,5)==":scan") //jeszcze może być event niejawny + {//no to szukamy komórki pamięci o nazwie zawartej w evencie + AnsiString n=asEventName.SubString(1,asEventName.Length()-5); //do dwukropka + if (sTracks->Find(TP_MEMCELL,n.c_str())) //jeśli jest takowa komórka pamięci + e=new TEvent(n); //utworzenie niejawnego eventu jej odczytu + } + return e; //utworzony albo się nie udało +} + +void __fastcall TGround::FirstInit() +{//ustalanie zależności na scenerii przed wczytaniem pojazdów + if (bInitDone) return; //Ra: żeby nie robiło się dwa razy + bInitDone=true; + WriteLog("InitNormals"); + int i,j; + for (i=0;inNext) + { + Current->InitNormals(); + if (Current->iType!=TP_DYNAMIC) + {//pojazdów w ogóle nie dotyczy dodawanie do mapy + if (i==TP_EVLAUNCH?Current->EvLaunch->IsGlobal():false) + srGlobal.NodeAdd(Current); //dodanie do globalnego obiektu + else if (i==TP_TERRAIN) + {//specjalne przetwarzanie terenu wczytanego z pliku E3D + AnsiString xxxzzz; //nazwa kwadratu + TGroundRect *gr; + for (j=1;jiCount;++j) + {//od 1 do końca są zestawy trójkątów + xxxzzz=AnsiString(Current->nNode[j].smTerrain->pName); //pobranie nazwy + gr=GetRect(1000*(xxxzzz.SubString(1,3).ToIntDef(0)-500),1000*(xxxzzz.SubString(4,3).ToIntDef(0)-500)); + if (Global::bUseVBO) + gr->nTerrain=Current->nNode+j; //zapamiętanie + else + gr->RaNodeAdd(&Current->nNode[j]); + } + } +// else if ((Current->iType!=GL_TRIANGLES)&&(Current->iType!=GL_TRIANGLE_STRIP)?true //~czy trójkąt? + else if ((Current->iType!=GL_TRIANGLES)?true //~czy trójkąt? + :(Current->iFlags&0x20)?true //~czy teksturę ma nieprzezroczystą? + :(Current->fSquareMinRadius!=0.0)?true //~czy widoczny z bliska? + :(Current->fSquareRadius<=90000.0)) //~czy widoczny z daleka? + GetSubRect(Current->pCenter.x,Current->pCenter.z)->NodeAdd(Current); + else //dodajemy do kwadratu kilometrowego + GetRect(Current->pCenter.x,Current->pCenter.z)->NodeAdd(Current); + } + //if (Current->iType!=TP_DYNAMIC) + // GetSubRect(Current->pCenter.x,Current->pCenter.z)->AddNode(Current); + } + } + for (i=0;i0) + { + glFogi(GL_FOG_MODE, GL_LINEAR); + glFogfv(GL_FOG_COLOR, Global::FogColor); // set fog color + glFogf(GL_FOG_START, Global::fFogStart); // fog start depth + glFogf(GL_FOG_END, Global::fFogEnd); // fog end depth + glEnable(GL_FOG); + } + else + glDisable(GL_FOG); + glDisable(GL_LIGHTING); + glLightfv(GL_LIGHT0,GL_POSITION,Global::lightPos); //daylight position + glLightfv(GL_LIGHT0,GL_AMBIENT,Global::ambientDayLight); //kolor wszechobceny + glLightfv(GL_LIGHT0,GL_DIFFUSE,Global::diffuseDayLight); //kolor padający + glLightfv(GL_LIGHT0,GL_SPECULAR,Global::specularDayLight); //kolor odbity + //musi być tutaj, bo wcześniej nie mieliśmy wartości światła + if (Global::fMoveLight>=0.0) //albo tak, albo niech ustala minimum ciemności w nocy + { + Global::fLuminance= //obliczenie luminacji "światła w ciemności" + +0.150*Global::ambientDayLight[0] //R + +0.295*Global::ambientDayLight[1] //G + +0.055*Global::ambientDayLight[2]; //B + if (Global::fLuminance>0.1) //jeśli miało by być za jasno + for (int i=0;i<3;i++) + Global::ambientDayLight[i]*=0.1/Global::fLuminance; //ograniczenie jasności w nocy + glLightModelfv(GL_LIGHT_MODEL_AMBIENT,Global::ambientDayLight); + } + else if (Global::bDoubleAmbient) //Ra: wcześniej było ambient dawane na obydwa światła + glLightModelfv(GL_LIGHT_MODEL_AMBIENT,Global::ambientDayLight); + glEnable(GL_LIGHTING); + WriteLog("FirstInit is done"); +}; + +bool __fastcall TGround::Init(AnsiString asFile,HDC hDC) +{//główne wczytywanie scenerii + if (asFile.LowerCase().SubString(1,7)=="scenery") + asFile.Delete(1,8); //Ra: usunięcie niepotrzebnych znaków - zgodność wstecz z 2003 + WriteLog("Loading scenery from "+asFile); + Global::pGround=this; + //pTrain=NULL; + pOrigin=aRotate=vector3(0,0,0); //zerowanie przesunięcia i obrotu + AnsiString str=""; + //TFileStream *fs; + //int size; + std::string subpath=Global::asCurrentSceneryPath.c_str(); // "scenery/"; + cParser parser(asFile.c_str(),cParser::buffer_FILE,subpath,Global::bLoadTraction); + std::string token; + +/* + TFileStream *fs; + fs=new TFileStream(asFile , fmOpenRead | fmShareCompat ); + AnsiString str=""; + int size=fs->Size; + str.SetLength(size); + fs->Read(str.c_str(),size); + str+=""; + delete fs; + TQueryParserComp *Parser; + Parser=new TQueryParserComp(NULL); + Parser->TextToParse=str; +// Parser->LoadStringToParse(asFile); + Parser->First(); + AnsiString Token,asFileName; +*/ + const int OriginStackMaxDepth=100; //rozmiar stosu dla zagnieżdżenia origin + int OriginStackTop=0; + vector3 OriginStack[OriginStackMaxDepth]; //stos zagnieżdżenia origin + + double tf; + int ParamCount,ParamPos; + + //ABu: Jezeli nie ma definicji w scenerii to ustawiane ponizsze wartosci: + hh=10; //godzina startu + mm=30; //minuty startu + srh=6; //godzina wschodu slonca + srm=0; //minuty wschodu slonca + ssh=20; //godzina zachodu slonca + ssm=0; //minuty zachodu slonca + TGroundNode *LastNode=NULL; //do użycia w trainset + iNumNodes=0; + token=""; + parser.getTokens(); + parser >> token; + int refresh=0; + + while (token!="") //(!Parser->EndOfFile) + { + if (refresh==50) + {//SwapBuffers(hDC); //Ra: bez ogranicznika za bardzo spowalnia :( a u niektórych miga + refresh=0; + Global::DoEvents(); + } + else ++refresh; + str=AnsiString(token.c_str()); + if (str==AnsiString("node")) + { + LastNode=AddGroundNode(&parser); //rozpoznanie węzła + if (LastNode) + {//jeżeli przetworzony poprawnie + if (LastNode->iType==GL_TRIANGLES) + {if (!LastNode->Vertices) + SafeDelete(LastNode); //usuwamy nieprzezroczyste trójkąty terenu + } + else if (Global::bLoadTraction?false:LastNode->iType==TP_TRACTION) + SafeDelete(LastNode); //usuwamy druty, jeśli wyłączone + if (LastNode) //dopiero na koniec dopisujemy do tablic + if (LastNode->iType!=TP_DYNAMIC) + {//jeśli nie jest pojazdem + LastNode->nNext=nRootOfType[LastNode->iType]; //ostatni dodany dołączamy na końcu nowego + nRootOfType[LastNode->iType]=LastNode; //ustawienie nowego na początku listy + iNumNodes++; + } + else + {//jeśli jest pojazdem + //if (!bInitDone) FirstInit(); //jeśli nie było w scenerii + if (LastNode->DynamicObject->Mechanik) //ale może być pasażer + if (LastNode->DynamicObject->Mechanik->Primary()) //jeśli jest głównym (pasażer nie jest) + nTrainSetDriver=LastNode; //pojazd, któremu zostanie wysłany rozkład + LastNode->nNext=nRootDynamic; + nRootDynamic=LastNode; //dopisanie z przodu do listy + //if (bTrainSet && (LastNode?(LastNode->iType==TP_DYNAMIC):false)) + if (nTrainSetNode) //jeżeli istnieje wcześniejszy TP_DYNAMIC + nTrainSetNode->DynamicObject->AttachPrev(LastNode->DynamicObject,TempConnectionType[iTrainSetWehicleNumber-2]); + nTrainSetNode=LastNode; //ostatnio wczytany + if (TempConnectionType[iTrainSetWehicleNumber-1]==0) //jeśli sprzęg jest zerowy, to wysłać rozkład do składu + {//powinien też tu wchodzić, gdy pojazd bez trainset + if (nTrainSetDriver) //pojazd, któremu zostanie wysłany rozkład + {//wysłanie komendy "Timetable" ustawia odpowiedni tryb jazdy + nTrainSetDriver->DynamicObject->Mechanik->DirectionInitial(); + nTrainSetDriver->DynamicObject->Mechanik->PutCommand("Timetable:"+asTrainName,fTrainSetVel,0,NULL); + nTrainSetDriver=NULL; //a przy "endtrainset" już wtedy nie potrzeba + } + } + } + } + else + { + Error("Scene parse error near "+AnsiString(token.c_str())); + //break; + } + } + else + if (str==AnsiString("trainset")) + { + iTrainSetWehicleNumber=0; + nTrainSetNode=NULL; + nTrainSetDriver=NULL; //pojazd, któremu zostanie wysłany rozkład + bTrainSet=true; + parser.getTokens(); + parser >> token; + asTrainName=AnsiString(token.c_str()); //McZapkie: rodzaj+nazwa pociagu w SRJP + parser.getTokens(); + parser >> token; + asTrainSetTrack=AnsiString(token.c_str()); //ścieżka startowa + parser.getTokens(2); + parser >> fTrainSetDist >> fTrainSetVel; //przesunięcie i prędkość + } + else + if (str==AnsiString("endtrainset")) + {//McZapkie-110103: sygnaly konca pociagu ale tylko dla pociagow rozkladowych + if (nTrainSetNode) //trainset bez dynamic się sypał + {//powinien też tu wchodzić, gdy pojazd bez trainset + if (nTrainSetDriver) //pojazd, któremu zostanie wysłany rozkład + {//wysłanie komendy "Timetable" ustawia odpowiedni tryb jazdy + nTrainSetDriver->DynamicObject->Mechanik->DirectionInitial(); + nTrainSetDriver->DynamicObject->Mechanik->PutCommand("Timetable:"+asTrainName,fTrainSetVel,0,NULL); + } + } + if (LastNode) //ostatni wczytany obiekt + if (LastNode->iType==TP_DYNAMIC) //o ile jest pojazdem (na ogół jest, ale kto wie...) + if (iTrainSetWehicleNumber?!TempConnectionType[iTrainSetWehicleNumber-1]:false) //jeśli ostatni pojazd ma sprzęg 0 + LastNode->DynamicObject->RaLightsSet(-1,2+32+64); //to założymy mu końcówki blaszane (jak AI się odpali, to sobie poprawi) + bTrainSet=false; + fTrainSetVel=0; + //iTrainSetConnection=0; + nTrainSetNode=nTrainSetDriver=NULL; + iTrainSetWehicleNumber=0; + } + else if (str==AnsiString("event")) + { + TEvent *tmp=new TEvent(); + tmp->Load(&parser,&pOrigin); + if (tmp->Type==tp_Unknown) + delete tmp; + else + {//najpierw sprawdzamy, czy nie ma, a potem dopisujemy + TEvent *found=FindEvent(tmp->asName); + if (found) + {//jeśli znaleziony duplikat + int i=tmp->asName.Length(); + if (tmp->asName[1]=='#') //zawsze jeden znak co najmniej jest + {delete tmp; tmp=NULL;} //utylizacja duplikatu z krzyżykiem + else if (i>8?tmp->asName.SubString(1,9)=="lineinfo:":false) //tymczasowo wyjątki + {delete tmp; tmp=NULL;} //tymczasowa utylizacja duplikatów W5 + else if (i>8?tmp->asName.SubString(i-7,8)=="_warning":false) //tymczasowo wyjątki + {delete tmp; tmp=NULL;} //tymczasowa utylizacja duplikatu z trąbieniem + else if (i>4?tmp->asName.SubString(i-3,4)=="_shp":false) //nie podlegają logowaniu + {delete tmp; tmp=NULL;} //tymczasowa utylizacja duplikatu SHP + if (tmp) //jeśli nie został zutylizowany + if (Global::bJoinEvents) + found->Append(tmp); //doczepka (taki wirtualny multiple bez warunków) + else + {ErrorLog("Duplicated event: "+tmp->asName); + found->Append(tmp); //doczepka (taki wirtualny multiple bez warunków) + found->Type=tp_Ignored; //dezaktywacja pierwotnego - taka proteza na wsteczną zgodność + //SafeDelete(tmp); //bezlitośnie usuwamy wszelkie duplikaty, żeby nie zaśmiecać drzewka + } + } + if (tmp) + {//jeśli nie duplikat + tmp->evNext2=RootEvent; //lista wszystkich eventów (m.in. do InitEvents) + RootEvent=tmp; + if (!found) + {//jeśli nazwa wystąpiła, to do kolejki i wyszukiwarki dodawany jest tylko pierwszy + if (RootEvent->Type!=tp_Ignored) + if (RootEvent->asName.Pos("onstart")) //event uruchamiany automatycznie po starcie + AddToQuery(RootEvent,NULL); //dodanie do kolejki + sTracks->Add(0,tmp->asName.c_str(),tmp); //dodanie do wyszukiwarki + } + } + } + } +// else +// if (str==AnsiString("include")) //Tolaris to zrobil wewnatrz parsera +// { +// Include(Parser); +// } + else if (str==AnsiString("rotate")) + { + //parser.getTokens(3); + //parser >> aRotate.x >> aRotate.y >> aRotate.z; //Ra: to potrafi dawać błędne rezultaty + parser.getTokens(); parser >> aRotate.x; + parser.getTokens(); parser >> aRotate.y; + parser.getTokens(); parser >> aRotate.z; + //WriteLog("*** rotate "+AnsiString(aRotate.x)+" "+AnsiString(aRotate.y)+" "+AnsiString(aRotate.z)); + } + else if (str==AnsiString("origin")) + { +// str=Parser->GetNextSymbol().LowerCase(); +// if (str=="begin") + { + if (OriginStackTop>=OriginStackMaxDepth-1) + { + MessageBox(0,AnsiString("Origin stack overflow ").c_str(),"Error",MB_OK); + break; + } + parser.getTokens(3); + parser >> OriginStack[OriginStackTop].x >> OriginStack[OriginStackTop].y >> OriginStack[OriginStackTop].z; + pOrigin+=OriginStack[OriginStackTop]; //sumowanie całkowitego przesunięcia + OriginStackTop++; //zwiększenie wskaźnika stosu + } + } + else if (str==AnsiString("endorigin")) + { +// else + // if (str=="end") + { + if (OriginStackTop<=0) + { + MessageBox(0,AnsiString("Origin stack underflow ").c_str(),"Error",MB_OK); + break; + } + + OriginStackTop--; //zmniejszenie wskaźnika stosu + pOrigin-=OriginStack[OriginStackTop]; + } + } + else if (str==AnsiString("atmo")) //TODO: uporzadkowac gdzie maja byc parametry mgly! + {//Ra: ustawienie parametrów OpenGL przeniesione do FirstInit + WriteLog("Scenery atmo definition"); + parser.getTokens(3); + parser >> Global::AtmoColor[0] >> Global::AtmoColor[1] >> Global::AtmoColor[2]; + parser.getTokens(2); + parser >> Global::fFogStart >> Global::fFogEnd; + if (Global::fFogEnd>0.0) + {//ostatnie 3 parametry są opcjonalne + parser.getTokens(3); + parser >> Global::FogColor[0] >> Global::FogColor[1] >> Global::FogColor[2]; + } + parser.getTokens(); + parser >> token; + while (token.compare("endatmo")!=0) + {//a kolejne parametry są pomijane + parser.getTokens(); + parser >> token; + } + } + else if (str==AnsiString("time")) + { + WriteLog("Scenery time definition"); + char temp_in[9]; + char temp_out[9]; + int i, j; + parser.getTokens(); + parser >> temp_in; + for(j=0;j<=8;j++) temp_out[j]=' '; + for (i=0; temp_in[i]!=':'; i++) + temp_out[i]=temp_in[i]; + hh=atoi(temp_out); + for(j=0;j<=8;j++) temp_out[j]=' '; + for (j=i+1; j<=8; j++) + temp_out[j-(i+1)]=temp_in[j]; + mm=atoi(temp_out); + + + parser.getTokens(); + parser >> temp_in; + for(j=0;j<=8;j++) temp_out[j]=' '; + for (i=0; temp_in[i]!=':'; i++) + temp_out[i]=temp_in[i]; + srh=atoi(temp_out); + for(j=0;j<=8;j++) temp_out[j]=' '; + for (j=i+1; j<=8; j++) + temp_out[j-(i+1)]=temp_in[j]; + srm=atoi(temp_out); + + parser.getTokens(); + parser >> temp_in; + for(j=0;j<=8;j++) temp_out[j]=' '; + for (i=0; temp_in[i]!=':'; i++) + temp_out[i]=temp_in[i]; + ssh=atoi(temp_out); + for(j=0;j<=8;j++) temp_out[j]=' '; + for (j=i+1; j<=8; j++) + temp_out[j-(i+1)]=temp_in[j]; + ssm=atoi(temp_out); + while (token.compare("endtime")!=0) + { + parser.getTokens(); + parser >> token; + } + } + else if (str==AnsiString("light")) + {//Ra: ustawianie światła przeniesione do FirstInit + WriteLog("Scenery light definition"); + vector3 lp; + parser.getTokens(); parser >> lp.x; + parser.getTokens(); parser >> lp.y; + parser.getTokens(); parser >> lp.z; + lp=Normalize(lp); //kierunek padania + Global::lightPos[0]=lp.x; //daylight position + Global::lightPos[1]=lp.y; + Global::lightPos[2]=lp.z; + parser.getTokens(); parser >> Global::ambientDayLight[0]; //kolor wszechobceny + parser.getTokens(); parser >> Global::ambientDayLight[1]; + parser.getTokens(); parser >> Global::ambientDayLight[2]; + + parser.getTokens(); parser >> Global::diffuseDayLight[0]; //kolor padający + parser.getTokens(); parser >> Global::diffuseDayLight[1]; + parser.getTokens(); parser >> Global::diffuseDayLight[2]; + + parser.getTokens(); parser >> Global::specularDayLight[0]; //kolor odbity + parser.getTokens(); parser >> Global::specularDayLight[1]; + parser.getTokens(); parser >> Global::specularDayLight[2]; + + do + { parser.getTokens(); parser >> token; + } while (token.compare("endlight")!=0); + + } + else if (str==AnsiString("camera")) + { + vector3 xyz,abc; + xyz=abc=vector3(0,0,0); //wartości domyślne, bo nie wszystie muszą być + int i=-1,into=-1; //do której definicji kamery wstawić + WriteLog("Scenery camera definition"); + do + {//opcjonalna siódma liczba określa numer kamery, a kiedyś były tylko 3 + parser.getTokens(); parser >> token; + switch (++i) + {//kiedyś camera miało tylko 3 współrzędne + case 0: xyz.x=atof(token.c_str()); break; + case 1: xyz.y=atof(token.c_str()); break; + case 2: xyz.z=atof(token.c_str()); break; + case 3: abc.x=atof(token.c_str()); break; + case 4: abc.y=atof(token.c_str()); break; + case 5: abc.z=atof(token.c_str()); break; + case 6: into=atoi(token.c_str()); //takie sobie, bo można wpisać -1 + } + } while (token.compare("endcamera")!=0); + if (into<0) into=++Global::iCameraLast; + if ((into>=0)&&(into<10)) + {//przepisanie do odpowiedniego miejsca w tabelce + Global::pFreeCameraInit[into]=xyz; + abc.x=DegToRad(abc.x); + abc.y=DegToRad(abc.y); + abc.z=DegToRad(abc.z); + Global::pFreeCameraInitAngle[into]=abc; + Global::iCameraLast=into; //numer ostatniej + } + } + else if (str==AnsiString("sky")) + {//youBy - niebo z pliku + WriteLog("Scenery sky definition"); + parser.getTokens(); + parser >> token; + AnsiString SkyTemp; + SkyTemp=AnsiString(token.c_str()); + if (Global::asSky=="1") Global::asSky=SkyTemp; + do + {//pożarcie dodatkowych parametrów + parser.getTokens(); parser >> token; + } while (token.compare("endsky")!=0); + WriteLog(Global::asSky.c_str()); + } + else if (str==AnsiString("firstinit")) + FirstInit(); + else if (str==AnsiString("description")) + { + do + { + parser.getTokens(); + parser >> token; + } while (token.compare("enddescription")!=0); + } + else if (str==AnsiString("test")) + {//wypisywanie treści po przetworzeniu + WriteLog("---> Parser test:"); + do + { + parser.getTokens(); + parser >> token; + WriteLog(token.c_str()); + } while (token.compare("endtest")!=0); + WriteLog("---> End of parser test."); + } + else if (str==AnsiString("config")) + {//możliwość przedefiniowania parametrów w scenerii + Global::ConfigParse(NULL,&parser); //parsowanie dodatkowych ustawień + } + else if (str!=AnsiString("")) + {//pomijanie od nierozpoznanej komendy do jej zakończenia + if ((token.length()>2)&&(atof(token.c_str())==0.0)) + {//jeśli nie liczba, to spróbować pominąć komendę + WriteLog(AnsiString("Unrecognized command: "+str)); + str="end"+str; + do + { + parser.getTokens(); + token=""; + parser >> token; + } while ((token!="")&&(token.compare(str.c_str())!=0)); + } + else //jak liczba to na pewno błąd + Error(AnsiString("Unrecognized command: "+str)); + } + else + if (str==AnsiString("")) + break; + + //LastNode=NULL; + + token=""; + parser.getTokens(); + parser >> token; + } + + delete parser; + sTracks->Sort(TP_TRACK); //finalne sortowanie drzewa torów + sTracks->Sort(TP_MEMCELL); //finalne sortowanie drzewa komórek pamięci + sTracks->Sort(TP_MODEL); //finalne sortowanie drzewa modeli + sTracks->Sort(0); //finalne sortowanie drzewa eventów + if (!bInitDone) FirstInit(); //jeśli nie było w scenerii + if (Global::pTerrainCompact) + TerrainWrite(); //Ra: teraz można zapisać teren w jednym pliku + Global::iPause&=~0x10; //koniec pauzy wczytywania + return true; +} + +bool __fastcall TGround::InitEvents() +{//łączenie eventów z pozostałymi obiektami + TGroundNode *tmp,*trk; + char buff[255]; + int i; + for (TEvent *Current=RootEvent;Current;Current=Current->evNext2) + { + switch (Current->Type) + { + case tp_AddValues: //sumowanie wartości + case tp_UpdateValues: //zmiana wartości + tmp=FindGroundNode(Current->asNodeName,TP_MEMCELL); //nazwa komórki powiązanej z eventem + if (tmp) + {//McZapkie-100302 + if (Current->iFlags&(conditional_trackoccupied|conditional_trackfree)) + {//jeśli chodzi o zajetosc toru (tor może być inny, niż wpisany w komórce) + trk=FindGroundNode(Current->asNodeName,TP_TRACK); //nazwa toru ta sama, co nazwa komórki + if (trk) Current->Params[9].asTrack=trk->pTrack; + if (!Current->Params[9].asTrack) + ErrorLog("Bad event: track \""+AnsiString(Current->asNodeName)+"\" does not exists in \""+Current->asName+"\""); + } + Current->Params[4].nGroundNode=tmp; + Current->Params[5].asMemCell=tmp->MemCell; //komórka do aktualizacji + if (Current->iFlags&(conditional_memcompare)) + Current->Params[9].asMemCell=tmp->MemCell; //komórka do badania warunku + if (!tmp->MemCell->asTrackName.IsEmpty()) //tor powiązany z komórką powiązaną z eventem + {//tu potrzebujemy wskaźnik do komórki w (tmp) + trk=FindGroundNode(tmp->MemCell->asTrackName,TP_TRACK); + if (trk) + Current->Params[6].asTrack=trk->pTrack; + else + ErrorLog("Bad memcell: track \""+tmp->MemCell->asTrackName+"\" not exists in memcell \""+tmp->asName+"\""); + } + else + Current->Params[6].asTrack=NULL; + } + else + {//nie ma komórki, to nie będzie działał poprawnie + Current->Type=tp_Ignored; //deaktywacja + ErrorLog("Bad event: \""+Current->asName+"\" cannot find memcell \""+Current->asNodeName+"\""); + } + break; + case tp_LogValues: //skojarzenie z memcell + if (Current->asNodeName.IsEmpty()) + {//brak skojarzenia daje logowanie wszystkich + Current->Params[9].asMemCell=NULL; + break; + } + case tp_GetValues: + case tp_WhoIs: + tmp=FindGroundNode(Current->asNodeName,TP_MEMCELL); + if (tmp) + { + Current->Params[8].nGroundNode=tmp; + Current->Params[9].asMemCell=tmp->MemCell; + if (Current->Type==tp_GetValues) //jeśli odczyt komórki + if (tmp->MemCell->IsVelocity()) //a komórka zawiera komendę SetVelocity albo ShuntVelocity + Current->bEnabled=false; //to event nie będzie dodawany do kolejki + } + else + {//nie ma komórki, to nie będzie działał poprawnie + Current->Type=tp_Ignored; //deaktywacja + ErrorLog("Bad event: \""+Current->asName+"\" cannot find memcell \""+Current->asNodeName+"\""); + } + break; + case tp_CopyValues: //skopiowanie komórki do innej + tmp=FindGroundNode(Current->asNodeName,TP_MEMCELL); //komórka docelowa + if (tmp) + { + Current->Params[4].nGroundNode=tmp; + Current->Params[5].asMemCell=tmp->MemCell; //komórka docelowa + if (!tmp->MemCell->asTrackName.IsEmpty()) //tor powiązany z komórką powiązaną z eventem + {//tu potrzebujemy wskaźnik do komórki w (tmp) + trk=FindGroundNode(tmp->MemCell->asTrackName,TP_TRACK); + if (trk) + Current->Params[6].asTrack=trk->pTrack; + else + ErrorLog("Bad memcell: track \""+tmp->MemCell->asTrackName+"\" not exists in memcell \""+tmp->asName+"\""); + } + else + Current->Params[6].asTrack=NULL; + } + else + ErrorLog("Bad copyvalues: event \""+Current->asName+"\" cannot find memcell \""+Current->asNodeName+"\""); + strcpy(buff,Current->Params[9].asText); //skopiowanie nazwy drugiej komórki do bufora roboczego + SafeDeleteArray(Current->Params[9].asText); //usunięcie nazwy komórki + tmp=FindGroundNode(buff,TP_MEMCELL); //komórka źódłowa + if (tmp) + { + Current->Params[8].nGroundNode=tmp; + Current->Params[9].asMemCell=tmp->MemCell; //komórka źródłowa + } + else + ErrorLog("Bad copyvalues: event \""+Current->asName+"\" cannot find memcell \""+AnsiString(buff)+"\""); + break; + case tp_Animation: //animacja modelu + tmp=FindGroundNode(Current->asNodeName,TP_MODEL); //egzemplarza modelu do animowania + if (tmp) + { + strcpy(buff,Current->Params[9].asText); //skopiowanie nazwy submodelu do bufora roboczego + SafeDeleteArray(Current->Params[9].asText); //usunięcie nazwy submodelu + if (Current->Params[0].asInt==4) + Current->Params[9].asModel=tmp->Model; //model dla całomodelowych animacji + else + {//standardowo przypisanie submodelu + Current->Params[9].asAnimContainer=tmp->Model->GetContainer(buff); //submodel + if (Current->Params[9].asAnimContainer) + {Current->Params[9].asAnimContainer->WillBeAnimated(); //oflagowanie animacji + if (!Current->Params[9].asAnimContainer->Event()) //nie szukać, gdy znaleziony + Current->Params[9].asAnimContainer->EventAssign(FindEvent(Current->asNodeName+"."+AnsiString(buff)+":done")); + } + } + } + else + ErrorLog("Bad animation: event \""+Current->asName+"\" cannot find model \""+Current->asNodeName+"\""); + Current->asNodeName=""; + break; + case tp_Lights: //zmiana świeteł modelu + tmp=FindGroundNode(Current->asNodeName,TP_MODEL); + if (tmp) + Current->Params[9].asModel=tmp->Model; + else + ErrorLog("Bad lights: event \""+Current->asName+"\" cannot find model \""+Current->asNodeName+"\""); + Current->asNodeName=""; + break; + case tp_Visible: //ukrycie albo przywrócenie obiektu + tmp=FindGroundNode(Current->asNodeName,TP_MODEL); //najpierw model + if (!tmp) tmp=FindGroundNode(Current->asNodeName,TP_TRACTION); //może druty? + if (!tmp) tmp=FindGroundNode(Current->asNodeName,TP_TRACK); //albo tory? + if (tmp) + Current->Params[9].nGroundNode=tmp; + else + ErrorLog("Bad visibility: event \""+Current->asName+"\" cannot find model \""+Current->asNodeName+"\""); + Current->asNodeName=""; + break; + case tp_Switch: //przełożenie zwrotnicy albo zmiana stanu obrotnicy + tmp=FindGroundNode(Current->asNodeName,TP_TRACK); + if (tmp) + {//dowiązanie toru + if (!tmp->pTrack->iAction) //jeśli nie jest zwrotnicą ani obrotnicą + tmp->pTrack->iAction|=0x100; //to będzie się zmieniał stan uszkodzenia + Current->Params[9].asTrack=tmp->pTrack; + if (!Current->Params[0].asInt) //jeśli przełącza do stanu 0 + if (Current->Params[2].asdouble>=0.0) //jeśli jest zdefiniowany dodatkowy ruch iglic + Current->Params[9].asTrack->Switch(0,Current->Params[1].asdouble,Current->Params[2].asdouble); //przesłanie parametrów + } + else + ErrorLog("Bad switch: event \""+Current->asName+"\" cannot find track \""+Current->asNodeName+"\""); + Current->asNodeName=""; + break; + case tp_Sound: //odtworzenie dźwięku + tmp=FindGroundNode(Current->asNodeName,TP_SOUND); + if (tmp) + Current->Params[9].tsTextSound=tmp->tsStaticSound; + else + ErrorLog("Bad sound: event \""+Current->asName+"\" cannot find static sound \""+Current->asNodeName+"\""); + Current->asNodeName=""; + break; + case tp_TrackVel: //ustawienie prędkości na torze + if (!Current->asNodeName.IsEmpty()) + { + tmp=FindGroundNode(Current->asNodeName,TP_TRACK); + if (tmp) + {tmp->pTrack->iAction|=0x200; //flaga zmiany prędkości toru jest istotna dla skanowania + Current->Params[9].asTrack=tmp->pTrack; + } + else + ErrorLog("Bad velocity: event \""+Current->asName+"\" cannot find track \""+Current->asNodeName+"\""); + } + Current->asNodeName= ""; + break; + case tp_DynVel: //komunikacja z pojazdem o konkretnej nazwie + if (Current->asNodeName=="activator") + Current->Params[9].asDynamic=NULL; + else + { + tmp=FindGroundNode(Current->asNodeName,TP_DYNAMIC); + if (tmp) + Current->Params[9].asDynamic= tmp->DynamicObject; + else + Error("Event \""+Current->asName+"\" cannot find dynamic \""+Current->asNodeName+"\""); + } + Current->asNodeName= ""; + break; + case tp_Multiple: + if (Current->Params[9].asText!=NULL) + {//przepisanie nazwy do bufora + strcpy(buff,Current->Params[9].asText); + SafeDeleteArray(Current->Params[9].asText); + Current->Params[9].asPointer=NULL; //zerowanie wskaźnika, aby wykryć brak obeiktu + } + else buff[0]='\0'; + if (Current->iFlags&(conditional_trackoccupied|conditional_trackfree)) + {//jeśli chodzi o zajetosc toru + tmp=FindGroundNode(buff,TP_TRACK); + if (tmp) Current->Params[9].asTrack=tmp->pTrack; + if (!Current->Params[9].asTrack) + {ErrorLog(AnsiString("Bad event: Track \"")+AnsiString(buff)+"\" does not exist in \""+Current->asName+"\""); + Current->iFlags&=~(conditional_trackoccupied|conditional_trackfree); //zerowanie flag + } + } + else if (Current->iFlags&(conditional_memstring|conditional_memval1|conditional_memval2)) + {//jeśli chodzi o komorke pamieciową + tmp=FindGroundNode(buff,TP_MEMCELL); + if (tmp) Current->Params[9].asMemCell=tmp->MemCell; + if (!Current->Params[9].asMemCell) + {ErrorLog(AnsiString("Bad event: MemCell \"")+AnsiString(buff)+AnsiString("\" does not exist in \""+Current->asName+"\"")); + Current->iFlags&=~(conditional_memstring|conditional_memval1|conditional_memval2); + } + } + for (i=0;i<8;i++) + { + if (Current->Params[i].asText!=NULL) + { + strcpy(buff,Current->Params[i].asText); + SafeDeleteArray(Current->Params[i].asText); + Current->Params[i].asEvent=FindEvent(buff); + if (!Current->Params[i].asEvent) //Ra: tylko w logu informacja o braku + if (AnsiString(Current->Params[i].asText).SubString(1,5)!="none_") + {WriteLog(AnsiString("Event \"")+AnsiString(buff)+AnsiString("\" does not exist")); + ErrorLog("Missed event: "+AnsiString(buff)+" in multiple "+Current->asName); + } + } + } + break; + case tp_Voltage: //zmiana napięcia w zasilaczu (TractionPowerSource) + if (!Current->asNodeName.IsEmpty()) + { + tmp=FindGroundNode(Current->asNodeName,TP_TRACTIONPOWERSOURCE); //podłączenie zasilacza + if (tmp) + Current->Params[9].psPower=tmp->psTractionPowerSource; + else + ErrorLog("Bad voltage: event \""+Current->asName+"\" cannot find power source \""+Current->asNodeName+"\""); + } + Current->asNodeName= ""; + break; + case tp_Message: //wyświetlenie komunikatu + break; + } + if (Current->fDelay<0) + AddToQuery(Current,NULL); + } + for (TGroundNode *Current=nRootOfType[TP_MEMCELL];Current;Current=Current->nNext) + {//Ra: eventy komórek pamięci, wykonywane po wysłaniu komendy do zatrzymanego pojazdu + Current->MemCell->AssignEvents(FindEvent(Current->asName+":sent")); + } + return true; +} + +void __fastcall TGround::InitTracks() +{//łączenie torów ze sobą i z eventami + TGroundNode *Current,*Model; + TTrack *tmp; //znaleziony tor + TTrack *Track; + int iConnection,state; + AnsiString name; + //tracks=tracksfar=0; + for (Current=nRootOfType[TP_TRACK];Current;Current=Current->nNext) + { + Track=Current->pTrack; + if (Global::iHiddenEvents&1) + if (!Current->asName.IsEmpty()) + {//jeśli podana jest nazwa torów, można szukać eventów skojarzonych przez nazwę + if (Track->asEvent1Name.IsEmpty()) + if (FindEvent(Current->asName+":event1")) + Track->asEvent1Name=Current->asName+":event1"; + if (Track->asEvent2Name.IsEmpty()) + if (FindEvent(Current->asName+":event2")) + Track->asEvent2Name=Current->asName+":event2"; + } + Track->AssignEvents( + Track->asEvent0Name.IsEmpty()?NULL:FindEvent(Track->asEvent0Name), + Track->asEvent1Name.IsEmpty()?NULL:FindEventScan(Track->asEvent1Name), + Track->asEvent2Name.IsEmpty()?NULL:FindEventScan(Track->asEvent2Name)); + Track->AssignallEvents( + Track->asEventall0Name.IsEmpty()?NULL:FindEvent(Track->asEventall0Name), + Track->asEventall1Name.IsEmpty()?NULL:FindEvent(Track->asEventall1Name), + Track->asEventall2Name.IsEmpty()?NULL:FindEvent(Track->asEventall2Name)); //MC-280503 + switch (Track->eType) + { + case tt_Table: //obrotnicę też łączymy na starcie z innymi torami + Model=FindGroundNode(Current->asName,TP_MODEL); //szukamy modelu o tej samej nazwie + //if (tmp) //mamy model, trzeba zapamiętać wskaźnik do jego animacji + {//jak coś pójdzie źle, to robimy z tego normalny tor + //Track->ModelAssign(tmp->Model->GetContainer(NULL)); //wiązanie toru z modelem obrotnicy + Track->RaAssign(Current,Model?Model->Model:NULL,FindEvent(Current->asName+":done"),FindEvent(Current->asName+":joined")); //wiązanie toru z modelem obrotnicy + //break; //jednak połączę z sąsiednim, jak ma się wysypywać null track + } + if (!Model) //jak nie ma modelu + break; //to pewnie jest wykolejnica, a ta jest domyślnie zamknięta i wykoleja + case tt_Normal: //tylko proste są podłączane do rozjazdów, stąd dwa rozjazdy się nie połączą ze sobą + if (Track->CurrentPrev()==NULL) //tylko jeśli jeszcze nie podłączony + { + tmp=FindTrack(Track->CurrentSegment()->FastGetPoint_0(),iConnection,Current); + switch (iConnection) + { + case -1: //Ra: pierwsza koncepcja zawijania samochodów i statków + //if ((Track->iCategoryFlag&1)==0) //jeśli nie jest torem szynowym + // Track->ConnectPrevPrev(Track,0); //łączenie końca odcinka do samego siebie + break; + case 0: + Track->ConnectPrevPrev(tmp,0); + break; + case 1: + Track->ConnectPrevNext(tmp,1); + break; + case 2: + Track->ConnectPrevPrev(tmp,0); //do Point1 pierwszego + tmp->SetConnections(0); //zapamiętanie ustawień w Segmencie + break; + case 3: + Track->ConnectPrevNext(tmp,1); //do Point2 pierwszego + tmp->SetConnections(0); //zapamiętanie ustawień w Segmencie + break; + case 4: + tmp->Switch(1); + Track->ConnectPrevPrev(tmp,2); //do Point1 drugiego + tmp->SetConnections(1); //robi też Switch(0) + tmp->Switch(0); + break; + case 5: + tmp->Switch(1); + Track->ConnectPrevNext(tmp,3); //do Point2 drugiego + tmp->SetConnections(1); //robi też Switch(0) + tmp->Switch(0); + break; + } + } + if (Track->CurrentNext()==NULL) //tylko jeśli jeszcze nie podłączony + { + tmp=FindTrack(Track->CurrentSegment()->FastGetPoint_1(),iConnection,Current); + switch (iConnection) + { + case -1: //Ra: pierwsza koncepcja zawijania samochodów i statków + //if ((Track->iCategoryFlag&1)==0) //jeśli nie jest torem szynowym + // Track->ConnectNextNext(Track,1); //łączenie końca odcinka do samego siebie + break; + case 0: + Track->ConnectNextPrev(tmp,0); + break; + case 1: + Track->ConnectNextNext(tmp,1); + break; + case 2: + Track->ConnectNextPrev(tmp,0); + tmp->SetConnections(0); //zapamiętanie ustawień w Segmencie + break; + case 3: + Track->ConnectNextNext(tmp,1); + tmp->SetConnections(0); //zapamiętanie ustawień w Segmencie + break; + case 4: + tmp->Switch(1); + Track->ConnectNextPrev(tmp,2); + tmp->SetConnections(1); //robi też Switch(0) + //tmp->Switch(0); + break; + case 5: + tmp->Switch(1); + Track->ConnectNextNext(tmp,3); + tmp->SetConnections(1); //robi też Switch(0) + //tmp->Switch(0); + break; + } + } + break; + case tt_Switch: //dla rozjazdów szukamy eventów sygnalizacji rozprucia + Track->AssignForcedEvents( + FindEvent(Current->asName+":forced+"), + FindEvent(Current->asName+":forced-")); + break; + } + name=Track->IsolatedName(); //pobranie nazwy odcinka izolowanego + if (!name.IsEmpty()) //jeśli została zwrócona nazwa + Track->IsolatedEventsAssign(FindEvent(name+":busy"),FindEvent(name+":free")); + if (Current->asName.SubString(1,1)=="*") //możliwy portal, jeśli nie podłączony od striny 1 + if (!Track->CurrentPrev()&&Track->CurrentNext()) + Track->iCategoryFlag|=0x100; //ustawienie flagi portalu + } + //WriteLog("Total "+AnsiString(tracks)+", far "+AnsiString(tracksfar)); + TIsolated *p=TIsolated::Root(); + while (p) + {//jeśli się znajdzie, to podać wskaźnik + Current=FindGroundNode(p->asName,TP_MEMCELL); //czy jest komóka o odpowiedniej nazwie + if (Current) + p->pMemCell=Current->MemCell; //przypisanie powiązanej komórki + else + {//utworzenie automatycznej komórki + Current=new TGroundNode(); //to nie musi mieć nazwy, nazwa w wyszukiwarce wystarczy + //Current->asName=p->asName; //mazwa identyczna, jak nazwa odcinka izolowanego + Current->MemCell=new TMemCell(NULL); //nowa komórka + sTracks->Add(TP_MEMCELL,p->asName.c_str(),Current); //dodanie do wyszukiwarki + Current->nNext=nRootOfType[TP_MEMCELL]; //to nie powinno tutaj być, bo robi się śmietnik + nRootOfType[TP_MEMCELL]=Current; + iNumNodes++; + p->pMemCell=Current->MemCell; //wskaźnik komóki przekazany do odcinka izolowanego + } + p=p->Next(); + } + //for (Current=nRootOfType[TP_TRACK];Current;Current=Current->nNext) + // if (Current->pTrack->eType==tt_Cross) + // Current->pTrack->ConnectionsLog(); //zalogowanie informacji o połączeniach +} + +void __fastcall TGround::InitTraction() +{//łączenie drutów ze sobą oraz z torami i eventami + TGroundNode *nCurrent,*nTemp; + TTraction *tmp; //znalezione przęsło + TTraction *Traction; + int iConnection; + AnsiString name; + for (nCurrent=nRootOfType[TP_TRACTION];nCurrent;nCurrent=nCurrent->nNext) + {//podłączenie do zasilacza, żeby można było sumować prąd kilku pojazdów + //a jednocześnie z jednego miejsca zmieniać napięcie eventem + //wykonywane najpierw, żeby można było logować podłączenie 2 zasilaczy do jednego drutu + //izolator zawieszony na przęśle jest ma być osobnym odcinkiem drutu o długości ok. 1m, + //podłączonym do zasilacza o nazwie "*" (gwiazka); "none" nie będzie odpowiednie + Traction=nCurrent->hvTraction; + nTemp=FindGroundNode(Traction->asPowerSupplyName,TP_TRACTIONPOWERSOURCE); + if (nTemp) //jak zasilacz znaleziony + Traction->PowerSet(nTemp->psTractionPowerSource); //to podłączyć do przęsła + else + if (Traction->asPowerSupplyName!="*") //gwiazdka dla przęsła z izolatorem + if (Traction->asPowerSupplyName!="none") //dopuszczamy na razie brak podłączenia? + {//logowanie błędu i utworzenie zasilacza o domyślnej zawartości + ErrorLog("Missed TractionPowerSource: "+Traction->asPowerSupplyName); + nTemp=new TGroundNode(); + nTemp->iType=TP_TRACTIONPOWERSOURCE; + nTemp->asName=Traction->asPowerSupplyName; + nTemp->psTractionPowerSource=new TTractionPowerSource(); + nTemp->psTractionPowerSource->Init(Traction->NominalVoltage,Traction->MaxCurrent); + nTemp->nNext=nRootOfType[nTemp->iType]; //ostatni dodany dołączamy na końcu nowego + nRootOfType[nTemp->iType]=nTemp; //ustawienie nowego na początku listy + iNumNodes++; + } + } + for (nCurrent=nRootOfType[TP_TRACTION];nCurrent;nCurrent=nCurrent->nNext) + { + Traction=nCurrent->hvTraction; + if (!Traction->hvNext[0]) //tylko jeśli jeszcze nie podłączony + { + tmp=FindTraction(&Traction->pPoint1,iConnection,nCurrent); + switch (iConnection) + { + case 0: + Traction->Connect(0,tmp,0); + break; + case 1: + Traction->Connect(0,tmp,1); + break; + } + if (Traction->hvNext[0]) //jeśli został podłączony + if (Traction->psSection&&tmp->psSection) //tylko przęsło z izolatorem może nie mieć zasilania, bo ma 2, trzeba sprawdzać sąsiednie + if (Traction->psSection!=tmp->psSection) //połączone odcinki mają różne zasilacze + {//to może być albo podłączenie podstacji lub kabiny sekcyjnej do sekcji, albo błąd + if (Traction->psSection->bSection&&!tmp->psSection->bSection) + {//(tmp->psSection) jest podstacją, a (Traction->psSection) nazwą sekcji + tmp->PowerSet(Traction->psSection); //zastąpienie wskazaniem sekcji + } + else if (!Traction->psSection->bSection&&tmp->psSection->bSection) + {//(Traction->psSection) jest podstacją, a (tmp->psSection) nazwą sekcji + Traction->PowerSet(tmp->psSection); //zastąpienie wskazaniem sekcji + } + else //jeśli obie to sekcje albo obie podstacje, to będzie błąd + ErrorLog("Bad power: at "+FloatToStrF(Traction->pPoint1.x,ffFixed,6,2)+" "+FloatToStrF(Traction->pPoint1.y,ffFixed,6,2)+" "+FloatToStrF(Traction->pPoint1.z,ffFixed,6,2)); + } + } + if (!Traction->hvNext[1]) //tylko jeśli jeszcze nie podłączony + { + tmp=FindTraction(&Traction->pPoint2,iConnection,nCurrent); + switch (iConnection) + { + case 0: + Traction->Connect(1,tmp,0); + break; + case 1: + Traction->Connect(1,tmp,1); + break; + } + if (Traction->hvNext[1]) //jeśli został podłączony + if (Traction->psSection&&tmp->psSection) //tylko przęsło z izolatorem może nie mieć zasilania, bo ma 2, trzeba sprawdzać sąsiednie + if (Traction->psSection!=tmp->psSection) + {//to może być albo podłączenie podstacji lub kabiny sekcyjnej do sekcji, albo błąd + if (Traction->psSection->bSection&&!tmp->psSection->bSection) + {//(tmp->psSection) jest podstacją, a (Traction->psSection) nazwą sekcji + tmp->PowerSet(Traction->psSection); //zastąpienie wskazaniem sekcji + } + else if (!Traction->psSection->bSection&&tmp->psSection->bSection) + {//(Traction->psSection) jest podstacją, a (tmp->psSection) nazwą sekcji + Traction->PowerSet(tmp->psSection); //zastąpienie wskazaniem sekcji + } + else //jeśli obie to sekcje albo obie podstacje, to będzie błąd + ErrorLog("Bad power: at "+FloatToStrF(Traction->pPoint2.x,ffFixed,6,2)+" "+FloatToStrF(Traction->pPoint2.y,ffFixed,6,2)+" "+FloatToStrF(Traction->pPoint2.z,ffFixed,6,2)); + } + } + } + iConnection=0; //teraz będzie licznikiem końców + for (nCurrent=nRootOfType[TP_TRACTION];nCurrent;nCurrent=nCurrent->nNext) + {//operacje mające na celu wykrywanie bieżni wspólnych i łączenie przęseł naprążania + if (nCurrent->hvTraction->WhereIs()) //oznakowanie przedostatnich przęseł + {//poszukiwanie bieżni wspólnej dla przedostatnich przęseł, również w celu połączenia zasilania + //to się nie sprawdza, bo połączyć się mogą dwa niezasilane odcinki jako najbliższe sobie + //nCurrent->hvTraction->hvParallel=TractionNearestFind(nCurrent->pCenter,0,nCurrent); //szukanie najbliższego przęsła + //trzeba by zliczać końce, a potem wpisać je do tablicy, aby sukcesywnie podłączać do zasilaczy + nCurrent->hvTraction->iTries=5; //oznaczanie końcowych + ++iConnection; + } + if (nCurrent->hvTraction->fResistance[0]==0.0) + {nCurrent->hvTraction->ResistanceCalc(); //obliczanie przęseł w segmencie z bezpośrednim zasilaniem + //ErrorLog("Section "+nCurrent->hvTraction->asPowerSupplyName+" connected"); //jako niby błąd będzie bardziej widoczne + nCurrent->hvTraction->iTries=0; //nie potrzeba mu szukać zasilania + } + //if (!Traction->hvParallel) //jeszcze utworzyć pętle z bieżni wspólnych + } + int zg=0; //zgodność kierunku przęseł, tymczasowo iterator do tabeli końców + TGroundNode **nEnds=new TGroundNode*[iConnection]; //końców jest ok. 10 razy mniej niż wszystkich przęseł (Quark: 216) + for (nCurrent=nRootOfType[TP_TRACTION];nCurrent;nCurrent=nCurrent->nNext) + {//łączenie bieżni wspólnych, w tym oznaczanie niepodanych jawnie + Traction=nCurrent->hvTraction; + if (!Traction->asParallel.IsEmpty()) //będzie wskaźnik na inne przęsło + if ((Traction->asParallel=="none")||(Traction->asParallel=="*")) //jeśli nieokreślone + Traction->iLast=2; //jakby przedostatni - niech po prostu szuka (iLast już przeliczone) + else if (!Traction->hvParallel) //jeśli jeszcze nie został włączony w kółko + {nTemp=FindGroundNode(Traction->asParallel,TP_TRACTION); + if (nTemp) + {//o ile zostanie znalezione przęsło o takiej nazwie + if (!nTemp->hvTraction->hvParallel) //jeśli tamten jeszcze nie ma wskaźnika bieżni wspólnej + Traction->hvParallel=nTemp->hvTraction; //wpisać siebie i dalej dać mu wskaźnik zwrotny + else //a jak ma, to albo dołączyć się do kółeczka + Traction->hvParallel=nTemp->hvTraction->hvParallel; //przjąć dotychczasowy wskaźnik od niego + nTemp->hvTraction->hvParallel=Traction; //i na koniec ustawienie wskaźnika zwrotnego + } + if (!Traction->hvParallel) + ErrorLog("Missed overhead: "+Traction->asParallel); //logowanie braku + } + if (Traction->iTries>0) //jeśli zaznaczony do podłączenia + //if (!nCurrent->hvTraction->psPower[0]||!nCurrent->hvTraction->psPower[1]) + if (zghvTraction->hvNext[0]) + {//jeśli końcowy ma ciąg dalszy od strony 0 (Point1), szukamy odcinka najbliższego do Point2 + if (TractionNearestFind(nEnds[i]->hvTraction->pPoint2,0,nEnds[i])) //poszukiwanie przęsła + {nEnds[i]=NULL; + zg=1; //jak coś zostało podłączone, to może zasilanie gdzieś dodatkowo dotrze + } + } + else if (nEnds[i]->hvTraction->hvNext[1]) + {//jeśli końcowy ma ciąg dalszy od strony 1 (Point2), szukamy odcinka najbliższego do Point1 + if (TractionNearestFind(nEnds[i]->hvTraction->pPoint1,1,nEnds[i])) //poszukiwanie przęsła + {nEnds[i]=NULL; + zg=1; //jak coś zostało podłączone, to może zasilanie gdzieś dodatkowo dotrze + } + } + else + {//gdy koniec jest samotny, to na razie nie zostanie podłączony (nie powinno takich być) + nEnds[i]=NULL; + } + } + } + delete[] nEnds; //nie potrzebne już +}; + +void __fastcall TGround::TrackJoin(TGroundNode *Current) +{//wyszukiwanie sąsiednich torów do podłączenia (wydzielone na użytek obrotnicy) + TTrack *Track=Current->pTrack; + TTrack *tmp; + int iConnection; + if (!Track->CurrentPrev()) + {tmp=FindTrack(Track->CurrentSegment()->FastGetPoint_0(),iConnection,Current); //Current do pominięcia + switch (iConnection) + { + case 0: Track->ConnectPrevPrev(tmp,0); break; + case 1: Track->ConnectPrevNext(tmp,1); break; + } + } + if (!Track->CurrentNext()) + { + tmp=FindTrack(Track->CurrentSegment()->FastGetPoint_1(),iConnection,Current); + switch (iConnection) + { + case 0: Track->ConnectNextPrev(tmp,0); break; + case 1: Track->ConnectNextNext(tmp,1); break; + } + } +} + +//McZapkie-070602: wyzwalacze zdarzen +bool __fastcall TGround::InitLaunchers() +{ + TGroundNode *Current,*tmp; + TEventLauncher *EventLauncher; + int i; + for (Current=nRootOfType[TP_EVLAUNCH];Current;Current=Current->nNext) + { + EventLauncher=Current->EvLaunch; + if (EventLauncher->iCheckMask!=0) + if (EventLauncher->asMemCellName!=AnsiString("none")) + {//jeśli jest powiązana komórka pamięci + tmp=FindGroundNode(EventLauncher->asMemCellName,TP_MEMCELL); + if (tmp) + EventLauncher->MemCell=tmp->MemCell; //jeśli znaleziona, dopisać + else + MessageBox(0,"Cannot find Memory Cell for Event Launcher","Error",MB_OK); + } + else + EventLauncher->MemCell=NULL; + EventLauncher->Event1=(EventLauncher->asEvent1Name!=AnsiString("none"))?FindEvent(EventLauncher->asEvent1Name):NULL; + EventLauncher->Event2=(EventLauncher->asEvent2Name!=AnsiString("none"))?FindEvent(EventLauncher->asEvent2Name):NULL; + } + return true; +} + +TTrack* __fastcall TGround::FindTrack(vector3 Point,int &iConnection,TGroundNode *Exclude) +{//wyszukiwanie innego toru kończącego się w (Point) + TTrack *Track; + TGroundNode *Current; + TTrack *tmp; + iConnection=-1; + TSubRect *sr; + //najpierw szukamy w okolicznych segmentach + int c=GetColFromX(Point.x); + int r=GetRowFromZ(Point.z); + if ((sr=FastGetSubRect(c,r))!=NULL) //75% torów jest w tym samym sektorze + if ((tmp=sr->FindTrack(&Point,iConnection,Exclude->pTrack))!=NULL) + return tmp; + int i,x,y; + for (i=1;i<9;++i) //sektory w kolejności odległości, 4 jest tu wystarczające, 9 na wszelki wypadek + {//niemal wszystkie podłączone tory znajdują się w sąsiednich 8 sektorach + x=SectorOrder[i].x; + y=SectorOrder[i].y; + if ((sr=FastGetSubRect(c+y,r+x))!=NULL) + if ((tmp=sr->FindTrack(&Point,iConnection,Exclude->pTrack))!=NULL) + return tmp; + if (x) + if ((sr=FastGetSubRect(c+y,r-x))!=NULL) + if ((tmp=sr->FindTrack(&Point,iConnection,Exclude->pTrack))!=NULL) + return tmp; + if (y) + if ((sr=FastGetSubRect(c-y,r+x))!=NULL) + if ((tmp=sr->FindTrack(&Point,iConnection,Exclude->pTrack))!=NULL) + return tmp; + if ((sr=FastGetSubRect(c-y,r-x))!=NULL) + if ((tmp=sr->FindTrack(&Point,iConnection,Exclude->pTrack))!=NULL) + return tmp; + } +#if 0 + //wyszukiwanie czołgowe (po wszystkich jak leci) - nie ma chyba sensu + for (Current=nRootOfType[TP_TRACK];Current;Current=Current->Next) + { + if ((Current->iType==TP_TRACK) && (Current!=Exclude)) + { + iConnection=Current->pTrack->TestPoint(&Point); + if (iConnection>=0) return Current->pTrack; + } + } +#endif + return NULL; +} + +TTraction* __fastcall TGround::FindTraction(vector3 *Point,int &iConnection,TGroundNode *Exclude) +{//wyszukiwanie innego przęsła kończącego się w (Point) + TTraction *Traction; + TGroundNode *Current; + TTraction *tmp; + iConnection=-1; + TSubRect *sr; + //najpierw szukamy w okolicznych segmentach + int c=GetColFromX(Point->x); + int r=GetRowFromZ(Point->z); + if ((sr=FastGetSubRect(c,r))!=NULL) //większość będzie w tym samym sektorze + if ((tmp=sr->FindTraction(Point,iConnection,Exclude->hvTraction))!=NULL) + return tmp; + int i,x,y; + for (i=1;i<9;++i) //sektory w kolejności odległości, 4 jest tu wystarczające, 9 na wszelki wypadek + {//wszystkie przęsła powinny zostać znajdować się w sąsiednich 8 sektorach + x=SectorOrder[i].x; + y=SectorOrder[i].y; + if ((sr=FastGetSubRect(c+y,r+x))!=NULL) + if ((tmp=sr->FindTraction(Point,iConnection,Exclude->hvTraction))!=NULL) + return tmp; + if (x&y) + {if ((sr=FastGetSubRect(c+y,r-x))!=NULL) + if ((tmp=sr->FindTraction(Point,iConnection,Exclude->hvTraction))!=NULL) + return tmp; + if ((sr=FastGetSubRect(c-y,r+x))!=NULL) + if ((tmp=sr->FindTraction(Point,iConnection,Exclude->hvTraction))!=NULL) + return tmp; + } + if ((sr=FastGetSubRect(c-y,r-x))!=NULL) + if ((tmp=sr->FindTraction(Point,iConnection,Exclude->hvTraction))!=NULL) + return tmp; + } + return NULL; +}; + +TTraction* __fastcall TGround::TractionNearestFind(vector3 &p,int dir,TGroundNode *n) +{//wyszukanie najbliższego do (p) przęsła o tej samej nazwie sekcji (ale innego niż podłączone) oraz zasilanego z kierunku (dir) + TGroundNode *nCurrent,*nBest=NULL; + int i,j,k,zg; + double d,dist=200.0*200.0; //[m] odległość graniczna + //najpierw szukamy w okolicznych segmentach + int c=GetColFromX(n->pCenter.x); + int r=GetRowFromZ(n->pCenter.z); + TSubRect *sr; + for (i=-1;i<=1;++i) //przeglądamy 9 najbliższych sektorów + for (j=-1;j<=1;++j) // + if ((sr=FastGetSubRect(c+i,r+j))!=NULL) //o ile w ogóle sektor jest + for (nCurrent=sr->nRenderWires;nCurrent;nCurrent=nCurrent->nNext3) + if (nCurrent->iType==TP_TRACTION) + if (nCurrent->hvTraction->psSection==n->hvTraction->psSection) //jeśli ta sama sekcja + if (nCurrent!=n) //ale nie jest tym samym + if (nCurrent->hvTraction!=n->hvTraction->hvNext[0]) //ale nie jest bezpośrednio podłączonym + if (nCurrent->hvTraction!=n->hvTraction->hvNext[1]) + if (nCurrent->hvTraction->psPower[k=(DotProduct(n->hvTraction->vParametric,nCurrent->hvTraction->vParametric)>=0?dir^1:dir)]) //ma zasilanie z odpowiedniej strony + if (nCurrent->hvTraction->fResistance[k]>=0.0) //żeby się nie propagowały jakieś ujemne + {//znaleziony kandydat do połączenia + d=SquareMagnitude(p-nCurrent->pCenter); //kwadrat odległości środków + if (dist>d) + {//zapamiętanie nowego najbliższego + dist=d; //nowy rekord odległości + nBest=nCurrent; + zg=k; //z którego końca brać wskaźnik zasilacza + } + } + if (nBest) //jak znalezione przęsło z zasilaniem, to podłączenie "równoległe" + {n->hvTraction->ResistanceCalc(dir,nBest->hvTraction->fResistance[zg],nBest->hvTraction->psPower[zg]); + //testowo skrzywienie przęsła tak, aby pokazać skąd ma zasilanie + //if (dir) //1 gdy ciąg dalszy jest od strony Point2 + // n->hvTraction->pPoint3=0.25*(nBest->pCenter+3*(zg?nBest->hvTraction->pPoint4:nBest->hvTraction->pPoint3)); + //else + // n->hvTraction->pPoint4=0.25*(nBest->pCenter+3*(zg?nBest->hvTraction->pPoint4:nBest->hvTraction->pPoint3)); + } + return (nBest?nBest->hvTraction:NULL); +}; + +bool __fastcall TGround::AddToQuery(TEvent *Event, TDynamicObject *Node) +{ + if (Event->bEnabled) //jeśli może być dodany do kolejki (nie używany w skanowaniu) + if (!Event->iQueued) //jeśli nie dodany jeszcze do kolejki + {//kolejka eventów jest posortowana względem (fStartTime) + Event->Activator=Node; + if (Event->Type==tp_AddValues?(Event->fDelay==0.0):false) + {//eventy AddValues trzeba wykonywać natychmiastowo, inaczej kolejka może zgubić jakieś dodawanie + //Ra: kopiowanie wykonania tu jest bez sensu, lepiej by było wydzielić funkcję wykonującą eventy i ją wywołać + if (EventConditon(Event)) + {//teraz mogą być warunki do tych eventów + Event->Params[5].asMemCell->UpdateValues(Event->Params[0].asText,Event->Params[1].asdouble,Event->Params[2].asdouble,Event->iFlags); + if (Event->Params[6].asTrack) + {//McZapkie-100302 - updatevalues oprocz zmiany wartosci robi putcommand dla wszystkich 'dynamic' na danym torze + for (int i=0;iParams[6].asTrack->iNumDynamics;++i) + Event->Params[5].asMemCell->PutCommand(Event->Params[6].asTrack->Dynamics[i]->Mechanik,&Event->Params[4].nGroundNode->pCenter); + if (DebugModeFlag) + WriteLog("EVENT EXECUTED: AddValues & Track command - "+AnsiString(Event->Params[0].asText)+" "+AnsiString(Event->Params[1].asdouble)+" "+AnsiString(Event->Params[2].asdouble)); + } + else + if (DebugModeFlag) + WriteLog("EVENT EXECUTED: AddValues - "+AnsiString(Event->Params[0].asText)+" "+AnsiString(Event->Params[1].asdouble)+" "+AnsiString(Event->Params[2].asdouble)); + } + Event=Event->evJoined; //jeśli jest kolejny o takiej samej nazwie, to idzie do kolejki + } + if (Event) + {//standardowe dodanie do kolejki + WriteLog("EVENT ADDED TO QUEUE: "+Event->asName+(Node?AnsiString(" by "+Node->asName):AnsiString(""))); + Event->fStartTime=fabs(Event->fDelay)+Timer::GetTime(); //czas od uruchomienia scenerii + if (Event->fRandomDelay>0.0) + Event->fStartTime+=Event->fRandomDelay*random(10000)*0.0001; //doliczenie losowego czasu opóźnienia + ++Event->iQueued; //zabezpieczenie przed podwójnym dodaniem do kolejki + if (QueryRootEvent?Event->fStartTime>=QueryRootEvent->fStartTime:false) + QueryRootEvent->AddToQuery(Event); //dodanie gdzieś w środku + else + {//dodanie z przodu: albo nic nie ma, albo ma być wykonany szybciej niż pierwszy + Event->evNext=QueryRootEvent; + QueryRootEvent=Event; + } + } + } + return true; +} + +bool __fastcall TGround::EventConditon(TEvent *e) +{//sprawdzenie spelnienia warunków dla eventu + if (e->iFlags<=update_only) return true; //bezwarunkowo + if (e->iFlags&conditional_trackoccupied) + return (!e->Params[9].asTrack->IsEmpty()); + else if (e->iFlags&conditional_trackfree) + return (e->Params[9].asTrack->IsEmpty()); + else if (e->iFlags&conditional_propability) + { + double rprobability=1.0*rand()/RAND_MAX; + WriteLog("Random integer: "+CurrToStr(rprobability)+"/"+CurrToStr(e->Params[10].asdouble)); + return (e->Params[10].asdouble>rprobability); + } + else if (e->iFlags&conditional_memcompare) + {//porównanie wartości + if (tmpEvent->Params[9].asMemCell->Compare(e->Params[10].asText,e->Params[11].asdouble,e->Params[12].asdouble,e->iFlags)) + return true; + else if (Global::iWriteLogEnabled && DebugModeFlag) + {//nie zgadza się, więc sprawdzmy, co + LogComment=e->Params[9].asMemCell->Text()+AnsiString(" ")+FloatToStrF(e->Params[9].asMemCell->Value1(),ffFixed,8,2)+" "+FloatToStrF(tmpEvent->Params[9].asMemCell->Value2(),ffFixed,8,2)+" != "; + if (TestFlag(e->iFlags,conditional_memstring)) + LogComment+=AnsiString(tmpEvent->Params[10].asText); + else + LogComment+="*"; + if (TestFlag(tmpEvent->iFlags,conditional_memval1)) + LogComment+=" "+FloatToStrF(tmpEvent->Params[11].asdouble,ffFixed,8,2); + else + LogComment+=" *"; + if (TestFlag(tmpEvent->iFlags,conditional_memval2)) + LogComment+=" "+FloatToStrF(tmpEvent->Params[12].asdouble,ffFixed,8,2); + else + LogComment+=" *"; + WriteLog(LogComment.c_str()); + } + } + return false; +}; + +bool __fastcall TGround::CheckQuery() +{//sprawdzenie kolejki eventów oraz wykonanie tych, którym czas minął + TLocation loc; + int i; +/* //Ra: to w ogóle jakiś chory kod jest; wygląda jak wyszukanie eventu z najlepszym czasem + Double evtime,evlowesttime; //Ra: co to za typ? + //evlowesttime=1000000; + if (QueryRootEvent) + { + OldQRE=QueryRootEvent; + tmpEvent=QueryRootEvent; + } + if (QueryRootEvent) + { + for (i=0;i<90;++i) + { + evtime=((tmpEvent->fStartTime)-(Timer::GetTime())); //pobranie wartości zmiennej + if (evtimeNext) + tmpEvent=tmpEvent->Next; + else + i=100; + } + if (OldQRE!=tmp2Event) + { + QueryRootEvent->AddToQuery(QueryRootEvent); + QueryRootEvent=tmp2Event; + } + } +*/ +/* + if (QueryRootEvent) + {//wypisanie kolejki + tmpEvent=QueryRootEvent; + WriteLog("--> Event queue:"); + while (tmpEvent) + { + WriteLog(tmpEvent->asName+" "+AnsiString(tmpEvent->fStartTime)); + tmpEvent=tmpEvent->Next; + } + } +*/ + while (QueryRootEvent?QueryRootEvent->fStartTimeevJoined) //jeśli jest kolejny o takiej samej nazwie + {//to teraz on będzie następny do wykonania + QueryRootEvent=QueryRootEvent->evJoined; //następny będzie ten doczepiony + QueryRootEvent->evNext=tmpEvent->evNext; //pamiętając o następnym z kolejki + QueryRootEvent->fStartTime=tmpEvent->fStartTime; //czas musi być ten sam, bo nie jest aktualizowany + QueryRootEvent->Activator=tmpEvent->Activator; //pojazd aktywujący + //w sumie można by go dodać normalnie do kolejki, ale trzeba te połączone posortować wg czasu wykonania + } + else //a jak nazwa jest unikalna, to kolejka idzie dalej + QueryRootEvent=QueryRootEvent->evNext; //NULL w skrajnym przypadku + if (tmpEvent->bEnabled) + {//w zasadzie te wyłączone są skanowane i nie powinny się nigdy w kolejce znaleźć + WriteLog("EVENT LAUNCHED: "+tmpEvent->asName+(tmpEvent->Activator?AnsiString(" by "+tmpEvent->Activator->asName):AnsiString(""))); + switch (tmpEvent->Type) + { + case tp_CopyValues: //skopiowanie wartości z innej komórki + tmpEvent->Params[5].asMemCell->UpdateValues + (tmpEvent->Params[9].asMemCell->Text(), + tmpEvent->Params[9].asMemCell->Value1(), + tmpEvent->Params[9].asMemCell->Value2(), + tmpEvent->iFlags //flagi określają, co ma być skopiowane + ); + //break; //żeby się wysłało do torów i nie było potrzeby na AddValues * 0 0 + case tp_AddValues: //różni się jedną flagą od UpdateValues + case tp_UpdateValues: + if (EventConditon(tmpEvent)) + {//teraz mogą być warunki do tych eventów + if (tmpEvent->Type!=tp_CopyValues) //dla CopyValues zrobiło się wcześniej + tmpEvent->Params[5].asMemCell->UpdateValues(tmpEvent->Params[0].asText,tmpEvent->Params[1].asdouble,tmpEvent->Params[2].asdouble,tmpEvent->iFlags); + if (tmpEvent->Params[6].asTrack) + {//McZapkie-100302 - updatevalues oprocz zmiany wartosci robi putcommand dla wszystkich 'dynamic' na danym torze + for (int i=0;iParams[6].asTrack->iNumDynamics;++i) + tmpEvent->Params[5].asMemCell->PutCommand(tmpEvent->Params[6].asTrack->Dynamics[i]->Mechanik,&tmpEvent->Params[4].nGroundNode->pCenter); + if (DebugModeFlag) + WriteLog("Type: UpdateValues & Track command - "+AnsiString(tmpEvent->Params[0].asText)+" "+AnsiString(tmpEvent->Params[1].asdouble)+" "+AnsiString(tmpEvent->Params[2].asdouble)); + } + else + if (DebugModeFlag) + WriteLog("Type: UpdateValues - "+AnsiString(tmpEvent->Params[0].asText)+" "+AnsiString(tmpEvent->Params[1].asdouble)+" "+AnsiString(tmpEvent->Params[2].asdouble)); + } + break; + case tp_GetValues: + if (tmpEvent->Activator) + { + //loc.X= -tmpEvent->Params[8].nGroundNode->pCenter.x; + //loc.Y= tmpEvent->Params[8].nGroundNode->pCenter.z; + //loc.Z= tmpEvent->Params[8].nGroundNode->pCenter.y; + if (Global::iMultiplayer) //potwierdzenie wykonania dla serwera (odczyt semafora już tak nie działa) + WyslijEvent(tmpEvent->asName,tmpEvent->Activator->GetName()); + //tmpEvent->Params[9].asMemCell->PutCommand(tmpEvent->Activator->Mechanik,loc); + tmpEvent->Params[9].asMemCell->PutCommand(tmpEvent->Activator->Mechanik,&tmpEvent->Params[8].nGroundNode->pCenter); + } + WriteLog("Type: GetValues"); + break; + case tp_PutValues: + if (tmpEvent->Activator) + { + loc.X=-tmpEvent->Params[3].asdouble; //zamiana, bo fizyka ma inaczej niż sceneria + loc.Y= tmpEvent->Params[5].asdouble; + loc.Z= tmpEvent->Params[4].asdouble; + if (tmpEvent->Activator->Mechanik) //przekazanie rozkazu do AI + tmpEvent->Activator->Mechanik->PutCommand(tmpEvent->Params[0].asText,tmpEvent->Params[1].asdouble,tmpEvent->Params[2].asdouble,loc); + else + {//przekazanie do pojazdu + tmpEvent->Activator->MoverParameters->PutCommand(tmpEvent->Params[0].asText,tmpEvent->Params[1].asdouble,tmpEvent->Params[2].asdouble,loc); + } + } + WriteLog("Type: PutValues"); + break; + case tp_Lights: + if (tmpEvent->Params[9].asModel) + for (i=0;iParams[i].asdouble>=0) //-1 zostawia bez zmiany + tmpEvent->Params[9].asModel->LightSet(i,tmpEvent->Params[i].asdouble); //teraz też ułamek + break; + case tp_Visible: + if (tmpEvent->Params[9].nGroundNode) + tmpEvent->Params[9].nGroundNode->bVisible=(tmpEvent->Params[i].asInt>0); + break; + case tp_Velocity : + Error("Not implemented yet :("); + break; + case tp_Exit : + MessageBox(0,tmpEvent->asNodeName.c_str()," THE END ",MB_OK); + Global::iTextMode=-1; //wyłączenie takie samo jak sekwencja F10 -> Y + return false; + case tp_Sound : + switch (tmpEvent->Params[0].asInt) + {//trzy możliwe przypadki: + case 0: tmpEvent->Params[9].tsTextSound->Stop(); break; + case 1: tmpEvent->Params[9].tsTextSound->Play(1,0,true,tmpEvent->Params[9].tsTextSound->vSoundPosition); break; + case -1: tmpEvent->Params[9].tsTextSound->Play(1,DSBPLAY_LOOPING,true,tmpEvent->Params[9].tsTextSound->vSoundPosition); break; + } + break; + case tp_Disable : + Error("Not implemented yet :("); + break; + case tp_Animation : //Marcin: dorobic translacje - Ra: dorobiłem ;-) + if (tmpEvent->Params[0].asInt==1) + tmpEvent->Params[9].asAnimContainer->SetRotateAnim( + vector3(tmpEvent->Params[1].asdouble, + tmpEvent->Params[2].asdouble, + tmpEvent->Params[3].asdouble), + tmpEvent->Params[4].asdouble); + else if (tmpEvent->Params[0].asInt==2) + tmpEvent->Params[9].asAnimContainer->SetTranslateAnim( + vector3(tmpEvent->Params[1].asdouble, + tmpEvent->Params[2].asdouble, + tmpEvent->Params[3].asdouble), + tmpEvent->Params[4].asdouble); + else if (tmpEvent->Params[0].asInt==4) + tmpEvent->Params[9].asModel->AnimationVND( + tmpEvent->Params[8].asPointer, + tmpEvent->Params[1].asdouble, //tu mogą być dodatkowe parametry, np. od-do + tmpEvent->Params[2].asdouble, + tmpEvent->Params[3].asdouble, + tmpEvent->Params[4].asdouble); + break; + case tp_Switch: + if (tmpEvent->Params[9].asTrack) + tmpEvent->Params[9].asTrack->Switch(tmpEvent->Params[0].asInt,tmpEvent->Params[1].asdouble,tmpEvent->Params[2].asdouble); + if (Global::iMultiplayer) //dajemy znać do serwera o przełożeniu + WyslijEvent(tmpEvent->asName,""); //wysłanie nazwy eventu przełączajacego + //Ra: bardziej by się przydała nazwa toru, ale nie ma do niej stąd dostępu + break; + case tp_TrackVel: + if (tmpEvent->Params[9].asTrack) + {//prędkość na zwrotnicy może być ograniczona z góry we wpisie, większej się nie ustawi eventem + WriteLog("type: TrackVel"); + //WriteLog("Vel: ",tmpEvent->Params[0].asdouble); + tmpEvent->Params[9].asTrack->VelocitySet(tmpEvent->Params[0].asdouble); + if (DebugModeFlag) //wyświetlana jest ta faktycznie ustawiona + WriteLog("vel: ",tmpEvent->Params[9].asTrack->VelocityGet()); + } + break; + case tp_DynVel: + Error("Event \"DynVel\" is obsolete"); + break; + case tp_Multiple: + { + bCondition=EventConditon(tmpEvent); + if (bCondition||(tmpEvent->iFlags&conditional_anyelse)) //warunek spelniony albo było użyte else + { + WriteLog("Multiple passed"); + for (i=0;i<8;++i) + {//dodawane do kolejki w kolejności zapisania + if (tmpEvent->Params[i].asEvent) + if (bCondition!=bool(tmpEvent->iFlags&(conditional_else<Params[i].asEvent!=tmpEvent) + AddToQuery(tmpEvent->Params[i].asEvent,tmpEvent->Activator); //normalnie dodać + else //jeśli ma być rekurencja + if (tmpEvent->fDelay>=5.0) //to musi mieć sensowny okres powtarzania + if (tmpEvent->iQueued<2) + {//trzeba zrobić wyjątek, aby event mógł się sam dodać do kolejki, raz już jest, ale będzie usunięty + //pętla eventowa może być uruchomiona wiele razy, ale tylko pierwsze uruchomienie zadziała + tmpEvent->iQueued=0; //tymczasowo, aby był ponownie dodany do kolejki + AddToQuery(tmpEvent,tmpEvent->Activator); + tmpEvent->iQueued=2; //kolejny raz już absolutnie nie dodawać + } + } + } + if (Global::iMultiplayer) //dajemy znać do serwera o wykonaniu + if ((tmpEvent->iFlags&conditional_anyelse)==0) //jednoznaczne tylko, gdy nie było else + { + if (tmpEvent->Activator) + WyslijEvent(tmpEvent->asName,tmpEvent->Activator->GetName()); + else + WyslijEvent(tmpEvent->asName,""); + } + } + } + break; + case tp_WhoIs: //pobranie nazwy pociągu do komórki pamięci + if (tmpEvent->iFlags&update_load) + {//jeśli pytanie o ładunek + if (tmpEvent->iFlags&update_memadd) //jeśli typ pojazdu + tmpEvent->Params[9].asMemCell->UpdateValues( + tmpEvent->Activator->MoverParameters->TypeName.c_str(), //typ pojazdu + 0, //na razie nic + 0, //na razie nic + tmpEvent->iFlags&(update_memstring|update_memval1|update_memval2)); + else //jeśli parametry ładunku + tmpEvent->Params[9].asMemCell->UpdateValues( + tmpEvent->Activator->MoverParameters->LoadType!=""?tmpEvent->Activator->MoverParameters->LoadType.c_str():"none", //nazwa ładunku + tmpEvent->Activator->MoverParameters->Load, //aktualna ilość + tmpEvent->Activator->MoverParameters->MaxLoad, //maksymalna ilość + tmpEvent->iFlags&(update_memstring|update_memval1|update_memval2)); + } + else if (tmpEvent->iFlags&update_memadd) + {//jeśli miejsce docelowe pojazdu + tmpEvent->Params[9].asMemCell->UpdateValues( + tmpEvent->Activator->asDestination.c_str(), //adres docelowy + tmpEvent->Activator->DirectionGet(), //kierunek pojazdu względem czoła składu (1=zgodny,-1=przeciwny) + tmpEvent->Activator->MoverParameters->Power, //moc pojazdu silnikowego: 0 dla wagonu + tmpEvent->iFlags&(update_memstring|update_memval1|update_memval2)); + } + else if (tmpEvent->Activator->Mechanik) + if (tmpEvent->Activator->Mechanik->Primary()) + {//tylko jeśli ktoś tam siedzi - nie powinno dotyczyć pasażera! + tmpEvent->Params[9].asMemCell->UpdateValues( + tmpEvent->Activator->Mechanik->TrainName().c_str(), + tmpEvent->Activator->Mechanik->StationCount()-tmpEvent->Activator->Mechanik->StationIndex(), //ile przystanków do końca + tmpEvent->Activator->Mechanik->IsStop()?1:0, //1, gdy ma tu zatrzymanie + tmpEvent->iFlags); + WriteLog("Train detected: "+tmpEvent->Activator->Mechanik->TrainName()); + } + break; + case tp_LogValues: //zapisanie zawartości komórki pamięci do logu + if (tmpEvent->Params[9].asMemCell) //jeśli była podana nazwa komórki + WriteLog("Memcell \""+tmpEvent->asNodeName+"\": "+ + tmpEvent->Params[9].asMemCell->Text()+" "+ + tmpEvent->Params[9].asMemCell->Value1()+" "+ + tmpEvent->Params[9].asMemCell->Value2()); + else //lista wszystkich + for (TGroundNode *Current=nRootOfType[TP_MEMCELL];Current;Current=Current->nNext) + WriteLog("Memcell \""+Current->asName+"\": "+ + Current->MemCell->Text()+" "+ + Current->MemCell->Value1()+" "+ + Current->MemCell->Value2()); + break; + case tp_Voltage: //zmiana napięcia w zasilaczu (TractionPowerSource) + if (tmpEvent->Params[9].psPower) + {//na razie takie chamskie ustawienie napięcia zasilania + WriteLog("type: Voltage"); + tmpEvent->Params[9].psPower->VoltageSet(tmpEvent->Params[0].asdouble); + } + case tp_Friction: //zmiana tarcia na scenerii + {//na razie takie chamskie ustawienie napięcia zasilania + WriteLog("type: Friction"); + Global::fFriction=(tmpEvent->Params[0].asdouble); + } + break; + case tp_Message: //wyświetlenie komunikatu + break; + } //switch (tmpEvent->Type) + } //if (tmpEvent->bEnabled) + --tmpEvent->iQueued; //teraz moze być ponownie dodany do kolejki +/* + if (QueryRootEvent->eJoined) //jeśli jest kolejny o takiej samej nazwie + {//to teraz jego dajemy do wykonania + QueryRootEvent->eJoined->Next=QueryRootEvent->Next; //pamiętając o następnym z kolejki + QueryRootEvent->eJoined->fStartTime=QueryRootEvent->fStartTime; //czas musi być ten sam, bo nie jest aktualizowany + //QueryRootEvent->fStartTime=0; + QueryRootEvent=QueryRootEvent->eJoined; //a wykonać ten doczepiony + } + else + {//a jak nazwa jest unikalna, to kolejka idzie dalej + //QueryRootEvent->fStartTime=0; + QueryRootEvent=QueryRootEvent->Next; //NULL w skrajnym przypadku + } +*/ + } //while + return true; +} + +void __fastcall TGround::OpenGLUpdate(HDC hDC) +{ + SwapBuffers(hDC); //swap buffers (double buffering) +}; + +void __fastcall TGround::UpdatePhys(double dt,int iter) +{//aktualizacja fizyki stałym krokiem: dt=krok czasu [s], dt*iter=czas od ostatnich przeliczeń + for (TGroundNode *Current=nRootOfType[TP_TRACTIONPOWERSOURCE];Current;Current=Current->nNext) + Current->psTractionPowerSource->Update(dt*iter); //zerowanie sumy prądów +}; + +bool __fastcall TGround::Update(double dt,int iter) +{//aktualizacja animacji krokiem FPS: dt=krok czasu [s], dt*iter=czas od ostatnich przeliczeń + if (dt==0.0) + {//jeśli załączona jest pauza, to tylko obsłużyć ruch w kabinie trzeba + return true; + } + //Ra: w zasadzie to trzeba by utworzyć oddzielną listę taboru do liczenia fizyki + // na którą by się zapisywały wszystkie pojazdy będące w ruchu + // pojazdy stojące nie potrzebują aktualizacji, chyba że np. ktoś im zmieni nastawę hamulca + // oddzielną listę można by zrobić na pojazdy z napędem, najlepiej posortowaną wg typu napędu + if (iter>1) //ABu: ponizsze wykonujemy tylko jesli wiecej niz jedna iteracja + {//pierwsza iteracja i wyznaczenie stalych: + for (TGroundNode *Current=nRootDynamic;Current;Current=Current->nNext) + {// + Current->DynamicObject->MoverParameters->ComputeConstans(); + Current->DynamicObject->CoupleDist(); + Current->DynamicObject->UpdateForce(dt,dt,false); + } + for (TGroundNode *Current=nRootDynamic;Current;Current=Current->nNext) + Current->DynamicObject->FastUpdate(dt); + //pozostale iteracje + for (int i=1;i<(iter-1);++i) //jeśli iter==5, to wykona się 3 razy + { + for (TGroundNode *Current=nRootDynamic;Current;Current=Current->nNext) + Current->DynamicObject->UpdateForce(dt,dt,false); + for (TGroundNode *Current=nRootDynamic;Current;Current=Current->nNext) + Current->DynamicObject->FastUpdate(dt); + } + //ABu 200205: a to robimy tylko raz, bo nie potrzeba więcej + //Winger 180204 - pantografy + double dt1=dt*iter; //całkowity czas + UpdatePhys(dt1,1); + TAnimModel::AnimUpdate(dt1); //wykonanie zakolejkowanych animacji + for (TGroundNode *Current=nRootDynamic;Current;Current=Current->nNext) + {//Ra: zmienić warunek na sprawdzanie pantografów w jednej zmiennej: czy pantografy i czy podniesione + if (Current->DynamicObject->MoverParameters->EnginePowerSource.SourceType==CurrentCollector) + GetTraction(Current->DynamicObject); //poszukiwanie drutu dla pantografów + Current->DynamicObject->UpdateForce(dt,dt1,true);//,true); + } + for (TGroundNode *Current=nRootDynamic;Current;Current=Current->nNext) + Current->DynamicObject->Update(dt,dt1); //Ra 2015-01: tylko tu przelicza sieć trakcyjną + } + else + {//jezeli jest tylko jedna iteracja + UpdatePhys(dt,1); + TAnimModel::AnimUpdate(dt); //wykonanie zakolejkowanych animacji + for (TGroundNode *Current=nRootDynamic;Current;Current=Current->nNext) + { + if (Current->DynamicObject->MoverParameters->EnginePowerSource.SourceType==CurrentCollector) + GetTraction(Current->DynamicObject); + Current->DynamicObject->MoverParameters->ComputeConstans(); + Current->DynamicObject->CoupleDist(); + Current->DynamicObject->UpdateForce(dt,dt,true);//,true); + } + for (TGroundNode *Current=nRootDynamic;Current;Current=Current->nNext) + Current->DynamicObject->Update(dt,dt);//Ra 2015-01: tylko tu przelicza sieć trakcyjną + } + if (bDynamicRemove) + {//jeśli jest coś do usunięcia z listy, to trzeba na końcu + for (TGroundNode *Current=nRootDynamic;Current;Current=Current->nNext) + if (!Current->DynamicObject->bEnabled) + { + DynamicRemove(Current->DynamicObject); //usunięcie tego i podłączonych + Current=nRootDynamic; //sprawdzanie listy od początku + } + bDynamicRemove=false; //na razie koniec + } + return true; +}; + +//Winger 170204 - szukanie trakcji nad pantografami +bool __fastcall TGround::GetTraction(TDynamicObject *model) +{//aktualizacja drutu zasilającego dla każdego pantografu, żeby odczytać napięcie + //jeśli pojazd się nie porusza, to nie ma sensu przeliczać tego więcej niż raz + double fRaParam; //parametr równania parametrycznego odcinka drutu + double fVertical; //odległość w pionie; musi być w zasięgu ruchu "pionowego" pantografu + double fHorizontal; //odległość w bok; powinna być mniejsza niż pół szerokości pantografu + vector3 vLeft,vUp,vFront,dwys; + vector3 pant0; + vector3 vParam; //współczynniki równania parametrycznego drutu + vector3 vStyk; //punkt przebicia drutu przez płaszczyznę ruchu pantografu + vector3 vGdzie; //wektor położenia drutu względem pojazdu + vFront=model->VectorFront(); //wektor normalny dla płaszczyzny ruchu pantografu + vUp=model->VectorUp(); //wektor pionu pudła (pochylony od pionu na przechyłce) + vLeft=model->VectorLeft(); //wektor odległości w bok (odchylony od poziomu na przechyłce) + dwys=model->GetPosition(); //współrzędne środka pojazdu + TAnimPant *p; //wskaźnik do obiektu danych pantografu + for (int k=0;kiAnimType[ANIM_PANTS];++k) + {//pętla po pantografach + p=model->pants[k].fParamPants; + if (k?model->MoverParameters->PantRearUp:model->MoverParameters->PantFrontUp) + {//jeśli pantograf podniesiony + pant0=dwys+(vLeft*p->vPos.z)+(vUp*p->vPos.y)+(vFront*p->vPos.x); + if (p->hvPowerWire) + {//jeżeli znamy drut z poprzedniego przebiegu + int n=30; //żeby się nie zapętlił + while (p->hvPowerWire) + {//powtarzane aż do znalezienia odpowiedniego odcinka na liście dwukierunkowej + //obliczamy wyraz wolny równania płaszczyzny (to miejsce nie jest odpowienie) + vParam=p->hvPowerWire->vParametric; //współczynniki równania parametrycznego + fRaParam=-DotProduct(pant0,vFront); + //podstawiamy równanie parametryczne drutu do równania płaszczyzny pantografu + //vFront.x*(t1x+t*vParam.x)+vFront.y*(t1y+t*vParam.y)+vFront.z*(t1z+t*vParam.z)+fRaDist=0; + fRaParam=-(DotProduct(p->hvPowerWire->pPoint1,vFront)+fRaParam)/DotProduct(vParam,vFront); + if (fRaParam<-0.001) //histereza rzędu 7cm na 70m typowego przęsła daje 1 promil + p->hvPowerWire=p->hvPowerWire->hvNext[0]; + else if (fRaParam>1.001) + p->hvPowerWire=p->hvPowerWire->hvNext[1]; + else if (p->hvPowerWire->iLast&3) + {//dla ostatniego i przedostatniego przęsła wymuszamy szukanie innego + p->hvPowerWire=NULL; //nie to, że nie ma, ale trzeba sprawdzić inne + //p->fHorizontal=fHorizontal; //zapamiętanie położenia drutu + break; + } + else if (p->hvPowerWire->hvParallel) + {//jeśli przęsło tworzy bieżnię wspólną, to trzeba sprawdzić pozostałe + p->hvPowerWire=NULL; //nie to, że nie ma, ale trzeba sprawdzić inne + //p->fHorizontal=fHorizontal; //zapamiętanie położenia drutu + break; //tymczasowo dla bieżni wspólnych poszukiwanie po całości + } + else + {//jeśli t jest w przedziale, wyznaczyć odległość wzdłuż wektorów vUp i vLeft + vStyk=p->hvPowerWire->pPoint1+fRaParam*vParam; //punkt styku płaszczyzny z drutem (dla generatora łuku el.) + vGdzie=vStyk-pant0; //wektor + //odległość w pionie musi być w zasięgu ruchu "pionowego" pantografu + fVertical=DotProduct(vGdzie,vUp); //musi się mieścić w przedziale ruchu pantografu + //odległość w bok powinna być mniejsza niż pół szerokości pantografu + fHorizontal=fabs(DotProduct(vGdzie,vLeft))-p->fWidth; //to się musi mieścić w przedziale zależnym od szerokości pantografu + //jeśli w pionie albo w bok jest za daleko, to dany drut jest nieużyteczny + if (fHorizontal>0) //0.635 dla AKP-1 AKP-4E + {//drut wyszedł poza zakres roboczy, ale jeszcze jest nabieżnik - pantograf się unosi bez utraty prądu + if (fHorizontal>p->fWidthExtra) //czy wyszedł za nabieżnik + {p->hvPowerWire=NULL; //dotychczasowy drut nie liczy się + //p->fHorizontal=fHorizontal; //zapamiętanie położenia drutu + } + else + {//problem jest, gdy nowy drut jest wyżej, wtedy pantograf odłącza się od starego, a na podniesienie do nowego potrzebuje czasu + p->PantTraction=fVertical+0.15*fHorizontal/p->fWidthExtra; //na razie liniowo na nabieżniku, dokładność poprawi się później + //p->fHorizontal=fHorizontal; //zapamiętanie położenia drutu + } + } + else + {//po wyselekcjonowaniu drutu, przypisać go do toru, żeby nie trzeba było szukać + //dla 3 końcowych przęseł sprawdzić wszystkie dostępne przęsła + //bo mogą być umieszczone równolegle nad torem - połączyć w pierścień + //najlepiej, jakby odcinki równoległe były oznaczone we wpisach + //WriteLog("Drut: "+AnsiString(fHorizontal)+" "+AnsiString(fVertical)); + p->PantTraction=fVertical; + //p->fHorizontal=fHorizontal; //zapamiętanie położenia drutu + break; //koniec pętli, aktualny drut pasuje + } + } + if (--n<=0) //coś za długo to szukanie trwa + p->hvPowerWire=NULL; + } + } + if (!p->hvPowerWire) //else nie, bo mógł zostać wyrzucony + {//poszukiwanie po okolicznych sektorach + int c=GetColFromX(dwys.x)+1; + int r=GetRowFromZ(dwys.z)+1; + TSubRect *tmp; + TGroundNode *node; + p->PantTraction=5.0; //taka za duża wartość + for (int j=r-2;j<=r;j++) + for (int i=c-2;i<=c;i++) + {//poszukiwanie po najbliższych sektorach niewiele da przy większym zagęszczeniu + tmp=FastGetSubRect(i,j); + if (tmp) + {//dany sektor może nie mieć nic w środku + for (node=tmp->nRenderWires;node;node=node->nNext3) //następny z grupy + if (node->iType==TP_TRACTION) //w grupie tej są druty oraz inne linie + { + vParam=node->hvTraction->vParametric; //współczynniki równania parametrycznego + fRaParam=-DotProduct(pant0,vFront); + fRaParam=-(DotProduct(node->hvTraction->pPoint1,vFront)+fRaParam)/DotProduct(vParam,vFront); + if ((fRaParam>=-0.001)?(fRaParam<=1.001):false) + {//jeśli tylko jest w przedziale, wyznaczyć odległość wzdłuż wektorów vUp i vLeft + vStyk=node->hvTraction->pPoint1+fRaParam*vParam; //punkt styku płaszczyzny z drutem (dla generatora łuku el.) + vGdzie=vStyk-pant0; //wektor + fVertical=DotProduct(vGdzie,vUp); //musi się mieścić w przedziale ruchu pantografu + if (fVertical>=0.0) //jeśli ponad pantografem (bo może łapać druty spod wiaduktu) + if (Global::bEnableTraction?fVerticalPantWys-0.15:false) //jeśli drut jest niżej niż 15cm pod ślizgiem + {//przełączamy w tryb połamania, o ile jedzie; (bEnableTraction) aby dało się jeździć na koślawych sceneriach + fHorizontal=fabs(DotProduct(vGdzie,vLeft))-p->fWidth; //i do tego jeszcze wejdzie pod ślizg + if (fHorizontal<=0.0) //0.635 dla AKP-1 AKP-4E + {p->PantWys=-1.0; //ujemna liczba oznacza połamanie + p->hvPowerWire=NULL; //bo inaczej się zasila w nieskończoność z połamanego + //p->fHorizontal=fHorizontal; //zapamiętanie położenia drutu + if (model->MoverParameters->EnginePowerSource.CollectorParameters.CollectorsNo>0) //liczba pantografów + --model->MoverParameters->EnginePowerSource.CollectorParameters.CollectorsNo; //teraz będzie mniejsza + if (DebugModeFlag) + ErrorLog("Pant. break: at "+FloatToStrF(pant0.x,ffFixed,7,2)+" "+FloatToStrF(pant0.y,ffFixed,7,2)+" "+FloatToStrF(pant0.z,ffFixed,7,2)); + } + } + else if (fVerticalPantTraction) //ale niżej, niż poprzednio znaleziony + { + fHorizontal=fabs(DotProduct(vGdzie,vLeft))-p->fWidth; + if (fHorizontal<=0.0) //0.635 dla AKP-1 AKP-4E + {//to się musi mieścić w przedziale zaleznym od szerokości pantografu + p->hvPowerWire=node->hvTraction; //jakiś znaleziony + p->PantTraction=fVertical; //zapamiętanie nowej wysokości + //p->fHorizontal=fHorizontal; //zapamiętanie położenia drutu + } + else if (fHorizontalfWidthExtra) //czy zmieścił się w zakresie nabieżnika? + {//problem jest, gdy nowy drut jest wyżej, wtedy pantograf odłącza się od starego, a na podniesienie do nowego potrzebuje czasu + fVertical+=0.15*fHorizontal/p->fWidthExtra; //korekta wysokości o nabieżnik - drut nad nabieżnikiem jest geometrycznie jakby nieco wyżej + if (fVerticalPantTraction) //gdy po korekcie jest niżej, niż poprzednio znaleziony + {//gdyby to wystarczyło, to możemy go uznać + p->hvPowerWire=node->hvTraction; //może być + p->PantTraction=fVertical; //na razie liniowo na nabieżniku, dokładność poprawi się później + //p->fHorizontal=fHorizontal; //zapamiętanie położenia drutu + } + } + } + } //warunek na parametr drutu <0;1> + } //pętla po drutach + } //sektor istnieje + } //pętla po sektorach + } //koniec poszukiwania w sektorach + if (!p->hvPowerWire) //jeśli drut nie znaleziony + if (!Global::bLiveTraction) //ale można oszukiwać + model->pants[k].fParamPants->PantTraction=1.4; //to dajemy coś tam dla picu + } //koniec obsługi podniesionego + else + p->hvPowerWire=NULL; //pantograf opuszczony + } + //if (model->fWahaczeAmpMoverParameters->DistCounter) + //{//nieużywana normalnie zmienna ogranicza powtórzone logowania + //model->fWahaczeAmp=model->MoverParameters->DistCounter; + //ErrorLog(FloatToStrF(1000.0*model->MoverParameters->DistCounter,ffFixed,7,3)+","+FloatToStrF(p->PantTraction,ffFixed,7,3)+","+FloatToStrF(p->fHorizontal,ffFixed,7,3)+","+FloatToStrF(p->PantWys,ffFixed,7,3)+","+AnsiString(p->hvPowerWire?1:0)); // + //if (p->fHorizontal>1.0) + //{ + // //Global::iPause|=1; //zapauzowanie symulacji + // Global::fTimeSpeed=1; //spowolnienie czasu do obejrzenia pantografu + // return true; //łapacz + //} + //} + return true; +}; + +bool __fastcall TGround::RenderDL(vector3 pPosition) +{//renderowanie scenerii z Display List - faza nieprzezroczystych + glDisable(GL_BLEND); + glAlphaFunc(GL_GREATER,0.45); // im mniejsza wartość, tym większa ramka, domyślnie 0.1f + ++TGroundRect::iFrameNumber; //zwięszenie licznika ramek (do usuwniania nadanimacji) + CameraDirection.x=sin(Global::pCameraRotation); //wektor kierunkowy + CameraDirection.z=cos(Global::pCameraRotation); + int tr,tc; + TGroundNode *node; + glColor3f(1.0f,1.0f,1.0f); + glEnable(GL_LIGHTING); + int n=2*iNumSubRects; //(2*==2km) promień wyświetlanej mapy w sektorach + int c=GetColFromX(pPosition.x); + int r=GetRowFromZ(pPosition.z); + TSubRect *tmp; + for (node=srGlobal.nRenderHidden;node;node=node->nNext3) + node->RenderHidden(); //rednerowanie globalnych (nie za często?) + int i,j,k; + //renderowanie czołgowe dla obiektów aktywnych a niewidocznych + for (j=r-n;j<=r+n;j++) + for (i=c-n;i<=c+n;i++) + if ((tmp=FastGetSubRect(i,j))!=NULL) + {tmp->LoadNodes(); //oznaczanie aktywnych sektorów + for (node=tmp->nRenderHidden;node;node=node->nNext3) + node->RenderHidden(); + tmp->RenderSounds(); //jeszcze dźwięki pojazdów by się przydały, również niewidocznych + } + //renderowanie progresywne - zależne od FPS oraz kierunku patrzenia + iRendered=0; //ilość renderowanych sektorów + vector3 direction; + for (k=0;k=0 + j=SectorOrder[k].y; + do + { + if (j<=0) i=-i; //pierwszy przebieg: j<=0, i>=0; drugi: j>=0, i<=0; trzeci: j<=0, i<=0 czwarty: j>=0, i>=0; + j=-j; //i oraz j musi być zmienione wcześniej, żeby continue działało + direction=vector3(i,0,j); //wektor od kamery do danego sektora + if (LengthSquared3(direction)>5) //te blisko są zawsze wyświetlane + {direction=SafeNormalize(direction); //normalizacja + if (CameraDirection.x*direction.x+CameraDirection.z*direction.z<0.55) + continue; //pomijanie sektorów poza kątem patrzenia + } + Rects[(i+c)/iNumSubRects][(j+r)/iNumSubRects].RenderDL(); //kwadrat kilometrowy nie zawsze, bo szkoda FPS + if ((tmp=FastGetSubRect(i+c,j+r))!=NULL) + if (tmp->iNodeCount) //o ile są jakieś obiekty, bo po co puste sektory przelatywać + pRendered[iRendered++]=tmp; //tworzenie listy sektorów do renderowania + } + while ((i<0)||(j<0)); //są 4 przypadki, oprócz i=j=0 + } + for (i=0;iRenderDL(); //renderowanie nieprzezroczystych + return true; +} + +bool __fastcall TGround::RenderAlphaDL(vector3 pPosition) +{//renderowanie scenerii z Display List - faza przezroczystych + glEnable(GL_BLEND); + glAlphaFunc(GL_GREATER,0.04); // im mniejsza wartość, tym większa ramka, domyślnie 0.1f + TGroundNode *node; + glColor4f(1.0f,1.0f,1.0f,1.0f); + TSubRect *tmp; + //Ra: renderowanie progresywne - zależne od FPS oraz kierunku patrzenia + int i; + for (i=iRendered-1;i>=0;--i) //od najdalszych + {//przezroczyste trójkąty w oddzielnym cyklu przed modelami + tmp=pRendered[i]; + for (node=tmp->nRenderRectAlpha;node;node=node->nNext3) + node->RenderAlphaDL(); //przezroczyste modele + } + for (i=iRendered-1;i>=0;--i) //od najdalszych + {//renderowanie przezroczystych modeli oraz pojazdów + pRendered[i]->RenderAlphaDL(); + } + glDisable(GL_LIGHTING); //linie nie powinny świecić + for (i=iRendered-1;i>=0;--i) //od najdalszych + {//druty na końcu, żeby się nie robiły białe plamy na tle lasu + tmp=pRendered[i]; + for (node=tmp->nRenderWires;node;node=node->nNext3) + node->RenderAlphaDL(); //druty + } + return true; +} + +bool __fastcall TGround::RenderVBO(vector3 pPosition) +{//renderowanie scenerii z VBO - faza nieprzezroczystych + glDisable(GL_BLEND); + glAlphaFunc(GL_GREATER,0.45); // im mniejsza wartość, tym większa ramka, domyślnie 0.1f + ++TGroundRect::iFrameNumber; //zwięszenie licznika ramek + CameraDirection.x=sin(Global::pCameraRotation); //wektor kierunkowy + CameraDirection.z=cos(Global::pCameraRotation); + int tr,tc; + TGroundNode *node; + glColor3f(1.0f,1.0f,1.0f); + glEnable(GL_LIGHTING); + int n=2*iNumSubRects; //(2*==2km) promień wyświetlanej mapy w sektorach + int c=GetColFromX(pPosition.x); + int r=GetRowFromZ(pPosition.z); + TSubRect *tmp; + for (node=srGlobal.nRenderHidden;node;node=node->nNext3) + node->RenderHidden(); //rednerowanie globalnych (nie za często?) + int i,j,k; + //renderowanie czołgowe dla obiektów aktywnych a niewidocznych + for (j=r-n;j<=r+n;j++) + for (i=c-n;i<=c+n;i++) + { + if ((tmp=FastGetSubRect(i,j))!=NULL) + {for (node=tmp->nRenderHidden;node;node=node->nNext3) + node->RenderHidden(); + tmp->RenderSounds(); //jeszcze dźwięki pojazdów by się przydały, również niewidocznych + } + } + //renderowanie progresywne - zależne od FPS oraz kierunku patrzenia + iRendered=0; //ilość renderowanych sektorów + vector3 direction; + for (k=0;k=0 + j=SectorOrder[k].y; + do + { + if (j<=0) i=-i; //pierwszy przebieg: j<=0, i>=0; drugi: j>=0, i<=0; trzeci: j<=0, i<=0 czwarty: j>=0, i>=0; + j=-j; //i oraz j musi być zmienione wcześniej, żeby continue działało + direction=vector3(i,0,j); //wektor od kamery do danego sektora + if (LengthSquared3(direction)>5) //te blisko są zawsze wyświetlane + {direction=SafeNormalize(direction); //normalizacja + if (CameraDirection.x*direction.x+CameraDirection.z*direction.z<0.55) + continue; //pomijanie sektorów poza kątem patrzenia + } + Rects[(i+c)/iNumSubRects][(j+r)/iNumSubRects].RenderVBO(); //kwadrat kilometrowy nie zawsze, bo szkoda FPS + if ((tmp=FastGetSubRect(i+c,j+r))!=NULL) + if (tmp->iNodeCount) //jeżeli są jakieś obiekty, bo po co puste sektory przelatywać + pRendered[iRendered++]=tmp; //tworzenie listy sektorów do renderowania + } + while ((i<0)||(j<0)); //są 4 przypadki, oprócz i=j=0 + } + //dodać rednerowanie terenu z E3D - jedno VBO jest używane dla całego modelu, chyba że jest ich więcej + if (Global::pTerrainCompact) + Global::pTerrainCompact->TerrainRenderVBO(TGroundRect::iFrameNumber); + for (i=0;iRenderVBO(); + } + return true; +} + +bool __fastcall TGround::RenderAlphaVBO(vector3 pPosition) +{//renderowanie scenerii z VBO - faza przezroczystych + glEnable(GL_BLEND); + glAlphaFunc(GL_GREATER,0.04); // im mniejsza wartość, tym większa ramka, domyślnie 0.1f + TGroundNode *node; + glColor4f(1.0f,1.0f,1.0f,1.0f); + TSubRect *tmp; + int i; + for (i=iRendered-1;i>=0;--i) //od najdalszych + {//renderowanie przezroczystych trójkątów sektora + tmp=pRendered[i]; + tmp->LoadNodes(); //ewentualne tworzenie siatek + if (tmp->StartVBO()) + {for (node=tmp->nRenderRectAlpha;node;node=node->nNext3) + if (node->iVboPtr>=0) + node->RenderAlphaVBO(); //nieprzezroczyste obiekty terenu + tmp->EndVBO(); + } + } + for (i=iRendered-1;i>=0;--i) //od najdalszych + pRendered[i]->RenderAlphaVBO(); //przezroczyste modeli oraz pojazdy + glDisable(GL_LIGHTING); //linie nie powinny świecić + for (i=iRendered-1;i>=0;--i) //od najdalszych + {//druty na końcu, żeby się nie robiły białe plamy na tle lasu + tmp=pRendered[i]; + if (tmp->StartVBO()) + {for (node=tmp->nRenderWires;node;node=node->nNext3) + node->RenderAlphaVBO(); //przezroczyste modele + tmp->EndVBO(); + } + } + return true; +}; + +//--------------------------------------------------------------------------- +void __fastcall TGround::Navigate(String ClassName,UINT Msg,WPARAM wParam,LPARAM lParam) +{//wysłanie komunikatu do sterującego + HWND h=FindWindow(ClassName.c_str(),0); //można by to zapamiętać + if (h==0) h=FindWindow(0,ClassName.c_str()); //można by to zapamiętać + SendMessage(h,Msg,wParam,lParam); +}; +//-------------------------------- +void __fastcall TGround::WyslijEvent(const AnsiString &e,const AnsiString &d) +{//Ra: jeszcze do wyczyszczenia + DaneRozkaz r; + r.iSygn='EU07'; + r.iComm=2; //2 - event + int i=e.Length(),j=d.Length(); + r.cString[0]=char(i); + strcpy(r.cString+1,e.c_str()); //zakończony zerem + r.cString[i+2]=char(j); //licznik po zerze kończącym + strcpy(r.cString+3+i,d.c_str()); //zakończony zerem + COPYDATASTRUCT cData; + cData.dwData='EU07'; //sygnatura + cData.cbData=12+i+j; //8+dwa liczniki i dwa zera kończące + cData.lpData=&r; + Navigate("TEU07SRK",WM_COPYDATA,(WPARAM)Global::hWnd,(LPARAM)&cData); +}; +//--------------------------------------------------------------------------- +void __fastcall TGround::WyslijString(const AnsiString &t,int n) +{//wysłanie informacji w postaci pojedynczego tekstu + DaneRozkaz r; + r.iSygn='EU07'; + r.iComm=n; //numer komunikatu + int i=t.Length(); + r.cString[0]=char(i); + strcpy(r.cString+1,t.c_str()); //z zerem kończącym + COPYDATASTRUCT cData; + cData.dwData='EU07'; //sygnatura + cData.cbData=10+i; //8+licznik i zero kończące + cData.lpData=&r; + Navigate("TEU07SRK",WM_COPYDATA,(WPARAM)Global::hWnd,(LPARAM)&cData); +}; +//--------------------------------------------------------------------------- +void __fastcall TGround::WyslijWolny(const AnsiString &t) +{//Ra: jeszcze do wyczyszczenia + WyslijString(t,4); //tor wolny +}; +//-------------------------------- +void __fastcall TGround::WyslijNamiary(TGroundNode* t) +{//wysłanie informacji o pojeździe - (float), długość ramki będzie zwiększana w miarę potrzeby +// WriteLog("Wysylam pojazd"); + DaneRozkaz r; + r.iSygn='EU07'; + r.iComm=7; //7 - dane pojazdu + int i=32,j=t->asName.Length(); + r.iPar[ 0]=i; //ilość danych liczbowych + r.fPar[ 1]=Global::fTimeAngleDeg/360.0; //aktualny czas (1.0=doba) + r.fPar[ 2]=t->DynamicObject->MoverParameters->Loc.X; //pozycja X + r.fPar[ 3]=t->DynamicObject->MoverParameters->Loc.Y; //pozycja Y + r.fPar[ 4]=t->DynamicObject->MoverParameters->Loc.Z; //pozycja Z + r.fPar[ 5]=t->DynamicObject->MoverParameters->V; //prędkość ruchu X + r.fPar[ 6]=t->DynamicObject->MoverParameters->nrot*M_PI*t->DynamicObject->MoverParameters->WheelDiameter; //prędkość obrotowa kóŁ + r.fPar[ 7]=0; //prędkość ruchu Z + r.fPar[ 8]=t->DynamicObject->MoverParameters->AccS; //przyspieszenie X + r.fPar[ 9]=t->DynamicObject->MoverParameters->AccN; //przyspieszenie Y //na razie nie + r.fPar[10]=t->DynamicObject->MoverParameters->AccV; //przyspieszenie Z + r.fPar[11]=t->DynamicObject->MoverParameters->DistCounter; //przejechana odległość w km + r.fPar[12]=t->DynamicObject->MoverParameters->PipePress; //ciśnienie w PG + r.fPar[13]=t->DynamicObject->MoverParameters->ScndPipePress; //ciśnienie w PZ + r.fPar[14]=t->DynamicObject->MoverParameters->BrakePress; //ciśnienie w CH + r.fPar[15]=t->DynamicObject->MoverParameters->Compressor; //ciśnienie w ZG + r.fPar[16]=t->DynamicObject->MoverParameters->Itot; //Prąd całkowity + r.iPar[17]=t->DynamicObject->MoverParameters->MainCtrlPos; //Pozycja NJ + r.iPar[18]=t->DynamicObject->MoverParameters->ScndCtrlPos; //Pozycja NB + r.iPar[19]=t->DynamicObject->MoverParameters->MainCtrlActualPos; //Pozycja jezdna + r.iPar[20]=t->DynamicObject->MoverParameters->ScndCtrlActualPos; //Pozycja bocznikowania + r.iPar[21]=t->DynamicObject->MoverParameters->ScndCtrlActualPos; //Pozycja bocznikowania + r.iPar[22]=t->DynamicObject->MoverParameters->ResistorsFlag*1+t->DynamicObject->MoverParameters->ConverterFlag*2+ + +t->DynamicObject->MoverParameters->CompressorFlag*4+t->DynamicObject->MoverParameters->Mains*8+ + +t->DynamicObject->MoverParameters->DoorLeftOpened*16+t->DynamicObject->MoverParameters->DoorRightOpened*32+ + +t->DynamicObject->MoverParameters->FuseFlag*64+t->DynamicObject->MoverParameters->DepartureSignal*128; +// WriteLog("Zapisalem stare"); +// WriteLog("Mam patykow "+IntToStr(t->DynamicObject->iAnimType[ANIM_PANTS])); + for(int p=0;p<4;p++) + { +// WriteLog("Probuje pant "+IntToStr(p)); + if(pDynamicObject->iAnimType[ANIM_PANTS]) + { + r.fPar[23+p]=t->DynamicObject->pants[p].fParamPants->PantWys; //stan pantografów 4 +// WriteLog("Zapisalem pant "+IntToStr(p)); + } + else + { + r.fPar[23+p]=-2; +// WriteLog("Nie mam pant "+IntToStr(p)); + } + } +// WriteLog("Zapisalem pantografy"); + for(int p=0;p<3;p++) + r.fPar[27+p]=t->DynamicObject->MoverParameters->ShowCurrent(p+1); //amperomierze kolejnych grup +// WriteLog("zapisalem prady"); + r.iPar[30]=t->DynamicObject->MoverParameters->WarningSignal; //trabienie + r.fPar[31]=t->DynamicObject->MoverParameters->RunningTraction.TractionVoltage; //napiecie WN +// WriteLog("Parametry gotowe"); + i<<=2; //ilość bajtów + r.cString[i]=char(j); //na końcu nazwa, żeby jakoś zidentyfikować + strcpy(r.cString+i+1,t->asName.c_str()); //zakończony zerem + COPYDATASTRUCT cData; + cData.dwData='EU07'; //sygnatura + cData.cbData=10+i+j; //8+licznik i zero kończące + cData.lpData=&r; +// WriteLog("Ramka gotowa"); + Navigate("TEU07SRK",WM_COPYDATA,(WPARAM)Global::hWnd,(LPARAM)&cData); +// WriteLog("Ramka poszla!"); +}; +//-------------------------------- +void __fastcall TGround::WyslijParam(int nr,int fl) +{//wysłanie parametrów symulacji w ramce (nr) z flagami (fl) + DaneRozkaz r; + r.iSygn='EU07'; + r.iComm=nr; //zwykle 5 + r.iPar[0]=fl; //flagi istotności kolejnych parametrów + int i=0; //domyślnie brak danych + switch (nr) + {//można tym przesyłać różne zestawy parametrów + case 5: //czas i pauza + r.fPar[1]=Global::fTimeAngleDeg/360.0; //aktualny czas (1.0=doba) + r.iPar[2]=Global::iPause; //stan zapauzowania + i=8; //dwa parametry po 4 bajty każdy + break; + } + COPYDATASTRUCT cData; + cData.dwData='EU07'; //sygnatura + cData.cbData=12+i; //12+rozmiar danych + cData.lpData=&r; + Navigate("TEU07SRK",WM_COPYDATA,(WPARAM)Global::hWnd,(LPARAM)&cData); +}; +//--------------------------------------------------------------------------- +//--------------------------------------------------------------------------- +//--------------------------------------------------------------------------- +void __fastcall TGround::RadioStop(vector3 pPosition) +{//zatrzymanie pociągów w okolicy + TGroundNode *node; + TSubRect *tmp; + int c=GetColFromX(pPosition.x); + int r=GetRowFromZ(pPosition.z); + int i,j; + int n=2*iNumSubRects; //przeglądanie czołgowe okolicznych torów w kwadracie 4km×4km + for (j=r-n;j<=r+n;j++) + for (i=c-n;i<=c+n;i++) + if ((tmp=FastGetSubRect(i,j))!=NULL) + for (node=tmp->nRootNode;node!=NULL;node=node->nNext2) + if (node->iType==TP_TRACK) + node->pTrack->RadioStop(); //przekazanie do każdego toru w każdym segmencie +}; + +TDynamicObject* __fastcall TGround::DynamicNearest(vector3 pPosition,double distance,bool mech) +{//wyszukanie pojazdu najbliższego względem (pPosition) + TGroundNode *node; + TSubRect *tmp; + TDynamicObject *dyn=NULL; + int c=GetColFromX(pPosition.x); + int r=GetRowFromZ(pPosition.z); + int i,j,k; + double sqm=distance*distance,sqd; //maksymalny promien poszukiwań do kwadratu + for (j=r-1;j<=r+1;j++) //plus dwa zewnętrzne sektory, łącznie 9 + for (i=c-1;i<=c+1;i++) + if ((tmp=FastGetSubRect(i,j))!=NULL) + for (node=tmp->nRootNode;node;node=node->nNext2) //następny z sektora + if (node->iType==TP_TRACK) //Ra: przebudować na użycie tabeli torów? + for (k=0;kpTrack->iNumDynamics;k++) + if (mech?(node->pTrack->Dynamics[k]->Mechanik!=NULL):true) //czy ma mieć obsadę + if ((sqd=SquareMagnitude(node->pTrack->Dynamics[k]->GetPosition()-pPosition))pTrack->Dynamics[k]; //nowy lider + } + return dyn; +}; +TDynamicObject* __fastcall TGround::CouplerNearest(vector3 pPosition,double distance,bool mech) +{//wyszukanie pojazdu, którego sprzęg jest najbliżej względem (pPosition) + TGroundNode *node; + TSubRect *tmp; + TDynamicObject *dyn=NULL; + int c=GetColFromX(pPosition.x); + int r=GetRowFromZ(pPosition.z); + int i,j,k; + double sqm=distance*distance,sqd; //maksymalny promien poszukiwań do kwadratu + for (j=r-1;j<=r+1;j++) //plus dwa zewnętrzne sektory, łącznie 9 + for (i=c-1;i<=c+1;i++) + if ((tmp=FastGetSubRect(i,j))!=NULL) + for (node=tmp->nRootNode;node;node=node->nNext2) //następny z sektora + if (node->iType==TP_TRACK) //Ra: przebudować na użycie tabeli torów? + for (k=0;kpTrack->iNumDynamics;k++) + if (mech?(node->pTrack->Dynamics[k]->Mechanik!=NULL):true) //czy ma mieć obsadę + {if ((sqd=SquareMagnitude(node->pTrack->Dynamics[k]->HeadPosition()-pPosition))pTrack->Dynamics[k]; //nowy lider + } + if ((sqd=SquareMagnitude(node->pTrack->Dynamics[k]->RearPosition()-pPosition))pTrack->Dynamics[k]; //nowy lider + } + } + return dyn; +}; +//--------------------------------------------------------------------------- +void __fastcall TGround::DynamicRemove(TDynamicObject* dyn) +{//Ra: usunięcie pojazdów ze scenerii (gdy dojadą na koniec i nie sa potrzebne) + TDynamicObject* d=dyn->Prev(); + if (d) //jeśli coś jest z przodu + DynamicRemove(d); //zaczynamy od tego z przodu + else + {//jeśli mamy już tego na początku + TGroundNode **n,*node; + d=dyn; //od pierwszego + while (d) + {if (d->MyTrack) d->MyTrack->RemoveDynamicObject(d); //usunięcie z toru o ile nie usunięty + n=&nRootDynamic; //lista pojazdów od początku + //node=NULL; //nie znalezione + while (*n?(*n)->DynamicObject!=d:false) + {//usuwanie z listy pojazdów + n=&((*n)->nNext); //sprawdzenie kolejnego pojazdu na liście + } + if ((*n)->DynamicObject==d) + {//jeśli znaleziony + node=(*n); //zapamiętanie węzła, aby go usunąć + (*n)=node->nNext; //pominięcie na liście + Global::TrainDelete(d); + d=d->Next(); //przejście do kolejnego pojazdu, póki jeszcze jest + delete node; //usuwanie fizyczne z pamięci + } + else + d=NULL; //coś nie tak! + } + } +}; + +//--------------------------------------------------------------------------- +void __fastcall TGround::TerrainRead(const AnsiString &f) +{//Ra: wczytanie trójkątów terenu z pliku E3D +}; + +//--------------------------------------------------------------------------- +void __fastcall TGround::TerrainWrite() +{//Ra: zapisywanie trójkątów terenu do pliku E3D + if (Global::pTerrainCompact->TerrainLoaded()) + return; //jeśli zostało wczytane, to nie ma co dalej robić + if (Global::asTerrainModel.IsEmpty()) return; + //Trójkąty są zapisywane kwadratami kilometrowymi. + //Kwadrat 500500 jest na środku (od 0.0 do 1000.0 na OX oraz OZ). + //Ewentualnie w numerowaniu kwadratów uwzględnic wpis //$g. + //Trójkąty są grupowane w submodele wg tekstury. + //Triangle_strip oraz triangle_fan są rozpisywane na pojedyncze trójkąty, + // chyba że dla danej tekstury wychodzi tylko jeden submodel. + TModel3d *m=new TModel3d(); //wirtualny model roboczy z oddzielnymi submodelami + TSubModel *sk; //wskaźnik roboczy na submodel kwadratu + TSubModel *st; //wskaźnik roboczy na submodel tekstury + //Zliczamy kwadraty z trójkątami, ilość tekstur oraz wierzchołków. + //Ilość kwadratów i ilość tekstur określi ilość submodeli. + //int sub=0; //całkowita ilość submodeli + //int ver=0; //całkowita ilość wierzchołków + int i,j,k; //indeksy w pętli + TGroundNode *Current; + float8 *ver; //trójkąty + TSubModel::iInstance=0; //pozycja w tabeli wierzchołków liczona narastająco + for (i=0;iNameSet(AnsiString(1000*(500+i-iNumRects/2)+(500+j-iNumRects/2)).c_str()); //nazwa=numer kwadratu + m->AddTo(NULL,sk); //dodanie submodelu dla kwadratu + for (Current=Rects[i][j].nRootNode;Current;Current=Current->nNext2) + if (Current->TextureID) + switch (Current->iType) + {//pętla po trójkątach - zliczanie wierzchołków, dodaje submodel dla każdej tekstury + case GL_TRIANGLES: + Current->iVboPtr=sk->TriangleAdd(m,Current->TextureID,Current->iNumVerts); //zwiększenie ilości trójkątów w submodelu + m->iNumVerts+=Current->iNumVerts; //zwiększenie całkowitej ilości wierzchołków + break; + case GL_TRIANGLE_STRIP: //na razie nie, bo trzeba przerabiać na pojedyncze trójkąty + break; + case GL_TRIANGLE_FAN: //na razie nie, bo trzeba przerabiać na pojedyncze trójkąty + break; + } + for (Current=Rects[i][j].nRootNode;Current;Current=Current->nNext2) + if (Current->TextureID) + switch (Current->iType) + {//pętla po trójkątach - dopisywanie wierzchołków + case GL_TRIANGLES: + //ver=sk->TrianglePtr(TTexturesManager::GetName(Current->TextureID).c_str(),Current->iNumVerts); //wskaźnik na początek + ver=sk->TrianglePtr(Current->TextureID,Current->iVboPtr,Current->Ambient,Current->Diffuse,Current->Specular); //wskaźnik na początek + //WriteLog("Zapis "+AnsiString(Current->iNumVerts)+" trójkątów w ("+AnsiString(i)+","+AnsiString(j)+") od "+AnsiString(Current->iVboPtr)+" dla "+AnsiString(Current->TextureID)); + Current->iVboPtr=-1; //bo to było tymczasowo używane + for (k=0;kiNumVerts;++k) + {//przepisanie współrzędnych + ver[k].Point.x=Current->Vertices[k].Point.x; + ver[k].Point.y=Current->Vertices[k].Point.y; + ver[k].Point.z=Current->Vertices[k].Point.z; + ver[k].Normal.x=Current->Vertices[k].Normal.x; + ver[k].Normal.y=Current->Vertices[k].Normal.y; + ver[k].Normal.z=Current->Vertices[k].Normal.z; + ver[k].tu=Current->Vertices[k].tu; + ver[k].tv=Current->Vertices[k].tv; + } + break; + case GL_TRIANGLE_STRIP: //na razie nie, bo trzeba przerabiać na pojedyncze trójkąty + break; + case GL_TRIANGLE_FAN: //na razie nie, bo trzeba przerabiać na pojedyncze trójkąty + break; + } + } + m->SaveToBinFile(AnsiString("models\\"+Global::asTerrainModel).c_str()); +}; +//--------------------------------------------------------------------------- + +void __fastcall TGround::TrackBusyList() +{//wysłanie informacji o wszystkich zajętych odcinkach + TGroundNode *Current; + TTrack *Track; + AnsiString name; + for (Current=nRootOfType[TP_TRACK];Current;Current=Current->nNext) + if (!Current->asName.IsEmpty()) //musi być nazwa + if (Current->pTrack->iNumDynamics) //osi to chyba nie ma jak policzyć + WyslijString(Current->asName,8); //zajęty +}; +//--------------------------------------------------------------------------- + +void __fastcall TGround::IsolatedBusyList() +{//wysłanie informacji o wszystkich odcinkach izolowanych + TIsolated *Current; + for (Current=TIsolated::Root();Current;Current=Current->Next()) + if (Current->Busy()) //sprawdź zajętość + WyslijString(Current->asName,11); //zajęty + else + WyslijString(Current->asName,10); //wolny + WyslijString("none",10); //informacja o końcu listy +}; +//--------------------------------------------------------------------------- + +void __fastcall TGround::IsolatedBusy(const AnsiString t) +{//wysłanie informacji o odcinku izolowanym (t) + //Ra 2014-06: do wyszukania użyć drzewka nazw + TIsolated *Current; + for (Current=TIsolated::Root();Current;Current=Current->Next()) + if (Current->asName==t) //wyszukiwanie odcinka o nazwie (t) + if (Current->Busy()) //sprawdź zajetość + {WyslijString(Current->asName,11); //zajęty + return; //nie sprawdzaj dalszych + } + WyslijString(t,10); //wolny +}; +//--------------------------------------------------------------------------- + +void __fastcall TGround::Silence(vector3 gdzie) +{//wyciszenie wszystkiego w sektorach przed przeniesieniem kamery z (gdzie) + int tr,tc; + TGroundNode *node; + int n=2*iNumSubRects; //(2*==2km) promień wyświetlanej mapy w sektorach + int c=GetColFromX(gdzie.x); //sektory wg dotychczasowej pozycji kamery + int r=GetRowFromZ(gdzie.z); + TSubRect *tmp; + int i,j,k; + //renderowanie czołgowe dla obiektów aktywnych a niewidocznych + for (j=r-n;j<=r+n;j++) + for (i=c-n;i<=c+n;i++) + if ((tmp=FastGetSubRect(i,j))!=NULL) + {//tylko dźwięki interesują + for (node=tmp->nRenderHidden;node;node=node->nNext3) + node->RenderHidden(); + tmp->RenderSounds(); //dźwięki pojazdów by się przydało wyłączyć + } +}; +//--------------------------------------------------------------------------- diff --git a/Ground.h b/Ground.h new file mode 100644 index 00000000..e69309f2 --- /dev/null +++ b/Ground.h @@ -0,0 +1,367 @@ +//--------------------------------------------------------------------------- + +#ifndef groundH +#define groundH + +#include "dumb3d.h" +#include "ResourceManager.h" +#include "VBO.h" +#include "Classes.h" + +using namespace Math3D; + +//Ra: zmniejszone liczby, aby zrobić tabelkę i zoptymalizować wyszukiwanie +const int TP_MODEL=10; +const int TP_MESH=11; //Ra: specjalny obiekt grupojący siatki dla tekstury +const int TP_DUMMYTRACK=12; //Ra: zdublowanie obiektu toru dla rozdzielenia tekstur +const int TP_TERRAIN=13; //Ra: specjalny model dla terenu +const int TP_DYNAMIC=14; +const int TP_SOUND=15; +const int TP_TRACK=16; +//const int TP_GEOMETRY=17; +const int TP_MEMCELL=18; +const int TP_EVLAUNCH=19; //MC +const int TP_TRACTION=20; +const int TP_TRACTIONPOWERSOURCE=21; //MC +//const int TP_ISOLATED=22; //Ra +const int TP_SUBMODEL=22; //Ra: submodele terenu +const int TP_LAST=25; //rozmiar tablicy + +struct DaneRozkaz +{//struktura komunikacji z EU07.EXE + int iSygn; //sygnatura 'EU07' + int iComm; //rozkaz/status (kod ramki) + union + {float fPar[62]; + int iPar[62]; + char cString[248]; //upakowane stringi + }; +}; + + + +typedef int TGroundNodeType; + +struct TGroundVertex +{ + vector3 Point; + vector3 Normal; + float tu,tv; + void HalfSet(const TGroundVertex &v1,const TGroundVertex &v2) + {//wyliczenie współrzędnych i mapowania punktu na środku odcinka v1<->v2 + Point=0.5*(v1.Point+v2.Point); + Normal=0.5*(v1.Normal+v2.Normal); + tu=0.5*(v1.tu+v2.tu); + tv=0.5*(v1.tv+v2.tv); + } + void SetByX(const TGroundVertex &v1,const TGroundVertex &v2,double x) + {//wyliczenie współrzędnych i mapowania punktu na odcinku v1<->v2 + double i=(x-v1.Point.x)/(v2.Point.x-v1.Point.x); //parametr równania + double j=1.0-i; + Point=j*v1.Point+i*v2.Point; + Normal=j*v1.Normal+i*v2.Normal; + tu=j*v1.tu+i*v2.tu; + tv=j*v1.tv+i*v2.tv; + } + void SetByZ(const TGroundVertex &v1,const TGroundVertex &v2,double z) + {//wyliczenie współrzędnych i mapowania punktu na odcinku v1<->v2 + double i=(z-v1.Point.z)/(v2.Point.z-v1.Point.z); //parametr równania + double j=1.0-i; + Point=j*v1.Point+i*v2.Point; + Normal=j*v1.Normal+i*v2.Normal; + tu=j*v1.tu+i*v2.tu; + tv=j*v1.tv+i*v2.tv; + } +}; + +class TSubRect; //sektor (aktualnie 200m×200m, ale może być zmieniony) + +class TGroundNode : public Resource +{//obiekt scenerii +private: +public: + TGroundNodeType iType; //typ obiektu + union + {//Ra: wskażniki zależne od typu - zrobić klasy dziedziczone zamiast + void *Pointer; //do przypisywania NULL + TSubModel *smTerrain; //modele terenu (kwadratow kilometrowych) + TAnimModel *Model; //model z animacjami + TDynamicObject *DynamicObject; //pojazd + vector3 *Points; //punkty dla linii + TTrack *pTrack; //trajektoria ruchu + TGroundVertex *Vertices; //wierzchołki dla trójkątów + TMemCell *MemCell; //komórka pamięci + TEventLauncher *EvLaunch; //wyzwalacz zdarzeń + TTraction *hvTraction; //drut zasilający + TTractionPowerSource *psTractionPowerSource; //zasilanie drutu (zaniedbane w sceneriach) + TTextSound *tsStaticSound; //dźwięk przestrzenny + TGroundNode *nNode; //obiekt renderujący grupowo ma tu wskaźnik na listę obiektów + }; + AnsiString asName; //nazwa (nie zawsze ma znaczenie) + union + { + int iNumVerts; //dla trójkątów + int iNumPts; //dla linii + int iCount; //dla terenu + //int iState; //Ra: nie używane - dźwięki zapętlone + }; + vector3 pCenter; //współrzędne środka do przydzielenia sektora + + union + { + //double fAngle; //kąt obrotu dla modelu + double fLineThickness; //McZapkie-120702: grubosc linii + //int Status; //McZapkie-170303: status dzwieku + }; + double fSquareRadius; //kwadrat widoczności do + double fSquareMinRadius; //kwadrat widoczności od + //TGroundNode *nMeshGroup; //Ra: obiekt grupujący trójkąty w TSubRect dla tekstury + int iVersion; //wersja siatki (do wykonania rekompilacji) + //union ? + GLuint DisplayListID; //numer siatki DisplayLists + bool PROBLEND; + int iVboPtr; //indeks w buforze VBO + GLuint TextureID; //główna (jedna) tekstura obiektu + int iFlags; //tryb przezroczystości: 0x10-nieprz.,0x20-przezroczysty,0x30-mieszany + int Ambient[4],Diffuse[4],Specular[4]; //oświetlenie + bool bVisible; + TGroundNode *nNext; //lista wszystkich w scenerii, ostatni na początku + TGroundNode *nNext2; //lista obiektów w sektorze + TGroundNode *nNext3; //lista obiektów renderowanych we wspólnym cyklu + __fastcall TGroundNode(); + __fastcall TGroundNode(TGroundNodeType t,int n=0); + __fastcall ~TGroundNode(); + void __fastcall Init(int n); + void __fastcall InitCenter(); //obliczenie współrzędnych środka + void __fastcall InitNormals(); + + void __fastcall MoveMe(vector3 pPosition); //przesuwanie (nie działa) + + //bool __fastcall Disable(); + inline TGroundNode* __fastcall Find(const AnsiString &asNameToFind,TGroundNodeType iNodeType) + {//wyszukiwanie czołgowe z typem + if ((iNodeType==iType)&&(asNameToFind==asName)) + return this; + else + if (nNext) return nNext->Find(asNameToFind,iNodeType); + return NULL; + }; + + void __fastcall Compile(bool many=false); + void Release(); + bool __fastcall GetTraction(); + + void __fastcall RenderHidden(); //obsługa dźwięków i wyzwalaczy zdarzeń + void __fastcall RenderDL(); //renderowanie nieprzezroczystych w Display Lists + void __fastcall RenderAlphaDL(); //renderowanie przezroczystych w Display Lists (McZapkie-131202) + void __fastcall RaRenderVBO(); //renderowanie (nieprzezroczystych) ze wspólnego VBO + void __fastcall RenderVBO(); //renderowanie nieprzezroczystych z własnego VBO + void __fastcall RenderAlphaVBO(); //renderowanie przezroczystych z (własnego) VBO +}; + +class TSubRect : public Resource, public CMesh +{//sektor składowy kwadratu kilometrowego +public: + int iTracks; //ilość torów w (tTracks) + TTrack **tTracks; //tory do renderowania pojazdów +protected: + TTrack *tTrackAnim; //obiekty do przeliczenia animacji + TGroundNode *nRootMesh; //obiekty renderujące wg tekstury (wtórne, lista po nNext2) + TGroundNode *nMeshed; //lista obiektów dla których istnieją obiekty renderujące grupowo +public: + TGroundNode *nRootNode; //wszystkie obiekty w sektorze, z wyjątkiem renderujących i pojazdów (nNext2) + TGroundNode *nRenderHidden; //lista obiektów niewidocznych, "renderowanych" również z tyłu (nNext3) + TGroundNode *nRenderRect; //z poziomu sektora - nieprzezroczyste (nNext3) + TGroundNode *nRenderRectAlpha; //z poziomu sektora - przezroczyste (nNext3) + TGroundNode *nRenderWires; //z poziomu sektora - druty i inne linie (nNext3) + TGroundNode *nRender; //indywidualnie - nieprzezroczyste (nNext3) + TGroundNode *nRenderMixed; //indywidualnie - nieprzezroczyste i przezroczyste (nNext3) + TGroundNode *nRenderAlpha; //indywidualnie - przezroczyste (nNext3) + int iNodeCount; //licznik obiektów, do pomijania pustych sektorów +public: + void __fastcall LoadNodes(); //utworzenie VBO sektora +public: + __fastcall TSubRect(); + virtual __fastcall ~TSubRect(); + virtual void Release(); //zwalnianie VBO sektora + void __fastcall NodeAdd(TGroundNode *Node); //dodanie obiektu do sektora na etapie rozdzielania na sektory + void __fastcall RaNodeAdd(TGroundNode *Node); //dodanie obiektu do listy renderowania + void __fastcall Sort(); //optymalizacja obiektów w sektorze (sortowanie wg tekstur) + TTrack* __fastcall FindTrack(vector3 *Point,int &iConnection,TTrack *Exclude); + TTraction* __fastcall FindTraction(vector3 *Point,int &iConnection,TTraction *Exclude); + bool __fastcall StartVBO(); //ustwienie VBO sektora dla (nRenderRect), (nRenderRectAlpha) i (nRenderWires) + bool __fastcall RaTrackAnimAdd(TTrack *t); //zgłoszenie toru do animacji + void __fastcall RaAnimate(); //przeliczenie animacji torów + void __fastcall RenderDL(); //renderowanie nieprzezroczystych w Display Lists + void __fastcall RenderAlphaDL(); //renderowanie przezroczystych w Display Lists (McZapkie-131202) + void __fastcall RenderVBO(); //renderowanie nieprzezroczystych z własnego VBO + void __fastcall RenderAlphaVBO(); //renderowanie przezroczystych z (własnego) VBO + void __fastcall RenderSounds(); //dźwięki pojazdów z niewidocznych sektorów +}; + +//Ra: trzeba sprawdzić wydajność siatki +const int iNumSubRects=5; //na ile dzielimy kilometr +const int iNumRects=500; +//const double fHalfNumRects=iNumRects/2.0; //połowa do wyznaczenia środka +const int iTotalNumSubRects=iNumRects*iNumSubRects; +const double fHalfTotalNumSubRects=iTotalNumSubRects/2.0; +const double fSubRectSize=1000.0/iNumSubRects; +const double fRectSize=fSubRectSize*iNumSubRects; + +class TGroundRect : public TSubRect +{//kwadrat kilometrowy + //obiekty o niewielkiej ilości wierzchołków będą renderowane stąd + //Ra: 2012-02 doszły submodele terenu +private: + int iLastDisplay; //numer klatki w której był ostatnio wyświetlany + TSubRect *pSubRects; + void __fastcall Init() { pSubRects=new TSubRect[iNumSubRects*iNumSubRects]; }; +public: + static int iFrameNumber; //numer kolejny wyświetlanej klatki + TGroundNode *nTerrain; //model terenu z E3D - użyć nRootMesh? + __fastcall TGroundRect(); + virtual __fastcall ~TGroundRect(); + + TSubRect* __fastcall SafeGetRect(int iCol,int iRow) + {//pobranie wskaźnika do małego kwadratu, utworzenie jeśli trzeba + if (!pSubRects) Init(); //utworzenie małych kwadratów + return pSubRects+iRow*iNumSubRects+iCol; //zwrócenie właściwego + }; + TSubRect* __fastcall FastGetRect(int iCol,int iRow) + {//pobranie wskaźnika do małego kwadratu, bez tworzenia jeśli nie ma + return (pSubRects?pSubRects+iRow*iNumSubRects+iCol:NULL); + }; + void __fastcall Optimize() + {//optymalizacja obiektów w sektorach + if (pSubRects) + for (int i=iNumSubRects*iNumSubRects-1;i>=0;--i) + pSubRects[i].Sort(); //optymalizacja obiektów w sektorach + }; + void __fastcall RenderDL(); + void __fastcall RenderVBO(); +}; + + +class TGround +{ + vector3 CameraDirection; //zmienna robocza przy renderowaniu + int const *iRange; //tabela widoczności + //TGroundNode *nRootNode; //lista wszystkich węzłów + TGroundNode *nRootDynamic; //lista pojazdów + TGroundRect Rects[iNumRects][iNumRects]; //mapa kwadratów kilometrowych + TEvent *RootEvent; //lista zdarzeń + TEvent *QueryRootEvent,*tmpEvent,*tmp2Event,*OldQRE; + TSubRect *pRendered[1500]; //lista renderowanych sektorów + int iNumNodes; + vector3 pOrigin; + vector3 aRotate; + bool bInitDone; + TGroundNode *nRootOfType[TP_LAST]; //tablica grupująca obiekty, przyspiesza szukanie + //TGroundNode *nLastOfType[TP_LAST]; //ostatnia + TSubRect srGlobal; //zawiera obiekty globalne (na razie wyzwalacze czasowe) + int hh,mm,srh,srm,ssh,ssm; //ustawienia czasu + //int tracks,tracksfar; //liczniki torów + TNames *sTracks; //posortowane nazwy torów i eventów +private: //metody prywatne + bool __fastcall EventConditon(TEvent *e); +public: + bool bDynamicRemove; //czy uruchomić procedurę usuwania pojazdów + TDynamicObject *LastDyn; //ABu: paskudnie, ale na bardzo szybko moze jakos przejdzie... + //TTrain *pTrain; + //double fVDozwolona; + //bool bTrabil; + + __fastcall TGround(); + __fastcall ~TGround(); + void __fastcall Free(); + bool __fastcall Init(AnsiString asFile,HDC hDC); + void __fastcall FirstInit(); + void __fastcall InitTracks(); + void __fastcall InitTraction(); + bool __fastcall InitEvents(); + bool __fastcall InitLaunchers(); + TTrack* __fastcall FindTrack(vector3 Point,int &iConnection,TGroundNode *Exclude); + TTraction* __fastcall FindTraction(vector3 *Point,int &iConnection,TGroundNode *Exclude); + TTraction* __fastcall TractionNearestFind(vector3 &p,int dir,TGroundNode *n); + //TGroundNode* __fastcall CreateGroundNode(); + TGroundNode* __fastcall AddGroundNode(cParser* parser); + bool __fastcall AddGroundNode(double x,double z,TGroundNode *Node) + { + TSubRect *tmp=GetSubRect(x,z); + if (tmp) + { + tmp->NodeAdd(Node); + return true; + } + else + return false; + }; +// bool __fastcall Include(TQueryParserComp *Parser); + //TGroundNode* __fastcall GetVisible(AnsiString asName); + TGroundNode* __fastcall GetNode(AnsiString asName); + bool __fastcall AddDynamic(TGroundNode *Node); + void __fastcall MoveGroundNode(vector3 pPosition); + void __fastcall UpdatePhys(double dt,int iter); //aktualizacja fizyki stałym krokiem + bool __fastcall Update(double dt,int iter); //aktualizacja przesunięć zgodna z FPS + bool __fastcall AddToQuery(TEvent *Event, TDynamicObject *Node); + bool __fastcall GetTraction(TDynamicObject *model); + bool __fastcall RenderDL(vector3 pPosition); + bool __fastcall RenderAlphaDL(vector3 pPosition); + bool __fastcall RenderVBO(vector3 pPosition); + bool __fastcall RenderAlphaVBO(vector3 pPosition); + bool __fastcall CheckQuery(); +// __fastcall GetRect(double x, double z) { return &(Rects[int(x/fSubRectSize+fHalfNumRects)][int(z/fSubRectSize+fHalfNumRects)]); }; +/* + int __fastcall GetRowFromZ(double z) { return (z/fRectSize+fHalfNumRects); }; + int __fastcall GetColFromX(double x) { return (x/fRectSize+fHalfNumRects); }; + int __fastcall GetSubRowFromZ(double z) { return (z/fSubRectSize+fHalfNumSubRects); }; + int __fastcall GetSubColFromX(double x) { return (x/fSubRectSize+fHalfNumSubRects); }; + */ +/* + inline TGroundNode* __fastcall FindGroundNode(const AnsiString &asNameToFind ) + { + if (RootNode) + return (RootNode->Find( asNameToFind )); + else + return NULL; + } +*/ + TGroundNode* __fastcall DynamicFindAny(AnsiString asNameToFind); + TGroundNode* __fastcall DynamicFind(AnsiString asNameToFind); + void __fastcall DynamicList(bool all=false); + TGroundNode* __fastcall FindGroundNode(AnsiString asNameToFind,TGroundNodeType iNodeType); + TGroundRect* __fastcall GetRect(double x, double z) { return &Rects[GetColFromX(x)/iNumSubRects][GetRowFromZ(z)/iNumSubRects]; }; + TSubRect* __fastcall GetSubRect(double x, double z) { return GetSubRect(GetColFromX(x),GetRowFromZ(z)); }; + TSubRect* __fastcall FastGetSubRect(double x, double z) { return FastGetSubRect(GetColFromX(x),GetRowFromZ(z)); }; + TSubRect* __fastcall GetSubRect(int iCol, int iRow); + TSubRect* __fastcall FastGetSubRect(int iCol, int iRow); + int __fastcall GetRowFromZ(double z) { return (z/fSubRectSize+fHalfTotalNumSubRects); }; + int __fastcall GetColFromX(double x) { return (x/fSubRectSize+fHalfTotalNumSubRects); }; + TEvent* __fastcall FindEvent(const AnsiString &asEventName); + TEvent* __fastcall FindEventScan(const AnsiString &asEventName); + void __fastcall TrackJoin(TGroundNode *Current); +private: + void __fastcall OpenGLUpdate(HDC hDC); + void __fastcall RaTriangleDivider(TGroundNode* node); + void __fastcall Navigate(String ClassName,UINT Msg,WPARAM wParam,LPARAM lParam); + bool PROBLEND; +public: + void __fastcall WyslijEvent(const AnsiString &e,const AnsiString &d); + int iRendered; //ilość renderowanych sektorów, pobierana przy pokazywniu FPS + void __fastcall WyslijString(const AnsiString &t,int n); + void __fastcall WyslijWolny(const AnsiString &t); + void __fastcall WyslijNamiary(TGroundNode* t); + void __fastcall WyslijParam(int nr,int fl); + void __fastcall RadioStop(vector3 pPosition); + TDynamicObject* __fastcall DynamicNearest(vector3 pPosition,double distance=20.0,bool mech=false); + TDynamicObject* __fastcall CouplerNearest(vector3 pPosition,double distance=20.0,bool mech=false); + void __fastcall DynamicRemove(TDynamicObject* dyn); + void __fastcall TerrainRead(const AnsiString &f); + void __fastcall TerrainWrite(); + void __fastcall TrackBusyList(); + void __fastcall IsolatedBusyList(); + void __fastcall IsolatedBusy(const AnsiString t); + void __fastcall Silence(vector3 gdzie); +}; +//--------------------------------------------------------------------------- +#endif diff --git a/Logs.cpp b/Logs.cpp new file mode 100644 index 00000000..b2ec162a --- /dev/null +++ b/Logs.cpp @@ -0,0 +1,94 @@ +//--------------------------------------------------------------------------- + +#include "system.hpp" +#include "classes.hpp" +#pragma hdrstop + +#include "Logs.h" +#include "Globals.h" + +#include +#include +#include + +std::ofstream output; //standardowy "log.txt", można go wyłączyć +std::ofstream errors; //lista błędów "errors.txt", zawsze działa + +char endstring[10]="\n"; + +void __fastcall WriteConsoleOnly(const char* str, double value) +{ + char buf[255]; + sprintf(buf,"%s %f \n",str,value); + //stdout= GetStdHandle(STD_OUTPUT_HANDLE); + DWORD wr= 0; + WriteConsole(GetStdHandle(STD_OUTPUT_HANDLE),buf,strlen(buf),&wr,NULL); + //WriteConsole(GetStdHandle(STD_OUTPUT_HANDLE),endstring,strlen(endstring),&wr,NULL); +} + +void __fastcall WriteConsoleOnly(const char* str) +{ + //printf("%n ffafaf /n",str); + SetConsoleTextAttribute(GetStdHandle(STD_OUTPUT_HANDLE),FOREGROUND_GREEN|FOREGROUND_INTENSITY); + DWORD wr= 0; + WriteConsole(GetStdHandle(STD_OUTPUT_HANDLE),str,strlen(str),&wr,NULL); + WriteConsole(GetStdHandle(STD_OUTPUT_HANDLE),endstring,strlen(endstring),&wr,NULL); +} + +void __fastcall WriteLog(const char* str, double value) +{ + if (Global::iWriteLogEnabled) + { + if (str) + { + char buf[255]; + sprintf(buf,"%s %f",str,value); + WriteLog(buf); + } + } +}; +void __fastcall WriteLog(const char* str) +{ + if (str) + { + if (Global::iWriteLogEnabled&1) + {if (!output.is_open()) + output.open("log.txt",std::ios::trunc); + output << str << "\n"; + output.flush(); + } + //hunter-271211: pisanie do konsoli tylko, gdy nie jest ukrywana + if (Global::iWriteLogEnabled&2) + WriteConsoleOnly(str); + } +}; +void __fastcall ErrorLog(const char* str) +{//Ra: bezwarunkowa rejestracja poważnych błędów + if (!errors.is_open()) + {errors.open("errors.txt",std::ios::trunc); + errors << AnsiString("EU07.EXE "+Global::asRelease).c_str() << "\n"; + } + if (str) errors << str; + errors << "\n"; + errors.flush(); +}; + +void __fastcall Error(const AnsiString &asMessage,bool box) +{ + if (box) + MessageBox(NULL,asMessage.c_str(),AnsiString("EU07 "+Global::asRelease).c_str(),MB_OK); + WriteLog(asMessage.c_str()); +} +void __fastcall ErrorLog(const AnsiString &asMessage) +{//zapisywanie błędów "errors.txt" + ErrorLog(asMessage.c_str()); + WriteLog(asMessage.c_str()); //do "log.txt" ewentualnie też +} + +void __fastcall WriteLog(const AnsiString &str) +{//Ra: wersja z AnsiString jest zamienna z Error() + WriteLog(str.c_str()); +}; +//--------------------------------------------------------------------------- + +#pragma package(smart_init) diff --git a/Logs.h b/Logs.h new file mode 100644 index 00000000..81c32a45 --- /dev/null +++ b/Logs.h @@ -0,0 +1,15 @@ +//--------------------------------------------------------------------------- + +#ifndef LogsH +#define LogsH +#include + +void __fastcall WriteConsoleOnly(const char *str, double value); +void __fastcall WriteConsoleOnly(const char *str); +void __fastcall WriteLog(const char *str, double value); +void __fastcall WriteLog(const char *str); +void __fastcall Error(const AnsiString &asMessage,bool box=true); +void __fastcall ErrorLog(const AnsiString &asMessage); +void __fastcall WriteLog(const AnsiString &str); +//--------------------------------------------------------------------------- +#endif diff --git a/Machajka.cpp b/Machajka.cpp new file mode 100644 index 00000000..62d418bc --- /dev/null +++ b/Machajka.cpp @@ -0,0 +1,94 @@ +//--------------------------------------------------------------------------- + +#include "system.hpp" +#include "classes.hpp" +#pragma hdrstop + + +#include "Machajka.h" +#include "Timer.h" +#include "Globals.h" + +__fastcall TMachajka::TMachajka():TTrain() +{ + TTrain::TTrain(); +} + +__fastcall TMachajka::~TMachajka() +{ + +} + +bool __fastcall TMachajka::Init(TDynamicObject *NewDynamicObject) +{ + TTrain::Init(NewDynamicObject); + return true; +} + +void __fastcall TMachajka::OnKeyPress(int cKey) +{ + if (!GetAsyncKeyState(VK_SHIFT)<0) //bez shifta + { + if (cKey==Global::Keys[k_IncMainCtrl]) + (DynamicObject->MoverParameters->AddPulseForce(1)); + else + if (cKey==Global::Keys[k_DecMainCtrl]) + (DynamicObject->MoverParameters->AddPulseForce(-1)); + else + if (cKey==Global::Keys[k_IncLocalBrakeLevel]) + (DynamicObject->MoverParameters->IncLocalBrakeLevel(1)); + else + if (cKey==Global::Keys[k_DecLocalBrakeLevel]) + (DynamicObject->MoverParameters->DecLocalBrakeLevel(1)); + else + if (cKey==Global::Keys[k_MechLeft]) + vMechMovement.x+=fMechCroach; + else + if (cKey==Global::Keys[k_MechRight]) + vMechMovement.x-=fMechCroach; + else + if (cKey==Global::Keys[k_MechBackward]) + vMechMovement.z-=fMechCroach; + else + if (cKey==Global::Keys[k_MechForward]) + vMechMovement.z+=fMechCroach; + else + if (cKey==Global::Keys[k_MechUp]) + pMechOffset.y+=0.3; //McZapkie-120302 - wstawanie + else + if (cKey==Global::Keys[k_MechDown]) + pMechOffset.y-=0.3; //McZapkie-120302 - siadanie, kucanie itp + } + else //z shiftem + { + if (cKey==Global::Keys[k_IncMainCtrlFAST]) + (DynamicObject->MoverParameters->AddPulseForce(2)); + else + if (cKey==Global::Keys[k_DecMainCtrlFAST]) + (DynamicObject->MoverParameters->AddPulseForce(-2)); + else + if (cKey==Global::Keys[k_IncLocalBrakeLevelFAST]) + (DynamicObject->MoverParameters->IncLocalBrakeLevel(2)); + else + if (cKey==Global::Keys[k_DecLocalBrakeLevelFAST]) + (DynamicObject->MoverParameters->DecLocalBrakeLevel(2)); + } +} + +bool __fastcall TMachajka::Update(double dt) +{ + TTrain::Update(dt); +} + +bool __fastcall TMachajka::UpdateMechPosition() +{ + TTrain::UpdateMechPosition(); +} + +bool __fastcall TMachajka::Render() +{ + TTrain::Render(); +} +//--------------------------------------------------------------------------- + +#pragma package(smart_init) diff --git a/Machajka.h b/Machajka.h new file mode 100644 index 00000000..81649103 --- /dev/null +++ b/Machajka.h @@ -0,0 +1,30 @@ +//--------------------------------------------------------------------------- + +#ifndef MachajkaH +#define MachajkaH + +#include "Train.h" + +class TMachajka:public TTrain +{ +public: + TSubModel *wajcha; +// double v; +// double m; +// double a; +// double f; +// bool enter; +// bool space; +// double wa,wv; + __fastcall TMachajka(); + virtual __fastcall ~TMachajka(); + virtual bool __fastcall Init(TDynamicObject *NewDynamicObject); + virtual void __fastcall OnKeyPress(int cKey); + virtual bool __fastcall Update(double dt); + virtual bool __fastcall UpdateMechPosition(); + virtual bool __fastcall Render(); +}; + + +//--------------------------------------------------------------------------- +#endif diff --git a/McZapkie/Mover.hpp b/McZapkie/Mover.hpp new file mode 100644 index 00000000..009f5b8f --- /dev/null +++ b/McZapkie/Mover.hpp @@ -0,0 +1,882 @@ +// Borland C++ Builder +// Copyright (c) 1995, 1999 by Borland International +// All rights reserved + +// (DO NOT EDIT: machine generated header) '_mover.pas' rev: 5.00 +//Ra: eee... tam, sam się generuje błędnie i trzeba ręcznie poprawiać! + +#ifndef _moverHPP +#define _moverHPP + +#pragma delphiheader begin +#pragma option push -w- +#pragma option push -Vx +#include // Pascal unit +#include // Pascal unit +#include // Pascal unit +#include // Pascal unit +#include // Pascal unit +#include // Pascal unit + +//-- user supplied ----------------------------------------------------------- + +namespace _mover +{ +//-- type declarations ------------------------------------------------------- +struct TLocation +{ + double X; + double Y; + double Z; +} ; + +struct TRotation +{ + double Rx; + double Ry; + double Rz; +} ; + +struct TDimension +{ + double W; + double L; + double H; +} ; + +struct TCommand +{ + AnsiString Command; + double Value1; + double Value2; + TLocation Location; +} ; + +struct TTrackShape +{ + double R; + double Len; + double dHtrack; + double dHrail; +} ; + +struct TTrackParam +{ + double Width; + double friction; + Byte CategoryFlag; + Byte QualityFlag; + Byte DamageFlag; + double Velmax; +} ; + +struct TTractionParam +{ + double TractionVoltage; + double TractionFreq; + double TractionMaxCurrent; + double TractionResistivity; +} ; + +#pragma option push -b- +enum TBrakeSystem { Individual, Pneumatic, ElectroPneumatic }; +#pragma option pop + +#pragma option push -b- +enum TBrakeSubSystem { ss_None, ss_W, ss_K, ss_KK, ss_Hik, ss_ESt, ss_KE, ss_LSt, ss_MT, ss_Dako }; +#pragma option pop + +#pragma option push -b- +enum TBrakeValve { NoValve, W, W_Lu_VI, W_Lu_L, W_Lu_XR, K, Kg, Kp, Kss, Kkg, Kkp, Kks, Hikg1, Hikss, + Hikp1, KE, SW, EStED, NESt3, ESt3, LSt, ESt4, ESt3AL2, EP1, EP2, M483, CV1_L_TR, CV1, CV1_R, Other + }; +#pragma option pop + +#pragma option push -b- +enum TBrakeHandle { NoHandle, West, FV4a, M394, M254, FVel1, FVel6, D2, Knorr, FD1, BS2, testH, St113 + }; +#pragma option pop + +#pragma option push -b- +enum TLocalBrake { NoBrake, ManualBrake, PneumaticBrake, HydraulicBrake }; +#pragma option pop + +typedef double TBrakeDelayTable[4]; + +struct TBrakePressure +{ + double PipePressureVal; + double BrakePressureVal; + double FlowSpeedVal; + TBrakeSystem BrakeType; +} ; + +typedef TBrakePressure TBrakePressureTable[13]; + +#pragma option push -b- +enum TEngineTypes { None, Dumb, WheelsDriven, ElectricSeriesMotor, ElectricInductionMotor, DieselEngine, + SteamEngine, DieselElectric }; +#pragma option pop + +#pragma option push -b- +enum TPowerType { NoPower, BioPower, MechPower, ElectricPower, SteamPower }; +#pragma option pop + +#pragma option push -b- +enum TFuelType { Undefined, Coal, Oil }; +#pragma option pop + +struct TGrateType +{ + TFuelType FuelType; + double GrateSurface; + double FuelTransportSpeed; + double IgnitionTemperature; + double MaxTemperature; +} ; + +struct TBoilerType +{ + double BoilerVolume; + double BoilerHeatSurface; + double SuperHeaterSurface; + double MaxWaterVolume; + double MinWaterVolume; + double MaxPressure; +} ; + +struct TCurrentCollector +{ + int CollectorsNo; + double MinH; + double MaxH; + double CSW; + double MinV; + double MaxV; + double InsetV; + double MinPress; + double MaxPress; +} ; + +#pragma option push -b- +enum TPowerSource { NotDefined, InternalSource, Transducer, Generator, Accumulator, CurrentCollector, + PowerCable, Heater }; +#pragma option pop + +struct _mover__1 +{ + double MaxCapacity; + TPowerSource RechargeSource; +} ; + +struct _mover__2 +{ + TPowerType PowerTrans; + double SteamPressure; +} ; + +struct _mover__3 +{ + TGrateType Grate; + TBoilerType Boiler; +} ; + +struct TPowerParameters +{ + double MaxVoltage; + double MaxCurrent; + double IntR; + TPowerSource SourceType; + union + { + struct + { + _mover__3 RHeater; + + }; + struct + { + _mover__2 RPowerCable; + + }; + struct + { + TCurrentCollector CollectorParameters; + + }; + struct + { + _mover__1 RAccumulator; + + }; + struct + { + TEngineTypes GeneratorEngine; + + }; + struct + { + double InputVoltage; + + }; + struct + { + TPowerType PowerType; + + }; + + }; +} ; + +struct TScheme +{ + Byte Relay; + double R; + Byte Bn; + Byte Mn; + bool AutoSwitch; + Byte ScndAct; +} ; + +typedef TScheme TSchemeTable[65]; + +struct TDEScheme +{ + double RPM; + double GenPower; + double Umax; + double Imax; +} ; + +typedef TDEScheme TDESchemeTable[33]; + +struct TShuntScheme +{ + double Umin; + double Umax; + double Pmin; + double Pmax; +} ; + +typedef TShuntScheme TShuntSchemeTable[33]; + +struct TMPTRelay +{ + double Iup; + double Idown; +} ; + +typedef TMPTRelay TMPTRelayTable[8]; + +struct TMotorParameters +{ + double mfi; + double mIsat; + double mfi0; + double fi; + double Isat; + double fi0; + bool AutoSwitch; +} ; + +struct TSecuritySystem +{ + Byte SystemType; + double AwareDelay; + double AwareMinSpeed; + double SoundSignalDelay; + double EmergencyBrakeDelay; + Byte Status; + double SystemTimer; + double SystemSoundCATimer; + double SystemSoundSHPTimer; + double SystemBrakeCATimer; + double SystemBrakeSHPTimer; + double SystemBrakeCATestTimer; + int VelocityAllowed; + int NextVelocityAllowed; + bool RadioStop; +} ; + +struct TTransmision +{ + Byte NToothM; + Byte NToothW; + double Ratio; +} ; + +#pragma option push -b- +enum TCouplerType { NoCoupler, Articulated, Bare, Chain, Screw, Automatic }; +#pragma option pop + +class DELPHICLASS T_MoverParameters; +struct TCoupling +{ + double SpringKB; + double SpringKC; + double beta; + double DmaxB; + double FmaxB; + double DmaxC; + double FmaxC; + TCouplerType CouplerType; + Byte CouplingFlag; + int AllowedFlag; + bool Render; + double CoupleDist; + T_MoverParameters* Connected; + Byte ConnectedNr; + double CForce; + double Dist; + bool CheckCollision; +} ; + +class PASCALIMPLEMENTATION T_MoverParameters : public System::TObject +{ + typedef System::TObject inherited; + +public: + double dMoveLen; + AnsiString filename; + Byte CategoryFlag; + AnsiString TypeName; + int TrainType; + TEngineTypes EngineType; + TPowerParameters EnginePowerSource; + TPowerParameters SystemPowerSource; + TPowerParameters HeatingPowerSource; + TPowerParameters AlterHeatPowerSource; + TPowerParameters LightPowerSource; + TPowerParameters AlterLightPowerSource; + double Vmax; + double Mass; + double Power; + double Mred; + double TotalMass; + double HeatingPower; + double LightPower; + double BatteryVoltage; + bool Battery; + bool EpFuse; + bool Signalling; + bool DoorSignalling; + bool Radio; + double NominalBatteryVoltage; + TDimension Dim; + double Cx; + double Floor; + double WheelDiameter; + double WheelDiameterL; + double WheelDiameterT; + double TrackW; + double AxleInertialMoment; + AnsiString AxleArangement; + Byte NPoweredAxles; + Byte NAxles; + Byte BearingType; + double ADist; + double BDist; + Byte NBpA; + int SandCapacity; + TBrakeSystem BrakeSystem; + TBrakeSubSystem BrakeSubsystem; + TBrakeValve BrakeValve; + TBrakeHandle BrakeHandle; + TBrakeHandle BrakeLocHandle; + double MBPM; + Hamulce::TBrake* Hamulec; + Hamulce::THandle* Handle; + Hamulce::THandle* LocHandle; + Hamulce::TReservoir* Pipe; + Hamulce::TReservoir* Pipe2; + TLocalBrake LocalBrake; + TBrakePressure BrakePressureTable[13]; + TBrakePressure BrakePressureActual; + Byte ASBType; + Byte TurboTest; + double MaxBrakeForce; + double MaxBrakePress[5]; + double P2FTrans; + double TrackBrakeForce; + Byte BrakeMethod; + double HighPipePress; + double LowPipePress; + double DeltaPipePress; + double CntrlPipePress; + double BrakeVolume; + double BrakeVVolume; + double VeselVolume; + int BrakeCylNo; + double BrakeCylRadius; + double BrakeCylDist; + double BrakeCylMult[3]; + Byte LoadFlag; + double BrakeCylSpring; + double BrakeSlckAdj; + double BrakeRigEff; + double RapidMult; + int BrakeValveSize; + AnsiString BrakeValveParams; + double Spg; + double MinCompressor; + double MaxCompressor; + double CompressorSpeed; + double BrakeDelay[4]; + Byte BrakeCtrlPosNo; + Byte MainCtrlPosNo; + Byte ScndCtrlPosNo; + bool ScndInMain; + bool MBrake; + TSecuritySystem SecuritySystem; + TScheme RList[65]; + int RlistSize; + TMotorParameters MotorParam[11]; + TTransmision Transmision; + double NominalVoltage; + double WindingRes; + double u; + double CircuitRes; + int IminLo; + int IminHi; + int ImaxLo; + int ImaxHi; + double nmax; + double InitialCtrlDelay; + double CtrlDelay; + double CtrlDownDelay; + Byte FastSerialCircuit; + Byte AutoRelayType; + bool CoupledCtrl; + bool IsCoupled; + Byte DynamicBrakeType; + Byte RVentType; + double RVentnmax; + double RVentCutOff; + int CompressorPower; + int SmallCompressorPower; + double dizel_Mmax; + double dizel_nMmax; + double dizel_Mnmax; + double dizel_nmax; + double dizel_nominalfill; + double dizel_Mstand; + double dizel_nmax_cutoff; + double dizel_nmin; + double dizel_minVelfullengage; + double dizel_AIM; + double dizel_engageDia; + double dizel_engageMaxForce; + double dizel_engagefriction; + double AnPos; + bool AnalogCtrl; + bool AnMainCtrl; + bool ShuntModeAllow; + bool ShuntMode; + bool Flat; + double Vhyp; + TDEScheme DElist[33]; + double Vadd; + TMPTRelay MPTRelay[8]; + Byte RelayType; + TShuntScheme SST[33]; + double PowerCorRatio; + double Ftmax; + double eimc[21]; + int MaxLoad; + AnsiString LoadAccepted; + AnsiString LoadQuantity; + double OverLoadFactor; + double LoadSpeed; + double UnLoadSpeed; + Byte DoorOpenCtrl; + Byte DoorCloseCtrl; + double DoorStayOpen; + bool DoorClosureWarning; + double DoorOpenSpeed; + double DoorCloseSpeed; + double DoorMaxShiftL; + double DoorMaxShiftR; + Byte DoorOpenMethod; + bool ScndS; + TLocation Loc; + TRotation Rot; + AnsiString Name; + TCoupling Couplers[2]; + double HVCouplers[2][2]; + int ScanCounter; + bool EventFlag; + Byte SoundFlag; + double DistCounter; + double V; + double Vel; + double AccS; + double AccN; + double AccV; + double nrot; + double EnginePower; + double dL; + double Fb; + double Ff; + double FTrain; + double FStand; + double FTotal; + double UnitBrakeForce; + double Ntotal; + bool SlippingWheels; + bool SandDose; + double Sand; + double BrakeSlippingTimer; + double dpBrake; + double dpPipe; + double dpMainValve; + double dpLocalValve; + double ScndPipePress; + double BrakePress; + double LocBrakePress; + double PipeBrakePress; + double PipePress; + double EqvtPipePress; + double Volume; + double CompressedVolume; + double PantVolume; + double Compressor; + bool CompressorFlag; + bool PantCompFlag; + bool CompressorAllow; + bool ConverterFlag; + bool ConverterAllow; + int BrakeCtrlPos; + double BrakeCtrlPosR; + double BrakeCtrlPos2; + Byte LocalBrakePos; + Byte ManualBrakePos; + double LocalBrakePosA; + Byte BrakeStatus; + bool EmergencyBrakeFlag; + Byte BrakeDelayFlag; + Byte BrakeDelays; + bool DynamicBrakeFlag; + double LimPipePress; + double ActFlowSpeed; + Byte DamageFlag; + Byte DerailReason; + TCommand CommandIn; + AnsiString CommandOut; + AnsiString CommandLast; + double ValueOut; + TTrackShape RunningShape; + TTrackParam RunningTrack; + double OffsetTrackH; + double OffsetTrackV; + bool Mains; + Byte MainCtrlPos; + Byte ScndCtrlPos; + int ActiveDir; + int CabNo; + int DirAbsolute; + int ActiveCab; + double LastSwitchingTime; + bool DepartureSignal; + bool InsideConsist; + TTractionParam RunningTraction; + double enrot; + double Im; + double Itot; + double IHeating; + double ITraction; + double TotalCurrent; + double Mm; + double Mw; + double Fw; + double Ft; + int Imin; + int Imax; + double Voltage; + Byte MainCtrlActualPos; + Byte ScndCtrlActualPos; + bool DelayCtrlFlag; + double LastRelayTime; + bool AutoRelayFlag; + bool FuseFlag; + bool ConvOvldFlag; + bool StLinFlag; + bool ResistorsFlag; + double RventRot; + bool UnBrake; + double PantPress; + bool s_CAtestebrake; + double dizel_fill; + double dizel_engagestate; + double dizel_engage; + double dizel_automaticgearstatus; + bool dizel_enginestart; + double dizel_engagedeltaomega; + double eimv[21]; + double PulseForce; + double PulseForceTimer; + int PulseForceCount; + double eAngle; + int Load; + AnsiString LoadType; + Byte LoadStatus; + double LastLoadChangeTime; + bool DoorBlocked; + bool DoorLeftOpened; + bool DoorRightOpened; + bool PantFrontUp; + bool PantRearUp; + bool PantFrontSP; + bool PantRearSP; + int PantFrontStart; + int PantRearStart; + double PantFrontVolt; + double PantRearVolt; + AnsiString PantSwitchType; + AnsiString ConvSwitchType; + bool Heating; + int DoubleTr; + bool PhysicActivation; + double FrictConst1; + double FrictConst2s; + double FrictConst2d; + double TotalMassxg; + double __fastcall GetTrainsetVoltage(void); + bool __fastcall Physic_ReActivation(void); + double __fastcall LocalBrakeRatio(void); + double __fastcall ManualBrakeRatio(void); + double __fastcall PipeRatio(void); + double __fastcall RealPipeRatio(void); + double __fastcall BrakeVP(void); + bool __fastcall DynamicBrakeSwitch(bool Switch); + bool __fastcall SendCtrlBroadcast(AnsiString CtrlCommand, double ctrlvalue); + bool __fastcall SendCtrlToNext(AnsiString CtrlCommand, double ctrlvalue, double dir); + bool __fastcall CabActivisation(void); + bool __fastcall CabDeactivisation(void); + bool __fastcall IncMainCtrl(int CtrlSpeed); + bool __fastcall DecMainCtrl(int CtrlSpeed); + bool __fastcall IncScndCtrl(int CtrlSpeed); + bool __fastcall DecScndCtrl(int CtrlSpeed); + bool __fastcall AddPulseForce(int Multipler); + bool __fastcall SandDoseOn(void); + bool __fastcall SecuritySystemReset(void); + void __fastcall SecuritySystemCheck(double dt); + bool __fastcall BatterySwitch(bool State); + bool __fastcall EpFuseSwitch(bool State); + bool __fastcall IncBrakeLevelOld(void); + bool __fastcall DecBrakeLevelOld(void); + bool __fastcall IncLocalBrakeLevel(Byte CtrlSpeed); + bool __fastcall DecLocalBrakeLevel(Byte CtrlSpeed); + bool __fastcall IncLocalBrakeLevelFAST(void); + bool __fastcall DecLocalBrakeLevelFAST(void); + bool __fastcall IncManualBrakeLevel(Byte CtrlSpeed); + bool __fastcall DecManualBrakeLevel(Byte CtrlSpeed); + bool __fastcall EmergencyBrakeSwitch(bool Switch); + bool __fastcall AntiSlippingBrake(void); + bool __fastcall BrakeReleaser(Byte state); + bool __fastcall SwitchEPBrake(Byte state); + bool __fastcall AntiSlippingButton(void); + bool __fastcall IncBrakePress(double &brake, double PressLimit, double dp); + bool __fastcall DecBrakePress(double &brake, double PressLimit, double dp); + bool __fastcall BrakeDelaySwitch(Byte BDS); + bool __fastcall IncBrakeMult(void); + bool __fastcall DecBrakeMult(void); + void __fastcall UpdateBrakePressure(double dt); + void __fastcall UpdatePipePressure(double dt); + void __fastcall CompressorCheck(double dt); + //void __fastcall UpdatePantVolume(double dt); + void __fastcall UpdateScndPipePressure(double dt); + void __fastcall UpdateBatteryVoltage(double dt); + double __fastcall GetDVc(double dt); + void __fastcall ComputeConstans(void); + double __fastcall ComputeMass(void); + double __fastcall Adhesive(double staticfriction); + double __fastcall TractionForce(double dt); + double __fastcall FrictionForce(double R, Byte TDamage); + double __fastcall BrakeForce(const TTrackParam &Track); + double __fastcall CouplerForce(Byte CouplerN, double dt); + void __fastcall CollisionDetect(Byte CouplerN, double dt); + double __fastcall ComputeRotatingWheel(double WForce, double dt, double n); + bool __fastcall SetInternalCommand(AnsiString NewCommand, double NewValue1, double NewValue2); + double __fastcall GetExternalCommand(AnsiString &Command); + bool __fastcall RunCommand(AnsiString command, double CValue1, double CValue2); + bool __fastcall RunInternalCommand(void); + void __fastcall PutCommand(AnsiString NewCommand, double NewValue1, double NewValue2, const TLocation + &NewLocation); + bool __fastcall DirectionBackward(void); + bool __fastcall MainSwitch(bool State); + bool __fastcall ConverterSwitch(bool State); + bool __fastcall CompressorSwitch(bool State); + bool __fastcall FuseOn(void); + bool __fastcall FuseFlagCheck(void); + void __fastcall FuseOff(void); + int __fastcall ShowCurrent(Byte AmpN); + double __fastcall v2n(void); + double __fastcall current(double n, double U); + double __fastcall Momentum(double I); + double __fastcall MomentumF(double I, double Iw, Byte SCP); + bool __fastcall CutOffEngine(void); + bool __fastcall MaxCurrentSwitch(bool State); + bool __fastcall ResistorsFlagCheck(void); + bool __fastcall MinCurrentSwitch(bool State); + bool __fastcall AutoRelaySwitch(bool State); + bool __fastcall AutoRelayCheck(void); + bool __fastcall dizel_EngageSwitch(double state); + bool __fastcall dizel_EngageChange(double dt); + bool __fastcall dizel_AutoGearCheck(void); + double __fastcall dizel_fillcheck(Byte mcp); + double __fastcall dizel_Momentum(double dizel_fill, double n, double dt); + bool __fastcall dizel_Update(double dt); + bool __fastcall LoadingDone(double LSpeed, AnsiString LoadInit); + void __fastcall ComputeTotalForce(double dt, double dt1, bool FullVer); + double __fastcall ComputeMovement(double dt, double dt1, const TTrackShape &Shape, TTrackParam &Track + , TTractionParam &ElectricTraction, const TLocation &NewLoc, TRotation &NewRot); + double __fastcall FastComputeMovement(double dt, const TTrackShape &Shape, TTrackParam &Track, const + TLocation &NewLoc, TRotation &NewRot); + bool __fastcall ChangeOffsetH(double DeltaOffset); + __fastcall T_MoverParameters(double VelInitial, AnsiString TypeNameInit, AnsiString NameInit, int LoadInitial + , AnsiString LoadTypeInitial, int Cab); + bool __fastcall LoadChkFile(AnsiString chkpath); + bool __fastcall CheckLocomotiveParameters(bool ReadyFlag, int Dir); + AnsiString __fastcall EngineDescription(int what); + bool __fastcall DoorLeft(bool State); + bool __fastcall DoorRight(bool State); + bool __fastcall DoorBlockedFlag(void); + bool __fastcall PantFront(bool State); + bool __fastcall PantRear(bool State); +public: + #pragma option push -w-inl + /* TObject.Create */ inline __fastcall T_MoverParameters(void) : System::TObject() { } + #pragma option pop + #pragma option push -w-inl + /* TObject.Destroy */ inline __fastcall virtual ~T_MoverParameters(void) { } + #pragma option pop + +}; + + +//-- var, const, procedure --------------------------------------------------- +static const bool Go = true; +static const bool Hold = false; +static const Shortint ResArraySize = 0x40; +static const Shortint MotorParametersArraySize = 0xa; +static const Shortint maxcc = 0x4; +static const Shortint LocalBrakePosNo = 0xa; +static const Shortint MainBrakeMaxPos = 0xa; +static const Shortint ManualBrakePosNo = 0x14; +static const Shortint dtrack_railwear = 0x2; +static const Shortint dtrack_freerail = 0x4; +static const Shortint dtrack_thinrail = 0x8; +static const Shortint dtrack_railbend = 0x10; +static const Shortint dtrack_plants = 0x20; +static const Shortint dtrack_nomove = 0x40; +static const Byte dtrack_norail = 0x80; +static const Shortint dtrain_thinwheel = 0x1; +static const Shortint dtrain_loadshift = 0x1; +static const Shortint dtrain_wheelwear = 0x2; +static const Shortint dtrain_bearing = 0x4; +static const Shortint dtrain_coupling = 0x8; +static const Shortint dtrain_ventilator = 0x10; +static const Shortint dtrain_loaddamage = 0x10; +static const Shortint dtrain_engine = 0x20; +static const Shortint dtrain_loaddestroyed = 0x20; +static const Shortint dtrain_axle = 0x40; +static const Byte dtrain_out = 0x80; +#define p_elengproblem (1.000000E-02) +#define p_elengdamage (1.000000E-01) +#define p_coupldmg (2.000000E-02) +#define p_derail (1.000000E-03) +#define p_accn (1.000000E-01) +#define p_slippdmg (1.000000E-03) +static const Shortint ctrain_virtual = 0x0; +static const Shortint ctrain_coupler = 0x1; +static const Shortint ctrain_pneumatic = 0x2; +static const Shortint ctrain_controll = 0x4; +static const Shortint ctrain_power = 0x8; +static const Shortint ctrain_passenger = 0x10; +static const Shortint ctrain_scndpneumatic = 0x20; +static const Shortint ctrain_heating = 0x40; +static const Byte ctrain_depot = 0x80; +static const Shortint dbrake_none = 0x0; +static const Shortint dbrake_passive = 0x1; +static const Shortint dbrake_switch = 0x2; +static const Shortint dbrake_reversal = 0x4; +static const Shortint dbrake_automatic = 0x8; +static const Shortint s_waiting = 0x1; +static const Shortint s_aware = 0x2; +static const Shortint s_active = 0x4; +static const Shortint s_CAalarm = 0x8; +static const Shortint s_SHPalarm = 0x10; +static const Shortint s_CAebrake = 0x20; +static const Shortint s_SHPebrake = 0x40; +static const Byte s_CAtest = 0x80; +static const Shortint sound_none = 0x0; +static const Shortint sound_loud = 0x1; +static const Shortint sound_couplerstretch = 0x2; +static const Shortint sound_bufferclamp = 0x4; +static const Shortint sound_bufferbump = 0x8; +static const Shortint sound_relay = 0x10; +static const Shortint sound_manyrelay = 0x20; +static const Shortint sound_brakeacc = 0x40; +extern PACKAGE bool PhysicActivationFlag; +static const Shortint dt_Default = 0x0; +static const Shortint dt_EZT = 0x1; +static const Shortint dt_ET41 = 0x2; +static const Shortint dt_ET42 = 0x4; +static const Shortint dt_PseudoDiesel = 0x8; +static const Shortint dt_ET22 = 0x10; +static const Shortint dt_SN61 = 0x20; +static const Shortint dt_EP05 = 0x40; +static const Byte dt_ET40 = 0x80; +static const Word dt_181 = 0x100; +static const Shortint eimc_s_dfic = 0x0; +static const Shortint eimc_s_dfmax = 0x1; +static const Shortint eimc_s_p = 0x2; +static const Shortint eimc_s_cfu = 0x3; +static const Shortint eimc_s_cim = 0x4; +static const Shortint eimc_s_icif = 0x5; +static const Shortint eimc_f_Uzmax = 0x7; +static const Shortint eimc_f_uzh = 0x8; +static const Shortint eimc_f_DU = 0x9; +static const Shortint eimc_f_I0 = 0xa; +static const Shortint eimc_f_cfu = 0xb; +static const Shortint eimc_p_F0 = 0xd; +static const Shortint eimc_p_a1 = 0xe; +static const Shortint eimc_p_Pmax = 0xf; +static const Shortint eimc_p_Fh = 0x10; +static const Shortint eimc_p_Ph = 0x11; +static const Shortint eimc_p_Vh0 = 0x12; +static const Shortint eimc_p_Vh1 = 0x13; +static const Shortint eimc_p_Imax = 0x14; +static const Shortint eimv_FMAXMAX = 0x0; +static const Shortint eimv_Fmax = 0x1; +static const Shortint eimv_ks = 0x2; +static const Shortint eimv_df = 0x3; +static const Shortint eimv_fp = 0x4; +static const Shortint eimv_U = 0x5; +static const Shortint eimv_pole = 0x6; +static const Shortint eimv_Ic = 0x7; +static const Shortint eimv_If = 0x8; +static const Shortint eimv_M = 0x9; +static const Shortint eimv_Fr = 0xa; +static const Shortint eimv_Ipoj = 0xb; +static const Shortint eimv_Pm = 0xc; +static const Shortint eimv_Pe = 0xd; +static const Shortint eimv_eta = 0xe; +static const Shortint eimv_fkr = 0xf; +static const Shortint eimv_Uzsmax = 0x10; +static const Shortint eimv_Pmax = 0x11; +static const Shortint eimv_Fzad = 0x12; +static const Shortint eimv_Imax = 0x13; +extern PACKAGE double __fastcall Distance(const TLocation &Loc1, const TLocation &Loc2, const TDimension + &Dim1, const TDimension &Dim2); + +} /* namespace _mover */ +#if !defined(NO_IMPLICIT_NAMESPACE_USE) +using namespace _mover; +#endif +#pragma option pop // -w- +#pragma option pop // -Vx + +#pragma delphiheader end. +//-- end unit ---------------------------------------------------------------- +#endif // _mover diff --git a/McZapkie/Oerlikon_ESt.hpp b/McZapkie/Oerlikon_ESt.hpp new file mode 100644 index 00000000..8877031f --- /dev/null +++ b/McZapkie/Oerlikon_ESt.hpp @@ -0,0 +1,293 @@ +// Borland C++ Builder +// Copyright (c) 1995, 1999 by Borland International +// All rights reserved + +// (DO NOT EDIT: machine generated header) 'Oerlikon_ESt.pas' rev: 5.00 + +#ifndef Oerlikon_EStHPP +#define Oerlikon_EStHPP + +#pragma delphiheader begin +#pragma option push -w- +#pragma option push -Vx +#include // Pascal unit +#include // Pascal unit +#include // Pascal unit +#include // Pascal unit +#include // Pascal unit +#include // Pascal unit + +//-- user supplied ----------------------------------------------------------- + +namespace Oerlikon_est +{ +//-- type declarations ------------------------------------------------------- +class DELPHICLASS TPrzekladnik; +class PASCALIMPLEMENTATION TPrzekladnik : public Hamulce::TReservoir +{ + typedef Hamulce::TReservoir inherited; + +public: + Hamulce::TReservoir* *BrakeRes; + Hamulce::TReservoir* *Next; + virtual void __fastcall Update(double dt); +public: + #pragma option push -w-inl + /* TReservoir.Create */ inline __fastcall TPrzekladnik(void) : Hamulce::TReservoir() { } + #pragma option pop + +public: + #pragma option push -w-inl + /* TObject.Destroy */ inline __fastcall virtual ~TPrzekladnik(void) { } + #pragma option pop + +}; + + +class DELPHICLASS TRura; +class PASCALIMPLEMENTATION TRura : public TPrzekladnik +{ + typedef TPrzekladnik inherited; + +public: + virtual double __fastcall P(void); + virtual void __fastcall Update(double dt); +public: + #pragma option push -w-inl + /* TReservoir.Create */ inline __fastcall TRura(void) : TPrzekladnik() { } + #pragma option pop + +public: + #pragma option push -w-inl + /* TObject.Destroy */ inline __fastcall virtual ~TRura(void) { } + #pragma option pop + +}; + + +class DELPHICLASS TPrzeciwposlizg; +class PASCALIMPLEMENTATION TPrzeciwposlizg : public TRura +{ + typedef TRura inherited; + +private: + bool Poslizg; + +public: + void __fastcall SetPoslizg(bool flag); + virtual void __fastcall Update(double dt); +public: + #pragma option push -w-inl + /* TReservoir.Create */ inline __fastcall TPrzeciwposlizg(void) : TRura() { } + #pragma option pop + +public: + #pragma option push -w-inl + /* TObject.Destroy */ inline __fastcall virtual ~TPrzeciwposlizg(void) { } + #pragma option pop + +}; + + +class DELPHICLASS TRapid; +class PASCALIMPLEMENTATION TRapid : public TPrzekladnik +{ + typedef TPrzekladnik inherited; + +private: + bool RapidStatus; + double RapidMult; + double DN; + double DL; + +public: + void __fastcall SetRapidParams(double mult, double size); + void __fastcall SetRapidStatus(bool rs); + virtual void __fastcall Update(double dt); +public: + #pragma option push -w-inl + /* TReservoir.Create */ inline __fastcall TRapid(void) : TPrzekladnik() { } + #pragma option pop + +public: + #pragma option push -w-inl + /* TObject.Destroy */ inline __fastcall virtual ~TRapid(void) { } + #pragma option pop + +}; + + +class DELPHICLASS TPrzekCiagly; +class PASCALIMPLEMENTATION TPrzekCiagly : public TPrzekladnik +{ + typedef TPrzekladnik inherited; + +private: + double Mult; + +public: + void __fastcall SetMult(double m); + virtual void __fastcall Update(double dt); +public: + #pragma option push -w-inl + /* TReservoir.Create */ inline __fastcall TPrzekCiagly(void) : TPrzekladnik() { } + #pragma option pop + +public: + #pragma option push -w-inl + /* TObject.Destroy */ inline __fastcall virtual ~TPrzekCiagly(void) { } + #pragma option pop + +}; + + +class DELPHICLASS TPrzek_PZZ; +class PASCALIMPLEMENTATION TPrzek_PZZ : public TPrzekladnik +{ + typedef TPrzekladnik inherited; + +private: + double LBP; + +public: + void __fastcall SetLBP(double P); + virtual void __fastcall Update(double dt); +public: + #pragma option push -w-inl + /* TReservoir.Create */ inline __fastcall TPrzek_PZZ(void) : TPrzekladnik() { } + #pragma option pop + +public: + #pragma option push -w-inl + /* TObject.Destroy */ inline __fastcall virtual ~TPrzek_PZZ(void) { } + #pragma option pop + +}; + + +class DELPHICLASS TPrzekZalamany; +class PASCALIMPLEMENTATION TPrzekZalamany : public TPrzekladnik +{ + typedef TPrzekladnik inherited; + +public: + #pragma option push -w-inl + /* TReservoir.Create */ inline __fastcall TPrzekZalamany(void) : TPrzekladnik() { } + #pragma option pop + +public: + #pragma option push -w-inl + /* TObject.Destroy */ inline __fastcall virtual ~TPrzekZalamany(void) { } + #pragma option pop + +}; + + +class DELPHICLASS TPrzekED; +class PASCALIMPLEMENTATION TPrzekED : public TRura +{ + typedef TRura inherited; + +private: + double MaxP; + +public: + void __fastcall SetP(double P); + virtual void __fastcall Update(double dt); +public: + #pragma option push -w-inl + /* TReservoir.Create */ inline __fastcall TPrzekED(void) : TRura() { } + #pragma option pop + +public: + #pragma option push -w-inl + /* TObject.Destroy */ inline __fastcall virtual ~TPrzekED(void) { } + #pragma option pop + +}; + + +class DELPHICLASS TNESt3; +class PASCALIMPLEMENTATION TNESt3 : public Hamulce::TBrake +{ + typedef Hamulce::TBrake inherited; + +private: + double Nozzles[11]; + Hamulce::TReservoir* CntrlRes; + double BVM; + bool Zamykajacy; + bool Przys_blok; + Hamulce::TReservoir* Miedzypoj; + TPrzekladnik* Przekladniki[3]; + bool RapidStatus; + bool RapidStaly; + double LoadC; + double TareM; + double LoadM; + double TareBP; + double HBG300; + double Podskok; + bool autom; + double LBP; + +public: + virtual double __fastcall GetPF(double PP, double dt, double Vel); + void __fastcall EStParams(double i_crc); + virtual void __fastcall Init(double PP, double HPP, double LPP, double BP, Byte BDF); + virtual double __fastcall GetCRP(void); + void __fastcall CheckState(double BCP, double &dV1); + void __fastcall CheckReleaser(double dt); + double __fastcall CVs(double bp); + double __fastcall BVs(double BCP); + void __fastcall SetSize(int size, AnsiString params); + void __fastcall PLC(double mass); + void __fastcall SetLP(double TM, double LM, double TBP); + virtual void __fastcall ForceEmptiness(void); + void __fastcall SetLBP(double P); +public: + #pragma option push -w-inl + /* TBrake.Create */ inline __fastcall TNESt3(double i_mbp, double i_bcr, double i_bcd, double i_brc + , Byte i_bcn, Byte i_BD, Byte i_mat, Byte i_ba, Byte i_nbpa) : Hamulce::TBrake(i_mbp, i_bcr, i_bcd + , i_brc, i_bcn, i_BD, i_mat, i_ba, i_nbpa) { } + #pragma option pop + +public: + #pragma option push -w-inl + /* TObject.Destroy */ inline __fastcall virtual ~TNESt3(void) { } + #pragma option pop + +}; + + +//-- var, const, procedure --------------------------------------------------- +static const Shortint dMAX = 0xa; +static const Shortint dON = 0x0; +static const Shortint dOO = 0x1; +static const Shortint dTN = 0x2; +static const Shortint dTO = 0x3; +static const Shortint dP = 0x4; +static const Shortint dSd = 0x5; +static const Shortint dSm = 0x6; +static const Shortint dPd = 0x7; +static const Shortint dPm = 0x8; +static const Shortint dPO = 0x9; +static const Shortint dPT = 0xa; +static const Shortint p_none = 0x0; +static const Shortint p_rapid = 0x1; +static const Shortint p_pp = 0x2; +static const Shortint p_al2 = 0x3; +static const Shortint p_ppz = 0x4; +static const Shortint P_ed = 0x5; +extern PACKAGE double __fastcall d2A(double d); + +} /* namespace Oerlikon_est */ +#if !defined(NO_IMPLICIT_NAMESPACE_USE) +using namespace Oerlikon_est; +#endif +#pragma option pop // -w- +#pragma option pop // -Vx + +#pragma delphiheader end. +//-- end unit ---------------------------------------------------------------- +#endif // Oerlikon_ESt diff --git a/McZapkie/Oerlikon_ESt.pas b/McZapkie/Oerlikon_ESt.pas new file mode 100644 index 00000000..5c5a8fa9 --- /dev/null +++ b/McZapkie/Oerlikon_ESt.pas @@ -0,0 +1,797 @@ +unit Oerlikon_ESt; {fizyka hamulcow Oerlikon ESt dla symulatora} + +(* + MaSzyna EU07 - SPKS + Brakes. Oerlikon ESt. + Copyright (C) 2007-2014 Maciej Cierniak +*) + + +(* +(C) youBy +Co jest: +- glowny przyrzad rozrzadczy +- napelniacz zbiornika pomocniczego +- napelniacz zbiornika sterujacego +- zawor podskoku +- nibyprzyspieszacz +- tylko 16",14",12",10" +- nieprzekladnik rura +- przekladnik 1:1 +- przekladniki AL2 +- przeciwposlizgi +- rapid REL2 +- HGB300 +- inne srednice +Co brakuje: +- dobry przyspieszacz +- mozliwosc zasilania z wysokiego cisnienia ESt4 +- ep: EP1 i EP2 +- samoczynne ep +- PZZ dla dodatkowego +*) + +interface + +uses mctools,sysutils,friction,hamulce;//,klasy_ham; + +CONST + dMAX=10; //dysze + dON = 0; //osobowy napelnianie (+ZP) + dOO = 1; //osobowy oproznianie + dTN = 2; //towarowy napelnianie (+ZP) + dTO = 3; //towarowy oproznianie + dP = 4; //zbiornik pomocniczy + dSd = 5; //zbiornik sterujacy + dSm = 6; //zbiornik sterujacy + dPd = 7; //duzy przelot zamykajcego + dPm = 8; //maly przelot zamykajacego + dPO = 9; //zasilanie pomocniczego O + dPT =10; //zasilanie pomocniczego T + +//przekladniki + p_none = 0; + p_rapid = 1; + p_pp = 2; + p_al2 = 3; + p_ppz = 4; + P_ed = 5; + + + +TYPE + TPrzekladnik= class(TReservoir) //przekladnik (powtarzacz) + private + public + BrakeRes: PReservoir; + Next: PReservoir; + procedure Update(dt:real); virtual; + end; + + TRura= class(TPrzekladnik) //nieprzekladnik, rura laczaca + private + public + function P: real; override; + procedure Update(dt:real); override; + end; + + TPrzeciwposlizg= class(TRura) //przy napelnianiu - rura, przy poslizgu - upust + private + Poslizg: boolean; + public + procedure SetPoslizg(flag: boolean); + procedure Update(dt:real); override; + end; + + TRapid= class(TPrzekladnik) //przekladnik dwustopniowy + private + RapidStatus: boolean; //status rapidu + RapidMult: real; //przelozenie (w dol) +// Komora2: real; + DN,DL: real; //srednice dysz napelniania i luzowania + public + procedure SetRapidParams(mult: real; size: real); + procedure SetRapidStatus(rs: boolean); + procedure Update(dt:real); override; + end; + + TPrzekCiagly= class(TPrzekladnik) //AL2 + private + Mult: real; + public + procedure SetMult(m: real); + procedure Update(dt:real); override; + end; + + TPrzek_PZZ= class(TPrzekladnik) //podwojny zawor zwrotny + private + LBP: real; + public + procedure SetLBP(P: real); + procedure Update(dt:real); override; + end; + + TPrzekZalamany= class(TPrzekladnik) //Knicksventil + private + public + end; + + TPrzekED= class(TRura) //przy napelnianiu - rura, przy hamowaniu - upust + private + MaxP: real; + public + procedure SetP(P: real); + procedure Update(dt:real); override; + end; + + TNESt3= class(TBrake) + private + Nozzles: array[0..dMAX] of real; //dysze + CntrlRes: TReservoir; //zbiornik sterujący + BVM: real; //przelozenie PG-CH +// ValveFlag: byte; //polozenie roznych zaworkow + Zamykajacy: boolean; //pamiec zaworka zamykajacego +// Przys_wlot: boolean; //wlot do komory przyspieszacza + Przys_blok: boolean; //blokada przyspieszacza + Miedzypoj: TReservoir; //pojemnosc posrednia (urojona) do napelniania ZP i ZS + Przekladniki: array[1..3] of TPrzekladnik; + RapidStatus: boolean; + RapidStaly: boolean; + LoadC: real; + TareM, LoadM: real; //masa proznego i pelnego + TareBP: real; //cisnienie dla proznego + HBG300: real; //zawor ograniczajacy cisnienie + Podskok: real; //podskok preznosci poczatkowej +// HPBR: real; //zasilanie ZP z wysokiego cisnienia + autom: boolean; //odluzniacz samoczynny + LBP: real; //cisnienie hamulca pomocniczego + public + function GetPF(PP, dt, Vel: real): real; override; //przeplyw miedzy komora wstepna i PG + procedure EStParams(i_crc: real); //parametry charakterystyczne dla ESt + procedure Init(PP, HPP, LPP, BP: real; BDF: byte); override; + function GetCRP: real; override; + procedure CheckState(BCP: real; var dV1: real); //glowny przyrzad rozrzadczy + procedure CheckReleaser(dt: real); //odluzniacz + function CVs(bp: real): real; //napelniacz sterujacego + function BVs(BCP: real): real; //napelniacz pomocniczego + procedure SetSize(size: integer; params: string); //ustawianie dysz (rozmiaru ZR), przekladniki + procedure PLC(mass: real); //wspolczynnik cisnienia przystawki wazacej + procedure SetLP(TM, LM, TBP: real); //parametry przystawki wazacej + procedure ForceEmptiness(); override; //wymuszenie bycia pustym + procedure SetLBP(P: real); //cisnienie z hamulca pomocniczego + end; + +function d2A(d: real):real; + +implementation + +function d2A(d: real):real; +begin + d2A:=(d*d)*0.7854/1000; +end; + +// ------ RURA ------ + +function TRura.P: real; +begin + P:=Next.P; +end; + +procedure TRura.Update(dt: real); +begin + Next.Flow(dVol); + dVol:=0; +end; + +// ------ PRZECIWPOSLIG ------ + +procedure TPrzeciwposlizg.SetPoslizg(flag: boolean); +begin + Poslizg:=flag; +end; + +procedure TPrzeciwposlizg.Update(dt: real); +begin + if (Poslizg) then + begin + BrakeRes.Flow(dVol); + Next.Flow(PF(Next.P,0,d2A(10))*dt); + end + else + Next.Flow(dVol); + dVol:=0; +end; + + +// ------ PRZEKLADNIK ------ + +procedure TPrzekladnik.Update(dt: real); +var BCP, BVP, dV: real; +begin + + BCP:=Next.P; + BVP:=BrakeRes.P; + + if(BCP>P)then + dV:=-PFVd(BCP,0,d2A(10),P)*dt + else + if(BCP0 then + BrakeRes.Flow(-dV); + +end; + +// ------ PRZEKLADNIK RAPID ------ + +procedure TRapid.SetRapidParams(mult: real; size: real); +begin + RapidMult:=mult; + RapidStatus:=false; + if (size>0.1) then //dopasowywanie srednicy przekladnika + begin + DN:=D2A(size*0.4); + DL:=D2A(size*0.4); + end + else + begin + DN:=D2A(5); + DL:=D2A(5); + end; +end; + +procedure TRapid.SetRapidStatus(rs: boolean); +begin + RapidStatus:=rs; +end; + +procedure TRapid.Update(dt: real); +var BCP, BVP, dV, ActMult: real; +begin + BVP:=BrakeRes.P; + BCP:=Next.P; + + if(RapidStatus)then + begin + ActMult:=RapidMult; + end + else + begin + ActMult:=1; + end; + + if(BCP*RapidMult>P*actMult)then + dV:=-PFVd(BCP,0,DL,P*actMult/RapidMult)*dt + else + if(BCP*RapidMult0 then + BrakeRes.Flow(-dV); + +end; + +// ------ PRZEKŁADNIK CIĄGŁY ------ + +procedure TPrzekCiagly.SetMult(m:real); +begin + Mult:=m; +end; + +procedure TPrzekCiagly.Update(dt: real); +var BCP, BVP, dV: real; +begin + BVP:=BrakeRes.P; + BCP:=Next.P; + + if(BCP>P*Mult)then + dV:=-PFVd(BCP,0,d2A(8),P*Mult)*dt + else + if(BCP0 then + BrakeRes.Flow(-dV); + +end; + +// ------ PRZEKŁADNIK CIĄGŁY ------ + +procedure TPrzek_PZZ.SetLBP(P:real); +begin + LBP:=P; +end; + +procedure TPrzek_PZZ.Update(dt: real); +var BCP, BVP, dV, Pgr: real; +begin + BVP:=BrakeRes.P; + BCP:=Next.P; + + Pgr:=Max0R(LBP,P); + + if(BCP>Pgr)then + dV:=-PFVd(BCP,0,d2A(8),Pgr)*dt + else + if(BCP0 then + BrakeRes.Flow(-dV); + +end; + +// ------ PRZECIWPOSLIG ------ + +procedure TPrzekED.SetP(P: real); +begin + MaxP:=P; +end; + +procedure TPrzekED.Update(dt: real); +begin + if Next.P>MaxP then + begin + BrakeRes.Flow(dVol); + Next.Flow(PFVd(Next.P,0,d2A(10)*dt,MaxP)); + end + else + Next.Flow(dVol); + dVol:=0; +end; + + +// ------ OERLIKON EST NA BOGATO ------ + +function TNESt3.GetPF(PP, dt, Vel: real): real; //przeplyw miedzy komora wstepna i PG +var dv, dv1, temp:real; + VVP, BVP, BCP, CVP, MPP, nastG: real; + i: byte; +begin + BVP:=BrakeRes.P; + VVP:=ValveRes.P; +// BCP:=BrakeCyl.P; + BCP:=Przekladniki[1].P; + CVP:=CntrlRes.P-0.0; + MPP:=Miedzypoj.P; + dV1:=0; + + nastG:=(BrakeDelayFlag and bdelay_G); + +//sprawdzanie stanu + CheckState(BCP, dV1); + CheckReleaser(dt); + +//luzowanie + if(BrakeStatus and b_hld)=b_off then + dV:=PF(0,BCP,Nozzles[dTO]*nastG+(1-nastG)*Nozzles[dOO])*dt*(0.1+4.9*Min0R(0.2,BCP-((CVP-0.05-VVP)*BVM+0.1))) + else dV:=0; +// BrakeCyl.Flow(-dV); + Przekladniki[1].Flow(-dV); + if((BrakeStatus and b_on)=b_on)and(Przekladniki[1].P*HBG30070) or ((RapidStatus) and (Abs(Vel)>50)) or (RapidStaly))); + (Przekladniki[i] as TRapid).SetRapidStatus(RapidStatus); + end + else + if (Przekladniki[i] is TPrzeciwposlizg) then + (Przekladniki[i] as TPrzeciwposlizg).SetPoslizg((BrakeStatus and b_asb)=b_asb) + else + if (Przekladniki[i] is TPrzekED) then + if (Vel<-15) then + (Przekladniki[i] as TPrzekED).SetP(0) + else (Przekladniki[i] as TPrzekED).SetP(MaxBP*3) + else + if (Przekladniki[i] is TPrzekCiagly) then + (Przekladniki[i] as TPrzekCiagly).SetMult(LoadC) + else + if (Przekladniki[i] is TPrzek_PZZ) then + (Przekladniki[i] as TPrzek_PZZ).SetLBP(LBP); + end; + + +//przeplyw testowy miedzypojemnosci + dV:=PF(MPP,VVP,BVs(BCP))+PF(MPP,CVP,CVs(BCP)); + if(MPP-0.05>BVP)then + dV:=dV+PF(MPP-0.05,BVP,Nozzles[dPT]*nastG+(1-nastG)*Nozzles[dPO]); + if MPP>VVP then dV:=dV+PF(MPP,VVP,d2A(5)); + Miedzypoj.Flow(dV*dt*0.15); + + +//przeplyw ZS <-> PG + temp:=CVs(BCP); + dV:=PF(CVP,MPP,temp)*dt; + CntrlRes.Flow(+dV); + ValveRes.Flow(-0.02*dV); + dV1:=dV1+0.98*dV; + +//przeplyw ZP <-> MPJ + if(MPP-0.05>BVP)then + dV:=PF(BVP,MPP-0.05,Nozzles[dPT]*nastG+(1-nastG)*Nozzles[dPO])*dt + else dV:=0; + BrakeRes.Flow(dV); + dV1:=dV1+dV*0.98; + ValveRes.Flow(-0.02*dV); +//przeplyw PG <-> rozdzielacz + dV:=PF(PP,VVP,0.005)*dt; //0.01 + ValveRes.Flow(-dV); + + + ValveRes.Act; + BrakeCyl.Act; + BrakeRes.Act; + CntrlRes.Act; + Miedzypoj.Act; + Przekladniki[1].Act; + Przekladniki[2].Act; + Przekladniki[3].Act; + GetPF:=dV-dV1; +end; + + +procedure TNESt3.EStParams(i_crc: real); //parametry charakterystyczne dla ESt +begin + +end; + + +procedure TNESt3.Init(PP, HPP, LPP, BP: real; BDF: byte); +begin + ValveRes.CreatePress(1*PP); + BrakeCyl.CreatePress(1*BP); + BrakeRes.CreatePress(1*PP); + CntrlRes:=TReservoir.Create; + CntrlRes.CreateCap(15); + CntrlRes.CreatePress(1*HPP); + BrakeStatus:=Byte(BP>1)*1; + Miedzypoj:=TReservoir.Create; + Miedzypoj.CreateCap(5); + Miedzypoj.CreatePress(PP); + + BVM:=1/(HPP-0.05-LPP)*MaxBP; + + BrakeDelayFlag:=BDF; + + Zamykajacy:=false; + + if not ((FM is TDisk1) or (FM is TDisk2)) then //jesli zeliwo to schodz + RapidStaly:=false + else + RapidStaly:=true; + +end; + + +function TNESt3.GetCRP: real; +begin + GetCRP:=CntrlRes.P; +// GetCRP:=Przekladniki[1].P; +// GetCRP:=Miedzypoj.P; +end; + + +procedure TNESt3.CheckState(BCP: real; var dV1: real); //glowny przyrzad rozrzadczy +var VVP, BVP, CVP, MPP: real; +begin + BVP:=BrakeRes.P; //-> tu ma byc komora rozprezna + VVP:=ValveRes.P; + CVP:=CntrlRes.P; + MPP:=Miedzypoj.P; + + if(BCP<0.25)and(VVP+0.08>CVP)then Przys_blok:=false; + +//sprawdzanie stanu +// if ((BrakeStatus and 1)=1)and(BCP>0.25)then + if(VVP+0.01+BCP/BVMCVP-0.05) then + BrakeStatus:=(BrakeStatus and 252) //luzowanie + else if(VVP+BCP/BVM>CVP-0.05) then + BrakeStatus:=(BrakeStatus and 253) //zatrzymanie napelaniania + else if(VVP+(BCP-0.1)/BVM0.25)then //zatrzymanie luzowania + BrakeStatus:=(BrakeStatus or 1); + + if (BrakeStatus and 1)=0 then + SoundFlag:=SoundFlag or sf_CylU; + + if(VVP+0.100.5)then + Zamykajacy:=true + else if(VVP-0.6 PG + if(MPPCVP-0.08)then + CVs:=Nozzles[dSD] + else + CVs:=Nozzles[dSm]; +end; + + +function TNESt3.BVs(BCP: real): real; //napelniacz pomocniczego +var CVP, MPP: real; +begin + CVP:=CntrlRes.P; + MPP:=Miedzypoj.P; + +//przeplyw ZP <-> rozdzielacz + if(MPP0 then + begin + Podskok:=0.7; + Przekladniki[1]:=TRura.Create; + Przekladniki[3]:=TRura.Create; + end + else + begin + Podskok:=-1; + Przekladniki[1]:=TRapid.Create; + if Pos('-s216',params)>0 then + (Przekladniki[1] as TRapid).SetRapidParams(2,16) + else + (Przekladniki[1] as TRapid).SetRapidParams(2,0); + Przekladniki[3]:=TPrzeciwposlizg.Create; + if Pos('-ED',params)>0 then + begin + Przekladniki[3].Free(); + (Przekladniki[1] as TRapid).SetRapidParams(2,18); + Przekladniki[3]:=TPrzekED.Create; + end; + end; + + if Pos('AL2',params)>0 then + Przekladniki[2]:=TPrzekCiagly.Create + else + if Pos('PZZ',params)>0 then + Przekladniki[2]:=TPrzek_PZZ.Create + else + Przekladniki[2]:=TRura.Create; + + if (Pos('3d',params)+Pos('4d',params)>0) then autom:=false else autom:=true; + if (Pos('HBG300',params)>0) then HBG300:=1 else HBG300:=0; + + case size of + 16: + begin //dON,dOO,dTN,dTO,dP,dS + Nozzles[dON]:=5.0;//5.0; + Nozzles[dOO]:=3.4;//3.4; + Nozzles[dTN]:=2.0; + Nozzles[dTO]:=1.75; + Nozzles[dP]:=3.8; + Nozzles[dPd]:=2.70; + Nozzles[dPm]:=1.25; + Nozzles[dPO]:=Nozzles[dON]; + Nozzles[dPT]:=Nozzles[dTN]; + end; + 14: + begin //dON,dOO,dTN,dTO,dP,dS + Nozzles[dON]:=4.3; + Nozzles[dOO]:=2.85; + Nozzles[dTN]:=1.83; + Nozzles[dTO]:=1.57; + Nozzles[dP]:=3.4; + Nozzles[dPd]:=2.20; + Nozzles[dPm]:=1.10; + Nozzles[dPO]:=Nozzles[dON]; + Nozzles[dPT]:=Nozzles[dTN]; + end; + 12: + begin //dON,dOO,dTN,dTO,dP,dS + Nozzles[dON]:=3.7; + Nozzles[dOO]:=2.50; + Nozzles[dTN]:=1.65; + Nozzles[dTO]:=1.39; + Nozzles[dP]:=2.65; + Nozzles[dPd]:=1.80; + Nozzles[dPm]:=0.85; + Nozzles[dPO]:=Nozzles[dON]; + Nozzles[dPT]:=Nozzles[dTN]; + end; + 10: + begin //dON,dOO,dTN,dTO,dP,dS + Nozzles[dON]:=3.1; + Nozzles[dOO]:=2.0; + Nozzles[dTN]:=1.35; + Nozzles[dTO]:=1.13; + Nozzles[dP]:=1.6; + Nozzles[dPd]:=1.55; + Nozzles[dPm]:=0.7; + Nozzles[dPO]:=Nozzles[dON]; + Nozzles[dPT]:=Nozzles[dTN]; + end; + 200: + begin //dON,dOO,dTN,dTO,dP,dS + Nozzles[dON]:=dNO1l; + Nozzles[dOO]:=dOO1l/1.15; + Nozzles[dTN]:=dNT1l; + Nozzles[dTO]:=dOT1l; + Nozzles[dP]:=7.4; + Nozzles[dPd]:=5.3; + Nozzles[dPm]:=2.5; + Nozzles[dPO]:=7.28; + Nozzles[dPT]:=2.96; + end; + 375: + begin //dON,dOO,dTN,dTO,dP,dS + Nozzles[dON]:=dNO1l; + Nozzles[dOO]:=dOO1l/1.15; + Nozzles[dTN]:=dNT1l; + Nozzles[dTO]:=dOT1l; + Nozzles[dP]:=13.0; + Nozzles[dPd]:=9.6; + Nozzles[dPm]:=4.4; + Nozzles[dPO]:=9.92; + Nozzles[dPT]:=3.99; + end; + 150: + begin //dON,dOO,dTN,dTO,dP,dS + Nozzles[dON]:=dNO1l; + Nozzles[dOO]:=dOO1l; + Nozzles[dTN]:=dNT1l; + Nozzles[dTO]:=dOT1l; + Nozzles[dP]:=5.8; + Nozzles[dPd]:=4.1; + Nozzles[dPm]:=1.9; + Nozzles[dPO]:=6.33; + Nozzles[dPT]:=2.58; + end; + 100: + begin //dON,dOO,dTN,dTO,dP,dS + Nozzles[dON]:=dNO1l; + Nozzles[dOO]:=dOO1l; + Nozzles[dTN]:=dNT1l; + Nozzles[dTO]:=dOT1l; + Nozzles[dP]:=4.2; + Nozzles[dPd]:=2.9; + Nozzles[dPm]:=1.4; + Nozzles[dPO]:=5.19; + Nozzles[dPT]:=2.14; + end; + else + begin + Nozzles[dON]:=0; + Nozzles[dOO]:=0; + Nozzles[dTN]:=0; + Nozzles[dTO]:=0; + Nozzles[dP]:=0; + Nozzles[dPd]:=0; + Nozzles[dPm]:=0; + end; + end; + + Nozzles[dSd]:=1.1; + Nozzles[dSm]:=0.9; + + //przeliczanie z mm^2 na l/m + for i:=0 to dMAX do + begin + Nozzles[i]:=d2A(Nozzles[i]); //(/1000^2*pi/4*1000) + end; + + for i:=1 to 3 do + begin + Przekladniki[i].BrakeRes:=@BrakeRes; + Przekladniki[i].CreateCap(i); + Przekladniki[i].CreatePress(BrakeCyl.P); + if i<3 then + Przekladniki[i].Next:=@Przekladniki[i+1] + else + Przekladniki[i].Next:=@BrakeCyl; + end +end; + +end. diff --git a/McZapkie/Unit1.pas b/McZapkie/Unit1.pas new file mode 100644 index 00000000..1435dc92 --- /dev/null +++ b/McZapkie/Unit1.pas @@ -0,0 +1,484 @@ +unit Unit1; + +interface + +uses + ai_driver,mtable,mover,mctools,Windows, Messages, SysUtils, Classes, Graphics, Controls, Forms, Dialogs, + StdCtrls, ExtCtrls; + +type + TForm1 = class(TForm) + Button1: TButton; + Button2: TButton; + Button3: TButton; + Button4: TButton; + Button5: TButton; + Button6: TButton; + Label2: TLabel; + Label3: TLabel; + Timer1: TTimer; + Label4: TLabel; + Label5: TLabel; + Label6: TLabel; + Label9: TLabel; + Label10: TLabel; + Label11: TLabel; + Button7: TButton; + Button8: TButton; + Label12: TLabel; + Label13: TLabel; + Label14: TLabel; + Label15: TLabel; + Button9: TButton; + Button10: TButton; + Label16: TLabel; + Label17: TLabel; + Label18: TLabel; + Label19: TLabel; + Button11: TButton; + Label20: TLabel; + Label21: TLabel; + Label22: TLabel; + Label23: TLabel; + Label24: TLabel; + Label25: TLabel; + lczas: TLabel; + Label28: TLabel; + Label29: TLabel; + Label30: TLabel; + Label31: TLabel; + Label32: TLabel; + Label33: TLabel; + Label34: TLabel; + Button12: TButton; + BStart: TButton; + Label35: TLabel; + Label36: TLabel; + Label37: TLabel; + Label38: TLabel; + Button13: TButton; + Label39: TLabel; + Label40: TLabel; + Label41: TLabel; + Label42: TLabel; + Label43: TLabel; + Button14: TButton; + Button15: TButton; + Label44: TLabel; + Label45: TLabel; + Label46: TLabel; + Label47: TLabel; + BMains: TButton; + Label48: TLabel; + Label49: TLabel; + Label50: TLabel; + Panel1: TPanel; + Label1: TLabel; + OpenDialog1: TOpenDialog; + Edit1: TEdit; + GroupBox1: TGroupBox; + CheckBox1: TCheckBox; + BSInc: TButton; + BSDec: TButton; + Label51: TLabel; + Label52: TLabel; + procedure Button1Click(Sender: TObject); + procedure Button2Click(Sender: TObject); + procedure Timer1Timer(Sender: TObject); + procedure FormCreate(Sender: TObject); + procedure Button5Click(Sender: TObject); + procedure Button6Click(Sender: TObject); + procedure Button7Click(Sender: TObject); + procedure Button8Click(Sender: TObject); + procedure Button3Click(Sender: TObject); + procedure Button4Click(Sender: TObject); + procedure Button9Click(Sender: TObject); + procedure Button10Click(Sender: TObject); + procedure Button11Click(Sender: TObject); + procedure Button12Click(Sender: TObject); + procedure BStartClick(Sender: TObject); + procedure Button13MouseDown(Sender: TObject; Button: TMouseButton; + Shift: TShiftState; X, Y: Integer); + procedure Button14Click(Sender: TObject); + procedure Button15Click(Sender: TObject); + procedure BMainsClick(Sender: TObject); + procedure CheckBox1Click(Sender: TObject); + procedure BSIncClick(Sender: TObject); + procedure BSDecClick(Sender: TObject); + private + { Private declarations } + public + { Public declarations } + end; + +const +mtno=30; +tno:integer=0; + +var +Form1: TForm1; +loc:TMoverParameters; +wagony:array[1..mtno] of TMoverParameters; +mechanik: TController; +pociag: TTrainParameters; +couplerflag:byte; +l0,l0p:TLocation; +ll:array[1..mtno] of TLocation; +r0:TRotation; +rr:array[1..mtno] of TRotation; +Shape:TTrackShape; Track:TTrackParam; +ExternalVoltage:real; +ActualTime:real; +fout: text; +OK:boolean; + +implementation + +{$R *.DFM} + +procedure TForm1.Button1Click(Sender: TObject); +var typename,path:string;slashpos:byte; +begin + +couplerflag:=strtoint(Edit1.Text); +if tno>0 then + wagony[tno]:=TMoverParameters.Create; + +OpenDialog1.Execute; +path:=''; +typename:=OpenDialog1.Filename; +repeat + slashpos:=pos('\',typename); + if slashpos>0 then + typename:=copy(typename,slashpos+1,length(typename)); +until slashpos=0; +path:=copy(opendialog1.filename,1,length(opendialog1.filename)-length(typename)); +typename:=Copy(typename,1,Pos('.chk',typename)-1); + +if tno=0 then + begin + loc.Init(l0,r0,0,typename,'lokomotywa',0,'',1); + OK:=loc.loadchkfile(path) and loc.CheckLocomotiveParameters(Go); + if OK then + begin + Label1.Caption:=loc.TypeName; + case loc.AutoRelayType of + 2: CheckBox1.Enabled:=True; + 1: CheckBox1.Checked:=True; + end; + end; + end +else + begin + wagony[tno].Init(ll[tno],rr[tno],0,typename,IntToStr(tno),0,'',0); + OK:=OK and (wagony[tno].loadchkfile(path) and wagony[tno].CheckLocomotiveParameters(Go)); + if OK then + begin + Label1.Caption:=Label1.Caption+' '+wagony[tno].TypeName; + if tno=1 then + ll[tno].x:=loc.Loc.x-loc.Dim.L/2-wagony[tno].Dim.L/2 + else + ll[tno].x:=wagony[tno-1].Loc.x-wagony[tno-1].Dim.L/2-wagony[tno].Dim.L/2; + wagony[tno].loc:=ll[tno]; + if tno=1 then + begin + OK:=OK and loc.attach(2,@wagony[1],couplerflag); + OK:=OK and wagony[1].attach(1,@loc,couplerflag); + end + else + begin + OK:=OK and wagony[tno-1].attach(2,@wagony[tno],couplerflag); + OK:=OK and wagony[tno].attach(1,@wagony[tno-1],couplerflag); + end + end; + end; + + if OK then + begin + BStart.Enabled:=True; + if tno=mtno then button1.enabled:=false + else inc(tno); + Label49.Caption:='ilosc pojazdow '+inttostr(tno); + end + else + begin + Label1.Caption:=inttostr(conversionerror)+' '+inttostr(linecount); + Button1.Enabled:=False; + end; +end; + +procedure TForm1.Button2Click(Sender: TObject); +var iw:integer; +begin + if Timer1.Enabled then + begin + Timer1.Enabled:=False; + CloseFile(fout); + end; + mechanik.CloseLog; + mechanik.free; + loc.Free; + for iw:=1 to tno do + wagony[iw].Free; + Close; +end; + +procedure TForm1.Timer1Timer(Sender: TObject); +var dl,dt:real; iw:integer; +begin + dt:=Timer1.Interval/1000; + ActualTime:=ActualTime+dt; + if l0.x>200 then Shape.R:=1000; + if l0.x>1000 then Shape.R:=-500; + if l0.x>1500 then Shape.R:=0; + if l0.x>2000 then Shape.R:=1500; + if l0.x>2200 then Shape.R:=3000; + if l0.x>2400 then Shape.R:=0; + loc.ComputeTotalForce(dt); + for iw:=1 to tno do + wagony[iw].ComputeTotalForce(dt); + dl:=loc.ComputeMovement(dt,Shape,Track,ExternalVoltage,l0,r0); + l0.x:=l0.x+dl; + for iw:=1 to tno do + begin + dl:=wagony[iw].ComputeMovement(dt,Shape,Track,ExternalVoltage,ll[iw],rr[iw]); + ll[iw].x:=ll[iw].x+dl; + end; + + mechanik.UpdateSituation(dt); + + + l0p.x:=500; l0p.y:=2; l0.z:=0; + if (l0.x>-1) and (l0.x<5) then + loc.PutCommand('SetVelocity',60,-1,l0p); + if (l0.x>499) and (l0.x<505) then + loc.PutCommand('SetVelocity',-1,-1,l0); + l0p.x:=3600; + if (l0.x>2985) and (l0.x<3005) then + loc.PutCommand('SetVelocity',-1,0,l0p); + if (l0.x>3600) and (l0.x<3615) then + loc.PutCommand('SetVelocity',0,0,l0); + if (l0.x>3430) and (loc.Vel<0.01) and (mechanik.GetCurrentOrder=Obey_train) then + loc.PutCommand('SetVelocity',0,0,l0); + + if (loc.power>0) then + begin + Label2.Caption:='I0='+r2s(Loc.Im,0)+' A'; + Label3.Caption:=r2s(Loc.Ft/1000,0)+' kN'; + Label13.Caption:=IntToStr(Loc.MainCtrlPos); + Label18.Caption:=IntToStr(Loc.ScndCtrlPos); + Label20.Caption:=IntToStr(Loc.MainCtrlActualPos); + Label21.Caption:=IntToStr(Loc.ScndCtrlActualPos); + end + else + for iw:=1 to tno do + if wagony[iw].power>0 then + begin + Label2.Caption:='I'+IntToStr(iw)+'='+r2s(wagony[iw].Im,0)+' A'; + Label3.Caption:=r2s(wagony[iw].Ft/1000,0)+' kN'; + Label13.Caption:=IntToStr(wagony[iw].MainCtrlPos); + Label18.Caption:=IntToStr(wagony[iw].ScndCtrlPos); + Label20.Caption:=IntToStr(wagony[iw].MainCtrlActualPos); + Label21.Caption:=IntToStr(wagony[iw].ScndCtrlActualPos); + end; + Label4.Caption:=r2s(l0.x,0)+' m'; + Label5.Caption:=r2s(Sign(Loc.V)*Loc.Vel,0)+' km/h'; + Label6.Caption:=r2s(Loc.AccS,0)+' m/ss'; + Label9.Caption:=r2s(Loc.Fb/1000,0)+' kN'; + Label10.Caption:=r2s(Loc.Compressor,0)+' MPa'; + Label11.Caption:=r2s(Loc.PipePress,0)+' MPa'; + Label12.Caption:=r2s(Loc.BrakePress,0)+' MPa'; + + + Label14.Caption:=IntToStr(Loc.BrakeCtrlPos); + Label15.Caption:=IntToStr(Loc.LocalBrakePos); + + Label16.Caption:=IntToStr(Loc.showcurrent(1)); + Label17.Caption:=IntToStr(Loc.showcurrent(2)); + + if loc.SlippingWheels then + Label19.Caption:='Poslizg!' + else Label19.Caption:=' '; + + + Label22.Caption:=r2s(ll[1].x,0)+' m'; + if tno>=1 then + begin + Label23.Caption:=r2s(Sign(wagony[1].V)*wagony[1].Vel,0)+' km/h'; + Label24.Caption:=r2s(Distance(loc.loc,wagony[1].loc,loc.dim,wagony[1].dim),0)+' m'; + end; + Label25.Caption:=r2s(loc.nrot,0)+' 1/s'; + + Label28.Caption:=r2s(ll[2].x,0)+' m'; + + if tno>=2 then + Label29.Caption:=r2s(sign(wagony[2].V)*wagony[2].Vel,0)+' km/h'; + + Label30.Caption:=r2s(loc.dpLocalValve/dt,0)+' MPa/s'; + Label31.Caption:=r2s(loc.dpBrake/dt,0)+' MPa/s'; + Label32.Caption:=r2s(loc.dpMainValve/dt,0)+' MPa/s'; + Label33.Caption:=r2s(loc.dpPipe/dt,0)+' MPa/s'; + + if tno>0 then Label34.Caption:=r2s(wagony[tno].PipePress,0)+' MPa'; + + Label35.Caption:=r2s(ll[3].x,0)+' m'; + if tno>0 then Label36.Caption:=r2s(sign(wagony[tno].V)*wagony[tno].Vel,0)+' km/h'; + if tno>0 then Label37.Caption:=r2s(wagony[tno].couplers[1].cforce/1000,0)+' kN'; + if tno>0 then Label38.Caption:=r2s(wagony[tno].brakepress,0)+' MPa'; + + Label39.Caption:=r2s(loc.enginePower/1000,0)+' kW'; + Label40.Caption:=i2s(trunc(loc.Rventrot*60))+' /min'; + Label41.Visible:=loc.SandDose; + Label42.Caption:=r2s(mechanik.accdesired,0)+' m/ss'; + Label43.Caption:=r2s(mechanik.veldesired,0)+' km/h'; + if tno>0 then Label44.Caption:=r2s(ll[tno].x,0)+' m'; + Label45.Caption:=inttostr(loc.activedir); + Label46.Caption:=inttostr(ord(mechanik.orderlist[mechanik.orderpos])); + Label47.Caption:=inttostr(mechanik.orderpos); + Label48.Caption:=inttostr(ord(loc.mains)); +{ if tno>0 then Label51.Caption:=wagony[1].CommandIn.Command; + if tno>0 then Label52.Caption:=r2s(wagony[1].CommandIn.Value1,0); +} + Label51.Caption:=loc.CommandIn.Command; + Label52.Caption:=r2s(loc.CommandIn.Value1,0); + Lczas.Caption:=r2s(actualtime,0)+' s'; + writeln(fout,Actualtime,' ',{loc.v-wag.v,}loc.UnitBrakeForce,' ',loc.dpMainValve,{' ',loc.dpLocalValve,}' ',loc.accs,' ',loc.couplers[2].cforce,' ',{,l1.x}' '{,Distance(loc.loc,wagony[1].loc,loc.dim,wagony[1].dim)}); +end; + +procedure TForm1.FormCreate(Sender: TObject); +var iw:integer; +begin + Timer1.Enabled:=False; + tno:=0; + assignfile(fout,'log.dat'); + rewrite(fout); + ActualTime:=0; + loc:=TMoverParameters.Create; + Shape.R:=0; Shape.Len:=10000; Shape.dHtrack:=0; Shape.dHrail:=0; + Track.Width:=1435; Track.friction:=0.15; Track.CategoryFlag:=1; + Track.QualityFlag:=25; Track.DamageFlag:=0; + Track.VelMax:=120; + ExternalVoltage:=3000; + l0.x:=0; l0.y:=0; l0.z:=0; + r0.rx:=0; r0.ry:=0; r0.rz:=0; + for iw:=1 to mtno do + begin + rr[iw].rx:=0; rr[iw].ry:=0; rr[iw].rz:=0; + ll[iw].x:=0; ll[iw].y:=0; ll[iw].z:=0; + end; + +end; + +procedure TForm1.Button5Click(Sender: TObject); +begin + loc.incbrakelevel; +end; + +procedure TForm1.Button6Click(Sender: TObject); +begin + loc.decbrakelevel; +end; + +procedure TForm1.Button7Click(Sender: TObject); +begin + loc.inclocalbrakelevel(1); +end; + +procedure TForm1.Button8Click(Sender: TObject); +begin + loc.declocalbrakelevel(1); +end; + +procedure TForm1.Button3Click(Sender: TObject); +begin + loc.incmainctrl(1); +end; + +procedure TForm1.Button4Click(Sender: TObject); +begin + loc.decmainctrl(1); +end; + +procedure TForm1.Button9Click(Sender: TObject); +begin +loc.DirectionForward; +end; + +procedure TForm1.Button10Click(Sender: TObject); +begin + loc.DirectionBackward; +end; + +procedure TForm1.Button11Click(Sender: TObject); +begin + loc.FuseOn; +end; + +procedure TForm1.Button12Click(Sender: TObject); +begin + Loc.AntiSlippingBrake; +end; + +procedure TForm1.BStartClick(Sender: TObject); +begin + tno:=tno-1; + Button1.Enabled:=False; + Edit1.Enabled:=False; + Timer1.Enabled:=True; + mechanik:=TController.Create; + pociag:=TTrainParameters.Create; + pociag.init('Testowy Express',100); + mechanik.init(l0,r0,HumanDriver,@loc,@pociag,Aggressive); + + BStart.Enabled:=False; + Button14.enabled:=True; + Button15.enabled:=True; +end; + +procedure TForm1.Button13MouseDown(Sender: TObject; Button: TMouseButton; + Shift: TShiftState; X, Y: Integer); +begin + loc.SandDoseOn; +end; + +procedure TForm1.Button14Click(Sender: TObject); +begin + mechanik.SetVelocity(30,120); +end; + +procedure TForm1.Button15Click(Sender: TObject); +begin + mechanik.AIControllFlag:=not mechanik.AIControllFlag; + if not loc.mains then + begin + mechanik.ChangeOrder(Prepare_Engine); + mechanik.JumpToNextOrder; + mechanik.ChangeOrder(Obey_train); + mechanik.JumpToNextOrder; + mechanik.ChangeOrder(Release_engine); + mechanik.JumpToFirstOrder; + mechanik.SetVelocity(60,120); + end; +end; + +procedure TForm1.BMainsClick(Sender: TObject); +begin + loc.MainSwitch; +end; + +procedure TForm1.CheckBox1Click(Sender: TObject); +begin + loc.autorelayswitch; +end; + +procedure TForm1.BSIncClick(Sender: TObject); +begin + loc.incscndctrl(1); +end; + +procedure TForm1.BSDecClick(Sender: TObject); +begin + loc.decscndctrl(1); +end; + +end. diff --git a/McZapkie/_Mover.hpp b/McZapkie/_Mover.hpp new file mode 100644 index 00000000..81065a91 --- /dev/null +++ b/McZapkie/_Mover.hpp @@ -0,0 +1,880 @@ +// Borland C++ Builder +// Copyright (c) 1995, 1999 by Borland International +// All rights reserved + +// (DO NOT EDIT: machine generated header) '_mover.pas' rev: 5.00 + +#ifndef _moverHPP +#define _moverHPP + +#pragma delphiheader begin +#pragma option push -w- +#pragma option push -Vx +#include // Pascal unit +#include // Pascal unit +#include // Pascal unit +#include // Pascal unit +#include // Pascal unit +#include // Pascal unit + +//-- user supplied ----------------------------------------------------------- + +namespace _mover +{ +//-- type declarations ------------------------------------------------------- +struct TLocation +{ + double X; + double Y; + double Z; +} ; + +struct TRotation +{ + double Rx; + double Ry; + double Rz; +} ; + +struct TDimension +{ + double W; + double L; + double H; +} ; + +struct TCommand +{ + AnsiString Command; + double Value1; + double Value2; + TLocation Location; +} ; + +struct TTrackShape +{ + double R; + double Len; + double dHtrack; + double dHrail; +} ; + +struct TTrackParam +{ + double Width; + double friction; + Byte CategoryFlag; + Byte QualityFlag; + Byte DamageFlag; + double Velmax; +} ; + +struct TTractionParam +{ + double TractionVoltage; + double TractionFreq; + double TractionMaxCurrent; + double TractionResistivity; +} ; + +#pragma option push -b- +enum TBrakeSystem { Individual, Pneumatic, ElectroPneumatic }; +#pragma option pop + +#pragma option push -b- +enum TBrakeSubSystem { ss_None, ss_W, ss_K, ss_KK, ss_Hik, ss_ESt, ss_KE, ss_LSt, ss_MT, ss_Dako }; +#pragma option pop + +#pragma option push -b- +enum TBrakeValve { NoValve, W, W_Lu_VI, W_Lu_L, W_Lu_XR, K, Kg, Kp, Kss, Kkg, Kkp, Kks, Hikg1, Hikss, + Hikp1, KE, SW, EStED, NESt3, ESt3, LSt, ESt4, ESt3AL2, EP1, EP2, M483, CV1_L_TR, CV1, CV1_R, Other + }; +#pragma option pop + +#pragma option push -b- +enum TBrakeHandle { NoHandle, West, FV4a, M394, M254, FVel1, FVel6, D2, Knorr, FD1, BS2, testH, St113 + }; +#pragma option pop + +#pragma option push -b- +enum TLocalBrake { NoBrake, ManualBrake, PneumaticBrake, HydraulicBrake }; +#pragma option pop + +typedef double TBrakeDelayTable[4]; + +struct TBrakePressure +{ + double PipePressureVal; + double BrakePressureVal; + double FlowSpeedVal; + TBrakeSystem BrakeType; +} ; + +typedef TBrakePressure TBrakePressureTable[13]; + +#pragma option push -b- +enum TEngineTypes { None, Dumb, WheelsDriven, ElectricSeriesMotor, ElectricInductionMotor, DieselEngine, + SteamEngine, DieselElectric }; +#pragma option pop + +#pragma option push -b- +enum TPowerType { NoPower, BioPower, MechPower, ElectricPower, SteamPower }; +#pragma option pop + +#pragma option push -b- +enum TFuelType { Undefined, Coal, Oil }; +#pragma option pop + +struct TGrateType +{ + TFuelType FuelType; + double GrateSurface; + double FuelTransportSpeed; + double IgnitionTemperature; + double MaxTemperature; +} ; + +struct TBoilerType +{ + double BoilerVolume; + double BoilerHeatSurface; + double SuperHeaterSurface; + double MaxWaterVolume; + double MinWaterVolume; + double MaxPressure; +} ; + +struct TCurrentCollector +{ + int CollectorsNo; + double MinH; + double MaxH; + double CSW; + double MinV; + double MaxV; + double InsetV; + double MinPress; + double MaxPress; +} ; + +#pragma option push -b- +enum TPowerSource { NotDefined, InternalSource, Transducer, Generator, Accumulator, CurrentCollector, + PowerCable, Heater }; +#pragma option pop + +struct _mover__1 +{ + double MaxCapacity; + TPowerSource RechargeSource; +} ; + +struct _mover__2 +{ + TPowerType PowerTrans; + double SteamPressure; +} ; + +struct _mover__3 +{ + TGrateType Grate; + TBoilerType Boiler; +} ; + +struct TPowerParameters +{ + double MaxVoltage; + double MaxCurrent; + double IntR; + TPowerSource SourceType; + union + { + struct + { + _mover__3 RHeater; + + }; + struct + { + _mover__2 RPowerCable; + + }; + struct + { + TCurrentCollector CollectorParameters; + + }; + struct + { + _mover__1 RAccumulator; + + }; + struct + { + TEngineTypes GeneratorEngine; + + }; + struct + { + double InputVoltage; + + }; + struct + { + TPowerType PowerType; + + }; + + }; +} ; + +struct TScheme +{ + Byte Relay; + double R; + Byte Bn; + Byte Mn; + bool AutoSwitch; + Byte ScndAct; +} ; + +typedef TScheme TSchemeTable[65]; + +struct TDEScheme +{ + double RPM; + double GenPower; + double Umax; + double Imax; +} ; + +typedef TDEScheme TDESchemeTable[33]; + +struct TShuntScheme +{ + double Umin; + double Umax; + double Pmin; + double Pmax; +} ; + +typedef TShuntScheme TShuntSchemeTable[33]; + +struct TMPTRelay +{ + double Iup; + double Idown; +} ; + +typedef TMPTRelay TMPTRelayTable[8]; + +struct TMotorParameters +{ + double mfi; + double mIsat; + double mfi0; + double fi; + double Isat; + double fi0; + bool AutoSwitch; +} ; + +struct TSecuritySystem +{ + Byte SystemType; + double AwareDelay; + double AwareMinSpeed; + double SoundSignalDelay; + double EmergencyBrakeDelay; + Byte Status; + double SystemTimer; + double SystemSoundCATimer; + double SystemSoundSHPTimer; + double SystemBrakeCATimer; + double SystemBrakeSHPTimer; + double SystemBrakeCATestTimer; + int VelocityAllowed; + int NextVelocityAllowed; + bool RadioStop; +} ; + +struct TTransmision +{ + Byte NToothM; + Byte NToothW; + double Ratio; +} ; + +#pragma option push -b- +enum TCouplerType { NoCoupler, Articulated, Bare, Chain, Screw, Automatic }; +#pragma option pop + +class DELPHICLASS T_MoverParameters; +struct TCoupling; +class PASCALIMPLEMENTATION T_MoverParameters : public System::TObject +{ + typedef System::TObject inherited; + +public: + double dMoveLen; + AnsiString filename; + Byte CategoryFlag; + AnsiString TypeName; + int TrainType; + TEngineTypes EngineType; + TPowerParameters EnginePowerSource; + TPowerParameters SystemPowerSource; + TPowerParameters HeatingPowerSource; + TPowerParameters AlterHeatPowerSource; + TPowerParameters LightPowerSource; + TPowerParameters AlterLightPowerSource; + double Vmax; + double Mass; + double Power; + double Mred; + double TotalMass; + double HeatingPower; + double LightPower; + double BatteryVoltage; + bool Battery; + bool EpFuse; + bool Signalling; + bool DoorSignalling; + bool Radio; + double NominalBatteryVoltage; + TDimension Dim; + double Cx; + double Floor; + double WheelDiameter; + double WheelDiameterL; + double WheelDiameterT; + double TrackW; + double AxleInertialMoment; + AnsiString AxleArangement; + Byte NPoweredAxles; + Byte NAxles; + Byte BearingType; + double ADist; + double BDist; + Byte NBpA; + int SandCapacity; + TBrakeSystem BrakeSystem; + TBrakeSubSystem BrakeSubsystem; + TBrakeValve BrakeValve; + TBrakeHandle BrakeHandle; + TBrakeHandle BrakeLocHandle; + double MBPM; + Hamulce::TBrake* Hamulec; + Hamulce::THandle* Handle; + Hamulce::THandle* LocHandle; + Hamulce::TReservoir* Pipe; + Hamulce::TReservoir* Pipe2; + TLocalBrake LocalBrake; + TBrakePressure BrakePressureTable[13]; + TBrakePressure BrakePressureActual; + Byte ASBType; + Byte TurboTest; + double MaxBrakeForce; + double MaxBrakePress[5]; + double P2FTrans; + double TrackBrakeForce; + Byte BrakeMethod; + double HighPipePress; + double LowPipePress; + double DeltaPipePress; + double CntrlPipePress; + double BrakeVolume; + double BrakeVVolume; + double VeselVolume; + int BrakeCylNo; + double BrakeCylRadius; + double BrakeCylDist; + double BrakeCylMult[3]; + Byte LoadFlag; + double BrakeCylSpring; + double BrakeSlckAdj; + double BrakeRigEff; + double RapidMult; + int BrakeValveSize; + AnsiString BrakeValveParams; + double Spg; + double MinCompressor; + double MaxCompressor; + double CompressorSpeed; + double BrakeDelay[4]; + Byte BrakeCtrlPosNo; + Byte MainCtrlPosNo; + Byte ScndCtrlPosNo; + bool ScndInMain; + bool MBrake; + TSecuritySystem SecuritySystem; + TScheme RList[65]; + int RlistSize; + TMotorParameters MotorParam[11]; + TTransmision Transmision; + double NominalVoltage; + double WindingRes; + double u; + double CircuitRes; + int IminLo; + int IminHi; + int ImaxLo; + int ImaxHi; + double nmax; + double InitialCtrlDelay; + double CtrlDelay; + double CtrlDownDelay; + Byte FastSerialCircuit; + Byte AutoRelayType; + bool CoupledCtrl; + bool IsCoupled; + Byte DynamicBrakeType; + Byte RVentType; + double RVentnmax; + double RVentCutOff; + int CompressorPower; + int SmallCompressorPower; + double dizel_Mmax; + double dizel_nMmax; + double dizel_Mnmax; + double dizel_nmax; + double dizel_nominalfill; + double dizel_Mstand; + double dizel_nmax_cutoff; + double dizel_nmin; + double dizel_minVelfullengage; + double dizel_AIM; + double dizel_engageDia; + double dizel_engageMaxForce; + double dizel_engagefriction; + double AnPos; + bool AnalogCtrl; + bool AnMainCtrl; + bool ShuntModeAllow; + bool ShuntMode; + bool Flat; + double Vhyp; + TDEScheme DElist[33]; + double Vadd; + TMPTRelay MPTRelay[8]; + Byte RelayType; + TShuntScheme SST[33]; + double PowerCorRatio; + double Ftmax; + double eimc[21]; + int MaxLoad; + AnsiString LoadAccepted; + AnsiString LoadQuantity; + double OverLoadFactor; + double LoadSpeed; + double UnLoadSpeed; + Byte DoorOpenCtrl; + Byte DoorCloseCtrl; + double DoorStayOpen; + bool DoorClosureWarning; + double DoorOpenSpeed; + double DoorCloseSpeed; + double DoorMaxShiftL; + double DoorMaxShiftR; + Byte DoorOpenMethod; + bool ScndS; + TLocation Loc; + TRotation Rot; + AnsiString Name; + TCoupling Couplers[2]; + double HVCouplers[2][2]; + int ScanCounter; + bool EventFlag; + Byte SoundFlag; + double DistCounter; + double V; + double Vel; + double AccS; + double AccN; + double AccV; + double nrot; + double EnginePower; + double dL; + double Fb; + double Ff; + double FTrain; + double FStand; + double FTotal; + double UnitBrakeForce; + double Ntotal; + bool SlippingWheels; + bool SandDose; + double Sand; + double BrakeSlippingTimer; + double dpBrake; + double dpPipe; + double dpMainValve; + double dpLocalValve; + double ScndPipePress; + double BrakePress; + double LocBrakePress; + double PipeBrakePress; + double PipePress; + double EqvtPipePress; + double Volume; + double CompressedVolume; + double PantVolume; + double Compressor; + bool CompressorFlag; + bool PantCompFlag; + bool CompressorAllow; + bool ConverterFlag; + bool ConverterAllow; + int BrakeCtrlPos; + double BrakeCtrlPosR; + double BrakeCtrlPos2; + Byte LocalBrakePos; + Byte ManualBrakePos; + double LocalBrakePosA; + Byte BrakeStatus; + bool EmergencyBrakeFlag; + Byte BrakeDelayFlag; + Byte BrakeDelays; + bool DynamicBrakeFlag; + double LimPipePress; + double ActFlowSpeed; + Byte DamageFlag; + Byte DerailReason; + TCommand CommandIn; + AnsiString CommandOut; + AnsiString CommandLast; + double ValueOut; + TTrackShape RunningShape; + TTrackParam RunningTrack; + double OffsetTrackH; + double OffsetTrackV; + bool Mains; + Byte MainCtrlPos; + Byte ScndCtrlPos; + int ActiveDir; + int CabNo; + int DirAbsolute; + int ActiveCab; + double LastSwitchingTime; + bool DepartureSignal; + bool InsideConsist; + TTractionParam RunningTraction; + double enrot; + double Im; + double Itot; + double IHeating; + double ITraction; + double TotalCurrent; + double Mm; + double Mw; + double Fw; + double Ft; + int Imin; + int Imax; + double Voltage; + Byte MainCtrlActualPos; + Byte ScndCtrlActualPos; + bool DelayCtrlFlag; + double LastRelayTime; + bool AutoRelayFlag; + bool FuseFlag; + bool ConvOvldFlag; + bool StLinFlag; + bool ResistorsFlag; + double RventRot; + bool UnBrake; + double PantPress; + bool s_CAtestebrake; + double dizel_fill; + double dizel_engagestate; + double dizel_engage; + double dizel_automaticgearstatus; + bool dizel_enginestart; + double dizel_engagedeltaomega; + double eimv[21]; + double PulseForce; + double PulseForceTimer; + int PulseForceCount; + double eAngle; + int Load; + AnsiString LoadType; + Byte LoadStatus; + double LastLoadChangeTime; + bool DoorBlocked; + bool DoorLeftOpened; + bool DoorRightOpened; + bool PantFrontUp; + bool PantRearUp; + bool PantFrontSP; + bool PantRearSP; + int PantFrontStart; + int PantRearStart; + double PantFrontVolt; + double PantRearVolt; + AnsiString PantSwitchType; + AnsiString ConvSwitchType; + bool Heating; + int DoubleTr; + bool PhysicActivation; + double FrictConst1; + double FrictConst2s; + double FrictConst2d; + double TotalMassxg; + double __fastcall GetTrainsetVoltage(void); + bool __fastcall Physic_ReActivation(void); + double __fastcall LocalBrakeRatio(void); + double __fastcall ManualBrakeRatio(void); + double __fastcall PipeRatio(void); + double __fastcall RealPipeRatio(void); + double __fastcall BrakeVP(void); + bool __fastcall DynamicBrakeSwitch(bool Switch); + bool __fastcall SendCtrlBroadcast(AnsiString CtrlCommand, double ctrlvalue); + bool __fastcall SendCtrlToNext(AnsiString CtrlCommand, double ctrlvalue, double dir); + bool __fastcall CabActivisation(void); + bool __fastcall CabDeactivisation(void); + bool __fastcall IncMainCtrl(int CtrlSpeed); + bool __fastcall DecMainCtrl(int CtrlSpeed); + bool __fastcall IncScndCtrl(int CtrlSpeed); + bool __fastcall DecScndCtrl(int CtrlSpeed); + bool __fastcall AddPulseForce(int Multipler); + bool __fastcall SandDoseOn(void); + bool __fastcall SecuritySystemReset(void); + void __fastcall SecuritySystemCheck(double dt); + bool __fastcall BatterySwitch(bool State); + bool __fastcall EpFuseSwitch(bool State); + bool __fastcall IncBrakeLevelOld(void); + bool __fastcall DecBrakeLevelOld(void); + bool __fastcall IncLocalBrakeLevel(Byte CtrlSpeed); + bool __fastcall DecLocalBrakeLevel(Byte CtrlSpeed); + bool __fastcall IncLocalBrakeLevelFAST(void); + bool __fastcall DecLocalBrakeLevelFAST(void); + bool __fastcall IncManualBrakeLevel(Byte CtrlSpeed); + bool __fastcall DecManualBrakeLevel(Byte CtrlSpeed); + bool __fastcall EmergencyBrakeSwitch(bool Switch); + bool __fastcall AntiSlippingBrake(void); + bool __fastcall BrakeReleaser(Byte state); + bool __fastcall SwitchEPBrake(Byte state); + bool __fastcall AntiSlippingButton(void); + bool __fastcall IncBrakePress(double &brake, double PressLimit, double dp); + bool __fastcall DecBrakePress(double &brake, double PressLimit, double dp); + bool __fastcall BrakeDelaySwitch(Byte BDS); + bool __fastcall IncBrakeMult(void); + bool __fastcall DecBrakeMult(void); + void __fastcall UpdateBrakePressure(double dt); + void __fastcall UpdatePipePressure(double dt); + void __fastcall CompressorCheck(double dt); + void __fastcall UpdateScndPipePressure(double dt); + double __fastcall GetDVc(double dt); + void __fastcall ComputeConstans(void); + double __fastcall ComputeMass(void); + double __fastcall Adhesive(double staticfriction); + double __fastcall TractionForce(double dt); + double __fastcall FrictionForce(double R, Byte TDamage); + double __fastcall BrakeForce(const TTrackParam &Track); + double __fastcall CouplerForce(Byte CouplerN, double dt); + void __fastcall CollisionDetect(Byte CouplerN, double dt); + double __fastcall ComputeRotatingWheel(double WForce, double dt, double n); + bool __fastcall SetInternalCommand(AnsiString NewCommand, double NewValue1, double NewValue2); + double __fastcall GetExternalCommand(AnsiString &Command); + bool __fastcall RunCommand(AnsiString command, double CValue1, double CValue2); + bool __fastcall RunInternalCommand(void); + void __fastcall PutCommand(AnsiString NewCommand, double NewValue1, double NewValue2, const TLocation + &NewLocation); + bool __fastcall DirectionBackward(void); + bool __fastcall MainSwitch(bool State); + bool __fastcall ConverterSwitch(bool State); + bool __fastcall CompressorSwitch(bool State); + bool __fastcall FuseOn(void); + bool __fastcall FuseFlagCheck(void); + void __fastcall FuseOff(void); + int __fastcall ShowCurrent(Byte AmpN); + double __fastcall v2n(void); + double __fastcall current(double n, double U); + double __fastcall Momentum(double I); + double __fastcall MomentumF(double I, double Iw, Byte SCP); + bool __fastcall CutOffEngine(void); + bool __fastcall MaxCurrentSwitch(bool State); + bool __fastcall ResistorsFlagCheck(void); + bool __fastcall MinCurrentSwitch(bool State); + bool __fastcall AutoRelaySwitch(bool State); + bool __fastcall AutoRelayCheck(void); + bool __fastcall dizel_EngageSwitch(double state); + bool __fastcall dizel_EngageChange(double dt); + bool __fastcall dizel_AutoGearCheck(void); + double __fastcall dizel_fillcheck(Byte mcp); + double __fastcall dizel_Momentum(double dizel_fill, double n, double dt); + bool __fastcall dizel_Update(double dt); + bool __fastcall LoadingDone(double LSpeed, AnsiString LoadInit); + void __fastcall ComputeTotalForce(double dt, double dt1, bool FullVer); + double __fastcall ComputeMovement(double dt, double dt1, const TTrackShape &Shape, TTrackParam &Track + , TTractionParam &ElectricTraction, const TLocation &NewLoc, TRotation &NewRot); + double __fastcall FastComputeMovement(double dt, const TTrackShape &Shape, TTrackParam &Track, const + TLocation &NewLoc, TRotation &NewRot); + bool __fastcall ChangeOffsetH(double DeltaOffset); + __fastcall T_MoverParameters(double VelInitial, AnsiString TypeNameInit, AnsiString NameInit, int LoadInitial + , AnsiString LoadTypeInitial, int Cab); + bool __fastcall LoadChkFile(AnsiString chkpath); + bool __fastcall CheckLocomotiveParameters(bool ReadyFlag, int Dir); + AnsiString __fastcall EngineDescription(int what); + bool __fastcall DoorLeft(bool State); + bool __fastcall DoorRight(bool State); + bool __fastcall DoorBlockedFlag(void); + bool __fastcall PantFront(bool State); + bool __fastcall PantRear(bool State); +public: + #pragma option push -w-inl + /* TObject.Create */ inline __fastcall T_MoverParameters(void) : System::TObject() { } + #pragma option pop + #pragma option push -w-inl + /* TObject.Destroy */ inline __fastcall virtual ~T_MoverParameters(void) { } + #pragma option pop + +}; + + +struct TCoupling +{ + double SpringKB; + double SpringKC; + double beta; + double DmaxB; + double FmaxB; + double DmaxC; + double FmaxC; + TCouplerType CouplerType; + Byte CouplingFlag; + int AllowedFlag; + bool Render; + double CoupleDist; + T_MoverParameters* Connected; + Byte ConnectedNr; + double CForce; + double Dist; + bool CheckCollision; +} ; + +//-- var, const, procedure --------------------------------------------------- +static const bool Go = true; +static const bool Hold = false; +static const Shortint ResArraySize = 0x40; +static const Shortint MotorParametersArraySize = 0xa; +static const Shortint maxcc = 0x4; +static const Shortint LocalBrakePosNo = 0xa; +static const Shortint MainBrakeMaxPos = 0xa; +static const Shortint ManualBrakePosNo = 0x14; +static const Shortint dtrack_railwear = 0x2; +static const Shortint dtrack_freerail = 0x4; +static const Shortint dtrack_thinrail = 0x8; +static const Shortint dtrack_railbend = 0x10; +static const Shortint dtrack_plants = 0x20; +static const Shortint dtrack_nomove = 0x40; +static const Byte dtrack_norail = 0x80; +static const Shortint dtrain_thinwheel = 0x1; +static const Shortint dtrain_loadshift = 0x1; +static const Shortint dtrain_wheelwear = 0x2; +static const Shortint dtrain_bearing = 0x4; +static const Shortint dtrain_coupling = 0x8; +static const Shortint dtrain_ventilator = 0x10; +static const Shortint dtrain_loaddamage = 0x10; +static const Shortint dtrain_engine = 0x20; +static const Shortint dtrain_loaddestroyed = 0x20; +static const Shortint dtrain_axle = 0x40; +static const Byte dtrain_out = 0x80; +#define p_elengproblem (1.000000E-02) +#define p_elengdamage (1.000000E-01) +#define p_coupldmg (2.000000E-02) +#define p_derail (1.000000E-03) +#define p_accn (1.000000E-01) +#define p_slippdmg (1.000000E-03) +static const Shortint ctrain_virtual = 0x0; +static const Shortint ctrain_coupler = 0x1; +static const Shortint ctrain_pneumatic = 0x2; +static const Shortint ctrain_controll = 0x4; +static const Shortint ctrain_power = 0x8; +static const Shortint ctrain_passenger = 0x10; +static const Shortint ctrain_scndpneumatic = 0x20; +static const Shortint ctrain_heating = 0x40; +static const Byte ctrain_depot = 0x80; +static const Shortint dbrake_none = 0x0; +static const Shortint dbrake_passive = 0x1; +static const Shortint dbrake_switch = 0x2; +static const Shortint dbrake_reversal = 0x4; +static const Shortint dbrake_automatic = 0x8; +static const Shortint s_waiting = 0x1; +static const Shortint s_aware = 0x2; +static const Shortint s_active = 0x4; +static const Shortint s_CAalarm = 0x8; +static const Shortint s_SHPalarm = 0x10; +static const Shortint s_CAebrake = 0x20; +static const Shortint s_SHPebrake = 0x40; +static const Byte s_CAtest = 0x80; +static const Shortint sound_none = 0x0; +static const Shortint sound_loud = 0x1; +static const Shortint sound_couplerstretch = 0x2; +static const Shortint sound_bufferclamp = 0x4; +static const Shortint sound_bufferbump = 0x8; +static const Shortint sound_relay = 0x10; +static const Shortint sound_manyrelay = 0x20; +static const Shortint sound_brakeacc = 0x40; +extern PACKAGE bool PhysicActivationFlag; +static const Shortint dt_Default = 0x0; +static const Shortint dt_EZT = 0x1; +static const Shortint dt_ET41 = 0x2; +static const Shortint dt_ET42 = 0x4; +static const Shortint dt_PseudoDiesel = 0x8; +static const Shortint dt_ET22 = 0x10; +static const Shortint dt_SN61 = 0x20; +static const Shortint dt_EP05 = 0x40; +static const Byte dt_ET40 = 0x80; +static const Word dt_181 = 0x100; +static const Shortint eimc_s_dfic = 0x0; +static const Shortint eimc_s_dfmax = 0x1; +static const Shortint eimc_s_p = 0x2; +static const Shortint eimc_s_cfu = 0x3; +static const Shortint eimc_s_cim = 0x4; +static const Shortint eimc_s_icif = 0x5; +static const Shortint eimc_f_Uzmax = 0x7; +static const Shortint eimc_f_Uzh = 0x8; +static const Shortint eimc_f_DU = 0x9; +static const Shortint eimc_f_I0 = 0xa; +static const Shortint eimc_f_cfu = 0xb; +static const Shortint eimc_p_F0 = 0xd; +static const Shortint eimc_p_a1 = 0xe; +static const Shortint eimc_p_Pmax = 0xf; +static const Shortint eimc_p_Fh = 0x10; +static const Shortint eimc_p_Ph = 0x11; +static const Shortint eimc_p_Vh0 = 0x12; +static const Shortint eimc_p_Vh1 = 0x13; +static const Shortint eimc_p_Imax = 0x14; +static const Shortint eimv_FMAXMAX = 0x0; +static const Shortint eimv_Fmax = 0x1; +static const Shortint eimv_ks = 0x2; +static const Shortint eimv_df = 0x3; +static const Shortint eimv_fp = 0x4; +static const Shortint eimv_U = 0x5; +static const Shortint eimv_pole = 0x6; +static const Shortint eimv_Ic = 0x7; +static const Shortint eimv_If = 0x8; +static const Shortint eimv_M = 0x9; +static const Shortint eimv_Fr = 0xa; +static const Shortint eimv_Ipoj = 0xb; +static const Shortint eimv_Pm = 0xc; +static const Shortint eimv_Pe = 0xd; +static const Shortint eimv_eta = 0xe; +static const Shortint eimv_fkr = 0xf; +static const Shortint eimv_Uzsmax = 0x10; +static const Shortint eimv_Pmax = 0x11; +static const Shortint eimv_Fzad = 0x12; +static const Shortint eimv_Imax = 0x13; +extern PACKAGE double __fastcall Distance(const TLocation &Loc1, const TLocation &Loc2, const TDimension + &Dim1, const TDimension &Dim2); + +} /* namespace _mover */ +#if !defined(NO_IMPLICIT_NAMESPACE_USE) +using namespace _mover; +#endif +#pragma option pop // -w- +#pragma option pop // -Vx + +#pragma delphiheader end. +//-- end unit ---------------------------------------------------------------- +#endif // _mover diff --git a/McZapkie/_mover.pas b/McZapkie/_mover.pas new file mode 100644 index 00000000..870db398 --- /dev/null +++ b/McZapkie/_mover.pas @@ -0,0 +1,7380 @@ +unit _mover; {fizyka ruchu dla symulatora lokomotywy} + +(* + MaSzyna EU07 locomotive simulator + Copyright (C) 2001-2004 Maciej Czapkiewicz and others + +*) + + +(* +(C) McZapkie v.2004.02 +Co brakuje: +6. brak pantografow itp 'Nie do konca, juz czesc zrobiona - Winger +7. brak efektu grzania oporow rozruchowych, silnika, osi +9. ulepszyc sprzeg sztywny oraz automatyczny +10. klopoty z EN57 +... +n. Inne lokomotywy oprocz elektrowozu pradu stalego +*) +(* +Zrobione: +1. model szeregowego silnika elektrycznego sterowanego reostatem +2. fizyka ruchu - sily oporu, nachylenia, przyspieszenia styczne i normalne, +przyczepnosc/poslizg przy hamowaniu i rozruchu +3. docisk klockow hamulcowych -hamulec reczny oraz pomocniczy hamulec pneumatyczny +4. ubytki cisnienia wskutek hamowania, kompresor - ladowanie zbiornika +5. niektore uszkodzenia i awarie - logika rozmyta +a) silnik elektryczny - za duzy prad, napiecie, obroty +b) sprzegi - zerwanie gdy zbyt duze sily +6. flagi niektorych dzwiekow +7. hamulec zasadniczy - elektropneumatyczny (impulsowanie), pneumatyczny - zmiany cisnienia +zwiekszenie nacisku przy duzych predkosciach w hamulcach Oerlikona +8. sprzegi - sila, tlumiennosc +9. lok. el. - wylacznik glowny, odlacznik uszkodzonych silnikow +10. parametry trakcji +11. opoznienia w zalaczaniu stycznikow +12. trakcja wielokrotna +13. informacja na temat zrodla mocy dla silnikow trakcyjnych, ogrzewania, oswietlenia +14. dumb - uproszczony model lokomotywy (tylko dla AI) +15. ladunki - ilosc, typ, szybkosc na- i rozladunku, funkcje przetestowac! +16. ulepszony model fizyczny silnika elektrycznego (hamowanie silnikiem, ujemne napiecia) +17. poprawione hamulce - parametry cylindrow itp +18. ulepszone hamulce - napelnianie uderzeniowe, stopnie hamowania +19. poprawione hamulce - wyszczegolnenie cisnienia dla stopni hamowania +20. poprawione hamulce elektropneumatyczne +21. poprawione hamowanie przeciwposlizgowe i odluzniacz +22. dodany model mechanicznego napedu recznego (drezyna) +23. poprawiona szybkosc hamowania pomocniczego i przeciwposlizgowego, odlaczanie silnikow, odlaczanie bocznikow +24. wprowadzone systemy zabezpieczenia: SHP, Czuwak, sygnalizacja kabinowa (nie dzialaja w DebugMode). +25. poprawiona predkosc propagacji fali cisnienia (normalizacja przez kwadrat dlugosci) //to jest zdeka liniowe +26. uwzgledniona masa ladunku, przesuniecie w/m toru ruchu +27. lampy/sygnaly przednie/tylne +28. wprowadzona pozycja odciecia hamulca (yB: tja, ale oerlikona....) +29. rozne poprawki: slizganie, wykolejanie itp +30. model silnika spalinowego z przekladnia mechaniczna +31. otwieranie drzwi, sprezarka, przetwornica +32. wylaczanie obliczen dla nieruchomych wagonow +33. Zbudowany model rozdzielacza powietrza roznych systemow +34. Poprawiona pozycja napelniania uderzeniowego i hamulec EP +35. Dodane baterie akumulatorow (KURS90) +36. Hamowanie elektrodynamiczne w ET42 i poprawione w EP09 +37. jednokierunkowosc walu kulakowego w EZT (nie do konca) +38. wal kulakowy w ET40 +39. poprawiona blokada nastawnika w ET40 +... +*) + + +interface uses mctools,sysutils,hamulce,Oerlikon_ESt; + +CONST + Go=true; + Hold=false; {dla CheckLocomotiveParameters} + ResArraySize=64; {dla silnikow elektrycznych} + MotorParametersArraySize=10; + maxcc=4; {max. ilosc odbierakow pradu} + LocalBrakePosNo=10; {ilosc nastaw hamulca pomocniczego} + MainBrakeMaxPos=10; {max. ilosc nastaw hamulca zasadniczego} + ManualBrakePosNo=20; {ilosc nastaw hamulca recznego} + + {uszkodzenia toru} + dtrack_railwear=2; + dtrack_freerail=4; + dtrack_thinrail=8; + dtrack_railbend=16; + dtrack_plants=32; + dtrack_nomove=64; + dtrack_norail=128; + + {uszkodzenia taboru} + dtrain_thinwheel=1; {dla lokomotyw} + dtrain_loadshift=1; {dla wagonow} + dtrain_wheelwear=2; + dtrain_bearing=4; + dtrain_coupling=8; + dtrain_ventilator=16; {dla lokomotywy el.} + dtrain_loaddamage=16; {dla wagonow} + dtrain_engine=32; {dla lokomotyw} + dtrain_loaddestroyed=32;{dla wagonow} + dtrain_axle=64; + dtrain_out=128; {wykolejenie} + + {wagi prawdopodobienstwa dla funkcji FuzzyLogic} + p_elengproblem = 0.01; + p_elengdamage = 0.1; + p_coupldmg = 0.02; + p_derail=0.001; + p_accn=0.1; + p_slippdmg=0.001; + + {typ sprzegu} + ctrain_virtual=0; //gdy pojazdy na tym samym torze się widzą wzajemnie + ctrain_coupler=1; //sprzeg fizyczny + ctrain_pneumatic=2; //przewody hamulcowe + ctrain_controll=4; //przewody sterujące (ukrotnienie) + ctrain_power=8; //przewody zasilające (WN) + ctrain_passenger=16; //mostek przejściowy + ctrain_scndpneumatic=32; //przewody 8 atm (żółte; zasilanie powietrzem) + ctrain_heating=64; //przewody ogrzewania WN + ctrain_depot=128; //nie rozłączalny podczas zwykłych manewrów (międzyczłonowy), we wpisie wartość ujemna + + {typ hamulca elektrodynamicznego} + dbrake_none=0; + dbrake_passive=1; + dbrake_switch=2; + dbrake_reversal=4; + dbrake_automatic=8; + + {status czuwaka/SHP} + //hunter-091012: rozdzielenie alarmow, dodanie testu czuwaka + s_waiting=1; //działa + s_aware=2; //czuwak miga + s_active=4; //SHP świeci + s_CAalarm=8; //buczy + s_SHPalarm=16; //buczy + s_CAebrake=32; //hamuje + s_SHPebrake=64; //hamuje + s_CAtest=128; + + {dzwieki} + sound_none=0; + sound_loud=1; + sound_couplerstretch=2; + sound_bufferclamp=4; + sound_bufferbump=8; + sound_relay=16; + sound_manyrelay=32; + sound_brakeacc=64; + + PhysicActivationFlag: boolean=false; + + //szczególne typy pojazdów (inna obsługa) dla zmiennej TrainType + //zamienione na flagi bitowe, aby szybko wybierać grupę (np. EZT+SZT) + dt_Default=0; + dt_EZT=1; + dt_ET41=2; + dt_ET42=4; + dt_PseudoDiesel=8; + dt_ET22=$10; //używane od Megapacka + dt_SN61=$20; //nie używane w warunkach, ale ustawiane z CHK + dt_EP05=$40; + dt_ET40=$80; + dt_181=$100; + +//stałe dla asynchronów + eimc_s_dfic=0; + eimc_s_dfmax=1; + eimc_s_p=2; + eimc_s_cfu=3; + eimc_s_cim=4; + eimc_s_icif=5; + eimc_f_Uzmax=7; + eimc_f_Uzh=8; + eimc_f_DU=9; + eimc_f_I0=10; + eimc_f_cfu=11; + eimc_p_F0=13; + eimc_p_a1=14; + eimc_p_Pmax=15; + eimc_p_Fh=16; + eimc_p_Ph=17; + eimc_p_Vh0=18; + eimc_p_Vh1=19; + eimc_p_Imax=20; + +//zmienne dla asynchronów + eimv_FMAXMAX=0; + eimv_Fmax=1; + eimv_ks=2; + eimv_df=3; + eimv_fp=4; + eimv_U=5; + eimv_pole=6; + eimv_Ic=7; + eimv_If=8; + eimv_M=9; + eimv_Fr=10; + eimv_Ipoj=11; + eimv_Pm=12; + eimv_Pe=13; + eimv_eta=14; + eimv_fkr=15; + eimv_Uzsmax=16; + eimv_Pmax=17; + eimv_Fzad=18; + eimv_Imax=19; + + +TYPE + {ogolne} + TLocation = record + X,Y,Z: real; {lokacja} + end; + TRotation = record + Rx,Ry,Rz: real; {rotacja} + end; + TDimension= record + W,L,H: real; {wymiary} + end; + + TCommand = record + Command: string; {komenda} + Value1,Value2: real; {argumenty komendy} + Location: TLocation; + end; + + {tory} + TTrackShape= record {ksztalt odcinka - promien, dlugosc, nachylenie, przechylka} + R, Len, dHtrack, dHrail: real; + end; + + TTrackParam= record {parametry odcinka - szerokosc, tarcie statyczne, kategoria, obciazalnosc w t/os, uszkodzenia} + Width, friction: real; + CategoryFlag, QualityFlag, DamageFlag: byte; + Velmax:real; {dla uzytku maszynisty w ai_driver} + end; + TTractionParam= record + TractionVoltage: real; {napiecie} + TractionFreq: real; {czestotliwosc} + TractionMaxCurrent: real; {obciazalnosc} + TractionResistivity: real; {rezystancja styku} + end; + {powyzsze parametry zwiazane sa z torem po ktorym aktualnie pojazd jedzie} + + {typy hamulcow zespolonych} + TBrakeSystem = (Individual, Pneumatic, ElectroPneumatic); + {podtypy hamulcow zespolonych} + TBrakeSubSystem = (ss_None, ss_W, ss_K, ss_KK, ss_Hik, ss_ESt, ss_KE, ss_LSt, ss_MT, ss_Dako); + TBrakeValve = (NoValve, W, W_Lu_VI, W_Lu_L, W_Lu_XR, K, Kg, Kp, Kss, Kkg, Kkp, Kks, Hikg1, Hikss, Hikp1, KE, SW, EStED, NESt3, ESt3, LSt, ESt4, ESt3AL2, EP1, EP2, M483, CV1_L_TR, CV1, CV1_R, Other); + TBrakeHandle = (NoHandle, West, FV4a, M394, M254, FVel1, FVel6, D2, Knorr, FD1, BS2, testH, St113); + {typy hamulcow indywidualnych} + TLocalBrake = (NoBrake, ManualBrake, PneumaticBrake, HydraulicBrake); + + TBrakeDelayTable= array[1..4] of real; + {dla osob/towar: opoznienie hamowania/odhamowania} + + TBrakePressure= record + PipePressureVal: real; + BrakePressureVal: real; + FlowSpeedVal: real; + BrakeType: TBrakeSystem; + end; + TBrakePressureTable= array[-2..MainBrakeMaxPos] of TBrakePressure; + + {typy napedow} + TEngineTypes = (None, Dumb, WheelsDriven, ElectricSeriesMotor, ElectricInductionMotor, DieselEngine, SteamEngine, DieselElectric); + {postac dostarczanej energii} + TPowerType = (NoPower, BioPower, MechPower, ElectricPower, SteamPower); + {rodzaj paliwa} + TFuelType = (Undefined, Coal, Oil); + {rodzaj rusztu} + TGrateType = record + FuelType: TFuelType; + GrateSurface: real; + FuelTransportSpeed: real; + IgnitionTemperature: real; + MaxTemperature: real; + end; + {rodzaj kotla} + TBoilerType = record + BoilerVolume: real; + BoilerHeatSurface: real; + SuperHeaterSurface: real; + MaxWaterVolume,MinWaterVolume: real; + MaxPressure: real; + end; + {rodzaj odbieraka pradu} + TCurrentCollector = record + CollectorsNo: longint; //musi być tu, bo inaczej się kopie + MinH,MaxH: real; //zakres ruchu pantografu, nigdzie nie używany + CSW: real; //szerokość części roboczej (styku) ślizgacza + MinV,MaxV: real; //minimalne i maksymalne akceptowane napięcie + InsetV: real; //minimalne napięcie wymagane do załączenia + MinPress: real; //minimalne ciśnienie do załączenia WS + MaxPress: real; //maksymalne ciśnienie za reduktorem + end; + {typy źródeł mocy} + TPowerSource = (NotDefined, InternalSource, Transducer, Generator, Accumulator, CurrentCollector, PowerCable, Heater); + {parametry źródeł mocy} + TPowerParameters = record + MaxVoltage: real; + MaxCurrent: real; + IntR: real; + case SourceType: TPowerSource of + NotDefined,InternalSource : (PowerType: TPowerType); + Transducer : (InputVoltage: real); + Generator : (GeneratorEngine: TEngineTypes); + Accumulator: (RAccumulator:record MaxCapacity:real; RechargeSource:TPowerSource end); + CurrentCollector: (CollectorParameters: TCurrentCollector); + PowerCable : (RPowerCable:record PowerTrans:TPowerType; SteamPressure:real end); + Heater : (RHeater:record Grate:TGrateType; Boiler:TBoilerType end); + end; + + {dla lokomotyw elektrycznych:} + TScheme= record + Relay: byte; {numer pozycji rozruchu samoczynnego} + R: real; {opornik rozruchowy} {dla dizla napelnienie} + Bn,Mn:byte; {ilosc galezi i silnikow w galezi} {dla dizla Mn: czy luz czy nie} + AutoSwitch: boolean; {czy dana pozycja nastawniana jest recznie czy autom.} + ScndAct: byte; {jesli ma bocznik w nastawniku, to ktory bocznik na ktorej pozycji} + end; + TSchemeTable = array[0..ResArraySize] of TScheme; {tablica rezystorow rozr.} + TDEScheme= record + RPM: real; {obroty diesla} + GenPower: real; {moc maksymalna} + Umax: real; {napiecie maksymalne} + Imax: real; {prad maksymalny} + end; + TDESchemeTable = array[0..32] of TDEScheme; {tablica rezystorow rozr.} + TShuntScheme = record + Umin: real; + Umax: real; + Pmin: real; + Pmax: real; + end; + TShuntSchemeTable = array[0..32] of TShuntScheme; + TMPTRelay = record {lista przekaznikow bocznikowania} + Iup: real; + Idown: real; + end; + TMPTRelayTable = array[0..7] of TMPTRelay; + + TMotorParameters = record + mfi,mIsat,mfi0:real; // aproksymacja M(I) silnika} {dla dizla mIsat=przekladnia biegu + fi,Isat,fi0: real; // aproksymacja E(n)=fi*n} {dla dizla fi, mfi: predkosci przelozenia biegu <-> + AutoSwitch: boolean; + end; + + TSecuritySystem= record + SystemType:byte; {0: brak, 1: czuwak aktywny, 2: SHP/sygnalizacja kabinowa} + AwareDelay:real; //czas powtarzania czuwaka + AwareMinSpeed:real; //minimalna prędkość załączenia czuwaka, normalnie 10% Vmax + SoundSignalDelay,EmergencyBrakeDelay:real; + Status: byte; {0: wylaczony, 1: wlaczony, 2: czuwak, 4: shp, 8: alarm, 16: hamowanie awaryjne} + //SystemTimer, SystemSoundTimer, SystemBrakeTimer: real; + SystemTimer, SystemSoundCATimer, SystemSoundSHPTimer, SystemBrakeCATimer, SystemBrakeSHPTimer, SystemBrakeCATestTimer: real; //hunter-091012 + VelocityAllowed, NextVelocityAllowed: integer; {predkosc pokazywana przez sygnalizacje kabinowa} + RadioStop:boolean; //czy jest RadioStop + end; + + //Ra: to oddzielnie, bo się kompilatorowi miesza + TTransmision= + record //liczba zebow przekladni} + NToothM, NToothW : byte; + Ratio: real; {NToothW/NToothM} + end; + + {sprzegi} + TCouplerType=(NoCoupler,Articulated,Bare,Chain,Screw,Automatic); + //Ra: T_MoverParameters jako klasa jest już wskaźnikiem na poziomie Pascala + //P_MoverParameters=^T_MoverParameters + T_MoverParameters=class; + TCoupling = record + {parametry} + SpringKB,SpringKC,beta:real; {stala sprezystosci zderzaka/sprzegu, %tlumiennosci } + DmaxB,FmaxB,DmaxC,FmaxC: real; {tolerancja scisku/rozciagania, sila rozerwania} + CouplerType: TCouplerType; {typ sprzegu} + {zmienne} + CouplingFlag : byte; {0 - wirtualnie, 1 - sprzegi, 2 - pneumatycznie, 4 - sterowanie, 8 - kabel mocy} + AllowedFlag : Integer; //Ra: znaczenie jak wyżej, maska dostępnych + Render: boolean; {ABu: czy rysowac jak zaczepiony sprzeg} + CoupleDist: real; {ABu: optymalizacja - liczenie odleglosci raz na klatkę, bez iteracji} + Connected: T_MoverParameters; {co jest podlaczone} + ConnectedNr: byte; //Ra: od której strony podłączony do (Connected): 0=przód, 1=tył + CForce: real; {sila z jaka dzialal} + Dist: real; {strzalka ugiecia zderzaków} + CheckCollision: boolean; {czy sprawdzac sile czy pedy} + end; + + //TCouplers= array[0..1] of TCoupling; + //TCouplerNr= array[0..1] of byte; //ABu: nr sprzegu z ktorym polaczony; Ra: wrzucić do TCoupling + + {----------------------------------------------} + {glowny obiekt} + T_MoverParameters = class(TObject) //Ra: dodana kreska w celu zrobienia wrappera + dMoveLen:real; + filename:string; + {---opis lokomotywy, wagonu itp} + {--opis serii--} + CategoryFlag: byte; {1 - pociag, 2 - samochod, 4 - statek, 8 - samolot} + {--sekcja stalych typowych parametrow} + TypeName: string; {nazwa serii/typu} + //TrainType: string; {typ: EZT/elektrowoz - Winger 040304} + TrainType: integer; {Ra: powinno być szybciej niż string} + EngineType: TEngineTypes; {typ napedu} + EnginePowerSource: TPowerParameters; {zrodlo mocy dla silnikow} + SystemPowerSource: TPowerParameters; {zrodlo mocy dla systemow sterowania/przetwornic/sprezarek} + HeatingPowerSource: TPowerParameters; {zrodlo mocy dla ogrzewania} + AlterHeatPowerSource: TPowerParameters; {alternatywne zrodlo mocy dla ogrzewania} + LightPowerSource: TPowerParameters; {zrodlo mocy dla oswietlenia} + AlterLightPowerSource: TPowerParameters;{alternatywne mocy dla oswietlenia} + Vmax,Mass,Power: real; {max. predkosc kontrukcyjna, masa wlasna, moc} + Mred: real; {Ra: zredukowane masy wirujące; potrzebne do obliczeń hamowania} + TotalMass:real; {wyliczane przez ComputeMass} + HeatingPower, LightPower: real; {moc pobierana na ogrzewanie/oswietlenie} + BatteryVoltage: real; {Winger - baterie w elektrykach} + Battery: boolean; {Czy sa zalavzone baterie} + EpFuse: boolean; {Czy sa zalavzone baterie} + Signalling: boolean; {Czy jest zalaczona sygnalizacja hamowania ostatniego wagonu} + DoorSignalling: boolean; {Czy jest zalaczona sygnalizacja blokady drzwi} + Radio: boolean; {Czy jest zalaczony radiotelefon} + NominalBatteryVoltage: real; {Winger - baterie w elektrykach} + Dim: TDimension; {wymiary} + Cx: real; {wsp. op. aerodyn.} + Floor: real; //poziom podłogi dla ładunków + WheelDiameter : real; {srednica kol napednych} + WheelDiameterL : real; //Ra: srednica kol tocznych przednich + WheelDiameterT : real; //Ra: srednica kol tocznych tylnych + TrackW: real; {nominalna szerokosc toru [m]} + AxleInertialMoment: real; {moment bezwladnosci zestawu kolowego} + AxleArangement : string; {uklad osi np. Bo'Bo' albo 1'C} + NPoweredAxles : byte; {ilosc osi napednych liczona z powyzszego} + NAxles : byte; {ilosc wszystkich osi j.w.} + BearingType: byte; {lozyska: 0 - slizgowe, 1 - toczne} + ADist, BDist: real; {odlegosc osi oraz czopow skretu} + {hamulce:} + NBpA : byte; {ilosc el. ciernych na os: 0 1 2 lub 4} + SandCapacity: integer; {zasobnik piasku [kg]} + BrakeSystem: TBrakeSystem;{rodzaj hamulca zespolonego} + BrakeSubsystem: TBrakeSubsystem; + BrakeValve: TBrakeValve; + BrakeHandle: TBrakeHandle; + BrakeLocHandle: TBrakeHandle; + MBPM: real; {masa najwiekszego cisnienia} + + Hamulec: TBrake; + Handle: THandle; + LocHandle: THandle; + Pipe, Pipe2: TReservoir; + + LocalBrake: TLocalBrake; {rodzaj hamulca indywidualnego} + BrakePressureTable: TBrakePressureTable; {wyszczegolnienie cisnien w rurze} + BrakePressureActual: TBrakePressure; //wartości ważone dla aktualnej pozycji kranu + ASBType: byte; {0: brak hamulca przeciwposlizgowego, 1: reczny, 2: automat} + TurboTest: byte; + MaxBrakeForce: real; {maksymalna sila nacisku hamulca} + MaxBrakePress: array[0..4] of real; //pomocniczy, proz, sred, lad, pp + P2FTrans: real; + TrackBrakeForce: real; {sila nacisku hamulca szynowego} + BrakeMethod: byte; {flaga rodzaju hamulca} + {max. cisnienie w cyl. ham., stala proporcjonalnosci p-K} + HighPipePress,LowPipePress,DeltaPipePress: real; + {max. i min. robocze cisnienie w przewodzie glownym oraz roznica miedzy nimi} + CntrlPipePress: real; //ciśnienie z zbiorniku sterującym + BrakeVolume, BrakeVVolume, VeselVolume: real; + {pojemnosc powietrza w ukladzie hamulcowym, w ukladzie glownej sprezarki [m^3] } + BrakeCylNo: integer; {ilosc cylindrow ham.} + BrakeCylRadius, BrakeCylDist: real; + BrakeCylMult: array[0..2] of real; + LoadFlag: byte; + {promien cylindra, skok cylindra, przekladnia hamulcowa} + BrakeCylSpring: real; {suma nacisku sprezyn powrotnych, kN} + BrakeSlckAdj: real; {opor nastawiacza skoku tloka, kN} + BrakeRigEff: real; {sprawnosc przekladni dzwigniowej} + RapidMult: real; {przelozenie rapidu} + BrakeValveSize: integer; + BrakeValveParams: string; + Spg: real; + MinCompressor,MaxCompressor,CompressorSpeed:real; + {cisnienie wlaczania, zalaczania sprezarki, wydajnosc sprezarki} + BrakeDelay: TBrakeDelayTable; {opoznienie hamowania/odhamowania t/o} + BrakeCtrlPosNo:byte; {ilosc pozycji hamulca} + {nastawniki:} + MainCtrlPosNo: byte; {ilosc pozycji nastawnika} + ScndCtrlPosNo: byte; + ScndInMain: boolean; {zaleznosc bocznika od nastawnika} + MBrake: boolean; {Czy jest hamulec reczny} + SecuritySystem: TSecuritySystem; + + {-sekcja parametrow dla lokomotywy elektrycznej} + RList: TSchemeTable; {lista rezystorow rozruchowych i polaczen silnikow, dla dizla: napelnienia} + RlistSize: integer; + MotorParam: array[0..MotorParametersArraySize] of TMotorParameters; + {rozne parametry silnika przy bocznikowaniach} + {dla lokomotywy spalinowej z przekladnia mechaniczna: przelozenia biegow} + Transmision : TTransmision; + // record {liczba zebow przekladni} + // NToothM, NToothW : byte; + // Ratio: real; {NToothW/NToothM} + // end; + NominalVoltage: real; {nominalne napiecie silnika} + WindingRes : real; + u: real; //wspolczynnik tarcia yB wywalic!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!! + CircuitRes : real; {rezystancje silnika i obwodu} + IminLo,IminHi: integer; {prady przelacznika automatycznego rozruchu, uzywane tez przez ai_driver} + ImaxLo,ImaxHi: integer; {maksymalny prad niskiego i wysokiego rozruchu} + nmax: real; {maksymalna dop. ilosc obrotow /s} + InitialCtrlDelay, {ile sek. opoznienia po wl. silnika} + CtrlDelay: real; { -//- -//- miedzy kolejnymi poz.} + CtrlDownDelay: real; { -//- -//- przy schodzeniu z poz.} {hunter-101012} + FastSerialCircuit: byte;{0 - po kolei zamyka styczniki az do osiagniecia szeregowej, 1 - natychmiastowe wejscie na szeregowa} {hunter-111012} + AutoRelayType: byte; {0 -brak, 1 - jest, 2 - opcja} + CoupledCtrl: boolean; {czy mainctrl i scndctrl sa sprzezone} + //CouplerNr: TCouplerNr; {ABu: nr sprzegu podlaczonego w drugim obiekcie} + IsCoupled: boolean; {czy jest sprzezony ale jedzie z tylu} + DynamicBrakeType: byte; {patrz dbrake_*} + RVentType: byte; {0 - brak, 1 - jest, 2 - automatycznie wlaczany} + RVentnmax: real; {maks. obroty wentylatorow oporow rozruchowych} + RVentCutOff: real; {rezystancja wylaczania wentylatorow dla RVentType=2} + CompressorPower: integer; {0: bezp. z obwodow silnika, 1: z przetwornicy, reczne, 2: w przetwornicy, stale, 5: z silnikowego} + SmallCompressorPower: integer; {Winger ZROBIC} + + {-sekcja parametrow dla lokomotywy spalinowej z przekladnia mechaniczna} + dizel_Mmax, dizel_nMmax, dizel_Mnmax, dizel_nmax, dizel_nominalfill: real; + {parametry aproksymacji silnika spalinowego} + dizel_Mstand: real; {moment oporow ruchu silnika dla enrot=0} +{ dizel_auto_min, dizel_auto_max: real; {predkosc obrotowa przelaczania automatycznej skrzyni biegow} + dizel_nmax_cutoff: real; {predkosc obrotowa zadzialania ogranicznika predkosci} + dizel_nmin: real; {najmniejsza dopuszczalna predkosc obrotowa} + dizel_minVelfullengage: real; {najmniejsza predkosc przy jezdzie ze sprzeglem bez poslizgu} + dizel_AIM: real; {moment bezwladnosci walu itp} + dizel_engageDia, dizel_engageMaxForce, dizel_engagefriction: real; {parametry sprzegla} + + {- dla lokomotyw spalinowo-elektrycznych -} + AnPos: real; // pozycja sterowania dokladnego (analogowego) + AnalogCtrl: boolean; // + AnMainCtrl: boolean; // + ShuntModeAllow: boolean; + ShuntMode: boolean; + + Flat: boolean; + Vhyp: real; + DElist: TDESchemeTable; + Vadd: real; + MPTRelay: TMPTRelayTable; + RelayType: byte; + SST: TShuntSchemeTable; + PowerCorRatio: real; //Wspolczynnik korekcyjny + + + {- dla uproszczonego modelu silnika (dumb) oraz dla drezyny} + Ftmax:real; + + {- dla lokomotyw z silnikami indukcyjnymi -} + eimc: array [0..20] of real; + + {-dla wagonow} + MaxLoad: longint; {masa w T lub ilosc w sztukach - ladownosc} + LoadAccepted, LoadQuantity: string; {co moze byc zaladowane, jednostki miary} + OverLoadFactor: real; {ile razy moze byc przekroczona ladownosc} + LoadSpeed,UnLoadSpeed: real;{szybkosc na- i rozladunku jednostki/s} + DoorOpenCtrl,DoorCloseCtrl: byte; {0: przez pasazera, 1: przez maszyniste, 2: samoczynne (zamykanie)} + DoorStayOpen: real; {jak dlugo otwarte w przypadku DoorCloseCtrl=2} + DoorClosureWarning: boolean; {czy jest ostrzeganie przed zamknieciem} + DoorOpenSpeed, DoorCloseSpeed: real; {predkosc otwierania i zamykania w j.u. } + DoorMaxShiftL,DoorMaxShiftR: real;{szerokosc otwarcia lub kat} + DoorOpenMethod: byte; {sposob otwarcia - 1: przesuwne, 2: obrotowe, 3: trójelementowe} + ScndS: boolean; {Czy jest bocznikowanie na szeregowej} + + {--sekcja zmiennych} + {--opis konkretnego egzemplarza taboru} + Loc: TLocation; //pozycja pojazdów do wyznaczenia odległości pomiędzy sprzęgami + Rot: TRotation; + Name: string; {nazwa wlasna} + Couplers: array[0..1] of TCoupling; //urzadzenia zderzno-sprzegowe, polaczenia miedzy wagonami + HVCouplers: array[0..1] of array[0..1] of real; //przewod WN + ScanCounter: integer; {pomocnicze do skanowania sprzegow} + EventFlag: boolean; {!o true jesli cos nietypowego sie wydarzy} + SoundFlag: byte; {!o patrz stale sound_ } + DistCounter: real; {! licznik kilometrow } + V: real; //predkosc w [m/s] względem sprzęgów (dodania gdy jedzie w stronę 0) + Vel: real; //moduł prędkości w [km/h], używany przez AI + AccS: real; //efektywne przyspieszenie styczne w [m/s^2] (wszystkie siły) + AccN: real; //przyspieszenie normalne w [m/s^2] + AccV: real; + nrot: real; + {! rotacja kol [obr/s]} + EnginePower: real; {! chwilowa moc silnikow} + dL, Fb, Ff : real; {przesuniecie, sila hamowania i tarcia} + FTrain,FStand: real; {! sila pociagowa i oporow ruchu} + FTotal: real; {! calkowita sila dzialajaca na pojazd} + UnitBrakeForce: real; {!s siła hamowania przypadająca na jeden element} + Ntotal: real; {!s siła nacisku klockow} + SlippingWheels,SandDose: boolean; {! poslizg kol, sypanie piasku} + Sand: real; {ilosc piasku} + BrakeSlippingTimer:real; {pomocnicza zmienna do wylaczania przeciwposlizgu} + dpBrake,dpPipe,dpMainValve,dpLocalValve: real; + {! przyrosty cisnienia w kroku czasowym} + ScndPipePress: real; {cisnienie w przewodzie zasilajacym} + BrakePress:real; {!o cisnienie w cylindrach hamulcowych} + LocBrakePress:real; {!o cisnienie w cylindrach hamulcowych z pomocniczego} + PipeBrakePress:real; {!o cisnienie w cylindrach hamulcowych z przewodu} + PipePress: real; {!o cisnienie w przewodzie glownym} + EqvtPipePress: real; {!o cisnienie w przewodzie glownym skladu} + Volume: real; {objetosc spr. powietrza w zbiorniku hamulca} + CompressedVolume:real; {objetosc spr. powietrza w ukl. zasilania} + PantVolume:real; {objetosc spr. powietrza w ukl. pantografu} + Compressor: real; {! cisnienie w ukladzie zasilajacym} + CompressorFlag: boolean; {!o czy wlaczona sprezarka} + PantCompFlag: boolean; {!o czy wlaczona sprezarka pantografow} + CompressorAllow: boolean; {! zezwolenie na uruchomienie sprezarki NBMX} + ConverterFlag: boolean; {! czy wlaczona przetwornica NBMX} + ConverterAllow: boolean; {zezwolenie na prace przetwornicy NBMX} + BrakeCtrlPos:integer; {nastawa hamulca zespolonego} + BrakeCtrlPosR:real; {nastawa hamulca zespolonego - plynna dla FV4a} + BrakeCtrlPos2:real; {nastawa hamulca zespolonego - kapturek dla FV4a} + LocalBrakePos:byte; {nastawa hamulca indywidualnego} + ManualBrakePos:byte; {nastawa hamulca recznego} + LocalBrakePosA: real; + BrakeStatus: byte; {0 - odham, 1 - ham., 2 - uszk., 4 - odluzniacz, 8 - antyposlizg, 16 - uzyte EP, 32 - pozycja R, 64 - powrot z R} + EmergencyBrakeFlag: boolean; {hamowanie nagle} + BrakeDelayFlag: byte; {nastawa opoznienia ham. osob/towar/posp/exp 0/1/2/4} + BrakeDelays: byte; {nastawy mozliwe do uzyskania} + DynamicBrakeFlag: boolean; {czy wlaczony hamulec elektrodymiczny} +// NapUdWsp: integer; + LimPipePress: real; {stabilizator cisnienia} + ActFlowSpeed: real; {szybkosc stabilizatora} + + + DamageFlag: byte; //kombinacja bitowa stalych dtrain_* } + DerailReason: byte; //przyczyna wykolejenia + + //EndSignalsFlag: byte; {ABu 060205: zmiany - koncowki: 1/16 - swiatla prz/tyl, 2/31 - blachy prz/tyl} + //HeadSignalsFlag: byte; {ABu 060205: zmiany - swiatla: 1/2/4 - przod, 16/32/63 - tyl} + CommandIn: TCommand; + {komenda przekazywana przez PutCommand} + {i wykonywana przez RunInternalCommand} + CommandOut: string; {komenda przekazywana przez ExternalCommand} + CommandLast: string; //Ra: ostatnio wykonana komenda do podglądu + ValueOut: real; {argument komendy która ma byc przekazana na zewnatrz} + + RunningShape:TTrackShape;{geometria toru po ktorym jedzie pojazd} + RunningTrack:TTrackParam;{parametry toru po ktorym jedzie pojazd} + OffsetTrackH, OffsetTrackV: real; {przesuniecie poz. i pion. w/m osi toru} + + {-zmienne dla lokomotyw} + Mains: boolean; {polozenie glownego wylacznika} + MainCtrlPos: byte; {polozenie glownego nastawnika} + ScndCtrlPos: byte; {polozenie dodatkowego nastawnika} + ActiveDir: integer; //czy lok. jest wlaczona i w ktorym kierunku: + //względem wybranej kabiny: -1 - do tylu, +1 - do przodu, 0 - wylaczona + CabNo: integer; //numer kabiny, z której jest sterowanie: 1 lub -1; w przeciwnym razie brak sterowania - rozrzad + DirAbsolute: integer; //zadany kierunek jazdy względem sprzęgów (1=w strone 0,-1=w stronę 1) + ActiveCab: integer; //numer kabiny, w ktorej jest obsada (zwykle jedna na skład) + LastSwitchingTime: real; {czas ostatniego przelaczania czegos} + //WarningSignal: byte; {0: nie trabi, 1,2: trabi} + DepartureSignal: boolean; {sygnal odjazdu} + InsideConsist: boolean; + {-zmienne dla lokomotywy elektrycznej} + RunningTraction:TTractionParam;{parametry sieci trakcyjnej najblizej lokomotywy} + enrot, Im, Itot,IHeating,ITraction, TotalCurrent, Mm, Mw, Fw, Ft: real; + {ilosc obrotow, prad silnika i calkowity, momenty, sily napedne} + //Ra: Im jest ujemny, jeśli lok jedzie w stronę sprzęgu 1 + //a ujemne powinien być przy odwróconej polaryzacji sieci... + //w wielu miejscach jest używane abs(Im) + Imin,Imax: integer; {prad przelaczania automatycznego rozruchu, prad bezpiecznika} + Voltage: real; {aktualne napiecie sieci zasilajacej} + MainCtrlActualPos: byte; {wskaznik RList} + ScndCtrlActualPos: byte; {wskaznik MotorParam} + DelayCtrlFlag: boolean; //czy czekanie na 1. pozycji na załączenie? + LastRelayTime: real; {czas ostatniego przelaczania stycznikow} + AutoRelayFlag: boolean; {mozna zmieniac jesli AutoRelayType=2} + FuseFlag: boolean; {!o bezpiecznik nadmiarowy} + ConvOvldFlag: boolean; {! nadmiarowy przetwornicy i ogrzewania} + StLinFlag: boolean; {!o styczniki liniowe} + ResistorsFlag: boolean; {!o jazda rezystorowa} + RventRot: real; {!s obroty wentylatorow rozruchowych} + UnBrake: boolean; {w EZT - nacisniete odhamowywanie} + PantPress: real; {Cisnienie w zbiornikach pantografow} + s_CAtestebrake: boolean; //hunter-091012: zmienna dla testu ca + + + {-zmienne dla lokomotywy spalinowej z przekladnia mechaniczna} + dizel_fill: real; {napelnienie} + dizel_engagestate: real; {sprzeglo skrzyni biegow: 0 - luz, 1 - wlaczone, 0.5 - wlaczone 50% (z poslizgiem)} + dizel_engage: real; {sprzeglo skrzyni biegow: aktualny docisk} + dizel_automaticgearstatus: real; {0 - bez zmiany, -1 zmiana na nizszy +1 zmiana na wyzszy} + dizel_enginestart: boolean; {czy trwa rozruch silnika} + dizel_engagedeltaomega: real; {roznica predkosci katowych tarcz sprzegla} + + {- zmienne dla lokomotyw z silnikami indukcyjnymi -} + eimv: array [0..20] of real; + + {-zmienne dla drezyny} + PulseForce :real; {przylozona sila} + PulseForceTimer: real; + PulseForceCount: integer; + + {dla drezyny, silnika spalinowego i parowego} + eAngle: real; + + {-dla wagonow} + Load: longint; {masa w T lub ilosc w sztukach - zaladowane} + LoadType: string; {co jest zaladowane} + LoadStatus: byte; //+1=trwa rozladunek,+2=trwa zaladunek,+4=zakończono,0=zaktualizowany model + LastLoadChangeTime: real; //raz (roz)ładowania + + DoorBlocked: boolean; //Czy jest blokada drzwi + DoorLeftOpened: boolean; //stan drzwi + DoorRightOpened: boolean; + PantFrontUp: boolean; //stan patykow 'Winger 160204 + PantRearUp: boolean; + PantFrontSP: boolean; //dzwiek patykow 'Winger 010304 + PantRearSP: boolean; + PantFrontStart: integer; //stan patykow 'Winger 160204 + PantRearStart: integer; + PantFrontVolt: real; //pantograf pod napieciem? 'Winger 160404 + PantRearVolt: real; + PantSwitchType: string; + ConvSwitchType: string; + + Heating: boolean; //ogrzewanie 'Winger 020304 + DoubleTr: integer; //trakcja ukrotniona - przedni pojazd 'Winger 160304 + + PhysicActivation: boolean; + + {ABu: stale dla wyznaczania sil (i nie tylko) po optymalizacji} + FrictConst1: real; + FrictConst2s: real; + FrictConst2d: real; + TotalMassxg : real; {TotalMass*g} + + + {--funkcje} + + + function GetTrainsetVoltage: real; + function Physic_ReActivation: boolean; + +{ function BrakeRatio: real; } + function LocalBrakeRatio: real; + function ManualBrakeRatio: real; + function PipeRatio: real; {ile napelniac} + function RealPipeRatio: real; {jak szybko} + function BrakeVP: real; + function DynamicBrakeSwitch(Switch:boolean):boolean; + + {! przesylanie komend sterujacych} + function SendCtrlBroadcast(CtrlCommand:string; ctrlvalue:real):boolean; + function SendCtrlToNext(CtrlCommand:string;ctrlvalue,dir:real):boolean; + function CabActivisation:boolean; + function CabDeactivisation:boolean; + + {! funkcje zwiekszajace/zmniejszajace nastawniki} + {! glowny nastawnik:} + function IncMainCtrl(CtrlSpeed:integer): boolean; + function DecMainCtrl(CtrlSpeed:integer): boolean; + {! pomocniczy nastawnik:} + function IncScndCtrl(CtrlSpeed:integer): boolean; + function DecScndCtrl(CtrlSpeed:integer): boolean; + + function AddPulseForce(Multipler:integer): boolean; {dla drezyny} + + {wlacza/wylacza sypanie piasku} + function SandDoseOn : boolean; + + {! zbijanie czuwaka/SHP} + function SecuritySystemReset:boolean; + {test czuwaka/SHP} + procedure SecuritySystemCheck(dt:real); + function BatterySwitch(State:boolean):boolean; + function EpFuseSwitch(State:boolean):boolean; + + {! stopnie hamowania - hamulec zasadniczy} + function IncBrakeLevelOld:boolean; + function DecBrakeLevelOld:boolean; + {! stopnie hamowania - hamulec pomocniczy} + function IncLocalBrakeLevel(CtrlSpeed:byte):boolean; + function DecLocalBrakeLevel(CtrlSpeed:byte):boolean; + {! ABu 010205: - skrajne polozenia ham. pomocniczego} + function IncLocalBrakeLevelFAST:boolean; + function DecLocalBrakeLevelFAST:boolean; + + {! stopnie hamowania - hamulec reczny} + function IncManualBrakeLevel(CtrlSpeed:byte):boolean; + function DecManualBrakeLevel(CtrlSpeed:byte):boolean; + + {! hamulec bezpieczenstwa} + function EmergencyBrakeSwitch(Switch:boolean): boolean; + {hamulec przeciwposlizgowy} + function AntiSlippingBrake: boolean; + {odluzniacz} + function BrakeReleaser(state: byte):boolean; + function SwitchEPBrake(state: byte):boolean; + + {! reczny wlacznik urzadzen antyposlizgowych} + function AntiSlippingButton: boolean; + + {funkcje dla ukladow pneumatycznych} + function IncBrakePress(var brake:real;PressLimit,dp:real):boolean; + function DecBrakePress(var brake:real;PressLimit,dp:real):boolean; + function BrakeDelaySwitch(BDS:byte): boolean; {! przelaczanie nastawy opoznienia} + function IncBrakeMult(): boolean; {przelaczanie prozny/ladowny} + function DecBrakeMult(): boolean; + {pomocnicze funkcje dla ukladow pneumatycznych} + procedure UpdateBrakePressure(dt: real); + procedure UpdatePipePressure(dt:real); + procedure CompressorCheck(dt:real); {wlacza, wylacza kompresor, laduje zbiornik} + procedure UpdateScndPipePressure(dt:real); + //procedure UpdateBatteryVoltage(dt:real); + function GetDVc(dt:real):real; + + {! funkcje laczace/rozlaczajace sprzegi} + //Ra: przeniesione do C++ + + {funkcje obliczajace sily} + procedure ComputeConstans; //ABu: wczesniejsze wyznaczenie stalych dla liczenia sil + //procedure SetCoupleDist; //ABu: wyznaczenie odleglosci miedzy wagonami + function ComputeMass:real; + function Adhesive(staticfriction:real): real; + function TractionForce(dt:real):real; + function FrictionForce(R:real;TDamage:byte):real; + function BrakeForce(Track:TTrackParam):real; + function CouplerForce(CouplerN:byte; dt:real):real; + procedure CollisionDetect(CouplerN:byte; dt:real); + + {obrot kol uwzgledniajacy poslizg} + function ComputeRotatingWheel(WForce,dt,n:real): real; + + {komendy} + function SetInternalCommand(NewCommand:string; NewValue1,NewValue2:real):boolean; + {! do wpisywania komend przez zewnetrzne zdarzenia} + function GetExternalCommand(var Command:string):real; + function RunCommand(command:string; CValue1,CValue2:real):boolean; + function RunInternalCommand:boolean; + procedure PutCommand(NewCommand:string; NewValue1,NewValue2:real; NewLocation:TLocation); + + {--funkcje dla lokomotyw} + {! kierunek ruchu} + //function DirectionForward: boolean; + function DirectionBackward: boolean; + {! wylacznik glowny} + function MainSwitch(State:boolean): boolean; +// procedure SwitchMainKey; + {! zmiana kabiny i resetowanie ustawien} + //function ChangeCab(direction:integer): boolean; + + {! wl/wyl przetwornicy} + function ConverterSwitch(State:boolean):boolean; + {! wl/wyl sprezarki} + function CompressorSwitch(State:boolean):boolean; +{ function SmallCompressorSwitch(State:boolean):boolean;} + {procedure ConverterCheck; ->C++} + + {-funkcje typowe dla lokomotywy elektrycznej} + {! wlaczanie bezpiecznika nadmiarowego} + function FuseOn: boolean; + function FuseFlagCheck: boolean; {sprawdzanei flagi nadmiarowego} + procedure FuseOff; {wywalanie bezpiecznika nadmiarowego} + {!o pokazuje bezwgl. wartosc pradu na wybranym amperomierzu} + function ShowCurrent(AmpN:byte): integer; + {!o pokazuje bezwgl. wartosc obrotow na obrotomierzu jednego z 3 pojazdow} + {function ShowEngineRotation(VehN:byte): integer; //Ra 2014-06: przeniesione do C++} + {funkcje uzalezniajace sile pociagowa od predkosci: v2n, n2r, current, momentum} + function v2n:real; + function current(n,U:real): real; + function Momentum(I:real): real; + function MomentumF(I, Iw :real; SCP:byte ): real; + {! odlaczanie uszkodzonych silnikow} + function CutOffEngine: boolean; + {! przelacznik pradu wysokiego rozruchu} + function MaxCurrentSwitch(State:boolean):boolean; + {sprawdzanie kontrolki rezystorow rozrochowych NBMX} + function ResistorsFlagCheck: boolean; + + {! przelacznik pradu automatycznego rozruchu} + function MinCurrentSwitch(State:boolean):boolean; + {! przelacznik automatycznego rozruchu} + function AutoRelaySwitch(State:boolean):boolean; + {symulacja automatycznego rozruchu} + function AutoRelayCheck: boolean; + + {-funkcje typowe dla lokomotywy spalinowej z przekladnia mechaniczna} + function dizel_EngageSwitch(state: real): boolean; + function dizel_EngageChange(dt: real): boolean; + function dizel_AutoGearCheck: boolean; + function dizel_fillcheck(mcp:byte): real; +{ function dizel_rotateengine(Momentum,dt,n,engage:real): real; } + function dizel_Momentum(dizel_fill,n,dt:real): real; + function dizel_Update(dt:real): boolean; + + {-funkcje dla wagonow} + function LoadingDone(LSpeed: real; LoadInit:string):boolean; + + {! WAZNA FUNKCJA - oblicza sile wypadkowa} + procedure ComputeTotalForce(dt: real; dt1: real; FullVer: boolean); + + {! BARDZO WAZNA FUNKCJA - oblicza przesuniecie lokomotywy lub wagonu} + function ComputeMovement(dt:real; dt1:real; Shape:TTrackShape; var Track:TTrackParam; var ElectricTraction:TTractionParam; NewLoc:TLocation; var NewRot:TRotation):real; + {dt powinno byc 10ms lub mniejsze} + {NewRot na wejsciu daje aktualna orientacje pojazdu, na wyjsciu daje dodatkowe wychylenia od tej orientacji} + + {! JESZCZE WAZNIEJSZA FUNKCJA - ABu: - mocno zoptymalizowanana ComputeMovement} + function FastComputeMovement(dt:real; Shape:TTrackShape; var Track:TTrackParam; NewLoc:TLocation; var NewRot:TRotation):real; //Shape:TTrackShape; var Track:TTrackParam; var ElectricTraction:TTractionParam; NewLoc:TLocation; var NewRot:TRotation):real; + {dt powinno byc 10ms lub mniejsze} + {NewRot na wejsciu daje aktualna orientacje pojazdu, na wyjsciu daje dodatkowe wychylenia od tej orientacji} + + + {dla samochodow} + function ChangeOffsetH(DeltaOffset:real): boolean; + + {! procedury I/O} + constructor Init(//LocInitial:TLocation; RotInitial:TRotation; + VelInitial:real; TypeNameInit, NameInit: string; LoadInitial:longint; LoadTypeInitial: string; Cab:integer); + {wywolac najpierw to} + function LoadChkFile(chkpath:string):Boolean; {potem zaladowac z pliku} + function CheckLocomotiveParameters(ReadyFlag:boolean;Dir:longint): boolean; {a nastepnie sprawdzic} + function EngineDescription(what:integer): string; {opis stanu lokomotywy} + + {obsluga drzwi} + function DoorLeft(State: Boolean): Boolean; {obsluga dzwi lewych} + function DoorRight(State: Boolean): Boolean; + function DoorBlockedFlag: Boolean; //czy blokada drzwi jest aktualnie załączona + + {obsluga pantografow - Winger 160204} + function PantFront(State: Boolean): Boolean; + function PantRear(State: Boolean): Boolean; + {ogrzewanie - Winger 020304} + //function Heating(State: Boolean): Boolean; + + //private + //function TotalMass:real; +{ function GetFTotal(CN:byte): real; + function GetMass(CN:byte): real; + procedure SendAVL(AccS,AccN,V,dL:real; CN:byte); } + end; {ufff} + +function Distance(Loc1,Loc2: TLocation; Dim1,Dim2:TDimension) : real; + +{----------------------------------------------------------------} +{========================McZapkie'2001===========================} +{----------------------------------------------------------------} +implementation + +const + Steel2Steel_friction=0.15; {tarcie statyczne} + g=9.81; {przyspieszenie ziemskie} + SandSpeed=0.1; {ile kg/s} + RVentSpeed=0.4; {rozpedzanie sie wentylatora obr/s^2} + RVentMinI=50.0; {przy jakim pradzie sie wylaczaja} + CouplerTune:real=0.1; {skalowanie tlumiennosci} + Pirazy2=Pi*2; + +{------------------------------------------} +{funkcje pomocnicze} + +function s2NPW(s:string):byte; +{wylicza ilosc osi napednych ze stringu opisujacego uklad osi} +{np. 2'A' daje 1, Bo'Bo' daje 4, 1'E daje 5 itp} +const A=ord('A')-1; +var k,NPW:byte; +begin + NPW:=0; + for k:=1 to Length(s) do + begin + if s[k] in ['A'..'Z'] then + NPW:=NPW+Ord(s[k])-A; + end; + s2NPW:=NPW; +end; + +function s2NNW(s:string):byte; +{wylicza ilosc osi nienapednych ze stringu opisujacego uklad osi} +{np. 2'A' daje 2, Bo'Bo' daje 0, 1'E daje 1 itp} +const Zero=ord('0'); +var k,NNW:byte; +begin + NNW:=0; + for k:=1 to Length(s) do + begin + if s[k] in ['1'..'9'] then + NNW:=NNW+Ord(s[k])-Zero; + end; + s2NNW:=NNW; +end; + +function Distance(Loc1,Loc2:TLocation;Dim1,Dim2:TDimension):real; +//zwraca odległość pomiędzy pojazdami (Loc1) i (Loc2) z uwzględnieneim ich długości (kule!) +var Dist:real; +begin + Dist:=SQRT(SQR(Loc2.x-Loc1.x)+SQR(Loc1.y-Loc2.y)); + Distance:=Dist-Dim2.L/2.0-Dim1.L/2.0; +{ Distance:=Hypot(Loc2.x-Loc1.x,Loc2.y-Loc1.y)-(Dim2.L+Dim1.L)/2; } +end; + +{oblicza zmiane predkosci i przyrost pedu wskutek kolizji} +function ComputeCollision(var v1,v2:real; m1,m2,beta:real;vc:boolean):real; +var CCP,w1,w2,m1m2:real; +begin + if (v1Coupler2) then DirPatch:=1 + else DirPatch:=-1; +end; + + +function DirF(CouplerN:byte): real; +begin + case CouplerN of + 0: DirF:=-1; + 1: DirF:=1 + else DirF:=0; + end; +end; + +{yB: funkcje dodatkowe hamulcowe} + +function PR(p1,p2:real): real; +var ph,pl:real; +begin + ph:=Max0R(p1,p2)+0.1; + pl:=p1+p2-ph+0.2; + PR:=(ph-pl)/(1.13*ph-pl); +end; + +function SPR(ph,pl:real): real; +begin + SPR:=0.674*(ph-pl)/(1.13*ph-pl+0.013); +end; + +{---------rozwiniecie deklaracji metod obiektu T_MoverParameters--------} + +function T_MoverParameters.GetTrainsetVoltage: real; +//ABu: funkcja zwracajaca napiecie dla calego skladu, przydatna dla EZT +var volt: real; +begin + volt:=0.0; + if Couplers[1].Connected<>nil then + if (TestFlag(Couplers[1].CouplingFlag,ctrain_power)) then //czy jest sprzęg WN + begin //najczęściej silnikowy jest z tyłu + if (Couplers[1].Connected.PantFrontVolt<>0.0) then + volt:=Couplers[1].Connected.PantFrontVolt + else + if (Couplers[1].Connected.PantRearVolt<>0.0) then + volt:=Couplers[1].Connected.PantRearVolt; + end; + if (volt=0.0) then + if Couplers[0].Connected<>nil then + if (TestFlag(Couplers[0].CouplingFlag,ctrain_power)) then //czy jest sprzęg WN + begin + if (Couplers[0].Connected.PantFrontVolt<>0.0) then + volt:=Couplers[0].Connected.PantFrontVolt + else + if (Couplers[0].Connected.PantRearVolt<>0.0) then + volt:=Couplers[0].Connected.PantRearVolt; + end; + GetTrainsetVoltage:=volt; +end; + + + +function T_MoverParameters.Physic_ReActivation: boolean; + begin + if PhysicActivation then + Physic_Reactivation:=false + else + begin + PhysicActivation:=true; + LastSwitchingTime:=0; + Physic_Reactivation:=true; + end; + end; + + +{stosunek obecnego nastawienia sily hamowania do maksymalnej nastawy} +{ +function T_MoverParameters.BrakeRatio: real; + begin + if BrakeCtrlPosNo>0 then + begin + if BrakeCtrlPos<0 then + BrakeRatio:=1 + else + BrakeRatio:=1-BrakeCtrlPos/BrakeCtrlPosNo + end + else + BrakeRatio:=0; + end; +} + +function T_MoverParameters.LocalBrakeRatio: real; +var LBR:real; +begin + if LocalBrakePosNo>0 then + LBR:=LocalBrakePos/LocalBrakePosNo + else + LBR:=0; +// if TestFlag(BrakeStatus,b_antislip) then +// LBR:=Max0R(LBR,PipeRatio)+0.4; + LocalBrakeRatio:=LBR; +end; + +function T_MoverParameters.ManualBrakeRatio: real; +var MBR:real; +begin + if ManualBrakePosNo>0 then + MBR:=ManualBrakePos/ManualBrakePosNo + else + MBR:=0; + ManualBrakeRatio:=MBR; +end; + +function T_MoverParameters.PipeRatio: real; +var pr:real; +begin + if DeltaPipePress>0 then + if (false) then //SPKS!! + begin + if (3*PipePress)>(HighPipePress+LowPipePress+LowPipePress) then + pr:=(HighPipePress-Min0R(HighPipePress,PipePress))/(DeltaPipePress*4.0/3.0) + else + pr:=(HighPipePress-1.0/3.0*DeltaPipePress-Max0R(LowPipePress,PipePress))/(DeltaPipePress*2.0/3.0); +// if (not TestFlag(BrakeStatus,b_Ractive)) and (BrakeMethod and 1 = 0) and TestFlag(BrakeDelays,bdelay_R) and (Power<1) and (BrakeCtrlPos<1) then +// pr:=Min0R(0.5,pr); + //if (Compressor>0.5) then + // pr:=pr*1.333; //dziwny rapid wywalamy + end + else + pr:=(HighPipePress-Max0R(LowPipePress,Min0R(HighPipePress,PipePress)))/DeltaPipePress + else + pr:=0; + PipeRatio:=pr; +end; + +function T_MoverParameters.RealPipeRatio: real; +var rpp:real; +begin + if DeltaPipePress>0 then + rpp:=(CntrlPipePress-PipePress)/(DeltaPipePress) + else + rpp:=0; + RealPipeRatio:=rpp; +end; + +function T_MoverParameters.BrakeVP: real; +begin + if BrakeVVolume>0 then + BrakeVP:=Volume/(10.0*BrakeVVolume) + else BrakeVP:=0; +end; + +{reczne przelaczanie hamulca elektrodynamicznego} +function T_MoverParameters.DynamicBrakeSwitch(Switch:boolean):boolean; +var b:byte; +begin + if (DynamicBrakeType=dbrake_switch) and (MainCtrlPos=0) then + begin + DynamicBrakeFlag:=Switch; + DynamicBrakeSwitch:=true; + for b:=0 to 1 do + with Couplers[b] do + if TestFlag(CouplingFlag,ctrain_controll) then + Connected.DynamicBrakeFlag:=DynamicBrakeFlag; + {end; + if (DynamicBrakeType=dbrake_passive) and (TrainType=dt_ET42) then + begin + DynamicBrakeFlag:=false; + DynamicBrakeSwitch:=false;} + end + else + DynamicBrakeSwitch:=false; +end; + + +function T_MoverParameters.SendCtrlBroadcast(CtrlCommand:string;ctrlvalue:real):boolean; +var b:byte; OK:boolean; +begin + OK:=((CtrlCommand<>CommandIn.Command) and (ctrlvalue<>CommandIn.Value1)); + if OK then + for b:=0 to 1 do + with Couplers[b] do + if TestFlag(CouplingFlag,ctrain_controll) then + if Connected.SetInternalCommand(CtrlCommand,ctrlvalue,DirF(b)) then + OK:=Connected.RunInternalCommand or OK; + SendCtrlBroadcast:=OK; +end; + + +function T_MoverParameters.SendCtrlToNext(CtrlCommand:string;ctrlvalue,dir:real):boolean; +//wysłanie komendy w kierunku dir (1=przod,-1=tył) do kolejnego pojazdu (jednego) +var + OK:Boolean; + d:Integer; //numer sprzęgu w kierunku którego wysyłamy +begin +//Ra: był problem z propagacją, jeśli w składzie jest pojazd wstawiony odwrotnie +//Ra: problem jest również, jeśli AI będzie na końcu składu + OK:=(dir<>0); // and Mains; + d:=(1+Sign(dir)) div 2; //dir=-1=>d=0, dir=1=>d=1 - wysyłanie tylko w tył + if OK then //musi być wybrana niezerowa kabina + with Couplers[d] do //własny sprzęg od strony (d) + if TestFlag(CouplingFlag,ctrain_controll) then + if ConnectedNr<>d then //jeśli ten nastpęny jest zgodny z aktualnym + begin + if Connected.SetInternalCommand(CtrlCommand,ctrlvalue,dir) then + OK:=Connected.RunInternalCommand and OK; //tu jest rekurencja + end + else //jeśli następny jest ustawiony przeciwnie, zmieniamy kierunek + if Connected.SetInternalCommand(CtrlCommand,ctrlvalue,-dir) then + OK:=Connected.RunInternalCommand and OK; //tu jest rekurencja + SendCtrlToNext:=OK; +end; + +function T_MoverParameters.CabActivisation:boolean; +//załączenie rozrządu +var OK:boolean; +begin + OK:=(CabNo=0); //numer kabiny, z której jest sterowanie + if (OK) then + begin + CabNo:=ActiveCab; //sterowanie jest z kabiny z obsadą + DirAbsolute:=ActiveDir*CabNo; + SendCtrlToNext('CabActivisation',1,CabNo); + end; + CabActivisation:=OK; +end; + +function T_MoverParameters.CabDeactivisation:boolean; +//wyłączenie rozrządu +var OK:boolean; +begin + OK:=(CabNo=ActiveCab); //o ile obsada jest w kabinie ze sterowaniem + if (OK) then + begin + CabNo:=0; + DirAbsolute:=ActiveDir*CabNo; + DepartureSignal:=false; //nie buczeć z nieaktywnej kabiny + SendCtrlToNext('CabActivisation',0,ActiveCab); //CabNo==0! + end; + CabDeactivisation:=OK; +end; + +{ +procedure MainCtrlBroadcast(Couplers:TCouplers; MainCtrlPos,MainCtrlActualPos:byte); +var b:byte; +begin + + for b:=0 to 1 do + with Couplers[b] do + if TestFlag(CouplingFlag,ctrain_controll) then + begin + Connected^.MainCtrlPos:=MainCtrlPos; + Connected^.MainCtrlActualPos:=MainCtrlActualPos; + end; +poprawic to!!! +end; + +procedure ScndCtrlBroadcast(Couplers:TCouplers; ScndCtrlPos,ScndCtrlActualPos:byte); +var b:byte; +begin + for b:=0 to 1 do + with Couplers[b] do + if TestFlag(CouplingFlag,ctrain_controll) then + begin + Connected^.ScndCtrlPos:=ScndCtrlPos; + Connected^.ScndCtrlActualPos:=ScndCtrlActualPos; + end; +end; +} + +{funkcje zwiekszajace/zmniejszajace nastawniki} + +function T_MoverParameters.IncMainCtrl(CtrlSpeed:integer): boolean; +var //b:byte; + OK:boolean; +begin + OK:=false; + if (MainCtrlPosNo>0) and (CabNo<>0) then + begin + if MainCtrlPosdt_ET22) or ((TrainType=dt_ET22) and (ScndCtrlPos=0)) then //w ET22 nie da się kręcić nastawnikiem przy włączonym boczniku + case EngineType of + None, Dumb, DieselElectric, ElectricInductionMotor: + if ((CtrlSpeed=1) and (TrainType<>dt_EZT)) or ((CtrlSpeed=1) and (TrainType=dt_EZT)and (activedir<>0)) then + begin //w EZT nie da się załączyć pozycji bez ustawienia kierunku + inc(MainCtrlPos); + OK:=true; + end + else + if ((CtrlSpeed>1) and (TrainType<>dt_EZT)) or ((CtrlSpeed>1) and (TrainType=dt_EZT)and (activedir<>0)) then + OK:=IncMainCtrl(1) and IncMainCtrl(CtrlSpeed-1); + ElectricSeriesMotor: + if (CtrlSpeed=1) and (ActiveDir<>0) then + begin + inc(MainCtrlPos); + OK:=true; + if Imax=ImaxHi then + if RList[MainCtrlPos].Bn>1 then + begin + if(TrainType=dt_ET42)then + begin + dec(MainCtrlPos); + OK:=false; + end; + if MaxCurrentSwitch(false) then + SetFlag(SoundFlag,sound_relay); {wylaczanie wysokiego rozruchu} + { if (EngineType=ElectricSeriesMotor) and (MainCtrlPos=1) then + MainCtrlActualPos:=1; + } + end; + if (CtrlSpeed=1) and (ActiveDir=-1) and (RList[MainCtrlPos].Bn>1) and (TrainType<>dt_pseudodiesel) then + begin //blokada wejścia na równoległą podczas jazdy do tyłu + dec(MainCtrlPos); + OK:=false; + end; + {if (TrainType='et40') then + if Abs(Im)>IminHi then + begin + dec(MainCtrlPos); //Blokada nastawnika po przekroczeniu minimalnego pradu + OK:=false; + end; } + if(DynamicBrakeFlag)then + if(TrainType=dt_ET42)then + if MainCtrlPos>20 then + begin + dec(MainCtrlPos); + OK:=false; + end; + end + else + if (CtrlSpeed>1) and (ActiveDir<>0) {and (ScndCtrlPos=0)} and (TrainType<>dt_ET40) then + begin //szybkie przejście na bezoporową + while (RList[MainCtrlPos].R>0) and IncMainCtrl(1) do ; + //OK:=true ; {takie chamskie, potem poprawie} <-Ra: kto miał to poprawić i po co? + if ActiveDir=-1 then + while (RList[MainCtrlPos].Bn>1) and IncMainCtrl(1) do + dec(MainCtrlPos); + OK:=false; + {if (TrainType=dt_ET40) then + while Abs (Im)>IminHi do + dec(MainCtrlPos); + OK:=false ; } + if(DynamicBrakeFlag)then + if(TrainType=dt_ET42)then + while(MainCtrlPos>20)do + dec(MainCtrlPos); + OK:=false; + end; + DieselEngine: + if CtrlSpeed=1 then + begin + inc(MainCtrlPos); + OK:=true; + if MainCtrlPos>0 then + CompressorAllow:=true + else + CompressorAllow:=false; + end + else + if CtrlSpeed>1 then + begin + while (MainCtrlPos=MainCtrlPosNo + if (CoupledCtrl) then //wspólny wał nastawnika jazdy i bocznikowania + begin + if (ScndCtrlPos false + begin + inc(ScndCtrlPos); + OK:=true; + end + else OK:=false; + end; + if OK then + begin + {OK:=}SendCtrlToNext('MainCtrl',MainCtrlPos,CabNo); {???} + {OK:=}SendCtrlToNext('ScndCtrl',ScndCtrlPos,CabNo); + end; + end + else {nie ma sterowania} + OK:=false; + //if OK then LastRelayTime:=0; + + //hunter-101012: poprawka + //poprzedni warunek byl niezbyt dobry, bo przez to przy trzymaniu + + //styczniki tkwily na tej samej pozycji (LastRelayTime byl caly czas 0 i rosl + //po puszczeniu plusa) + + if OK then + begin + if (DelayCtrlFlag) then + begin + if (LastRelayTime>=InitialCtrlDelay)and(MainCtrlPos=1) then + LastRelayTime:=0 + end + else if (LastRelayTime>CtrlDelay) then + LastRelayTime:=0; + end; + IncMainCtrl:=OK; +end; + + +function T_MoverParameters.DecMainCtrl(CtrlSpeed:integer): boolean; +var //b:byte; + OK:boolean; +begin + OK:=false; + if (MainCtrlPosNo>0) and (CabNo<>0) then + begin + if MainCtrlPos>0 then + begin + if ((TrainType<>dt_ET22) or (ScndCtrlPos=0)) then //Ra: ET22 blokuje nastawnik przy boczniku + begin + if CoupledCtrl and (ScndCtrlPos>0) then + begin + dec(ScndCtrlPos); {wspolny wal} + OK:=true; + end + else + case EngineType of + None, Dumb, DieselElectric, ElectricInductionMotor: + if ((CtrlSpeed=1) and {(ScndCtrlPos=0) and} (EngineType<>DieselElectric)) or ((CtrlSpeed=1)and(EngineType=DieselElectric))then + begin + dec(MainCtrlPos); + OK:=true; + end + else + if CtrlSpeed>1 then + OK:=DecMainCtrl(1) and DecMainCtrl(2); //CtrlSpeed-1); + ElectricSeriesMotor: + if (CtrlSpeed=1) {and (ScndCtrlPos=0)} then + begin + dec(MainCtrlPos); +// if (MainCtrlPos=0) and (ScndCtrlPos=0) and (TrainType<>dt_ET40)and(TrainType<>dt_EP05) then +// StLinFlag:=false; +// if (MainCtrlPos=0) and (TrainType<>dt_ET40) and (TrainType<>dt_EP05) then +// MainCtrlActualPos:=0; //yBARC: co to tutaj robi? ;) + OK:=true; + end + else + if (CtrlSpeed>1) {and (ScndCtrlPos=0)} then + begin + OK:=true; + if (RList[MainCtrlPos].R=0) + then DecMainCtrl(1); + while (RList[MainCtrlPos].R>0) and DecMainCtrl(1) do ; {takie chamskie, potem poprawie} + end; + DieselEngine: + if CtrlSpeed=1 then + begin + dec(MainCtrlPos); + OK:=true; + end + else + if CtrlSpeed>1 then + begin + while (MainCtrlPos>0) or (RList[MainCtrlPos].Mn>0) do + DecMainCtrl(1); + OK:=true; + end; + end; + end; + end + else + if EngineType=WheelsDriven then + OK:=AddPulseForce(-CtrlSpeed) + else + OK:=false; + if OK then + begin + {OK:=}SendCtrlToNext('MainCtrl',MainCtrlPos,CabNo); {hmmmm...???!!!} + {OK:=}SendCtrlToNext('ScndCtrl',ScndCtrlPos,CabNo); + end; + end + else + OK:=false; + //if OK then LastRelayTime:=0; + //hunter-101012: poprawka + if OK then + begin + if DelayCtrlFlag then + begin + if (LastRelayTime>=InitialCtrlDelay) then + LastRelayTime:=0; + end + else if (LastRelayTime>CtrlDownDelay) then + LastRelayTime:=0; + end; + DecMainCtrl:=OK; +end; + +function T_MoverParameters.IncScndCtrl(CtrlSpeed:integer): boolean; +var //b:byte; + OK:boolean; +begin + if (MainCtrlPos=0)and(CabNo<>0)and(TrainType=dt_ET42)and(ScndCtrlPos=0)and(DynamicBrakeFlag)then + begin + OK:=DynamicBrakeSwitch(false); + end + else + if (ScndCtrlPosNo>0) and (CabNo<>0) and not ((TrainType=dt_ET42)and((Imax=ImaxHi)or((DynamicBrakeFlag)and(MainCtrlPos>0)))) then + begin +{ if (RList[MainCtrlPos].R=0) and (MainCtrlPos>0) and (ScndCtrlPosDieselElectric) or (not AutoRelayFlag)) then + begin + if CtrlSpeed=1 then + begin + inc(ScndCtrlPos); + end + else + if CtrlSpeed>1 then + begin + ScndCtrlPos:=ScndCtrlPosNo; {takie chamskie, potem poprawie} + end; + OK:=true; + end + else {nie mozna zmienic} + OK:=false; + if OK then + begin + {OK:=}SendCtrlToNext('MainCtrl',MainCtrlPos,CabNo); {???} + {OK:=}SendCtrlToNext('ScndCtrl',ScndCtrlPos,CabNo); + end; + end + else {nie ma sterowania} + OK:=false; + //if OK then LastRelayTime:=0; + //hunter-101012: poprawka + if OK then + if (LastRelayTime>CtrlDelay) then + LastRelayTime:=0; + + IncScndCtrl:=OK; +end; + +function T_MoverParameters.DecScndCtrl(CtrlSpeed:integer): boolean; +var //b:byte; + OK:boolean; +begin + if (MainCtrlPos=0)and(CabNo<>0)and(TrainType=dt_ET42)and(ScndCtrlPos=0)and not(DynamicBrakeFlag)and(CtrlSpeed=1)then + begin + //Ra: AI wywołuje z CtrlSpeed=2 albo gdy ScndCtrlPos>0 + OK:=DynamicBrakeSwitch(true); + end + else + if (ScndCtrlPosNo>0) and (CabNo<>0) then + begin + if (ScndCtrlPos>0) and (not CoupledCtrl) and ((EngineType<>DieselElectric) or (not AutoRelayFlag))then + begin + if CtrlSpeed=1 then + begin + dec(ScndCtrlPos); + end + else + if CtrlSpeed>1 then + begin + ScndCtrlPos:=0; {takie chamskie, potem poprawie} + end; + OK:=true; + end + else + OK:=false; + if OK then + begin + {OK:=}SendCtrlToNext('MainCtrl',MainCtrlPos,CabNo); {???} + {OK:=}SendCtrlToNext('ScndCtrl',ScndCtrlPos,CabNo); + end; + end + else + OK:=false; + //if OK then LastRelayTime:=0; + //hunter-101012: poprawka + if OK then + if (LastRelayTime>CtrlDownDelay) then + LastRelayTime:=0; + DecScndCtrl:=OK; +end; + + +function T_MoverParameters.DirectionBackward: boolean; +begin + if (ActiveDir=1) and (MainCtrlPos=0) and (TrainType=dt_EZT) then + if MinCurrentSwitch(false) then + begin + DirectionBackward:=true; // + Exit; + end; + if (MainCtrlPosNo>0) and (ActiveDir>-1) and (MainCtrlPos=0) then + begin + if EngineType=WheelsDriven then + dec(CabNo); +{ else} + dec(ActiveDir); + DirAbsolute:=ActiveDir*CabNo; + if (DirAbsolute<>0) then + if (Battery) then //jeśli bateria jest już załączona + BatterySwitch(true); //to w ten oto durny sposób aktywuje się CA/SHP + DirectionBackward:=true; + SendCtrltoNext('Direction',ActiveDir,CabNo); + end + else + DirectionBackward:=false; +end; + +function T_MoverParameters.MainSwitch(State:boolean): boolean; +begin + MainSwitch:=false; //Ra: przeniesione z końca + if ((Mains<>State) and (MainCtrlPosNo>0)) then + begin + if (State=false) or ({(MainCtrlPos=0) and} (ScndCtrlPos=0) and (ConvOvldFlag=false) and (LastSwitchingTime>CtrlDelay) and not TestFlag(DamageFlag,dtrain_out)) then + begin + if Mains then //jeśli był załączony + SendCtrlToNext('MainSwitch',ord(State),CabNo); //wysłanie wyłączenia do pozostałych? + Mains:=State; + if Mains then //jeśli został załączony + SendCtrlToNext('MainSwitch',ord(State),CabNo); //wyslanie po wlaczeniu albo przed wylaczeniem + MainSwitch:=true; //wartość zwrotna + LastSwitchingTime:=0; + if (EngineType=DieselEngine) and Mains then + begin + dizel_enginestart:=State; + end; + //if (State=false) then //jeśli wyłączony + // begin + //SetFlag(SoundFlag,sound_relay); //hunter-091012: przeniesione do Train.cpp, zeby sie nie zapetlal + // if (SecuritySystem.Status<>12) then + // SecuritySystem.Status:=0; //deaktywacja czuwaka; Ra: a nie baterią? + // end + //else + //if (SecuritySystem.Status<>12) then + // SecuritySystem.Status:=s_waiting; //aktywacja czuwaka + end + end + //else MainSwitch:=false; +end; + +function T_MoverParameters.BatterySwitch(State:boolean):boolean; +begin + //Ra: ukrotnienie załączania baterii jest jakąś fikcją... + if (Battery<>State) then + begin + Battery:=State; + end; + if (Battery=true) then SendCtrlToNext('BatterySwitch',1,CabNo) + else SendCtrlToNext('BatterySwitch',0,CabNo); + BatterySwitch:=true; + if (Battery) and (ActiveCab<>0) {or (TrainType=dt_EZT)} then + SecuritySystem.Status:=SecuritySystem.Status or s_waiting //aktywacja czuwaka + else + SecuritySystem.Status:=0; //wyłączenie czuwaka +end; + +function T_MoverParameters.EpFuseSwitch(State:boolean):boolean; +begin + if (EpFuse<>State) then + begin + EpFuse:=State; + EpFuseSwitch:=true; + end + else + EpFuseSwitch:=false; +// if (EpFuse=true) then SendCtrlToNext('EpFuseSwitch',1,CabNo) +// else SendCtrlToNext('EpFuseSwitch',0,CabNo); +end; + +{wl/wyl przetwornicy} +function T_MoverParameters.ConverterSwitch(State:boolean):boolean; +begin + ConverterSwitch:=false; //Ra: normalnie chyba false? + if (ConverterAllow<>State) then + begin + ConverterAllow:=State; + ConverterSwitch:=true; + if CompressorPower=2 then + CompressorAllow:=ConverterAllow; + end; + if (ConverterAllow=true) then SendCtrlToNext('ConverterSwitch',1,CabNo) + else SendCtrlToNext('ConverterSwitch',0,CabNo) +end; + +{wl/wyl sprezarki} +function T_MoverParameters.CompressorSwitch(State:boolean):boolean; +begin + CompressorSwitch:=false; //Ra: normalnie chyba tak? +// if State=true then +// if ((CompressorPower=2) and (not ConverterAllow)) then +// State:=false; //yB: to juz niepotrzebne + if (CompressorAllow<>State)and(CompressorPower<2)then + begin + CompressorAllow:=State; + CompressorSwitch:=true; + end; + if (CompressorAllow=true) then SendCtrlToNext('CompressorSwitch',1,CabNo) + else SendCtrlToNext('CompressorSwitch',0,CabNo) +end; + +{wl/wyl malej sprezarki} +{function T_MoverParameters.SmallCompressorSwitch(State:boolean):boolean; +begin + if State=true then + if ((SmallCompressorPower=1) then + State:=false; + if (SmallCompressorAllow<>State) then + begin + SmallCompressorAllow:=State; + SmallCompressorSwitch:=true; + end; +end; +} +{sypanie piasku} +function T_MoverParameters.SandDoseOn : boolean; +begin + if (SandCapacity>0) then + begin + SandDoseOn:=true; + if SandDose then + SandDose:=false + else + if Sand>0 then SandDose:=true; + if CabNo<>0 then + SendCtrlToNext('SandDoseOn',1,CabNo); + end + else + SandDoseOn:=false; +end; + +(* +//Ra: to jest do przejrzenia i uporządkowania +function T_MoverParameters.SecuritySystemReset : boolean; +//zbijanie czuwaka/SHP + procedure Reset; + begin + with SecuritySystem do + if not(TestFlag(SystemType,2) and TestFlag(Status,s_active)) then + SecuritySystem.SystemTimer:=0; + SecuritySystem.SystemBrakeTimer:=0; + SecuritySystem.SystemSoundTimer:=0; + SecuritySystem.Status:=s_waiting; //aktywacja czuwaka + SecuritySystem.VelocityAllowed:=-1; + end; + procedure ResetSHP; + begin + SecuritySystem.SystemBrakeTimer:=0; + SecuritySystem.SystemSoundTimer:=0; + SecuritySystem.VelocityAllowed:=-1; + SecuritySystem.Status:=s_waiting; + end; +begin + with SecuritySystem do + begin + if (Status=3) or (Status=2) or (Status=11) or (Status=26)or(Status=27) then + begin + SecuritySystemReset:=true; + if (Status0)) or (Status=28) then {Wlaczone tylko SHP} + { begin + SecuritySystemReset:=true; + if (Status0) and (Status>0) and ((status<>12) or ((status=12) and (activedir<>0))) then + //if (SystemType>0) and (Status>0) then + begin + SecuritySystemReset:=true; + if not (ActiveDir=0) then + if not TestFlag(Status,s_CAebrake) or not TestFlag(Status,s_SHPebrake) then + Reset; + //else + // if EmergencyBrakeSwitch(false) then + // Reset; + end + else + SecuritySystemReset:=false; +// SendCtrlToNext('SecurityReset',0,CabNo); +end; + +{testowanie czuwaka/SHP} +procedure T_MoverParameters.SecuritySystemCheck(dt:real); +begin + with SecuritySystem do + begin + if (SystemType>0) and (Status>0) then + begin + SystemTimer:=SystemTimer+dt; + if TestFlag(Status,s_aware) or TestFlag(Status,s_active) then //jeśli świeci albo miga + SystemSoundTimer:=SystemSoundTimer+dt; + if TestFlag(Status,s_alarm) then //jeśli buczy + SystemBrakeTimer:=SystemBrakeTimer+dt; + if TestFlag(SystemType,1) then + if (SystemTimer>AwareDelay) and (AwareDelay>=0) then {-1 blokuje} + if not SetFlag(Status,s_aware) then {juz wlaczony sygnal swietlny} + if (SystemSoundTimer>SoundSignalDelay) and (SoundSignalDelay>=0) then + if not SetFlag(Status,s_alarm) then {juz wlaczony sygnal dzwiekowy} + if (SystemBrakeTimer>EmergencyBrakeDelay) and (EmergencyBrakeDelay>=0) then + SetFlag(Status,s_ebrake); {przeterminowanie czuwaka, hamowanie awaryjne} + if TestFlag(SystemType,2) and TestFlag(Status,s_active) then + if (Vel>VelocityAllowed) and (VelocityAllowed>=0) then + SetFlag(Status,s_ebrake) + else + if ((SystemSoundTimer>SoundSignalDelay) and (SoundSignalDelay>=0)) or ((Vel>NextVelocityAllowed) and (NextVelocityAllowed>=0)) then + if not SetFlag(Status,s_alarm) then {juz wlaczony sygnal dzwiekowy} + if (SystemBrakeTimer>EmergencyBrakeDelay) and (EmergencyBrakeDelay>=0) then + SetFlag(Status,s_ebrake); + if TestFlag(Status,s_ebrake) then + if not EmergencyBrakeFlag then + EmergencyBrakeSwitch(true); + end; + end; +end; +*) + +//hunter-091012: rozbicie alarmow, dodanie testu czuwaka +function T_MoverParameters.SecuritySystemReset : boolean; +//zbijanie czuwaka/SHP + procedure Reset; + begin + SecuritySystem.SystemTimer:=0; + + if TestFlag(SecuritySystem.Status,s_aware) then + begin + SecuritySystem.SystemBrakeCATimer:=0; + SecuritySystem.SystemSoundCATimer:=0; + SetFlag(SecuritySystem.Status,-s_aware); + SetFlag(SecuritySystem.Status,-s_CAalarm); + SetFlag(SecuritySystem.Status,-s_CAebrake); +// EmergencyBrakeFlag:=false; //YB-HN + SecuritySystem.VelocityAllowed:=-1; + end + else if TestFlag(SecuritySystem.Status,s_active) then + begin + SecuritySystem.SystemBrakeSHPTimer:=0; + SecuritySystem.SystemSoundSHPTimer:=0; + SetFlag(SecuritySystem.Status,-s_active); + SetFlag(SecuritySystem.Status,-s_SHPalarm); + SetFlag(SecuritySystem.Status,-s_SHPebrake); +// EmergencyBrakeFlag:=false; //YB-HN + SecuritySystem.VelocityAllowed:=-1; + end; + end; +begin + with SecuritySystem do + if (SystemType>0) and (Status>0) then + begin + SecuritySystemReset:=true; + if ((TrainType=dt_EZT)or(ActiveDir<>0)) then //Ra 2014-03: w EZT nie trzeba ustawiać kierunku + if not TestFlag(Status,s_CAebrake) or not TestFlag(Status,s_SHPebrake) then + Reset; + //else + // if EmergencyBrakeSwitch(false) then + // Reset; + end + else + SecuritySystemReset:=false; +// SendCtrlToNext('SecurityReset',0,CabNo); +end; + +procedure T_MoverParameters.SecuritySystemCheck(dt:real); +begin +//Ra: z CA/SHP w EZT jest ten problem, że w rozrządczym nie ma kierunku, a w silnikowym nie ma obsady +//poza tym jest zdefiniowany we wszystkich 3 członach EN57 + with SecuritySystem do + begin + if (SystemType>0) and (Status>0) and (Battery) then //Ra: EZT ma teraz czuwak w rozrządczym + begin + //CA + if (Vel>=AwareMinSpeed) then //domyślnie predkość większa od 10% Vmax, albo podanej jawnie w FIZ + begin + SystemTimer:=SystemTimer+dt; + if TestFlag(SystemType,1) and TestFlag(Status,s_aware) then //jeśli świeci albo miga + SystemSoundCATimer:=SystemSoundCATimer+dt; + if TestFlag(SystemType,1) and TestFlag(Status,s_CAalarm) then //jeśli buczy + SystemBrakeCATimer:=SystemBrakeCATimer+dt; + if TestFlag(SystemType,1) then + if (SystemTimer>AwareDelay) and (AwareDelay>=0) then {-1 blokuje} + if not SetFlag(Status,s_aware) then {juz wlaczony sygnal swietlny} + if (SystemSoundCATimer>SoundSignalDelay) and (SoundSignalDelay>=0) then + if not SetFlag(Status,s_CAalarm) then {juz wlaczony sygnal dzwiekowy} + if (SystemBrakeCATimer>EmergencyBrakeDelay) and (EmergencyBrakeDelay>=0) then + SetFlag(Status,s_CAebrake); + + + //SHP + if TestFlag(SystemType,2) and TestFlag(Status,s_active) then //jeśli świeci albo miga + SystemSoundSHPTimer:=SystemSoundSHPTimer+dt; + if TestFlag(SystemType,2) and TestFlag(Status,s_SHPalarm) then //jeśli buczy + SystemBrakeSHPTimer:=SystemBrakeSHPTimer+dt; + if TestFlag(SystemType,2) and TestFlag(Status,s_active) then + if (Vel>VelocityAllowed) and (VelocityAllowed>=0) then + SetFlag(Status,s_SHPebrake) + else + if ((SystemSoundSHPTimer>SoundSignalDelay) and (SoundSignalDelay>=0)) or ((Vel>NextVelocityAllowed) and (NextVelocityAllowed>=0)) then + if not SetFlag(Status,s_SHPalarm) then {juz wlaczony sygnal dzwiekowy} + if (SystemBrakeSHPTimer>EmergencyBrakeDelay) and (EmergencyBrakeDelay>=0) then + SetFlag(Status,s_SHPebrake); + + end; //else SystemTimer:=0; + + //TEST CA + if TestFlag(Status,s_CAtest) then //jeśli świeci albo miga + SystemBrakeCATestTimer:=SystemBrakeCATestTimer+dt; + if TestFlag(SystemType,1) then + if TestFlag(Status,s_CAtest) then {juz wlaczony sygnal swietlny} + if (SystemBrakeCATestTimer>EmergencyBrakeDelay) and (EmergencyBrakeDelay>=0) then + s_CAtestebrake:=true; + + //wdrazanie hamowania naglego +// if TestFlag(Status,s_SHPebrake) or TestFlag(Status,s_CAebrake) or (s_CAtestebrake=true) then +// EmergencyBrakeFlag:=true; //YB-HN + end + else if not (Battery) then + begin //wyłączenie baterii deaktywuje sprzęt + //SecuritySystem.Status:=0; //deaktywacja czuwaka + end; + end; +end; + +{nastawy hamulca} + +function T_MoverParameters.IncBrakeLevelOld:boolean; +//var b:byte; +begin + if (BrakeCtrlPosNo>0) {and (LocalBrakePos=0)} then + begin + if BrakeCtrlPos0); + SendCtrlToNext('BrakeCtrl',BrakeCtrlPos,CabNo); + end + else SendCtrlToNext('BrakeCtrl',-2,CabNo); +// else +// if not TestFlag(BrakeStatus,b_dmg) then +// BrakeStatus:=b_on;} + +//youBy: EP po nowemu + + IncBrakeLevelOld:=true; + if (BrakePressureActual.PipePressureVal<0)and(BrakePressureTable[BrakeCtrlPos-1].PipePressureVal>0) then + LimPipePress:=PipePress; + + if (BrakeSystem=ElectroPneumatic) then + if (BrakeSubSystem<>ss_K) then + begin + if (BrakeCtrlPos*BrakeCtrlPos)=1 then + begin +// SendCtrlToNext('Brake',BrakeCtrlPos,CabNo); +// SetFlag(BrakeStatus,b_epused); + end + else + begin +// SendCtrlToNext('Brake',0,CabNo); +// SetFlag(BrakeStatus,-b_epused); + end; + end; + + end + else + begin + IncBrakeLevelOld:=false; +{ if BrakeSystem=Pneumatic then + EmergencyBrakeSwitch(true); } + end; + end + else + IncBrakeLevelOld:=false; +end; + +function T_MoverParameters.DecBrakeLevelOld:boolean; +//var b:byte; +begin + if (BrakeCtrlPosNo>0) {and (LocalBrakePos=0)} then + begin + if (BrakeCtrlPos>-1-Byte(BrakeHandle=FV4a)) then + begin + dec(BrakeCtrlPos); +// BrakeCtrlPosR:=BrakeCtrlPos; + if EmergencyBrakeFlag then + begin + EmergencyBrakeFlag:=false; {!!!} + SendCtrlToNext('Emergency_brake',0,CabNo); + end; + +//youBy: wywalilem to, jak jest EP, to sa przenoszone sygnaly nt. co ma robic, a nie poszczegolne pozycje; +// wystarczy spojrzec na Knorra i Oerlikona EP w EN57; mogly ze soba wspolapracowac +{ + if (BrakeSystem=ElectroPneumatic) then + if BrakePressureActual.BrakeType=ElectroPneumatic then + begin +// BrakeStatus:=ord(BrakeCtrlPos>0); + SendCtrlToNext('BrakeCtrl',BrakeCtrlPos,CabNo); + end + else SendCtrlToNext('BrakeCtrl',-2,CabNo); +// else} +// if (not TestFlag(BrakeStatus,b_dmg) and (not TestFlag(BrakeStatus,b_release))) then +// BrakeStatus:=b_off; {luzowanie jesli dziala oraz nie byl wlaczony odluzniacz} + +//youBy: EP po nowemu + DecBrakeLevelOld:=true; +// if (BrakePressureTable[BrakeCtrlPos].PipePressureVal<0.0)and(BrakePressureTable[BrakeCtrlPos+1].PipePressureVal>0) then +// LimPipePress:=PipePress; + + if (BrakeSystem=ElectroPneumatic) then + if (BrakeSubSystem<>ss_K) then + begin + if (BrakeCtrlPos*BrakeCtrlPos)=1 then + begin +// SendCtrlToNext('Brake',BrakeCtrlPos,CabNo); +// SetFlag(BrakeStatus,b_epused); + end + else + begin +// SendCtrlToNext('Brake',0,CabNo); +// SetFlag(BrakeStatus,-b_epused); + end; + end; +(* for b:=0 to 1 do {poprawic to!} + with Couplers[b] do + if CouplingFlag and ctrain_controll=ctrain_controll then + Connected^.BrakeCtrlPos:=BrakeCtrlPos; +*) + end + else + DecBrakeLevelOld:=false; + end + else + DecBrakeLevelOld:=false; +end; + +function T_MoverParameters.IncLocalBrakeLevelFAST:boolean; +begin + if (LocalBrakePos0) do + begin + inc(LocalBrakePos); + dec(CtrlSpeed); + end; + IncLocalBrakeLevel:=true; + end + else + IncLocalBrakeLevel:=false; +UnBrake:=true; +end; + +function T_MoverParameters.IncManualBrakeLevel(CtrlSpeed:byte):boolean; +begin + if (ManualBrakePos0) do + begin + inc(ManualBrakePos); + dec(CtrlSpeed); + end; + IncManualBrakeLevel:=true; + end + else + IncManualBrakeLevel:=false; +end; + +function T_MoverParameters.DecLocalBrakeLevelFAST():boolean; +begin + if LocalBrakePos>0 then + begin + LocalBrakePos:=0; + DecLocalBrakeLevelFAST:=true; + end + else + DecLocalBrakeLevelFAST:=false; +UnBrake:=true; +end; + +function T_MoverParameters.DecLocalBrakeLevel(CtrlSpeed:byte):boolean; +begin + if LocalBrakePos>0 then + begin + while (CtrlSpeed>0) and (LocalBrakePos>0) do + begin + dec(LocalBrakePos); + dec(CtrlSpeed); + end; + DecLocalBrakeLevel:=true; + end + else + DecLocalBrakeLevel:=false; +UnBrake:=true; +end; + +function T_MoverParameters.DecManualBrakeLevel(CtrlSpeed:byte):boolean; +begin + if ManualBrakePos>0 then + begin + while (CtrlSpeed>0) and (ManualBrakePos>0) do + begin + dec(ManualBrakePos); + dec(CtrlSpeed); + end; + DecManualBrakeLevel:=true; + end + else + DecManualBrakeLevel:=false; + +end; + +function T_MoverParameters.EmergencyBrakeSwitch(Switch:boolean): boolean; +begin + if (BrakeSystem<>Individual) and (BrakeCtrlPosNo>0) then + begin + if (not EmergencyBrakeFlag) and Switch then + begin + EmergencyBrakeFlag:=Switch; + EmergencyBrakeSwitch:=true; + end + else + begin + if (Abs(V)<0.1) and (Switch=false) then {odblokowanie hamulca bezpieczenistwa tylko po zatrzymaniu} + begin + EmergencyBrakeFlag:=Switch; + EmergencyBrakeSwitch:=true; + end + else + EmergencyBrakeSwitch:=false; + end; + end + else + EmergencyBrakeSwitch:=false; {nie ma hamulca bezpieczenstwa gdy nie ma hamulca zesp.} +end; + +function T_MoverParameters.AntiSlippingBrake: boolean; +begin + AntiSlippingBrake:=false; //Ra: przeniesione z końca + if ASBType=1 then + begin + AntiSlippingBrake:=true; //SPKS!! + Hamulec.ASB(1); + BrakeSlippingTimer:=0; + end +end; + +function T_MoverParameters.AntiSlippingButton: boolean; +var OK:boolean; +begin + OK:=SandDoseOn; + AntiSlippingButton:=(AntiSlippingBrake or OK); +end; + +function T_MoverParameters.BrakeDelaySwitch(BDS:byte): boolean; +begin +// if BrakeCtrlPosNo>0 then + if Hamulec.SetBDF(BDS) then + begin + BrakeDelayFlag:=BDS; + BrakeDelaySwitch:=true; + BrakeStatus:=(BrakeStatus and 191); + //kopowanie nastawy hamulca do kolejnego czlonu - do przemyślenia + if CabNo<>0 then + SendCtrlToNext('BrakeDelay',BrakeDelayFlag,CabNo); + end + else + BrakeDelaySwitch:=false; +end; + +function T_MoverParameters.IncBrakeMult(): boolean; +begin + if (LoadFlag>0) and (MBPM<2) and (LoadFlag<3) then + begin + if (MaxBrakePress[2]>0) and (LoadFlag=1) then + LoadFlag:=2 + else + LoadFlag:=3; + IncBrakeMult:=true; + if BrakeCylMult[2]>0 then BrakeCylMult[0]:=BrakeCylMult[2]; + end + else + IncBrakeMult:=false; +end; + +function T_MoverParameters.DecBrakeMult(): boolean; +begin + if (LoadFlag>1) and (MBPM<2) then + begin + if (MaxBrakePress[2]>0) and (LoadFlag=3) then + LoadFlag:=2 + else + LoadFlag:=1; + DecBrakeMult:=true; + if BrakeCylMult[1]>0 then BrakeCylMult[0]:=BrakeCylMult[1]; + end + else + DecBrakeMult:=false; +end; + +function T_MoverParameters.BrakeReleaser(state: byte): boolean; +var OK:boolean; +begin + Hamulec.Releaser(state); + if CabNo<>0 then //rekurencyjne wysłanie do następnego + OK:=SendCtrlToNext('BrakeReleaser',state,CabNo); + BrakeReleaser:=OK; +end; + +function T_MoverParameters.SwitchEPBrake(state: byte):boolean; +var + OK:boolean; + temp: real; +begin + OK:=false; + if (BrakeHandle = St113) and (ActiveCab<>0) then + begin + if(state>0)then + temp:=(Handle as TSt113).GetCP + else + temp:=0; + Hamulec.SetEPS(temp); + SendCtrlToNext('Brake',temp,CabNo); + end; +// OK:=SetFlag(BrakeStatus,((2*State-1)*b_epused)); +// SendCtrlToNext('Brake',(state*(2*BrakeCtrlPos-1)),CabNo); + SwitchEPBrake:=OK; +end; + +{uklady pneumatyczne} + +function T_MoverParameters.IncBrakePress(var brake:real;PressLimit,dp:real):boolean; +begin +// if (DynamicBrakeType<>dbrake_switch) and (DynamicBrakeType<>dbrake_none) and ((BrakePress>2.0) or (PipePress<3.7{(LowPipePress+0.5)})) then + if (DynamicBrakeType<>dbrake_switch) and (DynamicBrakeType<>dbrake_none) and (BrakePress>2.0) and (TrainType<>dt_EZT) then //yB radzi nie sprawdzać ciśnienia w przewodzie + //hunter-301211: dla EN57 silnikow nie odlaczamy + begin + DynamicBrakeFlag:=true; {uruchamianie hamulca ED albo odlaczanie silnikow} + if (DynamicBrakeType=dbrake_automatic) and (abs(Im)>60) then {nie napelniaj wiecej, jak na EP09} + dp:=0.0; + end; + if brake+dpPressLimit then + begin + brake:=brake-dp; + DecBrakePress:=true; + end + else + begin + DecBrakePress:=false; + brake:=PressLimit; + end; +// if (DynamicBrakeType<>dbrake_switch) and ((BrakePress<0.1) and (PipePress>0.45{(LowPipePress+0.06)})) then + if (DynamicBrakeType<>dbrake_switch) and (BrakePress<0.1) then //yB radzi nie sprawdzać ciśnienia w przewodzie + DynamicBrakeFlag:=false; {wylaczanie hamulca ED i/albo zalaczanie silnikow} +end; + +procedure T_MoverParameters.UpdateBrakePressure(dt:real); +const LBDelay=5.0; {stala czasowa hamulca} +var Rate,Speed,dp,sm:real; +begin + dpLocalValve:=0; + dpBrake:=0; + + BrakePress:=Hamulec.GetBCP; +// BrakePress:=(Hamulec as TEst4).ImplsRes.pa; + Volume:=Hamulec.GetBRP; + +end; {updatebrakepressure} + + +function T_MoverParameters.GetDVc(dt:real):real; +var c:T_MoverParameters;dv1,dv2,dv:real; +begin + dv1:=0; + dv2:=0; +//sprzeg 1 + if Couplers[0].Connected<>nil then + if TestFlag(Couplers[0].CouplingFlag,ctrain_pneumatic) then + begin //*0.85 + c:=Couplers[0].Connected; //skrot //0.08 //e/D * L/D = e/D^2 * L + dv1:=0.5*dt*PF(PipePress,c.PipePress,(Spg)/(1+0.015/Spg*Dim.L)); + if (dv1*dv1>0.00000000000001) then c.Physic_Reactivation; + c.Pipe.Flow(-dv1); + end; +//sprzeg 2 + if Couplers[1].Connected<>nil then + if TestFlag(Couplers[1].CouplingFlag,ctrain_pneumatic) then + begin + c:=Couplers[1].Connected; //skrot + dv2:=0.5*dt*PF(PipePress,c.PipePress,(Spg)/(1+0.015/Spg*Dim.L)); + if (dv2*dv2>0.00000000000001) then c.Physic_Reactivation; + c.Pipe.Flow(-dv2); + end; + if (Couplers[1].Connected<>nil)and(Couplers[0].Connected<>nil) then + if (TestFlag(Couplers[0].CouplingFlag,ctrain_pneumatic))and(TestFlag(Couplers[1].CouplingFlag,ctrain_pneumatic))then + begin + dv:=0.05*dt*PF(Couplers[0].Connected.PipePress,Couplers[1].Connected.PipePress,(Spg*0.85)/(1+0.03*Dim.L))*0; + Couplers[0].Connected.Pipe.Flow(+dv); + Couplers[1].Connected.Pipe.Flow(-dv); + end; +//suma + GetDVc:=dv2+dv1; +end; + +procedure T_MoverParameters.UpdatePipePressure(dt:real); +const LBDelay=100;kL=0.5; +var {b: byte;} dV{,PWSpeed}{,PPP}:real; c: T_MoverParameters; + temp: real; + b: byte; +begin + + PipePress:=Pipe.P; +// PPP:=PipePress; + + dpMainValve:=0; + +if (BrakeCtrlPosNo>1) and (ActiveCab<>0)then +with BrakePressureTable[BrakeCtrlPos] do + begin + dpLocalValve:=LocHandle.GetPF(LocalBrakePos/LocalBrakePosNo, Hamulec.GetBCP, ScndPipePress, dt, 0); + if(BrakeHandle=FV4a)and((PipePress<2.75)and((Hamulec.GetStatus and b_rls)=0))and(BrakeSubsystem=ss_LSt)and(TrainType<>dt_EZT)then + temp:=PipePress+0.00001 + else + temp:=ScndPipePress; + Handle.SetReductor(BrakeCtrlPos2); + + dpMainValve:=Handle.GetPF(BrakeCtrlPosR, PipePress, temp, dt, EqvtPipePress); + if (dpMainValve<0){and(PipePressureVal>0.01)} then {50} + if Compressor>ScndPipePress then + begin + CompressedVolume:=CompressedVolume+dpMainValve/1500; + Pipe2.Flow(dpMainValve/3); + end + else + Pipe2.Flow(dpMainValve); +end; + +// if(EmergencyBrakeFlag)and(BrakeCtrlPosNo=0)then {ulepszony hamulec bezp.} + if(EmergencyBrakeFlag)or TestFlag(SecuritySystem.Status,s_SHPebrake) or TestFlag(SecuritySystem.Status,s_CAebrake) or (s_CAtestebrake=true)then {ulepszony hamulec bezp.} + dpMainValve:=dpMainValve/1+PF(0,PipePress,0.15)*dt; + //0.2*Spg + Pipe.Flow(-dpMainValve); + Pipe.Flow(-(PipePress)*0.001*dt); +// if Heating then +// Pipe.Flow(PF(PipePress,0,d2A(7))*dt); +// if ConverterFlag then +// Pipe.Flow(PF(PipePress,0,d2A(12))*dt); + dpMainValve:=dpMainValve/(Dim.L*Spg*20); + + CntrlPipePress:=Hamulec.GetVRP; //ciśnienie komory wstępnej rozdzielacza + + case BrakeValve of + W: + begin + if (BrakeLocHandle<>NoHandle) then + begin + LocBrakePress:=LocHandle.GetCP; + (Hamulec as TWest).SetLBP(LocBrakePress); + end; + if MBPM<2 then + (Hamulec as TWest).PLC(MaxBrakePress[LoadFlag]) + else + (Hamulec as TWest).PLC(TotalMass); + end; + LSt,EStED: + begin + LocBrakePress:=LocHandle.GetCP; + for b:=0 to 1 do + if((TrainType and (dt_ET41 or dt_ET42))>0)and(Couplers[b].Connected<>nil)then //nie podoba mi się to rozwiązanie, chyba trzeba dodać jakiś wpis do fizyki na to + if((Couplers[b].Connected.TrainType and (dt_ET41 or dt_ET42))>0)and((Couplers[b].CouplingFlag and 36) = 36)then + LocBrakePress:=Max0R(Couplers[b].Connected.LocHandle.GetCP,LocBrakePress); + + if(DynamicBrakeFlag)and(EngineType=ElectricInductionMotor)then + begin + if(Vel>10)then LocBrakePress:=0 else + if(Vel>5)then LocBrakePress:=(10-Vel)/5*LocBrakePress + end; + + (Hamulec as TLSt).SetLBP(LocBrakePress); + end; + CV1_L_TR: + begin + LocBrakePress:=LocHandle.GetCP; + (Hamulec as TCV1L_TR).SetLBP(LocBrakePress); + end; + EP2: (Hamulec as TEStEP2).PLC(TotalMass); + ESt3AL2,NESt3,ESt4,ESt3: + begin + if MBPM<2 then + (Hamulec as TNESt3).PLC(MaxBrakePress[LoadFlag]) + else + (Hamulec as TNESt3).PLC(TotalMass); + LocBrakePress:=LocHandle.GetCP; + (Hamulec as TNESt3).SetLBP(LocBrakePress); + end; + KE: + begin + LocBrakePress:=LocHandle.GetCP; + (Hamulec as TKE).SetLBP(LocBrakePress); + if MBPM<2 then + (Hamulec as TKE).PLC(MaxBrakePress[LoadFlag]) + else + (Hamulec as TKE).PLC(TotalMass); + end; + end; + + if (BrakeHandle = FVel6) and (ActiveCab<>0) then + begin + if (Battery) and (ActiveDir<>0) and (EpFuse) then //tu powinien byc jeszcze bezpiecznik EP i baterie - + temp:=(Handle as TFVel6).GetCP + else + temp:=0; + Hamulec.SetEPS(temp); + SendCtrlToNext('Brake',temp,CabNo); //Ra 2014-11: na tym się wysypuje, ale nie wiem, w jakich warunkach + end; + + Pipe.Act; + PipePress:=Pipe.P; + if (BrakeStatus and 128)=128 then //jesli hamulec wyłączony + temp:=0 //odetnij + else + temp:=1; //połącz + Pipe.Flow(temp*Hamulec.GetPF(temp*PipePress,dt,Vel)+GetDVc(dt)); + + if ASBType=128 then + Hamulec.ASB(Byte(SlippingWheels)); + + dpPipe:=0; + +//yB: jednokrokowe liczenie tego wszystkiego + Pipe.Act; + PipePress:=Pipe.P; + + dpMainValve:=dpMainValve/(100*dt); //normalizacja po czasie do syczenia; + + + if PipePress<-1 then + begin + PipePress:=-1; + Pipe.CreatePress(-1); + Pipe.Act; + end; + + if CompressedVolume<0 then + CompressedVolume:=0; +end; {updatepipepressure} + + +procedure T_MoverParameters.CompressorCheck(dt:real); +begin + //if (CompressorSpeed>0.0) then //ten warunek został sprawdzony przy wywołaniu funkcji + if (VeselVolume>0) then + begin + if MaxCompressor-MinCompressor<0.0001 then + begin +{ if Mains and (MainCtrlPos>1) then} + if CompressorAllow and Mains and (MainCtrlPos>0) then + begin + if (Compressor0) then + CompressedVolume:=CompressedVolume+dt*CompressorSpeed*(2*MaxCompressor-Compressor)/MaxCompressor*(DEList[MainCtrlPos].rpm/DEList[MainCtrlPosNo].rpm) + else + begin + CompressedVolume:=CompressedVolume+dt*CompressorSpeed*(2*MaxCompressor-Compressor)/MaxCompressor; + TotalCurrent:=0.0015*Voltage; //tymczasowo tylko obciążenie sprężarki, tak z 5A na sprężarkę + end + else + begin + CompressedVolume:=CompressedVolume*0.8; + SetFlag(SoundFlag,sound_relay); + SetFlag(SoundFlag,sound_loud); + end; + end; + end + else + begin + if (CompressorFlag) then //jeśli sprężarka załączona + begin //sprawdzić możliwe warunki wyłączenia sprężarki + if (CompressorPower=5) then //jeśli zasilanie z sąsiedniego członu + begin //zasilanie sprężarki w członie ra z członu silnikowego (sprzęg 1) + if (Couplers[1].Connected<>NIL) then + CompressorFlag:=Couplers[1].Connected.CompressorAllow and Couplers[1].Connected.ConverterFlag and Couplers[1].Connected.Mains + else + CompressorFlag:=false; //bez tamtego członu nie zadziała + end + else if (CompressorPower=4) then //jeśli zasilanie z poprzedniego członu + begin //zasilanie sprężarki w członie ra z członu silnikowego (sprzęg 1) + if (Couplers[0].Connected<>NIL) then + CompressorFlag:=Couplers[0].Connected.CompressorAllow and Couplers[0].Connected.ConverterFlag and Couplers[0].Connected.Mains + else + CompressorFlag:=false; //bez tamtego członu nie zadziała + end + else + CompressorFlag:=(CompressorAllow) and ((ConverterFlag) or (CompressorPower=0)) and (Mains); + if (Compressor>MaxCompressor) then //wyłącznik ciśnieniowy jest niezależny od sposobu zasilania + CompressorFlag:=false; + end + else //jeśli nie załączona + if (CompressorCtrlDelay) then //jeśli nie załączona, a ciśnienie za małe + begin //załączenie przy małym ciśnieniu + if (CompressorPower=5) then //jeśli zasilanie z następnego członu + begin //zasilanie sprężarki w członie ra z członu silnikowego (sprzęg 1) + if (Couplers[1].Connected<>NIL) then + CompressorFlag:=Couplers[1].Connected.CompressorAllow and Couplers[1].Connected.ConverterFlag and Couplers[1].Connected.Mains + else + CompressorFlag:=false; //bez tamtego członu nie zadziała + end + else if (CompressorPower=4) then //jeśli zasilanie z poprzedniego członu + begin //zasilanie sprężarki w członie ra z członu silnikowego (sprzęg 1) + if (Couplers[0].Connected<>NIL) then + CompressorFlag:=Couplers[0].Connected.CompressorAllow and Couplers[0].Connected.ConverterFlag and Couplers[0].Connected.Mains + else + CompressorFlag:=false; //bez tamtego członu nie zadziała + end + else + CompressorFlag:=(CompressorAllow) and ((ConverterFlag) or (CompressorPower=0)) and (Mains); + if (CompressorFlag) then //jeśli została załączona + LastSwitchingTime:=0; //to trzeba ograniczyć ponowne włączenie + end; +// for b:=0 to 1 do //z Megapacka +// with Couplers[b] do +// if TestFlag(CouplingFlag,ctrain_scndpneumatic) then +// Connected.CompressorFlag:=CompressorFlag; + if CompressorFlag then + if (EngineType=DieselElectric) and (CompressorPower>0) then + CompressedVolume:=CompressedVolume+dt*CompressorSpeed*(2*MaxCompressor-Compressor)/MaxCompressor*(DEList[MainCtrlPos].rpm/DEList[MainCtrlPosNo].rpm) + else + begin + CompressedVolume:=CompressedVolume+dt*CompressorSpeed*(2*MaxCompressor-Compressor)/MaxCompressor; + if (CompressorPower=5)and(Couplers[1].Connected<>NIL) then + Couplers[1].Connected.TotalCurrent:=0.0015*Couplers[1].Connected.Voltage //tymczasowo tylko obciążenie sprężarki, tak z 5A na sprężarkę + else if (CompressorPower=4)and(Couplers[0].Connected<>NIL) then + Couplers[0].Connected.TotalCurrent:=0.0015*Couplers[0].Connected.Voltage //tymczasowo tylko obciążenie sprężarki, tak z 5A na sprężarkę + else + TotalCurrent:=0.0015*Voltage; //tymczasowo tylko obciążenie sprężarki, tak z 5A na sprężarkę + end + end; + end; +end; +{Ra 2014-07: do C++ +procedure T_MoverParameters.ConverterCheck; +begin //sprawdzanie przetwornicy +if (ConverterAllow=true)and(Mains=true) then + ConverterFlag:=true + else + ConverterFlag:=false; +end; +} +//youBy - przewod zasilajacy +procedure T_MoverParameters.UpdateScndPipePressure(dt: real); +const Spz=0.5067; +var c:T_MoverParameters;dv1,dv2,dv:real; +begin + dv1:=0; + dv2:=0; + +//sprzeg 1 + if Couplers[0].Connected<>nil then + if TestFlag(Couplers[0].CouplingFlag,ctrain_scndpneumatic) then + begin + c:=Couplers[0].Connected; //skrot + dv1:=0.5*dt*PF(ScndPipePress,c.ScndPipePress,Spz*0.75); + if (dv1*dv1>0.00000000000001) then c.Physic_Reactivation; + c.Pipe2.Flow(-dv1); + end; +//sprzeg 2 + if Couplers[1].Connected<>nil then + if TestFlag(Couplers[1].CouplingFlag,ctrain_scndpneumatic) then + begin + c:=Couplers[1].Connected; //skrot + dv2:=0.5*dt*PF(ScndPipePress,c.ScndPipePress,Spz*0.75); + if (dv2*dv2>0.00000000000001) then c.Physic_Reactivation; + c.Pipe2.Flow(-dv2); + end; + if(Couplers[1].Connected<>nil)and(Couplers[0].Connected<>nil)then + if (TestFlag(Couplers[0].CouplingFlag,ctrain_scndpneumatic))and(TestFlag(Couplers[1].CouplingFlag,ctrain_scndpneumatic))then + begin + dv:=0.00025*dt*PF(Couplers[0].Connected.ScndPipePress,Couplers[1].Connected.ScndPipePress,Spz*0.25); + Couplers[0].Connected.Pipe2.Flow(+dv); + Couplers[1].Connected.Pipe2.Flow(-dv); + end; + + Pipe2.Flow(Hamulec.GetHPFlow(ScndPipePress, dt)); + + if ((Compressor>ScndPipePress) and (CompressorSpeed>0.0001)) or (TrainType=dt_EZT) then + begin + dV:=PF(Compressor,ScndPipePress,Spz)*dt; + CompressedVolume:=CompressedVolume+dV/1000; + Pipe2.Flow(-dV); + end; + + Pipe2.Flow(dv1+dv2); + Pipe2.Act; + ScndPipePress:=Pipe2.P; + + if ScndPipePress<-1 then + begin + ScndPipePress:=-1; + Pipe2.CreatePress(-1); + Pipe2.Act; + end; + + +end; + + +{lokomotywy} + +function T_MoverParameters.ComputeRotatingWheel(WForce,dt,n:real): real; +var newn,eps:real; +begin + if (n=0) and (WForce*Sign(V)<0) then + newn:=0 + else + begin + eps:=WForce*WheelDiameter/(2.0*AxleInertialMoment); + newn:=n+eps*dt; + if (newn*n<=0) and (eps*n<0) then + newn:=0; + end; + ComputeRotatingWheel:=newn; +end; + +{----------------------} +{LOKOMOTYWA ELEKTRYCZNA} + +function T_MoverParameters.FuseFlagCheck: boolean; +var b:byte; +begin + FuseFlagCheck:=false; + if Power>0.01 then FuseFlagCheck:=FuseFlag + else {pobor pradu jezeli niema mocy} + for b:=0 to 1 do + with Couplers[b] do + if TestFlag(CouplingFlag,ctrain_controll) then + if Connected.Power>0.01 then + FuseFlagCheck:=Connected.FuseFlagCheck(); +end; + +function T_MoverParameters.FuseOn: boolean; +begin + FuseOn:=false; + if (MainCtrlPos=0) and (ScndCtrlPos=0) and (TrainType<>dt_ET40) and Mains then + begin //w ET40 jest blokada nastawnika, ale czy działa dobrze? + SendCtrlToNext('FuseSwitch',1,CabNo); + if ((EngineType=ElectricSeriesMotor)or((EngineType=DieselElectric))) and FuseFlag then + begin + FuseFlag:=false; {wlaczenie ponowne obwodu} + FuseOn:=true; + SetFlag(SoundFlag,sound_relay); SetFlag(SoundFlag,sound_loud); + end; + end; +end; + +procedure T_MoverParameters.FuseOff; +begin + if not FuseFlag then + begin + FuseFlag:=true; + EventFlag:=true; + SetFlag(SoundFlag,sound_relay); + SetFlag(SoundFlag,sound_loud); + end; +end; + + +function T_MoverParameters.ShowCurrent(AmpN:byte): integer; +var b,Bn:byte; + Grupowy: boolean; +begin + ClearPendingExceptions; + ShowCurrent:=0; + Grupowy:=(DelayCtrlFlag) and (TrainType=dt_et22); //przerzucanie walu grupowego w ET22; + Bn:=RList[MainCtrlActualPos].Bn; //ile równoległych gałęzi silników + + if (DynamicBrakeType=dbrake_automatic) and (DynamicBrakeFlag) then + Bn:=2; + if Power>0.01 then + begin + if AmpN>0 then //podać prąd w gałęzi + begin + if (Bn0.01 then + ShowCurrent:=Connected.ShowCurrent(AmpN); +end; + +{Ra 2014-06: przeniesione do C++ +function T_MoverParameters.ShowEngineRotation(VehN:byte): integer; +var b:Byte; //,Bn:byte; +begin + ClearPendingExceptions; + ShowEngineRotation:=0; + case VehN of + 1: ShowEngineRotation:=Trunc(Abs(enrot)); + 2: for b:=0 to 1 do + with Couplers[b] do + if TestFlag(CouplingFlag,ctrain_controll) then + if Connected.Power>0.01 then + ShowEngineRotation:=Trunc(Abs(Connected.enrot)); + 3: if Couplers[1].Connected<>nil then + if TestFlag(Couplers[1].CouplingFlag,ctrain_controll) then + if Couplers[1].Connected.Couplers[1].Connected<>nil then + if TestFlag(Couplers[1].Connected.Couplers[1].CouplingFlag,ctrain_controll) then + if Couplers[1].Connected.Couplers[1].Connected.Power>0.01 then + ShowEngineRotation:=Trunc(Abs(Couplers[1].Connected.Couplers[1].Connected.enrot)); + end; +end; +} + +{funkcje uzalezniajace sile pociagowa od predkosci: V2n, n2R, Current, Momentum} +{----------------} + +function T_MoverParameters.V2n:real; +{przelicza predkosc liniowa na obrotowa} +const dmgn=0.5; +var n,deltan:real; +begin + n:=V/(Pi*WheelDiameter); //predkosc obrotowa wynikajaca z liniowej [obr/s] + deltan:=n-nrot; //"pochodna" prędkości obrotowej + if SlippingWheels then + if Abs(deltan)<0.01 then + SlippingWheels:=false; {wygaszenie poslizgu} + if SlippingWheels then {nie ma zwiazku z predkoscia liniowa V} + begin {McZapkie-221103: uszkodzenia kol podczas poslizgu} + if deltan>dmgn then + if FuzzyLogic(deltan,dmgn,p_slippdmg) then + if SetFlag(DamageFlag,dtrain_wheelwear) {podkucie} + then EventFlag:=true; + if deltan<-dmgn then + if FuzzyLogic(-deltan,dmgn,p_slippdmg) then + if SetFlag(DamageFlag,dtrain_thinwheel) {wycieranie sie obreczy} + then EventFlag:=true; + n:=nrot; {predkosc obrotowa nie zalezy od predkosci liniowej} + end; + V2n:=n; +end; + +function T_MoverParameters.Current(n,U:real): real; +{wazna funkcja - liczy prad plynacy przez silniki polaczone szeregowo lub rownolegle} +{w zaleznosci od polozenia nastawnikow MainCtrl i ScndCtrl oraz predkosci obrotowej n} +{a takze wywala bezpiecznik nadmiarowy gdy za duzy prad lub za male napiecie} +{jest takze mozliwosc uszkodzenia silnika wskutek nietypowych parametrow} +const ep09resED=5.8; {TODO: dobrac tak aby sie zgadzalo ze wbudzeniem} +var //Rw, + R,MotorCurrent:real; + Rz,Delta,Isf:real; + Mn: integer; + Bn: real; + SP: byte; + U1: real; //napiecie z korekta +begin + MotorCurrent:=0; +//i dzialanie hamulca ED w EP09 + if (DynamicBrakeType=dbrake_automatic) then + begin + if (((Hamulec as TLSt).GetEDBCP<0.25)and(Vadd<1))or(BrakePress>2.1) then + DynamicBrakeFlag:=false + else if (BrakePress>0.25) and ((Hamulec as TLSt).GetEDBCP>0.25) then + DynamicBrakeFlag:=true; + DynamicBrakeFlag:=DynamicBrakeFlag and ConverterFlag; + end; +//wylacznik cisnieniowy yBARC - to jest chyba niepotrzebne tutaj +// if BrakePress>2 then +// begin +// StLinFlag:=true; +// DelayCtrlFlag:=(TrainType<>dt_EZT); //EN57 nie ma czekania na 1. pozycji +// DynamicBrakeFlag:=false; +// end; + if(BrakeSubSystem=ss_LSt)then + if(DynamicBrakeFlag)then + (Hamulec as TLSt).SetED(Abs(Im/350)) //hamulec ED na EP09 dziala az do zatrzymania lokomotywy + else + (Hamulec as TLSt).SetED(0); + + ResistorsFlag:=(RList[MainCtrlActualPos].R>0.01){ and (not DelayCtrlFlag)}; + ResistorsFlag:=ResistorsFlag or ((DynamicBrakeFlag=true) and (DynamicBrakeType=dbrake_automatic)); + + if(TrainType=dt_ET22)and(DelayCtrlFlag)and(MainCtrlActualPos>1)then + Bn:=1-1/RList[MainCtrlActualPos].Bn + else + Bn:=1; + R:=RList[MainCtrlActualPos].R*Bn+CircuitRes; + + if (TrainType<>dt_EZT)or(Imin<>IminLo)or(not ScndS) then //yBARC - boczniki na szeregu poprawnie + Mn:=RList[MainCtrlActualPos].Mn + else + Mn:=RList[MainCtrlActualPos].Mn*RList[MainCtrlActualPos].Bn; +//z Megapacka +// if DynamicBrakeFlag and (TrainType=dt_ET42) then { KURS90 azeby mozna bylo hamowac przy opuszczonych pantografach } +// SP:=ScndCtrlActualPos; +// if(ScndInMain)then +// if not (RList[MainCtrlActualPos].ScndAct=255) then +// SP:=RList[MainCtrlActualPos].ScndAct; +// with MotorParam[SP] do +// begin +// Rz:=WindingRes+R; +// MotorCurrent:=-fi*n/Rz; +// end; + if DynamicBrakeFlag and (not FuseFlag) and (DynamicBrakeType=dbrake_automatic) and ConverterFlag and Mains then {hamowanie EP09} + with MotorParam[0] do //TUHEX + begin + MotorCurrent:=-Max0R(fi*(Vadd/(Vadd+Isat)-fi0),0)*n*2/ep09resED; {TODO: zrobic bardziej uniwersalne nie tylko dla EP09} +// if abs(MotorCurrent)>500 then +// MotorCurrent:=sign(MotorCurrent)*500 {TODO: zrobic bardziej finezyjnie} + end + else + if (RList[MainCtrlActualPos].Bn=0) {or FuseFlag} or (not StLinFlag) {or DelayCtrlFlag} then + //if (RList[MainCtrlActualPos].Bn=0) or FuseFlag or StLinFlag or DelayCtrlFlag or ((TrainType=dt_ET42)and(not(ConverterFlag)and not(DynamicBrakeFlag))) then //z Megapacka + MotorCurrent:=0 {wylaczone} + else {wlaczone} + begin + SP:=ScndCtrlActualPos; + if(ScndCtrlActualPos<255)then {tak smiesznie bede wylaczal } + begin + if(ScndInMain)then + if not (RList[MainCtrlActualPos].ScndAct=255) then + SP:=RList[MainCtrlActualPos].ScndAct; + with MotorParam[SP] do + begin + Rz:=Mn*WindingRes+R; + if DynamicBrakeFlag then {hamowanie} + begin + if DynamicBrakeType>1 then + begin + //if DynamicBrakeType<>dbrake_automatic then + // MotorCurrent:=-fi*n/Rz {hamowanie silnikiem na oporach rozruchowych} +(* begin + U:=0; + Isf:=Isat; + Delta:=SQR(Isf*Rz+Mn*fi*n-U)+4*U*Isf*Rz; + MotorCurrent:=(U-Isf*Rz-Mn*fi*n+SQRT(Delta))/(2*Rz) + end*) + if (DynamicBrakeType=dbrake_switch) and (TrainType=dt_ET42) then + begin //z Megapacka + Rz:=WindingRes+R; + MotorCurrent:=-fi*n/Rz; //{hamowanie silnikiem na oporach rozruchowych} + end; + end + else + MotorCurrent:=0; {odciecie pradu od silnika} + end + else + begin + U1:=U+Mn*n*fi0*fi; + Isf:=Sign(U1)*Isat; + Delta:=SQR(Isf*Rz+Mn*fi*n-U1)+4*U1*Isf*Rz; + if Mains then + begin + if U>0 then + MotorCurrent:=(U1-Isf*Rz-Mn*fi*n+SQRT(Delta))/(2.0*Rz) + else + MotorCurrent:=(U1-Isf*Rz-Mn*fi*n-SQRT(Delta))/(2.0*Rz) + end + else + MotorCurrent:=0; + end;{else DBF} + end;{with} + end{255} + else + MotorCurrent:=0; + end; +{ if Abs(CabNo)<2 then Im:=MotorCurrent*ActiveDir*CabNo + else Im:=0; +} + + if (DynamicBrakeType=dbrake_switch) and ((BrakePress>2.0) or (PipePress<3.6)) then + begin + Im:=0; + MotorCurrent:=0; + //Im:=0; + Itot:=0; + end + else + Im:=MotorCurrent; + Current:=Im; {prad brany do liczenia sily trakcyjnej} +{ EnginePower:=Im*Im*RList[MainCtrlActualPos].Bn*RList[MainCtrlActualPos].Mn*WindingRes;} + EnginePower:=Abs(Itot)*(1+RList[MainCtrlActualPos].Mn)*Abs(U); + + {awarie} + MotorCurrent:=Abs(Im); {zmienna pomocnicza} + if Motorcurrent>0 then + begin + if FuzzyLogic(Abs(n),nmax*1.1,p_elengproblem) then + if MainSwitch(false) then + EventFlag:=true; {zbyt duze obroty - wywalanie wskutek ognia okreznego} + if TestFlag(DamageFlag,dtrain_engine) then + if FuzzyLogic(MotorCurrent,ImaxLo/10.0,p_elengproblem) then + if MainSwitch(false) then + EventFlag:=true; {uszkodzony silnik (uplywy)} + if (FuzzyLogic(Abs(Im),Imax*2,p_elengproblem) or FuzzyLogic(Abs(n),nmax*1.11,p_elengproblem)) then +{ or FuzzyLogic(Abs(U/Mn),2*NominalVoltage,1)) then } {poprawic potem} + if (SetFlag(DamageFlag,dtrain_engine)) then + EventFlag:=true; + {! dorobic grzanie oporow rozruchowych i silnika} + end; +end; + +function T_MoverParameters.Momentum(I:real): real; +{liczy moment sily wytwarzany przez silnik elektryczny} +var SP: byte; +begin + SP:=ScndCtrlActualPos; + if (ScndInMain) then + if not (RList[MainCtrlActualPos].ScndAct=255) then + SP:=RList[MainCtrlActualPos].ScndAct; + with MotorParam[SP] do +// Momentum:=mfi*I*(1-1.0/(Abs(I)/mIsat+1)); + Momentum:=mfi*I*(Abs(I)/(Abs(I)+mIsat)-mfi0); +end; + +function T_MoverParameters.MomentumF(I, Iw :real; SCP: byte): real; +begin +//umozliwia dokladne sterowanie wzbudzeniem + with MotorParam[SCP] do + MomentumF:=mfi*I*Max0R(Abs(Iw)/(Abs(Iw)+mIsat)-mfi0,0); +end; + +function T_MoverParameters.dizel_Momentum(dizel_fill,n,dt:real): real; +{liczy moment sily wytwarzany przez silnik spalinowy} +var Moment, enMoment, eps, newn, friction: real; +begin +{ friction:=dizel_engagefriction*(11-2*random)/10; } + friction:=dizel_engagefriction; + if enrot>0 then + begin + Moment:=dizel_Mmax*dizel_fill-(dizel_Mmax-dizel_Mnmax*dizel_fill)*sqr(enrot/(dizel_nmax-dizel_nMmax*dizel_fill))-dizel_Mstand; +{ Moment:=Moment*(1+sin(eAngle*4))-dizel_Mstand*(1+cos(eAngle*4));} + end + else Moment:=-dizel_Mstand; + if enrot(dizel_engageMaxForce*dizel_engage*dizel_engageDia*friction*2) then {zerwanie przyczepnosci sprzegla} + enrot:=enrot+dt*Moment/dizel_AIM + else + begin + dizel_engagedeltaomega:=0; + enrot:=abs(n); {jest przyczepnosc tarcz} + end +(* + end + end + else + begin + if (enrot=0) and (Moment<0) then + newn:=0 + else + begin + //!! abs + dizel_engagedeltaomega:=enrot-n; {sliganie tarcz} + enMoment:=Moment-sign(dizel_engagedeltaomega)*dizel_engageMaxForce*dizel_engage*dizel_engageDia*friction; + Moment:=sign(dizel_engagedeltaomega)*dizel_engageMaxForce*dizel_engage*dizel_engageDia*friction; + dizel_engagedeltaomega:=abs(enrot-abs(n)); + eps:=enMoment/dizel_AIM; + newn:=enrot+eps*dt; + if (newn*enrot<=0) and (eps*enrot<0) then + newn:=0; + end; + enrot:=newn; + end; + dizel_Momentum:=Moment; + if (enrot=0) and (not dizel_enginestart) then + Mains:=false; +end; + +function T_MoverParameters.CutOffEngine: boolean; {wylacza uszkodzony silnik} +begin + CutOffEngine:=false; //Ra: wartość domyślna, sprawdzić to trzeba + if (NPoweredAxles>0) and (CabNo=0) and (EngineType=ElectricSeriesMotor) then + begin + if SetFlag(DamageFlag,-dtrain_engine) then + begin + NPoweredAxles:=NPoweredAxles div 2; + CutOffEngine:=true; + end; + end +end; + +{przelacznik pradu wysokiego rozruchu} +function T_MoverParameters.MaxCurrentSwitch(State:boolean):boolean; +begin + MaxCurrentSwitch:=false; + if (EngineType=ElectricSeriesMotor) then + if (ImaxHi>ImaxLo) then + begin + if State and (Imax=ImaxLo) and (RList[MainCtrlPos].Bn<2) and not ((TrainType=dt_ET42)and(MainctrlPos>0)) then + begin + Imax:=ImaxHi; + MaxCurrentSwitch:=true; + if CabNo<>0 then + SendCtrlToNext('MaxCurrentSwitch',1,CabNo); + end; + if (not State) then + if (Imax=ImaxHi) then + if not ((TrainType=dt_ET42)and(MainctrlPos>0)) then + begin + Imax:=ImaxLo; + MaxCurrentSwitch:=true; + if CabNo<>0 then + SendCtrlToNext('MaxCurrentSwitch',0,CabNo); + end; + end; +end; + + +{przelacznik pradu automatycznego rozruchu} +function T_MoverParameters.MinCurrentSwitch(State:boolean):boolean; +begin + MinCurrentSwitch:=false; + if ((EngineType=ElectricSeriesMotor) and (IminHi>IminLo)) or (TrainType=dt_EZT) then + begin + if State and (Imin=IminLo) then + begin + Imin:=IminHi; + MinCurrentSwitch:=true; + if CabNo<>0 then + SendCtrlToNext('MinCurrentSwitch',1,CabNo); + end; + if (not State) and (Imin=IminHi) then + begin + Imin:=IminLo; + MinCurrentSwitch:=true; + if CabNo<>0 then + SendCtrlToNext('MinCurrentSwitch',0,CabNo); + end; + end; +end; + + +{reczne przelaczanie samoczynnego rozruchu} +function T_MoverParameters.AutoRelaySwitch(State:boolean):boolean; + begin + if (AutoRelayType=2) and (AutoRelayFlag<>State) then + begin + AutoRelayFlag:=State; + AutoRelaySwitch:=true; + SendCtrlToNext('AutoRelaySwitch',ord(State),CabNo); + end + else + AutoRelaySwitch:=false; + end; + +function T_MoverParameters.AutoRelayCheck: boolean; +var OK:boolean; b:byte; +begin +// if ((TrainType=dt_EZT{) or (TrainType=dt_ET22)}) and (Imin=IminLo)) or ((ActiveDir<0) and (TrainType<>dt_PseudoDiesel')) then +// if RList[MainCtrlActualPos].Bn>1 then +// begin +// dec(MainCtrlActualPos); +// AutoRelayCheck:=false; +// Exit; +// end; +//yB: wychodzenie przy odcietym pradzie + if (ScndCtrlActualPos=255)then + begin + AutoRelayCheck:=false; + MainCtrlActualPos:=0; + end + else + //if (not Mains) or (FuseFlag) or (StLinFlag) then //hunter-111211: wylacznik cisnieniowy + //if ((not Mains) or (FuseFlag)) and not((DynamicBrakeFlag) and (TrainType=dt_ET42)) then + if ((not Mains) or (FuseFlag) or (StLinFlag)) and not((DynamicBrakeFlag) and (TrainType=dt_ET42)) then //hunter-111211: wylacznik cisnieniowy + begin + AutoRelayCheck:=false; + MainCtrlActualPos:=0; + ScndCtrlActualPos:=0; + end + else + begin + OK:=false; + if DelayCtrlFlag and (MainCtrlPos=1) and (MainCtrlActualPos=1) and (LastRelayTime>InitialCtrlDelay) then + begin + DelayCtrlFlag:=false; + SetFlag(SoundFlag,sound_relay); SetFlag(SoundFlag,sound_loud); + end; + //if (TrainType<>dt_EZT) then //Ra: w EZT można dać od razu na S albo R, wał kułakowy sobie dokręci + if (LastRelayTime>CtrlDelay) and not DelayCtrlFlag then + begin + if (MainCtrlPos=0) and (TrainType<>dt_ET40) and (TrainType<>dt_EP05) then + DelayCtrlFlag:=true; //(TrainType<>dt_EZT); //EN57 nie ma czekania na 1. pozycji + if (MainCtrlPos=0) and ((TrainType=dt_ET40)or(TrainType=dt_EP05)) and (MainCtrlActualPos=0) then + DelayCtrlFlag:=true; //(TrainType<>dt_EZT); //EN57 nie ma czekania na 1. pozycji + + if (((RList[MainCtrlActualPos].R=0) and ((not CoupledCtrl) or ((Imin=IminLo) and (ScndS=true)))) or (MainCtrlActualPos=RListSize)) + and ((ScndCtrlActualPos>0) or (ScndCtrlPos>0)) then + begin {zmieniaj scndctrlactualpos} + if (not AutoRelayFlag) or (not MotorParam[ScndCtrlActualPos].AutoSwitch) then + begin {scnd bez samoczynnego rozruchu} + OK:=true; + if (ScndCtrlActualPosScndCtrlPos) and (TrainType<>dt_EZT) then + dec(ScndCtrlActualPos) + + else + if (ScndCtrlActualPos>ScndCtrlPos) and (TrainType=dt_EZT) then + + Exit {utkniecie walu kulakowego} + else OK:=false; + end + else + begin {scnd z samoczynnym rozruchem} + if (ScndCtrlPosdt_EZT) then + begin + dec(ScndCtrlActualPos); + OK:=true; + end + else + if (ScndCtrlPosScndCtrlActualPos) then + if Abs(Im)1 then + begin + AutoRelayCheck:=false; + Exit; + end; + if (not AutoRelayFlag) or (not RList[MainCtrlActualPos].AutoSwitch) then + begin {main bez samoczynnego rozruchu} + OK:=true; + if RList[MainCtrlActualPos].RelayRList[MainCtrlPos].Mn)and (RList[MainCtrlActualPos+1].Mn0) and (TrainType=dt_ET22) and (LastRelayTime0 then + //if (RList[MainCtrlActualPos].R=0) and ((RList[MainCtrlActualPos].ScndAct=0) or (RList[MainCtrlActualPos].ScndAct=255)) then {dzwieki przechodzenia na bezoporowa} + if (RList[MainCtrlActualPos].R=0) and (not (MainCtrlActualPos=MainCtrlPosNo)) then //wejscie na bezoporowa + begin + SetFlag(SoundFlag,sound_manyrelay); SetFlag(SoundFlag,sound_loud); + end + else if (RList[MainCtrlActualPos].R>0) and (RList[MainCtrlActualPos-1].R=0) then //wejscie na drugi uklad + begin + SetFlag(SoundFlag,sound_manyrelay); + end; + + end + else if (RList[MainCtrlActualPos].Relay>MainCtrlPos) and (TrainType<>dt_EZT) then + begin + if not ((RList[MainCtrlActualPos].MnRList[MainCtrlActualPos].Mn)and (TrainType=dt_ET22) and (LastRelayTime0 then //hunter-111211: poprawki + //if (RList[MainCtrlActualPos+1].R=0) and ((RList[MainCtrlActualPos+1].ScndAct=0) or (RList[MainCtrlActualPos+1].ScndAct=255)) then {dzwieki schodzenia z bezoporowej} + if RList[MainCtrlActualPos].R=0 then {dzwieki schodzenia z bezoporowej} + begin + SetFlag(SoundFlag,sound_manyrelay); + end; + end + else + begin + Itot:=0; + Im:=0; + OK:=false; {odciecie pradu, przy przelaczaniu silnikow w ET22} + end; + end + else if (RList[MainCtrlActualPos].Relay>MainCtrlPos) and (TrainType=dt_EZT) and (MainCtrlPos>0) then //K90 + begin + Exit; {utkniecie walu kulakowego} + end + else if (TrainType=dt_EZT) and (MainCtrlPos=0) then + MainCtrlActualPos:=0 + else + if (RList[MainCtrlActualPos].R>0) and (ScndCtrlActualPos>0) and (TrainType<>dt_EZT) then + Dec(ScndCtrlActualPos) {boczniki nie dzialaja na poz. oporowych} + else + if (ScndCtrlPosdt_EZT) then + begin + if not ((RList[MainCtrlActualPos].MnRList[MainCtrlActualPos].Mn) and (TrainType=dt_ET22) and (LastRelayTime0 then + if (RList[MainCtrlActualPos+1].R=0) and ((RList[MainCtrlActualPos+1].ScndAct=0) or (RList[MainCtrlActualPos+1].ScndAct=255)) then {dzwieki schodzenia z bezoporowej} + begin + SetFlag(SoundFlag,sound_manyrelay); + end; + end + else + begin + Itot:=0; + Im:=0; + OK:=false; {odciecie pradu, przy przelaczaniu silnikow w ET22} + end; + end + else + if (MainCtrlPos0) and (TrainType=dt_EZT) then + begin + AutoRelayCheck:=false; + Exit; {utkniecie walu} + end + else + if (TrainType=dt_EZT) and (MainCtrlPos=0) then + begin + MainCtrlActualPos:=0; + ScndCtrlActualPos:=0; + end + else + if ((ScndCtrlPosRList[MainCtrlActualPos].Relay) or ((MainCtrlActualPosRList[MainCtrlPos].Mn) and(RList[MainCtrlActualPos+1].Mn0 then + if (RList[MainCtrlActualPos].R=0) and ((RList[MainCtrlActualPos].ScndAct=0) or (RList[MainCtrlActualPos].ScndAct=255)) then {dzwieki przechodzenia na bezoporowa} + begin + SetFlag(SoundFlag,sound_manyrelay); SetFlag(SoundFlag,sound_loud); + end; + end; + end; + end; + end; + end + else {DelayCtrlFlag} + if ((MainCtrlPos>1) and (MainCtrlActualPos>0) and DelayCtrlFlag) then + begin + //if (TrainType<>dt_EZT) then //Ra: w EZT można dać od razu na S albo R, wał kułakowy sobie dokręci + MainCtrlActualPos:=0; //Ra: tu jest chyba wyłączanie przy zbyt szybkim wejściu na drugą pozycję + OK:=true; + end + else + if ((MainCtrlPos=0) and (TrainType=dt_EZT)) then + begin + MainCtrlActualPos:=0; + ScndCtrlActualPos:=0; {zejscie walu kulakowego do 0 po ustawieniu nastawnika na 0} + OK:=true; + end + else + if (MainCtrlPos=1) and (MainCtrlActualPos=0) then + MainCtrlActualPos:=1 + else + if (MainCtrlPos=0) and (MainCtrlActualPos>0) and (TrainType<>dt_EZT) and (TrainType<>dt_ET40) and (TrainType<>dt_EP05) then + begin + dec(MainCtrlActualPos); + OK:=true; + end; + if (MainCtrlPos=0) and (MainCtrlActualPos>0) and ((TrainType=dt_ET40)or(TrainType=dt_EP05)) and (LastRelayTime>(InitialCtrlDelay*2)) then + begin + dec(MainCtrlActualPos); + OK:=true; {wal kulakowy w ET40} + end; + if OK then LastRelayTime:=0; + AutoRelayCheck:=OK; + end; +end; +*) + end + else + begin + if (enrot=0) and (Moment<0) then + newn:=0 + else + begin + //!! abs + dizel_engagedeltaomega:=enrot-n; {sliganie tarcz} + enMoment:=Moment-sign(dizel_engagedeltaomega)*dizel_engageMaxForce*dizel_engage*dizel_engageDia*friction; + Moment:=sign(dizel_engagedeltaomega)*dizel_engageMaxForce*dizel_engage*dizel_engageDia*friction; + dizel_engagedeltaomega:=abs(enrot-abs(n)); + eps:=enMoment/dizel_AIM; + newn:=enrot+eps*dt; + if (newn*enrot<=0) and (eps*enrot<0) then + newn:=0; + end; + enrot:=newn; + end; + dizel_Momentum:=Moment; + if (enrot=0) and (not dizel_enginestart) then + Mains:=false; +end; + +function T_MoverParameters.CutOffEngine: boolean; {wylacza uszkodzony silnik} +begin + CutOffEngine:=false; //Ra: wartość domyślna, sprawdzić to trzeba + if (NPoweredAxles>0) and (CabNo=0) and (EngineType=ElectricSeriesMotor) then + begin + if SetFlag(DamageFlag,-dtrain_engine) then + begin + NPoweredAxles:=NPoweredAxles div 2; + CutOffEngine:=true; + end; + end +end; + +{przelacznik pradu wysokiego rozruchu} +function T_MoverParameters.MaxCurrentSwitch(State:boolean):boolean; +begin + MaxCurrentSwitch:=false; + if (EngineType=ElectricSeriesMotor) then + if (ImaxHi>ImaxLo) then + begin + if State and (Imax=ImaxLo) and (RList[MainCtrlPos].Bn<2) and not ((TrainType=dt_ET42)and(MainctrlPos>0)) then + begin + Imax:=ImaxHi; + MaxCurrentSwitch:=true; + if CabNo<>0 then + SendCtrlToNext('MaxCurrentSwitch',1,CabNo); + end; + if (not State) then + if (Imax=ImaxHi) then + if not ((TrainType=dt_ET42)and(MainctrlPos>0)) then + begin + Imax:=ImaxLo; + MaxCurrentSwitch:=true; + if CabNo<>0 then + SendCtrlToNext('MaxCurrentSwitch',0,CabNo); + end; + end; +end; + + +{przelacznik pradu automatycznego rozruchu} +function T_MoverParameters.MinCurrentSwitch(State:boolean):boolean; +begin + MinCurrentSwitch:=false; + if ((EngineType=ElectricSeriesMotor) and (IminHi>IminLo)) or (TrainType=dt_EZT) then + begin + if State and (Imin=IminLo) then + begin + Imin:=IminHi; + MinCurrentSwitch:=true; + if CabNo<>0 then + SendCtrlToNext('MinCurrentSwitch',1,CabNo); + end; + if (not State) and (Imin=IminHi) then + begin + Imin:=IminLo; + MinCurrentSwitch:=true; + if CabNo<>0 then + SendCtrlToNext('MinCurrentSwitch',0,CabNo); + end; + end; +end; + + +{reczne przelaczanie samoczynnego rozruchu} +function T_MoverParameters.AutoRelaySwitch(State:boolean):boolean; + begin + if (AutoRelayType=2) and (AutoRelayFlag<>State) then + begin + AutoRelayFlag:=State; + AutoRelaySwitch:=true; + SendCtrlToNext('AutoRelaySwitch',ord(State),CabNo); + end + else + AutoRelaySwitch:=false; + end; + +function T_MoverParameters.AutoRelayCheck: boolean; +var OK:boolean; //b:byte; + ARFASI, ARFASI2 :boolean; //sprawdzenie wszystkich warunkow (AutoRelayFlag, AutoSwitch, Im2.1) or (ActiveDir=0) then //hunter-111211: wylacznik cisnieniowy + begin + StLinFlag:=false; //yBARC - rozlaczenie stycznikow liniowych + AutoRelayCheck:=false; + if not DynamicBrakeFlag then + begin + Im:=0; + Itot:=0; + ResistorsFlag:=false; + end; + end; + + ARFASI2:=(not AutoRelayFlag) or ((MotorParam[ScndCtrlActualPos].AutoSwitch) and (Abs(Im)0) or (ScndCtrlPos>0)) and (not(CoupledCtrl)or(RList[MainCtrlActualPos].Relay=MainCtrlPos))then + begin //zmieniaj scndctrlactualpos + begin {scnd bez samoczynnego rozruchu} + if (ScndCtrlActualPosCtrlDelay)and(ARFASI2) then + begin + inc(ScndCtrlActualPos); + OK:=true; + end + end + else + if ScndCtrlActualPos>ScndCtrlPos then + begin + if (LastRelayTime>CtrlDownDelay)and(TrainType<>dt_EZT) then + begin + dec(ScndCtrlActualPos); + OK:=true; + end + end + else OK:=false; + end; + end + else + begin //zmieniaj mainctrlactualpos + if ((ActiveDir<0) and (TrainType<>dt_PseudoDiesel)) then + if RList[MainCtrlActualPos+1].Bn>1 then + begin + AutoRelayCheck:=false; + Exit; //Ra: to powoduje, że EN57 nie wyłącza się przy IminLo + end; + begin //main bez samoczynnego rozruchu + if (RList[MainCtrlActualPos].Relay0) and (not (MainCtrlPos=MainCtrlPosNo)) and (FastSerialCircuit=1) then + begin + inc(MainCtrlActualPos); +// MainCtrlActualPos:=MainCtrlPos; //hunter-111012: szybkie wchodzenie na bezoporowa (303E) + OK:=true; + SetFlag(SoundFlag,sound_manyrelay); SetFlag(SoundFlag,sound_loud); + end + else if (LastRelayTime>CtrlDelay)and(ARFASI) then + begin + if (TrainType=dt_ET22)and(MainCtrlPos>1)and((RList[MainCtrlActualPos].Bn4*CtrlDelay) then //przejscie + begin + DelayCtrlFlag:=false; + OK:=true; + end + else + else //nie ET22 z wałem grupowym + begin + inc(MainCtrlActualPos); + OK:=true; + end; + //--------- + //hunter-111211: poprawki + if MainCtrlActualPos>0 then + if (RList[MainCtrlActualPos].R=0) and (not (MainCtrlActualPos=MainCtrlPosNo)) then //wejscie na bezoporowa + begin + SetFlag(SoundFlag,sound_manyrelay); SetFlag(SoundFlag,sound_loud); + end + else if (RList[MainCtrlActualPos].R>0) and (RList[MainCtrlActualPos-1].R=0) then //wejscie na drugi uklad + begin + SetFlag(SoundFlag,sound_manyrelay); + end; + end + end + else if RList[MainCtrlActualPos].Relay>MainCtrlPos then + begin + if (RList[MainCtrlPos].R=0) and (MainCtrlPos>0) and (not (MainCtrlPos=MainCtrlPosNo)) and (FastSerialCircuit=1) then + begin + dec(MainCtrlActualPos); +// MainCtrlActualPos:=MainCtrlPos; //hunter-111012: szybkie wchodzenie na bezoporowa (303E) + OK:=true; + SetFlag(SoundFlag,sound_manyrelay); + end + else if (LastRelayTime>CtrlDownDelay) then + begin + if (TrainType<>dt_EZT) then //tutaj powinien być tryb sterowania wałem + begin + dec(MainCtrlActualPos); + OK:=true; + end; + if MainCtrlActualPos>0 then //hunter-111211: poprawki + if RList[MainCtrlActualPos].R=0 then {dzwieki schodzenia z bezoporowej} + begin + SetFlag(SoundFlag,sound_manyrelay); + end; + end + end + else + if (RList[MainCtrlActualPos].R>0) and (ScndCtrlActualPos>0) then + begin + if (LastRelayTime>CtrlDownDelay) then + begin + Dec(ScndCtrlActualPos); {boczniki nie dzialaja na poz. oporowych} + OK:=true; + end + end + else + OK:=false; + end; + end; + end + else {not StLinFlag} + begin + OK:=false; + //ybARC - tutaj sa wszystkie warunki, jakie musza byc spelnione, zeby mozna byla zalaczyc styczniki liniowe + if ((MainCtrlPos=1)or((TrainType=dt_EZT)and(MainCtrlPos>0)))and(not FuseFlag)and(Mains)and(BrakePress<1.0)and(MainCtrlActualPos=0)and(ActiveDir<>0) then + begin + DelayCtrlFlag:=true; + if (LastRelayTime>=InitialCtrlDelay) then + begin + StLinFlag:=true; //ybARC - zalaczenie stycznikow liniowych + MainCtrlActualPos:=1; + DelayCtrlFlag:=false; + SetFlag(SoundFlag,sound_relay); SetFlag(SoundFlag,sound_loud); + OK:=true; + end; + end + else + DelayCtrlFlag:=false; + + if (not StLinFlag)and((MainCtrlActualPos>0)or(ScndCtrlActualPos>0)) then + if (TrainType=dt_EZT)and(CoupledCtrl)then //EN57 wal jednokierunkowy calosciowy + begin + if(MainCtrlActualPos=1)then + begin + MainCtrlActualPos:=0; + OK:=true; + end + else + if(LastRelayTime>CtrlDownDelay)then + begin + if(MainCtrlActualPosCtrlDownDelay) then + begin + if (ScndCtrlActualPos>0) then + dec(ScndCtrlActualPos) + else dec(MainCtrlActualPos); + OK:=true; + end + end + else + begin + MainCtrlActualPos:=0; + ScndCtrlActualPos:=0; + OK:=true; + end; + + end; + if OK then LastRelayTime:=0; + AutoRelayCheck:=OK; + end; +end; + +function T_MoverParameters.ResistorsFlagCheck:boolean; {sprawdzanie wskaznika oporow} +var b:byte; +begin + ResistorsFlagCheck:=false; + if Power>0.01 then ResistorsFlagCheck:=ResistorsFlag + else {pobor pradu jezeli niema mocy} + for b:=0 to 1 do + with Couplers[b] do + if TestFlag(CouplingFlag,ctrain_controll) then + if Connected.Power>0.01 then + ResistorsFlagCheck:=Connected.ResistorsFlagCheck(); +end; + +function T_MoverParameters.dizel_EngageSwitch(state: real): boolean; +{zmienia parametr do ktorego dazy sprzeglo} +begin + if (EngineType=DieselEngine) and (state<=1) and (state>=0) and (state<>dizel_engagestate) then + begin + dizel_engagestate:=state; + dizel_EngageSwitch:=true + end + else + dizel_EngageSwitch:=false; +end; + +function T_MoverParameters.dizel_EngageChange(dt: real): boolean; +{zmienia parametr do ktorego dazy sprzeglo} +const engagedownspeed=0.9; engageupspeed=0.5; +var engagespeed:real; //OK:boolean; +begin + dizel_EngageChange:=false; + if dizel_engage-dizel_engagestate>0 then + engagespeed:=engagedownspeed + else + engagespeed:=engageupspeed; + if dt>0.2 then + dt:=0.1; + if abs(dizel_engage-dizel_engagestate)<0.11 then + begin + if (dizel_engage<>dizel_engagestate) then + begin + dizel_EngageChange:=true; + dizel_engage:=dizel_engagestate; + end + //else OK:=false; //już jest false + end + else + begin + dizel_engage:=dizel_engage+engagespeed*dt*(dizel_engagestate-dizel_engage); + //OK:=false; + end; + //dizel_EngageChange:=OK; +end; + +(* +function T_MoverParameters.dizel_rotateengine(Momentum,dt,n,engage:real): real; +{oblicza obroty silnika} +var newn,eps:real; +begin + if (Momentum<0) and (n=0) and (enrot=0) then + newn:=0 + else + begin + if (enrot0) then + Momentum:=0 {nie dziala przy b. malych obrotach} + else + if enrotPi/2) then Momentum:=Momentum-2*dizel_Mstand + end + else + if enrotPi) then Momentum:=Momentum-dizel_Mstand; {wstrzymywanie przy malych obrotach} + + eps:=Momentum/dizel_AIM; + if engage<0.9 then {niepelny docisk - poslizg} + begin + newn:=(1-engage)*(enrot+eps*dt)+engage*(n+eps*dt); + if (newn*enrot<=0) and (eps*enrot<0) then + newn:=0; + end + else + newn:=n; {bez poslizgu sprzegla} + end; + dizel_rotateengine:=newn; +{todo: uwzglednianie AIM przy ruszaniu} +end; +*) + +function T_MoverParameters.dizel_fillcheck(mcp:byte): real; +{oblicza napelnienie, uzwglednia regulator obrotow} +var realfill,nreg: real; +begin + realfill:=0; + nreg:=0; + if Mains and (MainCtrlPosNo>0) then + begin + if dizel_enginestart and (LastSwitchingTime>=0.9*InitialCtrlDelay) then {wzbogacenie przy rozruchu} + realfill:=1 + else + realfill:=RList[mcp].R; {napelnienie zalezne od MainCtrlPos} + if dizel_nmax_cutoff>0 then + begin + case RList[MainCtrlPos].Mn of + 0,1: nreg:=dizel_nmin; + 2: if(dizel_automaticgearstatus=0)then + nreg:=dizel_nmax + else + nreg:=dizel_nmin; + else realfill:=0; {sluczaj} + end; + if enrot>nreg then + realfill:=realfill*(3.9-3.0*abs(enrot)/nreg); + if enrot>dizel_nmax_cutoff then + realfill:=realfill*(9.8-9.0*abs(enrot)/dizel_nmax_cutoff); + if enrot1 then + realfill:=1; + dizel_fillcheck:=realfill; +end; + +function T_MoverParameters.dizel_AutoGearCheck: boolean; +{automatycznie zmienia biegi gdy predkosc przekroczy widelki} +var OK: boolean; +begin + OK:=false; + if MotorParam[ScndCtrlActualPos].AutoSwitch and Mains then + begin + if (RList[MainCtrlPos].Mn=0) then + begin + if (dizel_engagestate>0) then + dizel_EngageSwitch(0); + if (MainCtrlPos=0) and (ScndCtrlActualPos>0) then + dizel_automaticgearstatus:=-1 + end + else + begin + if MotorParam[ScndCtrlActualPos].AutoSwitch and (dizel_automaticgearstatus=0) then {sprawdz czy zmienic biegi} + begin + if (Vel>MotorParam[ScndCtrlActualPos].mfi) and (ScndCtrlActualPos0) then + begin + dizel_automaticgearstatus:=-1; + OK:=true + end; + end; + end; + if (dizel_engage<0.1) and (dizel_automaticgearstatus<>0) then + begin + if dizel_automaticgearstatus=1 then + inc(ScndCtrlActualPos) + else + dec(ScndCtrlActualPos); + dizel_automaticgearstatus:=0; +{} dizel_EngageSwitch(1.0); {} + OK:=true; + end + end; + if Mains then + begin + if (dizel_automaticgearstatus=0) then {ustaw cisnienie w silowniku sprzegla} + case RList[MainCtrlPos].Mn of + 1: dizel_EngageSwitch(0.5); + 2: dizel_EngageSwitch(1.0); + else dizel_EngageSwitch(0.0) + end + else + dizel_EngageSwitch(0.0); + if not (MotorParam[ScndCtrlActualPos].mIsat>0) then + dizel_EngageSwitch(0.0); //wylacz sprzeglo na pozycjach neutralnych + if not AutoRelayFlag then + ScndCtrlActualPos:=ScndCtrlPos; + end; + dizel_AutoGearCheck:=OK; +end; + +function T_MoverParameters.dizel_Update(dt:real): boolean; +{odświeża informacje o silniku} +//var OK:boolean; +const fillspeed=2; +begin + //dizel_Update:=false; + if dizel_enginestart and (LastSwitchingTime>=InitialCtrlDelay) then + begin + dizel_enginestart:=false; + LastSwitchingTime:=0; + enrot:=dizel_nmin/2.0; {TODO: dac zaleznie od temperatury i baterii} + end; + {OK:=}dizel_EngageChange(dt); +// if AutoRelayFlag then Poprawka na SM03 + dizel_Update:=dizel_AutoGearCheck; +{ dizel_fill:=(dizel_fill+dizel_fillcheck(MainCtrlPos))/2; } + dizel_fill:=dizel_fill+fillspeed*dt*(dizel_fillcheck(MainCtrlPos)-dizel_fill); + //dizel_Update:=OK; +end; + + +{przyczepnosc} +function T_MoverParameters.Adhesive(staticfriction:real): real; +//var Adhesion: real; +begin + {Adhesion:=0; + case SlippingWheels of + true: + if SandDose then + Adhesion:=0.48 + else + Adhesion:=staticfriction*0.2; + false: + if SandDose then + Adhesion:=Max0R(staticfriction*(100+Vel)/(50+Vel)*1.1,0.48) + else + Adhesion:=staticfriction*(100+Vel)/(50+Vel) + end; + Adhesion:=Adhesion*(11-2*random)/10; + Adhesive:=Adhesion;} + + //ABu: male przerobki, tylko czy to da jakikolwiek skutek w FPS? + // w kazdym razie zaciemni kod na pewno :) + if SlippingWheels=false then + begin + if SandDose then + Adhesive:=(Max0R(staticfriction*(100.0+Vel)/((50.0+Vel)*11.0),0.048))*(11.0-2.0*random) + else + Adhesive:=(staticfriction*(100.0+Vel)/((50.0+Vel)*10))*(11.0-2.0*random); + end + else + begin + if SandDose then + Adhesive:=(0.048)*(11-2*random) + else + Adhesive:=(staticfriction*0.02)*(11-2*random); + end; +end; + + +{SILY} + +function T_MoverParameters.TractionForce(dt:real):real; +var PosRatio,dmoment,dtrans,tmp,tmpV: real; + i: byte; +{oblicza sile trakcyjna lokomotywy (dla elektrowozu tez calkowity prad)} +begin + Ft:=0; + dtrans:=0; + dmoment:=0; +// tmpV:=Abs(nrot*WheelDiameter/2); +//youBy + if (EngineType=DieselElectric) then + begin + tmp:=DEList[MainCtrlPos].rpm/60.0; + if (Heating) and (HeatingPower>0) and (MainCtrlPosNo>MainCtrlPos) then + begin + i:=MainCtrlPosNo; + while (DEList[i-2].rpm/60.0>tmp) do + i:=i-1; + tmp:=DEList[i].rpm/60.0 + end; + if enrot<>tmp*Byte(ConverterFlag) then + if ABS(tmp*Byte(ConverterFlag) - enrot) < 0.001 then + enrot:=tmp*Byte(ConverterFlag) + else + if (enrotDieselEngine then + enrot:=Transmision.Ratio*nrot + else //dla DieselEngine + begin + if (ShuntMode) then //dodatkowa przekładnia np. dla 2Ls150 + dtrans:=AnPos*Transmision.Ratio*MotorParam[ScndCtrlActualPos].mIsat + else + dtrans:=Transmision.Ratio*MotorParam[ScndCtrlActualPos].mIsat; + dmoment:=dizel_Momentum(dizel_fill,ActiveDir*1*dtrans*nrot,dt); {oblicza tez enrot} + end; + eAngle:=eAngle+enrot*dt; + if eAngle>Pirazy2 then + //eAngle:=Pirazy2-eAngle; <- ABu: a nie czasem tak, jak nizej? + eAngle:=eAngle-Pirazy2; + + //hunter-091012: przeniesione z if ActiveDir<>0 (zeby po zejsciu z kierunku dalej spadala predkosc wentylatorow) + if (EngineType=ElectricSeriesMotor) then + begin + case RVentType of {wentylatory rozruchowe} + 1: if ActiveDir<>0 then + RventRot:=RventRot+(RVentnmax-RventRot)*RVentSpeed*dt + else + RventRot:=RventRot*(1-RVentSpeed*dt); + 2: if (Abs(Itot)>RVentMinI) and (RList[MainCtrlActualPos].R>RVentCutOff) then + RventRot:=RventRot+(RVentnmax*Abs(Itot)/(ImaxLo*RList[MainCtrlActualPos].Bn)-RventRot)*RVentSpeed*dt + else + if (DynamicBrakeType=dbrake_automatic) and (DynamicBrakeFlag) then + RventRot:=RventRot+(RVentnmax*Im/ImaxLo-RventRot)*RVentSpeed*dt + else + begin + RventRot:=RventRot*(1-RVentSpeed*dt); + if RventRot<0.1 then RventRot:=0; + end; + end; {case} + end; {if} + + if ActiveDir<>0 then + case EngineType of + Dumb: + begin + PosRatio:=(MainCtrlPos+ScndCtrlPos)/(MainCtrlPosNo+ScndCtrlPosNo+0.01); + if Mains and (ActiveDir<>0) and (CabNo<>0) then + begin + if Vel>0.1 then + begin + Ft:=Min0R(1000.0*Power/Abs(V),Ftmax)*PosRatio; + end + else Ft:=Ftmax*PosRatio; + Ft:=Ft*DirAbsolute; //ActiveDir*CabNo; + end + else Ft:=0; + EnginePower:=1000*Power*PosRatio; + end; + WheelsDriven: + begin + if EnginePowerSource.SourceType=InternalSource then + if EnginePowerSource.PowerType=BioPower then + Ft:=sign(sin(eAngle))*PulseForce*Transmision.Ratio; + PulseForceTimer:=PulseForceTimer+dt; + if PulseForceTimer>CtrlDelay then + begin + PulseForce:=0; + if PulseForceCount>0 then + dec(PulseForceCount); + end; + EnginePower:=Ft*(1+Vel); + end; + ElectricSeriesMotor: + begin +{ enrot:=Transmision.Ratio*nrot; } + //yB: szereg dwoch sekcji w ET42 + if(TrainType=dt_ET42)and(Imax=ImaxHi)then + Voltage:=Voltage/2.0; + Mm:=Momentum(Current(enrot,Voltage)); {oblicza tez prad p/slinik} + if(TrainType=dt_ET42)then + begin + if(Imax=ImaxHi)then + Voltage:=Voltage*2; + if(DynamicBrakeFlag)and(Abs(Im)>300)then + FuseOff; + end; + if (DynamicBrakeType=dbrake_automatic)and(DynamicBrakeFlag) then + begin + if ((Vadd+Abs(Im))>760)or((Hamulec as TLSt).GetEDBCP<0.25) then + begin + Vadd:=Vadd-500*dt; + if(Vadd<1)then + Vadd:=0; + end + else if (DynamicBrakeFlag)and((Vadd+Abs(Im))<740) then + begin + Vadd:=Vadd+70*dt; + Vadd:=Min0R(Max0R(Vadd,60),400); + end; + if(Vadd>0)then Mm:=MomentumF(Im,Vadd,0); + end; + + if(TrainType=dt_ET22)and(DelayCtrlFlag)then //szarpanie przy zmianie układu w byku + Mm:=Mm*RList[MainCtrlActualPos].Bn/(RList[MainCtrlActualPos].Bn+1); //zrobione w momencie, żeby nie dawac elektryki w przeliczaniu sił + + if (Abs(Im)>Imax) then + Vhyp:=Vhyp+dt*(Abs(Im)/Imax-0.9)*10 //zwieksz czas oddzialywania na PN + else + Vhyp:=0; + if (Vhyp>CtrlDelay/2) then //jesli czas oddzialywania przekroczony + FuseOff; {wywalanie bezpiecznika z powodu przetezenia silnikow} + if (Mains) then //nie wchodzić w funkcję bez potrzeby + if (Abs(Voltage)EnginePowerSource.CollectorParameters.MaxV) then + if MainSwitch(false) then + EventFlag:=true; //wywalanie szybkiego z powodu niewłaściwego napięcia + + if (((DynamicBrakeType=dbrake_automatic)or(DynamicBrakeType=dbrake_switch)) and (DynamicBrakeFlag)) then + Itot:=Im*2 {2x2 silniki w EP09} + else if (TrainType=dt_EZT)and(Imin=IminLo)and(ScndS) then //yBARC - boczniki na szeregu poprawnie + Itot:=Im + else + Itot:=Im*RList[MainCtrlActualPos].Bn; {prad silnika * ilosc galezi} + Mw:=Mm*Transmision.Ratio; + Fw:=Mw*2.0/WheelDiameter; + Ft:=Fw*NPoweredAxles; {sila trakcyjna} + end; + DieselEngine: begin + EnginePower:=dmoment*enrot; + if MainCtrlPos>1 then + dmoment:=dmoment-dizel_Mstand*(0.2*enrot/nmax); {dodatkowe opory z powodu sprezarki} + Mm:=dizel_engage*dmoment; + Mw:=Mm*dtrans; {dmoment i dtrans policzone przy okazji enginerotation} + Fw:=Mw*2.0/WheelDiameter; + Ft:=Fw*NPoweredAxles; {sila trakcyjna} + Ft:=Ft*DirAbsolute; //ActiveDir*CabNo; + + end; + DieselElectric: //youBy + begin +// tmpV:=V*CabNo*ActiveDir; + tmpV:=nrot*Pirazy2*0.5*WheelDiameter*DirAbsolute; //*CabNo*ActiveDir; + //jazda manewrowa + if (ShuntMode) then + begin + Voltage:=(SST[MainCtrlPos].Umax * AnPos) + (SST[MainCtrlPos].Umin * (1 - AnPos)); + tmp:=(SST[MainCtrlPos].Pmax * AnPos) + (SST[MainCtrlPos].Pmin * (1 - AnPos)); + Ft:=tmp * 1000.0 / (abs(tmpV)+1.6); + PosRatio:=1; + end + else //jazda ciapongowa + begin + + tmp:=Min0R(DEList[MainCtrlPos].genpower,Power-HeatingPower*byte(Heating)); + + PosRatio:=DEList[MainCtrlPos].genpower / DEList[MainCtrlPosNo].genpower; {stosunek mocy teraz do mocy max} + if (MainCtrlPos>0) and (ConverterFlag) then + if tmpV < (Vhyp*(Power-HeatingPower*byte(Heating))/DEList[MainCtrlPosNo].genpower) then //czy na czesci prostej, czy na hiperboli + Ft:=(Ftmax - ((Ftmax - 1000.0 * DEList[MainCtrlPosNo].genpower / (Vhyp+Vadd)) * (tmpV/Vhyp) / PowerCorRatio)) * PosRatio //posratio - bo sila jakos tam sie rozklada + //Ft:=(Ftmax - (Ftmax - (1000.0 * DEList[MainCtrlPosNo].genpower / (Vhyp+Vadd) / PowerCorRatio)) * (tmpV/Vhyp)) * PosRatio //wersja z Megapacka + else //na hiperboli //1.107 - wspolczynnik sredniej nadwyzki Ft w symku nad charakterystyka + Ft:=1000.0 * tmp / (tmpV+Vadd) / PowerCorRatio //tu jest zawarty stosunek mocy + else Ft:=0; //jak nastawnik na zero, to sila tez zero + + PosRatio:=tmp/DEList[MainCtrlPosNo].genpower; + + end; + if (FuseFlag) then Ft:=0 else + Ft:=Ft*DirAbsolute; //ActiveDir * CabNo; //zwrot sily i jej wartosc + Fw:=Ft/NPoweredAxles; //sila na obwodzie kola + Mw:=Fw*WheelDiameter / 2.0; // moment na osi kola + Mm:=Mw/Transmision.Ratio; // moment silnika trakcyjnego + + + with MotorParam[ScndCtrlPos] do + if ABS(Mm) > fi then + Im:=NPoweredAxles * ABS(ABS(Mm) / mfi + mIsat) + else + Im:=NPoweredAxles * sqrt(ABS(Mm * Isat)); + + if (ShuntMode) then + begin + EnginePower:=Voltage * Im/1000.0; + if (EnginePower > tmp) then + begin + EnginePower:=tmp*1000.0; + Voltage:=EnginePower/Im; + end; + if (EnginePower < tmp) then + Ft:=Ft * EnginePower / tmp; + end + else + begin + if (ABS(Im) > DEList[MainCtrlPos].Imax) then + begin //nie ma nadmiarowego, tylko Imax i zwarcie na pradnicy + Ft:=Ft/Im*DEList[MainCtrlPos].Imax;Im:=DEList[MainCtrlPos].Imax; + end; + + if (Im > 0) then //jak pod obciazeniem + if (Flat) then //ograniczenie napiecia w pradnicy - plaszczak u gory + Voltage:=1000.0 * tmp / ABS(Im) + else //charakterystyka pradnicy obcowzbudnej (elipsa) - twierdzenie Pitagorasa + begin + Voltage:=sqrt(ABS(sqr(DEList[MainCtrlPos].Umax)-sqr(DEList[MainCtrlPos].Umax*Im/DEList[MainCtrlPos].Imax)))*(MainCtrlPos-1)+ + (1-Im/DEList[MainCtrlPos].Imax)*DEList[MainCtrlPos].Umax*(MainCtrlPosNo-MainCtrlPos); + Voltage:=Voltage/(MainCtrlPosNo-1); + Voltage:=Min0R(Voltage,(1000.0 * tmp / ABS(Im))); + if Voltage<(Im*0.05) then Voltage:=Im*0.05; + end; + if (Voltage > DEList[MainCtrlPos].Umax) or (Im = 0) then //gdy wychodzi za duze napiecie + Voltage:=DEList[MainCtrlPos].Umax * byte(ConverterFlag); //albo przy biegu jalowym (jest cos takiego?) + + EnginePower:=Voltage * Im / 1000.0; + + if (tmpV>2) and (EnginePower1) and (Im>Imax) then FuseOff; + if FuseFlag then Voltage:=0; + + //przekazniki bocznikowania, kazdy inny dla kazdej pozycji + if (MainCtrlPos = 0) or (ShuntMode) then + ScndCtrlPos:=0 + else if AutoRelayFlag then + case RelayType of + 0: begin + if (Im <= (MPTRelay[ScndCtrlPos].Iup*PosRatio)) and (ScndCtrlPos= (MPTRelay[ScndCtrlPos].Idown*PosRatio)) and (ScndCtrlPos>0) then + dec(ScndCtrlPos); + end; + 1: begin + if (MPTRelay[ScndCtrlPos].IupVel) and (ScndCtrlPos>0) then + dec(ScndCtrlPos); + end; + 2: begin + if (MPTRelay[ScndCtrlPos].Iup0) then + dec(ScndCtrlPos); + end; + 41: + begin + if (MainCtrlPos=MainCtrlPosNo) and (tmpV*3.6>MPTRelay[ScndCtrlPos].Iup) and (ScndCtrlPosMPTRelay[ScndCtrlPos].Idown)and (ScndCtrlPos>0) then + dec(ScndCtrlPos); + end; + 45: + begin + //wzrastanie + if (MainCtrlPos>11) and (ScndCtrlPosIm) then + inc(ScndCtrlPos) + else + else + if (MPTRelay[ScndCtrlPos].Iup0)and(MainCtrlPos<12)then + if (ScndCtrlPos=ScndCtrlPosNo)then + if (MPTRelay[ScndCtrlPos].IdownVel)then + dec(ScndCtrlPos); + if (MainCtrlPos<11)and(ScndCtrlPos>2) then ScndCtrlPos:=2; + if (MainCtrlPos<9)and(ScndCtrlPos>0) then ScndCtrlPos:=0; + end; + 46: + begin + //wzrastanie + if (MainCtrlPos>9) and (ScndCtrlPosIm) then + inc(ScndCtrlPos) + else + else + if (MPTRelay[ScndCtrlPos-1].Iup>Im) and (MPTRelay[ScndCtrlPos].Iup0)then + if (ScndCtrlPos) mod 2 = 0 then + if (MPTRelay[ScndCtrlPos].IdownVel)then + dec(ScndCtrlPos); + if (MainCtrlPos<9)and(ScndCtrlPos>2) then ScndCtrlPos:=2; + if (MainCtrlPos<6)and(ScndCtrlPos>0) then ScndCtrlPos:=0; + end; + end; + end; + ElectricInductionMotor: + begin + if (Voltage>1800) and (MainS) then + begin + + if ((Hamulec as TLSt).GetEDBCP<0.25)and(LocHandle.GetCP<0.25) then + DynamicBrakeFlag:=false + else if ((BrakePress>0.25) and ((Hamulec as TLSt).GetEDBCP>0.25)) or (LocHandle.GetCP>0.25) then + DynamicBrakeFlag:=true; + + if(DynamicBrakeFlag)then + begin + if eimv[eimv_Fmax]*sign(V)*DirAbsolute<-1 then + PosRatio:=-sign(V)*DirAbsolute*eimv[eimv_Fr]/(eimc[eimc_p_Fh]*Max0R((Hamulec as TLSt).GetEDBCP,LocHandle.GetCP)/MaxBrakePress[0]{dizel_fill}) + else + PosRatio:=0; + PosRatio:=round(20*Posratio)/20; + if PosRatio<19.5/20 then PosRatio:=PosRatio*0.9; + (Hamulec as TLSt).SetED(PosRatio); + PosRatio:=-Max0R((Hamulec as TLSt).GetEDBCP,LocHandle.GetCP)/MaxBrakePress[0]*Max0R(0,Min0R(1,(Vel-eimc[eimc_p_Vh0])/(eimc[eimc_p_Vh1]-eimc[eimc_p_Vh0]))); + tmp:=5; + end + else + begin + PosRatio:=(MainCtrlPos/MainCtrlPosNo); + PosRatio:=1.0*(PosRatio*0+1)*PosRatio; + (Hamulec as TLSt).SetED(0); + if (PosRatio>dizel_fill) then tmp:=1 else tmp:=4; //szybkie malenie, powolne wzrastanie + end; + if SlippingWheels then begin PosRatio:=0; tmp:=10; SandDoseOn; end;//przeciwposlizg + + dizel_fill:=dizel_fill+Max0R(Min0R(PosRatio-dizel_fill,0.1),-0.1)*2*(tmp{2{+4*byte(PosRatioeimc[eimc_p_Vh0])then + eimv[eimv_Fmax]:=-sign(V)*(DirAbsolute)*Min0R(eimc[eimc_p_Ph]*3.6/Vel,-eimc[eimc_p_Fh]*dizel_fill)//*Min0R(1,(Vel-eimc[eimc_p_Vh0])/(eimc[eimc_p_Vh1]-eimc[eimc_p_Vh0])) +// else +// eimv[eimv_Fmax]:=0 + else + eimv[eimv_Fmax]:=Min0R(Min0R(3.6*eimv[eimv_Pmax]/Max0R(Vel,1),eimc[eimc_p_F0]-Vel*eimc[eimc_p_a1]),eimv[eimv_FMAXMAX])*dizel_fill; + + eimv[eimv_ks]:=eimv[eimv_Fmax]/eimv[eimv_FMAXMAX]; + eimv[eimv_df]:=eimv[eimv_ks]*eimc[eimc_s_dfmax]; + eimv[eimv_fp]:=DirAbsolute*enrot*eimc[eimc_s_p]+eimv[eimv_df]; +// eimv[eimv_U]:=Max0R(eimv[eimv_Uzsmax],Min0R(eimc[eimc_f_cfu]*eimv[eimv_fp],eimv[eimv_Uzsmax])); +// eimv[eimv_pole]:=eimv[eimv_U]/(eimv[eimv_fp]*eimc[eimc_s_cfu]); + if(abs(eimv[eimv_fp])<=eimv[eimv_fkr])then + eimv[eimv_pole]:=eimc[eimc_f_cfu]/eimc[eimc_s_cfu] + else + eimv[eimv_pole]:=eimv[eimv_Uzsmax]/eimc[eimc_s_cfu]/abs(eimv[eimv_fp]); + eimv[eimv_U]:=eimv[eimv_pole]*eimv[eimv_fp]*eimc[eimc_s_cfu]; + eimv[eimv_Ic]:=(eimv[eimv_fp]-DirAbsolute*enrot*eimc[eimc_s_p])*eimc[eimc_s_dfic]*eimv[eimv_pole]; + eimv[eimv_If]:=eimv[eimv_Ic]*eimc[eimc_s_icif]; + eimv[eimv_M]:=eimv[eimv_pole]*eimv[eimv_Ic]*eimc[eimc_s_cim]; + eimv[eimv_Ipoj]:=(eimv[eimv_Ic]*NPoweredAxles*eimv[eimv_U])/(Voltage-eimc[eimc_f_DU])+eimc[eimc_f_I0]; + eimv[eimv_Pm]:=ActiveDir*eimv[eimv_M]*NPoweredAxles*enrot*Pirazy2/1000; + eimv[eimv_Pe]:=eimv[eimv_Ipoj]*Voltage/1000; + eimv[eimv_eta]:=eimv[eimv_Pm]/eimv[eimv_Pe]; + + Im:=eimv[eimv_If]; + Itot:=eimv[eimv_Ipoj]; + + + EnginePower:=Abs(eimv[eimv_Ic]*eimv[eimv_U]*NPoweredAxles)/1000; + tmpV:=eimv[eimv_fp]; + if (abs(eimv[eimv_If])>1) or (abs(tmpV)>0.1) then + begin + if abs(tmpV)<32 then RventRot:=1.0 else + if abs(tmpV)<39 then RventRot:=0.33*abs(tmpV)/32 else + RventRot:=0.25*abs(tmpV)/39;//} + end + else RVentRot:=0; + + Mm:=eimv[eimv_M]*DirAbsolute; + Mw:=Mm*Transmision.Ratio; + Fw:=Mw*2.0/WheelDiameter; + Ft:=Fw*NPoweredAxles; + eimv[eimv_Fr]:=DirAbsolute*Ft/1000; +// RventRot; + end + else + begin + Im:=0;Mm:=0;Mw:=0;Fw:=0;Ft:=0;Itot:=0;dizel_fill:=0;EnginePower:=0; + (Hamulec as TLSt).SetED(0);RventRot:=0.0; + end; + end; + None: begin end; + end; {case EngineType} + TractionForce:=Ft +end; + +function T_MoverParameters.BrakeForce(Track:TTrackParam):real; +var K,Fb,NBrakeAxles,sm:real; +//const OerlikonForceFactor=1.5; +begin + K:=0; + if NPoweredAxles>0 then + NBrakeAxles:=NPoweredAxles + else + NBrakeAxles:=NAxles; + case LocalBrake of + NoBrake : K:=0; + ManualBrake : K:=MaxBrakeForce*ManualBrakeRatio; + HydraulicBrake : K:=MaxBrakeForce*LocalBrakeRatio; + PneumaticBrake:if CompressorNtotal)then //histereza na nacisku klockow + Ntotal:=u*BrakeRigEff + else + begin + u:=(BrakePress*P2FTrans)*BrakeCylMult[0]-BrakeSlckAdj; + if (u*(2-1*BrakeRigEff)0) then + begin + if Ntotal>0 then {nie luz} + K:=K+Ntotal; {w kN} + K:=K*BrakeCylNo/(NBrakeAxles*NBpA); {w kN na os} + end; + if (BrakeSystem=Pneumatic)or(BrakeSystem=ElectroPneumatic) then + begin + u:=Hamulec.GetFC(Vel, K); + UnitBrakeForce:=u*K*1000; {sila na jeden klocek w N} + end + else + UnitBrakeForce:=K*1000; + if (NBpA*UnitBrakeForce>TotalMassxg*Adhesive(RunningTrack.friction)/NAxles) and (Abs(V)>0.001) then + {poslizg} + begin +{ Fb:=Adhesive(Track.friction)*Mass*g; } + SlippingWheels:=true; + end; +{ else + begin +{ SlippingWheels:=false;} +// if (LocalBrake=ManualBrake)or(MBrake=true)) and (BrakePress<0.3) then +// Fb:=UnitBrakeForce*NBpA {ham. reczny dziala na jedna os} +// else //yB: to nie do konca ma sens, ponieważ ręczny w wagonie działa na jeden cylinder hamulcowy/wózek, dlatego potrzebne są oddzielnie liczone osie + Fb:=UnitBrakeForce*NBrakeAxles*NBpA; + +// u:=((BrakePress*P2FTrans)-BrakeCylSpring*BrakeCylMult[BCMFlag]/BrakeCylNo-0.83*BrakeSlckAdj/(BrakeCylNo))*BrakeCylNo; + { end; } + BrakeForce:=Fb; +end; + +function T_MoverParameters.CouplerForce(CouplerN:byte;dt:real):real; +//wyliczenie siły na sprzęgu +var tempdist,newdist,distDelta,CF,dV,absdv,Fmax,BetaAvg:real; CNext:byte; +const MaxDist=405.0; {ustawione + 5 m, bo skanujemy do 400 m } + MinDist=0.5; {ustawione +.5 m, zeby nie rozlaczac przy malych odleglosciach} + MaxCount=1500; +begin + CF:=0; + //distDelta:=0; //Ra: value never used + CNext:=Couplers[CouplerN].ConnectedNr; +{ if Couplers[CouplerN].CForce=0 then {nie bylo uzgadniane wiec policz} + with Couplers[CouplerN] do + begin + CheckCollision:=false; + newdist:=CoupleDist; //odległość od sprzęgu sąsiada + //newdist:=Distance(Loc,Connected^.Loc,Dim,Connected^.Dim); + if (CouplerN=0) then + begin + //ABu: bylo newdist+10*((... + tempdist:=((Connected.dMoveLen*DirPatch(0,ConnectedNr))-dMoveLen); + newdist:=newdist+10.0*tempdist; + //tempdist:=tempdist+CoupleDist; //ABu: proby szybkiego naprawienia bledu + end + else + begin + //ABu: bylo newdist+10*((... + tempdist:=((dMoveLen-(Connected.dMoveLen*DirPatch(1,ConnectedNr)))); + newdist:=newdist+10.0*tempdist; + //tempdist:=tempdist+CoupleDist; //ABu: proby szybkiego naprawienia bledu + end; + + //blablabla + //ABu: proby znalezienia problemu ze zle odbijajacymi sie skladami + //***if (Couplers[CouplerN].CouplingFlag=ctrain_virtual) and (newdist>0) then + if (Couplers[CouplerN].CouplingFlag=ctrain_virtual) and (CoupleDist>0) then + begin + CF:=0; {kontrola zderzania sie - OK} + inc(ScanCounter); + if (newdist>MaxDist) or ((ScanCounter>MaxCount)and(newdist>MinDist)) then + //***if (tempdist>MaxDist) or ((ScanCounter>MaxCount)and(tempdist>MinDist)) then + begin {zerwij kontrolnie wirtualny sprzeg} + //Connected.Couplers[CNext].Connected:=nil; //Ra: ten podłączony niekoniecznie jest wirtualny + Connected:=nil; + ScanCounter:=Random(500); + end; + end + else + begin + if CouplingFlag=ctrain_virtual then + begin + BetaAvg:=beta; + Fmax:=(FmaxC+FmaxB)*CouplerTune; + end + else {usrednij bo wspolny sprzeg} + begin + BetaAvg:=(beta+Connected.Couplers[CNext].beta)/2.0; + Fmax:=(FmaxC+FmaxB+Connected.Couplers[CNext].FmaxC+Connected.Couplers[CNext].FmaxB)*CouplerTune/2.0; + end; + dV:=V-DirPatch(CouplerN,CNext)*Connected.V; + absdv:=abs(dV); + if (newdist<-0.001) and (Dist>=-0.001) and (absdv>0.010) then {090503: dzwieki pracy zderzakow} + begin + if SetFlag(SoundFlag,sound_bufferclamp) then + if absdV>0.5 then + SetFlag(SoundFlag,sound_loud); + end + else + if (newdist>0.002) and (Dist<=0.002) and (absdv>0.005) then {090503: dzwieki pracy sprzegu} + begin + if CouplingFlag>0 then + if SetFlag(SoundFlag,sound_couplerstretch) then + if absdV>0.1 then + SetFlag(SoundFlag,sound_loud); + end; + distDelta:=abs(newdist)-abs(Dist); //McZapkie-191103: poprawka na histereze + Dist:=newdist; + if Dist>0 then + begin + if distDelta>0 then + CF:=(-(SpringKC+Connected.Couplers[CNext].SpringKC)*Dist/2.0)*DirF(CouplerN)-Fmax*dV*betaAvg + else + CF:=(-(SpringKC+Connected.Couplers[CNext].SpringKC)*Dist/2.0)*DirF(CouplerN)*betaAvg-Fmax*dV*betaAvg; + {liczenie sily ze sprezystosci sprzegu} + if Dist>(DmaxC+Connected.Couplers[CNext].DmaxC) then {zderzenie} + //***if tempdist>(DmaxC+Connected^.Couplers[CNext].DmaxC) then {zderzenie} + CheckCollision:=true; + end; + if Dist<0 then + begin + if distDelta>0 then + CF:=(-(SpringKB+Connected.Couplers[CNext].SpringKB)*Dist/2.0)*DirF(CouplerN)-Fmax*dV*betaAvg + else + CF:=(-(SpringKB+Connected.Couplers[CNext].SpringKB)*Dist/2.0)*DirF(CouplerN)*betaAvg-Fmax*dV*betaAvg; + {liczenie sily ze sprezystosci zderzaka} + if -Dist>(DmaxB+Connected.Couplers[CNext].DmaxB) then {zderzenie} + //***if -tempdist>(DmaxB+Connected^.Couplers[CNext].DmaxB)/10 then {zderzenie} + begin + CheckCollision:=true; + if (CouplerType=Automatic) and (CouplingFlag=0) then {sprzeganie wagonow z samoczynnymi sprzegami} + //CouplingFlag:=ctrain_coupler+ctrain_pneumatic+ctrain_controll+ctrain_passenger+ctrain_scndpneumatic; + CouplingFlag:=ctrain_coupler+ctrain_pneumatic+ctrain_controll; //EN57 + end; + end; + end; + if (CouplingFlag<>ctrain_virtual) + then {uzgadnianie prawa Newtona} + Connected.Couplers[1-CouplerN].CForce:=-CF; + end; + CouplerForce:=CF; +end; + +procedure T_MoverParameters.CollisionDetect(CouplerN:byte; dt:real); +var CCF,Vprev,VprevC:real; VirtualCoupling:boolean; +begin + CCF:=0; + with Couplers[CouplerN] do + if (Connected<>nil) then + begin + VirtualCoupling:=(CouplingFlag=ctrain_virtual); + Vprev:=V; + VprevC:=Connected.V; + case CouplerN of + 0 : CCF:=ComputeCollision(V,Connected.V,TotalMass,Connected.TotalMass,(beta+Connected.Couplers[ConnectedNr].beta)/2.0,VirtualCoupling)/(dt{+0.01}); //yB: ej ej ej, a po + 1 : CCF:=ComputeCollision(Connected.V,V,Connected.TotalMass,TotalMass,(beta+Connected.Couplers[ConnectedNr].beta)/2.0,VirtualCoupling)/(dt{+0.01}); //czemu tu jest +0.01?? + end; + AccS:=AccS+(V-Vprev)/dt; //korekta przyspieszenia o siły wynikające ze zderzeń? + Connected.AccS:=Connected.AccS+(Connected.V-VprevC)/dt; + if (Dist>0) and (not VirtualCoupling) then + if FuzzyLogic(Abs(CCF),5*(FmaxC+1),p_coupldmg) then + begin {! zerwanie sprzegu} + if SetFlag(DamageFlag,dtrain_coupling) then + EventFlag:=true; + if (Couplers[CouplerN].CouplingFlag and ctrain_pneumatic>0) then + EmergencyBrakeFlag:=true; {hamowanie nagle - zerwanie przewodow hamulcowych} + CouplingFlag:=0; + case CouplerN of {wyzerowanie flag podlaczenia ale ciagle sa wirtualnie polaczone} + 0 : Connected.Couplers[1].CouplingFlag:=0; + 1 : Connected.Couplers[0].CouplingFlag:=0; + end + end ; + end; +end; + +procedure T_MoverParameters.ComputeConstans; +var BearingF,RollF,HideModifier: real; + Curvature: real; //Ra 2014-07: odwrotność promienia +begin + TotalCurrent:=0; //Ra 2014-04: tu zerowanie, aby EZT mogło pobierać prąd innemu członowi + TotalMass:=ComputeMass; + TotalMassxg:=TotalMass*g; {TotalMass*g} + BearingF:=2*(DamageFlag and dtrain_bearing); + + HideModifier:=0;//Byte(Couplers[0].CouplingFlag>0)+Byte(Couplers[1].CouplingFlag>0); + with Dim do + begin + if BearingType=0 then + RollF:=0.05 {slizgowe} + else + RollF:=0.015; {toczne} + RollF:=RollF+BearingF/200.0; + +(* if NPoweredAxles>0 then + RollF:=RollF*1.5; {dodatkowe lozyska silnikow}*) + if (NPoweredAxles>0) then //drobna optymalka + begin + RollF:=RollF+0.025; +{ if(Ft*Ft<1)then + HideModifier:=HideModifier-3; } + end; + Ff:=TotalMassxg*(BearingF+RollF*V*V/10.0)/1000.0; + {dorobic liczenie temperatury lozyska!} + FrictConst1:=((TotalMassxg*RollF)/10000.0)+(Cx*W*H); + Curvature:=abs(RunningShape.R); //zero oznacza nieskończony promień + if (Curvature>0.0) then Curvature:=1.0/Curvature; + //opór składu na łuku (youBy): +(500*TrackW/R)*TotalMassxg*0.001 do FrictConst2s/d + FrictConst2s:= (TotalMassxg*((500.0*TrackW*Curvature)+ 2.5 - HideModifier + 2*BearingF/dtrain_bearing))*0.001; + FrictConst2d:= (TotalMassxg*((500.0*TrackW*Curvature)+ 2.0 - HideModifier + BearingF/dtrain_bearing))*0.001; + end; +end; + +(* poprawione opory ruchu czekajace na lepsze cx w chk +procedure T_MoverParameters.ComputeConstans2(R:real); +var BearingF,RollF,HideModifier: real; +begin + TotalMass:=ComputeMass; + TotalMassxg:=TotalMass*g; {TotalMass*g} + BearingF:=2*(DamageFlag and dtrain_bearing); + + HideModifier:=Byte(Couplers[0].CouplingFlag>0)+Byte(Couplers[1].CouplingFlag>0); + with Dim do + begin + if BearingType=0 then + RollF:=10 {slizgowe} + else + RollF:=8; {toczne} + if NPoweredAxles>0 then + RollF:=RollF+2; {dodatkowe lozyska silnikow} + + RollF:=RollF+BearingF/100.0; //stala do ustalenia + + {dorobic liczenie temperatury lozyska!} + //stale do wzoru CNTK + FrictConst1:=(Cx*W*H)*(6.0-2.5*HideModifier)/100; //dwa czola, kazde ma +2.5 (lokomotywa i wagon) //V2 + FrictConst2s:=Totalmass*0.001*0.15; //V1 + if(R0.01) then + FrictionForce:=(FrictConst1*V*V)+FrictConst2d + else + FrictionForce:=(FrictConst1*V*V)+FrictConst2s; +end; + +(* poprawione opory ruchu czekajace na lepsze cx w chk +function T_MoverParameters.FrictionForce2(R:real;TDamage:byte):real; +begin +//ABu 240205: chyba juz ekstremalnie zoptymalizowana funkcja liczaca sily tarcia + FrictionForce2:=(FrictConst1*Vel*Vel)+(FrictConst2s*Vel)+FrictConst2d; +end; *) + +function T_MoverParameters.AddPulseForce(Multipler:integer): boolean; {dla drezyny} +begin + if (EngineType=WheelsDriven) and (EnginePowerSource.SourceType=InternalSource) and (EnginePowerSource.PowerType=BioPower) then + begin + ActiveDir:=CabNo; + DirAbsolute:=ActiveDir*CabNo; + if Vel>0 then + PulseForce:=Min0R(1000.0*Power/(Abs(V)+0.1),Ftmax) + else PulseForce:=Ftmax; + if PulseForceCount>1000.0 then + PulseForce:=0 + else + PulseForce:=PulseForce*Multipler; + PulseForceCount:=PulseForceCount+Abs(Multipler); + AddPulseForce:=(PulseForce>0); + end + else AddPulseForce:=false; +end; + + +function T_MoverParameters.LoadingDone(LSpeed:real; LoadInit:string): boolean; +//test zakończenia załadunku/rozładunku +var LoadChange:longint; +begin + ClearPendingExceptions; //zabezpieczenie dla Trunc() + //LoadingDone:=false; //nie zakończone + if (LoadInit<>'') then //nazwa ładunku niepusta + begin + if Load>MaxLoad then + LoadChange:=Abs(Trunc(LSpeed*LastLoadChangeTime/2.0)) //przeładowanie? + else + LoadChange:=Abs(Trunc(LSpeed*LastLoadChangeTime)); + if LSpeed<0 then //gdy rozładunek + begin + LoadStatus:=2; //trwa rozładunek (włączenie naliczania czasu) + if LoadChange<>0 then //jeśli coś przeładowano + begin + LastLoadChangeTime:=0; //naliczony czas został zużyty + Load:=Load-LoadChange; //zmniejszenie ilości ładunku + CommandIn.Value1:=CommandIn.Value1-LoadChange; //zmniejszenie ilości do rozładowania + if Load<0 then + Load:=0; //ładunek nie może być ujemny + if (Load=0) or (CommandIn.Value1<0) then //pusto lub rozładowano żądaną ilość + LoadStatus:=4; //skończony rozładunek + if Load=0 then LoadType:=''; //jak nic nie ma, to nie ma też nazwy + end + end + else if LSpeed>0 then //gdy załadunek + begin + LoadStatus:=1; //trwa załadunek (włączenie naliczania czasu) + if LoadChange<>0 then //jeśli coś przeładowano + begin + LastLoadChangeTime:=0; //naliczony czas został zużyty + LoadType:=LoadInit; //nazwa + Load:=Load+LoadChange; //zwiększenie ładunku + CommandIn.Value1:=CommandIn.Value1-LoadChange; + if (Load>=MaxLoad*(1+OverLoadFactor)) or (CommandIn.Value1<0) then + LoadStatus:=4; //skończony załadunek + end + end + else LoadStatus:=4; //zerowa prędkość zmiany, to koniec + end; + LoadingDone:=(LoadStatus>=4); +end; + +{-------------------------------------------------------------------} +{WAZNA FUNKCJA - oblicza siłę wypadkową} +procedure T_MoverParameters.ComputeTotalForce(dt: real; dt1: real; FullVer: boolean); +var b: byte; +begin + if PhysicActivation then + begin + { EventFlag:=false; {jesli cos sie zlego wydarzy to ustawiane na true} + { SoundFlag:=0; {jesli ma byc jakis dzwiek to zapalany jet odpowiedni bit} + {to powinno byc zerowane na zewnatrz} + + //juz zoptymalizowane: + FStand:=FrictionForce(RunningShape.R,RunningTrack.DamageFlag); //siła oporów ruchu + Vel:=Abs(V)*3.6; //prędkość w km/h + nrot:=V2n(); //przeliczenie prędkości liniowej na obrotową + + if TestFlag(BrakeMethod,bp_MHS) and (PipePress<3.0) and (Vel>45) and TestFlag(BrakeDelayFlag,bdelay_M) then //ustawione na sztywno na 3 bar + FStand:=Fstand+{(RunningTrack.friction)*}TrackBrakeForce; //doliczenie hamowania hamulcem szynowym + //w charakterystykach jest wartość siły hamowania zamiast nacisku +// if(FullVer=true) then +// begin //ABu: to dla optymalizacji, bo chyba te rzeczy wystarczy sprawdzac 1 raz na klatke? + LastSwitchingTime:=LastSwitchingTime+dt1; + if EngineType=ElectricSeriesMotor then + LastRelayTime:=LastRelayTime+dt1; +// end; + if Mains and {(Abs(CabNo)<2) and} (EngineType=ElectricSeriesMotor) then //potem ulepszyc! pantogtrafy! + begin //Ra 2014-03: uwzględnienie kierunku jazdy w napięciu na silnikach, a powinien być zdefiniowany nawrotnik + if CabNo=0 then + Voltage:=RunningTraction.TractionVoltage*ActiveDir + else + Voltage:=RunningTraction.TractionVoltage*DirAbsolute; //ActiveDir*CabNo; + end {bo nie dzialalo} + else + Voltage:=0; + if Mains and {(Abs(CabNo)<2) and} (EngineType=ElectricInductionMotor) then //potem ulepszyc! pantogtrafy! + Voltage:=RunningTraction.TractionVoltage; + //end; + + if Power>0 then + FTrain:=TractionForce(dt) + else + FTrain:=0; + Fb:=BrakeForce(RunningTrack); + if Max0R(Abs(FTrain),Fb)>TotalMassxg*Adhesive(RunningTrack.friction) then {poslizg} + SlippingWheels:=true; + if SlippingWheels then + begin + { TrainForce:=TrainForce-Fb; } + nrot:=ComputeRotatingWheel((FTrain-Fb*Sign(V)-Fstand)/NAxles-Sign(nrot*Pi*WheelDiameter-V)*Adhesive(RunningTrack.friction)*TotalMass,dt,nrot); + FTrain:=sign(FTrain)*TotalMassxg*Adhesive(RunningTrack.friction); + Fb:=Min0R(Fb,TotalMassxg*Adhesive(RunningTrack.friction)); + end; + { else SlippingWheels:=false; } + { FStand:=0; } + for b:=0 to 1 do + if (Couplers[b].Connected<>nil) {and (Couplers[b].CouplerType<>Bare) and (Couplers[b].CouplerType<>Articulated)} then + begin //doliczenie sił z innych pojazdów + Couplers[b].CForce:=CouplerForce(b,dt); + FTrain:=FTrain+Couplers[b].CForce + end + else Couplers[b].CForce:=0; + //FStand:=Fb+FrictionForce(RunningShape.R,RunningTrack.DamageFlag); + FStand:=Fb+FStand; + FTrain:=FTrain+TotalMassxg*RunningShape.dHtrack; //doliczenie składowej stycznej grawitacji + {!niejawne przypisanie zmiennej!} + FTotal:=FTrain-Sign(V)*FStand; + end; + + {McZapkie-031103: sprawdzanie czy warto liczyc fizyke i inne updaty} + {ABu 300105: cos tu mieszalem , dziala teraz troche lepiej, wiec zostawiam + zakomentowalem PhysicActivationFlag bo cos nie dzialalo i fizyka byla + liczona zawsze.} + //if PhysicActivationFlag then + // begin + if (CabNo=0) and (Vel<0.0001) and (abs(AccS)<0.0001) and (TrainType<>dt_EZT) then + begin + if not PhysicActivation then + begin + if Couplers[0].Connected<>nil then + if (Couplers[0].Connected.Vel>0.0001) or (Abs(Couplers[0].Connected.AccS)>0.0001) then + Physic_ReActivation; + if Couplers[1].Connected<>nil then + if (Couplers[1].Connected.Vel>0.0001) or (Abs(Couplers[1].Connected.AccS)>0.0001) then + Physic_ReActivation; + end; + if LastSwitchingTime>5 then //10+Random(100) then + PhysicActivation:=false; {zeby nie brac pod uwage braku V po uruchomieniu programu} + end + else + PhysicActivation:=true; + // end; + +end; + +{------------------------------------------------------------} +{OBLICZENIE PRZEMIESZCZENIA} +function T_MoverParameters.ComputeMovement(dt:real; dt1:real; Shape:TTrackShape; var Track:TTrackParam; var ElectricTraction:TTractionParam; NewLoc:TLocation; var NewRot:TRotation):real; +var b:byte; + Vprev,AccSprev:real; +// Iheat:real; prad ogrzewania +const Vepsilon=1e-5; Aepsilon=1e-3; //ASBSpeed=0.8; +begin +{ + for b:=0 to 1 do //przekazywanie napiec + if ((Couplers[b].CouplingFlag and ctrain_power) = ctrain_power)or(((Couplers[b].CouplingFlag and ctrain_heating) = ctrain_heating)and(Heating)) then + begin + HVCouplers[1-b][1]:=Max0R(Abs(Voltage),Couplers[b].Connected.HVCouplers[Couplers[b].ConnectedNr][1]); + end + else + HVCouplers[1-b][1]:=Max0R(Abs(Voltage),0); + end; + + for b:=0 to 1 do //przekazywanie pradow + if ((Couplers[b].CouplingFlag and ctrain_power) = ctrain_power)or(((Couplers[b].CouplingFlag and ctrain_heating) = ctrain_heating)and(Heating)) then //jesli spiety + begin + if (HVCouplers[b][1]) > 1 then //przewod pod napiecie + HVCouplers[b][0]:=Couplers[b].Connected.HVCouplers[1-Couplers[b].ConnectedNr][0]+Iheat//obciążenie + else + HVCouplers[b][0]:=0; + end + else //pierwszy pojazd + begin + if (HVCouplers[b][1]) > 1 then //pod napieciem + HVCouplers[b][0]:=0+Iheat//obciążenie + else + HVCouplers[b][0]:=0; + end; +} + + ClearPendingExceptions; + if not TestFlag(DamageFlag,dtrain_out) then + begin //Ra: to przepisywanie tu jest bez sensu + RunningShape:=Shape; + RunningTrack:=Track; + RunningTraction:=ElectricTraction; + with ElectricTraction do + if not DynamicBrakeFlag then + RunningTraction.TractionVoltage:=TractionVoltage-Abs(TractionResistivity*(Itot+HVCouplers[0][0]+HVCouplers[1][0])) + else + RunningTraction.TractionVoltage:=TractionVoltage-Abs(TractionResistivity*Itot*0); //zasadniczo ED oporowe nie zmienia napięcia w sieci + end; + if CategoryFlag=4 then + OffsetTrackV:=TotalMass/(Dim.L*Dim.W*1000.0) + else + if TestFlag(CategoryFlag,1) and TestFlag(RunningTrack.CategoryFlag,1) then + if TestFlag(DamageFlag,dtrain_out) then + begin + OffsetTrackV:=-0.2; OffsetTrackH:=sign(RunningShape.R)*0.2; + end; + Loc:=NewLoc; + Rot:=NewRot; + with NewRot do begin Rx:=0; Ry:=0; Rz:=0; end; + if dL=0 then {oblicz przesuniecie} + begin + Vprev:=V; + AccSprev:=AccS; + {dt:=ActualTime-LastUpdatedTime;} {przyrost czasu} + {przyspieszenie styczne} + AccS:=(FTotal/TotalMass+AccSprev)/2.0; //prawo Newtona ale z wygladzaniem (średnia z poprzednim) + + if TestFlag(DamageFlag,dtrain_out) then + AccS:=-Sign(V)*g*Random; + {przyspieszenie normalne} + if Abs(Shape.R)>0.01 then + AccN:=SQR(V)/Shape.R+g*Shape.dHrail/TrackW + else AccN:=g*Shape.dHrail/TrackW; + + {szarpanie} + if FuzzyLogic((10+Track.DamageFlag)*Mass*Vel/Vmax,500000,p_accn) then {Ra: czemu tu masa bez ładunku?} + AccV:=sqrt((1+Track.DamageFlag)*random(Trunc(50*Mass/1000000.0))*Vel/(Vmax*(10+(Track.QualityFlag and 31)))) + else + AccV:=AccV/2.0; + if AccV>1.0 then + AccN:=AccN+(7-random(5))*(100.0+Track.DamageFlag/2.0)*AccV/2000.0; + + {wykolejanie na luku oraz z braku szyn} + if TestFlag(CategoryFlag,1) then + begin + if FuzzyLogic((AccN/g)*(1+0.1*(Track.DamageFlag and dtrack_freerail)),TrackW/Dim.H,1) + or TestFlag(Track.DamageFlag,dtrack_norail) then + if SetFlag(DamageFlag,dtrain_out) then + begin + EventFlag:=true; + MainS:=false; + RunningShape.R:=0; + if (TestFlag(Track.DamageFlag,dtrack_norail)) then + DerailReason:=1 //Ra: powód wykolejenia: brak szyn + else + DerailReason:=2; //Ra: powód wykolejenia: przewrócony na łuku + end; + {wykolejanie na poszerzeniu toru} + if FuzzyLogic(Abs(Track.Width-TrackW),TrackW/10.0,1) then + if SetFlag(DamageFlag,dtrain_out) then + begin + EventFlag:=true; + MainS:=false; + RunningShape.R:=0; + DerailReason:=3; //Ra: powód wykolejenia: za szeroki tor + end; + end; + {wykolejanie wkutek niezgodnosci kategorii toru i pojazdu} + if not TestFlag(RunningTrack.CategoryFlag,CategoryFlag) then + if SetFlag(DamageFlag,dtrain_out) then + begin + EventFlag:=true; + MainS:=false; + DerailReason:=4; //Ra: powód wykolejenia: nieodpowiednia trajektoria + end; + + V:=V+(3*AccS-AccSprev)*dt/2.0; {przyrost predkosci} + + if TestFlag(DamageFlag,dtrain_out) then + if Vel<1 then + begin + V:=0; + AccS:=0; + end; + + if (V*Vprev<=0) and (Abs(FStand)>Abs(FTrain)) then {tlumienie predkosci przy hamowaniu} + begin {zahamowany} + V:=0; + //AccS:=0; //Ra 2014-03: ale siła grawitacji działa, więc nie może być zerowe + end; + (* + else + if (Abs(V)0.01 then +// AccN:=SQR(V)/Shape.R+g*Shape.dHrail/TrackW +// else AccN:=g*Shape.dHrail/TrackW; + + {szarpanie} + if FuzzyLogic((10+Track.DamageFlag)*Mass*Vel/Vmax,500000,p_accn) then + AccV:=sqrt((1+Track.DamageFlag)*random(Trunc(50*Mass/1000000.0))*Vel/(Vmax*(10+(Track.QualityFlag and 31)))) + else + AccV:=AccV/2.0; + if AccV>1.0 then + AccN:=AccN+(7-random(5))*(100.0+Track.DamageFlag/2.0)*AccV/2000.0; + +// {wykolejanie na luku oraz z braku szyn} +// if TestFlag(CategoryFlag,1) then +// begin +// if FuzzyLogic((AccN/g)*(1+0.1*(Track.DamageFlag and dtrack_freerail)),TrackW/Dim.H,1) +// or TestFlag(Track.DamageFlag,dtrack_norail) then +// if SetFlag(DamageFlag,dtrain_out) then +// begin +// EventFlag:=true; +// MainS:=false; +// RunningShape.R:=0; +// end; +// {wykolejanie na poszerzeniu toru} +// if FuzzyLogic(Abs(Track.Width-TrackW),TrackW/10,1) then +// if SetFlag(DamageFlag,dtrain_out) then +// begin +// EventFlag:=true; +// MainS:=false; +// RunningShape.R:=0; +// end; +// end; +// {wykolejanie wkutek niezgodnosci kategorii toru i pojazdu} +// if not TestFlag(RunningTrack.CategoryFlag,CategoryFlag) then +// if SetFlag(DamageFlag,dtrain_out) then +// begin +// EventFlag:=true; +// MainS:=false; +// end; + + V:=V+(3.0*AccS-AccSprev)*dt/2.0; {przyrost predkosci} + + if TestFlag(DamageFlag,dtrain_out) then + if Vel<1 then + begin + V:=0; + AccS:=0; //Ra 2014-03: ale siła grawitacji działa, więc nie może być zerowe + end; + + if (V*Vprev<=0) and (Abs(FStand)>Abs(FTrain)) then {tlumienie predkosci przy hamowaniu} + begin {zahamowany} + V:=0; + AccS:=0; + end; + dL:=(3*V-Vprev)*dt/2.0; {metoda Adamsa-Bashfortha} + {ale jesli jest kolizja (zas. zach. pedu) to...} + for b:=0 to 1 do + if Couplers[b].CheckCollision then + CollisionDetect(b,dt); {zmienia niejawnie AccS, V !!!} + end; {liczone dL, predkosc i przyspieszenie} + + {Ra: reszta przeniesiona do Mover.cpp} +end; {FastComputeMovement} + + + +function T_MoverParameters.ComputeMass: real; +var M:real; +begin + if Load>0 then + begin //zakładamy, że ładunek jest pisany małymi literami + if LoadQuantity='tonns' then + M:=Load*1000 + else if (LoadType='passengers') then + M:=Load*80 + else if LoadType='luggage' then + M:=Load*100 + else if LoadType='cars' then + M:=Load*800 + else if LoadType='containers' then + M:=Load*8000 + else if LoadType='transformers' then + M:=Load*50000 + else + M:=Load*1000; + end + else + M:=0; + {Ra: na razie tak, ale nie wszędzie masy wirujące się wliczają} + ComputeMass:=Mass+M+Mred; +end; + + + +{-----------------------------------------------------------------} +{funkcje wejscia/wyjscia} + +{przekazywanie komend i parametrow} + +function T_MoverParameters.SetInternalCommand(NewCommand:string; NewValue1,NewValue2:real):boolean; +begin + if (CommandIn.Command=Newcommand) and (commandIn.Value1=NewValue1) and (commandIn.Value2=NewValue2) then + SetInternalCommand:=false + else + with CommandIn do + begin + Command:=NewCommand; + Value1:=NewValue1; + Value2:=NewValue2; + SetInternalCommand:=true; + LastLoadChangeTime:=0; //zerowanie czasu (roz)ładowania + end; +end; + +function T_MoverParameters.GetExternalCommand(var Command:string):real; +begin + Command:=CommandOut; + GetExternalCommand:=ValueOut; +end; + +function T_MoverParameters.DoorBlockedFlag:Boolean; +begin + //if (DoorBlocked=true) and (Vel<5.0) then + DoorBlockedFlag:=false; + if (DoorBlocked=true) and (Vel>=5.0) then + DoorBlockedFlag:=true +end; + +function T_MoverParameters.RunCommand(command:string; CValue1,CValue2:real):boolean; +//wysłanie komendy otrzymanej z kierunku CValue2 (względem sprzęgów: 1=przod,-1=tył) +// Ra: Jest tu problem z rekurencją. Trzeba by oddzielić wykonywanie komend od mechanizmu +// ich propagacji w składzie. Osobnym problemem może być propagacja tylko w jedną stronę. +// Jeśli jakiś człon jest wstawiony odwrotnie, to również odwrotnie musi wykonywać +// komendy związane z kierunkami (PantFront, PantRear, DoorLeft, DoorRight). +// Komenda musi być zdefiniowana tutaj, a jeśli się wywołuje funkcję, to ona nie może +// sama przesyłać do kolejnych pojazdów. Należy też się zastanowić, czy dla uzyskania +// jakiejś zmiany (np. IncMainCtrl) lepiej wywołać funkcję, czy od razu wysłać komendę. +var OK:boolean; testload:string; +Begin +{$B+} {cholernie mi sie nie podoba ta dyrektywa!!!} + OK:=false; + ClearPendingExceptions(); + + {test komend sterowania ukrotnionego} + if command='MainCtrl' then + begin + if MainCtrlPosNo>=Trunc(CValue1) then + MainCtrlPos:=Trunc(CValue1); + OK:=SendCtrlToNext(command,CValue1,CValue2); + end + else if command='ScndCtrl' then + begin + if ScndCtrlPosNo>=Trunc(CValue1) then + ScndCtrlPos:=Trunc(CValue1); + OK:=SendCtrlToNext(command,CValue1,CValue2); + end +(* else if command='BrakeCtrl' then + begin + if BrakeCtrlPosNo>=Trunc(CValue1) then + begin + BrakeCtrlPos:=Trunc(CValue1); + OK:=SendCtrlToNext(command,CValue1,CValue2); + end; + end *) + else if command='Brake' then //youBy - jak sie EP hamuje, to trza sygnal wyslac... + begin + Hamulec.SetEPS(CValue1); + //fBrakeCtrlPos:=BrakeCtrlPos; //to powinnno być w jednym miejscu, aktualnie w C++!!! + BrakePressureActual:=BrakePressureTable[BrakeCtrlPos]; + OK:=SendCtrlToNext(command,CValue1,CValue2); + end //youby - odluzniacz hamulcow, przyda sie + else if command='BrakeReleaser' then + begin + OK:=BrakeReleaser(Round(CValue1)); //samo się przesyła dalej + //OK:=SendCtrlToNext(command,CValue1,CValue2); //to robiło kaskadę 2^n + end + else if command='MainSwitch' then + begin + if CValue1=1 then + begin + Mains:=true; + if (EngineType=DieselEngine) and Mains then + dizel_enginestart:=true; + end + else Mains:=false; + OK:=SendCtrlToNext(command,CValue1,CValue2); + end + else if command='Direction' then + begin + ActiveDir:=Trunc(CValue1); + DirAbsolute:=ActiveDir*CabNo; + OK:=SendCtrlToNext(command,CValue1,CValue2); + end + else if command='CabActivisation' then + begin +// OK:=Power>0.01; + case Trunc(CValue1*CValue2) of //CValue2 ma zmieniany znak przy niezgodności sprzęgów + 1 : CabNo:= 1; + -1 : CabNo:=-1; + else CabNo:=0; //gdy CValue1==0 + end; + DirAbsolute:=ActiveDir*CabNo; + OK:=SendCtrlToNext(command,CValue1,CValue2); + end + else if command='AutoRelaySwitch' then + begin + if (CValue1=1) and (AutoRelayType=2) then AutoRelayFlag:=true + else AutoRelayFlag:=false; + OK:=SendCtrlToNext(command,CValue1,CValue2); + end + else if command='FuseSwitch' then + begin + if ((EngineType=ElectricSeriesMotor)or(EngineType=DieselElectric)) and FuseFlag and (CValue1=1) and + (MainCtrlActualPos=0) and (ScndCtrlActualPos=0) and Mains then +{ if (EngineType=ElectricSeriesMotor) and (CValue1=1) and + (MainCtrlActualPos=0) and (ScndCtrlActualPos=0) and Mains then} + FuseFlag:=false; {wlaczenie ponowne obwodu} + // if ((EngineType=ElectricSeriesMotor)or(EngineType=DieselElectric)) and not FuseFlag and (CValue1=0) and Mains then + // FuseFlag:=true; + OK:=SendCtrlToNext(command,CValue1,CValue2); + end + else if command='ConverterSwitch' then {NBMX} + begin + if (CValue1=1) then ConverterAllow:=true + else if (CValue1=0) then ConverterAllow:=false; + OK:=SendCtrlToNext(command,CValue1,CValue2); + end + else if command='BatterySwitch' then {NBMX} + begin + if (CValue1=1) then Battery:=true + else if (CValue1=0) then Battery:=false; + if (Battery) and (ActiveCab<>0) {or (TrainType=dt_EZT)} then + SecuritySystem.Status:=SecuritySystem.Status or s_waiting //aktywacja czuwaka + else + SecuritySystem.Status:=0; //wyłączenie czuwaka + OK:=SendCtrlToNext(command,CValue1,CValue2); + end +// else if command='EpFuseSwitch' then {NBMX} +// begin +// if (CValue1=1) then EpFuse:=true +// else if (CValue1=0) then EpFuse:=false; +// OK:=SendCtrlToNext(command,CValue1,CValue2); +// end + else if command='CompressorSwitch' then {NBMX} + begin + if (CValue1=1) then CompressorAllow:=true + else if (CValue1=0) then CompressorAllow:=false; + OK:=SendCtrlToNext(command,CValue1,CValue2); + end + else if command='DoorOpen' then {NBMX} + begin //Ra: uwzględnić trzeba jeszcze zgodność sprzęgów + if (CValue2>0) then + begin //normalne ustawienie pojazdu + if (CValue1=1) OR (CValue1=3) then + DoorLeftOpened:=true; + if (CValue1=2) OR (CValue1=3) then + DoorRightOpened:=true; + end + else + begin //odwrotne ustawienie pojazdu + if (CValue1=2) OR (CValue1=3) then + DoorLeftOpened:=true; + if (CValue1=1) OR (CValue1=3) then + DoorRightOpened:=true; + end; + OK:=SendCtrlToNext(command,CValue1,CValue2); + end + else if command='DoorClose' then {NBMX} + begin //Ra: uwzględnić trzeba jeszcze zgodność sprzęgów + if (CValue2>0) then + begin //normalne ustawienie pojazdu + if (CValue1=1) OR (CValue1=3) then + DoorLeftOpened:=false; + if (CValue1=2) OR (CValue1=3) then + DoorRightOpened:=false; + end + else + begin //odwrotne ustawienie pojazdu + if (CValue1=2) OR (CValue1=3) then + DoorLeftOpened:=false; + if (CValue1=1) OR (CValue1=3) then + DoorRightOpened:=false; + end; + OK:=SendCtrlToNext(command,CValue1,CValue2); + end + else if command='PantFront' then {Winger 160204} + begin //Ra: uwzględnić trzeba jeszcze zgodność sprzęgów + //Czemu EZT ma być traktowane inaczej? Ukrotnienie ma, a człon może być odwrócony + if (TrainType=dt_EZT) then + begin //'ezt' + if (CValue1=1) then + begin + PantFrontUp:=true; + PantFrontStart:=0; + end + else if (CValue1=0) then + begin + PantFrontUp:=false; + PantFrontStart:=1; + end; + end + else + begin //nie 'ezt' - odwrotne ustawienie pantografów: ^-.-^ zamiast ^-.^- + if (CValue1=1) then + if (TestFlag(Couplers[1].CouplingFlag,ctrain_controll)and(CValue2= 1)) + or(TestFlag(Couplers[0].CouplingFlag,ctrain_controll)and(CValue2=-1)) + then + begin + PantFrontUp:=true; + PantFrontStart:=0; + end + else + begin + PantRearUp:=true; + PantRearStart:=0; + end + else if (CValue1=0) then + if (TestFlag(Couplers[1].CouplingFlag,ctrain_controll)and(CValue2= 1)) + or(TestFlag(Couplers[0].CouplingFlag,ctrain_controll)and(CValue2=-1)) + then + begin + PantFrontUp:=false; + PantFrontStart:=1; + end + else + begin + PantRearUp:=false; + PantRearStart:=1; + end; + end; + OK:=SendCtrlToNext(command,CValue1,CValue2); + end + else if command='PantRear' then {Winger 160204, ABu 310105 i 030305} + begin //Ra: uwzględnić trzeba jeszcze zgodność sprzęgów + if (TrainType=dt_EZT) then + begin {'ezt'} + if (CValue1=1) then + begin + PantRearUp:=true; + PantRearStart:=0; + end + else if (CValue1=0) then + begin + PantRearUp:=false; + PantRearStart:=1; + end; + end + else + begin {nie 'ezt'} + if (CValue1=1) then + {if ostatni polaczony sprz. sterowania} + if (TestFlag(Couplers[1].CouplingFlag,ctrain_controll)and(CValue2= 1)) + or(TestFlag(Couplers[0].CouplingFlag,ctrain_controll)and(CValue2=-1)) + then + begin + PantRearUp:=true; + PantRearStart:=0; + end + else + begin + PantFrontUp:=true; + PantFrontStart:=0; + end + else if (CValue1=0) then + if (TestFlag(Couplers[1].CouplingFlag,ctrain_controll)and(CValue2= 1)) + or(TestFlag(Couplers[0].CouplingFlag,ctrain_controll)and(CValue2=-1)) + then + begin + PantRearUp:=false; + PantRearStart:=1; + end + else + begin + PantFrontUp:=false; + PantFrontStart:=1; + end; + end; + OK:=SendCtrlToNext(command,CValue1,CValue2); + end + else if command='MaxCurrentSwitch' then + begin + OK:=MaxCurrentSwitch(CValue1=1); + end + else if command='MinCurrentSwitch' then + begin + OK:=MinCurrentSwitch(CValue1=1); + end +{test komend oddzialywujacych na tabor} + else if command='SetDamage' then + begin + if CValue2=1 then OK:=SetFlag(DamageFlag,Trunc(CValue1)); + if CValue2=-1 then OK:=SetFlag(DamageFlag,-Trunc(CValue1)); + end + else if command='Emergency_brake' then + begin + if EmergencyBrakeSwitch(Trunc(CValue1)=1) then + OK:=true + else OK:=false; + end + else if command='BrakeDelay' then + begin + BrakeDelayFlag:=Trunc(CValue1); + OK:=true; + end + else if command='SandDoseOn' then + begin + if SandDoseOn then + OK:=true + else OK:=false; + end + else if command='CabSignal' then {SHP,Indusi} + begin //Ra: to powinno działać tylko w członie obsadzonym + if {(TrainType=dt_EZT)or} (ActiveCab<>0) and (Battery) and TestFlag(SecuritySystem.SystemType,2) then //jeśli kabina jest obsadzona (silnikowy w EZT?) + with SecuritySystem do + begin + VelocityAllowed:=Trunc(CValue1); + NextVelocityAllowed:=Trunc(CValue2); + SystemSoundSHPTimer:=0; //hunter-091012 + SetFlag(Status,s_active); + end; + //else OK:=false; + OK:=true; //true, gdy można usunąć komendę + end + {naladunek/rozladunek} + else if Pos('Load=',command)=1 then + begin + OK:=false; //będzie powtarzane aż się załaduje + if (Vel=0) and (MaxLoad>0) and (Load0 then //nazwa jest obecna w CHK + OK:=LoadingDone(Min0R(CValue2,LoadSpeed),testload); //zmienia LoadStatus + end; + //if OK then LoadStatus:=0; //nie udalo sie w ogole albo juz skonczone + end + else if Pos('UnLoad=',command)=1 then + begin + OK:=false; //będzie powtarzane aż się rozładuje + if (Vel=0) and (Load>0) then //czy jest co rozladowac? + if Distance(Loc,CommandIn.Location,Dim,Dim)<10 then //ten peron + begin + testload:=DUE(command); //zgodność nazwy ładunku z CHK + if LoadType=testload then {mozna to rozladowac} + OK:=LoadingDone(-Min0R(CValue2,LoadSpeed),testload); + end; + //if OK then LoadStatus:=0; + end; + RunCommand:=OK; //dla true komenda będzie usunięta, dla false wykonana ponownie +{$B-} +End; + +function T_MoverParameters.RunInternalCommand:boolean; +var OK:boolean; +begin + if CommandIn.Command<>'' then + begin + OK:=RunCommand(CommandIn.Command,CommandIn.Value1,CommandIn.Value2); + if OK then + with CommandIn do + begin + Command:=''; {kasowanie bo rozkaz wykonany} + Value1:=0; + Value2:=0; + Location.x:=0; Location.y:=0; Location.z:=0; + if not PhysicActivation then + Physic_ReActivation; + end; + end + else + OK:=false; + RunInternalCommand:=OK; +end; + +procedure T_MoverParameters.PutCommand(NewCommand:string; NewValue1,NewValue2:real; NewLocation:TLocation); +begin + CommandLast:=NewCommand; //zapamiętanie komendy + with CommandIn do + begin + Command:=NewCommand; + Value1:=NewValue1; + Value2:=NewValue2; + Location:=NewLocation; + end; {czy uruchomic tu RunInternalCommand? nie wiem} +end; + +{dla samochodow - kolej nie wężykuje} +function T_MoverParameters.ChangeOffsetH(DeltaOffset:real):boolean; +begin + if TestFlag(CategoryFlag,2) and TestFlag(RunningTrack.CategoryFlag,2) then + begin + OffsetTrackH:=OffsetTrackH+DeltaOffset; +// if abs(OffsetTrackH)>(RunningTrack.Width/1.95-TrackW/2.0) then + if abs(OffsetTrackH)>(0.5*(RunningTrack.Width-Dim.W)-0.05) then //Ra: może pół pojazdu od brzegu? + ChangeOffsetH:=false {kola na granicy drogi} + else + ChangeOffsetH:=true; + end + else ChangeOffsetH:=false; +end; + +{inicjalizacja} + +constructor T_MoverParameters.Init(//LocInitial:TLocation; RotInitial:TRotation; + VelInitial:real; TypeNameInit, NameInit: string; LoadInitial:longint; LoadTypeInitial: string; Cab:integer); + {predkosc pocz. w km/h, ilosc ladunku, typ ladunku, numer kabiny} +var b,k:integer; +begin + {inicjalizacja stalych} + dMoveLen:=0; + CategoryFlag:=1; + EngineType:=None; + for b:=0 to ResArraySize do + begin + RList[b].Relay:=0; + RList[b].R:=0; + RList[b].Bn:=0; + RList[b].Mn:=0; + RList[b].AutoSwitch:=false; + end; + WheelDiameter:=1.0; + BrakeCtrlPosNo:=0; + for k:=-1 to MainBrakeMaxPos do + with BrakePressureTable[k] do + begin + PipePressureVal:=0; + BrakePressureVal:=0; + FlowSpeedVal:=0; + end; + with BrakePressureTable[-2] do {pozycja odciecia} + begin + PipePressureVal:=-1; + BrakePressureVal:=-1; + FlowSpeedVal:=0; + end; + Transmision.Ratio:=1; + NBpA:=0; + DynamicBrakeType:=0; + ASBType:=0; + AutoRelayType:=0; + for b:=0 to 1 do //Ra: kto tu zrobił "for b:=1 to 2 do" ??? + with Couplers[b] do + begin + CouplerType:=NoCoupler; + SpringkB:=1; SpringkC:=1; + DmaxB:=0.1; FmaxB:=1000; + DmaxC:=0.1; FmaxC:=1000; + end; + Power:=0; + MaxLoad:=0; LoadAccepted:=''; + LoadSpeed:=0; UnLoadSpeed:=0; + HeatingPower:=0; LightPower:=0; + with HeatingPowerSource do + begin + MaxVoltage:=0; MaxCurrent:=0; IntR:=0.001; + SourceType:=NotDefined; PowerType:=NoPower; RPowerCable.PowerTrans:=NoPower; + end; + with AlterHeatPowerSource do + begin + MaxVoltage:=0; MaxCurrent:=0; IntR:=0.001; + SourceType:=NotDefined; PowerType:=NoPower; RPowerCable.PowerTrans:=NoPower; + end; + with LightPowerSource do + begin + MaxVoltage:=0; MaxCurrent:=0; IntR:=0.001; + SourceType:=NotDefined; PowerType:=NoPower; RPowerCable.PowerTrans:=NoPower; + end; + with AlterLightPowerSource do + begin + MaxVoltage:=0; MaxCurrent:=0; IntR:=0.001; + SourceType:=NotDefined; PowerType:=NoPower; RPowerCable.PowerTrans:=NoPower; + end; + TypeName:=TypeNameInit; + HighPipePress:=0; + LowPipePress:=0; + DeltaPipePress:=0; + BrakeCylNo:=0; + BrakeCylRadius:=0; + BrakeCylDist:=0; + for b:=0 to 3 do + BrakeCylMult[b]:=0; + VeselVolume:=0; + BrakeVolume:=0; + RapidMult:=1; + dizel_Mmax:=1; dizel_nMmax:=1; dizel_Mnmax:=2; dizel_nmax:=2; dizel_nominalfill:=0; + dizel_Mstand:=0; + dizel_nmax_cutoff:=0; + dizel_nmin:=0; + dizel_minVelfullengage:=0; + dizel_AIM:=1; + dizel_engageDia:=0.5; dizel_engageMaxForce:=6000; dizel_engagefriction:=0.5; + DoorOpenCtrl:=0; DoorCloseCtrl:=0; + DoorStayOpen:=0; + DoorClosureWarning:=false; + DoorOpenSpeed:=1; DoorCloseSpeed:=1; + DoorMaxShiftL:=0.5; DoorMaxShiftR:=0.5; + DoorOpenMethod:=2; + DepartureSignal:=false; + InsideConsist:=false; + CompressorPower:=1; + SmallCompressorPower:=0; + + ScndInMain:=false; + + Vhyp:=1; + Vadd:=1; + PowerCorRatio:=1; + + {inicjalizacja zmiennych} + //Loc:=LocInitial; //Ra: to i tak trzeba potem przesunąć, po ustaleniu pozycji na torze (potrzebna długość) + //Rot:=RotInitial; + for b:=0 to 1 do + with Couplers[b] do + begin + AllowedFlag:=3; //domyślnie hak i hamulec, inne trzeba włączyć jawnie w FIZ + CouplingFlag:=0; + Connected:=nil; + ConnectedNr:=0; //Ra: to nie ma znaczenia jak nie podłączony + Render:=false; + CForce:=0; + Dist:=0; + CheckCollision:=false; + end; + ScanCounter:=0; + BrakeCtrlPos:=-2; //to nie ma znaczenia, konstruktor w Mover.cpp zmienia na -2 + BrakeDelayFlag:=0; + BrakeStatus:=b_off; + EmergencyBrakeFlag:=false; + MainCtrlPos:=0; + ScndCtrlPos:=0; + MainCtrlActualPos:=0; + ScndCtrlActualPos:=0; + Heating:=false; + Mains:=false; + ActiveDir:=0; //kierunek nie ustawiony + CabNo:=0; //sterowania nie ma, ustawiana przez CabActivization() + ActiveCab:=Cab; //obsada w podanej kabinie + DirAbsolute:=0; + SlippingWheels:=false; + SandDose:=false; + FuseFlag:=false; + ConvOvldFlag:=false; //hunter-251211 + StLinFlag:=false; + ResistorsFlag:=false; + Rventrot:=0; + enrot:=0; + nrot:=0; + Itot:=0; + EnginePower:=0; + BrakePress:=0; + Compressor:=0; + ConverterFlag:=false; + CompressorAllow:=false; + DoorLeftOpened:=false; + DoorRightOpened:=false; + battery:=false; + EpFuse:=true; + Signalling:=false; + Radio:=true; + DoorSignalling:=false; + UnBrake:=false; +//Winger 160204 + PantVolume:=0.48; //aby podniesione pantografy opadły w krótkim czasie przy wyłączonej sprężarce + PantFrontUp:=false; + PantRearUp:=false; + PantFrontStart:=0; + PantRearStart:=0; + PantFrontSP:=true; + PantRearSP:=true; + DoubleTr:=1; + BrakeSlippingTimer:=0; + dpBrake:=0; dpPipe:=0; dpMainValve:=0; dpLocalValve:=0; + MBPM:=1; + DynamicBrakeFlag:=false; + BrakeSystem:=Individual; + BrakeSubsystem:=ss_None; + Ft:=0; Ff:=0; Fb:=0; + Ftotal:=0; FStand:=0; FTrain:=0; + AccS:=0; AccN:=0; AccV:=0; + EventFlag:=false; SoundFlag:=0; + Vel:=Abs(VelInitial); V:=VelInitial/3.6; + LastSwitchingTime:=0; + LastRelayTime:=0; + DistCounter:=0; + PulseForce:=0; + PulseForceTimer:=0; + PulseForceCount:=0; + eAngle:=1.5; + dizel_fill:=0; + dizel_engagestate:=0; + dizel_engage:=0; + dizel_automaticgearstatus:=0; + dizel_enginestart:=false; + dizel_engagedeltaomega:=0; + PhysicActivation:=true; + + with RunningShape do + begin + R:=0; Len:=1; dHtrack:=0; dHrail:=0; + end; + RunningTrack.CategoryFlag:=CategoryFlag; + with RunningTrack do + begin + Width:=TrackW; friction:=Steel2Steel_friction; + QualityFlag:=20; + DamageFlag:=0; + Velmax:=100; {dla uzytku maszynisty w ai_driver} + end; + with RunningTraction do + begin + TractionVoltage:=0; + TractionFreq:=0; + TractionMaxCurrent:=0; + TractionResistivity:=1; + end; + OffsetTrackH:=0; OffsetTrackV:=0; + with CommandIn do + begin + Command:=''; + Value1:=0; Value2:=0; + Location.x:=0; Location.y:=0; Location.z:=0; + end; + + {czesciowo stale, czesciowo zmienne} + with SecuritySystem do + begin + SystemType:=0; + AwareDelay:=-1; SoundSignalDelay:=-1; EmergencyBrakeDelay:=-1; + Status:=0; + SystemTimer:=0; SystemBrakeCATimer:=0; SystemBrakeSHPTimer:=0; //hunter-091012 + VelocityAllowed:=-1; NextVelocityAllowed:=-1; + RadioStop:=false; //domyślnie nie ma + AwareMinSpeed:=0.1*Vmax; + end; + //ABu 240105: + //CouplerNr[0]:=1; + //CouplerNr[1]:=0; + +{TO POTEM TU UAKTYWNIC A WYWALIC Z CHECKPARAM} +{ + if Pos(LoadTypeInitial,LoadAccepted)>0 then + begin +} + LoadType:=LoadTypeInitial; + Load:=LoadInitial; + LoadStatus:=0; + LastLoadChangeTime:=0; +{ + end + else Load:=0; + } + + Name:=NameInit; + DerailReason:=0; //Ra: powód wykolejenia + TotalCurrent:=0; + ShuntModeAllow:=false; + ShuntMode:=false; +end; + +function T_MoverParameters.EngineDescription(what:integer): string; {opis stanu lokomotywy} +var outstr: string; +begin + outstr:=''; + case what of + 0: begin + if DamageFlag=255 then + outstr:='Totally destroyed!' + else + begin + if TestFlag(DamageFlag,dtrain_thinwheel) then + if Power>0.1 then + outstr:='Thin wheel,' + else + outstr:='Load shifted,'; + if TestFlag(DamageFlag,dtrain_wheelwear) then + outstr:='Wheel wear,'; + if TestFlag(DamageFlag,dtrain_bearing) then + outstr:='Bearing damaged,'; + if TestFlag(DamageFlag,dtrain_coupling) then + outstr:='Coupler broken,'; + if TestFlag(DamageFlag,dtrain_loaddamage) then + if Power>0.1 then + outstr:='Ventilator damaged,' + else + outstr:='Load damaged,'; + if TestFlag(DamageFlag,dtrain_loaddestroyed) then + if Power>0.1 then + outstr:='Engine damaged,' + else + outstr:='Load destroyed!,'; + if TestFlag(DamageFlag,dtrain_axle) then + outstr:='Axle broken,'; + if TestFlag(DamageFlag,dtrain_out) then + outstr:='DERAILED!'; + if outstr='' then + outstr:='OK!'; + end; + end; + else outstr:='Invalid qualifier'; + end; + EngineDescription:=outstr; +end; + +function T_MoverParameters.CheckLocomotiveParameters(ReadyFlag:boolean;Dir:longint): boolean; +var //k:integer; + OK:boolean; + b:byte; + bcmsno: byte; + bcmss: byte; +const + DefBrakeTable:array[1..8]of Byte=(15,4,25,25,13,3,12,2); +begin + OK:=true; + AutoRelayFlag:=(AutoRelayType=1); + Sand:=SandCapacity; + if (Pos('o',AxleArangement)>0) and (EngineType=ElectricSeriesMotor) then + OK:=(RList[1].Bn*RList[1].Mn=NPoweredAxles); {test poprawnosci ilosci osi indywidualnie napedzanych} + if (Pos(LoadType,LoadAccepted)=0) and (LoadType<>'') then + begin + Load:=0; + OK:=false; + end; + if BrakeSystem=Individual then + if BrakeSubSystem<>ss_None then + OK:=false; {!} + + if(BrakeVVolume=0)and(MaxBrakePress[3]>0)and(BrakeSystem<>Individual)then + BrakeVVolume:=MaxBrakePress[3]/(5-MaxBrakePress[3])*(BrakeCylRadius*BrakeCylRadius*BrakeCylDist*BrakeCylNo*pi)*1000; + if BrakeVVolume=0 then BrakeVVolume:=0.01; + +// Hamulec.Free; +//(i_mbp, i_bcr, i_bcd, i_brc: real; i_bcn, i_BD, i_mat, i_ba, i_nbpa: byte) + +case BrakeValve of + W, K : begin + Hamulec := TWest.Create(MaxBrakePress[3], BrakeCylRadius, BrakeCylDist, BrakeVVolume, BrakeCylNo, BrakeDelays, BrakeMethod, NAxles, NBpA); + if(MBPM<2)then //jesli przystawka wazaca + (Hamulec as TWest).SetLP(0,MaxBrakePress[3],0) + else + (Hamulec as TWest).SetLP(Mass, MBPM, MaxBrakePress[1]); + end; + KE : begin + Hamulec := TKE.Create(MaxBrakePress[3], BrakeCylRadius, BrakeCylDist, BrakeVVolume, BrakeCylNo, BrakeDelays, BrakeMethod, NAxles, NBpA); + (Hamulec as TKE).SetRM(RapidMult); + if(MBPM<2)then //jesli przystawka wazaca + (Hamulec as TKE).SetLP(0,MaxBrakePress[3],0) + else + (Hamulec as TKE).SetLP(Mass, MBPM, MaxBrakePress[1]) + end; + NEst3, ESt3, ESt3AL2, ESt4: + begin + Hamulec := TNESt3.Create(MaxBrakePress[3], BrakeCylRadius, BrakeCylDist, BrakeVVolume, BrakeCylNo, BrakeDelays, BrakeMethod, NAxles, NBpA); + (Hamulec as TNEst3).SetSize(BrakeValveSize,BrakeValveParams); + if(MBPM<2)then //jesli przystawka wazaca + (Hamulec as TNESt3).SetLP(0,MaxBrakePress[3],0) + else + (Hamulec as TNESt3).SetLP(Mass, MBPM, MaxBrakePress[1]) + end; +{ ESt3, ESt3AL2: if (MaxBrakePress[1])>0 then + begin + Hamulec := TESt3AL2.Create(MaxBrakePress[3], BrakeCylRadius, BrakeCylDist, BrakeVVolume, BrakeCylNo, BrakeDelays, BrakeMethod, NAxles, NBpA); + if(MBPM<2)then + (Hamulec as TESt3AL2).SetLP(0,MaxBrakePress[3],0) + else + (Hamulec as TESt3AL2).SetLP(Mass, MBPM, MaxBrakePress[1]) + end + else + Hamulec := TESt3.Create(MaxBrakePress[3], BrakeCylRadius, BrakeCylDist, BrakeVVolume, BrakeCylNo, BrakeDelays, BrakeMethod, NAxles, NBpA);} + LSt :begin + Hamulec := TLSt.Create(MaxBrakePress[3], BrakeCylRadius, BrakeCylDist, BrakeVVolume, BrakeCylNo, BrakeDelays, BrakeMethod, NAxles, NBpA); + (Hamulec as TLSt).SetRM(RapidMult); + end; + EStED :begin + Hamulec := TEStED.Create(MaxBrakePress[3], BrakeCylRadius, BrakeCylDist, BrakeVVolume, BrakeCylNo, BrakeDelays, BrakeMethod, NAxles, NBpA); + (Hamulec as TEStED).SetRM(RapidMult); + end; + EP2:begin + Hamulec :=TEStEP2.Create(MaxBrakePress[3], BrakeCylRadius, BrakeCylDist, BrakeVVolume, BrakeCylNo, BrakeDelays, BrakeMethod, NAxles, NBpA); + (Hamulec as TEStEP2).SetLP(Mass, MBPM, MaxBrakePress[1]); + end; +{ ESt4 :if (BrakeDelays and bdelay_R)=bdelay_R then + Hamulec:=TESt4R.Create(MaxBrakePress[3], BrakeCylRadius, BrakeCylDist, BrakeVVolume, BrakeCylNo, BrakeDelays, BrakeMethod, NAxles, NBpA) + else + Hamulec:= TESt.Create(MaxBrakePress[3], BrakeCylRadius, BrakeCylDist, BrakeVVolume, BrakeCylNo, BrakeDelays, BrakeMethod, NAxles, NBpA);} + CV1 : Hamulec:= TCV1.Create(MaxBrakePress[3], BrakeCylRadius, BrakeCylDist, BrakeVVolume, BrakeCylNo, BrakeDelays, BrakeMethod, NAxles, NBpA); + CV1_L_TR:Hamulec:= TCV1L_TR.Create(MaxBrakePress[3], BrakeCylRadius, BrakeCylDist, BrakeVVolume, BrakeCylNo, BrakeDelays, BrakeMethod, NAxles, NBpA) +else + Hamulec := TBrake.Create(MaxBrakePress[3], BrakeCylRadius, BrakeCylDist, BrakeVVolume, BrakeCylNo, BrakeDelays, BrakeMethod, NAxles, NBpA); +end; +Hamulec.SetASBP(MaxBrakePress[4]); + +case BrakeHandle of + FV4a: Handle := TFV4aM.Create; + FVel6: Handle := TFVel6.Create; + testH: Handle := Ttest.Create; + M394: Handle := TM394.Create; + Knorr: Handle := TH14K1.Create; + St113: Handle := TSt113.Create; +else + Handle := THandle.Create; +end; + +case BrakeLocHandle of + FD1: + begin + LocHandle := TFD1.Create; + LocHandle.Init(MaxBrakePress[0]); + end; + Knorr: + begin + LocHandle := TH1405.Create; + LocHandle.Init(MaxBrakePress[0]); + end; +else + LocHandle := THandle.Create; +end; + +//ustalanie srednicy przewodu glownego (lokomotywa lub napędowy + if (TestFlag(BrakeDelays,bdelay_G))and((not TestFlag(BrakeDelays,bdelay_R)) or (Power>1))then + Spg:=0.792 + else + Spg:=0.507; + + Pipe:= TReservoir.Create; + Pipe2:= TReservoir.Create; //zabezpieczenie, bo sie PG wywala... :( + Pipe.CreateCap((Max0R(Dim.L,14)+0.5)*Spg*1); //dlugosc x przekroj x odejscia i takie tam + Pipe2.CreateCap((Max0R(Dim.L,14)+0.5)*Spg*1); + + {to dac potem do init} + if ReadyFlag then {gotowy do drogi} + begin + CompressedVolume:=VeselVolume*MinCompressor*(9.8+Random)/10; + ScndPipePress:=CompressedVolume/VeselVolume; + PipePress:=CntrlPipePress; + BrakePress:=0; + LocalBrakePos:=0; +// if (BrakeSystem=Pneumatic) and (BrakeCtrlPosNo>0) then + if CabNo=0 then +// BrakeCtrlPos:=-2; //odcięcie na zespolonym; Ra: hamulec jest poprawiany w DynObj.cpp + BrakeCtrlPos:=Trunc(Handle.GetPos(bh_NP)) + else + BrakeCtrlPos:=Trunc(Handle.GetPos(bh_RP)); + MainSwitch(false); + PantFront(true); + PantRear(true); + MainSwitch(true); + ActiveDir:=0; //Dir; //nastawnik kierunkowy - musi być ustawiane osobno! + DirAbsolute:=ActiveDir*CabNo; //kierunek jazdy względem sprzęgów + LimPipePress:=CntrlPipePress; + end + else + begin {zahamowany} + Volume:=BrakeVVolume*MaxBrakePress[3]; + CompressedVolume:=VeselVolume*MinCompressor*0.55; + ScndPipePress:=5.1; + PipePress:=LowPipePress; + PipeBrakePress:=MaxBrakePress[3]; + BrakePress:=MaxBrakePress[3]; + LocalBrakePos:=0; +// if (BrakeSystem=Pneumatic) and (BrakeCtrlPosNo>0) then +// BrakeCtrlPos:=-2; //Ra: hamulec jest poprawiany w DynObj.cpp + BrakeCtrlPos:=Trunc(Handle.GetPos(bh_NP)); + LimPipePress:=LowPipePress; + end; + ActFlowSpeed:=0; + BrakeCtrlPosR:=BrakeCtrlPos; + + if(BrakeLocHandle=Knorr)then + LocalBrakePos:=5; + + Pipe.CreatePress(PipePress); + Pipe2.CreatePress(ScndPipePress); + Pipe.Act;Pipe2.Act; + + EqvtPipePress:=PipePress; + +//// fv4ac:=Pipe.P; +//// fv4ar:=Pipe.P; + + Handle.Init(PipePress); + + ComputeConstans(); + + + if(LoadFlag>0)then + begin + if(Load=MaxLoad*0.45)then + begin + IncBrakeMult(); + if(Load>=MaxLoad*0.55)then + IncBrakeMult(); + end; + end; + +//taki mini automat - powinno byc ladnie dobrze :) + BrakeDelayFlag:=bdelay_P; + if(TestFlag(BrakeDelays,bdelay_G))and not(TestFlag(BrakeDelays,bdelay_R))then + BrakeDelayFlag:=bdelay_G; + if(TestFlag(BrakeDelays,bdelay_R))and not(TestFlag(BrakeDelays,bdelay_G))then + BrakeDelayFlag:=bdelay_R; + +//yB: jesli pojazdy nie maja zadeklarowanych czasow, to wsadz z przepisow +-16,(6)% + for b:=1 to 4 do + begin + if BrakeDelay[b]=0 then + BrakeDelay[b]:=DefBrakeTable[b]; + BrakeDelay[b]:=BrakeDelay[b]*(2.5+Random)/3.0; + end; + + if(TrainType=dt_ET22)then + CompressorPower:=0; + +// Hamulec.Init(10*PipePress, 10*HighPipePress-0.15, 10*LowPipePress-0.15, 10*BrakePress, BrakeDelayFlag); + Hamulec.Init(PipePress, HighPipePress, LowPipePress, BrakePress, BrakeDelayFlag); +// Hamulec.Init(0, 0, -1.5, 0, BrakeDelayFlag); +// PipePress:=PipePress; + ScndPipePress:=Compressor; + CheckLocomotiveParameters:=OK; +end; + +function T_MoverParameters.DoorLeft(State: Boolean):Boolean; +begin + if (DoorLeftOpened<>State) and (DoorBlockedFlag=false) and (Battery=true) then + begin + DoorLeft:=true; + DoorLeftOpened:=State; + if (State=true) then + begin + if (CabNo>0) then + SendCtrlToNext('DoorOpen',1,CabNo) //1=lewe, 2=prawe + else + SendCtrlToNext('DoorOpen',2,CabNo); //zamiana + CompressedVolume:=CompressedVolume-0.003; + end + else + begin + if (CabNo>0) then + SendCtrlToNext('DoorClose',1,CabNo) + else + SendCtrlToNext('DoorClose',2,CabNo); + end; + end + else + DoorLeft:=false; +end; + +function T_MoverParameters.DoorRight(State: Boolean):Boolean; +begin + if (DoorRightOpened<>State) and (DoorBlockedFlag=false) and (Battery=true) then + begin + DoorRight:=true; + DoorRightOpened:=State; + if (State=true) then + begin + if (CabNo>0) then + SendCtrlToNext('DoorOpen',2,CabNo) //1=lewe, 2=prawe + else + SendCtrlToNext('DoorOpen',1,CabNo); //zamiana + CompressedVolume:=CompressedVolume-0.003; + end + else + begin + if (CabNo>0) then + SendCtrlToNext('DoorClose',2,CabNo) + else + SendCtrlToNext('DoorClose',1,CabNo); + end; + end + else + DoorRight:=false; +end; + +//Winger 160204 - pantografy +function T_MoverParameters.PantFront(State: Boolean):Boolean; +var pf1: Real; +begin +if (battery=true){ and ((TrainType<>dt_ET40)or ((TrainType=dt_ET40) and (EnginePowerSource.CollectorsNo>1)))}then +begin + PantFront:=true; + if (State=true) then pf1:=1 + else pf1:=0; + if (PantFrontUp<>State) then + begin + PantFrontUp:=State; + if (State=true) then + begin + PantFrontStart:=0; + SendCtrlToNext('PantFront',1,CabNo); + end + else + begin + PantFront:=false; + PantFrontStart:=1; + SendCtrlToNext('PantFront',0,CabNo); +{Ra: nie ma potrzeby opuszczać obydwu na raz, jak mozemy każdy osobno + if (TrainType=dt_EZT) and (ActiveCab=1) then + begin + PantRearUp:=false; + PantRearStart:=1; + SendCtrlToNext('PantRear',0,CabNo); + end; +} + end; + end + else + SendCtrlToNext('PantFront',pf1,CabNo); +end +end; + +function T_MoverParameters.PantRear(State: Boolean):Boolean; +var pf1: Real; +begin +if battery=true then + begin + PantRear:=true; + if (State=true) then pf1:=1 + else pf1:=0; + if (PantRearUp<>State) then + begin + PantRearUp:=State; + if (State=true) then + begin + PantRearStart:=0; + SendCtrlToNext('PantRear',1,CabNo); + end + else + begin + PantRear:=false; + PantRearStart:=1; + SendCtrlToNext('PantRear',0,CabNo); + end; + end + else + SendCtrlToNext('PantRear',pf1,CabNo); + end +end; + + + +{function T_MoverParameters.Heating(State: Boolean):Boolean; +begin + if (Heating<>State) then + begin + Heating:=State; +{ if (State=true) then + begin +// SendCtrlToNext('PantRear',1,CabNo); + end + else + begin +// SendCtrlToNext('PantRear',0,CabNo); + end; } +{ end +{ else + SendCtrlToNext('PantRear',0,CabNo); } +{end;} + +function T_MoverParameters.LoadChkFile(chkpath:string):Boolean; +const param_ok=1; wheels_ok=2; dimensions_ok=4; +var + lines,s: string; + bl,i,k:integer; + b,OKflag:byte; + fin: text; + OK: boolean; +procedure BrakeValveDecode(s:string); +begin + if s='W' then + BrakeValve:=W + else if s='W_Lu_L' then + BrakeValve:=W_Lu_L + else if s='W_Lu_XR' then + BrakeValve:=W_Lu_XR + else if s='W_Lu_VI' then + BrakeValve:=W_Lu_VI + else if s='K' then + BrakeValve:=W + else if s='Kkg' then + BrakeValve:=Kkg + else if s='Kkp' then + BrakeValve:=Kkp + else if s='Kks' then + BrakeValve:=Kks + else if s='Hikp1' then + BrakeValve:=Hikp1 + else if s='Hikss' then + BrakeValve:=Hikss + else if s='Hikg1' then + BrakeValve:=Hikg1 + else if s='KE' then + BrakeValve:=KE + else if s='EStED' then + BrakeValve:=EStED + else if Pos('ESt',s)>0 then + BrakeValve:=ESt3 + else if s='LSt' then + BrakeValve:=LSt + else if s='EP2' then + BrakeValve:=EP2 + else if s='EP1' then + BrakeValve:=EP1 + else if s='CV1' then + BrakeValve:=CV1 + else if s='CV1_L_TR' then + BrakeValve:=CV1_L_TR + else + BrakeValve:=Other; +end; +procedure BrakeSubsystemDecode; +begin + case BrakeValve of + W,W_Lu_L,W_Lu_VI,W_Lu_XR: BrakeSubsystem:=ss_W; + ESt3,ESt3AL2,ESt4,EP2,EP1: BrakeSubsystem:=ss_ESt; + KE: BrakeSubsystem:=ss_KE; + CV1, CV1_L_TR: BrakeSubsystem:=ss_Dako; + LSt, EStED: BrakeSubsystem:=ss_LSt; + else + BrakeSubsystem:=ss_None; + end; +end; +function EngineDecode(s:string):TEngineTypes; + begin + if s='ElectricSeriesMotor' then + EngineDecode:=ElectricSeriesMotor + else if s='DieselEngine' then + EngineDecode:=DieselEngine + else if s='SteamEngine' then + EngineDecode:=SteamEngine + else if s='WheelsDriven' then + EngineDecode:=WheelsDriven + else if s='Dumb' then + EngineDecode:=Dumb + else if s='DieselElectric' then + EngineDecode:=DieselElectric //youBy: spal-ele + else if s='DumbDE' then + EngineDecode:=DieselElectric //youBy: spal-ele + else if s='ElectricInductionMotor' then + EngineDecode:=ElectricInductionMotor +{ else if s='EZT' then {dla kibla} + { EngineDecode:=EZT } + else EngineDecode:=None; + end; +function PowerSourceDecode(s:string):TPowerSource; + begin + if s='Transducer' then PowerSourceDecode:=Transducer + else if s='Generator' then PowerSourceDecode:=Generator + else if s='Accu' then PowerSourceDecode:=Accumulator + else if s='CurrentCollector' then PowerSourceDecode:=CurrentCollector + else if s='PowerCable' then PowerSourceDecode:=PowerCable + else if s='Heater' then PowerSourceDecode:=Heater + else if s='Internal' then PowerSourceDecode:=InternalSource + else PowerSourceDecode:=NotDefined; + end; +function PowerDecode(s:string): TPowerType; + begin + if s='BioPower' then PowerDecode:=BioPower + else if s='BioPower' then PowerDecode:=BioPower + else if s='MechPower' then PowerDecode:=MechPower + else if s='ElectricPower' then PowerDecode:=ElectricPower + else if s='SteamPower' then PowerDecode:=SteamPower + else PowerDecode:=NoPower; + end; + procedure PowerParamDecode(lines,prefix:string; var PowerParamDecode:TPowerParameters); + begin + with PowerParamDecode do + begin + case SourceType of + NotDefined : PowerType:=PowerDecode(DUE(ExtractKeyWord(lines,prefix+'PowerType='))); + InternalSource : PowerType:=PowerDecode(DUE(ExtractKeyWord(lines,prefix+'PowerType='))); + Transducer : InputVoltage:=s2rE(DUE(ExtractKeyWord(lines,prefix+'TransducerInputV='))); + Generator : GeneratorEngine:=EngineDecode(DUE(ExtractKeyWord(lines,prefix+'GeneratorEngine='))); + Accumulator: begin + RAccumulator.MaxCapacity:=s2r(DUE(ExtractKeyWord(lines,prefix+'Cap='))); + s:=DUE(ExtractKeyWord(lines,prefix+'RS=')); + RAccumulator.RechargeSource:=PowerSourceDecode(s); + end; + CurrentCollector: begin + with CollectorParameters do + begin + CollectorsNo:=s2lE(DUE(ExtractKeyWord(lines,'CollectorsNo='))); + MinH:=s2rE(DUE(ExtractKeyWord(lines,'MinH='))); + MaxH:=s2rE(DUE(ExtractKeyWord(lines,'MaxH='))); + CSW:=s2rE(DUE(ExtractKeyWord(lines,'CSW='))); //szerokość części roboczej + MaxV:=s2rE(DUE(ExtractKeyWord(lines,'MaxVoltage='))); + s:=ExtractKeyWord(lines,'MinV='); //napięcie rozłączające WS + if s='' then + MinV:=0.5*MaxV //gdyby parametr nie podany + else + MinV:=s2rE(DUE(s)); + s:=ExtractKeyWord(lines,'InsetV='); //napięcie wymagane do załączenia WS + if s='' then + InsetV:=0.6*MaxV //gdyby parametr nie podany + else + InsetV:=s2rE(DUE(s)); + s:=ExtractKeyWord(lines,'MinPress='); //ciśnienie rozłączające WS + if s='' then + MinPress:=2.0 //domyślnie 2 bary do załączenia WS + else + MinPress:=s2rE(DUE(s)); + s:=ExtractKeyWord(lines,'MaxPress='); //maksymalne ciśnienie za reduktorem + if s='' then + MaxPress:=5.0+0.001*(random(50)-random(50)) + else + MaxPress:=s2rE(DUE(s)); + end; + end; + PowerCable : begin + RPowerCable.PowerTrans:=PowerDecode(DUE(ExtractKeyWord(lines,prefix+'PowerTrans='))); + if RPowerCable.PowerTrans=SteamPower then + RPowerCable.SteamPressure:=s2r(DUE(ExtractKeyWord(lines,prefix+'SteamPress='))); + end; + Heater : begin + {jeszcze nie skonczone!} + end; + end; + if (SourceType<>Heater) and (SourceType<>InternalSource) then + if not ((SourceType=PowerCable) and (RPowerCable.PowerTrans=SteamPower)) then + begin +{ PowerTrans:=ElectricPower; } + MaxVoltage:=s2rE(DUE(ExtractKeyWord(lines,prefix+'MaxVoltage='))); + MaxCurrent:=s2r(DUE(ExtractKeyWord(lines,prefix+'MaxCurrent='))); + IntR:=s2r(DUE(ExtractKeyWord(lines,prefix+'IntR='))); + end; + end; + end; +begin + //OK:=true; + OKflag:=0; + LineCount:=0; + ConversionError:=666; + Mass:=0; + filename:=chkpath+TypeName+'.fiz';//'.chk'; + assignfile(fin,filename); +{$I-} + reset(fin); +{$I+} + if IOresult<>0 then + begin + OK:=false; + ConversionError:=-8; + end + else + begin + ConversionError:=0; + while not (eof(fin) or (ConversionError<>0)) do + begin + readln(fin,lines); + inc(LineCount); + if Pos('/',lines)=0 then {nie komentarz} + begin + if Pos('Param.',lines)>0 then {stale parametry} + begin + SetFlag(OKFlag,param_ok); + s:=DUE(ExtractKeyWord(lines,'Category=')); + if s='train' then + CategoryFlag:=1 + else if s='road' then + CategoryFlag:=2 + else if s='ship' then + CategoryFlag:=4 + else if s='airplane' then + CategoryFlag:=8 + else if s='unimog' then + CategoryFlag:=3 + else + ConversionError:=-7; + s:=ExtractKeyWord(lines,'M='); + Mass:=s2rE(DUE(s)); {w kg} + s:=ExtractKeyWord(lines,'Mred='); {zredukowane masy wirujące} + if s='' then + Mred:=0 + else + Mred:=s2rE(DUE(s)); {w kg} + s:=ExtractKeyWord(lines,'Vmax='); + Vmax:=s2rE(DUE(s)); {w km/h} + s:=ExtractKeyWord(lines,'PWR='); + Power:=s2r(DUE(s)); {w kW} + s:=ExtractKeyWord(lines,'HeatingP='); + HeatingPower:=s2r(DUE(s)); {w kW} + s:=ExtractKeyWord(lines,'LightP='); + LightPower:=s2r(DUE(s)); {w kW} + s:=ExtractKeyWord(lines,'SandCap='); + SandCapacity:=s2i(DUE(s)); {w kg} + TrainType:=dt_Default; + s:=Ups(DUE(ExtractKeyWord(lines,'Type='))); //wielkimi + if s='EZT' then + begin + TrainType:=dt_EZT; + IminLo:=1;IminHi:=2;Imin:=1; //wirtualne wartości dla rozrządczego + end + else if s='ET41' then TrainType:=dt_ET41 + else if s='ET42' then TrainType:=dt_ET42 + else if s='ET22' then TrainType:=dt_ET22 + else if s='ET40' then TrainType:=dt_ET40 + else if s='EP05' then TrainType:=dt_EP05 + else if s='SN61' then TrainType:=dt_SN61 + else if s='PSEUDODIESEL' then TrainType:=dt_PseudoDiesel + else if s='181' then TrainType:=dt_181 + else if s='182' then TrainType:=dt_181; {na razie tak} + end + else if Pos('Load:',lines)>0 then {stale parametry} + begin + LoadAccepted:=LowerCase(DUE(ExtractKeyWord(lines,'LoadAccepted='))); + if LoadAccepted<>'' then + begin + s:=ExtractKeyWord(lines,'MaxLoad='); + MaxLoad:=s2lE(DUE(s)); + LoadQuantity:=DUE(ExtractKeyWord(lines,'LoadQ=')); + s:=ExtractKeyWord(lines,'OverLoadFactor='); + OverLoadFactor:=s2r(DUE(s)); + s:=ExtractKeyWord(lines,'LoadSpeed='); + LoadSpeed:=s2rE(DUE(s)); + s:=ExtractKeyWord(lines,'UnLoadSpeed='); + UnLoadSpeed:=s2rE(DUE(s)); + end; + end + else if Pos('Dimensions:',lines)>0 then {wymiary} + begin + with Dim do + begin + SetFlag(OKFlag,dimensions_ok); + s:=ExtractKeyWord(lines,'L='); + L:=s2rE(DUE(s)); + s:=ExtractKeyWord(lines,'H='); + H:=s2rE(DUE(s)); + s:=ExtractKeyWord(lines,'W='); + W:=s2rE(DUE(s)); + s:=ExtractKeyWord(lines,'Cx='); + Cx:=s2r(DUE(s)); + if Cx=0 then Cx:=0.3; + s:=ExtractKeyWord(lines,'Floor='); + if s='' then + begin + if (H<=2.0) then + Floor:=H //gdyby nie było parametru, lepsze to niż zero + else + Floor:=0.0; //zgodność wsteczna + end + else + Floor:=s2rE(DUE(s)); + end; + end + else if Pos('Wheels:',lines)>0 then {kola} + begin +{ SetFlag(OKFlag,wheels_ok);} + s:=ExtractKeyWord(lines,'D='); //średnica osi napędzających + WheelDiameter:=s2rE(DUE(s)); + s:=ExtractKeyWord(lines,'Dl='); //średnica przednich osi tocznych + if s='' then + WheelDiameterL:=WheelDiameter //gdyby nie było parametru, lepsze to niż zero + else + WheelDiameterL:=s2rE(DUE(s)); + s:=ExtractKeyWord(lines,'Dt='); //średnica tylnych osi tocznych + if s='' then + WheelDiameterT:=WheelDiameter //gdyby nie było parametru, lepsze to niż zero + else + WheelDiameterT:=s2rE(DUE(s)); + s:=ExtractKeyWord(lines,'Tw='); + TrackW:=s2rE(DUE(s)); + s:=ExtractKeyWord(lines,'AIM='); + AxleInertialMoment:=s2r(DUE(s)); + if AxleInertialMoment<=0 then AxleInertialMoment:=1; + AxleArangement:=DUE(ExtractKeyWord(lines,'Axle=')); + NPoweredAxles:=s2NPW(AxleArangement); + NAxles:=NPoweredAxles+s2NNW(AxleArangement); + if NAxles=0 then ConversionError:=-1; + s:=DUE(ExtractKeyWord(lines,'BearingType=')); + if s='Roll' then BearingType:=1 + else BearingType:=0; + s:=ExtractKeyWord(lines,'Ad='); + ADist:=s2rE(DUE(s)); + s:=ExtractKeyWord(lines,'Bd='); + BDist:=s2r(DUE(s)); + end + else if Pos('Brake:',lines)>0 then {hamulce} + begin + BrakeValveParams:=DUE(ExtractKeyWord(lines,'BrakeValve=')); + BrakeValveDecode(BrakeValveParams); + BrakeSubSystemDecode; + s:=ExtractKeyWord(lines,'NBpA='); + NBpA:=s2b(DUE(s)); + s:=ExtractKeyWord(lines,'MBF='); + MaxBrakeForce:=s2r(DUE(s)); + s:=ExtractKeyWord(lines,'Size='); + BrakeValveSize:=s2i(DUE(s)); + s:=ExtractKeyWord(lines,'TBF='); + TrackBrakeForce:=s2r(DUE(s))*1000; + s:=ExtractKeyWord(lines,'MaxBP='); + MaxBrakePress[3]:=s2r(DUE(s)); + if MaxBrakePress[3]>0 then + begin + s:=ExtractKeyWord(lines,'BCN='); + BrakeCylNo:=s2iE(DUE(s)); + if BrakeCylNo>0 then + begin + s:=ExtractKeyWord(lines,'MaxLBP='); + MaxBrakePress[0]:=s2r(DUE(s)); + if MaxBrakePress[0]<0.01 then + MaxBrakePress[0]:=MaxBrakePress[3]; + s:=DUE(ExtractKeyWord(lines,'TareMaxBP=')); + MaxBrakePress[1]:=s2r(s); + s:=DUE(ExtractKeyWord(lines,'MedMaxBP=')); + MaxBrakePress[2]:=s2r(s); + s:=ExtractKeyWord(lines,'MaxASBP='); + MaxBrakePress[4]:=s2r(DUE(s)); + if MaxBrakePress[4]<0.01 then + MaxBrakePress[4]:=0; + s:=ExtractKeyWord(lines,'BCR='); + BrakeCylRadius:=s2rE(DUE(s)); + s:=ExtractKeyWord(lines,'BCD='); + BrakeCylDist:=s2r(DUE(s)); + s:=ExtractKeyWord(lines,'BCS='); + BrakeCylSpring:=s2r(DUE(s)); + s:=ExtractKeyWord(lines,'BSA='); + BrakeSlckAdj:=s2r(DUE(s)); + s:=ExtractKeyWord(lines,'BRE='); + if s<>'' then + BrakeRigEff:=s2r(DUE(s)) + else + BrakeRigEff:=1; + s:=ExtractKeyWord(lines,'BCM='); + BrakeCylMult[0]:=s2r(DUE(s)); + s:=ExtractKeyWord(lines,'BCMlo='); + BrakeCylMult[1]:=s2r(DUE(s)); + s:=ExtractKeyWord(lines,'BCMHi='); + BrakeCylMult[2]:=s2r(DUE(s)); + P2FTrans:=100*Pi*SQR(BrakeCylRadius); {w kN/bar} + if (BrakeCylMult[1]>0) or (MaxBrakePress[1]>0) then LoadFlag:=1 else LoadFlag:=0; + BrakeVolume:=Pi*SQR(BrakeCylRadius)*BrakeCylDist*BrakeCylNo; + s:=ExtractKeyWord(lines,'BVV='); + BrakeVVolume:=s2R(DUE(s)); + + s:=DUE(ExtractKeyWord(lines,'BM=')); + if s='P10-Bg' then BrakeMethod:=bp_P10Bg else + if s='P10-Bgu' then BrakeMethod:=bp_P10Bgu else + if s='FR513' then BrakeMethod:=bp_FR513 else + if s='Cosid' then BrakeMethod:=bp_Cosid else + if s='P10yBg' then BrakeMethod:=bp_P10yBg else + if s='P10yBgu' then BrakeMethod:=bp_P10yBgu else + if s='Disk1' then BrakeMethod:=bp_D1 else + if s='Disk1+Mg' then BrakeMethod:=bp_D1+bp_MHS else + if s='Disk2' then BrakeMethod:=bp_D2 else + BrakeMethod:=0; + + s:=ExtractKeyWord(lines,'RM='); + if s<>'' then + RapidMult:=s2r(DUE(s)) + else + RapidMult:=1; + + + end + else ConversionError:=-5; + end + else + P2FTrans:=0; + s:=ExtractKeyWord(lines,'HiPP='); + if s<>'' then CntrlPipePress:=s2r(DUE(s)) + else CntrlPipePress:=5+0.001*(random(10)-random(10)); //Ra 2014-07: trochę niedokładności + HighPipePress:=CntrlPipePress; + s:=ExtractKeyWord(lines,'LoPP='); + if s<>'' then LowPipePress:=s2r(DUE(s)) + else LowPipePress:=Min0R(HighPipePress,3.5); + DeltaPipePress:=HighPipePress-LowPipePress; + s:=ExtractKeyWord(lines,'Vv='); + VeselVolume:=s2r(DUE(s)); + if VeselVolume=0 then + VeselVolume:=0.01; + s:=ExtractKeyWord(lines,'MinCP='); + MinCompressor:=s2r(DUE(s)); + s:=ExtractKeyWord(lines,'MaxCP='); + MaxCompressor:=s2r(DUE(s)); + s:=ExtractKeyWord(lines,'CompressorSpeed='); + CompressorSpeed:=s2r(DUE(s)); + s:=DUE(ExtractKeyWord(lines,'CompressorPower=')); + if s='Converter' then + CompressorPower:=2 + else if s='Engine' then + CompressorPower:=3 + else if s='Coupler1' then + CompressorPower:=4 //włączana w silnikowym EZT z przodu + else if s='Coupler2' then + CompressorPower:=5 //włączana w silnikowym EZT z tyłu + else if s='Main' then + CompressorPower:=0; + end + else if Pos('Doors:',lines)>0 then {drzwi} + begin + s:=DUE(ExtractKeyWord(lines,'OpenCtrl=')); + if s='DriverCtrl' then DoorOpenCtrl:=1 + else + DoorOpenCtrl:=0; + s:=DUE(ExtractKeyWord(lines,'CloseCtrl=')); + if s='DriverCtrl' then DoorCloseCtrl:=1 + else + if s='AutomaticCtrl' then DoorCloseCtrl:=2 + else + DoorCloseCtrl:=0; + if DoorCloseCtrl=2 then + begin + s:=ExtractKeyWord(lines,'DoorStayOpen='); + DoorStayOpen:=s2rE(DUE(s)); + end; + s:=ExtractKeyWord(lines,'OpenSpeed='); + DoorOpenSpeed:=s2r(DUE(s)); + s:=ExtractKeyWord(lines,'CloseSpeed='); + DoorCloseSpeed:=s2r(DUE(s)); + s:=ExtractKeyWord(lines,'DoorMaxShiftL='); + DoorMaxShiftL:=s2r(DUE(s)); + s:=ExtractKeyWord(lines,'DoorMaxShiftR='); + DoorMaxShiftR:=s2r(DUE(s)); + s:=DUE(ExtractKeyWord(lines,'DoorOpenMethod=')); + if s='Shift' then DoorOpenMethod:=1 //przesuw + else if s='Fold' then DoorOpenMethod:=3 //3 submodele się obracają + else + DoorOpenMethod:=2; //obrót + s:=DUE(ExtractKeyWord(lines,'DoorClosureWarning=')); + if s='Yes' then + DoorClosureWarning:=true + else + DoorClosureWarning:=false; + s:=DUE(ExtractKeyWord(lines,'DoorBlocked=')); + if s='Yes' then DoorBlocked:=true + else + DoorBlocked:=false; + end + else if (Pos('BuffCoupl.',lines)>0) or (Pos('BuffCoupl1.',lines)>0) then {zderzaki i sprzegi} + begin + with Couplers[0] do + begin + s:=DUE(ExtractKeyWord(lines,'CType=')); + if s='Automatic' then + CouplerType:=Automatic + else + if s='Screw' then + CouplerType:=Screw + else + if s='Chain' then + CouplerType:=Chain + else + if s='Bare' then + CouplerType:=Bare + else + if s='Articulated' then + CouplerType:=Articulated + else + CouplerType:=NoCoupler; + s:=ExtractKeyWord(lines,'AllowedFlag='); + if s<>'' then AllowedFlag:=s2i(DUE(s)); + if (AllowedFlag<0) then AllowedFlag:=(-AllowedFlag) OR ctrain_depot; + if (CouplerType<>NoCoupler) and (CouplerType<>Bare) and (CouplerType<>Articulated) then + begin + s:=ExtractKeyWord(lines,'kC='); + SpringKC:=s2rE(DUE(s))*1000; + s:=ExtractKeyWord(lines,'DmaxC='); + DmaxC:=s2rE(DUE(s)); + s:=ExtractKeyWord(lines,'FmaxC='); + FmaxC:=s2rE(DUE(s))*1000; + s:=ExtractKeyWord(lines,'kB='); + SpringKB:=s2rE(DUE(s))*1000; + s:=ExtractKeyWord(lines,'DmaxB='); + DmaxB:=s2rE(DUE(s)); + s:=ExtractKeyWord(lines,'FmaxB='); + FmaxB:=s2rE(DUE(s))*1000; + s:=ExtractKeyWord(lines,'beta='); + beta:=s2r(DUE(s)); + end + else + if (CouplerType=Bare) then {Ra: czemu masy bez ładunków?} + begin + SpringKC:=50*Mass+Ftmax/0.05; + DmaxC:=0.05; + FmaxC:=100*Mass+2*Ftmax; + SpringKB:=60*Mass+Ftmax/0.05; + DmaxB:=0.05; + FmaxB:=50*Mass+2*Ftmax; + beta:=0.3; + end + else + if (CouplerType=Articulated) then + begin + SpringKC:=60*Mass+1000; + DmaxC:=0.05; + FmaxC:=20000000+2*Ftmax; + SpringKB:=70*Mass+1000; + DmaxB:=0.05; + FmaxB:=4000000+2*Ftmax; + beta:=0.55; + end; + end; + if (Pos('BuffCoupl.',lines)>0) then + begin + Couplers[1].SpringKC:=Couplers[0].SpringKC; + Couplers[1].DmaxC:=Couplers[0].DmaxC; + Couplers[1].FmaxC:=Couplers[0].FmaxC; + Couplers[1].SpringKB:=Couplers[0].SpringKB; + Couplers[1].DmaxB:=Couplers[0].DmaxB; + Couplers[1].FmaxB:=Couplers[0].FmaxB; + Couplers[1].beta:=Couplers[0].beta; + Couplers[1].CouplerType:=Couplers[0].CouplerType; + Couplers[1].AllowedFlag:=Couplers[0].AllowedFlag; + end; +{ CouplerTune:=(1+Mass)/100000; } + end + else if (Pos('BuffCoupl2.',lines)>0) then {zderzaki i sprzegi jesli sa rozne} + with Couplers[1] do + begin + s:=DUE(ExtractKeyWord(lines,'CType=')); + if s='Automatic' then + CouplerType:=Automatic + else + if s='Screw' then + CouplerType:=Screw + else + if s='Chain' then + CouplerType:=Chain + else + if s='Bare' then + CouplerType:=Bare + else + if s='Articulated' then + CouplerType:=Articulated + else + CouplerType:=NoCoupler; + s:=ExtractKeyWord(lines,'AllowedFlag='); + if s<>'' then AllowedFlag:=s2i(DUE(s)); + if (AllowedFlag<0) then AllowedFlag:=(-AllowedFlag) OR ctrain_depot; + if (CouplerType<>NoCoupler) and (CouplerType<>Bare) and (CouplerType<>Articulated) then + begin + s:=ExtractKeyWord(lines,'kC='); + SpringKC:=s2rE(DUE(s))*1000; + s:=ExtractKeyWord(lines,'DmaxC='); + DmaxC:=s2rE(DUE(s)); + s:=ExtractKeyWord(lines,'FmaxC='); + FmaxC:=s2rE(DUE(s))*1000; + s:=ExtractKeyWord(lines,'kB='); + SpringKB:=s2rE(DUE(s))*1000; + s:=ExtractKeyWord(lines,'DmaxB='); + DmaxB:=s2rE(DUE(s)); + s:=ExtractKeyWord(lines,'FmaxB='); + FmaxB:=s2rE(DUE(s))*1000; + s:=ExtractKeyWord(lines,'beta='); + beta:=s2r(DUE(s)); + end + else + if (CouplerType=Bare) then + begin + SpringKC:=50*Mass+1000; + DmaxC:=0.05; + FmaxC:=20*Mass+2*Ftmax; + SpringKB:=60*Mass+1000; + DmaxB:=0.05; + FmaxB:=10*Mass+2*Ftmax; + beta:=0.3; + end + else + if (CouplerType=Articulated) then + begin + SpringKC:=60*Mass+1000; + DmaxC:=0.05; + FmaxC:=20000000+2*Ftmax; + SpringKB:=70*Mass+1000;; + DmaxB:=0.05; + FmaxB:=4000000+2*Ftmax; + beta:=0.55; + end; +{ CouplerTune:=(1+Mass)/100000; } + end + else if Pos('TurboPos:',lines)>0 then {turbo zalezne od pozycji nastawnika} + begin + s:=ExtractKeyWord(lines,'TurboPos='); + TurboTest:=s2b(DUE(s)); + end + else if Pos('Cntrl.',lines)>0 then {nastawniki} + begin + s:=DUE(ExtractKeyWord(lines,'BrakeSystem=')); + if s='Pneumatic' then BrakeSystem:=Pneumatic + else if s='ElectroPneumatic' then BrakeSystem:=ElectroPneumatic + else BrakeSystem:=Individual; + if BrakeSystem<>Individual then + begin + s:=ExtractKeyWord(lines,'BCPN='); + BrakeCtrlPosNo:=s2b(DUE(s)); + + for b:=1 to 4 do + begin + s:=ExtractKeyWord(lines,'BDelay'+Cut_Space(b2s(b),CutLeft)+'='); + BrakeDelay[b]:=s2b(DUE(s)); + end; + + s:=DUE(ExtractKeyWord(lines,'BrakeDelays=')); + if s='GPR' then BrakeDelays:=bdelay_G+bdelay_P+bdelay_R + else if s='PR' then BrakeDelays:=bdelay_P+bdelay_R + else if s='GP' then BrakeDelays:=bdelay_G+bdelay_P + else if s='R' then begin BrakeDelays:=bdelay_R; BrakeDelayFlag:=bdelay_R; end + else if s='P' then begin BrakeDelays:=bdelay_P; BrakeDelayFlag:=bdelay_P; end + else if s='G' then begin BrakeDelays:=bdelay_G; BrakeDelayFlag:=bdelay_G; end + else if s='GPR+Mg' then BrakeDelays:=bdelay_G+bdelay_P+bdelay_R+bdelay_M + else if s='PR+Mg' then BrakeDelays:=bdelay_P+bdelay_R+bdelay_M; + +{ else if s='DPR+Mg' then begin Brakedelays:=bdelay_R; BrakeMethod:=3; end + else if s='DGPR+Mg' then begin Brakedelays:=bdelay_G+bdelay_R; BrakeMethod:=3; end + else if s='DGPR' then begin Brakedelays:=bdelay_G+bdelay_R; BrakeMethod:=1; end + else if s='DPR' then begin Brakedelays:=bdelay_R; BrakeMethod:=1; end + else if s='DGP' then begin Brakedelays:=bdelay_G; BrakeMethod:=1; end;} +// else if s='GPR' then Brakedelays=bdelay_G+bdelay_R + + s:=DUE(ExtractKeyWord(lines,'BrakeHandle=')); + if s='FV4a' then BrakeHandle:=FV4a + else if s='test' then BrakeHandle:=testH + else if s='D2' then BrakeHandle:=D2 + else if s='M394' then BrakeHandle:=M394 + else if s='Knorr' then BrakeHandle:=Knorr + else if s='Westinghouse' then BrakeHandle:=West + else if s='FVel6' then BrakeHandle:=FVel6 + else if s='St113' then BrakeHandle:=St113; + + s:=DUE(ExtractKeyWord(lines,'LocBrakeHandle=')); + if s='FD1' then BrakeLocHandle:=FD1 + else if s='Knorr' then BrakeLocHandle:=Knorr + else if s='Westinghouse' then BrakeLocHandle:=West; + + s:=DUE(ExtractKeyWord(lines,'MaxBPMass=')); + if s<>'' then + MBPM:=s2rE(s)*1000; + + + if BrakeCtrlPosNo>0 then + begin + s:=DUE(ExtractKeyWord(lines,'ASB=')); + if s='Manual' then ASBType:=1 else + if s='Automatic' then ASBType:=2; + end + else + begin + s:=DUE(ExtractKeyWord(lines,'ASB=')); + if s='Yes' then ASBType:=128; + end; + end; + s:=DUE(ExtractKeyWord(lines,'LocalBrake=')); + if s='ManualBrake' then LocalBrake:=ManualBrake + else + if s='PneumaticBrake' then LocalBrake:=PneumaticBrake + else + if s='HydraulicBrake' then LocalBrake:=HydraulicBrake + else LocalBrake:=NoBrake; + s:=DUE(ExtractKeyWord(lines,'ManualBrake=')); + if s='Yes' then MBrake:=true + else MBrake:=false; + s:=DUE(ExtractKeyWord(lines,'DynamicBrake=')); + if s='Passive' then DynamicBrakeType:=dbrake_passive + else + if s='Switch' then DynamicBrakeType:=dbrake_switch + else + if s='Reversal' then DynamicBrakeType:=dbrake_reversal + else + if s='Automatic' then DynamicBrakeType:=dbrake_automatic + else DynamicBrakeType:=dbrake_none; + s:=ExtractKeyWord(lines,'MCPN='); + MainCtrlPosNo:=s2b(DUE(s)); + s:=ExtractKeyWord(lines,'SCPN='); + ScndCtrlPosNo:=s2b(DUE(s)); + s:=ExtractKeyWord(lines,'SCIM='); + ScndinMain:=boolean(s2b(DUE(s))); + s:=DUE(ExtractKeyWord(lines,'AutoRelay=')); + if s='Optional' then + AutoRelayType:=2 + else + if s='Yes' then + AutoRelayType:=1 + else + AutoRelayType:=0; + s:=DUE(ExtractKeyWord(lines,'CoupledCtrl=')); + if s='Yes' then + CoupledCtrl:=true {wspolny wal} + else CoupledCtrl:=false; + s:=DUE(ExtractKeyWord(lines,'ScndS=')); + if s='Yes' then + ScndS:=true {brak pozycji rownoleglej przy niskiej nastawie PSR} + else ScndS:=false; + s:=ExtractKeyWord(lines,'IniCDelay='); + InitialCtrlDelay:=s2r(DUE(s)); + s:=ExtractKeyWord(lines,'SCDelay='); + CtrlDelay:=s2r(DUE(s)); + s:=ExtractKeyWord(lines,'SCDDelay='); + if s<>'' then CtrlDownDelay:=s2r(DUE(s)) else CtrlDownDelay:=CtrlDelay; //hunter-101012: jesli nie ma SCDDelay; + s:=DUE(ExtractKeyWord(lines,'FSCircuit=')); //hunter-111012: dla siodemek 303E + if s='Yes' then + FastSerialCircuit:=1 + else + FastSerialCircuit:=0; + + if BrakeCtrlPosNo>0 then + for i:=0 to BrakeCtrlPosNo+1 do + begin + s:=ReadWord(fin); + k:=s2iE(s); + if ConversionError=0 then + with BrakePressureTable[k] do + begin + read(fin,PipePressureVal,BrakePressureVal,FlowSpeedVal); + s:=ReadWord(fin); + if s='Pneumatic' then BrakeType:=Pneumatic + else if s='ElectroPneumatic' then BrakeType:=ElectroPneumatic + else BrakeType:=Individual; +{ readln(fin); } + end; + end; + end + else if Pos('Light:',lines)>0 then {zrodlo mocy dla oswietlenia} + begin + s:=DUE(ExtractKeyWord(lines,'Light=')); + if s<>'' then + begin + LightPowerSource.SourceType:=PowerSourceDecode(s); + PowerParamDecode(lines,'L',LightPowerSource); + s:=DUE(ExtractKeyWord(lines,'AlterLight=')); + if s<>'' then + begin + AlterLightPowerSource.SourceType:=PowerSourceDecode(s); + PowerParamDecode(lines,'AlterL',AlterLightPowerSource) + end + else AlterLightPowerSource.SourceType:=NotDefined; + end ; + s:=ExtractKeyWord(lines,'Volt='); + if s<>'' then + NominalVoltage:=s2r(DUE(s)); + + s:=ExtractKeyWord(lines,'LMaxVoltage='); + if s<>'' then + begin + BatteryVoltage:=s2r(DUE(s)); + NominalBatteryVoltage:=s2r(DUE(s)); + end; + //else LightPowerSource.SourceType:=NotDefined; + end + else if Pos('Security:',lines)>0 then + begin + //if (TrainType<>dt_EZT)or(Power>1) then //dla EZT tylko w silnikowym + with SecuritySystem do + begin + s:=DUE(ExtractKeyWord(lines,'AwareSystem=')); + if Pos('Active',s)>0 then + SetFlag(SystemType,1); + if Pos('CabSignal',s)>0 then + SetFlag(SystemType,2); + s:=ExtractKeyWord(lines,'AwareDelay='); + if s<>'' then + AwareDelay:=s2r(DUE(s)); + s:=ExtractKeyWord(lines,'AwareMinSpeed='); + if s<>'' then + AwareMinSpeed:=s2r(DUE(s)) + else + AwareMinSpeed:=0.1*Vmax; //domyślnie 10% Vmax + s:=ExtractKeyWord(lines,'SoundSignalDelay='); + if s<>'' then + SoundSignalDelay:=s2r(DUE(s)); + s:=ExtractKeyWord(lines,'EmergencyBrakeDelay='); + if s<>'' then + EmergencyBrakeDelay:=s2r(DUE(s)); + s:=ExtractKeyWord(lines,'RadioStop='); + if s<>'' then + if Pos('Yes',s)>0 then + RadioStop:=true; + end + end + else if Pos('Clima:',lines)>0 then {zrodlo mocy dla ogrzewania itp} + begin + s:=DUE(ExtractKeyWord(lines,'Heating=')); + if s<>'' then + begin + HeatingPowerSource.SourceType:=PowerSourceDecode(s); + PowerParamDecode(lines,'H',HeatingPowerSource); + s:=DUE(ExtractKeyWord(lines,'AlterHeating=')); + if s<>'' then + begin + AlterHeatPowerSource.SourceType:=PowerSourceDecode(s); + PowerParamDecode(lines,'AlterH',AlterHeatPowerSource) + end + else AlterHeatPowerSource.SourceType:=NotDefined; + end + else HeatingPowerSource.SourceType:=NotDefined; + end + else if Pos('Power:',lines)>0 then {zrodlo mocy dla silnikow trakcyjnych itp} + begin + s:=DUE(ExtractKeyWord(lines,'EnginePower=')); + if s<>'' then + begin + EnginePowerSource.SourceType:=PowerSourceDecode(s); + PowerParamDecode(lines,'',EnginePowerSource); + if (EnginePowerSource.SourceType=Generator) and (EnginePowerSource.GeneratorEngine=WheelsDriven) then + ConversionError:=-666; {perpetuum mobile?} + if (Power=0) then //jeśli nie ma mocy, np. rozrządcze EZT + EnginePowerSource.SourceType:=NotDefined; //to silnik nie ma zasilania + end + else EnginePowerSource.SourceType:=NotDefined; + //if EnginePowerSource.SourceType=NotDefined then + begin + s:=DUE(ExtractKeyWord(lines,'SystemPower=')); + if s<>'' then + begin + SystemPowerSource.SourceType:=PowerSourceDecode(s); + PowerParamDecode(lines,'',SystemPowerSource); + end + else SystemPowerSource.SourceType:=NotDefined; + end + //else SystemPowerSource.SourceType:=InternalSource; + end + else if Pos('Engine:',lines)>0 then {stale parametry silnika} + begin + EngineType:=EngineDecode(DUE(ExtractKeyWord(lines,'EngineType='))); + case EngineType of + ElectricSeriesMotor: + begin + s:=ExtractKeyWord(lines,'Volt='); + NominalVoltage:=s2r(DUE(s)); + s:=DUE(ExtractKeyWord(lines,'Trans=')); + Transmision.NToothW:=s2b(copy(s,Pos(':',s)+1,Length(s))); + Transmision.NToothM:=s2b(copy(s,1,Pos(':',s)-1)); + if s<>'' then + with Transmision do + if NToothM>0 then + Ratio:=NToothW/NToothM + else Ratio:=1; + s:=ExtractKeyWord(lines,'WindingRes='); + WindingRes:=s2r(DUE(s)); + if WindingRes=0 then WindingRes:=0.01; + s:=ExtractKeyWord(lines,'nmax='); + nmax:=s2rE(DUE(s))/60.0; + end; + WheelsDriven: + begin + s:=DUE(ExtractKeyWord(lines,'Trans=')); + Transmision.NToothW:=s2b(copy(s,Pos(':',s)+1,Length(s))); + Transmision.NToothM:=s2b(copy(s,1,Pos(':',s)-1)); + if s<>'' then + with Transmision do + if NToothM>0 then + Ratio:=NToothW/NToothM + else Ratio:=1; + s:=ExtractKeyWord(lines,'Ftmax='); + Ftmax:=s2rE(DUE(s)); + end; + Dumb: + begin + s:=ExtractKeyWord(lines,'Ftmax='); + Ftmax:=s2rE(DUE(s)); + end; + DieselEngine: + begin + s:=DUE(ExtractKeyWord(lines,'Trans=')); + Transmision.NToothW:=s2b(copy(s,Pos(':',s)+1,Length(s))); + Transmision.NToothM:=s2b(copy(s,1,Pos(':',s)-1)); + if s<>'' then + with Transmision do + if NToothM>0 then + Ratio:=NToothW/NToothM + else Ratio:=1; + s:=ExtractKeyWord(lines,'nmin='); + dizel_nmin:=s2r(DUE(s))/60.0; + s:=ExtractKeyWord(lines,'nmax='); + nmax:=s2rE(DUE(s))/60.0; + s:=ExtractKeyWord(lines,'nmax_cutoff='); + dizel_nmax_cutoff:=s2r(DUE(s))/60.0; + s:=ExtractKeyWord(lines,'AIM='); + dizel_AIM:=s2r(DUE(s)); + s:=ExtractKeyWord(lines,'ShuntMode='); + if s<>'' then + begin //dodatkowa przekładnia dla SM03 (2Ls150) + ShuntModeAllow:=true; + ShuntMode:=false; + AnPos:=s2rE(DUE(s)); //dodatkowe przełożenie + if (AnPos<1.0) then //"rozruch wysoki" ma dawać większą siłę + AnPos:=1.0/AnPos; //im większa liczba, tym wolniej jedzie + end; + end; + DieselElectric: //youBy + begin + s:=DUE(ExtractKeyWord(lines,'Trans=')); + Transmision.NToothW:=s2b(copy(s,Pos(':',s)+1,Length(s))); + Transmision.NToothM:=s2b(copy(s,1,Pos(':',s)-1)); + if s<>'' then + with Transmision do + if NToothM>0 then + Ratio:=NToothW/NToothM + else Ratio:=1; + s:=ExtractKeyWord(lines,'Ftmax='); + Ftmax:=s2rE(DUE(s)); + s:=ExtractKeyWord(lines,'Flat='); + Flat:=Boolean(s2b(DUE(s))); + s:=ExtractKeyWord(lines,'Vhyp='); + Vhyp:=s2rE(DUE(s))/3.6; + s:=ExtractKeyWord(lines,'Vadd='); + Vadd:=s2rE(DUE(s))/3.6; + s:=ExtractKeyWord(lines,'Cr='); + PowerCorRatio:=s2rE(DUE(s)); + s:=ExtractKeyWord(lines,'RelayType='); + RelayType:=s2b(DUE(s)); + s:=ExtractKeyWord(lines,'ShuntMode='); + ShuntModeAllow:=Boolean(s2b(DUE(s))); + if (ShuntModeAllow) then + begin + ShuntModeAllow:=true; + ShuntMode:=false; + AnPos:=0; + ImaxHi:=2; + ImaxLo:=1; + end; + end; + ElectricInductionMotor: + begin + rventnmax:=1; + s:=ExtractKeyWord(lines,'Volt='); + NominalVoltage:=s2r(DUE(s)); + s:=DUE(ExtractKeyWord(lines,'Trans=')); + Transmision.NToothW:=s2b(copy(s,Pos(':',s)+1,Length(s))); + Transmision.NToothM:=s2b(copy(s,1,Pos(':',s)-1)); + if s<>'' then + with Transmision do + if NToothM>0 then + Ratio:=NToothW/NToothM + else Ratio:=1; + s:=ExtractKeyWord(lines,'dfic='); eimc[eimc_s_dfic]:=s2r(DUE(s)); + s:=ExtractKeyWord(lines,'dfmax='); eimc[eimc_s_dfmax]:=s2r(DUE(s)); + s:=ExtractKeyWord(lines,'p='); eimc[eimc_s_p]:=s2r(DUE(s)); + s:=ExtractKeyWord(lines,'cfu='); eimc[eimc_s_cfu]:=s2r(DUE(s)); + s:=ExtractKeyWord(lines,'cim='); eimc[eimc_s_cim]:=s2r(DUE(s)); + s:=ExtractKeyWord(lines,'icif='); eimc[eimc_s_icif]:=s2r(DUE(s)); + s:=ExtractKeyWord(lines,'Uzmax='); eimc[eimc_f_Uzmax]:=s2r(DUE(s)); + s:=ExtractKeyWord(lines,'Uzh='); eimc[eimc_f_Uzh]:=s2r(DUE(s)); + s:=ExtractKeyWord(lines,'DU='); eimc[eimc_f_DU]:=s2r(DUE(s)); + s:=ExtractKeyWord(lines,'I0='); eimc[eimc_f_I0]:=s2r(DUE(s)); + s:=ExtractKeyWord(lines,'fcfu='); eimc[eimc_f_cfu]:=s2r(DUE(s)); + s:=ExtractKeyWord(lines,'F0='); eimc[eimc_p_F0]:=s2r(DUE(s)); + s:=ExtractKeyWord(lines,'a1='); eimc[eimc_p_a1]:=s2r(DUE(s)); + s:=ExtractKeyWord(lines,'Pmax='); eimc[eimc_p_Pmax]:=s2r(DUE(s)); + s:=ExtractKeyWord(lines,'Fh='); eimc[eimc_p_Fh]:=s2r(DUE(s)); + s:=ExtractKeyWord(lines,'Ph='); eimc[eimc_p_Ph]:=s2r(DUE(s)); + s:=ExtractKeyWord(lines,'Vh0='); eimc[eimc_p_Vh0]:=s2r(DUE(s)); + s:=ExtractKeyWord(lines,'Vh1='); eimc[eimc_p_Vh1]:=s2r(DUE(s)); + s:=ExtractKeyWord(lines,'Imax='); eimc[eimc_p_Imax]:=s2r(DUE(s)); + + end; + + else ConversionError:=-13; {not implemented yet!} + end; + end + { Typy przelacznika 'Winger 010304 } + else if Pos('Switches:',lines)>0 then + begin + s:=DUE(ExtractKeyWord(lines,'Pantograph=')); + PantSwitchType:=s; + s:=DUE(ExtractKeyWord(lines,'Converter=')); + ConvSwitchType:=s; + {case PantSwitchType of + Continuos: + begin + PantSwitchType:='continuos'; + end; + Impulse: + begin + PantSwitchType:='impulse'; + end; } + end + + else if Pos('MotorParamTable:',lines)>0 then + case EngineType of + ElectricSeriesMotor: + begin + for k:=0 to ScndCtrlPosNo do + begin + with MotorParam[k] do + read(fin, bl, mfi,mIsat, fi,Isat); + if AutoRelayType=0 then + MotorParam[k].AutoSwitch:=false + else begin + readln(fin,i); + MotorParam[k].AutoSwitch:=Boolean(i); + end; + if bl<>k then + ConversionError:=-2 + end; + end; +//youBy + DieselElectric: + begin +// WW_MPTRelayNo:= ScndCtrlPosNo; + for k:=0 to ScndCtrlPosNo do + begin + with MotorParam[k] do + readln(fin, bl, mfi, mIsat, fi, Isat, MPTRelay[k].Iup, MPTRelay[k].Idown); + if bl<>k then + ConversionError:=-2 + end; + end; + + DieselEngine: + begin + s:=ExtractKeyWord(lines,'minVelfullengage='); + dizel_minVelfullengage:=s2r(DUE(s)); + s:=ExtractKeyWord(lines,'engageDia='); + dizel_engageDia:=s2r(DUE(s)); + s:=ExtractKeyWord(lines,'engageMaxForce='); + dizel_engageMaxForce:=s2r(DUE(s)); + s:=ExtractKeyWord(lines,'engagefriction='); + dizel_engagefriction:=s2r(DUE(s)); + + for k:=0 to ScndCtrlPosNo do + begin + with MotorParam[k] do + read(fin, bl, mIsat, fi,mfi); + if AutoRelayType=0 then + MotorParam[k].AutoSwitch:=false + else begin + readln(fin,i); + MotorParam[k].AutoSwitch:=Boolean(i); + end; + if bl<>k then + ConversionError:=-2 + end; + end + else ConversionError:=-3; + end + //dwa dodatkowe parametry korekcyjne + else if Pos('MotorParamTable0:',lines)>0 then + begin + for k:=0 to ScndCtrlPosNo do + begin + with MotorParam[k] do + read(fin, bl, mfi,mIsat,mfi0, fi,Isat,fi0); + if AutoRelayType=0 then + MotorParam[k].AutoSwitch:=False + else begin + readln(fin,i); + MotorParam[k].AutoSwitch:=Boolean(i); + end; + if bl<>k then + ConversionError:=-2 + end; + end + + else if Pos('Circuit:',lines)>0 then + begin + s:=ExtractKeyWord(lines,'CircuitRes='); + CircuitRes:=s2r(DUE(s)); + s:=ExtractKeyWord(lines,'IminLo='); + IminLo:=s2iE(DUE(s)); + s:=ExtractKeyWord(lines,'IminHi='); + IminHi:=s2i(DUE(s)); + s:=ExtractKeyWord(lines,'ImaxLo='); + ImaxLo:=s2iE(DUE(s)); + s:=ExtractKeyWord(lines,'ImaxHi='); + ImaxHi:=s2i(DUE(s)); + Imin:=IminLo; + Imax:=ImaxLo; + end + else if Pos('RList:',lines)>0 then + begin + s:=DUE(ExtractKeyWord(lines,'RVent=')); + if s='Automatic' then RventType:=2 + else + if s='Yes' then RventType:=1 + else + RventType:=0; + if RventType>0 then + begin + s:=ExtractKeyWord(lines,'RVentnmax='); + RVentnmax:=s2rE(DUE(s))/60.0; + s:=ExtractKeyWord(lines,'RVentCutOff='); + RVentCutOff:=s2r(DUE(s)); + end; + RListSize:=s2b(DUE(ExtractKeyWord(lines,'Size='))); + if RListSize>ResArraySize then + ConversionError:=-4 + else + for k:=0 to RListSize do + begin + read(fin, RList[k].Relay, RList[k].R, RList[k].Bn, RList[k].Mn); +{ if AutoRelayType=0 then + RList[k].AutoSwitch:=false + else begin } {to sie przyda do pozycji przejsciowych} + read(fin,i); + RList[k].AutoSwitch:=Boolean(i); + if(ScndInMain)then + begin + readln(fin,i); + RList[k].ScndAct:=i; + end + else readln(fin); + end; + end + else if Pos('DList:',lines)>0 then {dla spalinowego silnika} + begin + s:=ExtractKeyWord(lines,'Mmax='); + dizel_Mmax:=s2rE(DUE(s)); + s:=ExtractKeyWord(lines,'nMmax='); + dizel_nMmax:=s2rE(DUE(s)); + s:=ExtractKeyWord(lines,'Mnmax='); + dizel_Mnmax:=s2rE(DUE(s)); + s:=ExtractKeyWord(lines,'nmax='); + dizel_nmax:=s2rE(DUE(s)); + s:=ExtractKeyWord(lines,'nominalfill='); + dizel_nominalfill:=s2rE(DUE(s)); + s:=ExtractKeyWord(lines,'Mstand='); + dizel_Mstand:=s2rE(DUE(s)); + RListSize:=s2b(DUE(ExtractKeyWord(lines,'Size='))); + if RListSize>ResArraySize then + ConversionError:=-4 + else + for k:=0 to RListSize do + begin + readln(fin, RList[k].Relay, RList[k].R, RList[k].Mn); + end; + end +//youBy + else if (Pos('WWList:',lines)>0) then {dla spal-ele} + begin + RListSize:=s2b(DUE(ExtractKeyWord(lines,'Size='))); + for k:=0 to RListSize do + begin + if not (ShuntModeAllow) then + readln(fin, DEList[k].rpm, DEList[k].genpower, DEList[k].Umax, DEList[k].Imax) + else + begin + readln(fin, DEList[k].rpm, DEList[k].genpower, DEList[k].Umax, DEList[k].Imax, SST[k].Umin, SST[k].Umax, SST[k].Pmax); + SST[k].Pmin:=sqrt(sqr(SST[k].Umin)/47.6); + SST[k].Pmax:=Min0R(SST[k].Pmax,sqr(SST[k].Umax)/47.6); + end; + end; + end; + end; + end; {koniec filtru importu parametrow} + if ConversionError=0 then + OK:=true + else + OK:=false; + end; {otwarty plik} + if OK then + if OKflag<>param_ok{+wheels_ok}+dimensions_ok then + begin + OK:=false; + ConversionError:=-OKflag; {brakowalo jakiejs waznej linii z parametrami} + end; + if OK and (Mass<=0) then + begin + OK:=false; + ConversionError:=-666; + end; + LoadChkFile:=OK; + if ConversionError<>-8 then + close(fin); +end; {loadchkfile} + + +END. + + + diff --git a/McZapkie/friction.hpp b/McZapkie/friction.hpp new file mode 100644 index 00000000..250d1657 --- /dev/null +++ b/McZapkie/friction.hpp @@ -0,0 +1,232 @@ +// Borland C++ Builder +// Copyright (c) 1995, 1999 by Borland International +// All rights reserved + +// (DO NOT EDIT: machine generated header) 'friction.pas' rev: 5.00 + +#ifndef frictionHPP +#define frictionHPP + +#pragma delphiheader begin +#pragma option push -w- +#pragma option push -Vx +#include // Pascal unit +#include // Pascal unit +#include // Pascal unit +#include // Pascal unit + +//-- user supplied ----------------------------------------------------------- + +namespace Friction +{ +//-- type declarations ------------------------------------------------------- +class DELPHICLASS TFricMat; +class PASCALIMPLEMENTATION TFricMat : public System::TObject +{ + typedef System::TObject inherited; + +public: + virtual double __fastcall GetFC(double N, double Vel); +public: + #pragma option push -w-inl + /* TObject.Create */ inline __fastcall TFricMat(void) : System::TObject() { } + #pragma option pop + #pragma option push -w-inl + /* TObject.Destroy */ inline __fastcall virtual ~TFricMat(void) { } + #pragma option pop + +}; + + +class DELPHICLASS TP10Bg; +class PASCALIMPLEMENTATION TP10Bg : public TFricMat +{ + typedef TFricMat inherited; + +public: + virtual double __fastcall GetFC(double N, double Vel); +public: + #pragma option push -w-inl + /* TObject.Create */ inline __fastcall TP10Bg(void) : TFricMat() { } + #pragma option pop + #pragma option push -w-inl + /* TObject.Destroy */ inline __fastcall virtual ~TP10Bg(void) { } + #pragma option pop + +}; + + +class DELPHICLASS TP10Bgu; +class PASCALIMPLEMENTATION TP10Bgu : public TFricMat +{ + typedef TFricMat inherited; + +public: + virtual double __fastcall GetFC(double N, double Vel); +public: + #pragma option push -w-inl + /* TObject.Create */ inline __fastcall TP10Bgu(void) : TFricMat() { } + #pragma option pop + #pragma option push -w-inl + /* TObject.Destroy */ inline __fastcall virtual ~TP10Bgu(void) { } + #pragma option pop + +}; + + +class DELPHICLASS TP10yBg; +class PASCALIMPLEMENTATION TP10yBg : public TFricMat +{ + typedef TFricMat inherited; + +public: + virtual double __fastcall GetFC(double N, double Vel); +public: + #pragma option push -w-inl + /* TObject.Create */ inline __fastcall TP10yBg(void) : TFricMat() { } + #pragma option pop + #pragma option push -w-inl + /* TObject.Destroy */ inline __fastcall virtual ~TP10yBg(void) { } + #pragma option pop + +}; + + +class DELPHICLASS TP10yBgu; +class PASCALIMPLEMENTATION TP10yBgu : public TFricMat +{ + typedef TFricMat inherited; + +public: + virtual double __fastcall GetFC(double N, double Vel); +public: + #pragma option push -w-inl + /* TObject.Create */ inline __fastcall TP10yBgu(void) : TFricMat() { } + #pragma option pop + #pragma option push -w-inl + /* TObject.Destroy */ inline __fastcall virtual ~TP10yBgu(void) { } + #pragma option pop + +}; + + +class DELPHICLASS TP10; +class PASCALIMPLEMENTATION TP10 : public TFricMat +{ + typedef TFricMat inherited; + +public: + virtual double __fastcall GetFC(double N, double Vel); +public: + #pragma option push -w-inl + /* TObject.Create */ inline __fastcall TP10(void) : TFricMat() { } + #pragma option pop + #pragma option push -w-inl + /* TObject.Destroy */ inline __fastcall virtual ~TP10(void) { } + #pragma option pop + +}; + + +class DELPHICLASS TFR513; +class PASCALIMPLEMENTATION TFR513 : public TFricMat +{ + typedef TFricMat inherited; + +public: + virtual double __fastcall GetFC(double N, double Vel); +public: + #pragma option push -w-inl + /* TObject.Create */ inline __fastcall TFR513(void) : TFricMat() { } + #pragma option pop + #pragma option push -w-inl + /* TObject.Destroy */ inline __fastcall virtual ~TFR513(void) { } + #pragma option pop + +}; + + +class DELPHICLASS TFR510; +class PASCALIMPLEMENTATION TFR510 : public TFricMat +{ + typedef TFricMat inherited; + +public: + virtual double __fastcall GetFC(double N, double Vel); +public: + #pragma option push -w-inl + /* TObject.Create */ inline __fastcall TFR510(void) : TFricMat() { } + #pragma option pop + #pragma option push -w-inl + /* TObject.Destroy */ inline __fastcall virtual ~TFR510(void) { } + #pragma option pop + +}; + + +class DELPHICLASS TCosid; +class PASCALIMPLEMENTATION TCosid : public TFricMat +{ + typedef TFricMat inherited; + +public: + virtual double __fastcall GetFC(double N, double Vel); +public: + #pragma option push -w-inl + /* TObject.Create */ inline __fastcall TCosid(void) : TFricMat() { } + #pragma option pop + #pragma option push -w-inl + /* TObject.Destroy */ inline __fastcall virtual ~TCosid(void) { } + #pragma option pop + +}; + + +class DELPHICLASS TDisk1; +class PASCALIMPLEMENTATION TDisk1 : public TFricMat +{ + typedef TFricMat inherited; + +public: + virtual double __fastcall GetFC(double N, double Vel); +public: + #pragma option push -w-inl + /* TObject.Create */ inline __fastcall TDisk1(void) : TFricMat() { } + #pragma option pop + #pragma option push -w-inl + /* TObject.Destroy */ inline __fastcall virtual ~TDisk1(void) { } + #pragma option pop + +}; + + +class DELPHICLASS TDisk2; +class PASCALIMPLEMENTATION TDisk2 : public TFricMat +{ + typedef TFricMat inherited; + +public: + virtual double __fastcall GetFC(double N, double Vel); +public: + #pragma option push -w-inl + /* TObject.Create */ inline __fastcall TDisk2(void) : TFricMat() { } + #pragma option pop + #pragma option push -w-inl + /* TObject.Destroy */ inline __fastcall virtual ~TDisk2(void) { } + #pragma option pop + +}; + + +//-- var, const, procedure --------------------------------------------------- + +} /* namespace Friction */ +#if !defined(NO_IMPLICIT_NAMESPACE_USE) +using namespace Friction; +#endif +#pragma option pop // -w- +#pragma option pop // -Vx + +#pragma delphiheader end. +//-- end unit ---------------------------------------------------------------- +#endif // friction diff --git a/McZapkie/friction.pas b/McZapkie/friction.pas new file mode 100644 index 00000000..03204236 --- /dev/null +++ b/McZapkie/friction.pas @@ -0,0 +1,174 @@ +unit friction; {wspolczynnik tarcia roznych materialow} + +(* + MaSzyna EU07 - SPKS + Friction coefficient. + Copyright (C) 2007-2013 Maciej Cierniak +*) + + +(* +(C) youBy +Co brakuje: +- hamulce tarczowe +- kompozyty +*) +(* +Zrobione: +1) zadeklarowane niektore typy +2) wzor jubaja na tarcie wstawek Bg i Bgu z zeliwa P10 +3) hamulec tarczowy marki 152A ;) +*) + +interface + +//uses hamulce; +uses mctools,sysutils; + +TYPE + + TFricMat = class + public + function GetFC(N, Vel: real): real; virtual; + end; + + TP10Bg = class(TFricMat) + public + function GetFC(N, Vel: real): real; override; + end; + + TP10Bgu = class(TFricMat) + public + function GetFC(N, Vel: real): real; override; + end; + + TP10yBg = class(TFricMat) + public + function GetFC(N, Vel: real): real; override; + end; + + TP10yBgu = class(TFricMat) + public + function GetFC(N, Vel: real): real; override; + end; + + TP10 = class(TFricMat) + public + function GetFC(N, Vel: real): real; override; + end; + + TFR513 = class(TFricMat) + public + function GetFC(N, Vel: real): real; override; + end; + + TFR510 = class(TFricMat) + public + function GetFC(N, Vel: real): real; override; + end; + + TCosid = class(TFricMat) + public + function GetFC(N, Vel: real): real; override; + end; + + TDisk1 = class(TFricMat) + public + function GetFC(N, Vel: real): real; override; + end; + + TDisk2 = class(TFricMat) + public + function GetFC(N, Vel: real): real; override; + end; + + +implementation + +function TFricMat.GetFC(N, Vel: real): real; +begin + GetFC:=1; +end; + +function TP10Bg.GetFC(N, Vel: real): real; +begin +// GetFC:=0.60*((1.6*N+100)/(8.0*N+100))*((Vel+100)/(5*Vel+100))*(1.0032-0.0007*N-0.0001*N*N); +// GetFC:=47/(2*Vel+100)*(2.145-0.0538*N+0.00074*N*N-0.00000536*N*N*N)/2.145; +// GetFC:=46/(2*Vel+100)*(11.33-0.105*N)/(11.33+0.179*N); +// GetFC:=49/(2*Vel+100)*(13.08-0.083*N)/(12.94+0.285*N); +//if Vel<20 then Vel:=20; +// Vel:= Vel-20; +// GetFC:=0.52*((1*Vel+100)/(5.0*Vel+100))*(13.08-0.083*N)/(12.94+0.285*N); +// GetFC:=Min0R(0.67*(1*(277-2.66*Vel)/(100+2.1*Vel)+0.23*(-686+8.27*Vel)/(100+1.16*Vel))*(13.08-0.083*N)/(12.94+0.285*N),0.4); + GetFC:=exp(-0.022*N)*(0.19-0.095*exp(-Vel/25.7))+0.384*exp(-Vel/25.7)-0.028; +end; + +function TP10Bgu.GetFC(N, Vel: real): real; +begin +// GetFC:=0.60*((1.6*N+100)/(8.0*N+100))*((Vel+100)/(5*Vel+100)); +// GetFC:=47/(2*Vel+100)*(2.137-0.0514*N+0.000832*N*N-0.00000604*N*N*N)/2.137; +// GetFC:=0.49*100/(2*Vel+100)*(11.33-0.013*N)/(11.33+0.280*N); +// GetFC:=0.52*((Vel+100)/(5.0*Vel+100))*(11.33-0.013*N)/(11.33+0.280*N); +//if Vel<20 then Vel:=20; +// Vel:= Vel-20; +// GetFC:=0.52*((0.0*Vel+120)/(5*Vel+100))*(11.33-0.013*N)/(11.33+0.280*N); +// GetFC:=0.49*100/(3*Vel+100)*(11.33-0.013*N)/(11.33+0.280*N); +// GetFC:=Min0R(0.67*(1*(277-2.66*Vel)/(100+2.1*Vel)+0.23*(-686+8.27*Vel)/(100+1.16*Vel))*(11.33-0.013*N)/(11.33+0.280*N),0.4); + GetFC:=exp(-0.017*N)*(0.18-0.09*exp(-Vel/25.7))+0.381*exp(-Vel/25.7)-0.022;//0.05*exp(-0.2*N); +end; + +function TP10yBg.GetFC(N, Vel: real): real; +var A,C,u0, V0: real; +begin + A:=2.135*exp(-0.03726*N)-0.5; + C:=0.353-A*0.029; + u0:=0.41-C; + V0:=25.7+20*A; + GetFC:=(u0+C*exp(-Vel/V0)); +end; + +function TP10yBgu.GetFC(N, Vel: real): real; +var A,C,u0, V0: real; +begin + A:=1.68*exp(-0.02735*N)-0.5; + C:=0.353-A*0.044; + u0:=0.41-C; + V0:=25.7+21*A; + GetFC:=(u0+C*exp(-Vel/V0)); +end; + +function TP10.GetFC(N, Vel: real): real; +begin + GetFC:=0.60*((1.6*N+100)/(8.0*N+100))*((Vel+100)/(5*Vel+100)); +// GetFC:=43/(2*Vel+100)*(2.145-0.0538*N+0.00074*N*N-0.00000536*N*N*N)/2.145 +end; + + +function TFR513.GetFC(N, Vel: real): real; +begin + GetFC:=0.3-Vel*0.00081; +// GetFC:=43/(2*Vel+100)*(2.145-0.0538*N+0.00074*N*N-0.00000536*N*N*N)/2.145 +end; + +function TCosid.GetFC(N, Vel: real): real; +begin + GetFC:=0.27; +end; + +function TDisk1.GetFC(N, Vel: real): real; +begin + GetFC:=0.2375+0.000885*N-0.000345*N*N; +end; + +function TDisk2.GetFC(N, Vel: real): real; +begin + GetFC:=0.27; +end; + +function TFR510.GetFC(N, Vel: real): real; +begin + GetFC:=0.15; +end; + +end. + diff --git a/McZapkie/hamulce.hpp b/McZapkie/hamulce.hpp new file mode 100644 index 00000000..a868bddd --- /dev/null +++ b/McZapkie/hamulce.hpp @@ -0,0 +1,841 @@ +// Borland C++ Builder +// Copyright (c) 1995, 1999 by Borland International +// All rights reserved + +// (DO NOT EDIT: machine generated header) 'hamulce.pas' rev: 5.00 + +#ifndef hamulceHPP +#define hamulceHPP + +#pragma delphiheader begin +#pragma option push -w- +#pragma option push -Vx +#include // Pascal unit +#include // Pascal unit +#include // Pascal unit +#include // Pascal unit +#include // Pascal unit + +//-- user supplied ----------------------------------------------------------- + +namespace Hamulce +{ +//-- type declarations ------------------------------------------------------- +class DELPHICLASS TReservoir; +class PASCALIMPLEMENTATION TReservoir : public System::TObject +{ + typedef System::TObject inherited; + +protected: + double Cap; + double Vol; + double dVol; + +public: + __fastcall TReservoir(void); + void __fastcall CreateCap(double Capacity); + void __fastcall CreatePress(double Press); + virtual double __fastcall pa(void); + virtual double __fastcall P(void); + void __fastcall Flow(double dv); + void __fastcall Act(void); +public: + #pragma option push -w-inl + /* TObject.Destroy */ inline __fastcall virtual ~TReservoir(void) { } + #pragma option pop + +}; + + +typedef TReservoir* *PReservoir; + +class DELPHICLASS TBrakeCyl; +class PASCALIMPLEMENTATION TBrakeCyl : public TReservoir +{ + typedef TReservoir inherited; + +public: + virtual double __fastcall pa(void); + virtual double __fastcall P(void); +public: + #pragma option push -w-inl + /* TReservoir.Create */ inline __fastcall TBrakeCyl(void) : TReservoir() { } + #pragma option pop + +public: + #pragma option push -w-inl + /* TObject.Destroy */ inline __fastcall virtual ~TBrakeCyl(void) { } + #pragma option pop + +}; + + +class DELPHICLASS TBrake; +class PASCALIMPLEMENTATION TBrake : public System::TObject +{ + typedef System::TObject inherited; + +protected: + TReservoir* BrakeCyl; + TReservoir* BrakeRes; + TReservoir* ValveRes; + Byte BCN; + double BCM; + double BCA; + Byte BrakeDelays; + Byte BrakeDelayFlag; + Friction::TFricMat* FM; + double MaxBP; + Byte BA; + Byte NBpA; + double SizeBR; + double SizeBC; + bool DCV; + double ASBP; + Byte BrakeStatus; + Byte SoundFlag; + +public: + __fastcall TBrake(double i_mbp, double i_bcr, double i_bcd, double i_brc, Byte i_bcn, Byte i_BD, Byte + i_mat, Byte i_ba, Byte i_nbpa); + virtual double __fastcall GetFC(double Vel, double N); + virtual double __fastcall GetPF(double PP, double dt, double Vel); + double __fastcall GetBCF(void); + virtual double __fastcall GetHPFlow(double HP, double dt); + virtual double __fastcall GetBCP(void); + double __fastcall GetBRP(void); + double __fastcall GetVRP(void); + virtual double __fastcall GetCRP(void); + virtual void __fastcall Init(double PP, double HPP, double LPP, double BP, Byte BDF); + bool __fastcall SetBDF(Byte nBDF); + void __fastcall Releaser(Byte state); + virtual void __fastcall SetEPS(double nEPS); + void __fastcall ASB(Byte state); + Byte __fastcall GetStatus(void); + void __fastcall SetASBP(double press); + virtual void __fastcall ForceEmptiness(void); + Byte __fastcall GetSoundFlag(void); +public: + #pragma option push -w-inl + /* TObject.Destroy */ inline __fastcall virtual ~TBrake(void) { } + #pragma option pop + +}; + + +class DELPHICLASS TWest; +class PASCALIMPLEMENTATION TWest : public TBrake +{ + typedef TBrake inherited; + +private: + double LBP; + double dVP; + double EPS; + double TareM; + double LoadM; + double TareBP; + double LoadC; + +public: + void __fastcall SetLBP(double P); + virtual double __fastcall GetPF(double PP, double dt, double Vel); + virtual void __fastcall Init(double PP, double HPP, double LPP, double BP, Byte BDF); + virtual double __fastcall GetHPFlow(double HP, double dt); + void __fastcall PLC(double mass); + virtual void __fastcall SetEPS(double nEPS); + void __fastcall SetLP(double TM, double LM, double TBP); +public: + #pragma option push -w-inl + /* TBrake.Create */ inline __fastcall TWest(double i_mbp, double i_bcr, double i_bcd, double i_brc, + Byte i_bcn, Byte i_BD, Byte i_mat, Byte i_ba, Byte i_nbpa) : TBrake(i_mbp, i_bcr, i_bcd, i_brc, i_bcn + , i_BD, i_mat, i_ba, i_nbpa) { } + #pragma option pop + +public: + #pragma option push -w-inl + /* TObject.Destroy */ inline __fastcall virtual ~TWest(void) { } + #pragma option pop + +}; + + +class DELPHICLASS TESt; +class PASCALIMPLEMENTATION TESt : public TBrake +{ + typedef TBrake inherited; + +private: + TReservoir* CntrlRes; + double BVM; + +public: + virtual double __fastcall GetPF(double PP, double dt, double Vel); + void __fastcall EStParams(double i_crc); + virtual void __fastcall Init(double PP, double HPP, double LPP, double BP, Byte BDF); + virtual double __fastcall GetCRP(void); + void __fastcall CheckState(double BCP, double &dV1); + void __fastcall CheckReleaser(double dt); + double __fastcall CVs(double bp); + double __fastcall BVs(double BCP); +public: + #pragma option push -w-inl + /* TBrake.Create */ inline __fastcall TESt(double i_mbp, double i_bcr, double i_bcd, double i_brc, + Byte i_bcn, Byte i_BD, Byte i_mat, Byte i_ba, Byte i_nbpa) : TBrake(i_mbp, i_bcr, i_bcd, i_brc, i_bcn + , i_BD, i_mat, i_ba, i_nbpa) { } + #pragma option pop + +public: + #pragma option push -w-inl + /* TObject.Destroy */ inline __fastcall virtual ~TESt(void) { } + #pragma option pop + +}; + + +class DELPHICLASS TESt3; +class PASCALIMPLEMENTATION TESt3 : public TESt +{ + typedef TESt inherited; + +private: + double CylFlowSpeed[2][2]; + +public: + virtual double __fastcall GetPF(double PP, double dt, double Vel); +public: + #pragma option push -w-inl + /* TBrake.Create */ inline __fastcall TESt3(double i_mbp, double i_bcr, double i_bcd, double i_brc, + Byte i_bcn, Byte i_BD, Byte i_mat, Byte i_ba, Byte i_nbpa) : TESt(i_mbp, i_bcr, i_bcd, i_brc, i_bcn + , i_BD, i_mat, i_ba, i_nbpa) { } + #pragma option pop + +public: + #pragma option push -w-inl + /* TObject.Destroy */ inline __fastcall virtual ~TESt3(void) { } + #pragma option pop + +}; + + +class DELPHICLASS TESt3AL2; +class PASCALIMPLEMENTATION TESt3AL2 : public TESt3 +{ + typedef TESt3 inherited; + +private: + double TareM; + double LoadM; + double TareBP; + double LoadC; + +public: + TReservoir* ImplsRes; + virtual double __fastcall GetPF(double PP, double dt, double Vel); + void __fastcall PLC(double mass); + void __fastcall SetLP(double TM, double LM, double TBP); + virtual void __fastcall Init(double PP, double HPP, double LPP, double BP, Byte BDF); +public: + #pragma option push -w-inl + /* TBrake.Create */ inline __fastcall TESt3AL2(double i_mbp, double i_bcr, double i_bcd, double i_brc + , Byte i_bcn, Byte i_BD, Byte i_mat, Byte i_ba, Byte i_nbpa) : TESt3(i_mbp, i_bcr, i_bcd, i_brc, i_bcn + , i_BD, i_mat, i_ba, i_nbpa) { } + #pragma option pop + +public: + #pragma option push -w-inl + /* TObject.Destroy */ inline __fastcall virtual ~TESt3AL2(void) { } + #pragma option pop + +}; + + +class DELPHICLASS TESt4R; +class PASCALIMPLEMENTATION TESt4R : public TESt +{ + typedef TESt inherited; + +private: + bool RapidStatus; + double RapidTemp; + +public: + TReservoir* ImplsRes; + virtual double __fastcall GetPF(double PP, double dt, double Vel); + virtual void __fastcall Init(double PP, double HPP, double LPP, double BP, Byte BDF); +public: + #pragma option push -w-inl + /* TBrake.Create */ inline __fastcall TESt4R(double i_mbp, double i_bcr, double i_bcd, double i_brc + , Byte i_bcn, Byte i_BD, Byte i_mat, Byte i_ba, Byte i_nbpa) : TESt(i_mbp, i_bcr, i_bcd, i_brc, i_bcn + , i_BD, i_mat, i_ba, i_nbpa) { } + #pragma option pop + +public: + #pragma option push -w-inl + /* TObject.Destroy */ inline __fastcall virtual ~TESt4R(void) { } + #pragma option pop + +}; + + +class DELPHICLASS TLSt; +class PASCALIMPLEMENTATION TLSt : public TESt4R +{ + typedef TESt4R inherited; + +private: + double CylFlowSpeed[2][2]; + double LBP; + double RM; + double EDFlag; + +public: + void __fastcall SetLBP(double P); + void __fastcall SetRM(double RMR); + virtual double __fastcall GetPF(double PP, double dt, double Vel); + virtual double __fastcall GetHPFlow(double HP, double dt); + virtual void __fastcall Init(double PP, double HPP, double LPP, double BP, Byte BDF); + virtual double __fastcall GetEDBCP(void); + void __fastcall SetED(double EDstate); +public: + #pragma option push -w-inl + /* TBrake.Create */ inline __fastcall TLSt(double i_mbp, double i_bcr, double i_bcd, double i_brc, + Byte i_bcn, Byte i_BD, Byte i_mat, Byte i_ba, Byte i_nbpa) : TESt4R(i_mbp, i_bcr, i_bcd, i_brc, i_bcn + , i_BD, i_mat, i_ba, i_nbpa) { } + #pragma option pop + +public: + #pragma option push -w-inl + /* TObject.Destroy */ inline __fastcall virtual ~TLSt(void) { } + #pragma option pop + +}; + + +class DELPHICLASS TEStED; +class PASCALIMPLEMENTATION TEStED : public TLSt +{ + typedef TLSt inherited; + +private: + double Nozzles[11]; + bool Zamykajacy; + bool Przys_blok; + TReservoir* Miedzypoj; + +public: + virtual void __fastcall Init(double PP, double HPP, double LPP, double BP, Byte BDF); + virtual double __fastcall GetPF(double PP, double dt, double Vel); + virtual double __fastcall GetEDBCP(void); +public: + #pragma option push -w-inl + /* TBrake.Create */ inline __fastcall TEStED(double i_mbp, double i_bcr, double i_bcd, double i_brc + , Byte i_bcn, Byte i_BD, Byte i_mat, Byte i_ba, Byte i_nbpa) : TLSt(i_mbp, i_bcr, i_bcd, i_brc, i_bcn + , i_BD, i_mat, i_ba, i_nbpa) { } + #pragma option pop + +public: + #pragma option push -w-inl + /* TObject.Destroy */ inline __fastcall virtual ~TEStED(void) { } + #pragma option pop + +}; + + +class DELPHICLASS TEStEP2; +class PASCALIMPLEMENTATION TEStEP2 : public TLSt +{ + typedef TLSt inherited; + +private: + double TareM; + double LoadM; + double TareBP; + double LoadC; + double EPS; + +public: + virtual double __fastcall GetPF(double PP, double dt, double Vel); + virtual void __fastcall Init(double PP, double HPP, double LPP, double BP, Byte BDF); + void __fastcall PLC(double mass); + virtual void __fastcall SetEPS(double nEPS); + void __fastcall SetLP(double TM, double LM, double TBP); +public: + #pragma option push -w-inl + /* TBrake.Create */ inline __fastcall TEStEP2(double i_mbp, double i_bcr, double i_bcd, double i_brc + , Byte i_bcn, Byte i_BD, Byte i_mat, Byte i_ba, Byte i_nbpa) : TLSt(i_mbp, i_bcr, i_bcd, i_brc, i_bcn + , i_BD, i_mat, i_ba, i_nbpa) { } + #pragma option pop + +public: + #pragma option push -w-inl + /* TObject.Destroy */ inline __fastcall virtual ~TEStEP2(void) { } + #pragma option pop + +}; + + +class DELPHICLASS TCV1; +class PASCALIMPLEMENTATION TCV1 : public TBrake +{ + typedef TBrake inherited; + +private: + TReservoir* CntrlRes; + double BVM; + +public: + virtual double __fastcall GetPF(double PP, double dt, double Vel); + virtual void __fastcall Init(double PP, double HPP, double LPP, double BP, Byte BDF); + virtual double __fastcall GetCRP(void); + void __fastcall CheckState(double BCP, double &dV1); + double __fastcall CVs(double bp); + double __fastcall BVs(double BCP); +public: + #pragma option push -w-inl + /* TBrake.Create */ inline __fastcall TCV1(double i_mbp, double i_bcr, double i_bcd, double i_brc, + Byte i_bcn, Byte i_BD, Byte i_mat, Byte i_ba, Byte i_nbpa) : TBrake(i_mbp, i_bcr, i_bcd, i_brc, i_bcn + , i_BD, i_mat, i_ba, i_nbpa) { } + #pragma option pop + +public: + #pragma option push -w-inl + /* TObject.Destroy */ inline __fastcall virtual ~TCV1(void) { } + #pragma option pop + +}; + + +class DELPHICLASS TCV1R; +class PASCALIMPLEMENTATION TCV1R : public TCV1 +{ + typedef TCV1 inherited; + +private: + TReservoir* ImplsRes; + bool RapidStatus; +public: + #pragma option push -w-inl + /* TBrake.Create */ inline __fastcall TCV1R(double i_mbp, double i_bcr, double i_bcd, double i_brc, + Byte i_bcn, Byte i_BD, Byte i_mat, Byte i_ba, Byte i_nbpa) : TCV1(i_mbp, i_bcr, i_bcd, i_brc, i_bcn + , i_BD, i_mat, i_ba, i_nbpa) { } + #pragma option pop + +public: + #pragma option push -w-inl + /* TObject.Destroy */ inline __fastcall virtual ~TCV1R(void) { } + #pragma option pop + +}; + + +class DELPHICLASS TCV1L_TR; +class PASCALIMPLEMENTATION TCV1L_TR : public TCV1 +{ + typedef TCV1 inherited; + +private: + TReservoir* ImplsRes; + double LBP; + +public: + virtual double __fastcall GetPF(double PP, double dt, double Vel); + virtual void __fastcall Init(double PP, double HPP, double LPP, double BP, Byte BDF); + void __fastcall SetLBP(double P); + virtual double __fastcall GetHPFlow(double HP, double dt); +public: + #pragma option push -w-inl + /* TBrake.Create */ inline __fastcall TCV1L_TR(double i_mbp, double i_bcr, double i_bcd, double i_brc + , Byte i_bcn, Byte i_BD, Byte i_mat, Byte i_ba, Byte i_nbpa) : TCV1(i_mbp, i_bcr, i_bcd, i_brc, i_bcn + , i_BD, i_mat, i_ba, i_nbpa) { } + #pragma option pop + +public: + #pragma option push -w-inl + /* TObject.Destroy */ inline __fastcall virtual ~TCV1L_TR(void) { } + #pragma option pop + +}; + + +class DELPHICLASS TKE; +class PASCALIMPLEMENTATION TKE : public TBrake +{ + typedef TBrake inherited; + +private: + bool RapidStatus; + TReservoir* ImplsRes; + TReservoir* CntrlRes; + TReservoir* Brak2Res; + double BVM; + double TareM; + double LoadM; + double TareBP; + double LoadC; + double RM; + double LBP; + +public: + void __fastcall SetRM(double RMR); + virtual double __fastcall GetPF(double PP, double dt, double Vel); + virtual void __fastcall Init(double PP, double HPP, double LPP, double BP, Byte BDF); + virtual double __fastcall GetHPFlow(double HP, double dt); + virtual double __fastcall GetCRP(void); + void __fastcall CheckState(double BCP, double &dV1); + void __fastcall CheckReleaser(double dt); + double __fastcall CVs(double bp); + double __fastcall BVs(double BCP); + void __fastcall PLC(double mass); + void __fastcall SetLP(double TM, double LM, double TBP); + void __fastcall SetLBP(double P); +public: + #pragma option push -w-inl + /* TBrake.Create */ inline __fastcall TKE(double i_mbp, double i_bcr, double i_bcd, double i_brc, Byte + i_bcn, Byte i_BD, Byte i_mat, Byte i_ba, Byte i_nbpa) : TBrake(i_mbp, i_bcr, i_bcd, i_brc, i_bcn, + i_BD, i_mat, i_ba, i_nbpa) { } + #pragma option pop + +public: + #pragma option push -w-inl + /* TObject.Destroy */ inline __fastcall virtual ~TKE(void) { } + #pragma option pop + +}; + + +class DELPHICLASS THandle; +class PASCALIMPLEMENTATION THandle : public System::TObject +{ + typedef System::TObject inherited; + +public: + bool Time; + bool TimeEP; + double Sounds[5]; + virtual double __fastcall GetPF(double i_bcp, double pp, double hp, double dt, double ep); + virtual void __fastcall Init(double press); + virtual double __fastcall GetCP(void); + virtual void __fastcall SetReductor(double nAdj); + virtual double __fastcall GetSound(Byte i); + virtual double __fastcall GetPos(Byte i); +public: + #pragma option push -w-inl + /* TObject.Create */ inline __fastcall THandle(void) : System::TObject() { } + #pragma option pop + #pragma option push -w-inl + /* TObject.Destroy */ inline __fastcall virtual ~THandle(void) { } + #pragma option pop + +}; + + +class DELPHICLASS TFV4a; +class PASCALIMPLEMENTATION TFV4a : public THandle +{ + typedef THandle inherited; + +private: + double CP; + double TP; + double RP; + +public: + virtual double __fastcall GetPF(double i_bcp, double pp, double hp, double dt, double ep); + virtual void __fastcall Init(double press); +public: + #pragma option push -w-inl + /* TObject.Create */ inline __fastcall TFV4a(void) : THandle() { } + #pragma option pop + #pragma option push -w-inl + /* TObject.Destroy */ inline __fastcall virtual ~TFV4a(void) { } + #pragma option pop + +}; + + +class DELPHICLASS TFV4aM; +class PASCALIMPLEMENTATION TFV4aM : public THandle +{ + typedef THandle inherited; + +private: + double CP; + double TP; + double RP; + double XP; + double RedAdj; + bool Fala; + +public: + virtual double __fastcall GetPF(double i_bcp, double pp, double hp, double dt, double ep); + virtual void __fastcall Init(double press); + virtual void __fastcall SetReductor(double nAdj); + virtual double __fastcall GetSound(Byte i); + virtual double __fastcall GetPos(Byte i); +public: + #pragma option push -w-inl + /* TObject.Create */ inline __fastcall TFV4aM(void) : THandle() { } + #pragma option pop + #pragma option push -w-inl + /* TObject.Destroy */ inline __fastcall virtual ~TFV4aM(void) { } + #pragma option pop + +}; + + +class DELPHICLASS TM394; +class PASCALIMPLEMENTATION TM394 : public THandle +{ + typedef THandle inherited; + +private: + double CP; + double RedAdj; + +public: + virtual double __fastcall GetPF(double i_bcp, double pp, double hp, double dt, double ep); + virtual void __fastcall Init(double press); + virtual void __fastcall SetReductor(double nAdj); + virtual double __fastcall GetCP(void); + virtual double __fastcall GetPos(Byte i); +public: + #pragma option push -w-inl + /* TObject.Create */ inline __fastcall TM394(void) : THandle() { } + #pragma option pop + #pragma option push -w-inl + /* TObject.Destroy */ inline __fastcall virtual ~TM394(void) { } + #pragma option pop + +}; + + +class DELPHICLASS TH14K1; +class PASCALIMPLEMENTATION TH14K1 : public THandle +{ + typedef THandle inherited; + +private: + double CP; + double RedAdj; + +public: + virtual double __fastcall GetPF(double i_bcp, double pp, double hp, double dt, double ep); + virtual void __fastcall Init(double press); + virtual void __fastcall SetReductor(double nAdj); + virtual double __fastcall GetCP(void); + virtual double __fastcall GetPos(Byte i); +public: + #pragma option push -w-inl + /* TObject.Create */ inline __fastcall TH14K1(void) : THandle() { } + #pragma option pop + #pragma option push -w-inl + /* TObject.Destroy */ inline __fastcall virtual ~TH14K1(void) { } + #pragma option pop + +}; + + +class DELPHICLASS TSt113; +class PASCALIMPLEMENTATION TSt113 : public TH14K1 +{ + typedef TH14K1 inherited; + +private: + double EPS; + +public: + virtual double __fastcall GetPF(double i_bcp, double pp, double hp, double dt, double ep); + virtual double __fastcall GetCP(void); + virtual double __fastcall GetPos(Byte i); + virtual void __fastcall Init(double press); +public: + #pragma option push -w-inl + /* TObject.Create */ inline __fastcall TSt113(void) : TH14K1() { } + #pragma option pop + #pragma option push -w-inl + /* TObject.Destroy */ inline __fastcall virtual ~TSt113(void) { } + #pragma option pop + +}; + + +class DELPHICLASS Ttest; +class PASCALIMPLEMENTATION Ttest : public THandle +{ + typedef THandle inherited; + +private: + double CP; + +public: + virtual double __fastcall GetPF(double i_bcp, double pp, double hp, double dt, double ep); + virtual void __fastcall Init(double press); +public: + #pragma option push -w-inl + /* TObject.Create */ inline __fastcall Ttest(void) : THandle() { } + #pragma option pop + #pragma option push -w-inl + /* TObject.Destroy */ inline __fastcall virtual ~Ttest(void) { } + #pragma option pop + +}; + + +class DELPHICLASS TFD1; +class PASCALIMPLEMENTATION TFD1 : public THandle +{ + typedef THandle inherited; + +private: + double MaxBP; + double BP; + +public: + virtual double __fastcall GetPF(double i_bcp, double pp, double hp, double dt, double ep); + virtual void __fastcall Init(double press); + virtual double __fastcall GetCP(void); +public: + #pragma option push -w-inl + /* TObject.Create */ inline __fastcall TFD1(void) : THandle() { } + #pragma option pop + #pragma option push -w-inl + /* TObject.Destroy */ inline __fastcall virtual ~TFD1(void) { } + #pragma option pop + +}; + + +class DELPHICLASS TH1405; +class PASCALIMPLEMENTATION TH1405 : public THandle +{ + typedef THandle inherited; + +private: + double MaxBP; + double BP; + +public: + virtual double __fastcall GetPF(double i_bcp, double pp, double hp, double dt, double ep); + virtual void __fastcall Init(double press); + virtual double __fastcall GetCP(void); +public: + #pragma option push -w-inl + /* TObject.Create */ inline __fastcall TH1405(void) : THandle() { } + #pragma option pop + #pragma option push -w-inl + /* TObject.Destroy */ inline __fastcall virtual ~TH1405(void) { } + #pragma option pop + +}; + + +class DELPHICLASS TFVel6; +class PASCALIMPLEMENTATION TFVel6 : public THandle +{ + typedef THandle inherited; + +private: + double EPS; + +public: + virtual double __fastcall GetPF(double i_bcp, double pp, double hp, double dt, double ep); + virtual double __fastcall GetCP(void); + virtual double __fastcall GetPos(Byte i); + virtual double __fastcall GetSound(Byte i); + virtual void __fastcall Init(double press); +public: + #pragma option push -w-inl + /* TObject.Create */ inline __fastcall TFVel6(void) : THandle() { } + #pragma option pop + #pragma option push -w-inl + /* TObject.Destroy */ inline __fastcall virtual ~TFVel6(void) { } + #pragma option pop + +}; + + +//-- var, const, procedure --------------------------------------------------- +static const Shortint LocalBrakePosNo = 0xa; +static const Shortint MainBrakeMaxPos = 0xa; +static const Shortint bdelay_G = 0x1; +static const Shortint bdelay_P = 0x2; +static const Shortint bdelay_R = 0x4; +static const Shortint bdelay_M = 0x8; +static const Byte bdelay_GR = 0x80; +static const Shortint b_off = 0x0; +static const Shortint b_hld = 0x1; +static const Shortint b_on = 0x2; +static const Shortint b_rfl = 0x4; +static const Shortint b_rls = 0x8; +static const Shortint b_ep = 0x10; +static const Shortint b_asb = 0x20; +static const Byte b_dmg = 0x80; +static const Shortint df_on = 0x1; +static const Shortint df_off = 0x2; +static const Shortint df_br = 0x4; +static const Shortint df_vv = 0x8; +static const Shortint df_bc = 0x10; +static const Shortint df_cv = 0x20; +static const Shortint df_PP = 0x40; +static const Byte df_RR = 0x80; +static const Shortint s_fv4a_b = 0x0; +static const Shortint s_fv4a_u = 0x1; +static const Shortint s_fv4a_e = 0x2; +static const Shortint s_fv4a_x = 0x3; +static const Shortint s_fv4a_t = 0x4; +static const Shortint bp_P10 = 0x0; +static const Shortint bp_P10Bg = 0x2; +static const Shortint bp_P10Bgu = 0x1; +static const Shortint bp_LLBg = 0x4; +static const Shortint bp_LLBgu = 0x3; +static const Shortint bp_LBg = 0x6; +static const Shortint bp_LBgu = 0x5; +static const Shortint bp_KBg = 0x8; +static const Shortint bp_KBgu = 0x7; +static const Shortint bp_D1 = 0x9; +static const Shortint bp_D2 = 0xa; +static const Shortint bp_FR513 = 0xb; +static const Shortint bp_Cosid = 0xc; +static const Shortint bp_PKPBg = 0xd; +static const Shortint bp_PKPBgu = 0xe; +static const Byte bp_MHS = 0x80; +static const Shortint bp_P10yBg = 0xf; +static const Shortint bp_P10yBgu = 0x10; +static const Shortint sf_Acc = 0x1; +static const Shortint sf_BR = 0x2; +static const Shortint sf_CylB = 0x4; +static const Shortint sf_CylU = 0x8; +static const Shortint sf_rel = 0x10; +static const Shortint sf_ep = 0x20; +static const Shortint bh_MIN = 0x0; +static const Shortint bh_MAX = 0x1; +static const Shortint bh_FS = 0x2; +static const Shortint bh_RP = 0x3; +static const Shortint bh_NP = 0x4; +static const Shortint bh_MB = 0x5; +static const Shortint bh_FB = 0x6; +static const Shortint bh_EB = 0x7; +static const Shortint bh_EPR = 0x8; +static const Shortint bh_EPN = 0x9; +static const Shortint bh_EPB = 0xa; +#define SpgD (7.917000E-01) +#define SpO (5.067000E-01) +extern PACKAGE double BPT[9][2]; +extern PACKAGE double BPT_394[7][2]; +static const Shortint i_bcpno = 0x6; +extern PACKAGE double __fastcall PF(double P1, double P2, double S, double DP); +extern PACKAGE double __fastcall PF1(double P1, double P2, double S); +extern PACKAGE double __fastcall PFVa(double PH, double PL, double S, double LIM, double DP); +extern PACKAGE double __fastcall PFVd(double PH, double PL, double S, double LIM, double DP); + +} /* namespace Hamulce */ +#if !defined(NO_IMPLICIT_NAMESPACE_USE) +using namespace Hamulce; +#endif +#pragma option pop // -w- +#pragma option pop // -Vx + +#pragma delphiheader end. +//-- end unit ---------------------------------------------------------------- +#endif // hamulce diff --git a/McZapkie/hamulce.pas b/McZapkie/hamulce.pas new file mode 100644 index 00000000..79d552f1 --- /dev/null +++ b/McZapkie/hamulce.pas @@ -0,0 +1,3014 @@ +unit hamulce; {fizyka hamulcow dla symulatora} + +(* + MaSzyna EU07 - SPKS + Brakes. + Copyright (C) 2007-2014 Maciej Cierniak +*) + + +(* +(C) youBy +Co brakuje: +moze jeszcze jakis SW +*) +(* +Zrobione: +ESt3, ESt3AL2, ESt4R, LSt, FV4a, FD1, EP2, prosty westinghouse +duzo wersji żeliwa +KE +Tarcze od 152A +Magnetyki (implementacja w mover.pas) +Matrosow 394 +H14K1 (zasadniczy), H1405 (pomocniczy), St113 (ep) +Knorr/West EP - żeby był +*) + +interface + +uses mctools,sysutils,friction; + +CONST + + LocalBrakePosNo=10; {ilosc nastaw hamulca recznego lub pomocniczego} + MainBrakeMaxPos=10; {max. ilosc nastaw hamulca zasadniczego} + + {nastawy hamulca} + bdelay_G=1; //G + bdelay_P=2; //P + bdelay_R=4; //R + bdelay_M=8; //Mg + bdelay_GR=128; //G-R + + + {stan hamulca} + b_off = 0; //luzowanie + b_hld = 1; //trzymanie + b_on = 2; //napelnianie + b_rfl = 4; //uzupelnianie + b_rls = 8; //odluzniacz + b_ep = 16; //elektropneumatyczny + b_asb = 32; //elektropneumatyczny + b_dmg =128; //wylaczony z dzialania + + {uszkodzenia hamulca} + df_on = 1; //napelnianie + df_off = 2; //luzowanie + df_br = 4; //wyplyw z ZP + df_vv = 8; //wyplyw z komory wstepnej + df_bc = 16; //wyplyw z silownika + df_cv = 32; //wyplyw z ZS + df_PP = 64; //zawsze niski stopien + df_RR =128; //zawsze wysoki stopien + + {indeksy dzwiekow FV4a} + s_fv4a_b = 0; //hamowanie + s_fv4a_u = 1; //luzowanie + s_fv4a_e = 2; //hamowanie nagle + s_fv4a_x = 3; //wyplyw sterujacego fala + s_fv4a_t = 4; //wyplyw z czasowego + + {pary cierne} + bp_P10 = 0; + bp_P10Bg = 2; //żeliwo fosforowe P10 + bp_P10Bgu = 1; + bp_LLBg = 4; //komp. b.n.t. + bp_LLBgu = 3; + bp_LBg = 6; //komp. n.t. + bp_LBgu = 5; + bp_KBg = 8; //komp. w.t. + bp_KBgu = 7; + bp_D1 = 9; //tarcze + bp_D2 = 10; + bp_FR513 = 11; //Frenoplast FR513 + bp_Cosid = 12; //jakistam kompozyt :D + bp_PKPBg = 13; //żeliwo PKP + bp_PKPBgu = 14; + bp_MHS = 128; //magnetyczny hamulec szynowy + bp_P10yBg = 15; //żeliwo fosforowe P10 + bp_P10yBgu= 16; + + sf_Acc = 1; //przyspieszacz + sf_BR = 2; //przekladnia + sf_CylB = 4; //cylinder - napelnianie + sf_CylU = 8; //cylinder - oproznianie + sf_rel = 16; //odluzniacz + sf_ep = 32; //zawory ep + + bh_MIN= 0; //minimalna pozycja + bh_MAX= 1; //maksymalna pozycja + bh_FS = 2; //napelnianie uderzeniowe //jesli nie ma, to jazda + bh_RP = 3; //jazda + bh_NP = 4; //odciecie - podwojna trakcja + bh_MB = 5; //odciecie - utrzymanie stopnia hamowania/pierwszy 1 stopien hamowania + bh_FB = 6; //pelne + bh_EB = 7; //nagle + bh_EPR= 8; //ep - luzowanie //pelny luz dla ep kątowego + bh_EPN= 9; //ep - utrzymanie //jesli rowne luzowaniu, wtedy sterowanie przyciskiem + bh_EPB=10; //ep - hamowanie //pelne hamowanie dla ep kątowego + + + SpgD=0.7917; + SpO=0.5067; //przekroj przewodu 1" w l/m + //wyj: jednostka dosyc dziwna, ale wszystkie obliczenia + //i pojemnosci sa podane w litrach (rozsadne wielkosci) + //zas dlugosc pojazdow jest podana w metrach + //a predkosc przeplywu w m/s //3.5 + //7//1.5 +// BPT: array[-2..6] of array [0..1] of real= ((0, 5.0), (14, 5.4), (9, 5.0), (6, 4.6), (9, 4.5), (9, 4.0), (9, 3.5), (9, 2.8), (34, 2.8)); +// BPT: array[-2..6] of array [0..1] of real= ((0, 5.0), (7, 5.0), (2.0, 5.0), (4.5, 4.6), (4.5, 4.2), (4.5, 3.8), (4.5, 3.4), (4.5, 2.8), (8, 2.8)); + BPT: array[-2..6] of array [0..1] of real= ((0, 5.0), (7, 5.0), (2.0, 5.0), (4.5, 4.6), (4.5, 4.2), (4.5, 3.8), (4.5, 3.4), (4.5, 2.8), (8, 2.8)); + BPT_394: array[-1..5] of array [0..1] of real= ((13, 10.0), (5, 5.0), (0, -1), (5, -1), (5, 0.0), (5, 0.0), (18, 0.0)); +// BPT: array[-2..6] of array [0..1] of real= ((0, 5.0), (12, 5.4), (9, 5.0), (9, 4.6), (9, 4.2), (9, 3.8), (9, 3.4), (9, 2.8), (34, 2.8)); +// BPT: array[-2..6] of array [0..1] of real= ((0, 0),(0, 0),(0, 0),(0, 0),(0, 0),(0, 0),(0, 0),(0, 0),(0, 0)); + i_bcpno= 6; + +TYPE + //klasa obejmujaca pojedyncze zbiorniki + TReservoir= class + protected + Cap: real; + Vol: real; + dVol: real; + public + constructor Create; + procedure CreateCap(Capacity: real); + procedure CreatePress(Press: real); + function pa: real; virtual; + function P: real; virtual; + procedure Flow(dv: real); + procedure Act; + end; + + PReservoir=^TReservoir; + + TBrakeCyl= class(TReservoir) + public + function pa: real; override; + function P: real; override; + end; + + //klasa obejmujaca uklad hamulca zespolonego pojazdu + TBrake= class + protected + BrakeCyl: TReservoir; //silownik + BrakeRes: TReservoir; //ZP + ValveRes: TReservoir; //komora wstepna + BCN: byte; //ilosc silownikow + BCM: real; //przekladnia hamulcowa + BCA: real; //laczny przekroj silownikow + BrakeDelays: byte; //dostepne opoznienia + BrakeDelayFlag: byte; //aktualna nastawa + FM: TFricMat; //material cierny + MaxBP: real; //najwyzsze cisnienie + BA: byte; //osie hamowane + NBpA: byte; //klocki na os + SizeBR: real; //rozmiar^2 ZP (w stosunku do 14") + SizeBC: real; //rozmiar^2 CH (w stosunku do 14") + DCV: boolean; //podwojny zawor zwrotny + ASBP: real; //cisnienie hamulca pp + + BrakeStatus: byte; //flaga stanu + SoundFlag: byte; + public + constructor Create(i_mbp, i_bcr, i_bcd, i_brc: real; + i_bcn, i_BD, i_mat, i_ba, i_nbpa: byte); + //maksymalne cisnienie, promien, skok roboczy, pojemnosc ZP; + //ilosc cylindrow, opoznienia hamulca, material klockow, osie hamowane, klocki na os; + + function GetFC(Vel, N: real): real; virtual; //wspolczynnik tarcia - hamulec wie lepiej + function GetPF(PP, dt, Vel: real): real; virtual; //przeplyw miedzy komora wstepna i PG + function GetBCF: real; //sila tlokowa z tloka + function GetHPFlow(HP, dt: real): real; virtual; //przeplyw - 8 bar + function GetBCP: real; virtual; //cisnienie cylindrow hamulcowych + function GetBRP: real; //cisnienie zbiornika pomocniczego + function GetVRP: real; //cisnienie komory wstepnej rozdzielacza + function GetCRP: real; virtual; //cisnienie zbiornika sterujacego + procedure Init(PP, HPP, LPP, BP: real; BDF: byte); virtual; //inicjalizacja hamulca + function SetBDF(nBDF: byte): boolean; //nastawiacz GPRM + procedure Releaser(state: byte); //odluzniacz + procedure SetEPS(nEPS:real); virtual;//hamulec EP + procedure ASB(state: byte); //hamulec przeciwposlizgowy + function GetStatus(): byte; //flaga statusu, moze sie przydac do odglosow + procedure SetASBP(press: real); //ustalenie cisnienia pp + procedure ForceEmptiness(); virtual; + function GetSoundFlag: byte; +// procedure + end; + + TWest= class(TBrake) + private + LBP: real; //cisnienie hamulca pomocniczego + dVP: real; //pobor powietrza wysokiego cisnienia + EPS: real; //stan elektropneumatyka + TareM, LoadM: real; //masa proznego i pelnego + TareBP: real; //cisnienie dla proznego + LoadC: real; //wspolczynnik przystawki wazacej + public + procedure SetLBP(P: real); //cisnienie z hamulca pomocniczego + function GetPF(PP, dt, Vel: real): real; override; //przeplyw miedzy komora wstepna i PG + procedure Init(PP, HPP, LPP, BP: real; BDF: byte); override; + function GetHPFlow(HP, dt: real): real; override; + procedure PLC(mass: real); //wspolczynnik cisnienia przystawki wazacej + procedure SetEPS(nEPS: real); override; //stan hamulca EP + procedure SetLP(TM, LM, TBP: real); //parametry przystawki wazacej + end; + + TESt= class(TBrake) + private + CntrlRes: TReservoir; //zbiornik sterujący + BVM: real; //przelozenie PG-CH + public + function GetPF(PP, dt, Vel: real): real; override; //przeplyw miedzy komora wstepna i PG + procedure EStParams(i_crc: real); //parametry charakterystyczne dla ESt + procedure Init(PP, HPP, LPP, BP: real; BDF: byte); override; + function GetCRP: real; override; + procedure CheckState(BCP: real; var dV1: real); //glowny przyrzad rozrzadczy + procedure CheckReleaser(dt: real); //odluzniacz + function CVs(bp: real): real; //napelniacz sterujacego + function BVs(BCP: real): real; //napelniacz pomocniczego + end; + + TESt3= class(TESt) + private + CylFlowSpeed: array[0..1] of array [0..1] of real; + public + function GetPF(PP, dt, Vel: real): real; override; //przeplyw miedzy komora wstepna i PG + end; + + TESt3AL2= class(TESt3) + private + TareM, LoadM: real; //masa proznego i pelnego + TareBP: real; //cisnienie dla proznego + LoadC: real; + public + ImplsRes: TReservoir; //komora impulsowa + function GetPF(PP, dt, Vel: real): real; override; //przeplyw miedzy komora wstepna i PG + procedure PLC(mass: real); //wspolczynnik cisnienia przystawki wazacej + procedure SetLP(TM, LM, TBP: real); //parametry przystawki wazacej + procedure Init(PP, HPP, LPP, BP: real; BDF: byte); override; + end; + + TESt4R= class(TESt) + private + RapidStatus: boolean; + RapidTemp: real; //akrualne, zmienne przelozenie + public + ImplsRes: TReservoir; //komora impulsowa + function GetPF(PP, dt, Vel: real): real; override; //przeplyw miedzy komora wstepna i PG + procedure Init(PP, HPP, LPP, BP: real; BDF: byte); override; + end; + + TLSt= class(TESt4R) + private + CylFlowSpeed: array[0..1] of array [0..1] of real; + LBP: real; //cisnienie hamulca pomocniczego + RM: real; //przelozenie rapida + EDFlag: real; //luzowanie hamulca z powodu zalaczonego ED + public + procedure SetLBP(P: real); //cisnienie z hamulca pomocniczego + procedure SetRM(RMR: real); //ustalenie przelozenia rapida + function GetPF(PP, dt, Vel: real): real; override; //przeplyw miedzy komora wstepna i PG + function GetHPFlow(HP, dt: real): real; override; //przeplyw - 8 bar + procedure Init(PP, HPP, LPP, BP: real; BDF: byte); override; + function GetEDBCP: real; virtual; //cisnienie tylko z hamulca zasadniczego, uzywane do hamulca ED w EP09 + procedure SetED(EDstate: real); //stan hamulca ED do luzowania + end; + + TEStED= class(TLSt) //zawor z EP09 - Est4 z oddzielnym przekladnikiem, kontrola rapidu i takie tam + private + Nozzles: array[0..10] of real; //dysze + Zamykajacy: boolean; //pamiec zaworka zamykajacego + Przys_blok: boolean; //blokada przyspieszacza + Miedzypoj: TReservoir; //pojemnosc posrednia (urojona) do napelniania ZP i ZS + public + procedure Init(PP, HPP, LPP, BP: real; BDF: byte); override; + function GetPF(PP, dt, Vel: real): real; override; //przeplyw miedzy komora wstepna i PG + function GetEDBCP: real; override; //cisnienie tylko z hamulca zasadniczego, uzywane do hamulca ED w EP09 + end; + + TEStEP2= class(TLSt) + private + TareM, LoadM: real; //masa proznego i pelnego + TareBP: real; //cisnienie dla proznego + LoadC: real; + EPS: real; + public + function GetPF(PP, dt, Vel: real): real; override; //przeplyw miedzy komora wstepna i PG + procedure Init(PP, HPP, LPP, BP: real; BDF: byte); override; //inicjalizacja + procedure PLC(mass: real); //wspolczynnik cisnienia przystawki wazacej + procedure SetEPS(nEPS: real); override; //stan hamulca EP + procedure SetLP(TM, LM, TBP: real); //parametry przystawki wazacej + end; + + TCV1= class(TBrake) + private + CntrlRes: TReservoir; //zbiornik sterujący + BVM: real; //przelozenie PG-CH + public + function GetPF(PP, dt, Vel: real): real; override; //przeplyw miedzy komora wstepna i PG + procedure Init(PP, HPP, LPP, BP: real; BDF: byte); override; + function GetCRP: real; override; + procedure CheckState(BCP: real; var dV1: real); + function CVs(bp: real): real; + function BVs(BCP: real): real; + public + end; + + TCV1R= class(TCV1) + private + ImplsRes: TReservoir; //komora impulsowa + RapidStatus: boolean; + public +// function GetPF(PP, dt, Vel: real): real; override; //przeplyw miedzy komora wstepna i PG +// procedure Init(PP, HPP, LPP, BP: real; BDF: byte); override; + end; + + TCV1L_TR= class(TCV1) + private + ImplsRes: TReservoir; //komora impulsowa + LBP: real; //cisnienie hamulca pomocniczego + public + function GetPF(PP, dt, Vel: real): real; override; //przeplyw miedzy komora wstepna i PG + procedure Init(PP, HPP, LPP, BP: real; BDF: byte); override; + procedure SetLBP(P: real); //cisnienie z hamulca pomocniczego + function GetHPFlow(HP, dt: real): real; override; //przeplyw - 8 bar + end; + + TKE= class(TBrake) //Knorr Einheitsbauart — jeden do wszystkiego + private + RapidStatus: boolean; + ImplsRes: TReservoir; //komora impulsowa + CntrlRes: TReservoir; //zbiornik sterujący + Brak2Res: TReservoir; //zbiornik pomocniczy 2 + BVM: real; //przelozenie PG-CH + TareM, LoadM: real; //masa proznego i pelnego + TareBP: real; //cisnienie dla proznego + LoadC: real; //wspolczynnik zaladowania + RM: real; //przelozenie rapida + LBP: real; //cisnienie hamulca pomocniczego + public + procedure SetRM(RMR: real); //ustalenie przelozenia rapida + function GetPF(PP, dt, Vel: real): real; override; //przeplyw miedzy komora wstepna i PG + procedure Init(PP, HPP, LPP, BP: real; BDF: byte); override; + function GetHPFlow(HP, dt: real): real; override; //przeplyw - 8 bar + function GetCRP: real; override; + procedure CheckState(BCP: real; var dV1: real); + procedure CheckReleaser(dt: real); //odluzniacz + function CVs(bp: real): real; //napelniacz sterujacego + function BVs(BCP: real): real; //napelniacz pomocniczego + procedure PLC(mass: real); //wspolczynnik cisnienia przystawki wazacej + procedure SetLP(TM, LM, TBP: real); //parametry przystawki wazacej + procedure SetLBP(P: real); //cisnienie z hamulca pomocniczego + end; + + + + + //klasa obejmujaca krany + THandle= class + private +// BCP: integer; + public + Time: boolean; + TimeEP: boolean; + Sounds: array[0..4] of real; //wielkosci przeplywow dla dzwiekow + function GetPF(i_bcp:real; pp, hp, dt, ep: real): real; virtual; + procedure Init(press: real); virtual; + function GetCP(): real; virtual; + procedure SetReductor(nAdj: real); virtual; + function GetSound(i: byte): real; virtual; + function GetPos(i: byte): real; virtual; + end; + + TFV4a= class(THandle) + private + CP, TP, RP: real; //zbiornik sterujący, czasowy, redukcyjny + public + function GetPF(i_bcp:real; pp, hp, dt, ep: real): real; override; + procedure Init(press: real); override; + end; + + TFV4aM= class(THandle) + private + CP, TP, RP: real; //zbiornik sterujący, czasowy, redukcyjny + XP: real; //komora powietrzna w reduktorze — jest potrzebna do odwzorowania fali + RedAdj: real; //dostosowanie reduktora cisnienia (krecenie kapturkiem) +// Sounds: array[0..4] of real; //wielkosci przeplywow dla dzwiekow + Fala: boolean; + public + function GetPF(i_bcp:real; pp, hp, dt, ep: real): real; override; + procedure Init(press: real); override; + procedure SetReductor(nAdj: real); override; + function GetSound(i: byte): real; override; + function GetPos(i: byte): real; override; + end; + +{ FBS2= class(THandle) + private + CP, TP, RP: real; //zbiornik sterujący, czasowy, redukcyjny + XP: real; //komora powietrzna w reduktorze — jest potrzebna do odwzorowania fali + RedAdj: real; //dostosowanie reduktora cisnienia (krecenie kapturkiem) +// Sounds: array[0..4] of real; //wielkosci przeplywow dla dzwiekow + Fala: boolean; + public + function GetPF(i_bcp:real; pp, hp, dt, ep: real): real; override; + procedure Init(press: real); override; + procedure SetReductor(nAdj: real); override; + function GetSound(i: byte): real; override; + function GetPos(i: byte): real; override; + end; } + +{ TD2= class(THandle) + private + CP, TP, RP: real; //zbiornik sterujący, czasowy, redukcyjny + XP: real; //komora powietrzna w reduktorze — jest potrzebna do odwzorowania fali + RedAdj: real; //dostosowanie reduktora cisnienia (krecenie kapturkiem) +// Sounds: array[0..4] of real; //wielkosci przeplywow dla dzwiekow + Fala: boolean; + public + function GetPF(i_bcp:real; pp, hp, dt, ep: real): real; override; + procedure Init(press: real); override; + procedure SetReductor(nAdj: real); override; + function GetSound(i: byte): real; override; + function GetPos(i: byte): real; override; + end;} + + TM394= class(THandle) + private + CP: real; //zbiornik sterujący, czasowy, redukcyjny + RedAdj: real; //dostosowanie reduktora cisnienia (krecenie kapturkiem) + public + function GetPF(i_bcp:real; pp, hp, dt, ep: real): real; override; + procedure Init(press: real); override; + procedure SetReductor(nAdj: real); override; + function GetCP: real; override; + function GetPos(i: byte): real; override; + end; + + TH14K1= class(THandle) + private + CP: real; //zbiornik sterujący, czasowy, redukcyjny + RedAdj: real; //dostosowanie reduktora cisnienia (krecenie kapturkiem) + public + function GetPF(i_bcp:real; pp, hp, dt, ep: real): real; override; + procedure Init(press: real); override; + procedure SetReductor(nAdj: real); override; + function GetCP: real; override; + function GetPos(i: byte): real; override; + end; + + TSt113= class(TH14K1) + private + EPS: real; + public + function GetPF(i_bcp:real; pp, hp, dt, ep: real): real; override; + function GetCP: real; override; + function GetPos(i: byte): real; override; + procedure Init(press: real); override; + end; + + Ttest= class(THandle) + private + CP: real; + public + function GetPF(i_bcp:real; pp, hp, dt, ep: real): real; override; + procedure Init(press: real); override; + end; + + TFD1= class(THandle) + private + MaxBP: real; //najwyzsze cisnienie + BP: real; //aktualne cisnienie + public + function GetPF(i_bcp:real; pp, hp, dt, ep: real): real; override; + procedure Init(press: real); override; + function GetCP(): real; override; +// procedure Init(press: real; MaxBP: real); overload; + end; + + TH1405= class(THandle) + private + MaxBP: real; //najwyzsze cisnienie + BP: real; //aktualne cisnienie + public + function GetPF(i_bcp:real; pp, hp, dt, ep: real): real; override; + procedure Init(press: real); override; + function GetCP(): real; override; +// procedure Init(press: real; MaxBP: real); overload; + end; + + + TFVel6= class(THandle) + private + EPS: real; + public + function GetPF(i_bcp:real; pp, hp, dt, ep: real): real; override; + function GetCP(): real; override; + function GetPos(i: byte): real; override; + function GetSound(i: byte): real; override; + procedure Init(press: real); override; + end; + +function PF(P1,P2,S:real;DP:real = 0.25):real; +function PF1(P1,P2,S:real):real; + +function PFVa(PH,PL,S,LIM:real;DP:real = 0.1):real; //zawor napelniajacy z PH do PL, PL do LIM +function PFVd(PH,PL,S,LIM:real;DP:real = 0.1):real; //zawor wypuszczajacy z PH do PL, PH do LIM + +implementation + +uses _mover; +//---FUNKCJE OGOLNE--- + +const DPL=0.25; + +function PR(p1,p2:real):real; +var ph,pl: real; +begin + ph:=Max0R(p1,p2)+0.1; + pl:=p1+p2-ph+0.2; + PR:=(p2-p1)/(1.13*ph-pl); +end; + +function PF_old(P1,P2,S:real):real; +var ph,pl: real; +begin + PH:=Max0R(P1,P2)+1; + PL:=P1+P2-PH+2; + if PH-PL<0.0001 then PF_old:=0 else + if (PH-PL)<0.05 then + PF_old:=20*(PH-PL)*(PH+1)*222*S*(P2-P1)/(1.13*ph-pl) + else + PF_old:=(PH+1)*222*S*(P2-P1)/(1.13*ph-pl); +end; + +function PF(P1,P2,S:real;DP:real = 0.25):real; +var ph,pl,sg,fm: real; +begin + PH:=Max0R(P1,P2)+1; //wyzsze cisnienie absolutne + PL:=P1+P2-PH+2; //nizsze cisnienie absolutne + sg:=PL/PH; //bezwymiarowy stosunek cisnien + fm:=PH*197*S*sign(P2-P1); //najwyzszy mozliwy przeplyw, wraz z kierunkiem + if (SG>0.5) then //jesli ponizej stosunku krytycznego + if (PH-PL)0.5) then //jesli ponizej stosunku krytycznego + if (SGPL then + begin + LIM:=LIM+1; + PH:=PH+1; //wyzsze cisnienie absolutne + PL:=PL+1; //nizsze cisnienie absolutne + sg:=PL/PH; //bezwymiarowy stosunek cisnien + fm:=PH*197*S; //najwyzszy mozliwy przeplyw, wraz z kierunkiem + if (LIM-PL)0.5) then //jesli ponizej stosunku krytycznego + if (PH-PL)0.5) then //jesli ponizej stosunku krytycznego + if (PH-PL)0.88 then P:=0.5+(VtoC-0.88)*1.043-0.064*(VtoC-0.88)*(VtoC-0.88) + else P:=0.15+0.35/0.82*(VtoC-0.06); +end; *) + +//(* STARA WERSJA +function TBrakeCyl.P:real; +var VtoC: real; //stosunek cisnienia do objetosci +const + VS = 0.005; + pS = 0.05; + VD = 1.40; + cD = 1; + pD = VD-cD; +begin + VtoC:=Vol/Cap; +// P:=VtoC; + if VtoCVD then P:=VtoC-cD //caly silownik + else P:=pS+(VtoC-VS)/(VD-VS)*(pD-pS); //wysuwanie tloka +end; //*) + + +//---HAMULEC--- +(* +constructor TBrake.Create(i_mbp, i_bcr, i_bcd, i_brc: real; i_bcn, i_BD, i_mat, i_ba, i_nbpa: byte); +begin + inherited Create; + MaxBP:=i_mbp; + BCN:=i_bcn; + BCA:=i_bcn*i_bcr*i_bcr*pi; + BA:=i_ba; + NBpA:=i_nbpa; + BrakeDelays:=i_BD; + +//tworzenie zbiornikow + BrakeCyl.CreateCap(i_bcd*BCA*1000); + BrakeRes.CreateCap(i_brc); + ValveRes.CreateCap(0.2); + +// FM.Free; +//materialy cierne + case i_mat of + bp_P10Bg: FM:=TP10Bg.Create; + bp_P10Bgu: FM:=TP10Bgu.Create; + else //domyslnie + FM:=TP10.Create; + end; + + +end ; *) + +constructor TBrake.Create(i_mbp, i_bcr, i_bcd, i_brc: real; i_bcn, i_BD, i_mat, i_ba, i_nbpa: byte); +begin + inherited Create; + MaxBP:=i_mbp; + BCN:=i_bcn; + BCA:=i_bcn*i_bcr*i_bcr*pi; + BA:=i_ba; + NBpA:=i_nbpa; + BrakeDelays:=i_BD; + //210.88 +// SizeBR:=i_bcn*i_bcr*i_bcr*i_bcd*40.17*MaxBP/(5-MaxBP); //objetosc ZP w stosunku do cylindra 14" i cisnienia 4.2 atm + SizeBR:=i_brc*0.0128; + SizeBC:=i_bcn*i_bcr*i_bcr*i_bcd*210.88*MaxBP/4.2; //objetosc CH w stosunku do cylindra 14" i cisnienia 4.2 atm + +// BrakeCyl:=TReservoir.Create; + BrakeCyl:=TBrakeCyl.Create; + BrakeRes:=TReservoir.Create; + ValveRes:=TReservoir.Create; + +//tworzenie zbiornikow + BrakeCyl.CreateCap(i_bcd*BCA*1000); + BrakeRes.CreateCap(i_brc); + ValveRes.CreateCap(0.25); + +// FM.Free; +//materialy cierne + i_mat:=i_mat and (255-bp_MHS); + case i_mat of + bp_P10Bg: FM:=TP10Bg.Create; + bp_P10Bgu: FM:=TP10Bgu.Create; + bp_FR513: FM:=TFR513.Create; + bp_Cosid: FM:=TCosid.Create; + bp_P10yBg: FM:=TP10yBg.Create; + bp_P10yBgu: FM:=TP10yBgu.Create; + bp_D1: FM:=TDisk1.Create; + bp_D2: FM:=TDisk2.Create; + else //domyslnie + FM:=TP10.Create; + end; +end; + +//inicjalizacja hamulca (stan poczatkowy) +procedure TBrake.Init(PP, HPP, LPP, BP: real; BDF: byte); +begin + +end; + +//pobranie wspolczynnika tarcia materialu +function TBrake.GetFC(Vel, N: real): real; +begin + GetFC:=FM.GetFC(N, Vel); +end; + +//cisnienie cylindra hamulcowego +function TBrake.GetBCP: real; +begin + GetBCP:=BrakeCyl.P; +end; + +//cisnienie zbiornika pomocniczego +function TBrake.GetBRP: real; +begin + GetBRP:=BrakeRes.P; +end; + +//cisnienie komory wstepnej +function TBrake.GetVRP: real; +begin + GetVRP:=ValveRes.P; +end; + +//cisnienie zbiornika sterujacego +function TBrake.GetCRP: real; +begin + GetCRP:=0; +end; + +//przeplyw z przewodu glowneg +function TBrake.GetPF(PP, dt, Vel: real): real; +begin + ValveRes.Act; + BrakeCyl.Act; + BrakeRes.Act; + GetPF:=0; +end; + +//przeplyw z przewodu zasilajacego +function TBrake.GetHPFlow(HP, dt: real): real; +begin + GetHPFlow:=0; +end; + +function TBrake.GetBCF: real; +begin + GetBCF:=BCA*100*BrakeCyl.P; +end; + +function TBrake.SetBDF(nBDF: byte): boolean; +begin + if ((nBDF and BrakeDelays)=nBDF)and(nBDF<>BrakeDelayFlag) then + begin + BrakeDelayFlag:=nBDF; + SetBDF:=true; + end + else + SetBDF:=false; +end; + +procedure TBrake.Releaser(state: byte); +begin + BrakeStatus:=(BrakeStatus and 247) or state*b_rls; +end; + +procedure TBrake.SetEPS(nEPS: real); +begin + +end; + +procedure TBrake.ASB(state: byte); +begin //255-b_asb(32) + BrakeStatus:=(BrakeStatus and 223) or state*b_asb; +end; + +function TBrake.GetStatus(): byte; +begin + GetStatus:=BrakeStatus; +end; + +function TBrake.GetSoundFlag: byte; +begin + GetSoundFlag:=SoundFlag; + SoundFlag:=0; +end; + +procedure TBrake.SetASBP(press: real); +begin + ASBP:=press; +end; + +procedure TBrake.ForceEmptiness(); +begin + ValveRes.CreatePress(0); + BrakeRes.CreatePress(0); + ValveRes.Act(); + BrakeRes.Act(); +end; + + +//---WESTINGHOUSE--- + +procedure TWest.Init(PP, HPP, LPP, BP: real; BDF: byte); +begin + ValveRes.CreatePress(PP); + BrakeCyl.CreatePress(BP); + BrakeRes.CreatePress(PP/2+HPP/2); +// BrakeStatus:=3*Byte(BP>0.1); +end; + +function TWest.GetPF(PP, dt, Vel: real): real; +var dv, dv1:real; + VVP, BVP, CVP, BCP: real; + temp: real; +begin + + BVP:=BrakeRes.P; + VVP:=ValveRes.P; + CVP:=BrakeCyl.P; + BCP:=BrakeCyl.P; + + if (BrakeStatus and 1)=1 then + if(VVP+0.03BVP+0.1) then + BrakeStatus:=(BrakeStatus and 252) + else if(VVP>BVP) then + BrakeStatus:=(BrakeStatus and 253) + else + else + if(VVP+0.25LBP+0.01) and (DCV) then + dV:=PF(0,CVP,0.1*sizeBC)*dt + else dV:=0; + BrakeCyl.Flow(-dV); + +//hamulec EP + temp:=BVP*Byte(EPS>0); + dV:=PF(temp,LBP,0.0015)*dt*EPS*EPS*Byte(LBP*EPS silowniki + if((BrakeStatus and b_on)=b_on)and((TareBP<0.1)or(BCPLBP)then + begin + DCV:=false; + dV:=PF(BVP,CVP,0.017*sizeBC)*dt; + end + else dV:=0 + else dV:=0; + BrakeRes.Flow(dV); + BrakeCyl.Flow(-dV); + if(DCV)then + dVP:=PF(LBP,BCP,0.01*sizeBC)*dt + else dVP:=0; + BrakeCyl.Flow(-dVP); + if(dVP>0)then dVP:=0; +//przeplyw ZP <-> rozdzielacz + if((BrakeStatus and b_hld)=b_off)then + dV:=PF(BVP,VVP,0.0011*sizeBR)*dt + else dV:=0; + BrakeRes.Flow(dV); + dV1:=dV*0.95; + ValveRes.Flow(-0.05*dV); +//przeplyw PG <-> rozdzielacz + dV:=PF(PP,VVP,0.01*sizeBR)*dt; + ValveRes.Flow(-dV); + + ValveRes.Act; + BrakeCyl.Act; + BrakeRes.Act; + GetPF:=dV-dV1; +end; + +function TWest.GetHPFlow(HP, dt: real): real; +begin + GetHPFlow:=dVP; +end; + +procedure TWest.SetLBP(P: real); +begin + LBP:=P; + if P>BrakeCyl.P then +// begin + DCV:=true; +// end +// else +// LBP:=P; +end; + +procedure TWest.SetEPS(nEPS: real); +var + BCP: real; +begin + BCP:=BrakeCyl.P; + if nEPS>0 then + DCV:=true + else if nEPS=0 then + begin + if(EPS<>0)then + begin + if(LBP>0.4)then + LBP:=BrakeCyl.P; + if(LBP<0.15)then + LBP:=0; + end; + end; + EPS:=nEPS; +end; + +procedure TWest.PLC(mass: real); +begin + LoadC:=1+Byte(Mass0.25)then + if(VVP+0.003+BCP/BVMCVP) then + BrakeStatus:=(BrakeStatus and 252) //luzowanie + else if(VVP+BCP/BVM>CVP) then + BrakeStatus:=(BrakeStatus and 253) //zatrzymanie napelaniania + else + else + if(VVP+0.100.25)and(BCP>0.25)then //zatrzymanie luzowanie + BrakeStatus:=(BrakeStatus or 1); + + if (BrakeStatus and 1)=0 then + SoundFlag:=SoundFlag or sf_CylU; +end; + +function TESt.CVs(bp: real): real; +var VVP, BVP, CVP: real; +begin + BVP:=BrakeRes.P; + CVP:=CntrlRes.P; + VVP:=ValveRes.P; + +//przeplyw ZS <-> PG + if(VVP0.4)then + CVs:=0 + else + if(VVP>CVP+0.4)then + if(BVP>CVP+0.2)then + CVs:=0.23 + else + CVs:=0.05 + else + if(BVP>CVP-0.1)then + CVs:=1 + else + CVs:=0.3; +end; + +function TESt.BVs(BCP: real): real; +var VVP, BVP, CVP: real; +begin + BVP:=BrakeRes.P; + CVP:=CntrlRes.P; + VVP:=ValveRes.P; + +//przeplyw ZP <-> rozdzielacz + if(BVPCVP+0.4)then + BVs:=0.1 + else + BVs:=0.3 + else + BVs:=0; +end; + + + + + +function TESt.GetPF(PP, dt, Vel: real): real; +var dv, dv1, temp:real; + VVP, BVP, BCP, CVP: real; +begin + BVP:=BrakeRes.P; + VVP:=ValveRes.P; + BCP:=BrakeCyl.P; + CVP:=CntrlRes.P-0.0; + + dV:=0; dV1:=0; + +//sprawdzanie stanu + CheckState(BCP, dV1); + CheckReleaser(dt); + + CVP:=CntrlRes.P; + VVP:=ValveRes.P; +//przeplyw ZS <-> PG + temp:=CVs(BCP); + dV:=PF(CVP,VVP,0.0015*temp)*dt; + CntrlRes.Flow(+dV); + ValveRes.Flow(-0.04*dV); + dV1:=dV1-0.96*dV; + + +//luzowanie + if(BrakeStatus and b_hld)=b_off then + dV:=PF(0,BCP,0.0058*sizeBC)*dt + else dV:=0; + BrakeCyl.Flow(-dV); + +//przeplyw ZP <-> silowniki + if(BrakeStatus and b_on)=b_on then + dV:=PF(BVP,BCP,0.016*sizeBC)*dt + else dV:=0; + BrakeRes.Flow(dV); + BrakeCyl.Flow(-dV); + +//przeplyw ZP <-> rozdzielacz + temp:=BVs(BCP); +// if(BrakeStatus and b_hld)=b_off then + if(VVP-0.05>BVP)then + dV:=PF(BVP,VVP,0.02*sizeBR*temp/1.87)*dt + else dV:=0; + BrakeRes.Flow(dV); + dV1:=dV1+dV*0.96; + ValveRes.Flow(-0.04*dV); +//przeplyw PG <-> rozdzielacz + dV:=PF(PP,VVP,0.01)*dt; + ValveRes.Flow(-dV); + + ValveRes.Act; + BrakeCyl.Act; + BrakeRes.Act; + CntrlRes.Act; + GetPF:=dV-dV1; +end; + +procedure TESt.Init(PP, HPP, LPP, BP: real; BDF: byte); +begin + ValveRes.CreatePress(PP); + BrakeCyl.CreatePress(BP); + BrakeRes.CreatePress(PP); + CntrlRes:=TReservoir.Create; + CntrlRes.CreateCap(15); + CntrlRes.CreatePress(HPP); + BrakeStatus:=0; + + BVM:=1/(HPP-LPP)*MaxBP; + + BrakeDelayFlag:=BDF; +end; + + +procedure TESt.EStParams(i_crc: real); +begin + +end; + + +function TESt.GetCRP: real; +begin + GetCRP:=CntrlRes.P; +end; + +//---EP2--- + +procedure TEStEP2.Init(PP, HPP, LPP, BP: real; BDF: byte); +begin + inherited; + ImplsRes.CreateCap(1); + ImplsRes.CreatePress(BP); + + BrakeRes.CreatePress(PP); + + BrakeDelayFlag:=bdelay_P; + BrakeDelays:=bdelay_P; +end; + + +function TEStEP2.GetPF(PP, dt, Vel: real): real; +var dv, dv1, temp:real; + VVP, BVP, BCP, CVP: real; +begin + BVP:=BrakeRes.P; + VVP:=ValveRes.P; + BCP:=ImplsRes.P; + CVP:=CntrlRes.P; //110115 - konsultacje warszawa1 + + dV:=0; dV1:=0; + +//odluzniacz + CheckReleaser(dt); + +//sprawdzanie stanu + if ((BrakeStatus and 1)=1)and(BCP>0.25) then + if(VVP+0.003+BCP/BVMCVP-0.12) then + BrakeStatus:=(BrakeStatus and 252) //luzowanie + else if(VVP+BCP/BVM>CVP-0.12) then + BrakeStatus:=(BrakeStatus and 253) //zatrzymanie napelaniania + else + else + if(VVP+0.100.25) then //zatrzymanie luzowanie + BrakeStatus:=(BrakeStatus or 1); + +//przeplyw ZS <-> PG + if(BVP0)or(BCP>0.25)then + temp:=0 + else + if(VVP>CVP+0.4)then + temp:=0.1 + else + temp:=0.5; + + dV:=PF(CVP,VVP,0.0015*temp/1.8)*dt; + CntrlRes.Flow(+dV); + ValveRes.Flow(-0.04*dV); + dV1:=dV1-0.96*dV; + +//hamulec EP + temp:=BVP*Byte(EPS>0); + dV:=PF(temp,LBP,0.00053+0.00060*Byte(EPS<0))*dt*EPS*EPS*Byte(LBP*EPS KI + if ((BrakeStatus and b_on)=b_on) and (BCP rozdzielacz + dV:=PF(PP,VVP,0.01*sizeBR)*dt; + ValveRes.Flow(-dV); + + GetPF:=dV-dV1; + + temp:=Max0R(BCP,LBP); + + if(ImplsRes.P>LBP+0.01)then + LBP:=0; + +//luzowanie CH + if(BrakeCyl.P>temp+0.005)or(Max0R(ImplsRes.P,8*LBP)<0.05) then + dV:=PF(0,BrakeCyl.P,0.25*sizeBC*(0.01+(BrakeCyl.P-temp)))*dt + else dV:=0; + BrakeCyl.Flow(-dV); +//przeplyw ZP <-> CH + if(BrakeCyl.P0.10)and(Max0R(BCP,LBP)0) and (LBP+0.01 PG + temp:=CVs(BCP); + dV:=PF(CVP,VVP,0.0015*temp)*dt; + CntrlRes.Flow(+dV); + ValveRes.Flow(-0.04*dV); + dV1:=dV1-0.96*dV; + + +//luzowanie + if(BrakeStatus and b_hld)=b_off then + dV:=PF(0,BCP,0.0042*(1.37-Byte(BrakeDelayFlag=bdelay_G))*sizeBC)*dt + else dV:=0; + BrakeCyl.Flow(-dV); +//przeplyw ZP <-> silowniki + if(BrakeStatus and b_on)=b_on then + dV:=PF(BVP,BCP,0.017*(1+Byte((BCP<0.58)and(BrakeDelayFlag=bdelay_G)))*(1.13-Byte((BCP>0.6)and(BrakeDelayFlag=bdelay_G)))*sizeBC)*dt + else dV:=0; + BrakeRes.Flow(dV); + BrakeCyl.Flow(-dV); +//przeplyw ZP <-> rozdzielacz + temp:=BVs(BCP); + if(VVP-0.05>BVP)then + dV:=PF(BVP,VVP,0.02*sizeBR*temp/1.87)*dt + else dV:=0; + BrakeRes.Flow(dV); + dV1:=dV1+dV*0.96; + ValveRes.Flow(-0.04*dV); +//przeplyw PG <-> rozdzielacz + dV:=PF(PP,VVP,0.01)*dt; + ValveRes.Flow(-dV); + + ValveRes.Act; + BrakeCyl.Act; + BrakeRes.Act; + CntrlRes.Act; + GetPF:=dV-dV1; +end; + +//---EST4-RAPID--- + +function TESt4R.GetPF(PP, dt, Vel: real): real; +var dv, dv1, temp:real; + VVP, BVP, BCP, CVP: real; +begin + BVP:=BrakeRes.P; + VVP:=ValveRes.P; + BCP:=ImplsRes.P; + CVP:=CntrlRes.P-0.0; + + dV:=0; dV1:=0; + +//sprawdzanie stanu + CheckState(BCP, dV1); + CheckReleaser(dt); + + CVP:=CntrlRes.P; + VVP:=ValveRes.P; +//przeplyw ZS <-> PG + temp:=CVs(BCP); + dV:=PF(CVP,VVP,0.0015*temp/1.8)*dt; + CntrlRes.Flow(+dV); + ValveRes.Flow(-0.04*dV); + dV1:=dV1-0.96*dV; + + +//luzowanie KI + if(BrakeStatus and b_hld)=b_off then + dV:=PF(0,BCP,0.00037*1.14*15/19)*dt + else dV:=0; + ImplsRes.Flow(-dV); +//przeplyw ZP <-> KI + if(BrakeStatus and b_on)=b_on then + dV:=PF(BVP,BCP,0.0014)*dt + else dV:=0; +// BrakeRes.Flow(dV); + ImplsRes.Flow(-dV); +//przeplyw ZP <-> rozdzielacz + temp:=BVs(BCP); + if(BVP rozdzielacz + dV:=PF(PP,VVP,0.01*sizeBR)*dt; + ValveRes.Flow(-dV); + + GetPF:=dV-dV1; + + + + RapidStatus:=(BrakeDelayFlag=bdelay_R)and(((Vel>55)and(RapidStatus))or(Vel>70)); + + RapidTemp:=RapidTemp+(0.9*Byte(RapidStatus)-RapidTemp)*dt/2; + temp:=1.9-RapidTemp; + if((BrakeStatus and b_asb)=b_asb)then + temp:=1000; +//luzowanie CH + if(BrakeCyl.P*temp>ImplsRes.P+0.005)or(ImplsRes.P<0.25) then + if((BrakeStatus and b_asb)=b_asb)then + dV:=PFVd(BrakeCyl.P,0,0.115*sizeBC*4,ImplsRes.P/temp)*dt + else + dV:=PFVd(BrakeCyl.P,0,0.115*sizeBC,ImplsRes.P/temp)*dt +// dV:=PF(0,BrakeCyl.P,0.115*sizeBC/2)*dt +// dV:=PFVd(BrakeCyl.P,0,0.015*sizeBC/2,ImplsRes.P/temp)*dt + else dV:=0; + BrakeCyl.Flow(-dV); +//przeplyw ZP <-> CH + if(BrakeCyl.P*temp0.3) then +// dV:=PFVa(BVP,BrakeCyl.P,0.020*sizeBC,ImplsRes.P/temp)*dt + dV:=PFVa(BVP,BrakeCyl.P,0.60*sizeBC,ImplsRes.P/temp)*dt + else dV:=0; + BrakeRes.Flow(-dV); + BrakeCyl.Flow(+dV); + + ImplsRes.Act; + ValveRes.Act; + BrakeCyl.Act; + BrakeRes.Act; + CntrlRes.Act; +end; + +procedure TESt4R.Init(PP, HPP, LPP, BP: real; BDF: byte); +begin + inherited; + ImplsRes:=TReservoir.Create; + ImplsRes.CreateCap(1); + ImplsRes.CreatePress(BP); + + BrakeDelayFlag:=bdelay_R; +end; + + +//---EST3/AL2--- + +function TESt3AL2.GetPF(PP, dt, Vel: real): real; +var dv, dv1, temp:real; + VVP, BVP, BCP, CVP: real; +begin + BVP:=BrakeRes.P; + VVP:=ValveRes.P; + BCP:=ImplsRes.P; + CVP:=CntrlRes.P-0.0; + + dV:=0; dV1:=0; + +//sprawdzanie stanu + CheckState(BCP, dV1); + CheckReleaser(dt); + + VVP:=ValveRes.P; +//przeplyw ZS <-> PG + temp:=CVs(BCP); + dV:=PF(CVP,VVP,0.0015*temp)*dt; + CntrlRes.Flow(+dV); + ValveRes.Flow(-0.04*dV); + dV1:=dV1-0.96*dV; + +//luzowanie KI + if(BrakeStatus and b_hld)=b_off then + dV:=PF(0,BCP,0.00017*(1.37-Byte(BrakeDelayFlag=bdelay_G)))*dt + else dV:=0; + ImplsRes.Flow(-dV); +//przeplyw ZP <-> KI + if ((BrakeStatus and b_on)=b_on) and (BCP0.6)and(BrakeDelayFlag=bdelay_G))))*dt + else dV:=0; + BrakeRes.Flow(dV); + ImplsRes.Flow(-dV); +//przeplyw ZP <-> rozdzielacz + temp:=BVs(BCP); + if(VVP-0.05>BVP)then + dV:=PF(BVP,VVP,0.02*sizeBR*temp/1.87)*dt + else dV:=0; + BrakeRes.Flow(dV); + dV1:=dV1+dV*0.96; + ValveRes.Flow(-0.04*dV); +//przeplyw PG <-> rozdzielacz + dV:=PF(PP,VVP,0.01)*dt; + ValveRes.Flow(-dV); + GetPF:=dV-dV1; + +//luzowanie CH + if(BrakeCyl.P>ImplsRes.P*LoadC+0.005)or(ImplsRes.P<0.15) then + dV:=PF(0,BrakeCyl.P,0.015*sizeBC)*dt + else dV:=0; + BrakeCyl.Flow(-dV); + +//przeplyw ZP <-> CH + if(BrakeCyl.P0.15) then + dV:=PF(BVP,BrakeCyl.P,0.020*sizeBC)*dt + else dV:=0; + BrakeRes.Flow(dV); + BrakeCyl.Flow(-dV); + + ImplsRes.Act; + ValveRes.Act; + BrakeCyl.Act; + BrakeRes.Act; + CntrlRes.Act; +end; + +procedure TESt3AL2.PLC(mass: real); +begin + LoadC:=1+Byte(Mass PG + if((CVP-BCP)*BVM>0.5)then + temp:=0 + else + if(VVP>CVP+0.4)then + temp:=0.5 + else + temp:=0.5; + + dV:=PF1(CVP,VVP,0.0015*temp/1.8/2)*dt; + CntrlRes.Flow(+dV); + ValveRes.Flow(-0.04*dV); + dV1:=dV1-0.96*dV; + + +//luzowanie KI {G} +// if VVP>BCP then +// dV:=PF(VVP,BCP,0.00004)*dt +// else if (CVP-BCP)<1.5 then +// dV:=PF(VVP,BCP,0.00020*(1.33-Byte((CVP-BCP)*BVM>0.65)))*dt +// else dV:=0; 0.00025 P + {P} + if VVP>BCP then + dV:=PF(VVP,BCP,0.00043*(1.5-Byte(((CVP-BCP)*BVM>1)and(BrakeDelayFlag=bdelay_G))),0.1)*dt + else if (CVP-BCP)<1.5 then + dV:=PF(VVP,BCP,0.001472*(1.36-Byte(((CVP-BCP)*BVM>1)and(BrakeDelayFlag=bdelay_G))),0.1)*dt + else dV:=0; + + ImplsRes.Flow(-dV); + ValveRes.Flow(+dV); +//przeplyw PG <-> rozdzielacz + dV:=PF(PP,VVP,0.01,0.1)*dt; + ValveRes.Flow(-dV); + + GetPF:=dV-dV1; + +// if Vel>55 then temp:=0.72 else +// temp:=1;{R} +//cisnienie PP + RapidTemp:=RapidTemp+(RM*Byte((Vel>55)and(BrakeDelayFlag=bdelay_R))-RapidTemp)*dt/2; + temp:=1-RapidTemp; + if EDFlag>0.2 then temp:=10000; + +//powtarzacz — podwojny zawor zwrotny + temp:=Max0R(((CVP-BCP)*BVM+ASBP*Byte((BrakeStatus and b_asb)=b_asb))/temp,LBP); +//luzowanie CH + if(BrakeCyl.P>temp+0.005)or(temp<0.28) then +// dV:=PF(0,BrakeCyl.P,0.0015*3*sizeBC)*dt +// dV:=PF(0,BrakeCyl.P,0.005*3*sizeBC)*dt + dV:=PFVd(BrakeCyl.P,0,0.005*7*sizeBC,temp)*dt + else dV:=0; + BrakeCyl.Flow(-dV); +//przeplyw ZP <-> CH + if(BrakeCyl.P0.29) then +// dV:=PF(BVP,BrakeCyl.P,0.002*3*sizeBC*2)*dt + dV:=-PFVa(BVP,BrakeCyl.P,0.002*7*sizeBC*2,temp)*dt + else dV:=0; + BrakeRes.Flow(dV); + BrakeCyl.Flow(-dV); + + ImplsRes.Act; + ValveRes.Act; + BrakeCyl.Act; + BrakeRes.Act; + CntrlRes.Act; +// LBP:=ValveRes.P; +// ValveRes.CreatePress(ImplsRes.P); +end; + +procedure TLSt.Init(PP, HPP, LPP, BP: real; BDF: byte); +begin + inherited; + ValveRes.CreateCap(1); + ImplsRes.CreateCap(8); + ImplsRes.CreatePress(PP); + BrakeRes.CreatePress(8); + ValveRes.CreatePress(PP); + + EDFlag:=0; + + BrakeDelayFlag:=BDF; +end; + +procedure TLSt.SetLBP(P: real); +begin + LBP:=P; +end; + +function TLSt.GetEDBCP: real; +var CVP, BCP: real; +begin + CVP:=CntrlRes.P; + BCP:=ImplsRes.P; + GetEDBCP:=(CVP-BCP)*BVM; +end; + +procedure TLSt.SetED(EDstate: real); +begin + EDFlag:=EDstate; +end; + +procedure TLSt.SetRM(RMR: real); +begin + RM:=1-RMR; +end; + +function TLSt.GetHPFlow(HP, dt: real): real; +var dV: real; +begin + dV:=Min0R(PF(HP,BrakeRes.P,0.01*dt),0); + BrakeRes.Flow(-dV); + GetHPFlow:=dV; +end; + +//---EStED--- + +function TEStED.GetPF(PP, dt, Vel: real): real; +var dv, dv1, temp:real; + VVP, BVP, BCP, CVP, MPP, nastG: real; + i: byte; +begin + BVP:=BrakeRes.P; + VVP:=ValveRes.P; + BCP:=ImplsRes.P; + CVP:=CntrlRes.P-0.0; + MPP:=Miedzypoj.P; + dV1:=0; + + nastG:=(BrakeDelayFlag and bdelay_G); + +//sprawdzanie stanu + if(BCP<0.25)and(VVP+0.08>CVP)then Przys_blok:=false; + +//sprawdzanie stanu + if(VVP+0.002+BCP/BVMCVP-0.05) then + BrakeStatus:=(BrakeStatus and 252) //luzowanie + else if(VVP+BCP/BVM>CVP-0.05) then + BrakeStatus:=(BrakeStatus and 253) //zatrzymanie napelaniania + else if(VVP+(BCP-0.1)/BVM0.25)then //zatrzymanie luzowania + BrakeStatus:=(BrakeStatus or 1); + + if(VVP+0.100.5)then + Zamykajacy:=true + else if(VVP-0.6CVP-0.08)then + temp:=Nozzles[5] + else + temp:=Nozzles[6]; + dV:=dV+PF(MPP,CVP,temp); + + if(MPP-0.05>BVP)then + dV:=dV+PF(MPP-0.05,BVP,Nozzles[10]*nastG+(1-nastG)*Nozzles[9]); + if MPP>VVP then dV:=dV+PF(MPP,VVP,0.02); + Miedzypoj.Flow(dV*dt*0.15); + + + RapidTemp:=RapidTemp+(RM*Byte((Vel>55)and(BrakeDelayFlag=bdelay_R))-RapidTemp)*dt/2; + temp:=1-RapidTemp; +// if EDFlag then temp:=1000; +// temp:=temp/(1-); + +//powtarzacz — podwojny zawor zwrotny + temp:=Max0R(BCP/temp*Min0R(Max0R(1-EDFlag,0),1),LBP); + + if(BrakeCyl.P>temp)then + dV:=-PFVd(BrakeCyl.P,0,0.02,temp)*dt + else + if(BrakeCyl.P0 then + BrakeRes.Flow(-dV); + + +//przeplyw ZS <-> PG + if(MPPCVP-0.08)then + temp:=Nozzles[5] + else + temp:=Nozzles[6]; + dV:=PF(CVP,MPP,temp)*dt; + CntrlRes.Flow(+dV); + ValveRes.Flow(-0.02*dV); + dV1:=dV1+0.98*dV; + +//przeplyw ZP <-> MPJ + if(MPP-0.05>BVP)then + dV:=PF(BVP,MPP-0.05,Nozzles[10]*nastG+(1-nastG)*Nozzles[9])*dt + else dV:=0; + BrakeRes.Flow(dV); + dV1:=dV1+dV*0.98; + ValveRes.Flow(-0.02*dV); +//przeplyw PG <-> rozdzielacz + dV:=PF(PP,VVP,0.005)*dt; //0.01 + ValveRes.Flow(-dV); + + + ValveRes.Act; + BrakeCyl.Act; + BrakeRes.Act; + CntrlRes.Act; + Miedzypoj.Act; + ImplsRes.Act; + GetPF:=dV-dV1; +end; + +procedure TEStED.Init(PP, HPP, LPP, BP: real; BDF: byte); +var i:integer; +begin + inherited; + + ValveRes.CreatePress(1*PP); + BrakeCyl.CreatePress(1*BP); + +// CntrlRes:=TReservoir.Create; +// CntrlRes.CreateCap(15); +// CntrlRes.CreatePress(1*HPP); + + BrakeStatus:=Byte(BP>1)*1; + Miedzypoj:=TReservoir.Create; + Miedzypoj.CreateCap(5); + Miedzypoj.CreatePress(PP); + + ImplsRes.CreateCap(1); + ImplsRes.CreatePress(BP); + + BVM:=1/(HPP-0.05-LPP)*MaxBP; + + BrakeDelayFlag:=BDF; + Zamykajacy:=false; + EDFlag:=0; + + Nozzles[0]:=1.250/1.7; + Nozzles[1]:=0.907; + Nozzles[2]:=0.510/1.7; + Nozzles[3]:=0.524/1.17; + Nozzles[4]:=7.4; + Nozzles[7]:=5.3; + Nozzles[8]:=2.5; + Nozzles[9]:=7.28; + Nozzles[10]:=2.96; + Nozzles[5]:=1.1; + Nozzles[6]:=0.9; + + for i:=0 to 10 do + begin + Nozzles[i]:=Nozzles[i]*Nozzles[i]*3.14159/4000; + end; + +end; + +function TEStED.GetEDBCP: real; +begin + GetEDBCP:=ImplsRes.P; +end; + + + +//---DAKO CV1--- + +procedure TCV1.CheckState(BCP: real; var dV1: real); +var VVP, BVP, CVP: real; +begin + BVP:=BrakeRes.P; + VVP:=Min0R(ValveRes.P,BVP+0.05); + CVP:=CntrlRes.P-0.0; + +//odluzniacz + if(BrakeStatus and b_rls=b_rls)and(CVP-VVP<0)then + BrakeStatus:=BrakeStatus and 247; + +//sprawdzanie stanu + if (BrakeStatus and 1)=1 then + if(VVP+0.003+BCP/BVMCVP) then + BrakeStatus:=(BrakeStatus and 252) //luzowanie + else if(VVP+BCP/BVM>CVP) then + BrakeStatus:=(BrakeStatus and 253) //zatrzymanie napelaniania + else + else + if(VVP+0.100.25) then //zatrzymanie luzowanie + BrakeStatus:=(BrakeStatus or 1); +end; + +function TCV1.CVs(bp: real): real; +begin +//przeplyw ZS <-> PG + if(bp>0.05)then + CVs:=0 + else + CVs:=0.23 +end; + +function TCV1.BVs(BCP: real): real; +var VVP, BVP, CVP: real; +begin + BVP:=BrakeRes.P; + CVP:=CntrlRes.P; + VVP:=ValveRes.P; + +//przeplyw ZP <-> rozdzielacz + if(BVP0.05)then + BVs:=0 + else + BVs:=0.2*(1.5-Byte(BVP>VVP)); +end; + +function TCV1.GetPF(PP, dt, Vel: real): real; +var dv, dv1, temp:real; + VVP, BVP, BCP, CVP: real; +begin + BVP:=BrakeRes.P; + VVP:=Min0R(ValveRes.P,BVP+0.05); + BCP:=BrakeCyl.P; + CVP:=CntrlRes.P-0.0; + + dV:=0; dV1:=0; + +//sprawdzanie stanu + CheckState(BCP, dV1); + + VVP:=ValveRes.P; +//przeplyw ZS <-> PG + temp:=CVs(BCP); + dV:=PF(CVP,VVP,0.0015*temp)*dt; + CntrlRes.Flow(+dV); + ValveRes.Flow(-0.04*dV); + dV1:=dV1-0.96*dV; + + +//luzowanie + if(BrakeStatus and b_hld)=b_off then + dV:=PF(0,BCP,0.0042*(1.37-Byte(BrakeDelayFlag=bdelay_G))*sizeBC)*dt + else dV:=0; + BrakeCyl.Flow(-dV); + +//przeplyw ZP <-> silowniki + if(BrakeStatus and b_on)=b_on then + dV:=PF(BVP,BCP,0.017*(1+Byte((BCP<0.58)and(BrakeDelayFlag=bdelay_G)))*(1.13-Byte((BCP>0.6)and(BrakeDelayFlag=bdelay_G)))*sizeBC)*dt + else dV:=0; + BrakeRes.Flow(dV); + BrakeCyl.Flow(-dV); + +//przeplyw ZP <-> rozdzielacz + temp:=BVs(BCP); + if(VVP+0.05>BVP)then + dV:=PF(BVP,VVP,0.02*sizeBR*temp/1.87)*dt + else dV:=0; + BrakeRes.Flow(dV); + dV1:=dV1+dV*0.96; + ValveRes.Flow(-0.04*dV); +//przeplyw PG <-> rozdzielacz + dV:=PF(PP,VVP,0.01)*dt; + ValveRes.Flow(-dV); + + ValveRes.Act; + BrakeCyl.Act; + BrakeRes.Act; + CntrlRes.Act; + GetPF:=dV-dV1; +end; + +procedure TCV1.Init(PP, HPP, LPP, BP: real; BDF: byte); +begin + ValveRes.CreatePress(PP); + BrakeCyl.CreatePress(BP); + BrakeRes.CreatePress(PP); + CntrlRes:=TReservoir.Create; + CntrlRes.CreateCap(15); + CntrlRes.CreatePress(HPP); + BrakeStatus:=0; + + BVM:=1/(HPP-LPP)*MaxBP; + + BrakeDelayFlag:=BDF; +end; + +function TCV1.GetCRP: real; +begin + GetCRP:=CntrlRes.P; +end; + + +//---CV1-L-TR--- + +procedure TCV1L_TR.SetLBP(P: real); +begin + LBP:=P; +end; + +function TCV1L_TR.GetHPFlow(HP, dt: real): real; +var dV: real; +begin + dV:=PF(HP,BrakeRes.P,0.01)*dt; + dV:=Min0R(0,dV); + BrakeRes.Flow(-dV); + GetHPFlow:=dV; +end; + +procedure TCV1L_TR.Init(PP, HPP, LPP, BP: real; BDF: byte); +begin + inherited; + ImplsRes:=TReservoir.Create; + ImplsRes.CreateCap(2.5); + ImplsRes.CreatePress(BP); +end; + +function TCV1L_TR.GetPF(PP, dt, Vel: real): real; +var dv, dv1, temp:real; + VVP, BVP, BCP, CVP: real; +begin + BVP:=BrakeRes.P; + VVP:=Min0R(ValveRes.P,BVP+0.05); + BCP:=ImplsRes.P; + CVP:=CntrlRes.P-0.0; + + dV:=0; dV1:=0; + +//sprawdzanie stanu + CheckState(BCP, dV1); + + VVP:=ValveRes.P; +//przeplyw ZS <-> PG + temp:=CVs(BCP); + dV:=PF(CVP,VVP,0.0015*temp)*dt; + CntrlRes.Flow(+dV); + ValveRes.Flow(-0.04*dV); + dV1:=dV1-0.96*dV; + + +//luzowanie KI + if(BrakeStatus and b_hld)=b_off then + dV:=PF(0,BCP,0.000425*(1.37-Byte(BrakeDelayFlag=bdelay_G)))*dt + else dV:=0; + ImplsRes.Flow(-dV); +//przeplyw ZP <-> KI + if ((BrakeStatus and b_on)=b_on) and (BCP0.6)and(BrakeDelayFlag=bdelay_G))))*dt + else dV:=0; + BrakeRes.Flow(dV); + ImplsRes.Flow(-dV); + +//przeplyw ZP <-> rozdzielacz + temp:=BVs(BCP); + if(VVP+0.05>BVP)then + dV:=PF(BVP,VVP,0.02*sizeBR*temp/1.87)*dt + else dV:=0; + BrakeRes.Flow(dV); + dV1:=dV1+dV*0.96; + ValveRes.Flow(-0.04*dV); +//przeplyw PG <-> rozdzielacz + dV:=PF(PP,VVP,0.01)*dt; + GetPF:=dV-dV1; + + temp:=Max0R(BCP,LBP); + +//luzowanie CH + if(BrakeCyl.P>temp+0.005)or(Max0R(ImplsRes.P,8*LBP)<0.25) then + dV:=PF(0,BrakeCyl.P,0.015*sizeBC)*dt + else dV:=0; + BrakeCyl.Flow(-dV); + +//przeplyw ZP <-> CH + if(BrakeCyl.P0.3)and(Max0R(BCP,LBP)CVP) then + BrakeStatus:=(BrakeStatus and 252) //luzowanie + else if(VVP+BCP/BVM>CVP) then + BrakeStatus:=(BrakeStatus and 253) //zatrzymanie napelaniania + else + else + if(VVP+0.100.25) then //zatrzymanie luzowanie + BrakeStatus:=(BrakeStatus or 1); +end; + +function TKE.CVs(bp: real): real; +var VVP, BVP, CVP: real; +begin + BVP:=BrakeRes.P; + CVP:=CntrlRes.P; + VVP:=ValveRes.P; + +//przeplyw ZS <-> PG + if(bp>0.2)then + CVs:=0 + else + if(VVP>CVP+0.4)then + CVs:=0.05 + else + CVs:=0.23 +end; + +function TKE.BVs(BCP: real): real; +var VVP, BVP, CVP: real; +begin + BVP:=BrakeRes.P; + CVP:=CntrlRes.P; + VVP:=ValveRes.P; + +//przeplyw ZP <-> rozdzielacz + if (BVP>VVP) then + BVs:=0 + else + if(BVP PG + temp:=CVs(IMP); + dV:=PF(CVP,VVP,0.0015*temp)*dt; + CntrlRes.Flow(+dV); + ValveRes.Flow(-0.04*dV); + dV1:=dV1-0.96*dV; + +//luzowanie + if(BrakeStatus and b_hld)=b_off then + begin + if ((BrakeDelayFlag and bdelay_G)=0) then + temp:=0.283+0.139 + else + temp:=0.139; + dV:=PF(0,IMP,0.001*temp)*dt + end + else dV:=0; + ImplsRes.Flow(-dV); + +//przeplyw ZP <-> silowniki + if((BrakeStatus and b_on)=b_on)and(IMP50)and(RapidStatus))or(Vel>70)) + else //jesli tarczowki, to zostan + RapidStatus:=((BrakeDelayFlag and bdelay_R)=bdelay_R); + +// temp:=1.9-0.9*Byte(RapidStatus); + + if(RM*RM>0.1)then //jesli jest rapid + if(RM>0)then //jesli dodatni (naddatek); + temp:=1-RM*Byte(RapidStatus) + else + temp:=1-RM*(1-Byte(RapidStatus)) + else + temp:=1; + temp:=temp/LoadC; +//luzowanie CH +// temp:=Max0R(BCP,LBP); + IMP:=Max0R(IMP/temp,Max0R(LBP,ASBP*Byte((BrakeStatus and b_asb)=b_asb))); + +//luzowanie CH + if(BCP>IMP+0.005)or(Max0R(ImplsRes.P,8*LBP)<0.25) then + dV:=PFVd(BCP,0,0.05,IMP)*dt + else dV:=0; + BrakeCyl.Flow(-dV); + if(BCP0.3) then + dV:=PFVa(BVP,BCP,0.05,IMP)*dt + else dV:=0; + BrakeRes.Flow(-dV); + BrakeCyl.Flow(+dV); + +//przeplyw ZP <-> rozdzielacz + temp:=BVs(IMP); +// if(BrakeStatus and b_hld)=b_off then + if(IMP<0.25)or(VVP+0.05>BVP)then + dV:=PF(BVP,VVP,0.02*sizeBR*temp/1.87)*dt + else dV:=0; + BrakeRes.Flow(dV); + dV1:=dV1+dV*0.96; + ValveRes.Flow(-0.04*dV); +//przeplyw PG <-> rozdzielacz + dV:=PF(PP,VVP,0.01)*dt; + ValveRes.Flow(-dV); + + ValveRes.Act; + BrakeCyl.Act; + BrakeRes.Act; + CntrlRes.Act; + ImplsRes.Act; + GetPF:=dV-dV1; +end; + +procedure TKE.Init(PP, HPP, LPP, BP: real; BDF: byte); +begin + ValveRes.CreatePress(PP); + BrakeCyl.CreatePress(BP); + BrakeRes.CreatePress(PP); + + CntrlRes:=TReservoir.Create; //komora sterujaca + CntrlRes.CreateCap(5); + CntrlRes.CreatePress(HPP); + + ImplsRes:=TReservoir.Create; //komora zastepcza silownika + ImplsRes.CreateCap(1); + ImplsRes.CreatePress(BP); + + BrakeStatus:=0; + + BVM:=1/(HPP-LPP)*MaxBP; + + BrakeDelayFlag:=BDF; +end; + +function TKE.GetCRP: real; +begin + GetCRP:=CntrlRes.P; +end; + +function TKE.GetHPFlow(HP, dt: real): real; +var dV: real; +begin + dV:=PF(HP,BrakeRes.P,0.01)*dt; + dV:=Min0R(0,dV); + BrakeRes.Flow(-dV); + GetHPFlow:=dV; +end; + +procedure TKE.PLC(mass: real); +begin + LoadC:=1+Byte(Massrp+0.05)then + dpMainValve:=PF(Min0R(cp+0.1,HP),pp,1.1*(ActFlowSpeed)/(LBDelay))*dt; + if(cp0.1)then + begin + cp:=5+(tp-0.1)*0.08; + tp:=tp-dt/12/2; + end; + if(cp>rp+0.1)and(cp<=5)then + dpMainValve:=PF(Min0R(cp+0.25,HP),pp,2*(ActFlowSpeed)/(LBDelay))*dt + else + if cp>5 then + dpMainValve:=PF(Min0R(cp,HP),pp,2*(ActFlowSpeed)/(LBDelay))*dt + else + dpMainValve:=PF(dpPipe,pp,(ActFlowSpeed)/(LBDelay))*dt + end; + + if(Round(i_bcp)=i_bcpNo)then + begin + dpMainValve:=PF(0,pp,(ActFlowSpeed)/(LBDelay))*dt; + end; + + GetPF:=dpMainValve; +end; + +procedure TFV4a.Init(press: real); +begin + CP:= press; + TP:= 0; + RP:= press; + Time:= false; + TimeEP:=false; +end; + + +//---FV4a/M--- nowonapisany kran bez poprawki IC + +function TFV4aM.GetPF(i_bcp:real; pp, hp, dt, ep: real): real; +function LPP_RP(pos: real): real; //cisnienie z zaokraglonej pozycji; +var i_pos: integer; +begin + i_pos:=Round(pos-0.5); //zaokraglone w dol + LPP_RP:=BPT[i_pos][1]+(BPT[i_pos+1][1]-BPT[i_pos][1])*(pos-i_pos); //interpolacja liniowa +end; +function EQ(pos: real; i_pos: real): boolean; +begin + EQ:=(pos<=i_pos+0.5)and(pos>i_pos-0.5); +end; +const + LBDelay = 100; + xpM = 0.3; //mnoznik membrany komory pod +var + LimPP, dpPipe, dpMainValve, ActFlowSpeed, dp: real; + pom: real; + i: byte; +begin + ep:=pp/2*1.5+ep/2*0.5; //SPKS!! +// ep:=pp; +// ep:=cp/3+pp/3+ep/3; +// ep:=cp; + + for i:=0 to 4 do + Sounds[i]:=0; + dp:=0; + + i_bcp:=Max0R(Min0R(i_bcp,5.999),-1.999); //na wszelki wypadek, zeby nie wyszlo poza zakres + + if(tp>0)then + begin //jesli czasowy jest niepusty +// dp:=0.07; //od cisnienia 5 do 0 w 60 sekund ((5-0)*dt/75) + dp:=0.045; //2.5 w 55 sekund (5,35->5,15 w PG) + tp:=tp-dp*dt; + Sounds[s_fv4a_t]:=dp; + end + else //.08 + begin + tp:=0; + end; + + if(xp>0)then //jesli komora pod niepusta jest niepusty + begin + dp:=2.5; + Sounds[s_fv4a_x]:=dp*xp; + xp:=xp-dt*dp*2; //od cisnienia 5 do 0 w 10 sekund ((5-0)*dt/10) + end + else //.75 + xp:=0; //jak pusty, to pusty + + Limpp:=Min0R(LPP_RP(i_bcp)+tp*0.08+RedAdj,HP); //pozycja + czasowy lub zasilanie + ActFlowSpeed:=BPT[Round(i_bcp)][0]; + + if(EQ(i_bcp,-1))then pom:=Min0R(HP,5.4+RedAdj) else pom:=Min0R(cp,HP); + + if(pom>rp+0.25)then Fala:=true; + if(Fala)then + if(pom>rp+0.3)then +// if(ep>rp+0.11)then + xp:=xp-20*PR(pom,xp)*dt +// else +// xp:=xp-16*(ep-(ep+0.01))/(0.1)*PR(ep,xp)*dt + else Fala:=false; + + if(Limpp>cp)then //podwyzszanie szybkie + cp:=cp+5*60*Min0R(abs(Limpp-cp),0.05)*PR(cp,Limpp)*dt //zbiornik sterujacy + else + cp:=cp+13*Min0R(abs(Limpp-cp),0.05)*PR(cp,Limpp)*dt; //zbiornik sterujacy + + Limpp:=pom; //cp + dpPipe:=Min0R(HP,Limpp+xp*xpM); + + if dpPipe>pp then + dpMainValve:=-PFVa(HP,pp,ActFlowSpeed/(LBDelay),dpPipe,0.4) + else + dpMainValve:=PFVd(pp,0,ActFlowSpeed/(LBDelay),dpPipe,0.4); + + if EQ(i_bcp,-1) then + begin + if(tp<5)then tp:=tp+dt; //5/10 + if(tp<1)then tp:=tp-0.5*dt; //5/10 +// dpMainValve:=dpMainValve*2;//+1*PF(dpPipe,pp,(ActFlowSpeed)/(LBDelay))//coby nie przeszkadzal przy ladowaniu z zaworu obok + end; + + if EQ(i_bcp,0) then + begin + if(tp>2)then + dpMainValve:=dpMainValve*1.5;//+0.5*PF(dpPipe,pp,(ActFlowSpeed)/(LBDelay))//coby nie przeszkadzal przy ladowaniu z zaworu obok + end; + + + + + + ep:=dpPipe; + if(EQ(i_bcp,0)or(rp>ep))then + rp:=rp+PF(rp,ep,0.0007)*dt //powolne wzrastanie, ale szybsze na jezdzie + else + rp:=rp+PF(rp,ep,0.000093/2*2)*dt; //powolne wzrastanie i to bardzo //jednak trzeba wydluzyc, bo obecnie zle dziala + if (rp0 then + Sounds[s_fv4a_b]:=dpMainValve + else + Sounds[s_fv4a_u]:=-dpMainValve; + end; + + GetPF:=dpMainValve*dt; +end; + +procedure TFV4aM.Init(press: real); +begin + CP:= press; + TP:= 0; + RP:= press; + XP:= 0; + Time:=false; + TimeEP:=false; +end; + +procedure TFV4aM.SetReductor(nAdj: real); +begin + RedAdj:= nAdj; +end; + +function TFV4aM.GetSound(i: byte): real; +begin + if i>4 then + GetSound:=0 + else + GetSound:=Sounds[i]; +end; + +function TFV4aM.GetPos(i: byte): real; +const + table: array[0..10] of real = (-2,6,-1,0,-2,1,4,6,0,0,0); +begin + GetPos:=table[i]; +end; + +//---M394--- Matrosow + +function TM394.GetPF(i_bcp:real; pp, hp, dt, ep: real): real; +const + LBDelay = 65; +var + LimPP, dpPipe, dpMainValve, ActFlowSpeed: real; + bcp: integer; +begin + bcp:=Round(i_bcp); + if bcp<-1 then bcp:=1; + + Limpp:=Min0R(BPT_394[bcp][1],HP); + ActFlowSpeed:=BPT_394[bcp][0]; + if (bcp=1)or(bcp=i_bcpNo) then + Limpp:=pp; + if (bcp=0) then + Limpp:=Limpp+RedAdj; + if (bcp<>2) then + if cp3)+Byte(bcp>4))*Min0R(abs(Limpp-cp),0.05)*PR(cp,Limpp)*dt; //zbiornik sterujacy + + Limpp:=cp; + dpPipe:=Min0R(HP,Limpp); + +// if(dpPipe>pp)then //napelnianie +// dpMainValve:=PF(dpPipe,pp,ActFlowSpeed/(LBDelay))*dt +// else //spuszczanie + dpMainValve:=PF(dpPipe,pp,ActFlowSpeed/(LBDelay))*dt; + + if bcp=-1 then +// begin + dpMainValve:=PF(HP,pp,(ActFlowSpeed)/(LBDelay))*dt; +// end; + + if bcp=i_bcpNo then +// begin + dpMainValve:=PF(0,pp,(ActFlowSpeed)/(LBDelay))*dt; +// end; + + GetPF:=dpMainValve; +end; + +procedure TM394.Init(press: real); +begin + CP:= press; + RedAdj:= 0; + Time:=true; + TimeEP:=false; +end; + +procedure TM394.SetReductor(nAdj: real); +begin + RedAdj:= nAdj; +end; + +function TM394.GetCP: real; +begin + GetCP:= CP; +end; + +function TM394.GetPos(i: byte): real; +const + table: array[0..10] of real = (-1,5,-1,0,1,2,4,5,0,0,0); +begin + GetPos:=table[i]; +end; + +//---H14K1-- Knorr + +function TH14K1.GetPF(i_bcp:real; pp, hp, dt, ep: real): real; +const + LBDelay = 100; //szybkosc + zasilanie sterujacego + BPT_K: array[-1..4] of array [0..1] of real= ((10, 0), (4, 1), (0, 1), (4, 0), (4, -1), (15, -1)); + NomPress = 5.0; +var + LimPP, dpPipe, dpMainValve, ActFlowSpeed: real; + bcp: integer; +begin + bcp:=Round(i_bcp); + if i_bcp<-1 then bcp:=1; + Limpp:=BPT_K[bcp][1]; + if Limpp<0 then + Limpp:=0.5*pp + else if Limpp>0 then + Limpp:=pp + else + Limpp:=cp; + ActFlowSpeed:=BPT_K[bcp][0]; + + cp:=cp+6*Min0R(abs(Limpp-cp),0.05)*PR(cp,Limpp)*dt; //zbiornik sterujacy + + dpMainValve:=0; + + if bcp=-1 then + dpMainValve:=PF(HP,pp,(ActFlowSpeed)/(LBDelay))*dt; + if(bcp=0)then + dpMainValve:=-PFVa(HP,pp,(ActFlowSpeed)/(LBDelay),NomPress+RedAdj)*dt; + if (bcp>1)and(pp>cp) then + dpMainValve:=PFVd(pp,0,(ActFlowSpeed)/(LBDelay),cp)*dt; + if bcp=i_bcpNo then + dpMainValve:=PF(0,pp,(ActFlowSpeed)/(LBDelay))*dt; + + GetPF:=dpMainValve; +end; + +procedure TH14K1.Init(press: real); +begin + CP:= press; + RedAdj:= 0; + Time:=true; + TimeEP:=true; +end; + +procedure TH14K1.SetReductor(nAdj: real); +begin + RedAdj:= nAdj; +end; + +function TH14K1.GetCP: real; +begin + GetCP:= CP; +end; + +function TH14K1.GetPos(i: byte): real; +const + table: array[0..10] of real = (-1,4,-1,0,1,2,3,4,0,0,0); +begin + GetPos:=table[i]; +end; + +//---St113-- Knorr EP + +function TSt113.GetPF(i_bcp:real; pp, hp, dt, ep: real): real; +const + LBDelay = 100; //szybkosc + zasilanie sterujacego + BPT_K: array[-1..4] of array [0..1] of real= ((10, 0), (4, 1), (0, 1), (4, 0), (4, -1), (15, -1)); + BEP_K: array[-1..5] of real= (0, -1, 1, 0, 0, 0, 0); + NomPress = 5.0; +var + LimPP, dpPipe, dpMainValve, ActFlowSpeed: real; + bcp: integer; +begin + bcp:=Round(i_bcp); + + EPS:=BEP_K[bcp]; + + if bcp>0 then bcp:=bcp-1; + + if bcp<-1 then bcp:=1; + Limpp:=BPT_K[bcp][1]; + if Limpp<0 then + Limpp:=0.5*pp + else if Limpp>0 then + Limpp:=pp + else + Limpp:=cp; + ActFlowSpeed:=BPT_K[bcp][0]; + + cp:=cp+6*Min0R(abs(Limpp-cp),0.05)*PR(cp,Limpp)*dt; //zbiornik sterujacy + + dpMainValve:=0; + + if bcp=-1 then + dpMainValve:=PF(HP,pp,(ActFlowSpeed)/(LBDelay))*dt; + if(bcp=0)then + dpMainValve:=-PFVa(HP,pp,(ActFlowSpeed)/(LBDelay),NomPress+RedAdj)*dt; + if (bcp>1)and(pp>cp) then + dpMainValve:=PFVd(pp,0,(ActFlowSpeed)/(LBDelay),cp)*dt; + if bcp=i_bcpNo then + dpMainValve:=PF(0,pp,(ActFlowSpeed)/(LBDelay))*dt; + + GetPF:=dpMainValve; +end; + +function TSt113.GetCP: real; +begin + GetCP:=EPS; +end; + +function TSt113.GetPos(i: byte): real; +const + table: array[0..10] of real = (-1,5,-1,0,2,3,4,5,0,0,1); +begin + GetPos:=table[i]; +end; + +procedure TSt113.Init(press: real); +begin + Time:=true; + TimeEP:=true; +end; + +//--- test --- + +function Ttest.GetPF(i_bcp:real; pp, hp, dt, ep: real): real; +const + LBDelay = 100; +var + LimPP, dpPipe, dpMainValve, ActFlowSpeed: real; +begin + + Limpp:=BPT[Round(i_bcp)][1]; + ActFlowSpeed:=BPT[Round(i_bcp)][0]; + + if(i_bcp=i_bcpNo)then limpp:=0.0; + + if(i_bcp=-1)then limpp:=7; + + cp:=cp+20*Min0R(abs(Limpp-cp),0.05)*PR(cp,Limpp)*dt/1; + + Limpp:=cp; + dpPipe:=Min0R(HP,Limpp); + + dpMainValve:=PF(dpPipe,pp,ActFlowSpeed/(LBDelay))*dt; + + if(Round(i_bcp)=i_bcpNo)then + begin + dpMainValve:=PF(0,pp,(ActFlowSpeed)/(LBDelay))*dt; + end; + + GetPF:=dpMainValve; +end; + +procedure Ttest.Init(press: real); +begin + CP:= press; +end; + + +//---FD1--- + +function TFD1.GetPF(i_bcp:real; pp, hp, dt, ep: real): real; +var dp, temp: real; +begin +// MaxBP:=4; +// temp:=Min0R(i_bcp*MaxBP,Min0R(5.0,HP)); + temp:=Min0R(i_bcp*MaxBP,HP); //0011 + dp:=10*Min0R(abs(temp-BP),0.1)*PF(temp,BP,0.0006*(2+Byte(temp>BP)))*dt; + BP:=BP-dp; + GetPF:=-dp; +end; + +procedure TFD1.Init(press: real); +begin + BP:=0; + MaxBP:=press; + Time:=false; + TimeEP:=false; +end; + +function TFD1.GetCP: real; +begin + GetCP:=BP; +end; + + +//---KNORR--- + +function TH1405.GetPF(i_bcp:real; pp, hp, dt, ep: real): real; +var dp, temp, A: real; +begin + pp:=Min0R(pp,MaxBP); + if i_bcp>0.5 then + begin + temp:=Min0R(MaxBP,HP); + A:=2*(i_bcp-0.5)*0.0011; + BP:=Max0R(BP,pp); + end + else + begin + temp:=0; + A:=0.2*(0.5-i_bcp)*0.0033; + BP:=Min0R(BP,pp); + end; + dp:=PF(temp,BP,A)*dt; + BP:=BP-dp; + GetPF:=-dp; +end; + +procedure TH1405.Init(press: real); +begin + BP:=0; + MaxBP:=press; + Time:=true; + TimeEP:=false; +end; + +function TH1405.GetCP: real; +begin + GetCP:=BP; +end; + + +//---FVel6--- + +function TFVel6.GetPF(i_bcp:real; pp, hp, dt, ep: real): real; +const + LBDelay = 100; +var + LimPP, dpPipe, dpMainValve, ActFlowSpeed: real; +begin + Limpp:=Min0R(5*Byte(i_bcp<3.5),hp); + if (i_bcp>=3.5) and ((i_bcp<4.3)or(i_bcp>5.5)) then + ActFlowSpeed:=0 + else if (i_bcp>4.3) and (i_bcp<4.8) then + ActFlowSpeed:=4*(i_bcp-4.3) //konsultacje wawa1 - bylo 8 + else if (i_bcp<4) then + ActFlowSpeed:=2 + else + ActFlowSpeed:=4; + dpMainValve:=PF(Limpp,pp,ActFlowSpeed/(LBDelay))*dt; + + + Sounds[s_fv4a_e]:=0; + Sounds[s_fv4a_u]:=0; + Sounds[s_fv4a_b]:=0; + if(i_bcp<3.5)then Sounds[s_fv4a_u]:=-dpMainValve else + if(i_bcp<4.8)then Sounds[s_fv4a_b]:=dpMainValve else + if(i_bcp<5.5)then Sounds[s_fv4a_e]:=dpMainValve; + + GetPF:=dpMainValve; + if(i_bcp<-0.5)then + EPS:=-1 + else if(i_bcp>0.5)and(i_bcp<4.7)then + EPS:=1 + else + EPS:=0; +// EPS:=i_bcp*Byte(i_bcp<2) +end; + +function TFVel6.GetCP: real; +begin + GetCP:=EPS; +end; + +function TFVel6.GetPos(i: byte): real; +const + table: array[0..10] of real = (-1,6,-1,0,6,4,4.7,5,-1,0,1); +begin + GetPos:=table[i]; +end; + +function TFVel6.GetSound(i: byte): real; +begin + if i>2 then + GetSound:=0 + else + GetSound:=Sounds[i]; +end; + +procedure TFVel6.Init(press: real); +begin + Time:=true; + TimeEP:=true; +end; + +end. + + diff --git a/McZapkie/klasy_ham.pas b/McZapkie/klasy_ham.pas new file mode 100644 index 00000000..2daa146d --- /dev/null +++ b/McZapkie/klasy_ham.pas @@ -0,0 +1,61 @@ +unit klasy_ham; {fizyka hamulcow dla symulatora} + +(* + MaSzyna EU07 - SPKS + Brakes. Basic classes. + Copyright (C) 2007-2013 Maciej Cierniak +*) + + +interface + +uses mctools,sysutils; + +//CONST; + +TYPE + TRurka= class //bezposrednie polaczenie, co wleci to wyleci + private + Vol: real; + Cap: real; + + public + function Update(dt: real); + procedure Flow(dV: real); + end; + + PRurka= ^TRurka; + + TTrojnik= class(TRurka) + private + Wyjscie1: PRurka; + Wyjscie2: PRurka; + Wyjscie3: PRurka; + public + end; + + TZbiornik= class(TRurka) + private + Wyjscie_jeden: PRurka; + public + end; + + TPowtarzacz= class(TRurka) + private + public + end; + + TPrzekladnik= class(TPowtarzacz) + private + public + end; + +function PF(P1,P2,S:real):real; + +implementation + + + +end. + + diff --git a/McZapkie/mctools.hpp b/McZapkie/mctools.hpp new file mode 100644 index 00000000..d989fcd1 --- /dev/null +++ b/McZapkie/mctools.hpp @@ -0,0 +1,95 @@ +// Borland C++ Builder +// Copyright (c) 1995, 1999 by Borland International +// All rights reserved + +// (DO NOT EDIT: machine generated header) 'mctools.pas' rev: 5.00 + +#ifndef mctoolsHPP +#define mctoolsHPP + +#pragma delphiheader begin +#pragma option push -w- +#pragma option push -Vx +#include // Pascal unit +#include // Pascal unit + +//-- user supplied ----------------------------------------------------------- + +namespace Mctools +{ +//-- type declarations ------------------------------------------------------- +typedef Set TableChar; + +//-- var, const, procedure --------------------------------------------------- +#define _EOL (System::Set () << '\xa' << '\xd' ) +static const char _SPACE = '\x20'; +#define _Spacesigns (System::Set () << '\x9' << '\xa' << '\xd' << '\x29' << '\x2a' << '\x2d' \ + << '\x49' << '\x4a' << '\x4d' << '\x69' << '\x6a' << '\x6d' << '\x89' << '\x8a' << '\x8d' << '\xa9' \ + << '\xaa' << '\xad' << '\xc9' << '\xca' << '\xcd' << '\xe9' << '\xea' << '\xed' ) +static const Shortint CutLeft = 0xffffffff; +static const Shortint CutRight = 0x1; +static const Shortint CutBoth = 0x0; +extern PACKAGE int ConversionError; +extern PACKAGE int LineCount; +extern PACKAGE bool DebugModeFlag; +extern PACKAGE bool FreeFlyModeFlag; +extern PACKAGE double Xmin; +extern PACKAGE double Ymin; +extern PACKAGE double Xmax; +extern PACKAGE double Ymax; +extern PACKAGE double Xaspect; +extern PACKAGE double Yaspect; +extern PACKAGE double Hstep; +extern PACKAGE double Vstep; +extern PACKAGE int Vsize; +extern PACKAGE int Hsize; +extern PACKAGE AnsiString __fastcall Ups(AnsiString s); +extern PACKAGE AnsiString __fastcall b2s(Byte b); +extern PACKAGE AnsiString __fastcall i2s(int i); +extern PACKAGE AnsiString __fastcall l2s(int l); +extern PACKAGE AnsiString __fastcall r2s(double r, Byte SWidth); +extern PACKAGE Byte __fastcall s2b(AnsiString s); +extern PACKAGE int __fastcall s2i(AnsiString s); +extern PACKAGE int __fastcall s2l(AnsiString s); +extern PACKAGE double __fastcall s2r(AnsiString s); +extern PACKAGE Byte __fastcall s2bE(AnsiString s); +extern PACKAGE int __fastcall s2iE(AnsiString s); +extern PACKAGE int __fastcall s2lE(AnsiString s); +extern PACKAGE double __fastcall s2rE(AnsiString s); +extern PACKAGE Byte __fastcall Max0(Byte x1, Byte x2); +extern PACKAGE Byte __fastcall Min0(Byte x1, Byte x2); +extern PACKAGE double __fastcall Max0R(double x1, double x2); +extern PACKAGE double __fastcall Min0R(double x1, double x2); +extern PACKAGE int __fastcall Sign(double x); +extern PACKAGE bool __fastcall TestFlag(int Flag, int Value); +extern PACKAGE bool __fastcall SetFlag(Byte &Flag, int Value); +extern PACKAGE bool __fastcall iSetFlag(int &Flag, int Value); +extern PACKAGE bool __fastcall FuzzyLogic(double Test, double Threshold, double Probability); +extern PACKAGE bool __fastcall FuzzyLogicAI(double Test, double Threshold, double Probability); +extern PACKAGE AnsiString __fastcall ReadWord(TextFile &infile); +extern PACKAGE AnsiString __fastcall Cut_Space(AnsiString s, int Just); +extern PACKAGE AnsiString __fastcall ExtractKeyWord(AnsiString InS, AnsiString KeyWord); +extern PACKAGE AnsiString __fastcall DUE(AnsiString S); +extern PACKAGE AnsiString __fastcall DWE(AnsiString S); +extern PACKAGE AnsiString __fastcall Ld2Sp(AnsiString S); +extern PACKAGE AnsiString __fastcall Tab2Sp(AnsiString S); +extern PACKAGE void __fastcall ComputeArc(double X0, double Y0, double Xn, double Yn, double R, double + L, double dL, double &phi, double &Xout, double &Yout); +extern PACKAGE void __fastcall ComputeALine(double X0, double Y0, double Xn, double Yn, double L, double + R, double &Xout, double &Yout); +extern PACKAGE double __fastcall Xhor(double h); +extern PACKAGE double __fastcall Yver(double v); +extern PACKAGE int __fastcall Horiz(double X); +extern PACKAGE int __fastcall Vert(double Y); +extern PACKAGE void __fastcall ClearPendingExceptions(void); + +} /* namespace Mctools */ +#if !defined(NO_IMPLICIT_NAMESPACE_USE) +using namespace Mctools; +#endif +#pragma option pop // -w- +#pragma option pop // -Vx + +#pragma delphiheader end. +//-- end unit ---------------------------------------------------------------- +#endif // mctools diff --git a/McZapkie/mctools.pas b/McZapkie/mctools.pas new file mode 100644 index 00000000..f0e9ab06 --- /dev/null +++ b/McZapkie/mctools.pas @@ -0,0 +1,497 @@ +unit mctools; +{rozne takie duperele do operacji na stringach w paszczalu, pewnie w delfi sa lepsze} +{konwersja zmiennych na stringi, funkcje matematyczne, logiczne, lancuchowe, I/O etc} + +interface + + +const +{Ra: te stałe nie są używane... + _FileName = ['a'..'z','A'..'Z',':','\','.','*','?','0'..'9','_','-']; + _RealNum = ['0'..'9','-','+','.','E','e']; + _Integer = ['0'..'9','-']; //Ra: to się gryzie z STLport w Builder 6 + _Plus_Int = ['0'..'9']; + _All = [' '..'ţ']; + _Delimiter= [',',';']+_EOL; + _Delimiter_Space=_Delimiter+[' ']; +} + _EOL = [#13,#10]; + _SPACE = ' '; + _Spacesigns=[' ']+[#9]+_EOL; + CutLeft=-1; CutRight=1; CutBoth=0; {Cut_Space} + +var + ConversionError: integer=0; + LineCount: integer=0; + DebugModeFlag: boolean=False; + FreeFlyModeFlag: boolean=False; + +type + TableChar = Set Of Char; {MCTUTIL} + +{konwersje} +function b2s(b:byte):string; +function i2s(i:integer):string; +function l2s(l:longint):string; +function r2s(r:real; SWidth:byte):string; +function s2b(s:string):byte; +function s2i(s:string):integer; +function s2l(s:string):longint; +function s2r(s:string):real; +function s2bE(s:string):byte; +function s2iE(s:string):integer; +function s2lE(s:string):longint; +function s2rE(s:string):real; + +{funkcje matematyczne} +function Max0(x1,x2:byte) : byte; +function Min0(x1,x2:byte) : byte; + +function Max0R(x1,x2:real) : real; +function Min0R(x1,x2:real) : real; + +function Sign(x:real) : integer; + +{funkcje logiczne} +function TestFlag(Flag:integer; Value:integer):boolean; +function SetFlag(var Flag:byte; Value:integer):boolean; +function iSetFlag(var Flag:integer; Value:integer):boolean; + +function FuzzyLogic(Test,Threshold,Probability:real):boolean; +{jesli Test>Threshold to losowanie} +function FuzzyLogicAI(Test,Threshold,Probability:real):boolean; +{to samo ale zawsze niezaleznie od DebugFlag} + +{operacje na stringach} +Function ReadWord(var infile:text):string; {czyta slowo z wiersza pliku tekstowego} +Function Ups (s:string ): string ; +Function Cut_Space(s:string; Just:integer) : string; +Function ExtractKeyWord(InS:String; KeyWord:string) : String; {wyciaga slowo kluczowe i lancuch do pierwszej spacji} +Function DUE(S:String) : String; {Delete Until Equal sign} +Function DWE(S:String) : String; {Delete While Equal sign} +Function Ld2Sp(S:String): String; {Low dash to Space sign} +Function Tab2Sp(S:String): String; {Tab to Space sign} + +{procedury, zmienne i funkcje graficzne} +procedure ComputeArc(X0,Y0,Xn,Yn,R,L:real;dL:real; var phi,Xout,Yout:real); +{wylicza polozenie Xout Yout i orientacje phi punktu na elemencie dL luku} +procedure ComputeALine(X0,Y0,Xn,Yn,L,R:real; var Xout,Yout:real); + + +var + Xmin,Ymin,Xmax,Ymax:real; + Xaspect,Yaspect:real; + Hstep,Vstep: real; + Vsize,Hsize:integer; + +function Xhor( h:real) :real; + { Converts horizontal screen coordinate into real X-coordinate. } + +function Yver( v:real) :real; + { Converts vertical screen coordinate into real Y-coordinate. } + +function Horiz(X:real):longint; + +function Vert(Y:real):longint; + +procedure ClearPendingExceptions; + +{------------------------------------------------} +Implementation +{================================================} + +function Ups (s:string ): string ; +var + jatka : integer; swy:string; +begin + swy:=''; + for jatka:=1 to length(s) do swy:=swy+UpCase(s[jatka]); + Ups:=swy; +end; {=Ups=} + +function b2s(b:byte):string; +var + s:string; +begin + Str(b:2,s); + b2s:=s; +end; {=b2s=} + +function i2s(i:integer):string; +var + s:string; +begin + Str(i:3,s); + i2s:=s; +end; {=i2s=} + +function l2s(l:longint):string; +var + s:string; +begin + Str(l:4,s); + l2s:=s; +end; {=l2s=} + +function r2s(r:real; SWidth:byte):string; +var + s:string; + absr:real; {rr:integer;} +begin + absr:=Abs(r); + if SWidth<8 then SWidth:=8; + if absr > 0.0001 then + begin {rr:=(Round(ln(1/absr)/ln(10)-1+Swidth/2));} + if absr < 100 then + Str(r:Swidth:(Round(ln(1/absr)/ln(10)-1+Swidth/2)),s) + else Str(r:Swidth:1,s) + end + else Str(r:Swidth,s); +{ if r>0 then s:=insert('+'s,3);} + r2s:=s; +end; {=r2s=} + +function s2b(s:string):byte; +var e:integer; + b:byte; +begin + Val(s,b,e); + s2b:=b; +end; + +function s2i(s:string):integer; +var e:integer; + i:integer; +begin + Val(s,i,e); + s2i:=i; +end; + +function s2l(s:string):longint; +var e:integer; + l:longint; +begin + Val(s,l,e); + s2l:=l; +end; + +function s2r(s:string):real; +var e:integer; + r:real; +begin + Val(s,r,e); + s2r:=r; +end; + + +function s2bE(s:string):byte; +var e:integer; + b:byte; +begin + s2bE:=0; + Val(s,b,e); + if e>0 then + ConversionError:=e + else s2bE:=b; +end; + +function s2iE(s:string):integer; +var e:integer; + i:integer; +begin + s2iE:=0; + Val(s,i,e); + if e>0 then + ConversionError:=e + else s2iE:=i; +end; + +function s2lE(s:string):longint; +var e:integer; + l:longint; +begin + s2lE:=0; + Val(s,l,e); + if e>0 then + ConversionError:=e + else s2lE:=l; +end; + +function s2rE(s:string):real; +var e:integer; + r:real; +begin + s2rE:=0; + Val(s,r,e); + if e>0 then + ConversionError:=e + else s2rE:=r; +end; + + +function Max0(x1,x2:byte) : byte; +begin +if x1>x2 then + Max0:=x1 +else + Max0:=x2; +end; + +function Min0(x1,x2:byte) : byte; +begin +if x1x2 then + Max0R:=x1 +else + Max0R:=x2; +end; + +function Min0R(x1,x2:real) : real; +begin +if x10 then Sign:=1; + if x<0 then Sign:=-1; +end; + +function TestFlag(Flag:integer; Value:integer):boolean; +begin + if (Flag and Value)=Value then + TestFlag:=True + else TestFlag:=False; +end; + +function SetFlag(var Flag:byte; Value:integer):boolean; +begin + SetFlag:=False; + if Value>0 then + if (Flag and Value)=0 then + begin + Flag:=Flag+Value; + SetFlag:=True + end; + if Value<0 then + if (Flag and Abs(Value))=Abs(Value) then + begin + Flag:=Flag+Value; + SetFlag:=True + end; +end; + +function iSetFlag(var Flag:integer; Value:integer):boolean; +begin + iSetFlag:=False; + if Value>0 then + if (Flag and Value)=0 then + begin + Flag:=Flag+Value; + iSetFlag:=True; //true, gdy było wcześniej 0 i zostało ustawione + end; + if Value<0 then + if (Flag and Abs(Value))=Abs(Value) then + begin + Flag:=Flag+Value; //Value jest ujemne, czyli zerowanie flagi + iSetFlag:=True; //true, gdy było wcześniej 1 i zostało wyzerowane + end; +end; + + +function FuzzyLogic(Test,Threshold,Probability:real):boolean; +begin + if (Test>Threshold) and (not DebugModeFlag) then + FuzzyLogic:=(RandomThreshold) then + FuzzyLogicAI:=(Random'' then + nextword:=True; + if not (c in _Spacesigns) then + s:=s+c; + end; + ReadWord:=s; +end; + + +Function Cut_Space(s:string; Just:integer) : string; +var ii:byte; +begin + case Just of + CutLeft : begin + ii:=0; + while (ii0) and (s[ii]=_SPACE) do + dec(ii); + S:=Copy(s,1,ii); + end; + CutBoth : begin + S:=Cut_Space(S,CutLeft); + S:=Cut_Space(S,CutRight); + end; + end; + Cut_Space:=S; +end; +{Cut_Space} + +Function ExtractKeyWord(InS:String; KeyWord:string) : String; +var s:string; kwp:byte; +begin + Ins:=Ins+' '; + kwp:=Pos(KeyWord,InS); + if kwp>0 then + begin + s:=Copy(InS,kwp,Length(Ins)); + s:=Copy(s,1,Pos(' ',s)-1); + end + else s:=''; + ExtractKeyWord:=s; +end; + +Function DUE(S:String) : String; {Delete Until Equal sign} +begin + DUE:=Copy(S,Pos('=',S)+1,Length(S)); +end; + +Function DWE(S:String) : String; {Delete While Equal sign} +var ep:byte; +begin + ep:=Pos('=',S); + if ep>0 then + DWE:=Copy(S,1,ep-1) + else DWE:=S; +end; + +Function Ld2Sp(S:String): String; {Low dash to Space sign} +var b:byte; s2:string; +begin + s2:=''; + for b:=1 to length(S) do + if S[b]='_' then + s2:=s2+' ' + else + s2:=s2+S[b]; + Ld2Sp:=s2; +end; + +Function Tab2Sp(S:String): String; {Tab to Space sign} +var b:byte; s2:string; +begin + s2:=''; + for b:=1 to length(S) do + if S[b]=#9 then + s2:=s2+' ' + else + s2:=s2+S[b]; + Tab2Sp:=s2; +end; + + +procedure ComputeArc(X0,Y0,Xn,Yn,R,L:real;dL:real; var phi,Xout,Yout:real); +{wylicza polozenie Xout Yout i orientacje phi punktu na elemencie dL luku} +var dX,dY,Xc,Yc,gamma,alfa,AbsR:real; +begin + if (R<>0) and (L<>0) then + begin + AbsR:=Abs(R); + dX:=Xn-X0; + dY:=Yn-Y0; + if dX<>0 then gamma:=arctan(dY/dX) + else if dY>0 then gamma:=Pi/2 + else gamma:=3*Pi/2; + alfa:=L/R; + phi:=gamma-(alfa+Pi*Round(R/AbsR))/2; + Xc:=X0-AbsR*cos(phi); + Yc:=Y0-AbsR*sin(phi); + phi:=phi+alfa*dL/L; + Xout:=AbsR*cos(phi)+Xc; + Yout:=AbsR*sin(phi)+Yc; + end; +end; + +procedure ComputeALine(X0,Y0,Xn,Yn,L,R:real; var Xout,Yout:real); +var dX,dY,gamma,alfa:real; +{ pX,pY : real;} +begin + alfa:=0; //ABu: bo nie bylo zainicjowane + dX:=Xn-X0; + dY:=Yn-Y0; + if dX<>0 then gamma:=arctan(dY/dX) + else if dY>0 then gamma:=Pi/2 + else gamma:=3*Pi/2; + if R<>0 then alfa:=L/R; + Xout:=X0+L*cos(alfa/2-gamma); + Yout:=Y0+L*sin(alfa/2-gamma); +end; + +{graficzne:} + + +function Xhor( h:real) :real; + begin + Xhor:= h*Hstep + Xmin; + end; + +function Yver( v:real) :real; + begin + Yver:= (Vsize-v)*Vstep + Ymin; + end; + +function Horiz(X:real):longint; +begin + x:= (x-Xmin) / Hstep; + if x > -MaxInt then + if x < MaxInt then Horiz:=Round(x) + else Horiz:= MaxInt + else Horiz:= -MaxInt; +end; + +function Vert(Y:real):longint; +begin + y:= (y-Ymin) / Vstep; + if y > -MaxInt then + if y < MaxInt then Vert:=Vsize-Round(y) + else Vert:= MaxInt + else Vert:= -MaxInt +end; + +procedure ClearPendingExceptions; +//resetuje błędy FPU, wymagane dla Trunc() +asm + FNCLEX +end; + +end. \ No newline at end of file diff --git a/McZapkie/mtable.hpp b/McZapkie/mtable.hpp new file mode 100644 index 00000000..03bc55ef --- /dev/null +++ b/McZapkie/mtable.hpp @@ -0,0 +1,127 @@ +// Borland C++ Builder +// Copyright (c) 1995, 1999 by Borland International +// All rights reserved + +// (DO NOT EDIT: machine generated header) 'mtable.pas' rev: 5.00 + +#ifndef mtableHPP +#define mtableHPP + +#pragma delphiheader begin +#pragma option push -w- +#pragma option push -Vx +#include // Pascal unit +#include // Pascal unit +#include // Pascal unit +#include // Pascal unit + +//-- user supplied ----------------------------------------------------------- + +namespace Mtable +{ +//-- type declarations ------------------------------------------------------- +struct TMTableLine +{ + double km; + double vmax; + AnsiString StationName; + AnsiString StationWare; + Byte TrackNo; + int Ah; + int Am; + int Dh; + int Dm; + double tm; + int WaitTime; +} ; + +typedef TMTableLine TMTable[101]; + +class DELPHICLASS TTrainParameters; +typedef TTrainParameters* *PTrainParameters; + +class PASCALIMPLEMENTATION TTrainParameters : public System::TObject +{ + typedef System::TObject inherited; + +public: + AnsiString TrainName; + double TTVmax; + AnsiString Relation1; + AnsiString Relation2; + double BrakeRatio; + AnsiString LocSeries; + double LocLoad; + TMTableLine TimeTable[101]; + int StationCount; + int StationIndex; + AnsiString NextStationName; + double LastStationLatency; + int Direction; + double __fastcall CheckTrainLatency(void); + AnsiString __fastcall ShowRelation(); + double __fastcall WatchMTable(double DistCounter); + AnsiString __fastcall NextStop(); + bool __fastcall IsStop(void); + bool __fastcall IsTimeToGo(double hh, double mm); + bool __fastcall UpdateMTable(double hh, double mm, AnsiString NewName); + __fastcall TTrainParameters(AnsiString NewTrainName); + void __fastcall NewName(AnsiString NewTrainName); + bool __fastcall LoadTTfile(AnsiString scnpath, int iPlus, double vMax); + bool __fastcall DirectionChange(void); + void __fastcall StationIndexInc(void); +public: + #pragma option push -w-inl + /* TObject.Create */ inline __fastcall TTrainParameters(void) : System::TObject() { } + #pragma option pop + #pragma option push -w-inl + /* TObject.Destroy */ inline __fastcall virtual ~TTrainParameters(void) { } + #pragma option pop + +}; + + +class DELPHICLASS TMTableTime; +class PASCALIMPLEMENTATION TMTableTime : public System::TObject +{ + typedef System::TObject inherited; + +public: + double GameTime; + int dd; + int hh; + int mm; + int srh; + int srm; + int ssh; + int ssm; + double mr; + void __fastcall UpdateMTableTime(double deltaT); + __fastcall TMTableTime(int InitH, int InitM, int InitSRH, int InitSRM, int InitSSH, int InitSSM); +public: + + #pragma option push -w-inl + /* TObject.Create */ inline __fastcall TMTableTime(void) : System::TObject() { } + #pragma option pop + #pragma option push -w-inl + /* TObject.Destroy */ inline __fastcall virtual ~TMTableTime(void) { } + #pragma option pop + +}; + + +//-- var, const, procedure --------------------------------------------------- +static const Shortint MaxTTableSize = 0x64; +static const char hrsd = '\x2e'; +extern PACKAGE TMTableTime* GlobalTime; + +} /* namespace Mtable */ +#if !defined(NO_IMPLICIT_NAMESPACE_USE) +using namespace Mtable; +#endif +#pragma option pop // -w- +#pragma option pop // -Vx + +#pragma delphiheader end. +//-- end unit ---------------------------------------------------------------- +#endif // mtable diff --git a/McZapkie/mtable.pas b/McZapkie/mtable.pas new file mode 100644 index 00000000..5d86419e --- /dev/null +++ b/McZapkie/mtable.pas @@ -0,0 +1,521 @@ +unit mtable; + +interface uses mctools,sysutils; + +const MaxTTableSize=100; //można by to robić dynamicznie + hrsd= '.'; +Type +//Ra: pozycja zerowa rozkładu chyba nie ma sensu +//Ra: numeracja przystanków jest 1..StationCount + + TMTableLine=record + km:real; //kilometraz linii + vmax:real; //predkosc rozkladowa przed przystankiem + //StationName:string[32]; //nazwa stacji ('_' zamiast spacji) + //StationWare:string[32]; //typ i wyposazenie stacji, oddz. przecinkami} + StationName:string; //nazwa stacji ('_' zamiast spacji) + StationWare:string; //typ i wyposazenie stacji, oddz. przecinkami} + TrackNo:byte; //ilosc torow szlakowych + Ah,Am:integer; //godz. i min. przyjazdu, -1 gdy bez postoju + Dh,Dm:integer; //godz. i min. odjazdu + tm:real; //czas jazdy do tej stacji w min. (z kolumny) + WaitTime:integer; //czas postoju (liczony plus 6 sekund) + end; + + TMTable = array[0..MaxTTableSize] of TMTableLine; + + PTrainParameters= ^TTrainParameters; + + TTrainParameters = class(TObject) + TrainName:string; + TTVmax:real; + Relation1,Relation2: string; //nazwy stacji danego odcinka + BrakeRatio: real; + LocSeries: string; //seria (typ) pojazdu + LocLoad: real; + TimeTable: TMTable; + StationCount: integer; //ilość przystanków (0-techniczny) + StationIndex: integer; //numer najbliższego (aktualnego) przystanku + NextStationName: string; + LastStationLatency: real; + Direction: integer; {kierunek jazdy w/g kilometrazu} + function CheckTrainLatency: real; + {todo: str hh:mm to int i z powrotem} + function ShowRelation: string; + function WatchMTable(DistCounter:real): real; + function NextStop:string; + function IsStop:boolean; + function IsTimeToGo(hh,mm:real):boolean; + function UpdateMTable(hh,mm:real; NewName: string): boolean; + constructor Init(NewTrainName:string); + procedure NewName(NewTrainName:string); + function LoadTTfile(scnpath:string;iPlus:Integer;vMax:real):boolean; + function DirectionChange():boolean; + procedure StationIndexInc(); + end; + + TMTableTime = class(TObject) + GameTime: real; + dd,hh,mm: integer; + srh,srm : integer; {wschod slonca} + ssh,ssm : integer; {zachod slonca} + mr:real; + procedure UpdateMTableTime(deltaT:real); + constructor Init(InitH,InitM,InitSRH,InitSRM,InitSSH,InitSSM:integer); + end; + +var GlobalTime: TMTableTime; + +implementation + +function CompareTime(t1h,t1m,t2h,t2m:real):real; {roznica czasu w minutach} +//zwraca różnicę czasu +//jeśli pierwsza jest aktualna, a druga rozkładowa, to ujemna oznacza opóżnienie +//na dłuższą metę trzeba uwzględnić datę, jakby opóżnienia miały przekraczać 12h (towarowych) +var + t:real; +begin + if (t2h<0) then + CompareTime:=0 + else + begin + t:=(t2h-t1h)*60+t2m-t1m; //jeśli t2=00:05, a t1=23:50, to różnica wyjdzie ujemna + if (t<-720) then //jeśli różnica przekracza 12h na minus + t:=t+1440 //to dodanie doby minut + else + if (t>720) then //jeśli przekracza 12h na plus + t:=t-1440; //to odjęcie doby minut + CompareTime:=t; + end; +end; + +function TTrainParameters.CheckTrainLatency: real; +begin + if (LastStationLatency>1.0) or (LastStationLatency<-1.0) then + CheckTrainLatency:=LastStationLatency {spoznienie + lub do przodu - z tolerancja 1 min} + else + CheckTrainLatency:=0 +end; + +function TTrainParameters.WatchMTable(DistCounter:real): real; +{zwraca odleglość do najblizszej stacji z zatrzymaniem} +var dist:real; +begin + if Direction=1 then + dist:=TimeTable[StationIndex].km-TimeTable[0].km-DistCounter + else + dist:=TimeTable[0].km-TimeTable[StationIndex].km-DistCounter; + WatchMTable:=dist; +end; + +function TTrainParameters.NextStop:string; +//pobranie nazwy następnego miejsca zatrzymania +begin + if StationIndex<=StationCount + then + NextStop:='PassengerStopPoint:'+NextStationName //nazwa następnego przystanku + else + NextStop:='[End of route]'; //że niby koniec +end; + +function TTrainParameters.IsStop:boolean; +//zapytanie, czy zatrzymywać na następnym punkcie rozkładu +begin + if (StationIndex=0 //-1 to brak postoju + else + IsStop:=true; //na ostatnim się zatrzymać zawsze +end; + +function TTrainParameters.UpdateMTable(hh,mm:real;NewName:string):boolean; +{odfajkowanie dojechania do stacji (NewName) i przeliczenie opóźnienia} +var OK:boolean; +begin + OK:=false; + if StationIndex<=StationCount then //Ra: "<=", bo ostatni przystanek jest traktowany wyjątkowo + begin + if NewName=NextStationName then //jeśli dojechane do następnego + begin //Ra: wywołanie może być powtarzane, jak stoi na W4 + if TimeTable[StationIndex+1].km-TimeTable[StationIndex].km<0 then //to jest bez sensu + Direction:=-1 + else + Direction:=1; //prowizorka bo moze byc zmiana kilometrazu + //ustalenie, czy opóźniony (porównanie z czasem odjazdu) + LastStationLatency:=CompareTime(hh,mm,TimeTable[StationIndex].Dh,TimeTable[StationIndex].Dm); + //inc(StationIndex); //przejście do następnej pozycji StationIndex<=StationCount + if StationIndex'') and (Relation2<>'') + then ShowRelation:=Relation1+' - '+Relation2 + else ShowRelation:=''; +end; + +constructor TTrainParameters.Init(NewTrainName:string); +{wstępne ustawienie parametrów rozkładu jazdy} +begin + NewName(NewTrainName); +end; + +procedure TTrainParameters.NewName(NewTrainName:string); +{wstępne ustawienie parametrów rozkładu jazdy} +var i:integer; +begin + TrainName:=NewTrainName; + StationCount:=0; + StationIndex:=0; + NextStationName:='nowhere'; + LastStationLatency:=0; + Direction:=1; + Relation1:=''; Relation2:=''; + for i:=0 to MaxTTableSize do + with timeTable[i] do + begin + km:=0; vmax:=-1; StationName:='nowhere'; StationWare:=''; + TrackNo:=1; Ah:=-1; Am:=-1; Dh:=-1; Dm:=-1; tm:=0; WaitTime:=0; + end; + TTVmax:=100; {wykasowac} +end; + +function TTrainParameters.LoadTTfile(scnpath:string;iPlus:Integer;vMax:real):boolean; +//wczytanie pliku-tabeli z rozkładem przesuniętym o (fPlus); (vMax) nie ma znaczenia +var + lines,s:string; + fin:text; + EndTable:boolean; + vActual:real; + i,time:Integer; //do zwiększania czasu + +procedure UpdateVelocity(StationCount:integer;vActual:real); +//zapisywanie prędkości maksymalnej do wcześniejszych odcinków +//wywoływane z numerem ostatniego przetworzonego przystanku +var i:integer; +begin + i:=StationCount; + //TTVmax:=vActual; {PROWIZORKA!!!} + while (i>=0) and (TimeTable[i].vmax=-1) do + begin + TimeTable[i].vmax:=vActual; //prędkość dojazdu do przystanku i + dec(i); //ewentualnie do poprzedniego też + end; +end; + +begin + ClearPendingExceptions; + ConversionError:=0; + EndTable:=False; + if (TrainName='') then + begin //jeśli pusty rozkład + //UpdateVelocity(StationCount,vMax); //ograniczenie do prędkości startowej + end + else + begin + ConversionError:=666; + vActual:=-1; + s:=scnpath+TrainName+'.txt'; + //Ra 2014-09: ustalić zasady wyznaczenia pierwotnego pliku przy przesuniętych rozkładach (kolejny pociąg dostaje numer +2) + assignfile(fin,s); + s:=''; + {$I-} + reset(fin); + {$I+} + if IOresult<>0 then + begin + vMax:=s2r(TrainName); //nie ma pliku ale jest liczba + if (vMax>10)and(vMax<200) then + begin + TTVmax:=vMax; //Ra 2014-07: zamiast rozkładu można podać Vmax + UpdateVelocity(StationCount,vMax); //ograniczenie do prędkości startowej + ConversionError:=0; + end + else + ConversionError:=-8; {Ra: ten błąd jest niepotrzebny} + end + else + begin {analiza rozkładu jazdy} + ConversionError:=0; + while not (eof(fin) or (ConversionError<>0) or EndTable) do + begin + readln(fin,lines); {wczytanie linii} + if Pos('___________________',lines)>0 then {linia pozioma górna} + if ReadWord(fin)='[' then {lewy pion} + if ReadWord(fin)='Rodzaj' then {"Rodzaj i numer pociagu"} + repeat + until (ReadWord(fin)='|') or (eof(fin)); {środkowy pion} + s:=ReadWord(fin); {nazwa pociągu} + //if LowerCase(s)<>ExtractFileName(TrainName) then {musi być taka sama, jak nazwa pliku} + //ConversionError:=-7 {błąd niezgodności} + TrainName:=s; //nadanie nazwy z pliku TXT (bez ścieżki do pliku) + //else + begin {czytaj naglowek} + repeat + until (Pos('_______|',ReadWord(fin))>0) or eof(fin); + repeat + until (ReadWord(fin)='[') or (eof(fin)); {pierwsza linia z relacją} + repeat + s:=ReadWord(fin); + until (s<>'|') or eof(fin); + if s<>'|' then Relation1:=s + else ConversionError:=-5; + repeat + until (Readword(fin)='Relacja') or (eof(fin)); {druga linia z relacją} + repeat + until (ReadWord(fin)='|') or (eof(fin)); + Relation2:=ReadWord(fin); + repeat + until Readword(fin)='Wymagany'; + repeat + until (ReadWord(fin)='|') or (eoln(fin)); + s:=ReadWord(fin); + s:=Copy(s,1,Pos('%',s)-1); + BrakeRatio:=s2rE(s); + repeat + until Readword(fin)='Seria'; + repeat + until (ReadWord(fin)='|') or (eof(fin)); + LocSeries:=ReadWord(fin); + LocLoad:=s2rE(ReadWord(fin)); + repeat + until (Pos('[______________',ReadWord(fin))>0) or (eof(fin)); + while not eof(fin) and not EndTable do + begin + inc(StationCount); + repeat + s:=ReadWord(fin); + until (s='[') or (eof(fin)); + with TimeTable[StationCount] do + begin + if s='[' then + s:=ReadWord(fin) + else ConversionError:=-4; + if Pos('|',s)=0 then + begin + km:=s2rE(s); + s:=ReadWord(fin); + end; + if Pos('|_____|',s)>0 then {zmiana predkosci szlakowej} + UpdateVelocity(StationCount,vActual) + else + begin + s:=ReadWord(fin); + if Pos('|',s)=0 then + vActual:=s2rE(s); + end; + while Pos('|',s)=0 do + s:=Readword(fin); + StationName:=ReadWord(fin); + repeat + s:=ReadWord(fin); + until (s='1') or (s='2') or eof(fin); + TrackNo:=s2bE(s); + s:=ReadWord(fin); + if s<>'|' then + begin + if Pos(hrsd,s)>0 then + begin + ah:=s2iE(Copy(s,1,Pos(hrsd,s)-1)); //godzina przyjazdu + am:=s2iE(Copy(s,Pos(hrsd,s)+1,Length(s))); //minuta przyjazdu + end + else + begin + ah:=TimeTable[StationCount-1].ah; //godzina z poprzedniej pozycji + am:=s2iE(s); //bo tylko minuty podane + end; + end; + repeat + s:=ReadWord(fin); + until (s<>'|') or (eof(fin)); + if s<>']' then + tm:=s2rE(s); + repeat + s:=ReadWord(fin); + until (s='[') or eof(fin); + s:=ReadWord(fin); + if Pos('|',s)=0 then + begin +{tu s moze byc miejscem zmiany predkosci szlakowej} + s:=ReadWord(fin); + end; + if Pos('|_____|',s)>0 then {zmiana predkosci szlakowej} + UpdateVelocity(StationCount,vActual) + else + begin + s:=ReadWord(fin); + if Pos('|',s)=0 then + vActual:=s2rE(s); + end; + while Pos('|',s)=0 do + s:=Readword(fin); + StationWare:=ReadWord(fin); + repeat + s:=ReadWord(fin); + until (s='1') or (s='2') or eof(fin); + TrackNo:=s2bE(s); + s:=ReadWord(fin); + if s<>'|' then + begin + if Pos(hrsd,s)>0 then + begin + dh:=s2iE(Copy(s,1,Pos(hrsd,s)-1)); //godzina odjazdu + dm:=s2iE(Copy(s,Pos(hrsd,s)+1,Length(s))); //minuta odjazdu + end + else + begin + dh:=TimeTable[StationCount-1].dh; //godzina z poprzedniej pozycji + dm:=s2iE(s); //bo tylko minuty podane + end; + end + else + begin + dh:=ah; //odjazd o tej samej, co przyjazd (dla ostatniego też) + dm:=am; //bo są używane do wyliczenia opóźnienia po dojechaniu + end; + if (ah>=0) then + WaitTime:=Trunc(CompareTime(ah,am,dh,dm)+0.1); + repeat + s:=ReadWord(fin); + until (s<>'|') or (eof(fin)); + if s<>']' then + tm:=s2rE(s); + repeat + s:=ReadWord(fin); + until (Pos('[',s)>0) or eof(fin); + if Pos('_|_',s)=0 then + s:=Readword(fin); + if Pos('|',s)=0 then + begin +{tu s moze byc miejscem zmiany predkosci szlakowej} + s:=ReadWord(fin); + end; + if Pos('|_____|',s)>0 then {zmiana predkosci szlakowej} + UpdateVelocity(StationCount,vActual) + else + begin + s:=ReadWord(fin); + if Pos('|',s)=0 then + vActual:=s2rE(s); + end; + while Pos('|',s)=0 do + s:=Readword(fin); + while (Pos(']',s)=0) do + s:=ReadWord(fin); + if Pos('_|_',s)>0 then EndTable:=True; + end; {timetableline} + end; + end; + end; {while eof} + close(fin); + end; + end; + if ConversionError=0 then + begin + if (TimeTable[1].StationName=Relation1) then //jeśli nazwa pierwszego zgodna z relacją + if (TimeTable[1].Ah<0) then //a nie podany czas przyjazdu + begin //to mamy zatrzymanie na pierwszym, a nie przelot + TimeTable[1].Ah:=TimeTable[1].Dh; + TimeTable[1].Am:=TimeTable[1].Dm; + end + //NextStationName:=TimeTable[1].StationName; +{ TTVmax:=TimeTable[1].vmax; } + end; + if (iPlus<>0) then //jeżeli jest przesunięcie rozkładu + for i:=1 to StationCount do //bez with, bo ciężko się przenosi na C++ + begin + if (TimeTable[i].Ah>=0) then + begin + time:=iPlus+TimeTable[i].Ah*60+TimeTable[i].Am; //nowe minuty + TimeTable[i].Am:=time mod 60; + TimeTable[i].Ah:=(time div 60) mod 60; + end; + if (TimeTable[i].Dh>=0) then + begin + time:=iPlus+TimeTable[i].Dh*60+TimeTable[i].Dm; //nowe minuty + TimeTable[i].Dm:=time mod 60; + TimeTable[i].Dh:=(time div 60) mod 60; + end; + end; + LoadTTfile:=(ConversionError=0); +end; + +procedure TMTableTime.UpdateMTableTime(deltaT:real); +//dodanie czasu (deltaT) w sekundach, z przeliczeniem godziny +begin + mr:=mr+deltaT; //dodawanie sekund + while mr>60.0 do //przeliczenie sekund do właściwego przedziału + begin + mr:=mr-60.0; + inc(mm); + end; + while mm>59 do //przeliczenie minut do właściwego przedziału + begin + mm:=mm-60; + inc(hh); + end; + while hh>23 do //przeliczenie godzin do właściwego przedziału + begin + hh:=hh-24; + inc(dd); //zwiększenie numeru dnia + end; + GameTime:=GameTime+deltaT; +end; + +constructor TMTableTime.Init(InitH,InitM,InitSRH,InitSRM,InitSSH,InitSSM:integer); +begin + GameTime:=0.0; + dd:=0; + hh:=InitH; + mm:=InitM; + srh:=InitSRH; + srm:=InitSRM; + ssh:=InitSSH; + ssm:=InitSSM; +end; + +function TTrainParameters.DirectionChange():boolean; +//sprawdzenie, czy po zatrzymaniu wykonać kolejne komendy +begin + DirectionChange:=false; //przed pierwszą bez zmiany + if (StationIndex>0) and (StationIndex0) then + DirectionChange:=true; +end; + + +END. + diff --git a/McZapkie/unit2.pas b/McZapkie/unit2.pas new file mode 100644 index 00000000..6c430de4 --- /dev/null +++ b/McZapkie/unit2.pas @@ -0,0 +1,338 @@ +unit Unit1; + +interface + +uses + ai_driver,mtable,mover,mctools,Windows, Messages, SysUtils, Classes, Graphics, Controls, Forms, Dialogs, + StdCtrls, ExtCtrls; + +type + TForm1 = class(TForm) + Button1: TButton; + Label1: TLabel; + Button2: TButton; + Button3: TButton; + Button4: TButton; + Button5: TButton; + Button6: TButton; + Label2: TLabel; + Label3: TLabel; + Timer1: TTimer; + Label4: TLabel; + Label5: TLabel; + Label6: TLabel; + Label7: TLabel; + Label8: TLabel; + Label9: TLabel; + Label10: TLabel; + Label11: TLabel; + Button7: TButton; + Button8: TButton; + Label12: TLabel; + Label13: TLabel; + Label14: TLabel; + Label15: TLabel; + Button9: TButton; + Button10: TButton; + Label16: TLabel; + Label17: TLabel; + Label18: TLabel; + Label19: TLabel; + Button11: TButton; + Label20: TLabel; + Label21: TLabel; + Label22: TLabel; + Label23: TLabel; + Label24: TLabel; + Label25: TLabel; + lczas: TLabel; + Label26: TLabel; + Label27: TLabel; + Label28: TLabel; + Label29: TLabel; + Label30: TLabel; + Label31: TLabel; + Label32: TLabel; + Label33: TLabel; + Label34: TLabel; + Button12: TButton; + BStart: TButton; + Label35: TLabel; + Label36: TLabel; + Label37: TLabel; + Label38: TLabel; + Button13: TButton; + Label39: TLabel; + Label40: TLabel; + Label41: TLabel; + Button14: TButton; + Button15: TButton; + Label42: TLabel; + Label43: TLabel; + procedure Button1Click(Sender: TObject); + procedure Button2Click(Sender: TObject); + procedure Timer1Timer(Sender: TObject); + procedure FormCreate(Sender: TObject); + procedure Button5Click(Sender: TObject); + procedure Button6Click(Sender: TObject); + procedure Button7Click(Sender: TObject); + procedure Button8Click(Sender: TObject); + procedure Button3Click(Sender: TObject); + procedure Button4Click(Sender: TObject); + procedure Button9Click(Sender: TObject); + procedure Button10Click(Sender: TObject); + procedure Button11Click(Sender: TObject); + procedure Button12Click(Sender: TObject); + procedure BStartClick(Sender: TObject); + procedure Button13MouseDown(Sender: TObject; Button: TMouseButton; + Shift: TShiftState; X, Y: Integer); + procedure Button14Click(Sender: TObject); + procedure Button15Click(Sender: TObject); + private + { Private declarations } + public + { Public declarations } + end; + +var +Form1: TForm1; +loc,wag,wag2,wag3:TMoverParameters; +mechanik: TController; +pociag: TTrainParameters; +l0,l1,l2,l3:TLocation; +r0,r1,r2,r3:TRotation; +Shape:TTrackShape; Track:TTrackParam; +ExternalVoltage:real; +ActualTime:real; +fout: text; + +implementation + +{$R *.DFM} + +procedure TForm1.Button1Click(Sender: TObject); +begin +assignfile(fout,'log.dat'); +rewrite(fout); +ActualTime:=0; +loc:=TMoverParameters.Create; +wag:=TMoverParameters.Create; +wag2:=TMoverParameters.Create; +wag3:=TMoverParameters.Create; +mechanik:=TController.Create; +pociag:=TTrainParameters.Create; +Shape.R:=0; Shape.Len:=10000; Shape.dHtrack:=0; Shape.dHrail:=0; +Track.Width:=1435; Track.friction:=0.15; Track.CategoryFlag:=1; +Track.QualityFlag:=25; Track.DamageFlag:=0; +Track.VelMax:=120; +ExternalVoltage:=3000; + l0.x:=0; l0.y:=0; l0.z:=0; + l1.x:=-14.0235; l1.y:=0; l1.z:=0; + l2.x:=-27.3634; l2.y:=0; l2.z:=0; + l3.x:=-40.7032; l3.y:=0; l3.z:=0; + r0.rx:=0; r0.ry:=0; r0.rz:=0; + r1.rx:=0; r1.ry:=0; r1.rz:=0; + r2.rx:=0; r2.ry:=0; r2.rz:=0; + r3.rx:=0; r3.ry:=0; r3.rz:=0; +{ loc.Init(l1,r1,0,'en57','456',0,'Human',1); } + loc.Init(l0,r0,60,'eu07','456',0,'',1); + wag.Init(l1,r1,60,'Falns_440v','52-51-342027-2',30,'',0); + wag2.Init(l2,r2,60,'Falns_440v','52-51-322311-5',30,'',0); + wag3.Init(l3,r3,60,'Falns_440v','52-51-410025-3',30,'',0); + pociag.init('Testowy Express',100); + mechanik.init(l1,r1,True,@loc,@pociag,Aggressive); + if (loc.loadchkfile('') and wag.loadchkfile('') and wag2.loadchkfile('') and wag3.loadchkfile('')) + and (loc.CheckLocomotiveParameters(Go) and wag.CheckLocomotiveParameters(Go) and wag2.CheckLocomotiveParameters(Go) and wag3.CheckLocomotiveParameters(Go)) then + begin + Label1.Caption:='OK'; + loc.attach(2,@wag,3); + wag.attach(1,@loc,3); + wag.attach(2,@wag2,3); + wag2.attach(1,@wag,3); + wag2.attach(2,@wag3,3); + wag3.attach(1,@wag2,3); + Timer1.Enabled:=True; + end + else Label1.Caption:=inttostr(conversionerror)+' '+inttostr(linecount); + Button1.Visible:=False; +end; + +procedure TForm1.Button2Click(Sender: TObject); +begin + if Timer1.Enabled then + begin + Timer1.Enabled:=False; + CloseFile(fout); + end; + loc.Free; + wag.Free; + wag2.free; + wag3.free; + mechanik.free; + Close; +end; + +procedure TForm1.Timer1Timer(Sender: TObject); +var dl,dt:real; +begin + dt:=Timer1.Interval/1000; + ActualTime:=ActualTime+dt; + loc.ComputeTotalForce(dt,Shape,Track,ExternalVoltage); + wag.ComputeTotalForce(dt,Shape,Track,ExternalVoltage); + wag2.ComputeTotalForce(dt,Shape,Track,ExternalVoltage); + wag3.ComputeTotalForce(dt,Shape,Track,ExternalVoltage); + dl:=loc.ComputeMovement(dt,Shape,Track,ExternalVoltage,l0,r0); + l0.x:=l0.x+dl; + dl:=wag.ComputeMovement(dt,Shape,Track,ExternalVoltage,l1,r1); + l1.x:=l1.x+dl; + dl:=wag2.ComputeMovement(dt,Shape,Track,ExternalVoltage,l2,r2); + l2.x:=l2.x+dl; + dl:=wag3.ComputeMovement(dt,Shape,Track,ExternalVoltage,l3,r3); + l3.x:=l3.x+dl; + + if l0.x<500 then mechanik.UpdateSituation(500-l0.x,dt) + else + if l0.x<2500 then mechanik.UpdateSituation(-1,dt) + else + if l0.x<3500 then mechanik.UpdateSituation(3500-l0.x,dt); + if (l0.x>499) and (l0.x<505) then + mechanik.SetVelocity(-1,-1,0); + if (l0.x>2499) and (l0.x<2510) then + mechanik.SetVelocity(-1,0,0); + + Label2.Caption:=r2s(Loc.Im,0)+' A'; + Label3.Caption:=r2s(Loc.Ft/1000,0)+' kN'; + Label4.Caption:=r2s(l0.x,0)+' m'; + Label5.Caption:=r2s(Sign(Loc.V)*Loc.Vel,0)+' km/h'; + Label6.Caption:=r2s(Loc.AccS,0)+' m/ss'; + Label7.Caption:=r2s(Loc.couplers[1].cforce/1000,0)+' kN'; + Label8.Caption:=r2s(Loc.couplers[2].cforce/1000,0)+' kN'; + Label9.Caption:=r2s(Loc.Fb/1000,0)+' kN'; + Label10.Caption:=r2s(Loc.Compressor,0)+' MPa'; + Label11.Caption:=r2s(Loc.PipePress,0)+' MPa'; + Label12.Caption:=r2s(Loc.BrakePress,0)+' MPa'; + + Label13.Caption:=IntToStr(Loc.MainCtrlPos); + Label14.Caption:=IntToStr(Loc.BrakeCtrlPos); + Label15.Caption:=IntToStr(Loc.LocalBrakePos); + + Label16.Caption:=IntToStr(Loc.showcurrent(1)); + Label17.Caption:=IntToStr(Loc.showcurrent(2)); + Label18.Caption:=IntToStr(Loc.ScndCtrlPos); + if loc.SlippingWheels then + Label19.Caption:='Poslizg!' + else Label19.Caption:=' '; + + Label20.Caption:=IntToStr(Loc.MainCtrlActualPos); + Label21.Caption:=IntToStr(Loc.ScndCtrlActualPos); + + Label22.Caption:=r2s(l1.x,0)+' m'; + Label23.Caption:=r2s(Sign(wag.V)*wag.Vel,0)+' km/h'; + Label24.Caption:=r2s(Distance(loc.loc,wag.loc,loc.dim,wag.dim),0)+' m'; + Label25.Caption:=r2s(loc.nrot,0)+' 1/s'; + + Label26.Caption:=r2s(wag.couplers[1].cforce/1000,0)+' kN'; + Label27.Caption:=r2s(wag.couplers[2].cforce/1000,0)+' kN'; + + Label28.Caption:=r2s(l2.x,0)+' m'; + Label29.Caption:=r2s(sign(wag2.V)*wag2.Vel,0)+' km/h'; + + Label30.Caption:=r2s(loc.dpLocalValve/dt,0)+' MPa/s'; + Label31.Caption:=r2s(loc.dpBrake/dt,0)+' MPa/s'; + Label32.Caption:=r2s(loc.dpMainValve/dt,0)+' MPa/s'; + Label33.Caption:=r2s(loc.dpPipe/dt,0)+' MPa/s'; + + Label34.Caption:=r2s(wag2.PipePress,0)+' MPa'; + + Label35.Caption:=r2s(l3.x,0)+' m'; + Label36.Caption:=r2s(sign(wag3.V)*wag3.Vel,0)+' km/h'; + Label37.Caption:=r2s(wag3.couplers[1].cforce/1000,0)+' kN'; + Label38.Caption:=r2s(wag3.brakepress,0)+' MPa'; + + Label39.Caption:=r2s(loc.enginePower/1000,0)+' kW'; + Label40.Caption:=i2s(trunc(loc.Rventrot*60))+' /min'; + Label41.Visible:=loc.SandDose; + Label42.Caption:=r2s(mechanik.accdesired,0)+' m/ss'; + Label43.Caption:=r2s(mechanik.veldesired,0)+' km/h'; + Lczas.Caption:=r2s(actualtime,0)+' s'; +end; + +procedure TForm1.FormCreate(Sender: TObject); +begin + Timer1.Enabled:=False; +end; + +procedure TForm1.Button5Click(Sender: TObject); +begin + loc.incbrakelevel(1); +end; + +procedure TForm1.Button6Click(Sender: TObject); +begin + loc.decbrakelevel(1); +end; + +procedure TForm1.Button7Click(Sender: TObject); +begin + loc.inclocalbrakelevel(1); +end; + +procedure TForm1.Button8Click(Sender: TObject); +begin + loc.declocalbrakelevel(1); +end; + +procedure TForm1.Button3Click(Sender: TObject); +begin + loc.incmainctrl(1); +end; + +procedure TForm1.Button4Click(Sender: TObject); +begin + loc.decmainctrl(1); +end; + +procedure TForm1.Button9Click(Sender: TObject); +begin +loc.DirectionForward; +end; + +procedure TForm1.Button10Click(Sender: TObject); +begin + loc.DirectionBackward; +end; + +procedure TForm1.Button11Click(Sender: TObject); +begin + loc.FuseOn; +end; + +procedure TForm1.Button12Click(Sender: TObject); +begin + Loc.AntiSlippingBrake; +end; + +procedure TForm1.BStartClick(Sender: TObject); +begin + loc.activedir:=1; +{ if mechanik.OrderDirectionChange(1) then } + mechanik.SetVelocity(60,0,0); +end; + +procedure TForm1.Button13MouseDown(Sender: TObject; Button: TMouseButton; + Shift: TShiftState; X, Y: Integer); +begin + loc.SandDoseOn; +end; + +procedure TForm1.Button14Click(Sender: TObject); +begin + mechanik.SetVelocity(30,120,0); +end; + +procedure TForm1.Button15Click(Sender: TObject); +begin + mechanik.SetVelocity(0,120,0); +end; + +end. diff --git a/MdlMngr.cpp b/MdlMngr.cpp new file mode 100644 index 00000000..e7ab9024 --- /dev/null +++ b/MdlMngr.cpp @@ -0,0 +1,182 @@ +//--------------------------------------------------------------------------- + +/* + MaSzyna EU07 locomotive simulator + Copyright (C) 2001-2004 Marcin Wozniak and others + +*/ + +#include "system.hpp" +#include "classes.hpp" +#include "Texture.h" +#pragma hdrstop + +#include "MdlMngr.h" +#include "Globals.h" + +#define SeekFiles AnsiString("*.t3d") + +TModel3d* __fastcall TMdlContainer::LoadModel(char *newName,bool dynamic) +{//wczytanie modelu do kontenerka + SafeDeleteArray(Name); + SafeDelete(Model); + Name=new char[strlen(newName)+1]; + strcpy(Name,newName); + Model=new TModel3d(); + if (!Model->LoadFromFile(Name,dynamic)) //np. "models\\pkp/head1-y.t3d" + SafeDelete(Model); + return Model; +}; + +TMdlContainer *TModelsManager::Models; +int TModelsManager::Count; +const MAX_MODELS=1000; + +void __fastcall TModelsManager::Init() +{ + Models=new TMdlContainer[MAX_MODELS]; + Count=0; +} +/* +__fastcall TModelsManager::TModelsManager() +{ +// Models= NULL; + Models= new TMdlContainer[MAX_MODELS]; + Count= 0; +}; + +__fastcall TModelsManager::~TModelsManager() +{ + Free(); +}; + */ +void __fastcall TModelsManager::Free() +{ + SafeDeleteArray(Models); +} + + +TModel3d* __fastcall TModelsManager::LoadModel(char *Name,bool dynamic) +{//wczytanie modelu do tablicy + TModel3d *mdl=NULL; + if (Count>=MAX_MODELS) + Error("FIXME: Too many models, program will now crash :)"); + else + { + mdl=Models[Count].LoadModel(Name,dynamic); + if (mdl) Count++; //jeśli błąd wczytania modelu, to go nie wliczamy + } + return mdl; +} + +TModel3d* __fastcall TModelsManager::GetModel(const char *Name,bool dynamic) +{//model może być we wpisie "node...model" albo "node...dynamic", a także być dodatkowym w dynamic (kabina, wnętrze, ładunek) + //dla "node...dynamic" mamy podaną ścieżkę w "\dynamic\" i musi być co najmniej 1 poziom, zwkle są 2 + //dla "node...model" może być typowy model statyczny ze ścieżką, domyślnie w "\scenery\" albo "\models" + //albo może być model z "\dynamic\", jeśli potrzebujemy wstawić auto czy wagon nieruchomo + // - ze ścieżki z której jest wywołany, np. dir="scenery\bud\" albo dir="dynamic\pkp\st44_v1\" plus name="model.t3d" + // - z domyślnej ścieżki dla modeli, np. "scenery\" albo "models\" plus name="bud\dombale.t3d" (dir="") + // - konkretnie podanej ścieżki np. name="\scenery\bud\dombale.t3d" (dir="") + //wywołania: + // - konwersja wszystkiego do E3D, podawana dokładna ścieżka, tekstury tam, gdzie plik + // - wczytanie kabiny, dokładna ścieżka, tekstury z katalogu modelu + // - wczytanie ładunku, ścieżka dokładna, tekstury z katalogu modelu + // - wczytanie modelu, ścieżka dokładna, tekstury z katalogu modelu + // - wczytanie przedsionków, ścieżka dokładna, tekstury z katalogu modelu + // - wczytanie uproszczonego wnętrza, ścieżka dokładna, tekstury z katalogu modelu + // - niebo animowane, ścieżka brana ze wpisu, tekstury nieokreślone + // - wczytanie modelu animowanego - Init() - sprawdzić + char buf[255]; + AnsiString buftp=Global::asCurrentTexturePath; //zapamiętanie aktualnej ścieżki do tekstur, bo będzie tyczmasowo zmieniana +/* +// Ra: niby tak jest lepiej, ale działa gorzej, więc przywrócone jest oryginalne + //nawet jeśli model będzie pobrany z tablicy, to trzeba ustalić ścieżkę dla tekstur + if (dynamic) //na razie tak, bo nie wiadomo, jaki może mieć wpływ na pozostałe modele + {//dla pojazdów podana jest zawsze pełna ścieżka do modelu + strcpy(buf,Name); + if (strchr(Name,'/')!=NULL) + {//pobieranie tekstur z katalogu, w którym jest model + Global::asCurrentTexturePath=Global::asCurrentTexturePath+AnsiString(Name); + Global::asCurrentTexturePath.Delete(Global::asCurrentTexturePath.Pos("/")+1,Global::asCurrentTexturePath.Length()); + } + } + else + {//dla modeli scenerii trzeba ustalić ścieżkę + if (strchr(Name,'\\')==NULL) + {//jeśli nie ma lewego ukośnika w ścieżce, a jest prawy, to zmienić ścieżkę dla tekstur na tę z modelem + strcpy(buf,"models\\"); //Ra: było by lepiej katalog dodać w parserze + //strcpy(buf,"scenery\\"); //Ra: było by lepiej katalog dodać w parserze + strcat(buf,Name); + if (strchr(Name,'/')!=NULL) + {//jeszcze musi być prawy ukośnik + Global::asCurrentTexturePath=Global::asCurrentTexturePath+AnsiString(Name); + Global::asCurrentTexturePath.Delete(Global::asCurrentTexturePath.Pos("/")+1,Global::asCurrentTexturePath.Length()); + } + } + else + {//jeśli jest lewy ukośnik, to ścieżkę do tekstur zmienić tylko dla pojazdów + strcpy(buf,Name); + } + } + StrLower(buf); + for (int i=0;igetTokens(1,false); //case sensitive + *parser >> token; + SafeDeleteArray(szText); + szText=new char[256]; //musi być bufor do łączenia tekstów + strcpy(szText,token.c_str()); + parser->getTokens(); + *parser >> fValue1; + parser->getTokens(); + *parser >> fValue2; + parser->getTokens(); + *parser >> token; + if (token.compare("none")!=0) //gdy różne od "none" + asTrackName=AnsiString(token.c_str()); //sprawdzane przez IsEmpty() + parser->getTokens(); + *parser >> token; + if (token.compare("endmemcell")!=0) + Error("endmemcell statement missing"); + CommandCheck(); + return true; +} + +void __fastcall TMemCell::PutCommand(TController *Mech, vector3 *Loc) +{//wysłanie zawartości komórki do AI + if (Mech) + Mech->PutCommand(szText,fValue1,fValue2,Loc); +} + +bool __fastcall TMemCell::Compare(char *szTestText,double fTestValue1,double fTestValue2,int CheckMask) +{//porównanie zawartości komórki pamięci z podanymi wartościami + if (TestFlag(CheckMask,conditional_memstring)) + {//porównać teksty + char *pos=StrPos(szTestText,"*"); //zwraca wskaźnik na pozycję albo NULL + if (pos) + {//porównanie fragmentu łańcucha + int i=pos-szTestText; //ilość porównywanych znaków + if (i) //jeśli nie jest pierwszym znakiem + if (AnsiString(szTestText,i)!=AnsiString(szText,i)) + return false; //początki o długości (i) są różne + } + else + if (AnsiString(szTestText)!=AnsiString(szText)) + return false; //łąńcuchy są różne + } + //tekst zgodny, porównać resztę + return ((!TestFlag(CheckMask,conditional_memval1) || (fValue1==fTestValue1)) && + (!TestFlag(CheckMask,conditional_memval2) || (fValue2==fTestValue2))); +}; + +bool __fastcall TMemCell::Render() +{ + return true; +} + +bool __fastcall TMemCell::IsVelocity() +{//sprawdzenie, czy event odczytu tej komórki ma być do skanowania, czy do kolejkowania + if (eCommand==cm_SetVelocity) return true; + if (eCommand==cm_ShuntVelocity) return true; + return (eCommand==cm_SetProximityVelocity); +}; + +void __fastcall TMemCell::StopCommandSent() +{// + if (!bCommand) return; + bCommand=false; + if (OnSent) //jeśli jest event + Global::AddToQuery(OnSent,NULL); +}; + +void __fastcall TMemCell::AssignEvents(TEvent *e) +{//powiązanie eventu + OnSent=e; +}; diff --git a/MemCell.h b/MemCell.h new file mode 100644 index 00000000..5b637bf9 --- /dev/null +++ b/MemCell.h @@ -0,0 +1,43 @@ +//--------------------------------------------------------------------------- + +#ifndef MemCellH +#define MemCellH + +#include "Classes.h" +#include "dumb3d.h" +using namespace Math3D; + +class TMemCell +{ +private: + vector3 vPosition; + char *szText; + double fValue1; + double fValue2; + TCommandType eCommand; + bool bCommand; //czy zawiera komendę dla zatrzymanego AI + TEvent *OnSent; //event dodawany do kolejki po wysłaniu komendy zatrzymującej skład +public: + AnsiString asTrackName; //McZapkie-100302 - zeby nazwe toru na ktory jest Putcommand wysylane pamietac + __fastcall TMemCell(vector3 *p); + __fastcall ~TMemCell(); + void __fastcall Init(); + void __fastcall UpdateValues(char *szNewText, double fNewValue1, double fNewValue2, int CheckMask); + bool __fastcall Load(cParser *parser); + void __fastcall PutCommand(TController *Mech, vector3 *Loc); + bool __fastcall Compare(char *szTestText, double fTestValue1, double fTestValue2, int CheckMask); + bool __fastcall Render(); + inline char* __fastcall Text() {return szText;}; + inline double __fastcall Value1() {return fValue1;}; + inline double __fastcall Value2() {return fValue2;}; + inline vector3 __fastcall Position() {return vPosition;}; + inline TCommandType __fastcall Command() {return eCommand;}; + inline bool __fastcall StopCommand() {return bCommand;}; + void __fastcall StopCommandSent(); + TCommandType __fastcall CommandCheck(); + bool __fastcall IsVelocity(); + void __fastcall AssignEvents(TEvent *e); +}; + +//--------------------------------------------------------------------------- +#endif diff --git a/Model3d.cpp b/Model3d.cpp new file mode 100644 index 00000000..b29087c5 --- /dev/null +++ b/Model3d.cpp @@ -0,0 +1,2077 @@ +//--------------------------------------------------------------------------- +/* + 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;idata+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;iPoint==*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 +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 (eType1.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 (eType0"); + 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;i0) //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=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> 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 (eType0) + { + 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;iDisplayLists(); + 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;iIdentity(); //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;iInitialRotate(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) && (fSquareDistreadArray()); + if (b_Anim) RaAnimation(b_Anim); + } + if (eTypefCosFalloffAngle) //kąt większy niż maksymalny stożek swiatła + { + double Distdimm=1.0; + if (fCosViewAngle0) + 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::fLuminanceRenderDL(); + if (iFlags&0xC000) + glPopMatrix(); + } + if (b_AnimRenderDL(); //dalsze rekurencyjnie +}; //Render + +void __fastcall TSubModel::RenderAlphaDL() +{//renderowanie przezroczystych przez DL + if (iVisible && (fSquareDist>=fSquareMinDist) && (fSquareDistreadArray()); + if (b_aAnim) RaAnimation(b_aAnim); + } + if (eTypeLength(); + 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_aAnimRenderAlphaDL(); +}; //RenderAlpha + +void __fastcall TSubModel::RenderVBO() +{//główna procedura renderowania przez VBO + if (iVisible && (fSquareDist>=fSquareMinDist) && (fSquareDistreadArray()); + if (b_Anim) RaAnimation(b_Anim); + } + if (eTypefCosFalloffAngle) //kąt większy niż maksymalny stożek swiatła + { + double Distdimm=1.0; + if (fCosViewAngle.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::fLuminanceEndVBO(); //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_AnimRenderVBO(); //dalsze rekurencyjnie +}; //RaRender + +void __fastcall TSubModel::RenderAlphaVBO() +{//renderowanie przezroczystych przez VBO + if (iVisible && (fSquareDist>=fSquareMinDist) && (fSquareDistreadArray()); + if (b_aAnim) RaAnimation(b_aAnim); + } + glColor3fv(f4Diffuse); + if (eTypeRenderAlphaVBO(); + if (iFlags&0xC000) + glPopMatrix(); + } + if (b_aAnimRenderAlphaVBO(); +}; //RaRenderAlpha + +//--------------------------------------------------------------------------- + +void __fastcall TSubModel::RaArrayFill(CVertNormTex *Vert) +{//wypełnianie tablic VBO + if (Child) Child->RaArrayFill(Vert); + if ((eTypeRaArrayFill(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;iiCurrent;++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;iChildAdd(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;iGetFromName(sName):NULL; + } +}; + +/* +TMaterial* __fastcall TModel3d::GetMaterialFromName(char *sName) +{ + AnsiString tmp=AnsiString(sName).Trim(); + for (int i=0; i0):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)>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>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>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;iParent=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;iasName,*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;iInfoSet(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=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;iWrite(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;iWrite(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 (iNextGet(); + ++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(); +}; + diff --git a/Model3d.h b/Model3d.h new file mode 100644 index 00000000..287bd2ff --- /dev/null +++ b/Model3d.h @@ -0,0 +1,365 @@ +//--------------------------------------------------------------------------- +#ifndef Model3dH +#define Model3dH + +#include "opengl/glew.h" +#include "Parser.h" +#include "dumb3d.h" +using namespace Math3D; +#include "Float3d.h" +#include "VBO.h" + +struct GLVERTEX +{ + vector3 Point; + vector3 Normal; + float tu,tv; +}; + +class TStringPack +{ + char *data; + //+0 - 4 bajty: typ kromki + //+4 - 4 bajty: długość łącznie z nagłówkiem + //+8 - obszar łańcuchów znakowych, każdy zakończony zerem + int *index; + //+0 - 4 bajty: typ kromki + //+4 - 4 bajty: długość łącznie z nagłówkiem + //+8 - tabela indeksów +public: + char* String(int n); + char* StringAt(int n) {return data+9+n;}; + __fastcall TStringPack() {data=NULL; index=NULL;}; + void __fastcall Init(char *d) {data=d;}; + void __fastcall InitIndex(int *i) {index=i;}; +}; + +class TMaterialColor +{ +public: + __fastcall TMaterialColor() {}; + __fastcall TMaterialColor(char V) + { + r=g=b=V; + }; + // __fastcall TMaterialColor(double R, double G, double B) + __fastcall TMaterialColor(char R, char G, char B) + { + r=R; g=G; b=B; + }; + + char r,g,b; +}; + +/* +struct TMaterial +{ + int ID; + AnsiString Name; +//McZapkie-240702: lepiej uzywac wartosci float do opisu koloru bo funkcje opengl chyba tego na ogol uzywaja + float Ambient[4]; + float Diffuse[4]; + float Specular[4]; + float Transparency; + GLuint TextureID; +}; +*/ +/* +struct THitBoxContainer +{ + TPlane Planes[6]; + int Index; + inline void __fastcall Reset() { Planes[0]= TPlane(vector3(0,0,0),0.0f); }; + inline bool __fastcall Inside(vector3 Point) + { + bool Hit= true; + + if (Planes[0].Defined()) + for (int i=0; i<6; i++) + { + if (Planes[i].GetSide(Point)>0) + { + Hit= false; + break; + }; + + } + else return(false); + return(Hit); + }; +}; +*/ + +/* Ra: tego nie będziemy już używać, bo można wycisnąć więcej +typedef enum +{smt_Unknown, //nieznany + smt_Mesh, //siatka + smt_Point, + smt_FreeSpotLight, //punkt świetlny + smt_Text, //generator tekstu + smt_Stars //wiele punktów świetlnych +} TSubModelType; +*/ +//Ra: specjalne typy submodeli, poza tym GL_TRIANGLES itp. +const int TP_ROTATOR=256; +const int TP_FREESPOTLIGHT=257; +const int TP_STARS=258; +const int TP_TEXT=259; + +enum TAnimType //rodzaj animacji +{at_None, //brak + at_Rotate, //obrót względem wektora o kąt + at_RotateXYZ, //obrót względem osi o kąty + at_Translate, //przesunięcie + at_SecondsJump, //sekundy z przeskokiem + at_MinutesJump, //minuty z przeskokiem + at_HoursJump, //godziny z przeskokiem 12h/360° + at_Hours24Jump, //godziny z przeskokiem 24h/360° + at_Seconds, //sekundy płynnie + at_Minutes, //minuty płynnie + at_Hours, //godziny płynnie 12h/360° + at_Hours24, //godziny płynnie 24h/360° + at_Billboard, //obrót w pionie do kamery + at_Wind, //ruch pod wpływem wiatru + at_Sky, //animacja nieba + at_IK=0x100, //odwrotna kinematyka - submodel sterujący (np. staw skokowy) + at_IK11=0x101, //odwrotna kinematyka - submodel nadrzędny do sterowango (np. stopa) + at_IK21=0x102, //odwrotna kinematyka - submodel nadrzędny do sterowango (np. podudzie) + at_IK22=0x103, //odwrotna kinematyka - submodel nadrzędny do nadrzędnego sterowango (np. udo) + at_Digital=0x200, //dziesięciocyfrowy licznik mechaniczny (z cylindrami) + at_DigiClk=0x201, //zegar cyfrowy jako licznik na dziesięciościanach + at_Undefined=0x800000FF //animacja chwilowo nieokreślona +}; + +class TModel3d; +class TSubModelInfo; + +class TSubModel +{//klasa submodelu - pojedyncza siatka, punkt świetlny albo grupa punktów + //Ra: ta klasa ma mieć wielkość 256 bajtów, aby pokryła się z formatem binarnym + //Ra: nie przestawiać zmiennych, bo wczytują się z pliku binarnego! +private: + TSubModel *Next; + TSubModel *Child; + int eType; //Ra: modele binarne dają więcej możliwości niż mesh złożony z trójkątów + int iName; //numer łańcucha z nazwą submodelu, albo -1 gdy anonimowy +public: //chwilowo + TAnimType b_Anim; +private: + int iFlags; //flagi informacyjne: + //bit 0: =1 faza rysowania zależy od wymiennej tekstury 0 + //bit 1: =1 faza rysowania zależy od wymiennej tekstury 1 + //bit 2: =1 faza rysowania zależy od wymiennej tekstury 2 + //bit 3: =1 faza rysowania zależy od wymiennej tekstury 3 + //bit 4: =1 rysowany w fazie nieprzezroczystych (stała tekstura albo brak) + //bit 5: =1 rysowany w fazie przezroczystych (stała tekstura) + //bit 7: =1 ta sama tekstura, co poprzedni albo nadrzędny + //bit 8: =1 wierzchołki wyświetlane z indeksów + //bit 9: =1 wczytano z pliku tekstowego (jest właścicielem tablic) + //bit 13: =1 wystarczy przesunięcie zamiast mnożenia macierzy (trzy jedynki) + //bit 14: =1 wymagane przechowanie macierzy (animacje) + //bit 15: =1 wymagane przechowanie macierzy (transform niejedynkowy) + union + {//transform, nie każdy submodel musi mieć + float4x4 *fMatrix; //pojedyncza precyzja wystarcza + //matrix4x4 *dMatrix; //do testu macierz podwójnej precyzji + int iMatrix; //w pliku binarnym jest numer matrycy + }; + int iNumVerts; //ilość wierzchołków (1 dla FreeSpotLight) + int iVboPtr; //początek na liście wierzchołków albo indeksów + int iTexture; //numer nazwy tekstury, -1 wymienna, 0 brak + float fVisible; //próg jasności światła do załączenia submodelu + float fLight; //próg jasności światła do zadziałania selfillum + float f4Ambient[4]; + float f4Diffuse[4]; //float ze względu na glMaterialfv() + float f4Specular[4]; + float f4Emision[4]; + float fWireSize; //nie używane, ale wczytywane + float fSquareMaxDist; + float fSquareMinDist; + //McZapkie-050702: parametry dla swiatla: + float fNearAttenStart; + float fNearAttenEnd; + int bUseNearAtten; //te 3 zmienne okreslaja rysowanie aureoli wokol zrodla swiatla + int iFarAttenDecay; //ta zmienna okresla typ zaniku natezenia swiatla (0:brak, 1,2: potega 1/R) + float fFarDecayRadius; //normalizacja j.w. + float fCosFalloffAngle; //cosinus kąta stożka pod którym widać światło + float fCosHotspotAngle; //cosinus kąta stożka pod którym widać aureolę i zwiększone natężenie światła + float fCosViewAngle; //cos kata pod jakim sie teraz patrzy + //Ra: dalej są zmienne robocze, można je przestawiać z zachowaniem rozmiaru klasy + int TextureID; //numer tekstury, -1 wymienna, 0 brak + int bWire; //nie używane, ale wczytywane + //short TexAlpha; //Ra: nie używane już + GLuint uiDisplayList; //roboczy numer listy wyświetlania + float Opacity; //nie używane, ale wczytywane + //ABu: te same zmienne, ale zdublowane dla Render i RenderAlpha, + //bo sie chrzanilo przemieszczanie obiektow. + //Ra: już się nie chrzani + float f_Angle; + float3 v_RotateAxis; + float3 v_Angles; +public: //chwilowo + float3 v_TransVector; + float8 *Vertices; //roboczy wskaźnik - wczytanie T3D do VBO + int iAnimOwner; //roboczy numer egzemplarza, który ustawił animację + TAnimType b_aAnim; //kody animacji oddzielnie, bo zerowane +public: + float4x4 *mAnimMatrix; //macierz do animacji kwaternionowych (należy do AnimContainer) + char space[8]; //wolne miejsce na przyszłe zmienne (zmniejszyć w miarę potrzeby) +public: + TSubModel **smLetter; //wskaźnik na tablicę submdeli do generoania tekstu (docelowo zapisać do E3D) + TSubModel *Parent; //nadrzędny, np. do wymnażania macierzy + int iVisible; //roboczy stan widoczności + //AnsiString asTexture; //robocza nazwa tekstury do zapisania w pliku binarnym + //AnsiString asName; //robocza nazwa + char *pTexture; //robocza nazwa tekstury do zapisania w pliku binarnym + char *pName; //robocza nazwa +private: + //int __fastcall SeekFaceNormal(DWORD *Masks, int f,DWORD dwMask,vector3 *pt,GLVERTEX *Vertices); + int __fastcall SeekFaceNormal(DWORD *Masks,int f,DWORD dwMask,float3 *pt,float8 *Vertices); + void __fastcall RaAnimation(TAnimType a); +public: + static int iInstance; //identyfikator egzemplarza, który aktualnie renderuje model + static GLuint *ReplacableSkinId; + static int iAlpha; //maska bitowa dla danego przebiegu + static double fSquareDist; + static TModel3d* pRoot; + static AnsiString* pasText; //tekst dla wyświetlacza (!!!! do przemyślenia) + __fastcall TSubModel(); + __fastcall ~TSubModel(); + void __fastcall FirstInit(); + int __fastcall Load(cParser& Parser, TModel3d *Model,int Pos,bool dynamic); + void __fastcall ChildAdd(TSubModel *SubModel); + void __fastcall NextAdd(TSubModel *SubModel); + TSubModel* __fastcall NextGet() {return Next;}; + TSubModel* __fastcall ChildGet() {return Child;}; + int __fastcall TriangleAdd(TModel3d *m,int tex,int tri); + float8* __fastcall TrianglePtr(int tex,int pos,int *la,int *ld,int*ls); + //float8* __fastcall TrianglePtr(const char *tex,int tri); + //void __fastcall SetRotate(vector3 vNewRotateAxis,float fNewAngle); + void __fastcall SetRotate(float3 vNewRotateAxis,float fNewAngle); + void __fastcall SetRotateXYZ(vector3 vNewAngles); + void __fastcall SetRotateXYZ(float3 vNewAngles); + void __fastcall SetTranslate(vector3 vNewTransVector); + void __fastcall SetTranslate(float3 vNewTransVector); + void __fastcall SetRotateIK1(float3 vNewAngles); + TSubModel* __fastcall GetFromName(AnsiString search,bool i=true); + TSubModel* __fastcall GetFromName(char *search,bool i=true); + void __fastcall RenderDL(); + void __fastcall RenderAlphaDL(); + void __fastcall RenderVBO(); + void __fastcall RenderAlphaVBO(); + //inline matrix4x4* __fastcall GetMatrix() {return dMatrix;}; + inline float4x4* __fastcall GetMatrix() {return fMatrix;}; + //matrix4x4* __fastcall GetTransform() {return Matrix;}; + inline void __fastcall Hide() {iVisible=0;}; + void __fastcall RaArrayFill(CVertNormTex *Vert); + //void __fastcall Render(); + int __fastcall FlagsCheck(); + void __fastcall WillBeAnimated() {if (this) iFlags|=0x4000;}; + void __fastcall InitialRotate(bool doit); + void __fastcall DisplayLists(); + void __fastcall Info(); + void __fastcall InfoSet(TSubModelInfo *info); + void __fastcall BinInit(TSubModel *s,float4x4 *m,float8 *v,TStringPack *t,TStringPack *n=NULL,bool dynamic=false); + void __fastcall ReplacableSet(GLuint *r,int a) + {ReplacableSkinId=r; iAlpha=a;}; + void __fastcall TextureNameSet(const char *n); + void __fastcall NameSet(const char *n); + //Ra: funkcje do budowania terenu z E3D + int __fastcall Flags() {return iFlags;}; + void __fastcall UnFlagNext() {iFlags&=0x00FFFFFF;}; + void __fastcall ColorsSet(int *a,int *d,int*s); + inline float3 Translation1Get() + {return fMatrix?*(fMatrix->TranslationGet())+v_TransVector:v_TransVector;} + inline float3 Translation2Get() + {return *(fMatrix->TranslationGet())+Child->Translation1Get();} + void __fastcall ParentMatrix(float4x4 *m); + float __fastcall MaxY(const float4x4 &m); + void __fastcall AdjustDist(); +}; + +class TSubModelInfo +{//klasa z informacjami o submodelach, do tworzenia pliku binarnego +public: + TSubModel *pSubModel; //wskaźnik na submodel + int iTransform; //numer transformu (-1 gdy brak) + int iName; //numer nazwy + int iTexture; //numer tekstury + int iNameLen; //długość nazwy + int iTextureLen; //długość tekstury + int iNext,iChild; //numer następnego i potomnego + static int iTotalTransforms; //ilość transformów + static int iTotalNames; //ilość nazw + static int iTotalTextures; //ilość tekstur + static int iCurrent; //aktualny obiekt + static TSubModelInfo* pTable; //tabele obiektów pomocniczych + __fastcall TSubModelInfo() + {pSubModel=NULL; + iTransform=iName=iTexture=iNext=iChild=-1; //nie ma + iNameLen=iTextureLen=0; + } + void __fastcall Reset() + {pTable=this; //ustawienie wskaźnika tabeli obiektów + iTotalTransforms=iTotalNames=iTotalTextures=iCurrent=0; //zerowanie liczników + } + __fastcall ~TSubModelInfo() {}; +}; + +class TModel3d : public CMesh +{ +private: + //TMaterial *Materials; + //int MaterialsCount; //Ra: nie używane + //bool TractionPart; //Ra: nie używane + TSubModel *Root; //drzewo submodeli + int iFlags; //Ra: czy submodele mają przezroczyste tekstury +public: //Ra: tymczasowo + int iNumVerts; //ilość wierzchołków (gdy nie ma VBO, to m_nVertexCount=0) +private: + TStringPack Textures; //nazwy tekstur + TStringPack Names; //nazwy submodeli + int *iModel; //zawartość pliku binarnego + int iSubModelsCount; //Ra: używane do tworzenia binarnych + AnsiString asBinary; //nazwa pod którą zapisać model binarny +public: + inline TSubModel* __fastcall GetSMRoot() {return(Root);}; + //double Radius; //Ra: nie używane + __fastcall TModel3d(); + __fastcall TModel3d(char *FileName); + __fastcall ~TModel3d(); + TSubModel* __fastcall GetFromName(const char *sName); + //TMaterial* __fastcall GetMaterialFromName(char *sName); + TSubModel* __fastcall AddToNamed(const char *Name, TSubModel *SubModel); + void __fastcall AddTo(TSubModel *tmp,TSubModel *SubModel); + void __fastcall LoadFromTextFile(char *FileName,bool dynamic); + void __fastcall LoadFromBinFile(char *FileName,bool dynamic); + bool __fastcall LoadFromFile(char *FileName,bool dynamic); + void __fastcall SaveToBinFile(char *FileName); + void __fastcall BreakHierarhy(); + //renderowanie specjalne + void __fastcall Render(double fSquareDistance,GLuint *ReplacableSkinId=NULL,int iAlpha=0x30300030); + void __fastcall RenderAlpha(double fSquareDistance,GLuint *ReplacableSkinId=NULL,int iAlpha=0x30300030); + void __fastcall RaRender(double fSquareDistance,GLuint *ReplacableSkinId=NULL,int iAlpha=0x30300030); + void __fastcall RaRenderAlpha(double fSquareDistance,GLuint *ReplacableSkinId=NULL,int iAlpha=0x30300030); + //jeden kąt obrotu + void __fastcall Render(vector3 pPosition,double fAngle=0,GLuint *ReplacableSkinId=NULL,int iAlpha=0x30300030); + void __fastcall RenderAlpha(vector3 pPosition,double fAngle=0,GLuint *ReplacableSkinId=NULL,int iAlpha=0x30300030); + void __fastcall RaRender(vector3 pPosition,double fAngle=0,GLuint *ReplacableSkinId=NULL,int iAlpha=0x30300030); + void __fastcall RaRenderAlpha(vector3 pPosition,double fAngle=0,GLuint *ReplacableSkinId=NULL,int iAlpha=0x30300030); + //trzy kąty obrotu + void __fastcall Render(vector3* vPosition,vector3* vAngle,GLuint *ReplacableSkinId=NULL,int iAlpha=0x30300030); + void __fastcall RenderAlpha(vector3* vPosition,vector3* vAngle,GLuint *ReplacableSkinId=NULL,int iAlpha=0x30300030); + void __fastcall RaRender(vector3* vPosition,vector3* vAngle,GLuint *ReplacableSkinId=NULL,int iAlpha=0x30300030); + void __fastcall RaRenderAlpha(vector3* vPosition,vector3* vAngle,GLuint *ReplacableSkinId=NULL,int iAlpha=0x30300030); + //inline int __fastcall GetSubModelsCount() { return (SubModelsCount); }; + int __fastcall Flags() {return iFlags;}; + void __fastcall Init(); + char* __fastcall NameGet() {return Root?Root->pName:NULL;}; + int __fastcall TerrainCount(); + TSubModel* __fastcall TerrainSquare(int n); + void __fastcall TerrainRenderVBO(int n); +}; + +//--------------------------------------------------------------------------- +#endif diff --git a/Mover.cpp b/Mover.cpp new file mode 100644 index 00000000..8cb7811d --- /dev/null +++ b/Mover.cpp @@ -0,0 +1,590 @@ +//--------------------------------------------------------------------------- + +#include "Mover.h" +//--------------------------------------------------------------------------- +#pragma package(smart_init) +// Ra: tu należy przenosić funcje z mover.pas, które nie są z niego wywoływane. +// Jeśli jakieś zmienne nie są używane w mover.pas, też można je przenosić. +// Przeniesienie wszystkiego na raz zrobiło by zbyt wielki chaos do ogarnięcia. + +const dEpsilon=0.01; //1cm (zależy od typu sprzęgu...) + +__fastcall TMoverParameters::TMoverParameters(double VelInitial,AnsiString TypeNameInit,AnsiString NameInit, + int LoadInitial,AnsiString LoadTypeInitial,int Cab) + : T_MoverParameters(VelInitial,TypeNameInit,NameInit,LoadInitial,LoadTypeInitial,Cab) +{//główny konstruktor + DimHalf.x=0.5*Dim.W; //połowa szerokości, OX jest w bok? + DimHalf.y=0.5*Dim.L; //połowa długości, OY jest do przodu? + DimHalf.z=0.5*Dim.H; //połowa wysokości, OZ jest w górę? + //BrakeLevelSet(-2); //Pascal ustawia na 0, przestawimy na odcięcie (CHK jest jeszcze nie wczytane!) + bPantKurek3=true; //domyślnie zbiornik pantografu połączony jest ze zbiornikiem głównym + iProblem=0; //pojazd w pełni gotowy do ruchu + iLights[0]=iLights[1]=0; //światła zgaszone +}; + + +double __fastcall TMoverParameters::Distance(const TLocation &Loc1,const TLocation &Loc2,const TDimension &Dim1,const TDimension &Dim2) +{//zwraca odległość pomiędzy pojazdami (Loc1) i (Loc2) z uwzględnieneim ich długości (kule!) + return hypot(Loc2.X-Loc1.X,Loc1.Y-Loc2.Y)-0.5*(Dim2.L+Dim1.L); +}; + +double __fastcall TMoverParameters::Distance(const vector3 &s1, const vector3 &s2, const vector3 &d1, const vector3 &d2) +{//obliczenie odległości prostopadłościanów o środkach (s1) i (s2) i wymiarach (d1) i (d2) + //return 0.0; //będzie zgłaszać warning - funkcja do usunięcia, chyba że się przyda... +}; + +double __fastcall TMoverParameters::CouplerDist(Byte Coupler) +{//obliczenie odległości pomiędzy sprzęgami (kula!) + return Couplers[Coupler].CoupleDist=Distance(Loc,Couplers[Coupler].Connected->Loc,Dim,Couplers[Coupler].Connected->Dim); //odległość pomiędzy sprzęgami (kula!) +}; + +bool __fastcall TMoverParameters::Attach(Byte ConnectNo,Byte ConnectToNr,TMoverParameters *ConnectTo,Byte CouplingType,bool Forced) +{//łączenie do swojego sprzęgu (ConnectNo) pojazdu (ConnectTo) stroną (ConnectToNr) + //Ra: zwykle wykonywane dwukrotnie, dla każdego pojazdu oddzielnie + //Ra: trzeba by odróżnić wymóg dociśnięcia od uszkodzenia sprzęgu przy podczepianiu AI do składu + if (ConnectTo) //jeśli nie pusty + { + if (ConnectToNr!=2) Couplers[ConnectNo].ConnectedNr=ConnectToNr; //2=nic nie podłączone + TCouplerType ct=ConnectTo->Couplers[Couplers[ConnectNo].ConnectedNr].CouplerType; //typ sprzęgu podłączanego pojazdu + Couplers[ConnectNo].Connected=ConnectTo; //tak podpiąć (do siebie) zawsze można, najwyżej będzie wirtualny + CouplerDist(ConnectNo); //przeliczenie odległości pomiędzy sprzęgami + if (CouplingType==ctrain_virtual) return false; //wirtualny więcej nic nie robi + if (Forced?true:((Couplers[ConnectNo].CoupleDist<=dEpsilon)&&(Couplers[ConnectNo].CouplerType!=NoCoupler)&&(Couplers[ConnectNo].CouplerType==ct))) + {//stykaja sie zderzaki i kompatybilne typy sprzegow, chyba że łączenie na starcie + if (Couplers[ConnectNo].CouplingFlag==ctrain_virtual) //jeśli wcześniej nie było połączone + {//ustalenie z której strony rysować sprzęg + Couplers[ConnectNo].Render=true; //tego rysować + ConnectTo->Couplers[Couplers[ConnectNo].ConnectedNr].Render=false; //a tego nie + }; + Couplers[ConnectNo].CouplingFlag=CouplingType; //ustawienie typu sprzęgu + //if (CouplingType!=ctrain_virtual) //Ra: wirtualnego nie łączymy zwrotnie! + //{//jeśli łączenie sprzęgiem niewirtualnym, ustawiamy połączenie zwrotne + ConnectTo->Couplers[Couplers[ConnectNo].ConnectedNr].CouplingFlag=CouplingType; + ConnectTo->Couplers[Couplers[ConnectNo].ConnectedNr].Connected=this; + ConnectTo->Couplers[Couplers[ConnectNo].ConnectedNr].CoupleDist=Couplers[ConnectNo].CoupleDist; + return true; + //} + //podłączenie nie udało się - jest wirtualne + } + } + return false; //brak podłączanego pojazdu, zbyt duża odległość, niezgodny typ sprzęgu, brak sprzęgu, brak haka +}; + +bool __fastcall TMoverParameters::Attach(Byte ConnectNo,Byte ConnectToNr,T_MoverParameters *ConnectTo,Byte CouplingType,bool Forced) +{//łączenie do (ConnectNo) pojazdu (ConnectTo) stroną (ConnectToNr) + return Attach(ConnectNo,ConnectToNr,(TMoverParameters*)ConnectTo,CouplingType,Forced); +}; + +int __fastcall TMoverParameters::DettachStatus(Byte ConnectNo) +{//Ra: sprawdzenie, czy odległość jest dobra do rozłączania + //powinny być 3 informacje: =0 sprzęg już rozłączony, <0 da się rozłączyć. >0 nie da się rozłączyć + if (!Couplers[ConnectNo].Connected) + return 0; //nie ma nic, to rozłączanie jest OK + if ((Couplers[ConnectNo].CouplingFlag&ctrain_coupler)==0) + return -Couplers[ConnectNo].CouplingFlag; //hak nie połączony - rozłączanie jest OK + if (TestFlag(DamageFlag,dtrain_coupling)) + return -Couplers[ConnectNo].CouplingFlag; //hak urwany - rozłączanie jest OK + //ABu021104: zakomentowane 'and (CouplerType<>Articulated)' w warunku, nie wiem co to bylo, ale za to teraz dziala odczepianie... :) } + //if (CouplerType==Articulated) return false; //sprzęg nie do rozpięcia - może być tylko urwany + //Couplers[ConnectNo].CoupleDist=Distance(Loc,Couplers[ConnectNo].Connected->Loc,Dim,Couplers[ConnectNo].Connected->Dim); + CouplerDist(ConnectNo); + if (Couplers[ConnectNo].CouplerType==Screw?Couplers[ConnectNo].CoupleDist<0.0:true) + return -Couplers[ConnectNo].CouplingFlag; //można rozłączać, jeśli dociśnięty + return (Couplers[ConnectNo].CoupleDist>0.2)?-Couplers[ConnectNo].CouplingFlag:Couplers[ConnectNo].CouplingFlag; +}; + +bool __fastcall TMoverParameters::Dettach(Byte ConnectNo) +{//rozlaczanie + if (!Couplers[ConnectNo].Connected) return true; //nie ma nic, to odczepiono + //with Couplers[ConnectNo] do + int i=DettachStatus(ConnectNo); //stan sprzęgu + if (i<0) + {//gdy scisniete zderzaki, chyba ze zerwany sprzeg (wirtualnego nie odpinamy z drugiej strony) + //Couplers[ConnectNo].Connected=NULL; //lepiej zostawic bo przeciez trzeba kontrolowac zderzenia odczepionych + Couplers[ConnectNo].Connected->Couplers[Couplers[ConnectNo].ConnectedNr].CouplingFlag=0; //pozostaje sprzęg wirtualny + Couplers[ConnectNo].CouplingFlag=0; //pozostaje sprzęg wirtualny + return true; + } + else if (i>0) + {//odłączamy węże i resztę, pozostaje sprzęg fizyczny, który wymaga dociśnięcia (z wirtualnym nic) + Couplers[ConnectNo].CouplingFlag&=ctrain_coupler; + Couplers[ConnectNo].Connected->Couplers[Couplers[ConnectNo].ConnectedNr].CouplingFlag=Couplers[ConnectNo].CouplingFlag; + } + return false; //jeszcze nie rozłączony +}; + +void __fastcall TMoverParameters::SetCoupleDist() +{//przeliczenie odległości sprzęgów + if (Couplers[0].Connected) + { + CouplerDist(0); + if (CategoryFlag&2) + {//Ra: dla samochodów zderzanie kul to za mało + } + } + if (Couplers[1].Connected) + { + CouplerDist(1); + if (CategoryFlag&2) + {//Ra: dla samochodów zderzanie kul to za mało + } + } +}; + +bool __fastcall TMoverParameters::DirectionForward() +{ + if ((MainCtrlPosNo>0)&&(ActiveDir<1)&&(MainCtrlPos==0)) + { + ++ActiveDir; + DirAbsolute=ActiveDir*CabNo; + if (DirAbsolute) + if (Battery) //jeśli bateria jest już załączona + BatterySwitch(true); //to w ten oto durny sposób aktywuje się CA/SHP + SendCtrlToNext("Direction",ActiveDir,CabNo); + return true; + } + else if ((ActiveDir==1)&&(MainCtrlPos==0)&&(TrainType==dt_EZT)) + return MinCurrentSwitch(true); //"wysoki rozruch" EN57 + return false; +}; + +// Nastawianie hamulców + +void __fastcall TMoverParameters::BrakeLevelSet(double b) +{//ustawienie pozycji hamulca na wartość (b) w zakresie od -2 do BrakeCtrlPosNo + //jedyny dopuszczalny sposób przestawienia hamulca zasadniczego + if (fBrakeCtrlPos==b) return; //nie przeliczać, jak nie ma zmiany + fBrakeCtrlPos=b; + BrakeCtrlPosR=b; + if (fBrakeCtrlPosGetPos(bh_MIN)) + fBrakeCtrlPos=Handle->GetPos(bh_MIN); //odcięcie + else + if (fBrakeCtrlPos>Handle->GetPos(bh_MAX)) + fBrakeCtrlPos=Handle->GetPos(bh_MAX); + int x=floor(fBrakeCtrlPos); //jeśli odwołujemy się do BrakeCtrlPos w pośrednich, to musi być obcięte a nie zaokrągone + while ((x>BrakeCtrlPos)&&(BrakeCtrlPos=-1)) //jeśli zmniejszyło się o 1 + if (!T_MoverParameters::DecBrakeLevelOld()) break; + BrakePressureActual=BrakePressureTable[BrakeCtrlPos+2]; //skopiowanie pozycji +/* +//youBy: obawiam sie, ze tutaj to nie dziala :P +//Ra 2014-03: było tak zrobione, że działało - po każdej zmianie pozycji była wywoływana ta funkcja +// if (BrakeSystem==Pneumatic?BrakeSubsystem==Oerlikon:false) //tylko Oerlikon akceptuje ułamki + if(false) + if (fBrakeCtrlPos>0.0) + {//wartości pośrednie wyliczamy tylko dla hamowania + double u=fBrakeCtrlPos-double(x); //ułamek ponad wartość całkowitą + if (u>0.0) + {//wyliczamy wartości ważone + BrakePressureActual.PipePressureVal+=-u*BrakePressureActual.PipePressureVal+u*BrakePressureTable[BrakeCtrlPos+1+2].PipePressureVal; + //BrakePressureActual.BrakePressureVal+=-u*BrakePressureActual.BrakePressureVal+u*BrakePressureTable[BrakeCtrlPos+1].BrakePressureVal; //to chyba nie będzie tak działać, zwłaszcza w EN57 + BrakePressureActual.FlowSpeedVal+=-u*BrakePressureActual.FlowSpeedVal+u*BrakePressureTable[BrakeCtrlPos+1+2].FlowSpeedVal; + } + } +*/ +}; + +bool __fastcall TMoverParameters::BrakeLevelAdd(double b) +{//dodanie wartości (b) do pozycji hamulca (w tym ujemnej) + //zwraca false, gdy po dodaniu było by poza zakresem + BrakeLevelSet(fBrakeCtrlPos+b); + return b>0.0?(fBrakeCtrlPos-1.0); //true, jeśli można kontynuować +}; + +bool __fastcall TMoverParameters::IncBrakeLevel() +{//nowa wersja na użytek AI, false gdy osiągnięto pozycję BrakeCtrlPosNo + return BrakeLevelAdd(1.0); +}; + +bool __fastcall TMoverParameters::DecBrakeLevel() +{//nowa wersja na użytek AI, false gdy osiągnięto pozycję -1 + return BrakeLevelAdd(-1.0); +}; + +bool __fastcall TMoverParameters::ChangeCab(int direction) +{//zmiana kabiny i resetowanie ustawien + if (abs(ActiveCab+direction)<2) + { +// if (ActiveCab+direction=0) then LastCab:=ActiveCab; + ActiveCab=ActiveCab+direction; + if ((BrakeSystem==Pneumatic)&&(BrakeCtrlPosNo>0)) + { +// if (BrakeHandle==FV4a) //!!!POBIERAĆ WARTOŚĆ Z KLASY ZAWORU!!! +// BrakeLevelSet(-2); //BrakeCtrlPos=-2; +// else if ((BrakeHandle==FVel6)||(BrakeHandle==St113)) +// BrakeLevelSet(2); +// else +// BrakeLevelSet(1); + BrakeLevelSet(Handle->GetPos(bh_NP)); + LimPipePress=PipePress; + ActFlowSpeed=0; + } + else + //if (TrainType=dt_EZT) and (BrakeCtrlPosNo>0) then + // BrakeCtrlPos:=5; //z Megapacka + //else +// BrakeLevelSet(0); //BrakeCtrlPos=0; + BrakeLevelSet(Handle->GetPos(bh_NP)); +// if not TestFlag(BrakeStatus,b_dmg) then +// BrakeStatus:=b_off; //z Megapacka + MainCtrlPos=0; + ScndCtrlPos=0; + //Ra: to poniżej jest bez sensu - można przejść nie wyłączając + //if ((EngineType!=DieselEngine)&&(EngineType!=DieselElectric)) + //{ + // Mains=false; + // CompressorAllow=false; + // ConverterAllow=false; + //} + //ActiveDir=0; + //DirAbsolute=0; + return true; + } + return false; +}; + +bool __fastcall TMoverParameters::CurrentSwitch(int direction) +{//rozruch wysoki (true) albo niski (false) + //Ra: przeniosłem z Train.cpp, nie wiem czy ma to sens + if (MaxCurrentSwitch(direction)) + {if (TrainType!=dt_EZT) + return (MinCurrentSwitch(direction)); + } + if (EngineType==DieselEngine) //dla 2Ls150 + if (ShuntModeAllow) + if (ActiveDir==0) //przed ustawieniem kierunku + ShuntMode=direction; + return false; +}; + +void __fastcall TMoverParameters::UpdatePantVolume(double dt) +{//KURS90 - sprężarka pantografów; Ra 2014-07: teraz jest to zbiornik rozrządu, chociaż to jeszcze nie tak + if (EnginePowerSource.SourceType==CurrentCollector) //tylko jeśli pantografujący + { + //Ra 2014-07: zasadniczo, to istnieje zbiornik rozrządu i zbiornik pantografów - na razie mamy razem + //Ra 2014-07: kurek trójdrogowy łączy spr.pom. z pantografami i wyłącznikiem ciśnieniowym WS + //Ra 2014-07: zbiornika rozrządu nie pompuje się tu, tylko pantografy; potem można zamknąć WS i odpalić resztę + if ((TrainType==dt_EZT)?(PantPressScndPipePress) PantPress=ScndPipePress; //oraz do ScndPipePress + PantVolume=(PantPress+1)*0.1; //objętość, na wypadek odcięcia kurkiem + } + else + {//zbiornik główny odcięty, można pompować pantografy + if (PantCompFlag&&Battery) //włączona bateria i mała sprężarka + PantVolume+=dt*(TrainType==dt_EZT?0.003:0.005)*(2*0.45-((0.1/PantVolume/10)-0.1))/0.45; //napełnianie zbiornika pantografów + //Ra 2013-12: Niebugocław mówi, że w EZT nabija 1.5 raz wolniej niż jak było 0.005 + PantPress=(10.0*PantVolume)-1.0; //tu by się przydała objętość zbiornika + } + if (!PantCompFlag&&(PantVolume>0.1)) + PantVolume-=dt*0.0003; //nieszczelności: 0.0003=0.3l/s + if (Mains) //nie wchodzić w funkcję bez potrzeby + if (EngineType==ElectricSeriesMotor) //nie dotyczy... czego właściwie? + if (PantPressPantVolumePantVolume=PantVolume; //przekazanie ciśnienia do sąsiedniego członu + //czy np. w ET40, ET41, ET42 pantografy członów mają połączenie pneumatyczne? + //Ra 2014-07: raczej nie - najpierw się załącza jeden człon, a potem można podnieść w drugim + } + else + {//a tu coś dla SM42 i SM31, aby pokazywać na manometrze + PantPress=CntrlPipePress; + } +}; + +void __fastcall TMoverParameters::UpdateBatteryVoltage(double dt) +{//przeliczenie obciążenia baterii + double sn1,sn2,sn3,sn4,sn5; //Ra: zrobić z tego amperomierz NN + if ((BatteryVoltage>0)&&(EngineType!=DieselEngine)&&(EngineType!=WheelsDriven)&&(NominalBatteryVoltage>0)) + { + if ((NominalBatteryVoltage/BatteryVoltage<1.22)&&Battery) + {//110V + if (!ConverterFlag) + sn1=(dt*2.0); //szybki spadek do ok 90V + else sn1=0; + if (ConverterFlag) + sn2=-(dt*2.0); //szybki wzrost do 110V + else sn2=0; + if (Mains) + sn3=(dt*0.05); + else sn3=0; + if (iLights[0]&63) //64=blachy, nie ciągną prądu //rozpisać na poszczególne żarówki... + sn4=dt*0.003; + else sn4=0; + if (iLights[1]&63) //64=blachy, nie ciągną prądu + sn5=dt*0.001; + else sn5=0; + }; + if ((NominalBatteryVoltage/BatteryVoltage>=1.22)&&Battery) + {//90V + if (PantCompFlag) + sn1=(dt*0.0046); + else sn1=0; + if (ConverterFlag) + sn2=-(dt*50); //szybki wzrost do 110V + else sn2=0; + if (Mains) + sn3=(dt*0.001); + else sn3=0; + if (iLights[0]&63) //64=blachy, nie ciągną prądu + sn4=(dt*0.0030); + else sn4=0; + if (iLights[1]&63) //64=blachy, nie ciągną prądu + sn5=(dt*0.0010); + else sn5=0; + }; + if (!Battery) + { + if (NominalBatteryVoltage/BatteryVoltage<1.22) + sn1=dt*50; + else + sn1=0; + sn2=dt*0.000001; + sn3=dt*0.000001; + sn4=dt*0.000001; + sn5=dt*0.000001; //bardzo powolny spadek przy wyłączonych bateriach + }; + BatteryVoltage-=(sn1+sn2+sn3+sn4+sn5); + if (NominalBatteryVoltage/BatteryVoltage>1.57) + if (MainSwitch(false)&&(EngineType!=DieselEngine)&&(EngineType!=WheelsDriven)) + EventFlag=true; //wywalanie szybkiego z powodu zbyt niskiego napiecia + if (BatteryVoltage>NominalBatteryVoltage) + BatteryVoltage=NominalBatteryVoltage; //wstrzymanie ładowania pow. 110V + if (BatteryVoltage<0.01) + BatteryVoltage=0.01; + } + else + if (NominalBatteryVoltage==0) + BatteryVoltage=0; + else + BatteryVoltage=90; +}; + +/* Ukrotnienie EN57: +1 //układ szeregowy +2 //układ równoległy +3 //bocznik 1 +4 //bocznik 2 +5 //bocznik 3 +6 //do przodu +7 //do tyłu +8 //1 przyspieszenie +9 //minus obw. 2 przyspieszenia +10 //jazda na oporach +11 //SHP +12A //podnoszenie pantografu przedniego +12B //podnoszenie pantografu tylnego +13A //opuszczanie pantografu przedniego +13B //opuszczanie wszystkich pantografów +14 //załączenie WS +15 //rozrząd (WS, PSR, wał kułakowy) +16 //odblok PN +18 //sygnalizacja przetwornicy głównej +19 //luzowanie EP +20 //hamowanie EP +21 //rezerwa** (1900+: zamykanie drzwi prawych) +22 //zał. przetwornicy głównej +23 //wył. przetwornicy głównej +24 //zał. przetw. oświetlenia +25 //wył. przetwornicy oświetlenia +26 //sygnalizacja WS +28 //sprężarka +29 //ogrzewanie +30 //rezerwa* (1900+: zamykanie drzwi lewych) +31 //otwieranie drzwi prawych +32H //zadziałanie PN siln. trakcyjnych +33 //sygnał odjazdu +34 //rezerwa (sygnalizacja poślizgu) +35 //otwieranie drzwi lewych +ZN //masa +*/ + +double __fastcall TMoverParameters::ComputeMovement +(double dt,double dt1, + const TTrackShape &Shape,TTrackParam &Track,TTractionParam &ElectricTraction, + const TLocation &NewLoc,TRotation &NewRot +) +{//trzeba po mału przenosić tu tę funkcję + double d; + T_MoverParameters::ComputeMovement(dt,dt1,Shape,Track,ElectricTraction,NewLoc,NewRot); + if (Power>1.0) //w rozrządczym nie (jest błąd w FIZ!) - Ra 2014-07: teraz we wszystkich + UpdatePantVolume(dt); //Ra 2014-07: obsługa zbiornika rozrządu oraz pantografów + + if (EngineType==WheelsDriven) + d=CabNo*dL; //na chwile dla testu + else + d=dL; + DistCounter=DistCounter+fabs(dL)/1000.0; + dL=0; + + //koniec procedury, tu nastepuja dodatkowe procedury pomocnicze + + //sprawdzanie i ewentualnie wykonywanie->kasowanie poleceń + if (LoadStatus>0) //czas doliczamy tylko jeśli trwa (roz)ładowanie + LastLoadChangeTime=LastLoadChangeTime+dt; //czas (roz)ładunku + RunInternalCommand(); + //automatyczny rozruch + if (EngineType==ElectricSeriesMotor) + if (AutoRelayCheck()) + SetFlag(SoundFlag,sound_relay); +/* + else {McZapkie-041003: aby slychac bylo przelaczniki w sterowniczym} + if (EngineType=None) and (MainCtrlPosNo>0) then + for b:=0 to 1 do + with Couplers[b] do + if TestFlag(CouplingFlag,ctrain_controll) then + if Connected^.Power>0.01 then + SoundFlag:=SoundFlag or Connected^.SoundFlag; +*/ + if (EngineType==DieselEngine) + if (dizel_Update(dt)) + SetFlag(SoundFlag,sound_relay); + //uklady hamulcowe: + if (VeselVolume>0) + Compressor=CompressedVolume/VeselVolume; + else + { + Compressor=0; + CompressorFlag=false; + }; + ConverterCheck(); + if (CompressorSpeed>0.0) //sprężarka musi mieć jakąś niezerową wydajność + CompressorCheck(dt); //żeby rozważać jej załączenie i pracę + UpdateBrakePressure(dt); + UpdatePipePressure(dt); + UpdateBatteryVoltage(dt); + UpdateScndPipePressure(dt); // druga rurka, youBy + //hamulec antypoślizgowy - wyłączanie + if ((BrakeSlippingTimer>0.8)&&(ASBType!=128)) //ASBSpeed=0.8 + Hamulec->ASB(0); + //SetFlag(BrakeStatus,-b_antislip); + BrakeSlippingTimer=BrakeSlippingTimer+dt; + //sypanie piasku - wyłączone i piasek się nie kończy - błędy AI + //if AIControllFlag then + // if SandDose then + // if Sand>0 then + // begin + // Sand:=Sand-NPoweredAxles*SandSpeed*dt; + // if Random
10) and (not DebugmodeFlag) then + if (!DebugModeFlag) + SecuritySystemCheck(dt1); + return d; +}; + +double __fastcall TMoverParameters::FastComputeMovement +(double dt, + const TTrackShape &Shape,TTrackParam &Track, + const TLocation &NewLoc,TRotation &NewRot +) +{//trzeba po mału przenosić tu tę funkcję + double d; + T_MoverParameters::FastComputeMovement(dt,Shape,Track,NewLoc,NewRot); + if (Power>1.0) //w rozrządczym nie (jest błąd w FIZ!) + UpdatePantVolume(dt); //Ra 2014-07: obsługa zbiornika rozrządu oraz pantografów + if (EngineType==WheelsDriven) + d=CabNo*dL; //na chwile dla testu + else + d=dL; + DistCounter=DistCounter+fabs(dL)/1000.0; + dL=0; + + //koniec procedury, tu nastepuja dodatkowe procedury pomocnicze + + //sprawdzanie i ewentualnie wykonywanie->kasowanie poleceń + if (LoadStatus>0) //czas doliczamy tylko jeśli trwa (roz)ładowanie + LastLoadChangeTime=LastLoadChangeTime+dt; //czas (roz)ładunku + RunInternalCommand(); + if (EngineType==DieselEngine) + if (dizel_Update(dt)) + SetFlag(SoundFlag,sound_relay); + //uklady hamulcowe: + if (VeselVolume>0) + Compressor=CompressedVolume/VeselVolume; + else + { + Compressor=0; + CompressorFlag=false; + }; + ConverterCheck(); + if (CompressorSpeed>0.0) //sprężarka musi mieć jakąś niezerową wydajność + CompressorCheck(dt); //żeby rozważać jej załączenie i pracę + UpdateBrakePressure(dt); + UpdatePipePressure(dt); + UpdateScndPipePressure(dt); // druga rurka, youBy + UpdateBatteryVoltage(dt); + //hamulec antyposlizgowy - wyłączanie + if ((BrakeSlippingTimer>0.8)&&(ASBType!=128)) //ASBSpeed=0.8 + Hamulec->ASB(0); + BrakeSlippingTimer=BrakeSlippingTimer+dt; + return d; +}; + +double __fastcall TMoverParameters::ShowEngineRotation(int VehN) +{//pokazywanie obrotów silnika, również dwóch dalszych pojazdów (3×SN61) + int b; + switch (VehN) + {//numer obrotomierza + case 1: + return fabs(enrot); + case 2: + for (b=0;b<=1;++b) + if (TestFlag(Couplers[b].CouplingFlag,ctrain_controll)) + if (Couplers[b].Connected->Power>0.01) + return fabs(Couplers[b].Connected->enrot); + break; + case 3: //to nie uwzględnia ewentualnego odwrócenia pojazdu w środku + for (b=0;b<=1;++b) + if (TestFlag(Couplers[b].CouplingFlag,ctrain_controll)) + if (Couplers[b].Connected->Power>0.01) + if (TestFlag(Couplers[b].Connected->Couplers[b].CouplingFlag,ctrain_controll)) + if (Couplers[b].Connected->Couplers[b].Connected->Power>0.01) + return fabs(Couplers[b].Connected->Couplers[b].Connected->enrot); + break; + }; + return 0.0; +}; + +void __fastcall TMoverParameters::ConverterCheck() +{//sprawdzanie przetwornicy + if (ConverterAllow&&Mains) + ConverterFlag=true; + else + ConverterFlag=false; +}; + +int __fastcall TMoverParameters::ShowCurrent(Byte AmpN) +{//odczyt amperażu + switch (EngineType) + {case ElectricInductionMotor: + switch (AmpN) + {//do asynchronicznych + case 1: return WindingRes*Mm/Vadd; + case 2: return dizel_fill*WindingRes; + default: return T_MoverParameters::ShowCurrent(AmpN); + } + break; + case DieselElectric: + return fabs(Im); + break; + default: + return T_MoverParameters::ShowCurrent(AmpN); + } +}; diff --git a/Mover.h b/Mover.h new file mode 100644 index 00000000..b6fe77a9 --- /dev/null +++ b/Mover.h @@ -0,0 +1,173 @@ +//--------------------------------------------------------------------------- + +#ifndef MoverH +#define MoverH +//--------------------------------------------------------------------------- +#include "Mover.hpp" +// Ra: Niestety "_mover.hpp" się nieprawidłowo generuje - przekłada sobie TCoupling na sam koniec. +// Przy wszelkich poprawkach w "_mover.pas" trzeba skopiować ręcznie "_mover.hpp" do "mover.hpp" i +// poprawić błędy! Tak aż do wydzielnia TCoupling z Pascala do C++... +// Docelowo obsługę sprzęgów (łączenie, rozłączanie, obliczanie odległości, przesył komend) +// trzeba przenieść na poziom DynObj.cpp. +// Obsługę silniników też trzeba wydzielić do osobnego modułu, bo każdy osobno może mieć poślizg. +#include "dumb3d.h" +using namespace Math3D; + +enum TProblem //lista problemów taboru, które uniemożliwiają jazdę +{//flagi bitowe + pr_Hamuje=1, //pojazd ma załączony hamulec lub zatarte osie + pr_Pantografy=2, //pojazd wymaga napompowania pantografów + pr_Ostatni=0x80000000 //ostatnia flaga bitowa +}; + +class TMoverParameters : public T_MoverParameters +{//Ra: wrapper na kod pascalowy, przejmujący jego funkcje +public: + vector3 vCoulpler[2]; //powtórzenie współrzędnych sprzęgów z DynObj :/ + vector3 DimHalf; //połowy rozmiarów do obliczeń geometrycznych + //int WarningSignal; //0: nie trabi, 1,2: trabi syreną o podanym numerze + unsigned char WarningSignal; //tymczasowo 8bit, ze względu na funkcje w MTools + double fBrakeCtrlPos; //płynna nastawa hamulca zespolonego + bool bPantKurek3; //kurek trójdrogowy (pantografu): true=połączenie z ZG, false=połączenie z małą sprężarką + int iProblem; //flagi problemów z taborem, aby AI nie musiało porównywać; 0=może jechać + int iLights[2]; //bity zapalonych świateł tutaj, żeby dało się liczyć pobór prądu +private: + double __fastcall CouplerDist(Byte Coupler); +public: + __fastcall TMoverParameters(double VelInitial,AnsiString TypeNameInit,AnsiString NameInit, + int LoadInitial,AnsiString LoadTypeInitial,int Cab); + //obsługa sprzęgów + double __fastcall Distance(const TLocation &Loc1,const TLocation &Loc2,const TDimension &Dim1,const TDimension &Dim2); + double __fastcall Distance(const vector3 &Loc1,const vector3 &Loc2,const vector3 &Dim1,const vector3 &Dim2); + bool __fastcall Attach(Byte ConnectNo,Byte ConnectToNr,TMoverParameters *ConnectTo,Byte CouplingType,bool Forced=false); + bool __fastcall Attach(Byte ConnectNo,Byte ConnectToNr,T_MoverParameters *ConnectTo,Byte CouplingType,bool Forced=false); + int __fastcall DettachStatus(Byte ConnectNo); + bool __fastcall Dettach(Byte ConnectNo); + void __fastcall SetCoupleDist(); + bool __fastcall DirectionForward(); + void __fastcall BrakeLevelSet(double b); + bool __fastcall BrakeLevelAdd(double b); + bool __fastcall IncBrakeLevel(); //wersja na użytek AI + bool __fastcall DecBrakeLevel(); + bool __fastcall ChangeCab(int direction); + bool __fastcall CurrentSwitch(int direction); + void __fastcall UpdateBatteryVoltage(double dt); + double __fastcall ComputeMovement + (double dt,double dt1, + const TTrackShape &Shape,TTrackParam &Track,TTractionParam &ElectricTraction, + const TLocation &NewLoc,TRotation &NewRot + ); + double __fastcall FastComputeMovement + (double dt, + const TTrackShape &Shape,TTrackParam &Track, + const TLocation &NewLoc,TRotation &NewRot + ); + double __fastcall ShowEngineRotation(int VehN); + //double __fastcall GetTrainsetVoltage(void); + //bool __fastcall Physic_ReActivation(void); + //double __fastcall LocalBrakeRatio(void); + //double __fastcall ManualBrakeRatio(void); + //double __fastcall PipeRatio(void); + //double __fastcall RealPipeRatio(void); + //double __fastcall BrakeVP(void); + //bool __fastcall DynamicBrakeSwitch(bool Switch); + //bool __fastcall SendCtrlBroadcast(AnsiString CtrlCommand, double ctrlvalue); + //bool __fastcall SendCtrlToNext(AnsiString CtrlCommand, double ctrlvalue, double dir); + //bool __fastcall CabActivisation(void); + //bool __fastcall CabDeactivisation(void); + //bool __fastcall IncMainCtrl(int CtrlSpeed); + //bool __fastcall DecMainCtrl(int CtrlSpeed); + //bool __fastcall IncScndCtrl(int CtrlSpeed); + //bool __fastcall DecScndCtrl(int CtrlSpeed); + //bool __fastcall AddPulseForce(int Multipler); + //bool __fastcall SandDoseOn(void); + //bool __fastcall SecuritySystemReset(void); + //void __fastcall SecuritySystemCheck(double dt); + //bool __fastcall BatterySwitch(bool State); + //bool __fastcall EpFuseSwitch(bool State); + //bool __fastcall IncBrakeLevelOld(void); + //bool __fastcall DecBrakeLevelOld(void); + //bool __fastcall IncLocalBrakeLevel(Byte CtrlSpeed); + //bool __fastcall DecLocalBrakeLevel(Byte CtrlSpeed); + //bool __fastcall IncLocalBrakeLevelFAST(void); + //bool __fastcall DecLocalBrakeLevelFAST(void); + //bool __fastcall IncManualBrakeLevel(Byte CtrlSpeed); + //bool __fastcall DecManualBrakeLevel(Byte CtrlSpeed); + //bool __fastcall EmergencyBrakeSwitch(bool Switch); + //bool __fastcall AntiSlippingBrake(void); + //bool __fastcall BrakeReleaser(Byte state); + //bool __fastcall SwitchEPBrake(Byte state); + //bool __fastcall AntiSlippingButton(void); + //bool __fastcall IncBrakePress(double &brake, double PressLimit, double dp); + //bool __fastcall DecBrakePress(double &brake, double PressLimit, double dp); + //bool __fastcall BrakeDelaySwitch(Byte BDS); + //bool __fastcall IncBrakeMult(void); + //bool __fastcall DecBrakeMult(void); + //void __fastcall UpdateBrakePressure(double dt); + //void __fastcall UpdatePipePressure(double dt); + //void __fastcall CompressorCheck(double dt); + void __fastcall UpdatePantVolume(double dt); + //void __fastcall UpdateScndPipePressure(double dt); + //void __fastcall UpdateBatteryVoltage(double dt); + //double __fastcall GetDVc(double dt); + //void __fastcall ComputeConstans(void); + //double __fastcall ComputeMass(void); + //double __fastcall Adhesive(double staticfriction); + //double __fastcall TractionForce(double dt); + //double __fastcall FrictionForce(double R, Byte TDamage); + //double __fastcall BrakeForce(const TTrackParam &Track); + //double __fastcall CouplerForce(Byte CouplerN, double dt); + //void __fastcall CollisionDetect(Byte CouplerN, double dt); + //double __fastcall ComputeRotatingWheel(double WForce, double dt, double n); + //bool __fastcall SetInternalCommand(AnsiString NewCommand, double NewValue1, double NewValue2); + //double __fastcall GetExternalCommand(AnsiString &Command); + //bool __fastcall RunCommand(AnsiString command, double CValue1, double CValue2); + //bool __fastcall RunInternalCommand(void); + //void __fastcall PutCommand(AnsiString NewCommand, double NewValue1, double NewValue2, const TLocation + // &NewLocation); + //bool __fastcall DirectionBackward(void); + //bool __fastcall MainSwitch(bool State); + //bool __fastcall ConverterSwitch(bool State); + //bool __fastcall CompressorSwitch(bool State); + void __fastcall ConverterCheck(); + //bool __fastcall FuseOn(void); + //bool __fastcall FuseFlagCheck(void); + //void __fastcall FuseOff(void); + int __fastcall ShowCurrent(Byte AmpN); + //double __fastcall v2n(void); + //double __fastcall current(double n, double U); + //double __fastcall Momentum(double I); + //double __fastcall MomentumF(double I, double Iw, Byte SCP); + //bool __fastcall CutOffEngine(void); + //bool __fastcall MaxCurrentSwitch(bool State); + //bool __fastcall ResistorsFlagCheck(void); + //bool __fastcall MinCurrentSwitch(bool State); + //bool __fastcall AutoRelaySwitch(bool State); + //bool __fastcall AutoRelayCheck(void); + //bool __fastcall dizel_EngageSwitch(double state); + //bool __fastcall dizel_EngageChange(double dt); + //bool __fastcall dizel_AutoGearCheck(void); + //double __fastcall dizel_fillcheck(Byte mcp); + //double __fastcall dizel_Momentum(double dizel_fill, double n, double dt); + //bool __fastcall dizel_Update(double dt); + //bool __fastcall LoadingDone(double LSpeed, AnsiString LoadInit); + //void __fastcall ComputeTotalForce(double dt, double dt1, bool FullVer); + //double __fastcall ComputeMovement(double dt, double dt1, const TTrackShape &Shape, TTrackParam &Track + // , TTractionParam &ElectricTraction, const TLocation &NewLoc, TRotation &NewRot); + //double __fastcall FastComputeMovement(double dt, const TTrackShape &Shape, TTrackParam &Track, const + // TLocation &NewLoc, TRotation &NewRot); + //bool __fastcall ChangeOffsetH(double DeltaOffset); + //__fastcall T_MoverParameters(double VelInitial, AnsiString TypeNameInit, AnsiString NameInit, int LoadInitial + // , AnsiString LoadTypeInitial, int Cab); + //bool __fastcall LoadChkFile(AnsiString chkpath); + //bool __fastcall CheckLocomotiveParameters(bool ReadyFlag, int Dir); + //AnsiString __fastcall EngineDescription(int what); + //bool __fastcall DoorLeft(bool State); + //bool __fastcall DoorRight(bool State); + //bool __fastcall DoorBlockedFlag(void); + //bool __fastcall PantFront(bool State); + //bool __fastcall PantRear(bool State); + // +}; + +#endif diff --git a/Names.cpp b/Names.cpp new file mode 100644 index 00000000..07da8552 --- /dev/null +++ b/Names.cpp @@ -0,0 +1,167 @@ +//--------------------------------------------------------------------------- + +#include +#pragma hdrstop + +#include "Names.h" + +//--------------------------------------------------------------------------- + +#pragma package(smart_init) +/* +Moduł zarządzający plikami oraz wyszukiwaniem obiektów wg nazw. +1. Ma przydzielony z góry (EU07.INI) obszar pamięci (rzędu 16MB). +2. W przypadku przepełnienia dostępnej pamięci wystąpi błąd wczytywania. +3. Obszar ten będzie zużywany na rekordy obiektów oraz ciągi tekstowe z nazwami. +4. Rekordy będą sortowane w ramach typu (tekstury, dźwięki, modele, node, eventy). +5. Pierwszy etap wyszukiwania to 5 bitów z pierwszego bajtu i 3 z drugiego (256). +6. Dla plików istnieje możliwość wczytania ich w innym terminie. +7. Możliwość wczytania plików w oddzielnym watku (np. tekstur). + +Obsługiwane pliki: +1. Tekstury, można wczytywać później, rekord przechowuje numer podany przez kartę graficzną. +2. Dźwięki, można wczytać później. +3. Modele, można wczytać później o ile nie mają animacji eventami i nie dotyczą pojazdów. + +Obiekty sortowane wg nazw, można dodawać i usuwać komórki scenerii: +4. Tory, drogi, rzeki - wyszukiwanie w celu sprawdzenia zajetości. +5. Eventy - wyszukiwane przy zewnętrznym wywołaniu oraz podczas wczytywania. +6. Pojazdy - wyszukiwane w celu wysyłania komend. +7. Egzemplarze modeli animowanych - wyszukiwanie w celu połączenia z animacjami. + +*/ + +void __fastcall ItemRecord::TreeAdd(ItemRecord *r,int c) +{//dodanie rekordu do drzewa - ustalenie w której gałęzi + //zapisać w (iFlags) ile znaków jest zgodnych z nadrzędnym, żeby nie sprawdzać wszystkich od zera + if ((cName[c]&&r->cName[c])?cName[c]==r->cName[c]:false) + TreeAdd(r,c+1); //ustawić wg kolejnego znaku, chyba że zero + else + if ((unsigned char)(cName[c])<(unsigned char)(r->cName[c])) + {//zero jest najmniejsze - doczepiamy jako (rNext) + if (!rNext) rNext=r; + else rNext->TreeAdd(r,0); //doczepić do tej gałęzi + } + else + { + if (!rPrev) rPrev=r; + else rPrev->TreeAdd(r,0); //doczepić do tej gałęzi + } +}; + +void __fastcall ItemRecord::ListGet(ItemRecord *r,int*&n) +{//rekurencyjne wypełnianie posortowanej listy na podstawie drzewa + if (rPrev) rPrev->ListGet(r,n); //dodanie wszystkich wcześniejszych + *n++=this-r; //dodanie swojego indeksu do tabeli + if (rNext) rNext->ListGet(r,n); //dodanie wszystkich późniejszych +}; + +void* __fastcall ItemRecord::TreeFind(const char *n) +{//wyszukanie ciągu (n) + ItemRecord *r=TreeFindRecord(n); + return r?r->pData:NULL; +}; + +ItemRecord* __fastcall ItemRecord::TreeFindRecord(const char *n) +{//wyszukanie ciągu (n) + ItemRecord *r=this; //żeby nie robić rekurencji + int i=0; + do + { + if (!n[i]) if (!r->cName[i]) return r; //znaleziony + if (n[i]==r->cName[i]) + ++i; //porównać kolejny znak + else + if ((unsigned char)(n[i])<(unsigned char)(r->cName[i])) + { + i=0; //porównywać od nowa + r=r->rPrev; //wcześniejsza gałąź drzewa + } + else + { + i=0; //porównywać od nowa + r=r->rNext; //późniejsza gałąź drzewa + } + } while (r); + return NULL; +}; + +__fastcall TNames::TNames() +{//tworzenie bufora + iSize=16*1024*1024; //rozmiar bufora w bajtach + cBuffer=new char[iSize]; + ZeroMemory(cBuffer,iSize); //nie trzymać jakiś starych śmieci + rRecords=(ItemRecord*)cBuffer; + cLast=cBuffer+iSize; //bajt za buforem + iLast=-1; + ZeroMemory(rTypes,20*sizeof(ItemRecord*)); +}; + +int __fastcall TNames::Add(int t,const char *n) +{//dodanie obiektu typu (t) o nazwie (n) + int len=strlen(n)+1; //ze znacznikiem końca + cLast-=len; //rezerwacja miejsca + memcpy(cLast,n,len); //przekopiowanie tekstu do bufora + //cLast[len-1]='\0'; + rRecords[++iLast].cName=cLast; //połączenie nazwy z rekordem + rRecords[iLast].iFlags=t; + if (!rTypes[t]) + rTypes[t]=rRecords+iLast; //korzeń drzewa, bo nie było wcześniej + else + rTypes[t]->TreeAdd(rRecords+iLast,0); //doczepienie jako gałąź + //rTypes[t]=Sort(t); //sortowanie uruchamiać ręcznie + if ((iLast&0x3F)==0) //nie za często, bo sortowania zajmą więcej czasu niż wyszukiwania + Sort(t); //optymalizacja drzewa co jakiś czas + return iLast; +} +int __fastcall TNames::Add(int t,const char *n,void *d) +{ + int i=Add(t,n); + rRecords[iLast].pData=d; + return i; +}; + +bool __fastcall TNames::Update(int t,const char *n,void *d) +{//dodanie jeśli nie ma, wymiana (d), gdy jest + ItemRecord *r=FindRecord(t,n); //najpierw sprawdzić, czy już jest + if (r) + {//przy zdublowaniu nazwy podmieniać w drzewku na późniejszy + r->pData=d; + return true; //duplikat + } + //Add(t,n,d); //nazwa unikalna + return false; //został dodany nowy +}; + +ItemRecord* __fastcall TNames::TreeSet(int *n,int d,int u) +{//rekurencyjne wypełnianie drzewa pozycjami od (d) do (u) + if (d==u) + { + rRecords[n[d]].rPrev=rRecords[n[d]].rNext=NULL; + return rRecords+n[d]; //tej gałęzi nie ma + } + else if (d>u) return NULL; + int p=(u+d)>>1; //połowa + rRecords[n[p]].rPrev=TreeSet(n,d,p-1); //zapisanie wcześniejszych gałęzi + rRecords[n[p]].rNext=TreeSet(n,p+1,u); //zapisanie późniejszych gałęzi + return rRecords+n[p]; +}; + +void __fastcall TNames::Sort(int t) +{//przebudowa drzewa typu (t), zwraca wierzchołek drzewa + if (iLast<3) return; //jak jest mało, to nie ma sensu sortować + if (rTypes[t]) //jeśli jest jakiś rekord danego typu + {int *r=new int[iLast+1]; //robocza tablica indeksów - numery posortowanych rekordów + int *q=r; //wskaźnik roboczy, przekazywany przez referencję + rTypes[t]->ListGet(rRecords,q); //drzewo jest już posortowane - zamienić je na listę + rTypes[t]=TreeSet(r,0,(q-r)-1); + delete[] r; + } + return; +}; + +ItemRecord* __fastcall TNames::FindRecord(const int t,const char *n) +{//poszukiwanie rekordu w celu np. zmiany wskaźnika + return rTypes[t]?rTypes[t]->TreeFindRecord(n):NULL; +}; + diff --git a/Names.h b/Names.h new file mode 100644 index 00000000..03db8c9c --- /dev/null +++ b/Names.h @@ -0,0 +1,53 @@ +//--------------------------------------------------------------------------- + +#ifndef NamesH +#define NamesH +//--------------------------------------------------------------------------- +class ItemRecord +{//rekord opisujący obiekt; raz utworzony nie przemieszcza się + //rozmiar rekordu można zmienić w razie potrzeby +public: + char *cName; //wskaźnik do nazwy umieszczonej w buforze + int iFlags; //flagi bitowe + ItemRecord *rPrev,*rNext; //posortowane drzewo (przebudowywane w razie potrzeby) + union + {void *pData; //wskaźnik do obiektu + int iData; //albo numer obiektu (tekstury) + unsigned int uData; + }; + //typedef + void __fastcall ListGet(ItemRecord *r,int*&n); + void __fastcall TreeAdd(ItemRecord *r,int c); + template inline TOut* DataGet() {return (TOut*)pData;}; + template inline void DataSet(TOut *x) {pData=(void*)x;}; + void* __fastcall TreeFind(const char *n); + ItemRecord* __fastcall TreeFindRecord(const char *n); +}; + +class TNames +{ +public: + int iSize; //rozmiar bufora + char *cBuffer; //bufor dla rekordów (na początku) i nazw (na końcu) + ItemRecord *rRecords; //rekordy na początku bufora + char *cLast; //ostatni użyty bajt na nazwy + ItemRecord *rTypes[20]; //rożne typy obiektów (początek drzewa) + int iLast; //ostatnio użyty rekord +public: + __fastcall TNames(); + int __fastcall Add(int t,const char *n); //dodanie obiektu typu (t) + int __fastcall Add(int t,const char *n,void *d); //dodanie obiektu z wskaźnikiem + int __fastcall Add(int t,const char *n,int d); //dodanie obiektu z numerem + bool __fastcall Update(int t,const char *n,void *d); //dodanie jeśli nie ma, wymiana (d), gdy jest + void __fastcall TreeSet(); + ItemRecord* __fastcall TreeSet(int *n,int d,int u); + void __fastcall Sort(int t); //przebudowa drzewa typu (t) + ItemRecord* __fastcall Item(int n); //rekord o numerze (n) + inline void* Find(const int t,const char *n) + {return rTypes[t]?rTypes[t]->TreeFind(n):NULL;}; + ItemRecord* __fastcall FindRecord(const int t,const char *n); + //template inline TOut* Find(const int t,const char *n) + //{return (TOut*)(rTypes[t]->TreeFind(n));}; +}; +#endif + diff --git a/QueryParserComp.hpp b/QueryParserComp.hpp new file mode 100644 index 00000000..76abdbee --- /dev/null +++ b/QueryParserComp.hpp @@ -0,0 +1,151 @@ +// Borland C++ Builder +// Copyright (c) 1995, 1999 by Borland International +// All rights reserved + +// (DO NOT EDIT: machine generated header) 'QueryParserComp.pas' rev: 5.00 + +#ifndef QueryParserCompHPP +#define QueryParserCompHPP + +#pragma delphiheader begin +#pragma option push -w- +#pragma option push -Vx +#include // Pascal unit +#include // Pascal unit +#include // Pascal unit +#include // Pascal unit + +//-- user supplied ----------------------------------------------------------- + +namespace Queryparsercomp +{ +//-- type declarations ------------------------------------------------------- +#pragma option push -b- +enum TTokenType { ttString, ttSymbol, ttComment, ttDelimiter, ttSpecialChar, ttStatementDelimiter, ttCommentedSymbol, + ttCommentDelimiter }; +#pragma option pop + +typedef Set TSetOfChar; + +typedef AnsiString TComment[2]; + +#pragma option push -b- +enum TCharacterType { ctSymbol, ctBeginComment, ctEndComment, ctDelimiter, ctString, ctSpecialChar } + ; +#pragma option pop + +#pragma option push -b- +enum QueryParserComp__1 { cmt1, cmt2, cmt3 }; +#pragma option pop + +typedef Set TCommentType; + +typedef AnsiString QueryParserComp__2[3][2]; + +typedef void __fastcall (__closure *TEndOfStatement)(System::TObject* Sender, AnsiString SQLStatement + ); + +class DELPHICLASS TQueryParserComp; +class PASCALIMPLEMENTATION TQueryParserComp : public Classes::TComponent +{ + typedef Classes::TComponent inherited; + +private: + Classes::TStringStream* FStream; + bool FEOF; + AnsiString FToken; + TTokenType FTokenType; + bool FComment; + bool FString; + bool FWasString; + TCommentType FCommentType; + AnsiString FStringDelimiters; + AnsiString FLastStringDelimiterFound; + int FSymbolsCount; + AnsiString FSpecialCharacters; + bool FRemoveStrDelimiter; + AnsiString FStringToParse; + int FGoPosition; + TEndOfStatement FOnStatementDelimiter; + bool FCountFromStatement; + Classes::TStringList* FStatementDelimiters; + char FStringDelimiter; + bool FGenerateOnStmtDelimiter; + void __fastcall Init(void); + void __fastcall SetStringToParse(AnsiString AStringToParse); + bool __fastcall StatementDelimiter(void); + bool __fastcall CheckForBeginComment(void); + bool __fastcall CheckForEndComment(char Character); + TCharacterType __fastcall CharacterType(char Character); + bool __fastcall CheckCharcterType(char Character); + bool __fastcall StringDelimiter(char Character); + bool __fastcall SpecialCharacter(char Character); + void __fastcall RemoveStringDelimiter(AnsiString &Source); + void __fastcall SetDelimiterType(AnsiString Source); + void __fastcall SetToken(void); + void __fastcall SetSD(Classes::TStringList* ASD); + void __fastcall SetSpecialCharacters(AnsiString ASpecialCharacters); + void __fastcall SetStringDelimiters(AnsiString AStringDelimiters); + +protected: + DYNAMIC void __fastcall DoStatementDelimiter(void); + +public: + __fastcall virtual TQueryParserComp(Classes::TComponent* AOwner); + __fastcall virtual ~TQueryParserComp(void); + void __fastcall LoadStringToParse(AnsiString FileName); + void __fastcall First(void); + void __fastcall FirstToken(void); + void __fastcall NextToken(void); + AnsiString __fastcall GetNextSymbol(); + __property bool EndOfFile = {read=FEOF, nodefault}; + __property bool Comment = {read=FComment, nodefault}; + __property AnsiString Token = {read=FToken}; + __property TTokenType TokenType = {read=FTokenType, nodefault}; + __property char CurrentStringDelimiter = {read=FStringDelimiter, nodefault}; + __property int SymbolsCount = {read=FSymbolsCount, default=0}; + __property Classes::TStringStream* StringStream = {read=FStream}; + +__published: + __property bool IsEOFStmtDelimiter = {read=FGenerateOnStmtDelimiter, write=FGenerateOnStmtDelimiter + , nodefault}; + __property AnsiString StringDelimiters = {read=FStringDelimiters, write=SetStringDelimiters}; + __property AnsiString SpecialCharacters = {read=FSpecialCharacters, write=SetSpecialCharacters}; + __property bool RemoveStrDelimiter = {read=FRemoveStrDelimiter, write=FRemoveStrDelimiter, nodefault + }; + __property bool CountFromStatement = {read=FCountFromStatement, write=FCountFromStatement, nodefault + }; + __property AnsiString TextToParse = {read=FStringToParse, write=SetStringToParse}; + __property Classes::TStringList* StatementDelimiters = {read=FStatementDelimiters, write=SetSD}; + __property TEndOfStatement OnStatementDelimiter = {read=FOnStatementDelimiter, write=FOnStatementDelimiter + }; +}; + + +//-- var, const, procedure --------------------------------------------------- +extern PACKAGE System::ResourceString _sTextNotSet; +#define Queryparsercomp_sTextNotSet System::LoadResourceString(&Queryparsercomp::_sTextNotSet) +extern PACKAGE System::ResourceString _sIllegalSpecialChar; +#define Queryparsercomp_sIllegalSpecialChar System::LoadResourceString(&Queryparsercomp::_sIllegalSpecialChar) + +extern PACKAGE System::ResourceString _sIllegalStringChar; +#define Queryparsercomp_sIllegalStringChar System::LoadResourceString(&Queryparsercomp::_sIllegalStringChar) + +static const char CR = '\xd'; +static const char LF = '\xa'; +static const char TAB = '\x9'; +#define CRLF "\r\n" +extern PACKAGE TSetOfChar Delimiters; +extern PACKAGE AnsiString Comments[3][2]; +extern PACKAGE void __fastcall Register(void); + +} /* namespace Queryparsercomp */ +#if !defined(NO_IMPLICIT_NAMESPACE_USE) +using namespace Queryparsercomp; +#endif +#pragma option pop // -w- +#pragma option pop // -Vx + +#pragma delphiheader end. +//-- end unit ---------------------------------------------------------------- +#endif // QueryParserComp diff --git a/QueryParserComp.pas b/QueryParserComp.pas new file mode 100644 index 00000000..8c0101d7 --- /dev/null +++ b/QueryParserComp.pas @@ -0,0 +1,724 @@ +unit QueryParserComp; + +interface + +uses + Classes, Sysutils; + +resourcestring + sTextNotSet = 'You must set the TextToParse property first.'; + sIllegalSpecialChar = 'Illegal special character.'; + sIllegalStringChar = 'Illegal string delimiter.'; + +type + TTokenType = (ttString, ttSymbol, ttComment, ttDelimiter, ttSpecialChar, + ttStatementDelimiter, ttCommentedSymbol, ttCommentDelimiter); + TSetOfChar = set of Char; + TComment = array[0..1] of string; + TCharacterType = (ctSymbol, ctBeginComment, ctEndComment, ctDelimiter, + ctString, ctSpecialChar); + TCommentType = set of (cmt1, cmt2, cmt3); + +const + CR = #13; + LF = #10; + TAB = #9; + CRLF = CR + LF; + Delimiters: TSetOfChar = [' ', ',', ';', CR, LF, TAB]; + Comments: array[0..2] of TComment = (('/*', '*/'), ('#', LF), ('//', LF)); + +type + TEndOfStatement = procedure(Sender: TObject; SQLStatement: String) of object; + + TQueryParserComp = class(TComponent) + private + FStream: TStringStream; + FEOF: Boolean; + FToken: String; + FTokenType: TTokenType; + FComment: Boolean; + FString: Boolean; + FWasString: Boolean; + FCommentType: TCommentType; + FStringDelimiters: String; + FLastStringDelimiterFound: String; + FSymbolsCount: Integer; + FSpecialCharacters: String; + FRemoveStrDelimiter: Boolean; + FStringToParse: String; + FGoPosition: Integer; + FOnStatementDelimiter: TEndOfStatement; + FCountFromStatement: Boolean; + FStatementDelimiters: TStringList; + FStringDelimiter: Char; + FGenerateOnStmtDelimiter: Boolean; + procedure Init; + procedure SetStringToParse(AStringToParse: String); + function StatementDelimiter: Boolean; + function CheckForBeginComment: Boolean; + function CheckForEndComment(Character: Char): Boolean; + function CharacterType(Character: Char): TCharacterType; + function CheckCharcterType(Character: Char): Boolean; + function StringDelimiter(Character: Char): Boolean; + function SpecialCharacter(Character: Char): Boolean; + procedure RemoveStringDelimiter(var Source: String); + procedure SetDelimiterType(Source: String); + procedure SetToken; + procedure SetSD(ASD: TStringList); + procedure SetSpecialCharacters(ASpecialCharacters: String); + procedure SetStringDelimiters(AStringDelimiters: String); + protected + procedure DoStatementDelimiter; dynamic; + public + constructor Create(AOwner: TComponent); override; + destructor Destroy; override; + procedure LoadStringToParse(FileName: string); + procedure First; + procedure FirstToken; + procedure NextToken; + function GetNextSymbol : string; + property EndOfFile: Boolean read FEOF; + property Comment: Boolean read FComment; + property Token: String read FToken; + property TokenType: TTokenType read FTokenType; + property CurrentStringDelimiter: Char read FStringDelimiter; + property SymbolsCount: Integer read FSymbolsCount default 0; + property StringStream: TStringStream read FStream; + published + property IsEOFStmtDelimiter: Boolean read FGenerateOnStmtDelimiter + write FGenerateOnStmtDelimiter; + property StringDelimiters: String read FStringDelimiters + write SetStringDelimiters; + property SpecialCharacters: String read FSpecialCharacters + write SetSpecialCharacters; + property RemoveStrDelimiter: Boolean read FRemoveStrDelimiter + write FRemoveStrDelimiter; + property CountFromStatement: Boolean read FCountFromStatement + write FCountFromStatement; + property TextToParse: String read FStringToParse + write SetStringToParse; + property StatementDelimiters: TStringList read FStatementDelimiters write SetSD; + property OnStatementDelimiter: TEndOfStatement read FOnStatementDelimiter + write FOnStatementDelimiter; + end; + +procedure Register; + +implementation + +{ TSQLParser } + +procedure Register; +begin + RegisterComponents('Samples', [TQueryParserComp]); +end; + +constructor TQueryParserComp.Create(AOwner: TComponent); +begin + inherited; + FStatementDelimiters := TStringList.Create; + FStatementDelimiters.Add('GO'); + FStatementDelimiters.Add(';'); + FCountFromStatement := True; +end; + +procedure TQueryParserComp.LoadStringToParse(FileName: string); +var + fs:TFileStream; + size:integer; +begin + + fs:= TFileStream.Create(FileName, fmOpenRead); + + size:= fs.Size; + + if Assigned(FStream) then + FStream.Free; + + FStream := TStringStream.Create(''); + FStream.CopyFrom(fs,size); + fs.Free; + Init; + First; +end; + +procedure TQueryParserComp.FirstToken; +begin + Init; + NextToken; +end; + +function TQueryParserComp.CheckForBeginComment: Boolean; +var + Buffer: String; +begin + Result := False; + if not FEOF and not FString then + begin + Buffer := FStream.ReadString(1); + if cmt1 in FCommentType then + if Buffer[1] = '*' then + begin + FCommentType := [cmt1]; + Result := True; + end; + if cmt2 in FCommentType then + if Buffer[1] = '/' then + begin + FCommentType := [cmt2]; + Result := True; + end; + if cmt3 in FCommentType then + if Buffer[1] = '-' then + begin + FCommentType := [cmt3]; + Result := True; + end; + FStream.Seek(-1, soFromCurrent); + end; +end; + +procedure TQueryParserComp.SetDelimiterType(Source: String); +begin + FToken := Source[1]; + + if ((cmt2 in FCommentType) or (cmt3 in FCommentType)) and FComment + and ((Source[1] = CR) or (Source[1] = LF)) then + begin + FComment := False; + FTokenType := ttCommentDelimiter; + end + else + FTokenType := ttDelimiter; +end; + +procedure TQueryParserComp.NextToken; +var + Buffer: String; + ETextNotSet: Exception; +begin + if FEOF then + Exit; + + if not Assigned(FStream) then + begin + ETextNotSet := Exception.Create(sTextNotSet); + raise ETextNotSet; + end; + + if not FString then + FStringDelimiter := ' '; + + FToken := ''; + if not FEOF then + begin + Buffer := FStream.ReadString(1); + if Length(Buffer) > 0 then + begin + if (Buffer[1] in Delimiters) and not (FString or FComment)then + SetDelimiterType(Buffer) + else + begin + if FStream.Position > 0 then + FStream.Seek(-1, soFromCurrent); + SetToken; + end; + end + else + FEOF := True; + end; + + case FTokenType of + ttSymbol: Inc(FSymbolsCount); + ttString: + begin + FStringDelimiter := FToken[1]; + if FRemoveStrDelimiter then + RemoveStringDelimiter(FToken); + end; + end; + + if StatementDelimiter then + FTokenType := ttStatementDelimiter; + + if FEOF then + begin + FLastStringDelimiterFound := ''; + FWasString := False; + FString := False; + + if FGenerateOnStmtDelimiter then + DoStatementDelimiter; + end; +end; + +function TQueryParserComp.GetNextSymbol : string; +begin + GetNextSymbol:= ''; + while ( not EndOfFile) do + begin + NextToken; + if (TokenType=ttSymbol) then + begin + GetNextSymbol:= Token; + break; + end + end + +end; + +function TQueryParserComp.StatementDelimiter: Boolean; +var + i: Integer; +begin + Result := False; + if not FString then + for i := 0 to FStatementDelimiters.Count - 1 do + begin + Result := (UpperCase(FToken) = UpperCase(FStatementDelimiters.Strings[i])); + if Result then + begin + if FCountFromStatement then + FSymbolsCount := 0; + DoStatementDelimiter; + Break; + end; + end; +end; + +function TQueryParserComp.CharacterType(Character: Char): TCharacterType; +begin + Result := ctSymbol; + case Character of + '/': + begin + if not FComment then + begin + FCommentType := [cmt1, cmt2]; + if CheckForBeginComment then + Result := ctBeginComment; + end; + end; + '-': + begin + if not FComment then + begin + FCommentType := [cmt3]; + if CheckForBeginComment then + Result := ctBeginComment; + end; + end; + '*': + begin + if CheckForEndComment(Character) then + Result := ctEndComment; + end; + CR, LF, ' ', ',', TAB: + begin + if CheckForEndComment(Character) then + Result := ctEndComment + else + Result := ctDelimiter; + + if FString and ((Character = CR) or (Character = LF)) then + begin + FString := False; + FWasString := False; + Result := ctDelimiter; + end; + end; + end; + + if not FString then + if SpecialCharacter(Character) then + begin + if not FComment then + Result := ctSpecialChar; + end; + + if not FComment then + if StringDelimiter(Character) then + begin + Result := ctSymbol; + if FString then + begin + FLastStringDelimiterFound := ''; + FWasString := True; + FString := False; + end + else + begin + FWasString := False; + FString := True; + end; + end; +end; + +function TQueryParserComp.CheckForEndComment(Character: Char): Boolean; +var + Buffer: String; +begin + Result := False; + + if not FComment or FString then + Exit; + + if not FEOF then + begin + if cmt1 in FCommentType then + begin + Buffer := FStream.ReadString(1); + if Buffer[1] = '/' then + Result := True; + + FStream.Seek(-1, soFromCurrent); + end; + if (cmt2 in FCommentType) or (cmt3 in FCommentType) then + begin + if (Character = CR) or (Character = LF) then + Result := True; + end; + end; +end; + +function TQueryParserComp.CheckCharcterType(Character: Char): Boolean; +var + Buffer: String; +begin + Result := False; + case CharacterType(Character) of + ctBeginComment: + begin + if not FComment then + begin + if FToken <> '' then + begin + FStream.Seek(-1, soFromCurrent); + FTokenType := ttSymbol; + end + else + begin + FComment := True; + FToken := FToken + Character; + Buffer := FStream.ReadString(1); + FToken := FToken + Buffer; + FTokenType := ttComment; + end; + Result := True; + end; + end; + ctEndComment: + begin + if FComment then + begin + Result := True; + if FToken <> '' then + begin + FStream.Seek(-1, soFromCurrent); + FTokenType := ttCommentedSymbol; + end + else + begin + FComment := False; + FToken := FToken + Character; + if FCommentType = [cmt1] then + begin + Buffer := FStream.ReadString(1); + FToken := FToken + Buffer; + end; + FTokenType := ttComment; + end; + end; + end; + ctSymbol: + begin + FToken := FToken + Character; + if FComment then + FTokenType := ttCommentedSymbol + else + begin + if FString or FWasString then + begin + if FWasString then + begin + FTokenType := ttString; + FWasString := False; + + + Result := True; + end + else + FTokenType := ttString; + end + else + FTokenType := ttSymbol; + end; + end; + ctSpecialChar: + begin + if FToken <> '' then + begin + FStream.Seek(-1, soFromCurrent); + FTokenType := ttSymbol; + end + else + begin + FToken := FToken + Character; + FTokenType := ttSpecialChar; + end; + Result := True; + end; + ctDelimiter: + begin + FTokenType := ttDelimiter; + Result := True; + end; + end +end; + +procedure TQueryParserComp.RemoveStringDelimiter(var Source: String); +var + EndOfString: Integer; + i: Integer; +begin + for i := 1 to Length(FStringDelimiters) do + begin + EndOfString := 1; + while not (EndOfString = 0) do + begin + EndOfString := Pos(FStringDelimiters[i], Source); + if EndOfString <> 0 then + begin + FLastStringDelimiterFound := Copy(FStringDelimiters, i, 1); + Delete(Source, EndOfString, 1); + end; + end; + end; +end; + +function TQueryParserComp.StringDelimiter(Character: Char): Boolean; +var + i: Integer; + Buffer: String; +begin + Result := False; + + for i := 1 to Length(FStringDelimiters) do + if (Character = FStringDelimiters[i]) then + begin + if (FLastStringDelimiterFound = '') then + FLastStringDelimiterFound := FStringDelimiters[i]; + + if (FLastStringDelimiterFound = FStringDelimiters[i]) then + begin + if not FEOF then + Buffer := FStream.ReadString(1); + + if Length(Buffer) > 0 then + begin + if Buffer[1] <> Character then + begin + FStream.Seek(-1, soFromCurrent); + Result := True; + end + else + FToken := FToken + Buffer; + end + else + Result := True; + end; + end; +end; + +function TQueryParserComp.SpecialCharacter(Character: Char): Boolean; +var + i: Integer; +begin + Result := False; + for i := 1 to Length(FSpecialCharacters) do + if Character = FSpecialCharacters[i] then + Result := True; +end; + +procedure TQueryParserComp.SetToken; +var + EndToken: Boolean; + Buffer: String; +begin + EndToken := False; + while not (EndToken or FEOF) do + begin + FEOF := FStream.Position >= FStream.Size-1; + Buffer := FStream.ReadString(1); + + if not (Buffer[1] in Delimiters) then + EndToken := CheckCharcterType(Buffer[1]) + else + begin + if not (FString or FComment) then + begin + EndToken := True; + FStream.Seek(-1, soFromCurrent); + end + else + begin + if FString and ((Buffer[1] = CR) or (Buffer[1] = LF)) then + begin + FString := False; + FWasString := False; + EndToken := True; + end + else + if FComment and ((cmt2 in FCommentType) or + (cmt3 in FCommentType)) and ((Buffer[1] = CR) or + (Buffer[1] = LF)) then + begin + EndToken := True; + FStream.Seek(-1, soFromCurrent); + FComment := False; + FCommentType := []; + end + else + FToken := FToken + Buffer; + end; + end; + end; //while +end; + +destructor TQueryParserComp.Destroy; +begin + if Assigned(FStream) then + FStream.Free; + + inherited Destroy; +end; + +procedure TQueryParserComp.DoStatementDelimiter; +var + Buffer: String; + CurrentPosition: Integer; +begin + if Assigned(FOnStatementDelimiter) then + begin + CurrentPosition := FStream.Position; + FStream.Seek(FGoPosition, soFromBeginning); + Buffer := FStream.ReadString(CurrentPosition-FGoPosition-Length(FToken)); + FStream.Seek(Length(FToken), soFromCurrent); + if FStream.Position >= FStream.Size then + FEOF := True; + + FGoPosition := FStream.Position; + + if FCountFromStatement then + FSymbolsCount := 0; + + FOnStatementDelimiter(Self, Trim(Buffer)); + end; +end; + +procedure TQueryParserComp.SetStringToParse(AStringToParse: String); +begin + + if AStringToParse = '' then + Exit; + + if Assigned(FStream) then + FStream.Free; + + TrimRight(AStringToParse); + FStream := TStringStream.Create(AStringToParse); + FStringToParse := AStringToParse; + + Init; +end; + +procedure TQueryParserComp.SetSD(ASD: TStringList); +begin + FStatementDelimiters.Assign(ASD); +end; + +procedure TQueryParserComp.First; +begin + Init; +end; + +procedure TQueryParserComp.Init; +var + ETextNotSet: Exception; +begin + if not Assigned(FStream) then + begin + ETextNotSet := Exception.Create(sTextNotSet); + raise ETextNotSet; + end; + + FStream.Seek(0, soFromBeginning); + FToken := ''; + FTokenType := ttString; + FComment := False; + FCommentType := []; + FEOF := False; + FSymbolsCount := 0; + FGoPosition := 0; + FLastStringDelimiterFound := ''; + FWasString := False; + FString := False; +end; + +procedure TQueryParserComp.SetSpecialCharacters(ASpecialCharacters: String); +var + i: Integer; + k: Integer; + IllegalSpecialChar: Exception; +begin + for i := 1 to Length(ASpecialCharacters) do + begin + for k := 0 to FStatementDelimiters.Count - 1 do + begin + if (Pos(ASpecialCharacters[i], FStatementDelimiters.Strings[k]) <> 0) then + begin + IllegalSpecialChar := Exception.Create(sIllegalSpecialChar); + raise IllegalSpecialChar; + end; + end; + + if (ASpecialCharacters[i] in Delimiters) or + (Pos(ASpecialCharacters[i], FStringDelimiters) <> 0) then + begin + IllegalSpecialChar := Exception.Create(sIllegalSpecialChar); + raise IllegalSpecialChar; + end; + end; + + FSpecialCharacters := ASpecialCharacters; +end; + +procedure TQueryParserComp.SetStringDelimiters(AStringDelimiters: String); +var + i: Integer; + k: Integer; + IllegalStringChar: Exception; +begin + for i := 1 to Length(AStringDelimiters) do + begin + for k := 0 to FStatementDelimiters.Count - 1 do + begin + if (Pos(AStringDelimiters[i], FStatementDelimiters.Strings[k]) <> 0) then + begin + IllegalStringChar := Exception.Create(sIllegalStringChar); + raise IllegalStringChar; + end; + end; + + if (AStringDelimiters[i] in Delimiters) or + (Pos(AStringDelimiters[i], FSpecialCharacters) <> 0) then + begin + IllegalStringChar := Exception.Create(sIllegalStringChar); + raise IllegalStringChar; + end; + end; + + FStringDelimiters := AStringDelimiters; +end; + +end. diff --git a/RealSound.cpp b/RealSound.cpp new file mode 100644 index 00000000..73e4cdfd --- /dev/null +++ b/RealSound.cpp @@ -0,0 +1,277 @@ +//--------------------------------------------------------------------------- +/* + MaSzyna EU07 locomotive simulator + Copyright (C) 2001-2004 Marcin Wozniak, Maciej Czapkiewicz and others + +*/ + +#include "system.hpp" +#include "classes.hpp" +#pragma hdrstop + +#include "math.h" +#include "RealSound.h" +#include "Globals.h" +#include "Timer.h" +#include "Logs.h" +#include "McZapkie\mctools.hpp" + +__fastcall TRealSound::TRealSound() +{ + pSound=NULL; + dSoundAtt=-1; + AM=0.0; + AA=0.0; + FM=0.0; + FA=0.0; + vSoundPosition.x=0; + vSoundPosition.y=0; + vSoundPosition.z=0; + fDistance=fPreviousDistance=0.0; + fFrequency=22050.0; //częstotliwość samplowania pliku + iDoppler=0; //normlanie jest załączony; !=0 - modyfikacje + bLoopPlay=false; //dźwięk wyłączony +} + +__fastcall TRealSound::~TRealSound() +{ + //if (this) if (pSound) pSound->Stop(); +} + +void __fastcall TRealSound::Free() +{ +} + +void __fastcall TRealSound::Init(char *SoundName, double DistanceAttenuation, double X, double Y, double Z,bool Dynamic,bool freqmod,double rmin) +{ + //Nazwa=SoundName; //to tak raczej nie zadziała, (SoundName) jest tymczasowe + pSound=TSoundsManager::GetFromName(SoundName,Dynamic,&fFrequency); + if (pSound) + { + if (freqmod) + if (fFrequency!=22050.0) + {//dla modulowanych nie może być zmiany mnożnika, bo częstotliwość w nagłówku byłą ignorowana, a mogła być inna niż 22050 + fFrequency=22050.0; + ErrorLog("Bad sound: "+AnsiString(SoundName)+", as modulated, should have 22.05kHz in header"); + } + AM=1.0; + pSound->SetVolume(DSBVOLUME_MIN); + } + else + {//nie ma dźwięku, to jest wysyp + AM=0; + ErrorLog("Missed sound: "+AnsiString(SoundName)); + } + if (DistanceAttenuation>0.0) + { + dSoundAtt=DistanceAttenuation*DistanceAttenuation; + vSoundPosition.x=X; + vSoundPosition.y=Y; + vSoundPosition.z=Z; + if (rmin<0) iDoppler=1; //wyłączenie efektu Dopplera, np. dla dźwięku ptaków + } + else + dSoundAtt=-1; +}; + + +double __fastcall TRealSound::ListenerDistance(vector3 ListenerPosition) +{ + if (dSoundAtt==-1) + { return 0.0; } + else + { return SquareMagnitude(ListenerPosition-vSoundPosition); } +} + +void __fastcall TRealSound::Play(double Volume, int Looping, bool ListenerInside, vector3 NewPosition) +{ + if (!pSound) return; + long int vol; + double dS; +// double Distance; + DWORD stat; + if ((Global::bSoundEnabled)&&(AM!=0)) + { + if (Volume>1.0) + Volume=1.0; + fPreviousDistance=fDistance; + fDistance=0.0; //?? + if (dSoundAtt>0.0) + { + vSoundPosition=NewPosition; + dS=dSoundAtt; //*dSoundAtt; //bo odleglosc podawana w kwadracie + fDistance=ListenerDistance(Global::pCameraPosition); + if (ListenerInside) //osłabianie dźwięków z odległością + Volume=Volume*dS/(dS+fDistance); + else + Volume=Volume*dS/(dS+2*fDistance); //podwójne dla ListenerInside=false + } + if (iDoppler) // + {//Ra 2014-07: efekt Dopplera nie zawsze jest wskazany + //if (FreeFlyModeFlag) //gdy swobodne latanie - nie sprawdza się to + fPreviousDistance=fDistance; //to efektu Dopplera nie będzie + } + if (Looping) //dźwięk zapętlony można wyłączyć i zostanie włączony w miarę potrzeby + bLoopPlay=true; //dźwięk wyłączony + //McZapkie-010302 - babranie tylko z niezbyt odleglymi dźwiękami + if ((dSoundAtt==-1)||(fDistance<20.0*dS)) + { +// vol=2*Volume+1; +// if (vol<1) vol=1; +// vol=10000*(log(vol)-1); +// vol=10000*(vol-1); + //int glos=1; + //Volume=Volume*glos; //Ra: whatta hella is this + if (Volume<0.0) Volume=0.0; + vol=-5000.0+5000.0*Volume; + if (vol>=0) + vol=-1; + if (Timer::GetSoundTimer()||!Looping) //Ra: po co to jest? + pSound->SetVolume(vol); //Attenuation, in hundredths of a decibel (dB). + pSound->GetStatus(&stat); + if (!(stat&DSBSTATUS_PLAYING)) + pSound->Play(0,0,Looping); + } + else //wylacz dzwiek bo daleko + {//Ra 2014-09: oddalanie się nie może być powodem do wyłączenie dźwięku +/* +// Ra: stara wersja, ale podobno lepsza + pSound->GetStatus(&stat); + if (bLoopPlay) //jeśli zapętlony, to zostanie ponownie włączony, o ile znajdzie się bliżej + if (stat&DSBSTATUS_PLAYING) + pSound->Stop(); +// Ra: wyłączyłem, bo podobno jest gorzej niż wcześniej + //ZiomalCl: dźwięk po wyłączeniu sam się nie włączy, gdy wrócimy w rejon odtwarzania + pSound->SetVolume(DSBVOLUME_MIN); //dlatego lepiej go wyciszyć na czas oddalenia się + pSound->GetStatus(&stat); + if (!(stat&DSBSTATUS_PLAYING)) + pSound->Play(0,0,Looping); //ZiomalCl: włączenie odtwarzania rownież i tu, gdyż jesli uruchamiamy dźwięk poza promieniem, nie uruchomi się on w ogóle +*/ + } + } +}; + +void __fastcall TRealSound::Start() +{//włączenie dźwięku + +}; + +void __fastcall TRealSound::Stop() +{ + DWORD stat; + if (pSound) + if ((Global::bSoundEnabled)&&(AM!=0)) + { + bLoopPlay=false; //dźwięk wyłączony + pSound->GetStatus(&stat); + if (stat&DSBSTATUS_PLAYING) + pSound->Stop(); + } +}; + +void __fastcall TRealSound::AdjFreq(double Freq, double dt) //McZapkie TODO: dorobic tu efekt Dopplera +//Freq moze byc liczba dodatnia mniejsza od 1 lub wieksza od 1 +{ + float df, Vlist, Vsrc; + if ((Global::bSoundEnabled) && (AM!=0)) + { + if (dt>0) +//efekt Dopplera + { + Vlist=(sqrt(fPreviousDistance)-sqrt(fDistance))/dt; + df= Freq*(1+Vlist/299.8); + } + else + df=Freq; + if (Timer::GetSoundTimer()) + { + df=fFrequency*df; //TODO - brac czestotliwosc probkowania z wav + pSound->SetFrequency(( dfDSBFREQUENCY_MAX ? DSBFREQUENCY_MAX : df) ) ); + } + } +} + +double TRealSound::GetWaveTime() //McZapkie: na razie tylko dla 22KHz/8bps +{//używana do pomiaru czasu dla dźwięków z początkiem i końcem + if (!pSound) return 0.0; + double WaveTime; + DSBCAPS caps; + caps.dwSize=sizeof(caps); + pSound->GetCaps(&caps); + WaveTime=caps.dwBufferBytes; + return WaveTime/fFrequency; //(pSound->); // wielkosc w bajtach przez czestotliwosc probkowania +} + +void __fastcall TRealSound::SetPan(int Pan) +{ + pSound->SetPan(Pan); +} + +int TRealSound::GetStatus() +{ +DWORD stat; + if ((Global::bSoundEnabled) && (AM!=0)) + { + pSound->GetStatus(&stat); + return stat; + } + else + return 0; +} + +void __fastcall TRealSound::ResetPosition() +{ + if (pSound) //Ra: znowu jakiś badziew! + pSound->SetCurrentPosition(0); +} + +void __fastcall TTextSound::Init(char *SoundName,double SoundAttenuation,double X,double Y,double Z,bool Dynamic,bool freqmod,double rmin) +{//dodatkowo doczytuje plik tekstowy + TRealSound::Init(SoundName,SoundAttenuation,X,Y,Z,Dynamic,freqmod,rmin); + fTime=GetWaveTime(); + AnsiString txt=AnsiString(SoundName); + txt.Delete(txt.Length()-3,4); //obcięcie rozszerzenia + for (int i=txt.Length();i>0;--i) + if (txt[i]=='/') txt[i]='\\'; //bo nie rozumi + txt+="-"+Global::asLang+".txt"; //już może być w różnych językach + if (!FileExists(txt)) + txt="sounds\\"+txt; //ścieżka może nie być podana + if (FileExists(txt)) + {//wczytanie + TFileStream *ts=new TFileStream(txt,fmOpenRead); + asText=AnsiString::StringOfChar(' ',ts->Size); + ts->Read(asText.c_str(),ts->Size); + delete ts; + } +}; +void __fastcall TTextSound::Play(double Volume,int Looping,bool ListenerInside,vector3 NewPosition) +{ + if (!asText.IsEmpty()) + {//jeśli ma powiązany tekst + DWORD stat; + pSound->GetStatus(&stat); + if (!(stat&DSBSTATUS_PLAYING)) //jeśli nie jest aktualnie odgrywany + { + int i; + AnsiString t=asText; + do + {//na razie zrobione jakkolwiek, docelowo przenieść teksty do tablicy nazw + i=t.Pos("\r"); //znak nowej linii + if (!i) + Global::tranTexts.Add(t.c_str(),fTime,true); + else + { + Global::tranTexts.Add(t.SubString(1,i-1).c_str(),fTime,true); + t.Delete(1,i); + while (t.IsEmpty()?false:(unsigned char)(t[1])<33) + t.Delete(1,1); + } + } while (i>0); + } + } + TRealSound::Play(Volume,Looping,ListenerInside,NewPosition); +}; + +//--------------------------------------------------------------------------- +#pragma package(smart_init) + diff --git a/RealSound.h b/RealSound.h new file mode 100644 index 00000000..90d6d3e5 --- /dev/null +++ b/RealSound.h @@ -0,0 +1,66 @@ +//--------------------------------------------------------------------------- +#ifndef RealSoundH +#define RealSoundH + +#include "Sound.h" +#include "Geometry.h" + +class TRealSound +{ +protected: + PSound pSound; + char* Nazwa; //dla celow odwszawiania + double fDistance,fPreviousDistance; //dla liczenia Dopplera + float fFrequency; //częstotliwość samplowania pliku + int iDoppler; //Ra 2014-07: możliwość wyłączenia efektu Dopplera np. dla śpiewu ptaków +public: + vector3 vSoundPosition; //polozenie zrodla dzwieku + double dSoundAtt; //odleglosc polowicznego zaniku dzwieku + double AM; //mnoznik amplitudy + double AA; //offset amplitudy + double FM; //mnoznik czestotliwosci + double FA; //offset czestotliwosci + bool bLoopPlay; //czy zapętlony dźwięk jest odtwarzany + __fastcall TRealSound(); + __fastcall ~TRealSound(); + void __fastcall Free(); + void __fastcall Init(char *SoundName,double SoundAttenuation,double X,double Y,double Z,bool Dynamic,bool freqmod=false,double rmin=0.0); + double __fastcall ListenerDistance(vector3 ListenerPosition); + void __fastcall Play(double Volume,int Looping,bool ListenerInside,vector3 NewPosition); + void __fastcall Start(); + void __fastcall Stop(); + void __fastcall AdjFreq(double Freq,double dt); + void __fastcall SetPan(int Pan); + double GetWaveTime(); //McZapkie TODO: dorobic dla roznych bps + int GetStatus(); + void __fastcall ResetPosition(); + //void __fastcall FreqReset(float f=22050.0) {fFrequency=f;}; +}; + +class TTextSound : public TRealSound +{//dźwięk ze stenogramem + AnsiString asText; + float fTime; //czas trwania +public: + void __fastcall Init(char *SoundName,double SoundAttenuation,double X,double Y,double Z,bool Dynamic,bool freqmod=false,double rmin=0.0); + void __fastcall Play(double Volume,int Looping,bool ListenerInside,vector3 NewPosition); +}; + +class TSynthSound +{//klasa generująca sygnał odjazdu (Rp12, Rp13), potem rozbudować o pracę manewrowego... + int iIndex[44]; //indeksy początkowe, gdy mamy kilka wariantów dźwięków składowych + //0..9 - cyfry 0..9 + //10..19 - liczby 10..19 + //21..29 - dziesiątki (*21==*10?) + //31..39 - setki 100,200,...,800,900 + //40 - "tysiąc" + //41 - "tysiące" + //42 - indeksy początkowe dla "odjazd" + //43 - indeksy początkowe dla "gotów" + PSound *sSound; //posortowana tablica dźwięków, rozmiar zależny od liczby znalezionych plików + //a może zamiast wielu plików/dźwięków zrobić jeden połączony plik i posługiwać się czasem od..do? +}; + + +//--------------------------------------------------------------------------- +#endif diff --git a/ResourceManager.cpp b/ResourceManager.cpp new file mode 100644 index 00000000..20e1b927 --- /dev/null +++ b/ResourceManager.cpp @@ -0,0 +1,78 @@ +#include "ResourceManager.h" +#include "Logs.h" + +#include + +ResourceManager::Resources ResourceManager::_resources; +double ResourceManager::_expiry = 5.0f; +double ResourceManager::_lastUpdate = 0.0f; +double ResourceManager::_lastReport = 0.0f; + +void ResourceManager::Register(Resource* resource) +{ + _resources.push_back(resource); +}; + +void ResourceManager::Unregister(Resource* resource) +{ + Resources::iterator iter = std::find(_resources.begin(), _resources.end(), resource); + + if(iter != _resources.end()) + _resources.erase(iter); + + resource->Release(); +}; + +class ResourceExpired +{ +public: + ResourceExpired(double time): _time(time) { }; + bool operator()(Resource* resource) + { + return (resource->GetLastUsage() < _time); + } + +private: + double _time; +}; + +void ResourceManager::Sweep(double currentTime) +{ + + if(currentTime - _lastUpdate < _expiry) + return; + + Resources::iterator begin = std::remove_if(_resources.begin(), _resources.end(), ResourceExpired(currentTime - _expiry)); + +#ifdef RESOURCE_REPORTING + if(begin != _resources.end()) + WriteLog("Releasing resources"); +#endif + + for(Resources::iterator iter = begin; iter != _resources.end(); iter++) + (*iter)->Release(); + +#ifdef RESOURCE_REPORTING + if(begin != _resources.end()) + { + std::ostringstream msg; + msg << "Released " << (_resources.end() - begin) << " resources"; + WriteLog(msg.str().c_str()); + }; +#endif + + _resources.erase(begin, _resources.end()); + +#ifdef RESOURCE_REPORTING + if(currentTime - _lastReport > 30.0f) + { + std::ostringstream msg; + msg << "Resources count: " << _resources.size(); + WriteLog(msg.str().c_str()); + _lastReport = currentTime; + }; +#endif + + _lastUpdate = currentTime; + +}; diff --git a/ResourceManager.h b/ResourceManager.h new file mode 100644 index 00000000..5a16a008 --- /dev/null +++ b/ResourceManager.h @@ -0,0 +1,45 @@ +#ifndef RESOURCEMANAGER_H +#define RESOURCEMANAGER_H 1 + +#include +#include + +#pragma hdrstop + +class Resource +{ + +public: + virtual void Release() = 0; + double GetLastUsage() const { return _lastUsage; } + +protected: + void SetLastUsage(double lastUsage) { _lastUsage = lastUsage; } + +private: + double _lastUsage; + +}; + +class ResourceManager +{ + +public: + static void Register(Resource* resource); + static void Unregister(Resource* resource); + + static void Sweep(double currentTime); + static void SetExpiry(double expiry) { _expiry = expiry; } + +private: + typedef std::vector Resources; + + static double _expiry; + static double _lastUpdate; + static double _lastReport; + + static Resources _resources; + +}; + +#endif diff --git a/Segment.cpp b/Segment.cpp new file mode 100644 index 00000000..77081a84 --- /dev/null +++ b/Segment.cpp @@ -0,0 +1,918 @@ +//--------------------------------------------------------------------------- + +#include "system.hpp" +#pragma hdrstop +#include "opengl/glew.h" +//#include "opengl/glut.h" + +#include "Segment.h" +#include "Usefull.h" +#include "Globals.h" +#include "Track.h" + +//#define Precision 10000 + +#pragma package(smart_init) +//--------------------------------------------------------------------------- + +//101206 Ra: trapezoidalne drogi +//110806 Ra: odwrócone mapowanie wzdłuż - Point1 == 1.0 + +AnsiString __fastcall Where(vector3 p) +{//zamiana współrzędnych na tekst, używana w błędach + return AnsiString(p.x)+" "+AnsiString(p.y)+" "+AnsiString(p.z); +}; + +__fastcall TSegment::TSegment(TTrack *owner) +{ + Point1=CPointOut=CPointIn=Point2=vector3(0.0f,0.0f,0.0f); + fLength=0; + fRoll1=0; + fRoll2=0; + fTsBuffer=NULL; + fStep=0; + pOwner=owner; +}; + +__fastcall TSegment::~TSegment() +{ + SafeDeleteArray(fTsBuffer); +}; + +bool __fastcall TSegment::Init( + vector3 NewPoint1,vector3 NewPoint2,double fNewStep, + double fNewRoll1,double fNewRoll2) +{//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 + 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 + return TSegment::Init( + NewPoint1,NewPoint1+dir,NewPoint2-dir,NewPoint2, + fNewStep,fNewRoll1,fNewRoll2, + true); + } +}; + +bool __fastcall TSegment::Init( + vector3 &NewPoint1,vector3 NewCPointOut,vector3 NewCPointIn,vector3 &NewPoint2, + double fNewStep,double fNewRoll1, double fNewRoll2, bool bIsCurve) +{//wersja uniwersalna (dla krzywej i prostego) + Point1=NewPoint1; + CPointOut=NewCPointOut; + CPointIn=NewCPointIn; + Point2=NewPoint2; + //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. + if (fRoll1!=0.0) + {//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 + if (bCurve) CPointOut.y+=w1; //prosty ma wektory jednostkowe + 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 + if (bCurve) CPointIn.y+=w2; //prosty ma wektory jednostkowe + //zwrócić trzeba informację o podwyższeniu podsypki + } + } + //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 + bCurve=bIsCurve; + if (bCurve) + {//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 + fLength=ComputeLength(); + } + else + fLength=(Point1-Point2).Length(); + fStep=fNewStep; + if (fLength<=0) + { + 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ć + } + fStoop=atan2((Point2.y-Point1.y),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 + double s=0; + int i=0; + iSegCount=ceil(fLength/fStep); //potrzebne do VBO + //fStep=fLength/(double)(iSegCount-1); //wyrównanie podziału + fTsBuffer=new double[iSegCount+1]; + fTsBuffer[0]=0; /* TODO : fix fTsBuffer */ + while (sfLength) s=fLength; + fTsBuffer[i]=GetTFromS(s); + } + } + if (fLength>500) + {//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; + } + return true; +} + + +vector3 __fastcall TSegment::GetFirstDerivative(double fTime) +{ + + double fOmTime = 1.0 - fTime; + double fPowTime = fTime; + vector3 kResult = fOmTime*(CPointOut-Point1); + + //int iDegreeM1 = 3 - 1; + + double fCoeff = 2*fPowTime; + kResult = (kResult+fCoeff*(CPointIn-CPointOut))*fOmTime; + fPowTime *= fTime; + + kResult += fPowTime*(Point2-CPointIn); + kResult *= 3; + + return kResult; +} + +double __fastcall TSegment::RombergIntegral(double fA, double fB) +{ + double fH = fB - fA; + + const int ms_iOrder= 5; + + double ms_apfRom[2][ms_iOrder]; + + ms_apfRom[0][0] = 0.5*fH*((GetFirstDerivative(fA).Length())+(GetFirstDerivative(fB).Length())); + for (int i0 = 2, iP0 = 1; i0 <= ms_iOrder; i0++, iP0 *= 2, fH *= 0.5) + { + // approximations via the trapezoid rule + double fSum = 0.0; + int i1; + for (i1 = 1; i1 <= iP0; i1++) + fSum += (GetFirstDerivative(fA + fH*(i1-0.5)).Length()); + + // Richardson extrapolation + ms_apfRom[1][0] = 0.5*(ms_apfRom[0][0] + fH*fSum); + for (int i2 = 1, iP2 = 4; i2 < i0; i2++, iP2 *= 4) + { + ms_apfRom[1][i2] = + (iP2*ms_apfRom[1][i2-1] - ms_apfRom[0][i2-1])/(iP2-1); + } + + for (i1 = 0; i1 < i0; i1++) + ms_apfRom[0][i1] = ms_apfRom[1][i1]; + } + + return ms_apfRom[0][ms_iOrder-1]; +} + +double __fastcall TSegment::GetTFromS(double s) +{ + // initial guess for Newton's method + int it=0; + double fTolerance= 0.001; + double fRatio = s/RombergIntegral(0,1); + double fOmRatio = 1.0 - fRatio; + double fTime = fOmRatio*0 + fRatio*1; + +// for (int i = 0; i < iIterations; i++) + while (true) + { + it++; + if (it>10) + { + ErrorLog("Bad geometry: Too many iterations at "+Where(Point1)); + //MessageBox(0,"Too many iterations","GetTFromS",MB_OK); + return fTime; + } + + double fDifference = RombergIntegral(0,fTime) - s; + if ( ( fDifference>0 ? fDifference : -fDifference) < fTolerance ) + return fTime; + + fTime -= fDifference/GetFirstDerivative(fTime).Length(); + } + + // Newton's method failed. If this happens, increase iterations or + // tolerance or integration accuracy. + //return -1; //Ra: tu nigdy nie dojdzie + +}; + +vector3 __fastcall 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ń +}; + +vector3 __fastcall 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ń +}; + +double __fastcall 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 poprzedniej + //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 tmp=Point2-Point1; + 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> + //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 + last=tmp; + } + return (l); +} + +const double fDirectionOffset=0.1; //długość wektora do wyliczenia kierunku + +vector3 __fastcall 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 + double t2=GetTFromS(fDistance+fDirectionOffset); + if (t2>=1.0) + return (Point1-CPointIn); //na zewnątrz jako prosta + return (FastGetPoint(t2)-FastGetPoint(t1)); +} + +vector3 __fastcall TSegment::FastGetDirection(double fDistance, double fOffset) +{//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 + double t2=fDistance+fOffset; + if (t2>=1.0) + return (Point2-CPointIn); //wektor na końcu jest stały + return (FastGetPoint(t2)-FastGetPoint(t1)); +} + +vector3 __fastcall TSegment::GetPoint(double fDistance) +{//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 + 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 + return ((1.0-t)*Point1+(t)*Point2); + } +}; + +void __fastcall TSegment::RaPositionGet(double fDistance,vector3 &p,vector3 &a) +{//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 + 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) + //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,t*(t*3.0*vA.z+vB.z+vB.z)+vC.z); //kierunek krzywej w planie + } + else + {//wyliczenie dla odcinka prostego jest prostsze + 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.y=fStoop; //pochylenie toru prostego + a.z=fDirection; //kierunek toru w planie + } +}; + + +vector3 __fastcall TSegment::FastGetPoint(double t) +{ + //return (bCurve?Interpolate(t,Point1,CPointOut,CPointIn,Point2):((1.0-t)*Point1+(t)*Point2)); + return (bCurve?RaInterpolate(t):((1.0-t)*Point1+(t)*Point2)); +} + +void __fastcall 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 + //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 + if (iQualityFactor<1) 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 + 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 + step=fStep*iQualityFactor; + 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ę + if (i>iSegCount) + 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 + 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 + m2=s/fLength; jmm2=1.0-m2; + while (sfLength-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 + m2=1.0; jmm2=0.0; + } + while (tv1<0.0) tv1+=1.0; //przestawienie mapowania + 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 + //parallel2=CrossProduct(dir,vector3(0,1,0)); //wektor poprzeczny + parallel2=Normalize(vector3(-dir.z,0.0,dir.x)); //wektor poprzeczny + glBegin(GL_TRIANGLE_STRIP); + if (trapez) + for (j=0;jfLength) + { + step-= (s-fLength); + s= fLength; + } + + while (tv1<0.0) tv1+=1.0; + tv2=tv1-step/fTextureLength; + + t= fTsBuffer[i]; + pos2= FastGetPoint( t ); + dir=FastGetDirection(t,offset); + //parallel2=Normalize(CrossProduct(dir,vector3(0,1,0))); + parallel2=Normalize(vector3(-dir.z,0.0,dir.x)); //wektor poprzeczny + + a2= double(i)/(iSkip); + glBegin(GL_TRIANGLE_STRIP); + for (j=0; jfLength) + { + step-= (s-fLength); + s= fLength; + } + + while (tv1<0.0) tv1+=1.0; + + tv2=tv1-step/fTextureLength; + + t= s/fLength; + pos2= FastGetPoint( t ); + + a2= double(i)/(iSkip); + glBegin(GL_TRIANGLE_STRIP); + for (j=0; jnx=norm.x; //niekoniecznie tak + Vert->ny=norm.y; + Vert->nz=norm.z; + Vert->u=jmm1*ShapePoints[j].z+m1*ShapePoints[j+iNumShapePoints].z; + Vert->v=tv1; + Vert->x=pt.x; Vert->y=pt.y; Vert->z=pt.z; //punkt na początku odcinka + Vert++; + //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; + 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->nx=norm.x; //niekoniecznie tak + Vert->ny=norm.y; + Vert->nz=norm.z; + Vert->u=jmm2*ShapePoints[j].z+m2*ShapePoints[j+iNumShapePoints].z; + Vert->v=tv2; + Vert->x=pt.x; Vert->y=pt.y; Vert->z=pt.z; //punkt na końcu odcinka + Vert++; + } + else + for (j=0;jnx=norm.x; //niekoniecznie tak + Vert->ny=norm.y; + Vert->nz=norm.z; + Vert->u=ShapePoints[j].z; + Vert->v=tv1; + Vert->x=pt.x; Vert->y=pt.y; Vert->z=pt.z; //punkt na początku odcinka + Vert++; + norm=ShapePoints[j].n.x*parallel2; + norm.y+=ShapePoints[j].n.y; + pt=parallel2*ShapePoints[j].x+pos2; + pt.y+=ShapePoints[j].y; + Vert->nx=norm.x; //niekoniecznie tak + Vert->ny=norm.y; + Vert->nz=norm.z; + Vert->u=ShapePoints[j].z; + Vert->v=tv2; + Vert->x=pt.x; Vert->y=pt.y; Vert->z=pt.z; //punkt na końcu odcinka + Vert++; + } + pos1=pos2; + parallel1=parallel2; + tv1=tv2; + } + } + else + {//gdy prosty + pos1=FastGetPoint((fStep*iSkip)/fLength); + pos2=FastGetPoint_1(); + dir=GetDirection(); + //parallel1=Normalize(CrossProduct(dir,vector3(0,1,0))); + parallel1=Normalize(vector3(-dir.z,0.0,dir.x)); //wektor poprzeczny + if (trapez) + for (j=0;jnx=norm.x; //niekoniecznie tak + Vert->ny=norm.y; + Vert->nz=norm.z; + Vert->u=ShapePoints[j].z; + Vert->v=0; + Vert->x=pt.x; Vert->y=pt.y; Vert->z=pt.z; //punkt na początku odcinka + Vert++; + //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ść + Vert->nx=norm.x; //niekoniecznie tak + Vert->ny=norm.y; + Vert->nz=norm.z; + Vert->u=ShapePoints[j+iNumShapePoints].z; + Vert->v=fLength/fTextureLength; + Vert->x=pt.x; Vert->y=pt.y; Vert->z=pt.z; //punkt na końcu odcinka + Vert++; + } + else + for (j=0;jnx=norm.x; //niekoniecznie tak + Vert->ny=norm.y; + Vert->nz=norm.z; + Vert->u=ShapePoints[j].z; + Vert->v=0; + Vert->x=pt.x; Vert->y=pt.y; Vert->z=pt.z; //punkt na początku odcinka + Vert++; + pt=parallel1*(ShapePoints[j].x-fOffsetX)+pos2; + pt.y+=ShapePoints[j].y; + Vert->nx=norm.x; //niekoniecznie tak + Vert->ny=norm.y; + Vert->nz=norm.z; + Vert->u=ShapePoints[j].z; + Vert->v=fLength/fTextureLength; + Vert->x=pt.x; Vert->y=pt.y; Vert->z=pt.z; //punkt na końcu odcinka + Vert++; + } + } +}; + +void __fastcall 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 + vector3 pos1,pos2,dir,parallel1,parallel2,pt; + double s,step,fOffset,t,fEnd; + int i,j ; + 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) + 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 + fOffset=0.1/fLength; //pierwsze 10cm + 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(vector3(-dir.z,0.0,dir.x)); //wektor poprzeczny + if (iEnd==0) iEnd=iSegCount; + fEnd=fLength*double(iEnd)/double(iSegCount); + m2=s/fEnd; jmm2=1.0-m2; + while (ix=pt.x; Vert->y=pt.y; Vert->z=pt.z; //punkt na początku odcinka + Vert++; + //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++; + } + pos1=pos2; + parallel1=parallel2; + } + } + else + {//gdy prosty + pos1=FastGetPoint((fStep*iSkip)/fLength); + pos2=FastGetPoint_1(); + dir=GetDirection(); + //parallel1=Normalize(CrossProduct(dir,vector3(0,1,0))); + parallel1=Normalize(vector3(-dir.z,0.0,dir.x)); //wektor poprzeczny + if (trapez) + for (j=0;jx=pt.x; Vert->y=pt.y; 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ść + Vert->x=pt.x; Vert->y=pt.y; Vert->z=pt.z; //punkt na końcu odcinka + Vert++; + } + } +}; +//--------------------------------------------------------------------------- + + diff --git a/Segment.h b/Segment.h new file mode 100644 index 00000000..1e64e24f --- /dev/null +++ b/Segment.h @@ -0,0 +1,104 @@ +//--------------------------------------------------------------------------- + +#ifndef SegmentH +#define SegmentH + +#include "VBO.h" +#include "dumb3d.h" +#include "Classes.h" + +using namespace Math3D; + +//110405 Ra: klasa punktów przekroju z normalnymi + +class vector6 : public vector3 +{//punkt przekroju wraz z wektorem normalnym +public: + vector3 n; + __fastcall vector6() + {x=y=z=n.x=n.z=0.0; n.y=1.0;}; + __fastcall vector6(double a,double b,double c,double d,double e,double f) + //{x=a; y=b; z=c; n.x=d; n.y=e; n.z=f;}; + {x=a; y=b; z=c; n.x=0.0; n.y=1.0; n.z=0.0;}; //Ra: bo na razie są z tym problemy + __fastcall vector6(double a,double b,double c) + {x=a; y=b; z=c; n.x=0.0; n.y=1.0; n.z=0.0;}; +}; + +class TSegment +{//aproksymacja toru (zwrotnica ma dwa takie, jeden z nich jest aktywny) +private: + vector3 Point1,CPointOut,CPointIn,Point2; + double fRoll1,fRoll2; //przechyłka na końcach + double fLength; //długość policzona + double *fTsBuffer; //wartości parametru krzywej dla równych odcinków + double fStep; + int iSegCount; //ilość odcinków do rysowania krzywej + double fDirection; //Ra: kąt prostego w planie; dla łuku kąt od Point1 + double fStoop; //Ra: kąt wzniesienia; dla łuku od Point1 + vector3 vA,vB,vC; //współczynniki wielomianów trzeciego stopnia vD==Point1 + //TSegment *pPrev; //odcinek od strony punktu 1 - w segmencie, żeby nie skakać na zwrotnicach + //TSegment *pNext; //odcinek od strony punktu 2 + TTrack *pOwner; //wskaźnik na właściciela + double fAngle[2]; //kąty zakończenia drogi na przejazdach + vector3 __fastcall GetFirstDerivative(double fTime); + double __fastcall RombergIntegral(double fA, double fB); + double __fastcall GetTFromS(double s); + vector3 __fastcall RaInterpolate(double t); + vector3 __fastcall RaInterpolate0(double t); + //TSegment *segNeightbour[2]; //sąsiednie odcinki - musi być przeniesione z Track + //int iNeightbour[2]; //do którego końca doczepiony +public: + bool bCurve; + //int iShape; //Ra: flagi kształtu dadzą więcej możliwości optymalizacji (0-Bezier,1-prosty,2/3-łuk w lewo/prawo,6/7-przejściowa w lewo/prawo) + __fastcall TSegment(TTrack *owner); + __fastcall ~TSegment(); + bool __fastcall Init(vector3 NewPoint1,vector3 NewPoint2,double fNewStep, + double fNewRoll1=0,double fNewRoll2=0); + bool __fastcall Init(vector3 &NewPoint1,vector3 NewCPointOut, + vector3 NewCPointIn,vector3 &NewPoint2,double fNewStep, + double fNewRoll1=0,double fNewRoll2=0,bool bIsCurve=true); + inline double __fastcall ComputeLength(); //McZapkie-150503 + inline vector3 __fastcall GetDirection1() {return bCurve?CPointOut-Point1:CPointOut;}; + inline vector3 __fastcall GetDirection2() {return bCurve?CPointIn-Point2:CPointIn;}; + vector3 __fastcall GetDirection(double fDistance); + vector3 __fastcall GetDirection() {return CPointOut;}; + vector3 __fastcall FastGetDirection(double fDistance,double fOffset); + vector3 __fastcall GetPoint(double fDistance); + void __fastcall RaPositionGet(double fDistance,vector3 &p,vector3 &a); + vector3 __fastcall FastGetPoint(double t); + inline vector3 __fastcall FastGetPoint_0() {return Point1;}; + inline vector3 __fastcall FastGetPoint_1() {return Point2;}; + inline double __fastcall GetRoll(double s) + { + s/=fLength; + return ((1.0-s)*fRoll1+s*fRoll2); + } + void __fastcall GetRolls(double &r1,double &r2) + {//pobranie przechyłek (do generowania trójkątów) + r1=fRoll1; r2=fRoll2; + } + void __fastcall RenderLoft(const vector6 *ShapePoints,int iNumShapePoints, + double fTextureLength,int iSkip=0,int iQualityFactor=1,vector3 **p=NULL,bool bRender=true); + void __fastcall RenderSwitchRail(const vector6 *ShapePoints1,const vector6 *ShapePoints2, + int iNumShapePoints,double fTextureLength,int iSkip=0,double fOffsetX=0.0f); + void __fastcall Render(); + inline double __fastcall GetLength() {return fLength;}; + void __fastcall MoveMe(vector3 pPosition) + {Point1+=pPosition; + Point2+=pPosition; + if (bCurve) + {CPointIn+=pPosition; + CPointOut+=pPosition; + } + } + int __fastcall RaSegCount() {return fTsBuffer?iSegCount:1;}; + void __fastcall RaRenderLoft(CVertNormTex* &Vert,const vector6 *ShapePoints,int iNumShapePoints, + double fTextureLength,int iSkip=0,int iEnd=0,double fOffsetX=0.0); + void __fastcall RaAnimate(CVertNormTex* &Vert,const vector6 *ShapePoints,int iNumShapePoints, + double fTextureLength,int iSkip=0,int iEnd=0,double fOffsetX=0.0); + void __fastcall AngleSet(int i,double a) {fAngle[i]=a;}; + void __fastcall Rollment(double w1,double w2); //poprawianie przechyłki +}; + +//--------------------------------------------------------------------------- +#endif diff --git a/Sound.cpp b/Sound.cpp new file mode 100644 index 00000000..edc2290c --- /dev/null +++ b/Sound.cpp @@ -0,0 +1,377 @@ +//--------------------------------------------------------------------------- + +#include "system.hpp" +#include "classes.hpp" +#pragma hdrstop + +#define STRICT +#include "Sound.h" +#include "Usefull.h" +#include "Globals.h" +//#define SAFE_DELETE(p) { if(p) { delete (p); (p)=NULL; } } +#define SAFE_RELEASE(p) { if(p) { (p)->Release(); (p)=NULL; } } + +char Directory[]= "sounds\\"; + +LPDIRECTSOUND TSoundsManager::pDS; +LPDIRECTSOUNDNOTIFY TSoundsManager::pDSNotify; + +int TSoundsManager::Count= 0; +TSoundContainer *TSoundsManager::First=NULL; + + +__fastcall TSoundContainer::TSoundContainer( LPDIRECTSOUND pDS, char *Directory, char *strFileName, int NConcurrent) +{//wczytanie pliku dźwiękowego + int hr= 111; + DSBuffer=NULL; //na początek, gdyby uruchomić dźwięków się nie udało + + Concurrent= NConcurrent; + + Oldest= 0; +// strcpy(Name, strFileName); + + strcpy(Name,Directory); + strcat(Name,strFileName); + + CWaveSoundRead* pWaveSoundRead; + + + // Create a new wave file class + pWaveSoundRead = new CWaveSoundRead(); + + // Load the wave file + if (FAILED(pWaveSoundRead->Open(Name))) + if(FAILED(pWaveSoundRead->Open(strFileName))) + { +// SetFileUI( hDlg, TEXT("Bad wave file.") ); + return; + ErrorLog("Missed sound: "+AnsiString(strFileName)); + } + + strcpy(Name,AnsiString(strFileName).LowerCase().c_str()); + + // Set up the direct sound buffer, and only request the flags needed + // since each requires some overhead and limits if the buffer can + // be hardware accelerated + DSBUFFERDESC dsbd; + ZeroMemory( &dsbd, sizeof(DSBUFFERDESC) ); + dsbd.dwSize = sizeof(DSBUFFERDESC); + dsbd.dwFlags = DSBCAPS_STATIC | DSBCAPS_CTRLPAN | DSBCAPS_CTRLVOLUME | DSBCAPS_CTRLFREQUENCY; + if (!Global::bInactivePause) //jeśli przełączony w tło ma nadal działać + dsbd.dwFlags|=DSBCAPS_GLOBALFOCUS; //to dźwięki mają być również słyszalne + dsbd.dwBufferBytes = pWaveSoundRead->m_ckIn.cksize; + dsbd.lpwfxFormat = pWaveSoundRead->m_pwfx; + fSamplingRate=pWaveSoundRead->m_pwfx->nSamplesPerSec; + iBitsPerSample=pWaveSoundRead->m_pwfx->wBitsPerSample; + +// pDSBuffer= (LPDIRECTSOUNDBUFFER*) malloc(Concurrent*sizeof(LPDIRECTSOUNDBUFFER)); +// for (int i=0; iCreateSoundBuffer( &dsbd, &(DSBuffer), NULL ) ) ) + //if (FAILED(pDS->CreateSoundBuffer(&dsbd,&(DSBuffer),NULL))) + return; + + // Remember how big the buffer is + DWORD dwBufferBytes; + + dwBufferBytes = dsbd.dwBufferBytes; + + + //---------------------------------------------------------- + + + BYTE* pbWavData; // Pointer to actual wav data + UINT cbWavSize; // Size of data + VOID* pbData = NULL; + VOID* pbData2 = NULL; + DWORD dwLength; + DWORD dwLength2; + + // The size of wave data is in pWaveFileSound->m_ckIn + INT nWaveFileSize = pWaveSoundRead->m_ckIn.cksize; + + // Allocate that buffer. + pbWavData = new BYTE[ nWaveFileSize ]; + if( NULL == pbWavData ) + return ;//E_OUTOFMEMORY; + + //if (FAILED(hr=pWaveSoundRead->Read( nWaveFileSize,pbWavData,&cbWavSize))) + if( FAILED( hr = pWaveSoundRead->Read( nWaveFileSize, + pbWavData, + &cbWavSize ) ) ) + return ; + + // Reset the file to the beginning + pWaveSoundRead->Reset(); + + // Lock the buffer down + //if (FAILED(hr=DSBuffer->Lock(0,dwBufferBytes,&pbData,&dwLength,&pbData2,&dwLength2,0))) + if( FAILED( hr = DSBuffer->Lock( 0, dwBufferBytes, &pbData, &dwLength, + &pbData2, &dwLength2, 0L ) ) ) + return ; + + // Copy the memory to it. + memcpy( pbData, pbWavData, dwBufferBytes ); + + // Unlock the buffer, we don't need it anymore. + DSBuffer->Unlock( pbData, dwBufferBytes, NULL, 0 ); + pbData = NULL; + + // We dont need the wav file data buffer anymore, so delete it + delete[] pbWavData; + + delete pWaveSoundRead; + + DSBuffers.push(DSBuffer); + +/* + for (int i=1; iDuplicateSoundBuffer(pDSBuffer[0],&(pDSBuffer[i])))) + { + Concurrent= i; + break; + }; + + + };*/ + +}; +__fastcall TSoundContainer::~TSoundContainer() +{ +// for (int i=Concurrent-1; i>=0; i--) +// SAFE_RELEASE( pDSBuffer[i] ); +// free(pDSBuffer); + while (!DSBuffers.empty()) + { + SAFE_RELEASE(DSBuffers.top()); + DSBuffers.pop(); + } + SafeDelete( Next ); +}; + +LPDIRECTSOUNDBUFFER __fastcall TSoundContainer::GetUnique(LPDIRECTSOUND pDS) +{ + if (!DSBuffer) return NULL; + //jeśli się dobrze zainicjowało + LPDIRECTSOUNDBUFFER buff; + pDS->DuplicateSoundBuffer(DSBuffer,&buff); + if (buff) DSBuffers.push(buff); + return DSBuffers.top(); +}; + + + +__fastcall TSoundsManager::~TSoundsManager() +{ + + Free(); +}; + +void __fastcall TSoundsManager::Free() +{ + SafeDelete( First ); + SAFE_RELEASE( pDS ); +}; + + +TSoundContainer* __fastcall TSoundsManager::LoadFromFile(char *Dir,char *Name,int Concurrent) +{ + TSoundContainer *Tmp=First; + First=new TSoundContainer(pDS,Dir,Name,Concurrent); + First->Next=Tmp; + Count++; + return First; //albo NULL, jak nie wyjdzie (na razie zawsze wychodzi) +}; + +void __fastcall TSoundsManager::LoadSounds(char *Directory) +{//wczytanie wszystkich plików z katalogu - mało elastyczne + WIN32_FIND_DATA FindFileData; + HANDLE handle=FindFirstFile("sounds\\*.wav",&FindFileData); + if (handle!=INVALID_HANDLE_VALUE) + do + { + LoadFromFile(Directory,FindFileData.cFileName,1); + } while (FindNextFile(handle,&FindFileData)); + FindClose(handle); +}; + +LPDIRECTSOUNDBUFFER __fastcall TSoundsManager::GetFromName(char *Name,bool Dynamic,float *fSamplingRate) +{//wyszukanie dźwięku w pamięci albo wczytanie z pliku + AnsiString file; + if (Dynamic) + {//próba wczytania z katalogu pojazdu + file=Global::asCurrentDynamicPath+AnsiString(Name); + if (FileExists(file)) + Name=file.c_str(); //nowa nazwa + else + Dynamic=false; //wczytanie z "sounds/" + } + TSoundContainer *Next=First; + DWORD dwStatus; + for (int i=0;iName)==0) + { + if (fSamplingRate) + *fSamplingRate=Next->fSamplingRate; //częstotliwość + return (Next->GetUnique(pDS)); +// DSBuffers. + /* + Next->pDSBuffer[Next->Oldest]->Stop(); + Next->pDSBuffer[Next->Oldest]->SetCurrentPosition(0); + if (Next->OldestConcurrent-1) + { + Next->Oldest++; + return (Next->pDSBuffer[Next->Oldest-1]); + } + else + { + Next->Oldest= 0; + return (Next->pDSBuffer[Next->Concurrent-1]); + }; + +/* for (int j=0; jConcurrent; j++) + { + + Next->pDSBuffer[j]->GetStatus(&dwStatus); + if ((dwStatus & DSBSTATUS_PLAYING) != DSBSTATUS_PLAYING) + return (Next->pDSBuffer[j]); + } */ + } + else + Next=Next->Next; + }; + if (Dynamic) //wczytanie z katalogu pojazdu + Next=LoadFromFile("",Name,1); + else + Next=LoadFromFile(Directory,Name,1); + if (Next) + {// + if (fSamplingRate) + *fSamplingRate=Next->fSamplingRate; //częstotliwość + return Next->GetUnique(pDS); + } + ErrorLog("Missed sound: "+AnsiString(Name)); + return (NULL); +}; + +void __fastcall TSoundsManager::RestoreAll() +{ + TSoundContainer *Next= First; + + HRESULT hr; + + DWORD dwStatus; + + for (int i=0; iDSBuffer->GetStatus( &dwStatus ) ) ); + // return hr; + + if( dwStatus & DSBSTATUS_BUFFERLOST ) + { + // Since the app could have just been activated, then + // DirectSound may not be giving us control yet, so + // the restoring the buffer may fail. + // If it does, sleep until DirectSound gives us control. + do + { + hr = Next->DSBuffer->Restore(); + if( hr == DSERR_BUFFERLOST ) + Sleep( 10 ); + } + while ((hr=Next->DSBuffer->Restore())!=NULL); + +// char *Name= Next->Name; +// int cc= Next->Concurrent; +// delete Next; +// Next= new TSoundContainer(pDS, Directory, Name, cc); +// if( FAILED( hr = FillBuffer() ) ); +// return hr; + }; + Next= Next->Next; + }; + +}; + + +//void __fastcall TSoundsManager::Init(char *Name, int Concurrent) +//__fastcall TSoundsManager::TSoundsManager(HWND hWnd) +//void __fastcall TSoundsManager::Init(HWND hWnd, char *NDirectory) + +void __fastcall TSoundsManager::Init(HWND hWnd) +{ + + First= NULL; + Count= 0; + pDS= NULL; + pDSNotify= NULL; + + HRESULT hr; //=222; + LPDIRECTSOUNDBUFFER pDSBPrimary = NULL; + +// strcpy(Directory, NDirectory); + + // Create IDirectSound using the primary sound device + hr = DirectSoundCreate( NULL, &pDS, NULL ); + if( hr!=DS_OK ) + { + +if (hr==DSERR_ALLOCATED) + return; +if (hr==DSERR_INVALIDPARAM) + return; +if (hr==DSERR_NOAGGREGATION) + return; +if (hr==DSERR_NODRIVER) + return; +if (hr==DSERR_OUTOFMEMORY) + return; + +// hr=0; + }; +// return ; + + // Set coop level to DSSCL_PRIORITY +// if( FAILED( hr = pDS->SetCooperativeLevel( hWnd, DSSCL_PRIORITY ) ) ); + // return ; + pDS->SetCooperativeLevel( hWnd, DSSCL_PRIORITY ); + + // Get the primary buffer + DSBUFFERDESC dsbd; + ZeroMemory( &dsbd, sizeof(DSBUFFERDESC) ); + dsbd.dwSize = sizeof(DSBUFFERDESC); + dsbd.dwFlags = DSBCAPS_PRIMARYBUFFER; + if (!Global::bInactivePause) //jeśli przełączony w tło ma nadal działać + dsbd.dwFlags|=DSBCAPS_GLOBALFOCUS; //to dźwięki mają być również słyszalne + dsbd.dwBufferBytes = 0; + dsbd.lpwfxFormat = NULL; + + if( FAILED( hr = pDS->CreateSoundBuffer( &dsbd, &pDSBPrimary, NULL ) ) ) + return ; + + // Set primary buffer format to 22kHz and 16-bit output. + WAVEFORMATEX wfx; + ZeroMemory( &wfx, sizeof(WAVEFORMATEX) ); + wfx.wFormatTag = WAVE_FORMAT_PCM; + wfx.nChannels = 2; + wfx.nSamplesPerSec = 44100; + wfx.wBitsPerSample = 16; + wfx.nBlockAlign = wfx.wBitsPerSample / 8 * wfx.nChannels; + wfx.nAvgBytesPerSec = wfx.nSamplesPerSec * wfx.nBlockAlign; + + if( FAILED( hr = pDSBPrimary->SetFormat(&wfx) ) ) + return ; + + SAFE_RELEASE( pDSBPrimary ); + +}; + + +//--------------------------------------------------------------------------- +#pragma package(smart_init) diff --git a/Sound.h b/Sound.h new file mode 100644 index 00000000..9bdd240c --- /dev/null +++ b/Sound.h @@ -0,0 +1,61 @@ +//--------------------------------------------------------------------------- +#ifndef SoundH +#define SoundH + +#include +#undef EOF +#include +//#include +//#include +#include +#include +//#include "resource.h" +#include "WavRead.h" + +typedef LPDIRECTSOUNDBUFFER PSound; + +//inline __fastcall Playing(PSound Sound) +//{ + +//} + +class TSoundContainer +{ +public: + int Concurrent; + int Oldest; + char Name[80]; + LPDIRECTSOUNDBUFFER DSBuffer; + float fSamplingRate; //częstotliwość odczytana z pliku + int iBitsPerSample; //ile bitów na próbkę + TSoundContainer *Next; + std::stack< LPDIRECTSOUNDBUFFER > DSBuffers; + LPDIRECTSOUNDBUFFER __fastcall GetUnique(LPDIRECTSOUND pDS); + __fastcall TSoundContainer(LPDIRECTSOUND pDS, char *Directory, char *strFileName, int NConcurrent); + __fastcall ~TSoundContainer(); +}; + + +class TSoundsManager +{ +private: + static LPDIRECTSOUND pDS; + static LPDIRECTSOUNDNOTIFY pDSNotify; +// static char Directory[80]; + static int Count; + static TSoundContainer *First; + static TSoundContainer* __fastcall LoadFromFile(char *Dir,char *Name,int Concurrent); +public: +// __fastcall TSoundsManager(HWND hWnd); +// static void __fastcall Init(HWND hWnd, char *NDirectory); + static void __fastcall Init(HWND hWnd); + __fastcall ~TSoundsManager(); + static void __fastcall Free(); + static void __fastcall Init(char *Name, int Concurrent); + static void __fastcall LoadSounds(char *Directory); + static LPDIRECTSOUNDBUFFER __fastcall GetFromName(char *Name,bool Dynamic,float *fSamplingRate=NULL); + static void __fastcall RestoreAll(); +}; + +//--------------------------------------------------------------------------- +#endif diff --git a/Spline.cpp b/Spline.cpp new file mode 100644 index 00000000..4a6f1713 --- /dev/null +++ b/Spline.cpp @@ -0,0 +1,518 @@ +//--------------------------------------------------------------------------- + +#include "system.hpp" +#include "classes.hpp" +#pragma hdrstop + +#include "Geometry.h" +#include "Spline.h" +#include "usefull.h" +#include "maptextfile.hpp" + +//#define asSplinesPatch AnsiString("Scenery\\") + + +bool __fastcall Connect(TKnot *k1, TKnot *k2) +{ + if (k1 && k2) + { + k1->Next= k2; + k2->Prev= k1; + k1->InitLength(); + return true; + } + else + return false; +} + +#define Precision 10000 +float __fastcall CurveLength(vector3 p1, vector3 cp1, vector3 cp2, vector3 p2) +{ + float t,l=0; + vector3 tmp,last= p1; + for (int i=1; i<=Precision; i++) + { + t= float(i)/float(Precision); + tmp= Interpolate(t,p1,cp1,cp2,p2); + t= vector3(tmp-last).Length(); + l+= t; + last= tmp; + } + return (l); + +} + +__fastcall TKnot::TKnot() +{ + Next=Prev= NULL; + Length= -1; + IsCurve= false; + fLengthIn=fLengthOut= 0; + fRoll= 0; + bSwitchDirectionForward= false; + bSwitchDirectionBackward= false; +} + +__fastcall TKnot::TKnot(int n) +{ + bSwitchDirectionForward= false; + bSwitchDirectionBackward= false; + Next=Prev= NULL; + Length= -1; + IsCurve= false; + fLengthIn=fLengthOut= 0; + if (n>0) + { + Next= new TKnot(n-1); + Next->Prev= this; + } +} + +__fastcall TKnot::~TKnot() +{ +} + +vector3 __fastcall TKnot::GetDirection(float t) +{ + if (IsCurve) + { + vector3 v1= CPointOut-Point; + vector3 v2= Next->Point-Next->CPointIn; //BUGBUG + return v1*(1-t)+v2*(t); + } + else + return (Next->Point-Point);//Spline->Knots[KnotIndex].Point-Spline->Knots[KnotIndex].Point); +} + +float __fastcall TKnot::GetTFromS(float s) +{ + // initial guess for Newton's method + int it=0; + float fTolerance= 0.001; + float fRatio = s/RombergIntegral(0,1); + float fOmRatio = 1.0 - fRatio; + float fTime = fOmRatio*0 + fRatio*1; + +// for (int i = 0; i < iIterations; i++) + while (true) + { + it++; + if (it>10) + MessageBox(0,"Too many iterations","TSpline->GetTFromS",MB_OK); + + float fDifference = RombergIntegral(0,fTime) - s; + if ( ( fDifference>0 ? fDifference : -fDifference) < fTolerance ) + return fTime; + + fTime -= fDifference/GetFirstDerivative(fTime).Length(); + } + + // Newton's method failed. If this happens, increase iterations or + // tolerance or integration accuracy. + return -1; + +} + +bool __fastcall TKnot::Init(TKnot *NNext, TKnot *NPrev) +{ + if (NNext!=NULL) + { + Next= NNext; + Next->Prev= this; + } + if (NPrev!=NULL) + { + Prev= NPrev; + Prev->Next= this; + } +} + +bool __fastcall TKnot::InitCPoints() +{ + if (Prev!=NULL) + if (Prev->IsCurve) + if (Next!=NULL) + { + if (!IsCurve) + { + CPointIn= Point-fLengthIn*Normalize(Next->Point-Point); + } + else + CPointIn= Point-fLengthIn*(Normalize(Normalize(Next->Point-Point)+Normalize(Point-Prev->Point))); + } + else + CPointIn= Point-fLengthIn*Normalize(Point-Prev->Point); + else + CPointIn= Prev->Point; + + if (Next!=NULL) + if (IsCurve) + if (Prev!=NULL) + { + if (!Prev->IsCurve) + { + CPointOut= Point-fLengthOut*Normalize(Prev->Point-Point); + } + else + CPointOut= Point-fLengthOut*(Normalize(Normalize(Prev->Point-Point)+Normalize(Point-Next->Point))); + } + else; +// CPointOut= -fLengthOut*Normalize(Next->Point-Point); + else + CPointOut= Next->Point; + else + CPointOut= Point-fLengthOut*Normalize(Prev->Point-Point); +} + +bool __fastcall TKnot::InitLength() +{ + + if (IsCurve) + if (Next) + Length= RombergIntegral(0,1); + else; + else + if (Next) + Length= (Point-Next->Point).Length(); + + return true; + + +} + +vector3 TKnot::GetFirstDerivative(float fTime) +{ + + float fOmTime = 1.0 - fTime; + float fPowTime = fTime; + vector3 kResult = fOmTime*(CPointOut-Point); + + int iDegreeM1 = 3 - 1; + + float fCoeff = 2*fPowTime; + kResult = (kResult+fCoeff*(Next->CPointIn-CPointOut))*fOmTime; + fPowTime *= fTime; + + kResult += fPowTime*(Next->Point-Next->CPointIn); + kResult *= 3; + + return kResult; +} + +float TKnot::RombergIntegral(float fA, float fB) +{ + float fH = fB - fA; + + const int ms_iOrder= 5; + + float ms_apfRom[2][ms_iOrder]; + + ms_apfRom[0][0] = 0.5*fH*((GetFirstDerivative(fA).Length())+(GetFirstDerivative(fB).Length())); + for (int i0 = 2, iP0 = 1; i0 <= ms_iOrder; i0++, iP0 *= 2, fH *= 0.5) + { + // approximations via the trapezoid rule + float fSum = 0.0; + int i1; + for (i1 = 1; i1 <= iP0; i1++) + fSum += (GetFirstDerivative(fA + fH*(i1-0.5)).Length()); + + // Richardson extrapolation + ms_apfRom[1][0] = 0.5*(ms_apfRom[0][0] + fH*fSum); + for (int i2 = 1, iP2 = 4; i2 < i0; i2++, iP2 *= 4) + { + ms_apfRom[1][i2] = + (iP2*ms_apfRom[1][i2-1] - ms_apfRom[0][i2-1])/(iP2-1); + } + + for (i1 = 0; i1 < i0; i1++) + ms_apfRom[0][i1] = ms_apfRom[1][i1]; + } + + return ms_apfRom[0][ms_iOrder-1]; +} + + +//----------------------------------------------------------------------------// + + +__fastcall TSpline::TSpline() +{ +// Closed= true; +// asName= "foo"; +// Knots= NULL; + RootKnot= NULL; + iNumKnots= 0; + KnotsAllocated= false; +// Next=Prev= this; +} + +__fastcall TSpline::TSpline(AnsiString asNName) +{ +// Closed= true; +// asName= asNName; +// Knots= NULL; + RootKnot= NULL; + iNumKnots= 0; + KnotsAllocated= false; +// Next=Prev= this; +} + +__fastcall TSpline::~TSpline() +{ + // if (KnotsAllocated) +// SafeDeleteArray(Knots); + +// SafeDelete(RootKnot); + + TKnot *ck,*tk; + ck= RootKnot; + + for (int i=0; iNext; + SafeDelete(tk); + } + +} + +bool __fastcall TSpline::Create( int n, AnsiString asNName ) +{ +/* +// asName= asNName; + iNumKnots= n; + Knots= new TKnot[iNumKnots]; + KnotsAllocated= true; + Knots[0].Prev= NULL; + Knots[iNumKnots-1].Next= NULL; + for (int i=1; iOpen(asSceneryPatch+FileName,mmRead); + + tf->ReadLn(buf); + + if (buf==AnsiString("\"SPLINE\"")) + { + tf->ReadLn(buf); + if (FirstKnot==NULL) + Create(buf.ToInt()); + else + AssignKnots(FirstKnot,buf.ToInt()); + TKnot *CurrentKnot= Knots; +// iNumKnots= buf.ToInt(); + // Knots= new TKnot[iNumKnots];// malloc(*sizeof(TKnot)); + + DecimalSeparator= '.'; + for (i=0; iReadLn(buf); CurrentKnot->Point.x= buf.ToDouble(); + tf->ReadLn(buf); CurrentKnot->Point.z= buf.ToDouble(); + tf->ReadLn(buf); CurrentKnot->Point.y= buf.ToDouble(); + tf->ReadLn(buf); CurrentKnot->CPointIn.x= buf.ToDouble(); + tf->ReadLn(buf); CurrentKnot->CPointIn.z= buf.ToDouble(); + tf->ReadLn(buf); CurrentKnot->CPointIn.y= buf.ToDouble(); + tf->ReadLn(buf); CurrentKnot->CPointOut.x= buf.ToDouble(); + tf->ReadLn(buf); CurrentKnot->CPointOut.z= buf.ToDouble(); + tf->ReadLn(buf); CurrentKnot->CPointOut.y= buf.ToDouble(); + + tf->ReadLn(buf); +// buf.Trim(); + Knots[i].IsCurve= (buf!="#line "); + CurrentKnot= CurrentKnot->Next; + + + } + DecimalSeparator= ','; + + CurrentKnot= Knots; + + for (i=0; iIsCurve) + { + + CurrentKnot->Length= CurveLength(CurrentKnot->Point,CurrentKnot->CPointOut,CurrentKnot->Next->CPointIn,CurrentKnot->Next->Point); + } + else + { + CurrentKnot->CPointOut= 2*CurrentKnot->Point-CurrentKnot->CPointIn; + CurrentKnot->Next->CPointIn= CurrentKnot->Point; + CurrentKnot->Length= (CurrentKnot->Point-CurrentKnot->Next->Point).Length(); + } + CurrentKnot= CurrentKnot->Next; + } + CurrentKnot->Length= -1; + } + + + + tf->Close(); + + delete tf; + + return (iNumKnots); + */ +} + +int __fastcall TSpline::Load( TQueryParserComp *Parser, AnsiString asEndString ) +{ + TKnot *LastKnot= NULL;; + if (RootKnot!=NULL) + for (LastKnot= RootKnot; LastKnot->Next!=NULL; LastKnot= LastKnot->Next); + + TKnot *tmp; + + tmp= new TKnot(0); + tmp->Prev= LastKnot; + if (LastKnot!=NULL) + LastKnot->Next= tmp; + else + RootKnot= tmp; + + LastKnot= tmp; + + float tf,r,pr; + vector3 dir; + +// asName= Parser->GetNextSymbol(); + + iNumKnots= 0; + + do + { + LastKnot->fLengthIn= Parser->GetNextSymbol().ToDouble(); + tf= Parser->GetNextSymbol().ToDouble(); + LastKnot->Point.x= tf; + tf= Parser->GetNextSymbol().ToDouble(); + LastKnot->Point.y= tf; + tf= Parser->GetNextSymbol().ToDouble(); + LastKnot->Point.z= tf; + tf= Parser->GetNextSymbol().ToDouble(); + LastKnot->fRoll= tf/180*M_PI; + + LastKnot->fLengthOut= Parser->GetNextSymbol().ToDouble(); + + LastKnot->IsCurve= (LastKnot->fLengthOut!=0); + + LastKnot->Next= new TKnot(0); + LastKnot->Next->Prev= LastKnot; + LastKnot= LastKnot->Next; + + iNumKnots++; + + + } while (Parser->GetNextSymbol().LowerCase()!=asEndString && !Parser->EOF); + + LastKnot->Prev->Next= NULL; + delete LastKnot; + if (RootKnot!=NULL) + for (LastKnot= RootKnot; LastKnot!=NULL; LastKnot= LastKnot->Next) + LastKnot->InitCPoints(); + if (RootKnot!=NULL) + for (LastKnot= RootKnot; LastKnot!=NULL; LastKnot= LastKnot->Next) + LastKnot->InitLength(); +} + +float __fastcall TSpline::GetLength() +{ + TKnot *tmp= RootKnot; + float l= 0; + for (int i=0; iLength; + tmp= tmp->Next; + } + + return l; + +} + +vector3 __fastcall TSpline::GetCenter() +{ + TKnot *ck,*tk; + ck= RootKnot; + vector3 pt= vector3(0,0,0); + + for (int i=0; iPoint; + ck= ck->Next; + } + if (iNumKnots>0) + pt/= iNumKnots; + +} + +TKnot* __fastcall TSpline::GetLastKnot() +{ + TKnot *ck; + ck= RootKnot; + + for (int i=0; iNext; + } + return ck; +} + + +bool __fastcall TSpline::Render() +{ + TKnot *LastKnot= NULL;; + + // if (RootKnot==NULL) +// RootKnot= Knots; + + if (RootKnot!=NULL) + { + glBindTexture(GL_TEXTURE_2D, 0); + glBegin(GL_LINE_STRIP); + int i=0; + for (LastKnot= RootKnot; LastKnot!=NULL && iNext, i++) +// for (LastKnot= RootKnot; LastKnot!=NULL; LastKnot= LastKnot->Next) + glVertex3f(LastKnot->Point.x,LastKnot->Point.y,LastKnot->Point.z); + glEnd(); +/* + if (RootKnot->Prev!=NULL) + { + glBindTexture(GL_TEXTURE_2D, 0); + glBegin(GL_LINE_STRIP); + glVertex3f(RootKnot->Point.x,RootKnot->Point.y,RootKnot->Point.z); + glVertex3f(RootKnot->Prev->Point.x,RootKnot->Prev->Point.y,RootKnot->Prev->Point.z); + glEnd(); + }*/ + + } + +} + + +//--------------------------------------------------------------------------- + +#pragma package(smart_init) diff --git a/Spline.h b/Spline.h new file mode 100644 index 00000000..b8ef6017 --- /dev/null +++ b/Spline.h @@ -0,0 +1,89 @@ +//--------------------------------------------------------------------------- +#ifndef SplineH +#define SplineH + +#include "dumb3d.h" +#include "QueryParserComp.hpp" +using namespace Math3D; + +#define B1(t) (t*t*t) +#define B2(t) (3*t*t*(1-t)) +#define B3(t) (3*t*(1-t)*(1-t)) +#define B4(t) ((1-t)*(1-t)*(1-t)) +#define Interpolate(t,p1,cp1,cp2,p2) (B4(t)*p1+B3(t)*cp1+B2(t)*cp2+B1(t)*p2) + +class TKnot +{ +public: +// inline bool __fastcall IsCurve() { return (!(Point==CPointIn)); }; +// inline vector3 __fastcall GetDirection() { return (CPointOut-Point); }; + __fastcall TKnot(); + __fastcall TKnot(int n); + __fastcall ~TKnot(); + inline float __fastcall GetRoll(float s) + { + if (Next) + { + s/= Length; + return ((1-s)*fRoll+(s)*Next->fRoll); + } + else + return fRoll; +// (Length-s) (s-Length) + } + vector3 __fastcall GetDirection(float t= 0); + inline vector3 __fastcall InterpolateSegm(float t) { return (Interpolate(t,Point,CPointOut,Next->CPointIn,Next->Point) ); }; + float __fastcall GetTFromS(float s); + bool __fastcall Init(TKnot *NNext, TKnot *NPrev); + bool __fastcall InitCPoints(); + bool __fastcall InitLength(); + vector3 Point,CPointIn,CPointOut; + float fRoll; + bool IsCurve; + float Length; + TKnot *Next,*Prev; + float fLengthIn,fLengthOut; + bool bSwitchDirectionForward; + bool bSwitchDirectionBackward; + +private: + vector3 GetFirstDerivative(float fTime); + float RombergIntegral (float fA, float fB); +}; + +class TSpline +{ +public: + __fastcall TSpline(); + __fastcall TSpline(AnsiString asNName); + __fastcall ~TSpline(); + bool __fastcall Create( int n, AnsiString asNName="foo" ); + bool __fastcall AssignKnots( TKnot *FirstKnot, int n ); + int __fastcall LoadFromFile( AnsiString FileName, TKnot *FirstKnot = NULL ); + int __fastcall Load( TQueryParserComp *Parser, AnsiString asEndString="endspline" ); + float __fastcall GetLength(); + vector3 __fastcall GetCenter(); + TKnot* __fastcall GetLastKnot(); + bool __fastcall Render(); + +// inline int NextIndex(int n) { return (np1]; + // p2 = &system[spring->p2]; +// VectorDifference(&p1->pos,&p2->pos,&deltaP); // Vector distance + deltaP= pPosition1 - pPosition2; +// dist = VectorLength(&deltaP); // Magnitude of deltaP + dist = deltaP.Length(); + if (dist==0) + { + vForce1=vForce2=vector3(0,0,0); + return false; + } + +// Hterm = (dist - spring->restLen) * spring->Ks; // Ks * (dist - rest) + Hterm= (dist - restLen) * Ks; // Ks * (dist - rest) + +// VectorDifference(&p1->v,&p2->v,&deltaV); // Delta Velocity Vector + deltaV= pPosition1 - pPosition2; + +// Dterm = (DotProduct(&deltaV,&deltaP) * spring->Kd) / dist; // Damping Term + //Dterm = (DotProduct(deltaV,deltaP) * Kd) / dist; + Dterm= 0; + +// ScaleVector(&deltaP,1.0f / dist, &springForce); // Normalize Distance Vector +// ScaleVector(&springForce,-(Hterm + Dterm),&springForce); // Calc Force + springForce= deltaP/dist*(-(Hterm + Dterm)); +// VectorSum(&p1->f,&springForce,&p1->f); // Apply to Particle 1 + // VectorDifference(&p2->f,&springForce,&p2->f); // - Force on Particle 2 + vForce1= springForce; + vForce2= springForce; + + return true; +} + +void __fastcall TSpring::Render() +{ + +} + + +//--------------------------------------------------------------------------- + +#pragma package(smart_init) diff --git a/Spring.h b/Spring.h new file mode 100644 index 00000000..3b587f67 --- /dev/null +++ b/Spring.h @@ -0,0 +1,38 @@ +//--------------------------------------------------------------------------- + +#ifndef ParticlesH +#define ParticlesH + + +#define STATIC_THRESHOLD 0.17f +//efine STATIC_THRESHOLD 0.03f +const double m_Kd = 0.02f; // DAMPING FACTOR +const double m_Kr = 0.8f; // 1.0 = SUPERBALL BOUNCE 0.0 = DEAD WEIGHT +const double m_Ksh = 5.0f; // HOOK'S SPRING CONSTANT +const double m_Ksd = 0.1f; // SPRING DAMPING CONSTANT + +const double m_Csf = 0.9f; // Default Static Friction +const double m_Ckf = 0.7f; // Default Kinetic Friction + +#include "dumb3d.h" +using namespace Math3D; + +class TSpring +{ +public: + __fastcall TSpring(); + __fastcall ~TSpring(); +// void __fastcall Init(TParticnp1, TParticle *np2, double nKs= 0.5f, double nKd= 0.002f, double nrestLen= -1.0f); + void __fastcall Init(double nrestLen, double nKs= 0.5f, double nKd= 0.002f); + bool __fastcall ComputateForces(vector3 pPosition1, vector3 pPosition2); + void __fastcall Render(); + vector3 vForce1,vForce2; + double restLen; // LENGTH OF SPRING AT REST + double Ks; // SPRING CONSTANT + double Kd; // SPRING DAMPING +private: +}; + + +//--------------------------------------------------------------------------- +#endif diff --git a/Texture.cpp b/Texture.cpp new file mode 100644 index 00000000..e6c0214f --- /dev/null +++ b/Texture.cpp @@ -0,0 +1,835 @@ +//--------------------------------------------------------------------------- + +/* + MaSzyna EU07 locomotive simulator + Copyright (C) 2001-2004 Marcin Wozniak and others + +*/ + +#include +#include +#include "opengl/glew.h" +#include + +#include "system.hpp" +#include "classes.hpp" +#include "stdio.h" +#pragma hdrstop + +#include "Usefull.h" +#include "Texture.h" +#include "TextureDDS.h" + +#include "logs.h" +#include "Globals.h" +#include "io.h" + +TTexturesManager::Alphas TTexturesManager::_alphas; +TTexturesManager::Names TTexturesManager::_names; + +void TTexturesManager::Init() +{ +}; + +TTexturesManager::Names::iterator TTexturesManager::LoadFromFile(std::string fileName,int filter) +{ + + std::string message("Loading - texture: "); + + std::string realFileName(fileName); + std::ifstream file(fileName.c_str()); + //Ra: niby bez tego jest lepiej, ale działa gorzej, więc przywrócone jest oryginalne + if (!file.is_open()) + realFileName.insert(0,szTexturePath); + else + file.close(); + + //char* cFileName = const_cast(fileName.c_str()); + + message += realFileName; + WriteLog(message.c_str()); //Ra: chybaa miało być z komunikatem z przodu, a nie tylko nazwa + + size_t pos = fileName.rfind('.'); + std::string ext(fileName, pos + 1, std::string::npos); + + AlphaValue texinfo; + + if (ext=="tga") + texinfo=LoadTGA(realFileName,filter); + else if (ext=="tex") + texinfo=LoadTEX(realFileName); + else if (ext=="bmp") + texinfo=LoadBMP(realFileName); + else if (ext=="dds") + texinfo=LoadDDS(realFileName,filter); + + _alphas.insert(texinfo); //zapamiętanie stanu przezroczystości tekstury - można by tylko przezroczyste + std::pair ret = _names.insert(std::make_pair(fileName, texinfo.first)); + + if (!texinfo.first) + { + WriteLog("Failed"); + ErrorLog("Missed texture: "+AnsiString(realFileName.c_str())); + return _names.end(); + }; + + _alphas.insert(texinfo); + ret=_names.insert(std::make_pair(fileName,texinfo.first)); //dodanie tekstury do magazynu (spisu nazw) + + //WriteLog("OK"); //Ra: "OK" nie potrzeba, samo "Failed" wystarczy + return ret.first; + +}; + +struct ReplaceSlash +{ + const char operator()(const char input) + { + return input == '/' ? '\\' : input; + } +}; + +GLuint TTexturesManager::GetTextureID(char* dir,char* where,std::string fileName,int filter) +{//ustalenie numeru tekstury, wczytanie jeśli nie jeszcze takiej nie było +/* +// Ra: niby tak jest lepiej, ale działa gorzej, więc przywrócone jest oryginalne + //najpierw szukamy w katalogu, z którego wywoływana jest tekstura, potem z wyższego + //Ra: przerobić na wyszukiwanie w drzewie nazw, do którego zapisywać np. rozmiary, przezroczystość + //Ra: ustalać, które tekstury można wczytać już w trakcie symulacji + size_t pos=fileName.find(':'); //szukamy dwukropka + if (pos!=std::string::npos) //po dwukropku mogą być podane dodatkowe informacje + fileName=fileName.substr(0,pos); //niebędące nazwą tekstury + std::transform(fileName.begin(),fileName.end(),fileName.begin(),ReplaceSlash()); //zamiana "/" na "\" + //jeśli bieżaca ścieżka do tekstur nie została dodana to dodajemy domyślną + //if (fileName.find('\\')==std::string::npos) //bz sensu + // fileName.insert(0,szDefaultTexturePath); + //najpierw szukamy w podanym katalogu, potem w domyślnym + Names::iterator iter; + std::ifstream file; + if ((fileName.find('.')==fileName.npos)?true:(fileName.rfind('.')second; //znalezione! + if (dir) + {//może we wskazanym katalogu? + test=fileName; + test.insert(0,dir); //jeszcze próba z dodatkową ścieżką + test.append(Global::szDefaultExt[i]); //dodanie jednego z kilku rozszerzeń + iter=_names.find(test); //czy mamy już w magazynie? + if (iter!=_names.end()) + return iter->second; //znalezione! + } + //} + //for (int i=0;i<4;++i) + //{//w magazynie nie ma, to sprawdzamy na dysku + test=fileName; + if (where) test.insert(0,where); //ścieżka obiektu wywołującego + test.append(Global::szDefaultExt[i]); //dodanie jednego z kilku rozszerzeń + file.open(test.c_str()); + if (!file.is_open()) + {test=fileName; + if (dir) test.insert(0,dir); //próba z dodatkową ścieżką + test.append(Global::szDefaultExt[i]); //dodanie jednego z kilku rozszerzeń + file.open(test.c_str()); + } + if (file.is_open()) + {//jak znaleziony, to plik zostaje otwarty + fileName=test; //zapamiętanie znalezionego rozszerzenia + break; //wyjście z pętli na etapie danego rozszerzenia + } + } + } + else + {//gdy jest kropka, to rozszerzenie jest jawne + std::string test; //zmienna robocza + //najpierw szukamy w magazynie + test=fileName; + if (where) test.insert(0,where); //ścieżka obiektu wywołującego + iter=_names.find(test); //czy mamy już w magazynie? + if (iter!=_names.end()) + return iter->second; //znalezione! + test=fileName; + if (dir) test.insert(0,dir); //jeszcze próba z dodatkową ścieżką + iter=_names.find(test); //czy mamy już w magazynie? + if (iter!=_names.end()) + return iter->second; //znalezione! + //w magazynie nie ma, to sprawdzamy na dysku + test=fileName; + if (where) test.insert(0,where); //ścieżka obiektu wywołującego + file.open(test.c_str()); + if (!file.is_open()) + {//jak znaleziony, to plik zostaje otwarty + test=fileName; + if (dir) test.insert(0,dir); //próba z dodatkową ścieżką + file.open(test.c_str()); + if (file.is_open()) + fileName=test; //ustalenie nowej nazwy + } + } + if (file.is_open()) + {//plik pozostaje otwarty, gdy znaleziono na dysku + file.close(); //można już zamknąć + iter=LoadFromFile(fileName,filter); //doda się do magazynu i zwróci swoją pozycję + } +*/ + size_t pos=fileName.find(':'); //szukamy dwukropka + if (pos!=std::string::npos) //po dwukropku mogą być podane dodatkowe informacje + fileName=fileName.substr(0,pos); //niebędące nazwą tekstury + pos=fileName.find('|'); //szukamy separatora tekstur + if (pos!=std::string::npos) //po | może być nazwa kolejnej tekstury + fileName=fileName.substr(0,pos); //i trzeba to obciąć + std::transform(fileName.begin(),fileName.end(),fileName.begin(),ReplaceSlash()); + //jeśli bieżaca ścieżka do tekstur nie została dodana to dodajemy domyślną + if (fileName.find('\\')==std::string::npos) + fileName.insert(0,szTexturePath); + Names::iterator iter; + if (fileName.find('.')==std::string::npos) + {//Ra: wypróbowanie rozszerzeń po kolei, zaczynając od domyślnego + fileName.append("."); //kropka będze na pewno, resztę trzeba próbować + std::string test; //zmienna robocza + for (int i=0;i<4;++i) + {//najpierw szukamy w magazynie + test=fileName; + test.append(Global::szDefaultExt[i]); + iter=_names.find(fileName); //czy mamy już w magazynie? + if (iter!=_names.end()) + return iter->second; //znalezione! + test.insert(0,szTexturePath); //jeszcze próba z dodatkową ścieżką + iter=_names.find(fileName); //czy mamy już w magazynie? + if (iter!=_names.end()) + return iter->second; //znalezione! + } + for (int i=0;i<4;++i) + {//w magazynie nie ma, to sprawdzamy na dysku + test=fileName; + test.append(Global::szDefaultExt[i]); + std::ifstream file(test.c_str()); + if (!file.is_open()) + {test.insert(0,szTexturePath); + file.open(test.c_str()); + } + if (file.is_open()) + { + fileName.append(Global::szDefaultExt[i]); //dopisanie znalezionego + file.close(); + break; //wyjście z pętli na etapie danego rozszerzenia + } + } + } + iter=_names.find(fileName); //czy mamy już w magazynie + if (iter==_names.end()) + iter=LoadFromFile(fileName,filter); + return (iter!=_names.end()?iter->second:0); +}; + +bool TTexturesManager::GetAlpha(GLuint id) +{//atrybut przezroczystości dla tekstury o podanym numerze (id) + Alphas::iterator iter=_alphas.find(id); + return (iter!=_alphas.end()?iter->second:false); +} + +TTexturesManager::AlphaValue TTexturesManager::LoadBMP(std::string fileName) +{ + + AlphaValue fail(0, false); + std::ifstream file(fileName.c_str(), std::ios::binary); + + if (!file.is_open()) + { + //file.close(); + return fail; + }; + + BITMAPFILEHEADER header; + size_t bytes; + + file.read((char*) &header, sizeof(BITMAPFILEHEADER)); + if(file.eof()) + { + file.close(); + return fail; + } + + // Read in bitmap information structure + BITMAPINFO info; + long infoSize = header.bfOffBits - sizeof(BITMAPFILEHEADER); + file.read((char*) &info, infoSize); + + if(file.eof()) + { + file.close(); + return fail; + }; + + GLuint width = info.bmiHeader.biWidth; + GLuint height = info.bmiHeader.biHeight; + + unsigned long bitSize = info.bmiHeader.biSizeImage; + if(!bitSize) + bitSize = (width * info.bmiHeader.biBitCount + 7) / 8 * height; + + GLubyte* data = new GLubyte[bitSize]; + file.read((char*) data, bitSize); + + if(file.eof()) + { + delete[] data; + file.close(); + return fail; + }; + + file.close(); + + GLuint id; + + glGenTextures(1, &id); + glBindTexture(GL_TEXTURE_2D, id); + glTexParameterf(GL_TEXTURE_2D,GL_TEXTURE_WRAP_S, GL_REPEAT); + glTexParameterf(GL_TEXTURE_2D,GL_TEXTURE_WRAP_T, GL_REPEAT); + glTexParameterf(GL_TEXTURE_2D,GL_TEXTURE_MAG_FILTER, GL_LINEAR); + glTexParameterf(GL_TEXTURE_2D,GL_TEXTURE_MIN_FILTER, GL_LINEAR); + + // This is specific to the binary format of the data read in. + glPixelStorei(GL_UNPACK_ALIGNMENT, 1); + glPixelStorei(GL_UNPACK_ROW_LENGTH, 0); + glPixelStorei(GL_UNPACK_SKIP_ROWS, 0); + glPixelStorei(GL_UNPACK_SKIP_PIXELS, 0); + + glTexImage2D(GL_TEXTURE_2D, 0, 3, width, height, 0, + GL_BGR_EXT, GL_UNSIGNED_BYTE, data); + + delete[] data; + return std::make_pair(id, false); + +}; + +TTexturesManager::AlphaValue TTexturesManager::LoadTGA(std::string fileName,int filter) +{ + AlphaValue fail(0,false); + int writeback=-1; //-1 plik jest OK, >=0 - od którego bajtu zapisać poprawiony plik + GLubyte TGACompheader[]={0,0,10,0,0,0,0,0,0,0,0,0}; //uncompressed TGA header + GLubyte TGAcompare[12]; //used to compare TGA header + GLubyte header[6]; //first 6 useful bytes from the header + std::fstream file(fileName.c_str(),std::ios::binary|std::ios::in); + file.read((char*)TGAcompare,sizeof(TGAcompare)); + file.read((char*)header,sizeof(header)); + //std::cout << file.tellg() << std::endl; + if (file.eof()) + { + file.close(); + return fail; + }; + bool compressed=(memcmp(TGACompheader,TGAcompare,sizeof(TGACompheader))==0); + GLint width =header[1]*256+header[0]; //determine the TGA width (highbyte*256+lowbyte) + GLint height=header[3]*256+header[2]; //determine the TGA height (highbyte*256+lowbyte) + // check if width, height and bpp is correct + if ( !width || !height || (header[4]!=24 && header[4]!=32)) + { + WriteLog("Bad texture: "+AnsiString(fileName.c_str())+" has wrong header or bits per pixel"); + file.close(); + return fail; + }; + {//sprawdzenie prawidłowości rozmiarów + int i,j; + for (i=width,j=0;i;i>>=1) if (i&1) ++j; + if (j==1) + for (i=height,j=0;i;i>>=1) if (i&1) ++j; + if (j!=1) WriteLog("Bad texture: "+AnsiString(fileName.c_str())+" is "+AnsiString(width)+"×"+AnsiString(height)); + } + GLuint bpp=header[4]; //grab the TGA's bits per pixel (24 or 32) + GLuint bytesPerPixel=bpp/8; // divide by 8 to get the bytes per pixel + GLuint imageSize=width*height*bytesPerPixel; //calculate the memory required for the TGA data + GLubyte *imageData=new GLubyte[imageSize]; //reserve memory to hold the TGA data + if (!compressed) + {//WriteLog("Not compressed."); + file.read(imageData,imageSize); + if (file.eof()) + { + delete[] imageData; + file.close(); + return fail; + }; + } + else + {//skompresowany plik TGA + GLuint filesize; //current byte + GLuint colorbuffer[1]; // Storage for 1 pixel + file.seekg(0,ios::end); //na koniec + filesize=(int)file.tellg()-18; //rozmiar bez nagłówka + file.seekg(18,ios::beg); //ponownie za nagłówkiem + GLubyte *copyto=imageData; //gdzie wstawiać w buforze + GLubyte *copyend=imageData+imageSize; //za ostatnim bajtem bufora + GLubyte *copyfrom=imageData+imageSize-filesize; //gdzie jest początek + int chunkheader=0; //Ra: będziemy wczytywać najmłodszy bajt + if (filesizeimageSize) + {//nie ma prawa być większe + WriteLog("Compression error"); + delete[] imageData; + file.close(); + return fail; + } + //na końcu mogą być śmieci + int extraend=copyend-copyto; //długość śmieci na końcu + if (extraend>0) + {//przesuwamy bufor do końca obszaru dekompresji + WriteLog("Extra bytes: "+AnsiString(extraend)); + memmove(copyfrom+extraend,copyfrom,filesize-extraend); + copyfrom+=extraend; + file.close(); + filesize-=extraend; //to chyba nie ma znaczenia + if (Global::iModifyTGA&2) //flaga obcinania śmieci + {//najlepiej by było obciąć plik, ale fstream tego nie potrafi + int handle; + for (unsigned int i=0;icopyfrom) + {//jeśli piksele mają być kopiowane, to możliwe jest przesunięcie ich o 1 bajt, na miejsce licznika + filesize=(imageData+imageSize-copyto)/bytesPerPixel; //ile pikseli pozostało do końca + //WriteLog("Decompression buffer overflow at pixel "+AnsiString((copyto-imageData)/bytesPerPixel)+"+"+AnsiString(filesize)); + //pozycję w pliku trzeba by zapamietać i po wczytaniu reszty pikseli starą metodą + //zapisać od niej dane od (copyto), poprzedzone bajtem o wartości (filesize-1) + writeback=imageData+imageSize+extraend-copyfrom; //ile bajtów skompresowanych zostało do końca + copyfrom=copyto; //adres piksela do zapisania + file.seekg(-writeback,ios::end); //odległość od końca (ujemna) + if ((filesize>128)||!(Global::iModifyTGA&4)) //gdy za dużo pikseli albo wyłączone + writeback=-1; //zapis możliwe jeśli ilość problematycznych pikseli nie przekaracza 128 + break; //bufor się zatkał, dalej w ten sposób się nie da + } + if (chunkheader<128) + {//dla nagłówka < 128 mamy podane ile pikseli przekopiować minus 1 + copybytes=(++chunkheader)*bytesPerPixel; //rozmiar kopiowanego obszaru + memcpy(copyto,++copyfrom,copybytes); //skopiowanie tylu bajtów + copyto+=copybytes; + copyfrom+=copybytes; + } + else + {//chunkheader > 128 RLE data, next color reapeated chunkheader - 127 times + chunkheader-=127; + //copy the color into the image data as many times as dictated + if (bytesPerPixel==4) + {//przy czterech bajtach powinno być szybsze używanie int + __int32 *ptr=(__int32*)(copyto); //wskaźnik na int + __int32 bgra=*((__int32*)++copyfrom); //kolor wypełniający (4 bajty) + for (int counter=0;counter128 RLE data, next color reapeated (chunkheader-127) times + chunkheader-=127; + file.read((char*)colorbuffer,bytesPerPixel); + //copy the color into the image data as many times as dictated + if (bytesPerPixel==4) + {//przy czterech bajtach powinno być szybsze używanie int + __int32 *ptr=(__int32*)(copyto),bgra=*((__int32*)colorbuffer); + for (int counter=0;counter=0) + {//zapisanie pliku + file.close(); //tamten zamykamy, bo był tylko do odczytu + if (writeback) + {//zapisanie samej końcówki pliku, która utrudnia dekompresję w buforze + WriteLog("Rewriting end of file..."); + chunkheader=filesize-1; //licznik jest o 1 mniejszy + file.open(fileName.c_str(),std::ios::binary|std::ios::out|std::ios::in); + file.seekg(-writeback,ios::end); //odległość od końca (ujemna) + file.write((char*)&chunkheader,1); //zapisanie licznika + file.write(copyfrom,filesize*bytesPerPixel); //piksele bez kompresji + } + else + {//zapisywanie całości pliku, będzie krótszy, więc trzeba usunąć go w całości + WriteLog("Writing uncompressed file..."); + TGAcompare[2]=2; //bez kompresji + file.open(fileName.c_str(),std::ios::binary|std::ios::out|std::ios::trunc); + file.write((char*)TGAcompare,sizeof(TGAcompare)); + file.write((char*)header,sizeof(header)); + file.write(imageData,imageSize); + } + } + }; + file.close(); //plik zamykamy dopiero na samym końcu + bool alpha = (bpp == 32); + bool hash = (fileName.find('#') != std::string::npos); //true gdy w nazwie jest "#" + bool dollar = (fileName.find('$') == std::string::npos); //true gdy w nazwie nie ma "$" + size_t pos=fileName.rfind('%'); //ostatni % w nazwie + if (pos!=std::string::npos) + if (pos10)) filter=-1; //jeśli nie jest cyfrą + } + if (!alpha&&!hash&&dollar&&(filter<0)) + filter=Global::iDefaultFiltering; //dotyczy tekstur TGA bez kanału alfa + //ewentualne przeskalowanie tekstury do dopuszczalnego rozumiaru + GLint w=width,h=height; + if (width>Global::iMaxTextureSize) width=Global::iMaxTextureSize; //ogranizczenie wielkości + if (height>Global::iMaxTextureSize) height=Global::iMaxTextureSize; + if ((w!=width)||(h!=height)) + {//przeskalowanie tekstury, żeby się nie wyświetlała jako biała + GLubyte* imgData=new GLubyte[width*height*bytesPerPixel]; //nowy rozmiar + gluScaleImage(bytesPerPixel==3?GL_RGB:GL_RGBA,w,h,GL_UNSIGNED_BYTE,imageData,width,height,GL_UNSIGNED_BYTE,imgData); + delete imageData; //usunięcie starego + imageData=imgData; + } + GLuint id=CreateTexture(imageData,(alpha?GL_BGRA:GL_BGR),width,height,alpha,hash,dollar,filter); + delete[] imageData; + ++Global::iTextures; + return std::make_pair(id,alpha); +}; + +TTexturesManager::AlphaValue TTexturesManager::LoadTEX(std::string fileName) +{ + + AlphaValue fail(0, false); + + std::ifstream file(fileName.c_str(), ios::binary); + + char head[5]; + file.read(head, 4); + head[4] = 0; + + bool alpha; + + if(std::string("RGB ") == head) + { + alpha = false; + } + else if(std::string("RGBA") == head) + { + alpha = true; + } + else + { + std::string message("Unrecognized texture format: "); + message += head; + Error(message.c_str()); + return fail; + }; + + GLuint width; + GLuint height; + + file.read((char *) &width, sizeof(int)); + file.read((char *) &height, sizeof(int)); + + GLuint bpp = alpha ? 4 : 3; + GLuint size = width * height * bpp; + + GLubyte* data = new GLubyte[size]; + file.read(data, size); + + bool hash = (fileName.find('#') != std::string::npos); + + GLuint id = CreateTexture(data,(alpha?GL_RGBA:GL_RGB),width,height,alpha,hash); + delete[] data; + + return std::make_pair(id, alpha); + +}; + +TTexturesManager::AlphaValue TTexturesManager::LoadDDS(std::string fileName,int filter) +{ + + AlphaValue fail(0, false); + + std::ifstream file(fileName.c_str(), ios::binary); + + char filecode[5]; + file.read(filecode, 4); + filecode[4] = 0; + + if(std::string("DDS ") != filecode) + { + file.close(); + return fail; + }; + + DDSURFACEDESC2 ddsd; + file.read((char*) &ddsd, sizeof(ddsd)); + + DDS_IMAGE_DATA data; + + // + // This .dds loader supports the loading of compressed formats DXT1, DXT3 + // and DXT5. + // + + GLuint factor; + + switch( ddsd.ddpfPixelFormat.dwFourCC ) + { + case FOURCC_DXT1: + // DXT1's compression ratio is 8:1 + data.format = GL_COMPRESSED_RGBA_S3TC_DXT1_EXT; + factor = 2; + break; + + case FOURCC_DXT3: + // DXT3's compression ratio is 4:1 + data.format = GL_COMPRESSED_RGBA_S3TC_DXT3_EXT; + factor = 4; + break; + + case FOURCC_DXT5: + // DXT5's compression ratio is 4:1 + data.format = GL_COMPRESSED_RGBA_S3TC_DXT5_EXT; + factor = 4; + break; + + default: + file.close(); + return fail; + } + + GLuint bufferSize = (ddsd.dwMipMapCount > 1 ? ddsd.dwLinearSize * factor : ddsd.dwLinearSize); + + data.pixels = new GLubyte[bufferSize]; + file.read((char*)data.pixels,bufferSize); + + file.close(); + + data.width = ddsd.dwWidth; + data.height = ddsd.dwHeight; + data.numMipMaps = ddsd.dwMipMapCount; + {//sprawdzenie prawidłowości rozmiarów + int i,j; + for (i=data.width,j=0;i;i>>=1) if (i&1) ++j; + if (j==1) + for (i=data.height,j=0;i;i>>=1) if (i&1) ++j; + if (j!=1) WriteLog("Bad texture: "+AnsiString(fileName.c_str())+" is "+AnsiString(data.width)+"×"+AnsiString(data.height)); + } + + if (ddsd.ddpfPixelFormat.dwFourCC == FOURCC_DXT1) + data.components = 3; + else + data.components = 4; + + data.blockSize = (data.format == GL_COMPRESSED_RGBA_S3TC_DXT1_EXT ? 8 : 16); + + GLuint id; + glGenTextures(1, &id); + glBindTexture(GL_TEXTURE_2D, id); + if (filter>=0) + SetFiltering(filter); //cyfra po % w nazwie + else + //SetFiltering(bHasAlpha&&bDollar,bHash); //znaki #, $ i kanał alfa w nazwie + SetFiltering(data.components==4,fileName.find('#')!=std::string::npos); + + GLuint offset = 0; + int firstMipMap = 0; + + while ((data.width>Global::iMaxTextureSize)||(data.height>Global::iMaxTextureSize)) + {//pomijanie zbyt dużych mipmap, jeśli wymagane jest ograniczenie rozmiaru + offset+=((data.width+3)/4)*((data.height+3)/4)*data.blockSize; + data.width/=2; + data.height/=2; + firstMipMap++; + }; + + for (int i=0;i=0) + SetFiltering(filter); //cyfra po % w nazwie + else + SetFiltering(bHasAlpha&&bDollar,bHash); //znaki #, $ i kanał alfa w nazwie + glPixelStorei(GL_UNPACK_ALIGNMENT,1); + glPixelStorei(GL_UNPACK_ROW_LENGTH,0); + glPixelStorei(GL_UNPACK_SKIP_ROWS,0); + glPixelStorei(GL_UNPACK_SKIP_PIXELS,0); + if (bHasAlpha || bHash || (filter==0)) + glTexImage2D(GL_TEXTURE_2D,0,(bHasAlpha?GL_RGBA:GL_RGB),width,height,0,bpp,GL_UNSIGNED_BYTE,buff); + else + gluBuild2DMipmaps(GL_TEXTURE_2D,GL_RGB,width,height,bpp,GL_UNSIGNED_BYTE,buff); + return ID; +} + +void TTexturesManager::Free() +{//usunięcie wszyskich tekstur (bez usuwania struktury) + for (Names::iterator iter=_names.begin();iter!=_names.end();iter++) + glDeleteTextures(1,&(iter->second)); +} + +std::string TTexturesManager::GetName(GLuint id) +{//pobranie nazwy tekstury + for (Names::iterator iter=_names.begin();iter!=_names.end();iter++) + if (iter->second==id) + return iter->first; + return ""; +}; +#pragma package(smart_init) + diff --git a/Texture.h b/Texture.h new file mode 100644 index 00000000..88230ceb --- /dev/null +++ b/Texture.h @@ -0,0 +1,58 @@ +//--------------------------------------------------------------------------- + +#ifndef TextureH +#define TextureH + +#include +#include + +#include "opengl/glew.h" +#include "usefull.h" + +/* +//Ra: miejsce umieszczenia tego jest deczko bezsensowne +void __fastcall glDebug() +{//logowanie błędów OpenGL + GLenum err; + if (Global::iErorrCounter==326) //tu wpisz o 1 mniej niz wartość, przy której się wyłożyło + Global::iErorrCounter=Global::iErorrCounter+0; //do zastawiania pułapki przed błędnym kodem + while ((err=glGetError())!=GL_NO_ERROR) //dalej jest pułapka po wykonaniu błędnego kodu + WriteLog("OpenGL error found: "+AnsiString(err)+", step:"+AnsiString(Global::iErorrCounter)); + ++Global::iErorrCounter; +}; +*/ + +class TTexturesManager +{ +public: + static void Init(); + static void Free(); + + static GLuint GetTextureID(char* dir,char* where,std::string name,int filter=-1); + static bool GetAlpha(GLuint ID); //McZapkie-141203: czy tekstura ma polprzeroczystosc + static std::string GetName(GLuint id); + +private: + typedef std::pair AlphaValue; + + typedef std::map Names; + typedef std::map Alphas; + + static Names::iterator LoadFromFile(std::string name,int filter=-1); + + static AlphaValue LoadBMP(std::string fileName); + static AlphaValue LoadTEX(std::string fileName); + static AlphaValue LoadTGA(std::string fileName,int filter=-1); + static AlphaValue LoadDDS(std::string fileName,int filter=-1); + + static void SetFiltering(int filter); + static void SetFiltering(bool alpha, bool hash); + static GLuint CreateTexture(char *buff,GLint bpp,int width,int height,bool bHasAlpha,bool bHash,bool bDollar=true,int filter=-1); + + static Names _names; + static Alphas _alphas; +// std::list Textures; + +}; +//--------------------------------------------------------------------------- +#endif diff --git a/TextureDDS.cpp b/TextureDDS.cpp new file mode 100644 index 00000000..10eebebb --- /dev/null +++ b/TextureDDS.cpp @@ -0,0 +1,299 @@ +#include "TextureDDS.h" + +void DxtcReadColors(const GLubyte* Data, Color8888* result) +{ + GLubyte r0, g0, b0, r1, g1, b1; + + b0 = Data[0] & 0x1F; + g0 = ((Data[0] & 0xE0) >> 5) | ((Data[1] & 0x7) << 3); + r0 = (Data[1] & 0xF8) >> 3; + + b1 = Data[2] & 0x1F; + g1 = ((Data[2] & 0xE0) >> 5) | ((Data[3] & 0x7) << 3); + r1 = (Data[3] & 0xF8) >> 3; + + result[0].r = r0 << 3 | r0 >> 2; + result[0].g = g0 << 2 | g0 >> 3; + result[0].b = b0 << 3 | b0 >> 2; + + result[1].r = r1 << 3 | r1 >> 2; + result[1].g = g1 << 2 | g1 >> 3; + result[1].b = b1 << 3 | b1 >> 2; +}; + +void DxtcReadColor(GLushort Data, Color8888* Out) +{ + GLubyte r, g, b; + + b = Data & 0x1f; + g = (Data & 0x7E0) >> 5; + r = (Data & 0xF800) >> 11; + + Out->r = r << 3 | r >> 2; + Out->g = g << 2 | g >> 3; + Out->b = b << 3 | r >> 2; +}; + +void DecompressDXT1(DDS_IMAGE_DATA lImage, const GLubyte *lCompData, GLubyte *Data) +{ + GLint x, y, i, j, k; + GLuint Select; + const GLubyte *Temp; + Color8888 colours[4], *col; + GLushort color_0, color_1; + GLuint bitmask, Offset; + + Temp = lCompData; + colours[0].a = 0xFF; + colours[1].a = 0xFF; + colours[2].a = 0xFF; + + for (y = 0; y < lImage.height; y += 4) { + for (x = 0; x < lImage.width; x += 4) { + color_0 = *((const GLushort*)Temp); + color_1 = *((const GLushort*)(Temp + 2)); + + DxtcReadColor(color_0, colours); + DxtcReadColor(color_1, colours + 1); + bitmask = ((const GLuint*)Temp)[1]; + + Temp += 8; + + if (color_0 > color_1) { + // Four-color block: derive the other two colors. + // 00 = color_0, 01 = color_1, 10 = color_2, 11 = color_3 + // These 2-bit codes correspond to the 2-bit fields + // stored in the 64-bit block. + colours[2].b = (2 * colours[0].b + colours[1].b + 1) / 3; + colours[2].g = (2 * colours[0].g + colours[1].g + 1) / 3; + colours[2].r = (2 * colours[0].r + colours[1].r + 1) / 3; + + colours[3].b = (colours[0].b + 2 * colours[1].b + 1) / 3; + colours[3].g = (colours[0].g + 2 * colours[1].g + 1) / 3; + colours[3].r = (colours[0].r + 2 * colours[1].r + 1) / 3; + colours[3].a = 0xFF; + } + else + { + // Three-color block: derive the other color. + // 00 = color_0, 01 = color_1, 10 = color_2, + // 11 = transparent. + // These 2-bit codes correspond to the 2-bit fields + // stored in the 64-bit block. + colours[2].b = (colours[0].b + colours[1].b) / 2; + colours[2].g = (colours[0].g + colours[1].g) / 2; + colours[2].r = (colours[0].r + colours[1].r) / 2; + + colours[3].b = (colours[0].b + 2 * colours[1].b + 1) / 3; + colours[3].g = (colours[0].g + 2 * colours[1].g + 1) / 3; + colours[3].r = (colours[0].r + 2 * colours[1].r + 1) / 3; + colours[3].a = 0x00; + } + + for (j = 0, k = 0; j < 4; j++) { + for (i = 0; i < 4; i++, k++) { + Select = (bitmask & (0x03 << k*2)) >> k*2; + col = &colours[Select]; + + if (((x + i) < lImage.width) && ((y + j) < lImage.height)) { + Offset = (y + j) * lImage.width * lImage.components + (x + i) * lImage.components; + Data[Offset + 0] = col->r; + Data[Offset + 1] = col->g; + Data[Offset + 2] = col->b; + Data[Offset + 3] = col->a; + } + } + } + } + } +} + +void DecompressDXT3(DDS_IMAGE_DATA lImage, const GLubyte *lCompData, GLubyte *Data) +{ + const GLubyte* Temp = lCompData; + + Color8888 colours[4], *col; + GLuint bitmask, Offset; + const GLubyte* alpha; + + for (GLint y = 0; y < lImage.height; y += 4) { + for (GLint x = 0; x < lImage.width; x += 4) { + alpha = Temp; + Temp += 8; + DxtcReadColors(Temp, colours); + bitmask = ((GLuint*)Temp)[1]; + + Temp += 8; + + // Four-color block: derive the other two colors. + // 00 = color_0, 01 = color_1, 10 = color_2, 11 = color_3 + // These 2-bit codes correspond to the 2-bit fields + // stored in the 64-bit block. + colours[2].b = (2 * colours[0].b + colours[1].b + 1) / 3; + colours[2].g = (2 * colours[0].g + colours[1].g + 1) / 3; + colours[2].r = (2 * colours[0].r + colours[1].r + 1) / 3; + + colours[3].b = (colours[0].b + 2 * colours[1].b + 1) / 3; + colours[3].g = (colours[0].g + 2 * colours[1].g + 1) / 3; + colours[3].r = (colours[0].r + 2 * colours[1].r + 1) / 3; + + GLuint k = 0; + for (GLint j = 0; j < 4; j++) { + for (GLint i = 0; i < 4; i++, k++) { + GLuint Select = (bitmask & (0x03 << k*2)) >> k*2; + col = &colours[Select]; + + if (((x + i) < lImage.width) && ((y + j) < lImage.height)) { + Offset = (y + j) * lImage.width * lImage.components + (x + i) * lImage.components; + Data[Offset + 0] = col->r; + Data[Offset + 1] = col->g; + Data[Offset + 2] = col->b; + } + } + } + + for (GLint j = 0; j < 4; j++) { + GLushort word = alpha[2*j] + 256*alpha[2*j+1]; + for (GLint i = 0; i < 4; i++) { + if (((x + i) < lImage.width) && ((y + j) < lImage.height)) { + Offset = (y + j) * lImage.width * lImage.components + (x + i) * lImage.components + 3; + Data[Offset] = word & 0x0F; + Data[Offset] = Data[Offset] | (Data[Offset] << 4); + } + word >>= 4; + } + } + } + } +} + +void DecompressDXT5(DDS_IMAGE_DATA lImage, const GLubyte *lCompData, GLubyte *Data) +{ + GLint x, y, z, i, j, k; + GLuint Select; + const GLubyte *Temp; //, r0, g0, b0, r1, g1, b1; + Color8888 colours[4], *col; + GLuint bitmask, Offset; + GLubyte alphas[8]; + GLuint bits; + + Temp = lCompData; + + for (y = 0; y < lImage.height; y += 4) { + for (x = 0; x < lImage.width; x += 4) { + if (y >= lImage.height || x >= lImage.width) + break; + alphas[0] = Temp[0]; + alphas[1] = Temp[1]; + const GLubyte* alphamask = Temp + 2; + Temp += 8; + + DxtcReadColors(Temp, colours); + bitmask = ((const GLuint*)Temp)[1]; + + Temp += 8; + + // Four-color block: derive the other two colors. + // 00 = color_0, 01 = color_1, 10 = color_2, 11 = color_3 + // These 2-bit codes correspond to the 2-bit fields + // stored in the 64-bit block. + colours[2].b = (2 * colours[0].b + colours[1].b + 1) / 3; + colours[2].g = (2 * colours[0].g + colours[1].g + 1) / 3; + colours[2].r = (2 * colours[0].r + colours[1].r + 1) / 3; + + colours[3].b = (colours[0].b + 2 * colours[1].b + 1) / 3; + colours[3].g = (colours[0].g + 2 * colours[1].g + 1) / 3; + colours[3].r = (colours[0].r + 2 * colours[1].r + 1) / 3; + + k = 0; + for (j = 0; j < 4; j++) { + for (i = 0; i < 4; i++, k++) { + + Select = (bitmask & (0x03 << k*2)) >> k*2; + col = &colours[Select]; + + // only put pixels out < width or height + if (((x + i) < lImage.width) && ((y + j) < lImage.height)) { + Offset = (y + j) * lImage.width * lImage.components + (x + i) * lImage.components; + Data[Offset + 0] = col->r; + Data[Offset + 1] = col->g; + Data[Offset + 2] = col->b; + } + } + } + + // 8-alpha or 6-alpha block? + if (alphas[0] > alphas[1]) { + // 8-alpha block: derive the other six alphas. + // Bit code 000 = alpha_0, 001 = alpha_1, others are interpolated. + alphas[2] = (6 * alphas[0] + 1 * alphas[1] + 3) / 7; // bit code 010 + alphas[3] = (5 * alphas[0] + 2 * alphas[1] + 3) / 7; // bit code 011 + alphas[4] = (4 * alphas[0] + 3 * alphas[1] + 3) / 7; // bit code 100 + alphas[5] = (3 * alphas[0] + 4 * alphas[1] + 3) / 7; // bit code 101 + alphas[6] = (2 * alphas[0] + 5 * alphas[1] + 3) / 7; // bit code 110 + alphas[7] = (1 * alphas[0] + 6 * alphas[1] + 3) / 7; // bit code 111 + } + else { + // 6-alpha block. + // Bit code 000 = alpha_0, 001 = alpha_1, others are interpolated. + alphas[2] = (4 * alphas[0] + 1 * alphas[1] + 2) / 5; // Bit code 010 + alphas[3] = (3 * alphas[0] + 2 * alphas[1] + 2) / 5; // Bit code 011 + alphas[4] = (2 * alphas[0] + 3 * alphas[1] + 2) / 5; // Bit code 100 + alphas[5] = (1 * alphas[0] + 4 * alphas[1] + 2) / 5; // Bit code 101 + alphas[6] = 0x00; // Bit code 110 + alphas[7] = 0xFF; // Bit code 111 + } + + // Note: Have to separate the next two loops, + // it operates on a 6-byte system. + + // First three bytes + //bits = *((ILint*)alphamask); + bits = (alphamask[0]) | (alphamask[1] << 8) | (alphamask[2] << 16); + for (j = 0; j < 2; j++) { + for (i = 0; i < 4; i++) { + // only put pixels out < width or height + if (((x + i) < lImage.width) && ((y + j) < lImage.height)) { + Offset = (y + j) * lImage.width * lImage.components + (x + i) * lImage.components + 3; + Data[Offset] = alphas[bits & 0x07]; + } + bits >>= 3; + } + } + + // Last three bytes + //bits = *((ILint*)&alphamask[3]); + bits = (alphamask[3]) | (alphamask[4] << 8) | (alphamask[5] << 16); + for (j = 2; j < 4; j++) { + for (i = 0; i < 4; i++) { + // only put pixels out < width or height + if (((x + i) < lImage.width) && ((y + j) < lImage.height)) { + Offset = (y + j) * lImage.width * lImage.components + (x + i) * lImage.components + 3; + Data[Offset] = alphas[bits & 0x07]; + } + bits >>= 3; + } + } + } + } +} + +void DecompressDXT(DDS_IMAGE_DATA lImage, const GLubyte *lCompData, GLubyte *Data) +{ + switch(lImage.format) + { + case GL_COMPRESSED_RGBA_S3TC_DXT1_EXT: + DecompressDXT1(lImage, lCompData, Data); + break; + + case GL_COMPRESSED_RGBA_S3TC_DXT3_EXT: + DecompressDXT3(lImage, lCompData, Data); + break; + + case GL_COMPRESSED_RGBA_S3TC_DXT5_EXT: + DecompressDXT5(lImage, lCompData, Data); + break; + + }; +} + diff --git a/TextureDDS.h b/TextureDDS.h new file mode 100644 index 00000000..8fdfc859 --- /dev/null +++ b/TextureDDS.h @@ -0,0 +1,30 @@ +#ifndef TEXTURE_DDS_H +#define TEXTURE_DDS_H 1 + +#include "opengl/glew.h" + +#pragma hdrstop + +struct Color8888 +{ + GLubyte r; // change the order of names to change the + GLubyte g; // order of the output ARGB or BGRA, etc... + GLubyte b; // Last one is MSB, 1st is LSB. + GLubyte a; +}; + +struct DDS_IMAGE_DATA +{ + GLsizei width; + GLsizei height; + GLint components; + GLenum format; + GLuint blockSize; + int numMipMaps; + GLubyte *pixels; +}; + +void DecompressDXT(DDS_IMAGE_DATA lImage, const GLubyte *lCompData, GLubyte *Data); + +#endif + \ No newline at end of file diff --git a/Timer.cpp b/Timer.cpp new file mode 100644 index 00000000..d5ebc7b2 --- /dev/null +++ b/Timer.cpp @@ -0,0 +1,119 @@ +//--------------------------------------------------------------------------- + +#include "system.hpp" +#include "classes.hpp" +#pragma hdrstop + +#include "Timer.h" +#include "Globals.h" + +namespace Timer { + +double DeltaTime,DeltaRenderTime; +double fFPS =0.0f; +double fLastTime =0.0f; +DWORD dwFrames =0L; +double fSimulationTime=0; +double fSoundTimer=0; +double fSinceStart=0; + + + +double __fastcall GetTime() +{ + return fSimulationTime; +} + +double __fastcall GetDeltaTime() +{//czas symulacji (stoi gdy pauza) + return DeltaTime; +} + +double __fastcall GetDeltaRenderTime() +{//czas renderowania (do poruszania się) + return DeltaRenderTime; +} + +double __fastcall GetfSinceStart() +{ + return fSinceStart; +} + +void __fastcall SetDeltaTime(double t) +{ + DeltaTime= t; +} + +double __fastcall GetSimulationTime() +{ + return fSimulationTime; +} + +void __fastcall SetSimulationTime(double t) +{ + fSimulationTime=t; +} + +bool __fastcall GetSoundTimer() +{//Ra: być może, by dźwięki nie modyfikowały się zbyt często, po 0.1s zeruje się ten licznik + return (fSoundTimer==0.0f); +} + + +double __fastcall GetFPS() +{ + return fFPS; +} + +void __fastcall ResetTimers() +{ + //double CurrentTime= + GetTickCount(); + DeltaTime=0.1; + DeltaRenderTime=0; + fSoundTimer=0; +}; + +LONGLONG fr,count,oldCount; +//LARGE_INTEGER fr,count; +void __fastcall UpdateTimers(bool pause) +{ + QueryPerformanceFrequency((LARGE_INTEGER*)&fr); + QueryPerformanceCounter((LARGE_INTEGER*)&count); + DeltaRenderTime=double(count-oldCount)/double(fr); + if (!pause) + {DeltaTime=Global::fTimeSpeed*DeltaRenderTime; + fSoundTimer+=DeltaTime; + if (fSoundTimer>0.1) fSoundTimer=0; +/* + double CurrentTime= double(count)/double(fr);//GetTickCount(); + DeltaTime= (CurrentTime-OldTime); + OldTime= CurrentTime; +*/ + if (DeltaTime>1) DeltaTime=1; + } + else + DeltaTime=0; //wszystko stoi, bo czas nie płynie + oldCount=count; + + // Keep track of the time lapse and frame count + double fTime=GetTickCount()*0.001f; // Get current time in seconds + ++dwFrames; //licznik ramek + //update the frame rate once per second + if (fTime-fLastTime>1.0f) + { + fFPS =dwFrames/(fTime-fLastTime); + fLastTime=fTime; + dwFrames =0L; + } + fSimulationTime+=DeltaTime; +}; + + + +}; + +//--------------------------------------------------------------------------- + +#pragma package(smart_init) + \ No newline at end of file diff --git a/Timer.h b/Timer.h new file mode 100644 index 00000000..0f2f042b --- /dev/null +++ b/Timer.h @@ -0,0 +1,33 @@ +//--------------------------------------------------------------------------- + +#ifndef TimerH +#define TimerH + +namespace Timer { + + +double __fastcall GetTime(); + +double __fastcall GetDeltaTime(); +double __fastcall GetDeltaRenderTime(); + +double __fastcall GetfSinceStart(); + +void __fastcall SetDeltaTime(double v); + +double __fastcall GetSimulationTime(); + +void __fastcall SetSimulationTime(double v); + +bool __fastcall GetSoundTimer(); + +double __fastcall GetFPS(); + +void __fastcall ResetTimers(); + +void __fastcall UpdateTimers(bool pause); + +}; + +//--------------------------------------------------------------------------- +#endif diff --git a/Track.cpp b/Track.cpp new file mode 100644 index 00000000..5ab2db36 --- /dev/null +++ b/Track.cpp @@ -0,0 +1,2618 @@ +//--------------------------------------------------------------------------- +/* + MaSzyna EU07 locomotive simulator + Copyright (C) 2001-2004 Marcin Wozniak and others + +*/ + +//nagłówki identyczne w każdym pliku... +#pragma hdrstop + +#include "Track.h" +#include "Usefull.h" +#include "Texture.h" +#include "Timer.h" +#include "Globals.h" +#include "Ground.h" +#include "parser.h" +#include "Mover.h" +#include "DynObj.h" +#include "AnimModel.h" +#include "MemCell.h" +#include "Event.h" + +#pragma package(smart_init) + +//101206 Ra: trapezoidalne drogi i tory +//110720 Ra: rozprucie zwrotnicy i odcinki izolowane + +static const double fMaxOffset=0.1; //double(0.1f)==0.100000001490116 +//const int NextMask[4]={0,1,0,1}; //tor następny dla stanów 0, 1, 2, 3 +//const int PrevMask[4]={0,0,1,1}; //tor poprzedni dla stanów 0, 1, 2, 3 +const int iLewo4[4]={5,3,4,6}; //segmenty (1..6) do skręcania w lewo +const int iPrawo4[4]={-4,-6,-3,-5}; //segmenty (1..6) do skręcania w prawo +const int iProsto4[4]={1,-1,2,-2}; //segmenty (1..6) do jazdy prosto +const int iEnds4[13]={3,0,2,1,2,0,-1,1,3,2,0,3,1}; //numer sąsiedniego toru na końcu segmentu "-1" +const int iLewo3[4]={1,3,2,1}; //segmenty do skręcania w lewo +const int iPrawo3[4]={-2,-1,-3,-2}; //segmenty do skręcania w prawo +const int iProsto3[4]={1,-1,2,1}; //segmenty do jazdy prosto +const int iEnds3[13]={3,0,2,1,2,0,-1,1,0,2,0,3,1}; //numer sąsiedniego toru na końcu segmentu "-1" +TIsolated *TIsolated::pRoot=NULL; + +__fastcall TSwitchExtension::TSwitchExtension(TTrack *owner,int what) +{//na początku wszystko puste + CurrentIndex=0; + pNexts[0]=NULL; //wskaźniki do kolejnych odcinków ruchu + pNexts[1]=NULL; + pPrevs[0]=NULL; + pPrevs[1]=NULL; + fOffsetSpeed=0.1; //prędkość liniowa iglic + fOffsetDelay=0.05; //dodatkowy ruch drugiej iglicy po zablokowaniu pierwszej na opornicy + fOffset1=fOffset=fDesiredOffset=-fOffsetDelay; //położenie zasadnicze + fOffset2=0.0; //w zasadniczym wewnętrzna iglica dolega + pOwner=NULL; + pNextAnim=NULL; + bMovement=false; //nie potrzeba przeliczać fOffset1 + Segments[0]=new TSegment(owner); //z punktu 1 do 2 + Segments[1]=new TSegment(owner); //z punktu 3 do 4 (1=3 dla zwrotnic; odwrócony dla skrzyżowań, ewentualnie 1=4) + Segments[2]=(what>=3)?new TSegment(owner):NULL; //z punktu 2 do 4 skrzyżowanie od góry: wersja "-1": + Segments[3]=(what>=4)?new TSegment(owner):NULL; //z punktu 4 do 1 1 1=4 0 0=3 + Segments[4]=(what>=5)?new TSegment(owner):NULL; //z punktu 1 do 3 4 x 3 3 3 x 2 2 + Segments[5]=(what>=6)?new TSegment(owner):NULL; //z punktu 3 do 2 2 2 1 1 + evPlus=evMinus=NULL; + fVelocity=-1.0; //maksymalne ograniczenie prędkości (ustawianej eventem) + vTrans=vector3(0,0,0); //docelowa translacja przesuwnicy +} +__fastcall TSwitchExtension::~TSwitchExtension() +{//nie ma nic do usuwania + //delete Segments[0]; + //delete Segments[1]; + delete Segments[2]; + delete Segments[3]; + delete Segments[4]; + delete Segments[5]; +} + +__fastcall TIsolated::TIsolated() +{//utworznie pustego + TIsolated("none",NULL); +}; +__fastcall TIsolated::TIsolated(const AnsiString &n,TIsolated *i) +{//utworznie obwodu izolowanego + asName=n; + pNext=i; + iAxles=0; + evBusy=evFree=NULL; + pMemCell=NULL; //podpiąć istniejącą albo utworzyć pustą +}; + +__fastcall TIsolated::~TIsolated() +{//usuwanie +/* + TIsolated *p=pRoot; + while (pRoot) + { + p=pRoot; + p->pNext=NULL; + delete p; + } +*/ +}; + +TIsolated* __fastcall TIsolated::Find(const AnsiString &n) +{//znalezienie obiektu albo utworzenie nowego + TIsolated *p=pRoot; + while (p) + {//jeśli się znajdzie, to podać wskaźnik + if (p->asName==n) return p; + p=p->pNext; + } + pRoot=new TIsolated(n,pRoot); + return pRoot; +}; + +void __fastcall TIsolated::Modify(int i,TDynamicObject *o) +{//dodanie lub odjęcie osi + if (iAxles) + {//grupa zajęta + iAxles+=i; + if (!iAxles) + {//jeśli po zmianie nie ma żadnej osi na odcinku izolowanym + if (evFree) + Global::AddToQuery(evFree,o); //dodanie zwolnienia do kolejki + if (Global::iMultiplayer) //jeśli multiplayer + Global::pGround->WyslijString(asName,10); //wysłanie pakietu o zwolnieniu + if (pMemCell) //w powiązanej komórce + pMemCell->UpdateValues(NULL,0,int(pMemCell->Value2())&~0xFF,update_memval2); //"zerujemy" ostatnią wartość + } + } + else + {//grupa była wolna + iAxles+=i; + if (iAxles) + { + if (evBusy) + Global::AddToQuery(evBusy,o); //dodanie zajętości do kolejki + if (Global::iMultiplayer) //jeśli multiplayer + Global::pGround->WyslijString(asName,11); //wysłanie pakietu o zajęciu + if (pMemCell) //w powiązanej komórce + pMemCell->UpdateValues(NULL,0,int(pMemCell->Value2())|1,update_memval2); //zmieniamy ostatnią wartość na nieparzystą + } + } +}; + + +__fastcall TTrack::TTrack(TGroundNode *g) +{//tworzenie nowego odcinka ruchu + trNext=trPrev=NULL; //sąsiednie + Segment=NULL; //dane odcinka + SwitchExtension=NULL; //dodatkowe parametry zwrotnicy i obrotnicy + TextureID1=0; //tekstura szyny + fTexLength=4.0; //powtarzanie tekstury + TextureID2=0; //tekstura podsypki albo drugiego toru zwrotnicy + fTexHeight1=0.6; //nowy profil podsypki ;) + fTexWidth=0.9; + fTexSlope=0.9; + eType=tt_Normal; //domyślnie zwykły + iCategoryFlag=1; //1-tor, 2-droga, 4-rzeka, 8-samolot? + fTrackWidth=1.435; //rozstaw toru, szerokość nawierzchni + fFriction=0.15; //współczynnik tarcia + fSoundDistance=-1; + iQualityFlag=20; + iDamageFlag=0; + eEnvironment=e_flat; + bVisible=true; + iEvents=0; //Ra: flaga informująca o obecności eventów + evEvent0=NULL; + evEvent1=NULL; + evEvent2=NULL; + evEventall0=NULL; + evEventall1=NULL; + evEventall2=NULL; + fVelocity=-1; //ograniczenie prędkości + fTrackLength=100.0; + fRadius=0; //promień wybranego toru zwrotnicy + fRadiusTable[0]=0; //dwa promienie nawet dla prostego + fRadiusTable[1]=0; + iNumDynamics=0; + ScannedFlag=false; + DisplayListID=0; + iTrapezoid=0; //parametry kształtu: 0-standard, 1-przechyłka, 2-trapez, 3-oba + hvOverhead=NULL; //drut zasilający, najbliższy Point1 toru + fTexRatio1=1.0; //proporcja boków tekstury nawierzchni (żeby zaoszczędzić na rozmiarach tekstur...) + fTexRatio2=1.0; //proporcja boków tekstury chodnika (żeby zaoszczędzić na rozmiarach tekstur...) + iPrevDirection=0; //domyślnie wirtualne odcinki dołączamy stroną od Point1 + iNextDirection=0; + pIsolated=NULL; + pMyNode=g; //Ra: proteza, żeby tor znał swoją nazwę TODO: odziedziczyć TTrack z TGroundNode + iAction=0; //normalnie może być pomijany podczas skanowania + fOverhead=-1.0; //można normalnie pobierać prąd (0 dla jazdy bezprądowej po danym odcinku + nFouling[0]=NULL; //ukres albo kozioł od strony Point1 + nFouling[1]=NULL; //ukres albo kozioł od strony Point2 + trColides=NULL; //tor kolizyjny, na którym trzeba sprawdzać pojazdy pod kątem zderzenia +} + +__fastcall TTrack::~TTrack() +{//likwidacja odcinka + if (eType==tt_Normal) + delete Segment; //dla zwrotnic nie usuwać tego (kopiowany) + else + {//usuwanie dodatkowych danych dla niezwykłych odcinków + if (eType==tt_Cross) + delete SwitchExtension->vPoints; //skrzyżowanie może mieć punkty + SafeDelete(SwitchExtension); + } +} + +void __fastcall TTrack::Init() +{//tworzenie pomocniczych danych + switch (eType) + { + case tt_Switch: + SwitchExtension=new TSwitchExtension(this,2); //na wprost i na bok + break; + case tt_Cross: //tylko dla skrzyżowania dróg + SwitchExtension=new TSwitchExtension(this,6); //6 połączeń + SwitchExtension->vPoints=NULL; //brak tablicy punktów + SwitchExtension->iPoints=0; + SwitchExtension->bPoints=false; //tablica punktów nie wypełniona + SwitchExtension->iRoads=4; //domyślnie 4 + break; + case tt_Normal: + Segment=new TSegment(this); + break; + case tt_Table: //oba potrzebne + SwitchExtension=new TSwitchExtension(this,1); //kopia oryginalnego toru + Segment=new TSegment(this); + break; + } +} + +TTrack* __fastcall TTrack::Create400m(int what,double dx) +{//tworzenie toru do wstawiania taboru podczas konwersji na E3D + TGroundNode *tmp=new TGroundNode(TP_TRACK); //node + TTrack* trk=tmp->pTrack; + trk->bVisible=false; //nie potrzeba pokazywać, zresztą i tak nie ma tekstur + trk->iCategoryFlag=what; //taki sam typ plus informacja, że dodatkowy + trk->Init(); //utworzenie segmentu + trk->Segment->Init(vector3(-dx,0,0),vector3(-dx,0,400),0,0,0); //prosty + tmp->pCenter=vector3(-dx,0,200); //środek, aby się mogło wyświetlić + TSubRect *r=Global::pGround->GetSubRect(tmp->pCenter.x,tmp->pCenter.z); + r->NodeAdd(tmp); //dodanie toru do segmentu + r->Sort(); //żeby wyświetlał tabor z dodanego toru + r->Release(); //usunięcie skompilowanych zasobów + return trk; +}; + +TTrack* __fastcall TTrack::NullCreate(int dir) +{//tworzenie toru wykolejającego od strony (dir), albo pętli dla samochodów + TGroundNode *tmp=new TGroundNode(TP_TRACK),*tmp2=NULL; //node + TTrack* trk=tmp->pTrack; //tor; UWAGA! obrotnica może generować duże ilości tego + //tmp->iType=TP_TRACK; + //TTrack* trk=new TTrack(tmp); //tor; UWAGA! obrotnica może generować duże ilości tego + //tmp->pTrack=trk; + trk->bVisible=false; //nie potrzeba pokazywać, zresztą i tak nie ma tekstur + //trk->iTrapezoid=1; //są przechyłki do uwzględniania w rysowaniu + trk->iCategoryFlag=(iCategoryFlag&15)|0x80; //taki sam typ plus informacja, że dodatkowy + double r1,r2; + Segment->GetRolls(r1,r2); //pobranie przechyłek na początku toru + vector3 p1,cv1,cv2,p2; //będziem tworzyć trajektorię lotu + if (iCategoryFlag&1) + {//tylko dla kolei + trk->iDamageFlag=128; //wykolejenie + trk->fVelocity=0.0; //koniec jazdy + trk->Init(); //utworzenie segmentu + switch (dir) + {//łączenie z nowym torem + case 0: + p1=Segment->FastGetPoint_0(); + p2=p1-450.0*Normalize(Segment->GetDirection1()); + trk->Segment->Init(p1,p2,5,-RadToDeg(r1),70.0); //bo prosty, kontrolne wyliczane przy zmiennej przechyłce + ConnectPrevPrev(trk,0); + break; + case 1: + p1=Segment->FastGetPoint_1(); + p2=p1-450.0*Normalize(Segment->GetDirection2()); + trk->Segment->Init(p1,p2,5,RadToDeg(r2),70.0); //bo prosty, kontrolne wyliczane przy zmiennej przechyłce + ConnectNextPrev(trk,0); + break; + case 3: //na razie nie możliwe + p1=SwitchExtension->Segments[1]->FastGetPoint_1(); //koniec toru drugiego zwrotnicy + p2=p1-450.0*Normalize(SwitchExtension->Segments[1]->GetDirection2()); //przedłużenie na wprost + trk->Segment->Init(p1,p2,5,RadToDeg(r2),70.0); //bo prosty, kontrolne wyliczane przy zmiennej przechyłce + ConnectNextPrev(trk,0); + //trk->ConnectPrevNext(trk,dir); + SetConnections(1); //skopiowanie połączeń + Switch(1); //bo się przełączy na 0, a to coś chce się przecież wykoleić na bok + break; //do drugiego zwrotnicy... nie zadziała? + } + } + else + {//tworznie pętelki dla samochodów + trk->fVelocity=20.0; //zawracanie powoli + trk->fRadius=20.0; //promień, aby się dodawało do tabelki prędkości i liczyło narastająco + trk->Init(); //utworzenie segmentu + tmp2=new TGroundNode(TP_TRACK); //drugi odcinek do zapętlenia + TTrack* trk2=tmp2->pTrack; + trk2->iCategoryFlag=(iCategoryFlag&15)|0x80; //taki sam typ plus informacja, że dodatkowy + trk2->bVisible=false; + trk2->fVelocity=20.0; //zawracanie powoli + trk2->fRadius=20.0; //promień, aby się dodawało do tabelki prędkości i liczyło narastająco + trk2->Init(); //utworzenie segmentu + switch (dir) + {//łączenie z nowym torem + case 0: + p1=Segment->FastGetPoint_0(); + cv1=-20.0*Normalize(Segment->GetDirection1()); //pierwszy wektor kontrolny + p2=p1+cv1+cv1; //40m + trk->Segment->Init(p1,p1+cv1,p2+vector3(-cv1.z,cv1.y,cv1.x),p2,2,-RadToDeg(r1),0.0); //bo prosty, kontrolne wyliczane przy zmiennej przechyłce + ConnectPrevPrev(trk,0); + trk2->Segment->Init(p1,p1+cv1,p2+vector3(cv1.z,cv1.y,-cv1.x),p2,2,-RadToDeg(r1),0.0); //bo prosty, kontrolne wyliczane przy zmiennej przechyłce + trk2->iPrevDirection=0; //zwrotnie do tego samego odcinka + break; + case 1: + p1=Segment->FastGetPoint_1(); + cv1=-20.0*Normalize(Segment->GetDirection2()); //pierwszy wektor kontrolny + p2=p1+cv1+cv1; + trk->Segment->Init(p1,p1+cv1,p2+vector3(-cv1.z,cv1.y,cv1.x),p2,2,RadToDeg(r2),0.0); //bo prosty, kontrolne wyliczane przy zmiennej przechyłce + ConnectNextPrev(trk,0); + trk2->Segment->Init(p1,p1+cv1,p2+vector3(cv1.z,cv1.y,-cv1.x),p2,2,RadToDeg(r2),0.0); //bo prosty, kontrolne wyliczane przy zmiennej przechyłce + trk2->iPrevDirection=1; //zwrotnie do tego samego odcinka + break; + } + trk2->trPrev=this; + trk->ConnectNextNext(trk2,1); //połączenie dwóch dodatkowych odcinków punktami 2 + tmp2->pCenter=(0.5*(p1+p2)); //środek, aby się mogło wyświetlić + } + //trzeba jeszcze dodać do odpowiedniego segmentu, aby się renderowały z niego pojazdy + tmp->pCenter=(0.5*(p1+p2)); //środek, aby się mogło wyświetlić + if (tmp2) tmp2->pCenter=tmp->pCenter; //ten sam środek jest + //Ra: to poniżej to porażka, ale na razie się nie da inaczej + TSubRect *r=Global::pGround->GetSubRect(tmp->pCenter.x,tmp->pCenter.z); + r->NodeAdd(tmp); //dodanie toru do segmentu + if (tmp2) r->NodeAdd(tmp2); //drugiego też + r->Sort(); //żeby wyświetlał tabor z dodanego toru + r->Release(); //usunięcie skompilowanych zasobów + return trk; +}; + +void __fastcall TTrack::ConnectPrevPrev(TTrack *pTrack,int typ) +{//łączenie torów - Point1 własny do Point1 cudzego + if (pTrack) + {//(pTrack) może być zwrotnicą, a (this) tylko zwykłym odcinkiem + trPrev=pTrack; + iPrevDirection=((pTrack->eType==tt_Switch)?0:(typ&2)); + pTrack->trPrev=this; + pTrack->iPrevDirection=0; + } +} +void __fastcall TTrack::ConnectPrevNext(TTrack *pTrack,int typ) +{//łaczenie torów - Point1 własny do Point2 cudzego + if (pTrack) + { + trPrev=pTrack; + iPrevDirection=typ|1; //1:zwykły lub pierwszy zwrotnicy, 3:drugi zwrotnicy + pTrack->trNext=this; + pTrack->iNextDirection=0; + if (bVisible) + if (pTrack->bVisible) + if (eType==tt_Normal) //jeśli łączone są dwa normalne + if (pTrack->eType==tt_Normal) + if ((fTrackWidth!=pTrack->fTrackWidth) //Ra: jeśli kolejny ma inne wymiary + || (fTexHeight1!=pTrack->fTexHeight1) + || (fTexWidth!=pTrack->fTexWidth) + || (fTexSlope!=pTrack->fTexSlope)) + pTrack->iTrapezoid|=2; //to rysujemy potworka + } +} +void __fastcall TTrack::ConnectNextPrev(TTrack *pTrack,int typ) +{//łaczenie torów - Point2 własny do Point1 cudzego + if (pTrack) + { + trNext=pTrack; + iNextDirection=((pTrack->eType==tt_Switch)?0:(typ&2)); + pTrack->trPrev=this; + pTrack->iPrevDirection=1; + if (bVisible) + if (pTrack->bVisible) + if (eType==tt_Normal) //jeśli łączone są dwa normalne + if (pTrack->eType==tt_Normal) + if ((fTrackWidth!=pTrack->fTrackWidth) //Ra: jeśli kolejny ma inne wymiary + || (fTexHeight1!=pTrack->fTexHeight1) + || (fTexWidth!=pTrack->fTexWidth) + || (fTexSlope!=pTrack->fTexSlope)) + iTrapezoid|=2; //to rysujemy potworka + } +} +void __fastcall TTrack::ConnectNextNext(TTrack *pTrack,int typ) +{//łaczenie torów - Point2 własny do Point2 cudzego + if (pTrack) + { + trNext=pTrack; + iNextDirection=typ|1; //1:zwykły lub pierwszy zwrotnicy, 3:drugi zwrotnicy + pTrack->trNext=this; + pTrack->iNextDirection=1; + } +} + +vector3 __fastcall MakeCPoint(vector3 p,double d,double a1,double a2) +{ + vector3 cp=vector3(0,0,1); + cp.RotateX(DegToRad(a2)); + cp.RotateY(DegToRad(a1)); + cp=cp*d+p; + return cp; +} + +vector3 __fastcall LoadPoint(cParser *parser) +{//pobranie współrzędnych punktu + vector3 p; + std::string token; + parser->getTokens(3); + *parser >> p.x >> p.y >> p.z; + return p; +} + +void __fastcall TTrack::Load(cParser *parser,vector3 pOrigin,AnsiString name) +{//pobranie obiektu trajektorii ruchu + vector3 pt,vec,p1,p2,cp1,cp2,p3,p4,cp3,cp4; //dodatkowe punkty potrzebne do skrzyżowań + double a1,a2,r1,r2,r3,r4,d1,d2,a; + AnsiString str; + bool bCurve; + int i;//,state; //Ra: teraz już nie ma początkowego stanu zwrotnicy we wpisie + std::string token; + + parser->getTokens(); + *parser >> token; + str=AnsiString(token.c_str()); //typ toru + + if (str=="normal") + { + eType=tt_Normal; + iCategoryFlag=1; + } + else if (str=="switch") + { + eType=tt_Switch; + iCategoryFlag=1; + } + else if (str=="turn") + {//Ra: to jest obrotnica + eType=tt_Table; + iCategoryFlag=1; + } + else if (str=="table") + {//Ra: obrotnica, przesuwnica albo wywrotnica + eType=tt_Table; + iCategoryFlag=1; + } + else if (str=="road") + { + eType=tt_Normal; + iCategoryFlag=2; + } + else if (str=="cross") + {//Ra: to będzie skrzyżowanie dróg + eType=tt_Cross; + iCategoryFlag=2; + } + else if (str=="river") + {eType=tt_Normal; + iCategoryFlag=4; + } + else if (str=="tributary") + {eType=tt_Tributary; + iCategoryFlag=4; + } + else + eType=tt_Unknown; + if (Global::iWriteLogEnabled&4) + WriteLog(str.c_str()); + parser->getTokens(4); + *parser >> fTrackLength >> fTrackWidth >> fFriction >> fSoundDistance; +// fTrackLength=Parser->GetNextSymbol().ToDouble(); //track length 100502 +// fTrackWidth=Parser->GetNextSymbol().ToDouble(); //track width +// fFriction=Parser->GetNextSymbol().ToDouble(); //friction coeff. +// fSoundDistance=Parser->GetNextSymbol().ToDouble(); //snd + fTrackWidth2=fTrackWidth; //rozstaw/szerokość w punkcie 2, na razie taka sama + parser->getTokens(2); + *parser >> iQualityFlag >> iDamageFlag; +// iQualityFlag=Parser->GetNextSymbol().ToInt(); //McZapkie: qualityflag +// iDamageFlag=Parser->GetNextSymbol().ToInt(); //damage + if (iDamageFlag&128) + iAction|=0x80; //flaga wykolejania z powodu uszkodzenia + parser->getTokens(); + *parser >> token; + str=AnsiString(token.c_str()); //environment + if (str=="flat") + eEnvironment=e_flat; + else if (str=="mountains" || str=="mountain") + eEnvironment=e_mountains; + else if (str=="canyon") + eEnvironment=e_canyon; + else if (str=="tunnel") + eEnvironment=e_tunnel; + else if (str=="bridge") + eEnvironment=e_bridge; + else if (str=="bank") + eEnvironment=e_bank; + else + { + eEnvironment=e_unknown; + Error("Unknown track environment: \""+str+"\""); + } + parser->getTokens(); + *parser >> token; + bVisible=(token.compare( "vis" )==0); //visible + if (bVisible) + { + parser->getTokens(); + *parser >> token; + str=AnsiString(token.c_str()); //railtex + TextureID1=(str=="none"?0:TTexturesManager::GetTextureID(szTexturePath,szSceneryPath,str.c_str(),(iCategoryFlag&1)?Global::iRailProFiltering:Global::iBallastFiltering)); + parser->getTokens(); + *parser >> fTexLength; //tex tile length + if (fTexLength<0.01) fTexLength=4; //Ra: zabezpiecznie przed zawieszeniem + parser->getTokens(); + *parser >> token; + str=AnsiString(token.c_str()); //sub || railtex + TextureID2=(str=="none"?0:TTexturesManager::GetTextureID(szTexturePath,szSceneryPath,str.c_str(),(eType==tt_Normal)?Global::iBallastFiltering:Global::iRailProFiltering)); + parser->getTokens(3); + *parser >> fTexHeight1 >> fTexWidth >> fTexSlope; +// fTexHeight=Parser->GetNextSymbol().ToDouble(); //tex sub height +// fTexWidth=Parser->GetNextSymbol().ToDouble(); //tex sub width +// fTexSlope=Parser->GetNextSymbol().ToDouble(); //tex sub slope width + if (iCategoryFlag&4) + fTexHeight1=-fTexHeight1; //rzeki mają wysokość odwrotnie niż drogi + } + else + if (Global::iWriteLogEnabled&4) WriteLog("unvis"); + Init(); //ustawia SwitchExtension + double segsize=5.0; //długość odcinka segmentowania + switch (eType) + {//Ra: łuki segmentowane co 5m albo 314-kątem foremnym + case tt_Table: //obrotnica jest prawie jak zwykły tor + iAction|=2; //flaga zmiany położenia typu obrotnica + case tt_Normal: + p1=LoadPoint(parser)+pOrigin; //pobranie współrzędnych P1 + parser->getTokens(); + *parser >> r1; //pobranie przechyłki w P1 + cp1=LoadPoint(parser); //pobranie współrzędnych punktów kontrolnych + cp2=LoadPoint(parser); + p2=LoadPoint(parser)+pOrigin; //pobranie współrzędnych P2 + parser->getTokens(2); + *parser >> r2 >> fRadius; //pobranie przechyłki w P1 i promienia + fRadius=fabs(fRadius); //we wpisie może być ujemny + if (iCategoryFlag&1) + {//zero na główce szyny + p1.y+=0.18; + p2.y+=0.18; + //na przechyłce doliczyć jeszcze pół przechyłki + } + if (fRadius!=0) //gdy podany promień + segsize=Min0R(5.0,0.2+fabs(fRadius)*0.02); //do 250m - 5, potem 1 co 50m + + if ((((p1+p1+p2)/3.0-p1-cp1).Length()<0.02)||(((p1+p2+p2)/3.0-p2+cp1).Length()<0.02)) + cp1=cp2=vector3(0,0,0); //"prostowanie" prostych z kontrolnymi, dokładność 2cm + + if ((cp1==vector3(0,0,0)) && (cp2==vector3(0,0,0))) //Ra: hm, czasem dla prostego są podane... + Segment->Init(p1,p2,segsize,r1,r2); //gdy prosty, kontrolne wyliczane przy zmiennej przechyłce + else + Segment->Init(p1,cp1+p1,cp2+p2,p2,segsize,r1,r2); //gdy łuk (ustawia bCurve=true) + if ((r1!=0)||(r2!=0)) iTrapezoid=1; //są przechyłki do uwzględniania w rysowaniu + if (eType==tt_Table) //obrotnica ma doklejkę + {//SwitchExtension=new TSwitchExtension(this,1); //dodatkowe zmienne dla obrotnicy + SwitchExtension->Segments[0]->Init(p1,p2,segsize); //kopia oryginalnego toru + } + else if (iCategoryFlag&2) + if (TextureID1&&fTexLength) + {//dla drogi trzeba ustalić proporcje boków nawierzchni + float w,h; + glBindTexture(GL_TEXTURE_2D,TextureID1); + glGetTexLevelParameterfv(GL_TEXTURE_2D,0,GL_TEXTURE_WIDTH,&w); + glGetTexLevelParameterfv(GL_TEXTURE_2D,0,GL_TEXTURE_HEIGHT,&h); + if (h!=0.0) fTexRatio1=w/h; //proporcja boków + glBindTexture(GL_TEXTURE_2D,TextureID2); + glGetTexLevelParameterfv(GL_TEXTURE_2D,0,GL_TEXTURE_WIDTH,&w); + glGetTexLevelParameterfv(GL_TEXTURE_2D,0,GL_TEXTURE_HEIGHT,&h); + if (h!=0.0) fTexRatio2=w/h; //proporcja boków + } + break; + + case tt_Cross: //skrzyżowanie dróg - 4 punkty z wektorami kontrolnymi + segsize=1.0; //specjalne segmentowanie ze względu na małe promienie + case tt_Tributary: //dopływ + case tt_Switch: //zwrotnica + iAction|=1; //flaga zmiany położenia typu zwrotnica lub skrzyżowanie dróg + //problemy z animacją iglic powstaje, gdzy odcinek prosty ma zmienną przechyłkę + //wtedy dzieli się na dodatkowe odcinki (po 0.2m, bo R=0) i animację diabli biorą + //Ra: na razie nie podejmuję się przerabiania iglic + + //SwitchExtension=new TSwitchExtension(this,eType==tt_Cross?6:2); //zwrotnica ma doklejkę + + p1=LoadPoint(parser)+pOrigin; //pobranie współrzędnych P1 + parser->getTokens(); + *parser >> r1; + cp1=LoadPoint(parser); + cp2=LoadPoint(parser); + p2=LoadPoint(parser)+pOrigin; //pobranie współrzędnych P2 + parser->getTokens(2); + *parser >> r2 >> fRadiusTable[0]; + fRadiusTable[0]=fabs(fRadiusTable[0]); //we wpisie może być ujemny + if (iCategoryFlag&1) + {//zero na główce szyny + p1.y+=0.18; + p2.y+=0.18; + //na przechyłce doliczyć jeszcze pół przechyłki? + } + if (fRadiusTable[0]>0) + segsize=Min0R(5.0,0.2+fRadiusTable[0]*0.02); + else + if (eType!=tt_Cross) //dla skrzyżowań muszą być podane kontrolne + {//jak promień zerowy, to przeliczamy punkty kontrolne + cp1=(p1+p1+p2)/3.0-p1; //jak jest prosty, to się zoptymalizuje + cp2=(p1+p2+p2)/3.0-p2; + segsize=5.0; + } //ułomny prosty + if (!(cp1==vector3(0,0,0)) && !(cp2==vector3(0,0,0))) + SwitchExtension->Segments[0]->Init(p1,p1+cp1,p2+cp2,p2,segsize,r1,r2); + else + SwitchExtension->Segments[0]->Init(p1,p2,segsize,r1,r2); + + p3=LoadPoint(parser)+pOrigin; //pobranie współrzędnych P3 + parser->getTokens(); + *parser >> r3; + cp3=LoadPoint(parser); + cp4=LoadPoint(parser); + p4=LoadPoint(parser)+pOrigin; //pobranie współrzędnych P4 + parser->getTokens(2); + *parser >> r4 >> fRadiusTable[1]; + fRadiusTable[1]=fabs(fRadiusTable[1]); //we wpisie może być ujemny + if (iCategoryFlag&1) + {//zero na główce szyny + p3.y+=0.18; + p4.y+=0.18; + //na przechyłce doliczyć jeszcze pół przechyłki? + } + + if (fRadiusTable[1]>0) + segsize=Min0R(5.0,0.2+fRadiusTable[1]*0.02); + else + if (eType!=tt_Cross) //dla skrzyżowań muszą być podane kontrolne + {//jak promień zerowy, to przeliczamy punkty kontrolne + cp3=(p3+p3+p4)/3.0-p3; //jak jest prosty, to się zoptymalizuje + cp4=(p3+p4+p4)/3.0-p4; + segsize=5.0; + } //ułomny prosty + + if (!(cp3==vector3(0,0,0)) && !(cp4==vector3(0,0,0))) + {//dla skrzyżowania dróg dać odwrotnie końce, żeby brzegi generować lewym + if (eType!=tt_Cross) + SwitchExtension->Segments[1]->Init(p3,p3+cp3,p4+cp4,p4,segsize,r3,r4); + else + SwitchExtension->Segments[1]->Init(p4,p4+cp4,p3+cp3,p3,segsize,r4,r3); //odwrócony + } + else + SwitchExtension->Segments[1]->Init(p3,p4,segsize,r3,r4); + if (eType==tt_Cross) + {//Ra 2014-07: dla skrzyżowań będą dodatkowe segmenty + SwitchExtension->Segments[2]->Init(p2,cp2+p2,cp4+p4,p4,segsize,r2,r4); //z punktu 2 do 4 + if (LengthSquared3(p3-p1)<0.01) //gdy mniej niż 10cm, to mamy skrzyżowanie trzech dróg + SwitchExtension->iRoads=3; + else //dla 4 dróg będą dodatkowe 3 segmenty + {SwitchExtension->Segments[3]->Init(p4,p4+cp4,p1+cp1,p1,segsize,r4,r1); //z punktu 4 do 1 + SwitchExtension->Segments[4]->Init(p1,p1+cp1,p3+cp3,p3,segsize,r1,r3); //z punktu 1 do 3 + SwitchExtension->Segments[5]->Init(p3,p3+cp3,p2+cp2,p2,segsize,r3,r2); //z punktu 3 do 2 + } + } + + Switch(0); //na stałe w położeniu 0 - nie ma początkowego stanu zwrotnicy we wpisie + + //Ra: zamienić później na iloczyn wektorowy + {vector3 v1,v2; + double a1,a2; + v1=SwitchExtension->Segments[0]->FastGetPoint_1()-SwitchExtension->Segments[0]->FastGetPoint_0(); + v2=SwitchExtension->Segments[1]->FastGetPoint_1()-SwitchExtension->Segments[1]->FastGetPoint_0(); + a1=atan2(v1.x,v1.z); + a2=atan2(v2.x,v2.z); + a2=a2-a1; + while (a2>M_PI) a2=a2-2*M_PI; + while (a2<-M_PI) a2=a2+2*M_PI; + SwitchExtension->RightSwitch=a2<0; //lustrzany układ OXY... + } + break; + } + parser->getTokens(); + *parser >> token; + str=AnsiString(token.c_str()); + while (str!="endtrack") + { + if (str=="event0") + { + parser->getTokens(); + *parser >> token; + asEvent0Name=AnsiString(token.c_str()); + } + else if (str=="event1") + { + parser->getTokens(); + *parser >> token; + asEvent1Name=AnsiString(token.c_str()); + } + else if (str=="event2") + { + parser->getTokens(); + *parser >> token; + asEvent2Name=AnsiString(token.c_str()); + } + else if (str=="eventall0") + { + parser->getTokens(); + *parser >> token; + asEventall0Name=AnsiString(token.c_str()); + } + else if (str=="eventall1") + { + parser->getTokens(); + *parser >> token; + asEventall1Name=AnsiString(token.c_str()); + } + else if (str=="eventall2") + { + parser->getTokens(); + *parser >> token; + asEventall2Name=AnsiString(token.c_str()); + } + else if (str=="velocity") + { + parser->getTokens(); + *parser >> fVelocity; //*0.28; McZapkie-010602 + if (SwitchExtension) //jeśli tor ruchomy + if (fabs(fVelocity)>=1.0) //żeby zero nie ograniczało dożywotnio + SwitchExtension->fVelocity=fVelocity; //zapamiętanie głównego ograniczenia; a np. -40 ogranicza tylko na bok + } + else if (str=="isolated") + {//obwód izolowany, do którego tor należy + parser->getTokens(); + *parser >> token; + pIsolated=TIsolated::Find(AnsiString(token.c_str())); + } + else if (str=="angle1") + {//kąt ścięcia końca od strony 1 + parser->getTokens(); + *parser >> a1; + Segment->AngleSet(0,a1); + } + else if (str=="angle2") + {//kąt ścięcia końca od strony 2 + parser->getTokens(); + *parser >> a2; + Segment->AngleSet(1,a2); + } + else if (str=="fouling1") + {//wskazanie modelu ukresu w kierunku 1 + parser->getTokens(); + *parser >> token; + //nFouling[0]= + } + else if (str=="fouling2") + {//wskazanie modelu ukresu w kierunku 2 + parser->getTokens(); + *parser >> token; + //nFouling[1]= + } + else if (str=="overhead") + {//informacja o stanie sieci: 0-jazda bezprądowa, >0-z opuszczonym i ograniczeniem prędkości + parser->getTokens(); + *parser >> fOverhead; + if (fOverhead>0.0) + iAction|=0x40; //flaga opuszczenia pantografu (tor uwzględniany w skanowaniu jako ograniczenie dla pantografujących) + } + else if (str=="colides") + {//informacja o stanie sieci: 0-jazda bezprądowa, >0-z opuszczonym i ograniczeniem prędkości + parser->getTokens(); + *parser >> token; + //trColides=; //tor kolizyjny, na którym trzeba sprawdzać pojazdy pod kątem zderzenia + } + else + ErrorLog("Unknown property: \""+str+"\" in track \""+name+"\""); + parser->getTokens(); *parser >> token; + str=AnsiString(token.c_str()); + } + //alternatywny zapis nazwy odcinka izolowanego - po znaku "@" w nazwie toru + if (!pIsolated) + if ((i=name.Pos("@"))>0) + if (ievPlus=NewEventPlus; + if (NewEventMinus) + SwitchExtension->evMinus=NewEventMinus; + return true; + } + return false; +}; + +AnsiString __fastcall TTrack::IsolatedName() +{//podaje nazwę odcinka izolowanego, jesli nie ma on jeszcze przypisanych zdarzeń + if (pIsolated) + if (!pIsolated->evBusy&&!pIsolated->evFree) + return pIsolated->asName; + return ""; +}; + +bool __fastcall TTrack::IsolatedEventsAssign(TEvent *busy, TEvent *free) +{//ustawia zdarzenia dla odcinka izolowanego + if (pIsolated) + {if (busy) + pIsolated->evBusy=busy; + if (free) + pIsolated->evFree=free; + return true; + } + return false; +}; + + +//ABu: przeniesione z Track.h i poprawione!!! +bool __fastcall TTrack::AddDynamicObject(TDynamicObject *Dynamic) +{//dodanie pojazdu do trajektorii + //Ra: tymczasowo wysyłanie informacji o zajętości konkretnego toru + //Ra: usunąć po upowszechnieniu się odcinków izolowanych + if (iCategoryFlag&0x100) //jeśli usuwaczek + {Dynamic->MyTrack=NULL; //trzeba by to uzależnić od kierunku ruchu... + return true; + } + if (Global::iMultiplayer) //jeśli multiplayer + if (!iNumDynamics) //pierwszy zajmujący + if (pMyNode->asName!="none") + Global::pGround->WyslijString(pMyNode->asName,8); //przekazanie informacji o zajętości toru + if (iNumDynamicsMyTrack=this; //ABu: na ktorym torze jesteśmy + if (Dynamic->iOverheadMask) //jeśli ma pantografy + Dynamic->OverheadTrack(fOverhead); //przekazanie informacji o jeździe bezprądowej na tym odcinku toru + return true; + } + else + { + Error("Too many dynamics on track "+pMyNode->asName); + return false; + } +}; + +void __fastcall TTrack::MoveMe(vector3 pPosition) +{//to nie jest używane + if (SwitchExtension) + { + SwitchExtension->Segments[0]->MoveMe(1*pPosition); + SwitchExtension->Segments[1]->MoveMe(1*pPosition); + SwitchExtension->Segments[2]->MoveMe(3*pPosition); //Ra: 3 razy? + SwitchExtension->Segments[3]->MoveMe(4*pPosition); + } + else + { + Segment->MoveMe(pPosition); + }; + ResourceManager::Unregister(this); +}; + + +const int numPts=4; +const int nnumPts=12; +/* +const vector6 szyna[nnumPts]= //szyna - vextor6(x,y,mapowanie tekstury,xn,yn,zn) +{pierwotna szyna, opracował youBy, zmiany w celu uzyskania symetrii + vector6( 0.111,-0.180,0.00, 1.000, 0.000,0.000), + vector6( 0.045,-0.155,0.15, 0.707, 0.707,0.000), + vector6( 0.045,-0.070,0.25, 0.707,-0.707,0.000), + vector6( 0.071,-0.040,0.35, 0.707,-0.707,0.000), //albo tu 0.073 + vector6( 0.072,-0.010,0.40, 0.707, 0.707,0.000), + vector6( 0.052,-0.000,0.45, 0.000, 1.000,0.000), + vector6( 0.020,-0.000,0.55, 0.000, 1.000,0.000), + vector6( 0.000,-0.010,0.60,-0.707, 0.707,0.000), + vector6( 0.001,-0.040,0.65,-0.707,-0.707,0.000), //albo tu -0.001 + vector6( 0.027,-0.070,0.75,-0.707,-0.707,0.000), //albo zostanie asymetryczna + vector6( 0.027,-0.155,0.85,-0.707, 0.707,0.000), + vector6(-0.039,-0.180,1.00,-1.000, 0.000,0.000) +}; +*/ +const vector6 szyna[nnumPts]= //szyna - vextor6(x,y,mapowanie tekstury,xn,yn,zn) +{//tę wersję opracował Tolein (bez pochylenia) + vector6( 0.111,-0.180,0.00, 1.000, 0.000,0.000), + vector6( 0.046,-0.150,0.15, 0.707, 0.707,0.000), + vector6( 0.044,-0.050,0.25, 0.707,-0.707,0.000), + vector6( 0.073,-0.038,0.35, 0.707,-0.707,0.000), + vector6( 0.072,-0.010,0.40, 0.707, 0.707,0.000), + vector6( 0.052,-0.000,0.45, 0.000, 1.000,0.000), + vector6( 0.020,-0.000,0.55, 0.000, 1.000,0.000), + vector6( 0.000,-0.010,0.60,-0.707, 0.707,0.000), + vector6( -0.001,-0.038,0.65,-0.707,-0.707,0.000), + vector6( 0.028,-0.050,0.75,-0.707,-0.707,0.000), + vector6( 0.026,-0.150,0.85,-0.707, 0.707,0.000), + vector6(-0.039,-0.180,1.00,-1.000, 0.000,0.000) +}; + + +const vector6 iglica[nnumPts]= //iglica - vextor3(x,y,mapowanie tekstury) +{vector6( 0.010,-0.180,0.00, 1.000, 0.000,0.000), + vector6( 0.010,-0.155,0.15, 1.000, 0.000,0.000), + vector6( 0.010,-0.070,0.25, 1.000, 0.000,0.000), + vector6( 0.010,-0.040,0.35, 1.000, 0.000,0.000), + vector6( 0.010,-0.010,0.40, 1.000, 0.000,0.000), + vector6( 0.010,-0.000,0.45, 0.707, 0.707,0.000), + vector6( 0.000,-0.000,0.55, 0.707, 0.707,0.000), + vector6( 0.000,-0.010,0.60,-1.000, 0.000,0.000), + vector6( 0.000,-0.040,0.65,-1.000, 0.000,0.000), + vector6( 0.000,-0.070,0.75,-1.000, 0.000,0.000), + vector6( 0.000,-0.155,0.85,-0.707, 0.707,0.000), + vector6(-0.040,-0.180,1.00,-1.000, 0.000,0.000) //1mm więcej, żeby nie nachodziły tekstury? +}; + + + +void __fastcall TTrack::Compile(GLuint tex) +{//generowanie treści dla Display Lists - model proceduralny + if (!tex) + {//jeśli nie podana tekstura, to każdy tor ma wlasne DL + if (DisplayListID) + Release(); //zwolnienie zasobów w celu ponownego utworzenia + if (Global::bManageNodes) + { + DisplayListID=glGenLists(1); //otwarcie nowej listy + glNewList(DisplayListID,GL_COMPILE); + }; + } + glColor3f(1.0f,1.0f,1.0f); //to tutaj potrzebne? + //Ra: nie zmieniamy oświetlenia przy kompilowaniu, ponieważ ono się zmienia w czasie! + //trochę podliczonych zmiennych, co się potem przydadzą + double fHTW=0.5*fabs(fTrackWidth); //połowa szerokości + double side=fabs(fTexWidth); //szerokść podsypki na zewnątrz szyny albo pobocza + double slop=fabs(fTexSlope); //szerokość pochylenia + double rozp=fHTW+side+slop; //brzeg zewnętrzny + double hypot1=hypot(slop,fTexHeight1); //rozmiar pochylenia do liczenia normalnych + if (hypot1==0.0) hypot1=1.0; + vector3 normal1=vector3(fTexSlope/hypot1,fTexHeight1/hypot1,0.0); //wektor normalny + double fHTW2,side2,slop2,rozp2,fTexHeight2,hypot2; + vector3 normal2; + if (iTrapezoid&2) //ten bit oznacza, że istnieje odpowiednie pNext + {//Ra: jest OK + fHTW2=0.5*fabs(trNext->fTrackWidth); //połowa rozstawu/nawierzchni + side2=fabs(trNext->fTexWidth); + slop2=fabs(trNext->fTexSlope); + rozp2=fHTW2+side2+slop2; //szerokość podstawy + fTexHeight2=trNext->fTexHeight1; + hypot2=hypot(slop2,fTexHeight2); + if (hypot2==0.0) hypot2=1.0; + normal2=vector3(trNext->fTexSlope/hypot2,fTexHeight2/hypot2,0.0); + } + else //gdy nie ma następnego albo jest nieodpowiednim końcem podpięty + {fHTW2=fHTW; side2=side; slop2=slop; rozp2=rozp; fTexHeight2=fTexHeight1; hypot2=hypot1; normal2=normal1;} + double roll1,roll2; + switch (iCategoryFlag&15) + { + case 1: //tor + { + Segment->GetRolls(roll1,roll2); + double sin1=sin(roll1),cos1=cos(roll1),sin2=sin(roll2),cos2=cos(roll2); + // zwykla szyna: //Ra: czemu główki są asymetryczne na wysokości 0.140? + vector6 rpts1[24],rpts2[24],rpts3[24],rpts4[24]; + int i; + for (i=0;i<12;++i) + {rpts1[i] =vector6(( fHTW+szyna[i].x)*cos1+szyna[i].y*sin1,-( fHTW+szyna[i].x)*sin1+szyna[i].y*cos1,szyna[i].z ,+szyna[i].n.x*cos1+szyna[i].n.y*sin1,-szyna[i].n.x*sin1+szyna[i].n.y*cos1,0.0); + rpts2[11-i]=vector6((-fHTW-szyna[i].x)*cos1+szyna[i].y*sin1,-(-fHTW-szyna[i].x)*sin1+szyna[i].y*cos1,szyna[i].z ,-szyna[i].n.x*cos1+szyna[i].n.y*sin1,+szyna[i].n.x*sin1+szyna[i].n.y*cos1,0.0); + } + if (iTrapezoid) //jak trapez albo przechyłki, to oddzielne punkty na końcu + for (i=0;i<12;++i) + {rpts1[12+i]=vector6(( fHTW2+szyna[i].x)*cos2+szyna[i].y*sin2,-( fHTW2+szyna[i].x)*sin2+szyna[i].y*cos2,szyna[i].z ,+szyna[i].n.x*cos2+szyna[i].n.y*sin2,-szyna[i].n.x*sin2+szyna[i].n.y*cos2,0.0); + rpts2[23-i]=vector6((-fHTW2-szyna[i].x)*cos2+szyna[i].y*sin2,-(-fHTW2-szyna[i].x)*sin2+szyna[i].y*cos2,szyna[i].z ,-szyna[i].n.x*cos2+szyna[i].n.y*sin2,+szyna[i].n.x*sin2+szyna[i].n.y*cos2,0.0); + } + switch (eType) //dalej zależnie od typu + { + case tt_Table: //obrotnica jak zwykły tor, animacja wykonywana w RaAnimate(), tutaj tylko regeneracja siatek + case tt_Normal: + if (TextureID2) + if (tex?TextureID2==tex:true) //jeśli pasuje do grupy (tex) + {//podsypka z podkładami jest tylko dla zwykłego toru + vector6 bpts1[8]; //punkty głównej płaszczyzny nie przydają się do robienia boków + if (fTexLength==4.0) //jeśli stare mapowanie na profil 0.2 0.5 1.1 (również 6-9-9/noil) + {//stare mapowanie z różną gęstością pikseli i oddzielnymi teksturami na każdy profil + if (iTrapezoid) //trapez albo przechyłki + {//podsypka z podkladami trapezowata + //ewentualnie poprawić mapowanie, żeby środek mapował się na 1.435/4.671 ((0.3464,0.6536) + //bo się tekstury podsypki rozjeżdżają po zmianie proporcji profilu + bpts1[0]=vector6(rozp, -fTexHeight1-0.18, 0.00,normal1.x,-normal1.y,0.0); //lewy brzeg + bpts1[1]=vector6((fHTW+side)*cos1, -(fHTW+side)*sin1-0.18, 0.33,0.0,1.0,0.0); //krawędź załamania + bpts1[2]=vector6(-bpts1[1].x, +(fHTW+side)*sin1-0.18, 0.67,-normal1.x,-normal1.y,0.0); //prawy brzeg początku symetrycznie + bpts1[3]=vector6(-rozp, -fTexHeight1-0.18, 1.00,-normal1.x,-normal1.y,0.0); //prawy skos + //przekrój końcowy + bpts1[4]=vector6(rozp2, -fTexHeight2-0.18, 0.00,normal2.x,-normal2.y,0.0); //lewy brzeg + bpts1[5]=vector6((fHTW2+side2)*cos2,-(fHTW2+side2)*sin2-0.18,0.33,0.0,1.0,0.0); //krawędź załamania + bpts1[6]=vector6(-bpts1[5].x, +(fHTW2+side2)*sin2-0.18,0.67,0.0,1.0,0.0); //prawy brzeg początku symetrycznie + bpts1[7]=vector6(-rozp2, -fTexHeight2-0.18, 1.00,-normal2.x,-normal2.y,0.0); //prawy skos + } + else + {bpts1[0]=vector6(rozp, -fTexHeight1-0.18,0.0,+normal1.x,-normal1.y,0.0); //lewy brzeg + bpts1[1]=vector6(fHTW+side, -0.18,0.33, +normal1.x,-normal1.y,0.0); //krawędź załamania + bpts1[2]=vector6(-fHTW-side,-0.18,0.67, -normal1.x,-normal1.y,0.0); //druga + bpts1[3]=vector6(-rozp, -fTexHeight1-0.18,1.0,-normal1.x,-normal1.y,0.0); //prawy skos + } + } + else + {//mapowanie proporcjonalne do powierzchni, rozmiar w poprzek określa fTexLength + double max=fTexRatio2*fTexLength; //szerokość proporcjonalna do długości + double map11=max>0.0?(fHTW+side)/max:0.25; //załamanie od strony 1 + double map12=max>0.0?(fHTW+side+hypot1)/max:0.5; //brzeg od strony 1 + if (iTrapezoid) //trapez albo przechyłki + {//podsypka z podkladami trapezowata + double map21=max>0.0?(fHTW2+side2)/max:0.25; //załamanie od strony 2 + double map22=max>0.0?(fHTW2+side2+hypot2)/max:0.5; //brzeg od strony 2 + //ewentualnie poprawić mapowanie, żeby środek mapował się na 1.435/4.671 ((0.3464,0.6536) + //bo się tekstury podsypki rozjeżdżają po zmianie proporcji profilu + bpts1[0]=vector6(rozp, -fTexHeight1-0.18 ,0.5-map12,normal1.x,-normal1.y,0.0); //lewy brzeg + bpts1[1]=vector6((fHTW+side)*cos1, -(fHTW+side)*sin1-0.18 ,0.5-map11,0.0,1.0,0.0); //krawędź załamania + bpts1[2]=vector6(-bpts1[1].x, +(fHTW+side)*sin1-0.18 ,0.5+map11,0.0,1.0,0.0); //prawy brzeg początku symetrycznie + bpts1[3]=vector6(-rozp, -fTexHeight1-0.18 ,0.5+map12,-normal1.x,-normal1.y,0.0); //prawy skos + //przekrój końcowy + bpts1[4]=vector6(rozp2, -fTexHeight2-0.18 ,0.5-map22,normal2.x,-normal2.y,0.0); //lewy brzeg + bpts1[5]=vector6((fHTW2+side2)*cos2,-(fHTW2+side2)*sin2-0.18,0.5-map21,0.0,1.0,0.0); //krawędź załamania + bpts1[6]=vector6(-bpts1[5].x, +(fHTW2+side2)*sin2-0.18,0.5+map21,0.0,1.0,0.0); //prawy brzeg początku symetrycznie + bpts1[7]=vector6(-rozp2, -fTexHeight2-0.18 ,0.5+map22,-normal2.x,-normal2.y,0.0); //prawy skos + } + else + {bpts1[0]=vector6(rozp, -fTexHeight1-0.18,0.5-map12,+normal1.x,-normal1.y,0.0); //lewy brzeg + bpts1[1]=vector6(fHTW+side, -0.18 ,0.5-map11,+normal1.x,-normal1.y,0.0); //krawędź załamania + bpts1[2]=vector6(-fHTW-side,-0.18 ,0.5+map11,-normal1.x,-normal1.y,0.0); //druga + bpts1[3]=vector6(-rozp, -fTexHeight1-0.18,0.5+map12,-normal1.x,-normal1.y,0.0); //prawy skos + } + } + if (!tex) glBindTexture(GL_TEXTURE_2D,TextureID2); + Segment->RenderLoft(bpts1,iTrapezoid?-4:4,fTexLength); + } + if (TextureID1) + if (tex?TextureID1==tex:true) //jeśli pasuje do grupy (tex) + {// szyny + if (!tex) glBindTexture(GL_TEXTURE_2D,TextureID1); + Segment->RenderLoft(rpts1,iTrapezoid?-nnumPts:nnumPts,fTexLength); + Segment->RenderLoft(rpts2,iTrapezoid?-nnumPts:nnumPts,fTexLength); + } + break; + case tt_Switch: //dla zwrotnicy dwa razy szyny + if (TextureID1) //zwrotnice nie są grupowane, aby prościej było je animować + {//iglice liczone tylko dla zwrotnic + //Ra: TODO: oddzielna animacja każdej iglicy, opór na docisku + vector6 rpts3[24],rpts4[24]; + for (i=0;i<12;++i) + {rpts3[i] =vector6(( fHTW+iglica[i].x)*cos1+iglica[i].y*sin1,-( fHTW+iglica[i].x)*sin1+iglica[i].y*cos1,iglica[i].z,+iglica[i].n.x*cos1+iglica[i].n.y*sin1,-iglica[i].n.x*sin1+iglica[i].n.y*cos1,0.0); + rpts4[11-i]=vector6((-fHTW-iglica[i].x)*cos1+iglica[i].y*sin1,-(-fHTW-iglica[i].x)*sin1+iglica[i].y*cos1,iglica[i].z,-iglica[i].n.x*cos1+iglica[i].n.y*sin1,+iglica[i].n.x*sin1+iglica[i].n.y*cos1,0.0); + } + if (iTrapezoid) //trapez albo przechyłki, to oddzielne punkty na końcu + for (i=0;i<12;++i) + {rpts3[12+i]=vector6(( fHTW2+iglica[i].x)*cos2+iglica[i].y*sin2,-( fHTW2+iglica[i].x)*sin2+iglica[i].y*cos2,iglica[i].z,+iglica[i].n.x*cos2+iglica[i].n.y*sin2,-iglica[i].n.x*sin2+iglica[i].n.y*cos2,0.0); + rpts4[23-i]=vector6((-fHTW2-iglica[i].x)*cos2+iglica[i].y*sin2,-(-fHTW2-iglica[i].x)*sin2+iglica[i].y*cos2,iglica[i].z,-iglica[i].n.x*cos2+iglica[i].n.y*sin2,+iglica[i].n.x*sin2+iglica[i].n.y*cos2,0.0); + } + //McZapkie-130302 - poprawione rysowanie szyn + if (SwitchExtension->RightSwitch) + {//zwrotnica prawa + glBindTexture(GL_TEXTURE_2D,TextureID1); + SwitchExtension->Segments[0]->RenderLoft(rpts1,nnumPts,fTexLength,2); //prawa szyna za iglicą + SwitchExtension->Segments[0]->RenderSwitchRail(rpts1,rpts3,nnumPts,fTexLength,2,SwitchExtension->fOffset2); //prawa iglica + SwitchExtension->Segments[0]->RenderLoft(rpts2,nnumPts,fTexLength); //lewa szyna normalnie cała + if (TextureID2!=TextureID1) //nie wiadomo, czy OpenGL to optymalizuje + glBindTexture(GL_TEXTURE_2D,TextureID2); + SwitchExtension->Segments[1]->RenderLoft(rpts1,nnumPts,fTexLength); //prawa szyna normalna cała + SwitchExtension->Segments[1]->RenderLoft(rpts2,nnumPts,fTexLength,2); //lewa szyna za iglicą + SwitchExtension->Segments[1]->RenderSwitchRail(rpts2,rpts4,nnumPts,fTexLength,2,-fMaxOffset+SwitchExtension->fOffset1); //lewa iglica + } + else + {//lewa kiedyś działała lepiej niż prawa + glBindTexture(GL_TEXTURE_2D,TextureID1); + SwitchExtension->Segments[0]->RenderLoft(rpts1,nnumPts,fTexLength); //prawa szyna normalna cała + SwitchExtension->Segments[0]->RenderLoft(rpts2,nnumPts,fTexLength,2); //lewa szyna za iglicą + SwitchExtension->Segments[0]->RenderSwitchRail(rpts2,rpts4,nnumPts,fTexLength,2,-SwitchExtension->fOffset2); //lewa iglica + if (TextureID2!=TextureID1) //nie wiadomo, czy OpenGL to optymalizuje + glBindTexture(GL_TEXTURE_2D,TextureID2); + SwitchExtension->Segments[1]->RenderLoft(rpts1,nnumPts,fTexLength,2); //prawa szyna za iglicą + SwitchExtension->Segments[1]->RenderSwitchRail(rpts1,rpts3,nnumPts,fTexLength,2,fMaxOffset-SwitchExtension->fOffset1); //prawa iglica + SwitchExtension->Segments[1]->RenderLoft(rpts2,nnumPts,fTexLength); //lewa szyna normalnie cała + } + } + break; + } + } //koniec obsługi torów + break; + case 2: //McZapkie-260302 - droga - rendering + //McZapkie:240702-zmieniony zakres widzialnosci + switch (eType) //dalej zależnie od typu + { + case tt_Normal: //drogi proste, bo skrzyżowania osobno + {vector6 bpts1[4]; //punkty głównej płaszczyzny przydają się do robienia boków + if (TextureID1||TextureID2) //punkty się przydadzą, nawet jeśli nawierzchni nie ma + {//double max=2.0*(fHTW>fHTW2?fHTW:fHTW2); //z szerszej strony jest 100% + double max=fTexRatio1*fTexLength; //test: szerokość proporcjonalna do długości + double map1=max>0.0?fHTW/max:0.5; //obcięcie tekstury od strony 1 + double map2=max>0.0?fHTW2/max:0.5; //obcięcie tekstury od strony 2 + if (iTrapezoid) //trapez albo przechyłki + {//nawierzchnia trapezowata + Segment->GetRolls(roll1,roll2); + bpts1[0]=vector6(fHTW*cos(roll1),-fHTW*sin(roll1),0.5-map1,sin(roll1),cos(roll1),0.0); //lewy brzeg początku + bpts1[1]=vector6(-bpts1[0].x,-bpts1[0].y,0.5+map1,-sin(roll1),cos(roll1),0.0); //prawy brzeg początku symetrycznie + bpts1[2]=vector6(fHTW2*cos(roll2),-fHTW2*sin(roll2),0.5-map2,sin(roll2),cos(roll2),0.0); //lewy brzeg końca + bpts1[3]=vector6(-bpts1[2].x,-bpts1[2].y,0.5+map2,-sin(roll2),cos(roll2),0.0); //prawy brzeg początku symetrycznie + } + else + {bpts1[0]=vector6( fHTW,0.0,0.5-map1,0.0,1.0,0.0); + bpts1[1]=vector6(-fHTW,0.0,0.5+map1,0.0,1.0,0.0); + } + } + if (TextureID1) //jeśli podana była tekstura, generujemy trójkąty + if (tex?TextureID1==tex:true) //jeśli pasuje do grupy (tex) + {//tworzenie trójkątów nawierzchni szosy + if (!tex) glBindTexture(GL_TEXTURE_2D,TextureID1); + Segment->RenderLoft(bpts1,iTrapezoid?-2:2,fTexLength); + } + if (TextureID2) + if (tex?TextureID2==tex:true) //jeśli pasuje do grupy (tex) + {//pobocze drogi - poziome przy przechyłce (a może krawężnik i chodnik zrobić jak w Midtown Madness 2?) + if (!tex) glBindTexture(GL_TEXTURE_2D,TextureID2); + vector6 rpts1[6],rpts2[6]; //współrzędne przekroju i mapowania dla prawej i lewej strony + if (fTexHeight1>=0.0) + {//standardowo: od zewnątrz pochylenie, a od wewnątrz poziomo + rpts1[0]=vector6(rozp,-fTexHeight1,0.0); //lewy brzeg podstawy + rpts1[1]=vector6(bpts1[0].x+side,bpts1[0].y,0.5); //lewa krawędź załamania + rpts1[2]=vector6(bpts1[0].x,bpts1[0].y,1.0); //lewy brzeg pobocza (mapowanie może być inne + rpts2[0]=vector6(bpts1[1].x,bpts1[1].y,1.0); //prawy brzeg pobocza + rpts2[1]=vector6(bpts1[1].x-side,bpts1[1].y,0.5); //prawa krawędź załamania + rpts2[2]=vector6(-rozp,-fTexHeight1,0.0); //prawy brzeg podstawy + if (iTrapezoid) //trapez albo przechyłki + {//pobocza do trapezowatej nawierzchni - dodatkowe punkty z drugiej strony odcinka + rpts1[3]=vector6(rozp2,-fTexHeight2,0.0); //lewy brzeg lewego pobocza + rpts1[4]=vector6(bpts1[2].x+side2,bpts1[2].y,0.5); //krawędź załamania + rpts1[5]=vector6(bpts1[2].x,bpts1[2].y,1.0); //brzeg pobocza + rpts2[3]=vector6(bpts1[3].x,bpts1[3].y,1.0); + rpts2[4]=vector6(bpts1[3].x-side2,bpts1[3].y,0.5); + rpts2[5]=vector6(-rozp2,-fTexHeight2,0.0); //prawy brzeg prawego pobocza + } + } + else + {//wersja dla chodnika: skos 1:3.75, każdy chodnik innej szerokości + //mapowanie propocjonalne do szerokości chodnika + //krawężnik jest mapowany od 31/64 do 32/64 lewy i od 32/64 do 33/64 prawy + double d=-fTexHeight1/3.75; //krawężnik o wysokości 150mm jest pochylony 40mm + double max=fTexRatio2*fTexLength; //test: szerokość proporcjonalna do długości + double map1l=max>0.0?side/max:0.484375; //obcięcie tekstury od lewej strony punktu 1 + double map1r=max>0.0?slop/max:0.484375; //obcięcie tekstury od prawej strony punktu 1 + rpts1[0]=vector6(bpts1[0].x+slop,bpts1[0].y-fTexHeight1,0.515625+map1r ); //prawy brzeg prawego chodnika + rpts1[1]=vector6(bpts1[0].x+d, bpts1[0].y-fTexHeight1,0.515625 ); //prawy krawężnik u góry + rpts1[2]=vector6(bpts1[0].x, bpts1[0].y, 0.515625-d/2.56); //prawy krawężnik u dołu + rpts2[0]=vector6(bpts1[1].x, bpts1[1].y, 0.484375+d/2.56); //lewy krawężnik u dołu + rpts2[1]=vector6(bpts1[1].x-d, bpts1[1].y-fTexHeight1,0.484375 ); //lewy krawężnik u góry + rpts2[2]=vector6(bpts1[1].x-side,bpts1[1].y-fTexHeight1,0.484375-map1l ); //lewy brzeg lewego chodnika + if (iTrapezoid) //trapez albo przechyłki + {//pobocza do trapezowatej nawierzchni - dodatkowe punkty z drugiej strony odcinka + slop2=fabs((iTrapezoid&2)?slop2:slop); //szerokość chodnika po prawej + double map2l=max>0.0?side2/max:0.484375; //obcięcie tekstury od lewej strony punktu 2 + double map2r=max>0.0?slop2/max:0.484375; //obcięcie tekstury od prawej strony punktu 2 + rpts1[3]=vector6(bpts1[2].x+slop2,bpts1[2].y-fTexHeight2,0.515625+map2r ); //prawy brzeg prawego chodnika + rpts1[4]=vector6(bpts1[2].x+d, bpts1[2].y-fTexHeight2,0.515625 ); //prawy krawężnik u góry + rpts1[5]=vector6(bpts1[2].x, bpts1[2].y, 0.515625-d/2.56); //prawy krawężnik u dołu + rpts2[3]=vector6(bpts1[3].x, bpts1[3].y, 0.484375+d/2.56); //lewy krawężnik u dołu + rpts2[4]=vector6(bpts1[3].x-d, bpts1[3].y-fTexHeight2,0.484375 ); //lewy krawężnik u góry + rpts2[5]=vector6(bpts1[3].x-side2,bpts1[3].y-fTexHeight2,0.484375-map2l ); //lewy brzeg lewego chodnika + } + } + if (iTrapezoid) //trapez albo przechyłki + {//pobocza do trapezowatej nawierzchni - dodatkowe punkty z drugiej strony odcinka + if ((fTexHeight1>=0.0)?true:(slop!=0.0)) + Segment->RenderLoft(rpts1,-3,fTexLength); //tylko jeśli jest z prawej + if ((fTexHeight1>=0.0)?true:(side!=0.0)) + Segment->RenderLoft(rpts2,-3,fTexLength); //tylko jeśli jest z lewej + } + else + {//pobocza zwykłe, brak przechyłki + if ((fTexHeight1>=0.0)?true:(slop!=0.0)) + Segment->RenderLoft(rpts1,3,fTexLength); + if ((fTexHeight1>=0.0)?true:(side!=0.0)) + Segment->RenderLoft(rpts2,3,fTexLength); + } + } + break; + } + case tt_Cross: //skrzyżowanie dróg rysujemy inaczej + {//ustalenie współrzędnych środka - przecięcie Point1-Point2 z CV4-Point4 + double a[4]; //kąty osi ulic wchodzących + vector3 p[4]; //punkty się przydadzą do obliczeń + //na razie połowa odległości pomiędzy Point1 i Point2, potem się dopracuje + a[0]=a[1]=0.5; //parametr do poszukiwania przecięcia łuków + //modyfikować a[0] i a[1] tak, aby trafić na przecięcie odcinka 34 + p[0]=SwitchExtension->Segments[0]->FastGetPoint(a[0]); //współrzędne środka pierwszego odcinka + p[1]=SwitchExtension->Segments[1]->FastGetPoint(a[1]); //-//- drugiego + //p[2]=p[1]-p[0]; //jeśli różne od zera, przeliczyć a[0] i a[1] i wyznaczyć nowe punkty + vector3 oxz=p[0]; //punkt mapowania środka tekstury skrzyżowania + p[0]=SwitchExtension->Segments[0]->GetDirection1(); //Point1 - pobranie wektorów kontrolnych + p[1]=SwitchExtension->Segments[1]->GetDirection2(); //Point3 (bo zamienione) + p[2]=SwitchExtension->Segments[0]->GetDirection2(); //Point2 + p[3]=SwitchExtension->Segments[1]->GetDirection1(); //Point4 (bo zamienione) + a[0]=atan2(-p[0].x,p[0].z); // kąty stycznych osi dróg + a[1]=atan2(-p[1].x,p[1].z); + a[2]=atan2(-p[2].x,p[2].z); + a[3]=atan2(-p[3].x,p[3].z); + p[0]=SwitchExtension->Segments[0]->FastGetPoint_0(); //Point1 - pobranie współrzędnych końców + p[1]=SwitchExtension->Segments[1]->FastGetPoint_1(); //Point3 + p[2]=SwitchExtension->Segments[0]->FastGetPoint_1(); //Point2 + p[3]=SwitchExtension->Segments[1]->FastGetPoint_0(); //Point4 - przy trzech drogach pokrywa się z Point1 + //2014-07: na początek rysować brzegi jak dla łuków + //punkty brzegu nawierzchni uzyskujemy podczas renderowania boków (bez sensu, ale najszybciej było zrobić) + int i,j; //ile punktów (może byc różna ilość punktów między drogami) + if (!SwitchExtension->vPoints) + {//jeśli tablica punktów nie jest jeszcze utworzona, zliczamy punkty i tworzymy ją + if (SwitchExtension->iRoads==3) //mogą być tylko 3 drogi zamiast 4 + SwitchExtension->iPoints=5+SwitchExtension->Segments[0]->RaSegCount()+SwitchExtension->Segments[1]->RaSegCount()+SwitchExtension->Segments[2]->RaSegCount(); + else + SwitchExtension->iPoints=5+SwitchExtension->Segments[2]->RaSegCount()+SwitchExtension->Segments[3]->RaSegCount()+SwitchExtension->Segments[4]->RaSegCount()+SwitchExtension->Segments[5]->RaSegCount(); //mogą być tylko 3 drogi + SwitchExtension->vPoints=new vector3[SwitchExtension->iPoints]; //tablica utworzona z zapasem, ale nie wypełniona współrzędnymi + } + vector3 *b=SwitchExtension->bPoints?NULL:SwitchExtension->vPoints; //zmienna robocza, NULL gdy tablica punktów już jest wypełniona + vector6 bpts1[4]; //punkty głównej płaszczyzny przydają się do robienia boków + if (TextureID1||TextureID2) //punkty się przydadzą, nawet jeśli nawierzchni nie ma + {//double max=2.0*(fHTW>fHTW2?fHTW:fHTW2); //z szerszej strony jest 100% + double max=fTexRatio1*fTexLength; //test: szerokość proporcjonalna do długości + double map1=max>0.0?fHTW/max:0.5; //obcięcie tekstury od strony 1 + double map2=max>0.0?fHTW2/max:0.5; //obcięcie tekstury od strony 2 + //if (iTrapezoid) //trapez albo przechyłki + {//nawierzchnia trapezowata + Segment->GetRolls(roll1,roll2); + bpts1[0]=vector6(fHTW*cos(roll1),-fHTW*sin(roll1),0.5-map1,sin(roll1),cos(roll1),0.0); //lewy brzeg początku + bpts1[1]=vector6(-bpts1[0].x,-bpts1[0].y,0.5+map1,-sin(roll1),cos(roll1),0.0); //prawy brzeg początku symetrycznie + bpts1[2]=vector6(fHTW2*cos(roll2),-fHTW2*sin(roll2),0.5-map2,sin(roll2),cos(roll2),0.0); //lewy brzeg końca + bpts1[3]=vector6(-bpts1[2].x,-bpts1[2].y,0.5+map2,-sin(roll2),cos(roll2),0.0); //prawy brzeg początku symetrycznie + } + } + //najpierw renderowanie poboczy i zapamiętywanie punktów + //problem ze skrzyżowaniami jest taki, że teren chce się pogrupować wg tekstur, ale zaczyna od nawierzchni + //sama nawierzchnia nie wypełni tablicy punktów, bo potrzebne są pobocza + //ale pobocza renderują się później, więc nawierzchnia nie załapuje się na renderowanie w swoim czasie + //if (TextureID2) + //if (tex?TextureID2==tex:true) //jeśli pasuje do grupy (tex) + {//pobocze drogi - poziome przy przechyłce (a może krawężnik i chodnik zrobić jak w Midtown Madness 2?) + if (TextureID2) if (!tex) glBindTexture(GL_TEXTURE_2D,TextureID2); + vector6 rpts1[6],rpts2[6]; //współrzędne przekroju i mapowania dla prawej i lewej strony + //Ra 2014-07: trzeba to przerobić na pętlę i pobierać profile (przynajmniej 2..4) z sąsiednich dróg + if (fTexHeight1>=0.0) + {//standardowo: od zewnątrz pochylenie, a od wewnątrz poziomo + rpts1[0]=vector6(rozp,-fTexHeight1,0.0); //lewy brzeg podstawy + rpts1[1]=vector6(bpts1[0].x+side,bpts1[0].y,0.5); //lewa krawędź załamania + rpts1[2]=vector6(bpts1[0].x,bpts1[0].y,1.0); //lewy brzeg pobocza (mapowanie może być inne + rpts2[0]=vector6(bpts1[1].x,bpts1[1].y,1.0); //prawy brzeg pobocza + rpts2[1]=vector6(bpts1[1].x-side,bpts1[1].y,0.5); //prawa krawędź załamania + rpts2[2]=vector6(-rozp,-fTexHeight1,0.0); //prawy brzeg podstawy + //if (iTrapezoid) //trapez albo przechyłki + {//pobocza do trapezowatej nawierzchni - dodatkowe punkty z drugiej strony odcinka + rpts1[3]=vector6(rozp2,-fTexHeight2,0.0); //lewy brzeg lewego pobocza + rpts1[4]=vector6(bpts1[2].x+side2,bpts1[2].y,0.5); //krawędź załamania + rpts1[5]=vector6(bpts1[2].x,bpts1[2].y,1.0); //brzeg pobocza + rpts2[3]=vector6(bpts1[3].x,bpts1[3].y,1.0); + rpts2[4]=vector6(bpts1[3].x-side2,bpts1[3].y,0.5); + rpts2[5]=vector6(-rozp2,-fTexHeight2,0.0); //prawy brzeg prawego pobocza + } + } + else + {//wersja dla chodnika: skos 1:3.75, każdy chodnik innej szerokości + //mapowanie propocjonalne do szerokości chodnika + //krawężnik jest mapowany od 31/64 do 32/64 lewy i od 32/64 do 33/64 prawy + double d=-fTexHeight1/3.75; //krawężnik o wysokości 150mm jest pochylony 40mm + double max=fTexRatio2*fTexLength; //test: szerokość proporcjonalna do długości + double map1l=max>0.0?side/max:0.484375; //obcięcie tekstury od lewej strony punktu 1 + double map1r=max>0.0?slop/max:0.484375; //obcięcie tekstury od prawej strony punktu 1 + rpts1[0]=vector6(bpts1[0].x+slop,bpts1[0].y-fTexHeight1,0.515625+map1r ); //prawy brzeg prawego chodnika + rpts1[1]=vector6(bpts1[0].x+d, bpts1[0].y-fTexHeight1,0.515625 ); //prawy krawężnik u góry + rpts1[2]=vector6(bpts1[0].x, bpts1[0].y, 0.515625-d/2.56); //prawy krawężnik u dołu + rpts2[0]=vector6(bpts1[1].x, bpts1[1].y, 0.484375+d/2.56); //lewy krawężnik u dołu + rpts2[1]=vector6(bpts1[1].x-d, bpts1[1].y-fTexHeight1,0.484375 ); //lewy krawężnik u góry + rpts2[2]=vector6(bpts1[1].x-side,bpts1[1].y-fTexHeight1,0.484375-map1l ); //lewy brzeg lewego chodnika + //if (iTrapezoid) //trapez albo przechyłki + {//pobocza do trapezowatej nawierzchni - dodatkowe punkty z drugiej strony odcinka + slop2=fabs((iTrapezoid&2)?slop2:slop); //szerokość chodnika po prawej + double map2l=max>0.0?side2/max:0.484375; //obcięcie tekstury od lewej strony punktu 2 + double map2r=max>0.0?slop2/max:0.484375; //obcięcie tekstury od prawej strony punktu 2 + rpts1[3]=vector6(bpts1[2].x+slop2,bpts1[2].y-fTexHeight2,0.515625+map2r ); //prawy brzeg prawego chodnika + rpts1[4]=vector6(bpts1[2].x+d, bpts1[2].y-fTexHeight2,0.515625 ); //prawy krawężnik u góry + rpts1[5]=vector6(bpts1[2].x, bpts1[2].y, 0.515625-d/2.56); //prawy krawężnik u dołu + rpts2[3]=vector6(bpts1[3].x, bpts1[3].y, 0.484375+d/2.56); //lewy krawężnik u dołu + rpts2[4]=vector6(bpts1[3].x-d, bpts1[3].y-fTexHeight2,0.484375 ); //lewy krawężnik u góry + rpts2[5]=vector6(bpts1[3].x-side2,bpts1[3].y-fTexHeight2,0.484375-map2l ); //lewy brzeg lewego chodnika + } + } + bool render=TextureID2?(tex?TextureID2==tex:true):false; //renderować nie trzeba, ale trzeba wyznaczyć punkty brzegowe nawierzchni + //if (iTrapezoid) //trapez albo przechyłki + if (SwitchExtension->iRoads==4) + {//pobocza do trapezowatej nawierzchni - dodatkowe punkty z drugiej strony odcinka + if ((fTexHeight1>=0.0)?true:(side!=0.0)) + SwitchExtension->Segments[2]->RenderLoft(rpts2,-3,fTexLength,0,1,&b,render); //tylko jeśli jest z lewej + if ((fTexHeight1>=0.0)?true:(side!=0.0)) + SwitchExtension->Segments[3]->RenderLoft(rpts2,-3,fTexLength,0,1,&b,render); //tylko jeśli jest z lewej + if ((fTexHeight1>=0.0)?true:(side!=0.0)) + SwitchExtension->Segments[4]->RenderLoft(rpts2,-3,fTexLength,0,1,&b,render); //tylko jeśli jest z lewej + if ((fTexHeight1>=0.0)?true:(side!=0.0)) + SwitchExtension->Segments[5]->RenderLoft(rpts2,-3,fTexLength,0,1,&b,render); //tylko jeśli jest z lewej + } + else //to będzie ewentualnie dla prostego na skrzyżowaniu trzech dróg + {//punkt 3 pokrywa się z punktem 1, jak w zwrotnicy; połączenie 1->2 nie musi być prostoliniowe + if ((fTexHeight1>=0.0)?true:(side!=0.0)) //OK + SwitchExtension->Segments[2]->RenderLoft(rpts2,-3,fTexLength,0,1,&b,render); //z P2 do P4 + if ((fTexHeight1>=0.0)?true:(side!=0.0)) //OK + SwitchExtension->Segments[1]->RenderLoft(rpts2,-3,fTexLength,0,1,&b,render); //z P4 do P3=P1 (odwrócony) + if ((fTexHeight1>=0.0)?true:(side!=0.0)) //OK + SwitchExtension->Segments[0]->RenderLoft(rpts2,-3,fTexLength,0,1,&b,render); //z P1 do P2 + /* + if ((fTexHeight1>=0.0)?true:(slop!=0.0)) + Segment->RenderLoft(rpts1,3,fTexLength); + if ((fTexHeight1>=0.0)?true:(side!=0.0)) + Segment->RenderLoft(rpts2,3,fTexLength); + */ + } + } + //renderowanie nawierzchni na końcu + double sina0=sin(a[0]),cosa0=cos(a[0]); + double u,v; + if (!SwitchExtension->bPoints) //jeśli tablica nie wypełniona + if (b) //ale jest wskaźnik do tablicy - może nie być? + {//coś się gubi w obliczeniach na wskaźnikach + i=(int((void*)(b))-int((void*)(SwitchExtension->vPoints)))/sizeof(vector3); //ustalenie liczby punktów, bo mogło wyjść inaczej niż policzone z góry + if (i>0) + {//jeśli zostało to właśnie utworzone + if (SwitchExtension->iPoints>i) //jeśli wyszło mniej niż było miejsca + SwitchExtension->iPoints=i; //domknięcie wachlarza + else + --SwitchExtension->iPoints; //jak tutaj wejdzie, to błąd jest - zrobić miejsce na powtórzenie pierwszego punktu na końcu + SwitchExtension->vPoints[SwitchExtension->iPoints++]=SwitchExtension->vPoints[0]; + SwitchExtension->bPoints=true; //tablica punktów została wypełniona + } + } + if (TextureID1) //jeśli podana tekstura nawierzchni + if (tex?TextureID1==tex:true) //jeśli pasuje do grupy (tex) + {if (!tex) glBindTexture(GL_TEXTURE_2D,TextureID1); + glBegin(GL_TRIANGLE_FAN); //takie kółeczko będzie + glNormal3f(0,1,0); + glTexCoord2f(0.5,0.5); //środek tekstury na środku skrzyżowania + glVertex3f(oxz.x,oxz.y,oxz.z); + for (i=SwitchExtension->iPoints-1;i>=0;--i) + //for (i=0;iiPoints;++i) + {glNormal3f(0,1,0); + u=(SwitchExtension->vPoints[i].x-oxz.x)/fTexLength; //mapowanie we współrzędnych scenerii + v=(SwitchExtension->vPoints[i].z-oxz.z)/(fTexRatio1*fTexLength); + glTexCoord2f(cosa0*u+sina0*v+0.5,-sina0*u+cosa0*v+0.5); + glVertex3f(SwitchExtension->vPoints[i].x,SwitchExtension->vPoints[i].y,SwitchExtension->vPoints[i].z); + } + glEnd(); + } + break; + } + } + break; + case 4: //McZapkie-260302 - rzeka- rendering + //Ra: rzeki na razie bez zmian, przechyłki na pewno nie mają + //Ra: przemyśleć wyrównanie u góry trawą do czworoboku + vector6 bpts1[numPts]={vector6( fHTW,0.0,0.0), vector6( fHTW,0.2,0.33), + vector6(-fHTW,0.0,0.67),vector6(-fHTW,0.0,1.0 ) }; + //Ra: dziwnie ten kształt wygląda + if (TextureID1) + if (tex?TextureID1==tex:true) //jeśli pasuje do grupy (tex) + { + if (!tex) glBindTexture(GL_TEXTURE_2D,TextureID1); + Segment->RenderLoft(bpts1,numPts,fTexLength); + } + if (TextureID2) + if (tex?TextureID2==tex:true) //jeśli pasuje do grupy (tex) + {//brzegi rzeki prawie jak pobocze derogi, tylko inny znak ma wysokość + //znak jest zmieniany przy wczytywaniu, więc tu musi byc minus fTexHeight + vector6 rpts1[3]={ vector6(rozp,-fTexHeight1,0.0), + vector6(fHTW+side,0.0,0.5), + vector6(fHTW,0.0,1.0) }; + vector6 rpts2[3]={ vector6(-fHTW,0.0,1.0), + vector6(-fHTW-side,0.0,0.5), + vector6(-rozp,-fTexHeight1,0.0) }; //Ra: po kiego 0.1? + if (!tex) glBindTexture(GL_TEXTURE_2D,TextureID2); //brzeg rzeki + Segment->RenderLoft(rpts1,3,fTexLength); + Segment->RenderLoft(rpts2,3,fTexLength); + } + break; + } + if (!tex) + if (Global::bManageNodes) + glEndList(); +}; + +void TTrack::Release() +{ + if (DisplayListID) + glDeleteLists(DisplayListID,1); + DisplayListID=0; +}; + +void __fastcall TTrack::Render() +{ + if (bVisible) //Ra: tory są renderowane sektorami i nie ma sensu każdorazowo liczyć odległości + { + if (!DisplayListID) + { + Compile(); + if (Global::bManageNodes) + ResourceManager::Register(this); + }; + SetLastUsage(Timer::GetSimulationTime()); + EnvironmentSet(); //oświetlenie nie może być skompilowane, bo może się zmieniać z czasem + glCallList(DisplayListID); + EnvironmentReset(); //ustawienie oświetlenia na zwykłe + if (InMovement()) Release(); //zwrotnica w trakcie animacji do odrysowania + }; +//#ifdef _DEBUG +#if 0 + if (DebugModeFlag && ScannedFlag) //McZapkie-230702 + //if (iNumDynamics) //będzie kreska na zajętym torze + { + vector3 pos1,pos2,pos3; + glDisable(GL_DEPTH_TEST); + glDisable(GL_LIGHTING); + glColor3ub(255,0,0); + glBindTexture(GL_TEXTURE_2D,0); + glBegin(GL_LINE_STRIP); + pos1=Segment->FastGetPoint_0(); + pos2=Segment->FastGetPoint(0.5); + pos3=Segment->FastGetPoint_1(); + glVertex3f(pos1.x,pos1.y,pos1.z); + glVertex3f(pos2.x,pos2.y+10,pos2.z); + glVertex3f(pos3.x,pos3.y,pos3.z); + glEnd(); + glEnable(GL_LIGHTING); + glEnable(GL_DEPTH_TEST); + ScannedFlag=false; + } +#endif + //glLightfv(GL_LIGHT0,GL_AMBIENT,Global::ambientDayLight); + //glLightfv(GL_LIGHT0,GL_DIFFUSE,Global::diffuseDayLight); + //glLightfv(GL_LIGHT0,GL_SPECULAR,Global::specularDayLight); +}; + +bool __fastcall TTrack::CheckDynamicObject(TDynamicObject *Dynamic) +{//sprawdzenie, czy pojazd jest przypisany do toru + for (int i=0;iasName!="none") + Global::pGround->WyslijString(pMyNode->asName,9); //przekazanie informacji o zwolnieniu toru + return true; + } + } + Error("Cannot remove dynamic from track"); + return false; +} + +bool __fastcall TTrack::InMovement() +{//tory animowane (zwrotnica, obrotnica) mają SwitchExtension + if (SwitchExtension) + {if (eType==tt_Switch) + return SwitchExtension->bMovement; //ze zwrotnicą łatwiej + if (eType==tt_Table) + if (SwitchExtension->pModel) + {if (!SwitchExtension->CurrentIndex) return false; //0=zablokowana się nie animuje + //trzeba każdorazowo porównywać z kątem modelu + TAnimContainer *ac=SwitchExtension->pModel?SwitchExtension->pModel->GetContainer(NULL):NULL; + return ac?(ac->AngleGet()!=SwitchExtension->fOffset)||!(ac->TransGet()==SwitchExtension->vTrans):false; + //return true; //jeśli jest taki obiekt + } + } + return false; +}; +void __fastcall TTrack::RaAssign(TGroundNode *gn,TAnimContainer *ac) +{//Ra: wiązanie toru z modelem obrotnicy + //if (eType==tt_Table) SwitchExtension->pAnim=p; +}; +void __fastcall TTrack::RaAssign(TGroundNode *gn,TAnimModel *am,TEvent *done,TEvent *joined) +{//Ra: wiązanie toru z modelem obrotnicy + if (eType==tt_Table) + {SwitchExtension->pModel=am; + SwitchExtension->pMyNode=gn; + SwitchExtension->evMinus=done; //event zakończenia animacji (zadanie nowej przedłuża) + SwitchExtension->evPlus=joined; //event potwierdzenia połączenia (gdy nie znajdzie, to się nie połączy) + if (am) + if (am->GetContainer(NULL)) //może nie być? + am->GetContainer(NULL)->EventAssign(done); //zdarzenie zakończenia animacji + } +}; + +int __fastcall TTrack::RaArrayPrepare() +{//przygotowanie tablic do skopiowania do VBO (zliczanie wierzchołków) + if (bVisible) //o ile w ogóle widać + switch (iCategoryFlag&15) + { + case 1: //tor + if (eType==tt_Switch) //dla zwrotnicy tylko szyny + return 48*((TextureID1?SwitchExtension->Segments[0]->RaSegCount():0)+(TextureID2?SwitchExtension->Segments[1]->RaSegCount():0)); + else //dla toru podsypka plus szyny + return (Segment->RaSegCount())*((TextureID1?48:0)+(TextureID2?8:0)); + case 2: //droga + if (eType==tt_Cross) //tylko dla skrzyżowania dróg + {//specjalny sposób obliczania liczby wierzchołków w skrzyżowaniu + //int n=0; //wierzchołki wewnętrzne do generowania nawierzchni + //int b=0; //wierzchołki do generowania boków + if (fTexHeight1>=0) //jeśli fTexHeight1<0, to są chodniki i może któregoś nie być + {//normalne pobocze, na razie się składa z + return (Segment->RaSegCount())*((TextureID1?4:0)+(TextureID2?12:0)); + } + else + return (Segment->RaSegCount())*((TextureID1?4:0)+(TextureID2?(fTexWidth!=0.0?6:0)+(fTexSlope!=0.0?6:0):0)); + } + else //standardowo dla zwykłej drogi + if (fTexHeight1>=0) //jeśli fTexHeight1<0, to są chodniki i może któregoś nie być + return (Segment->RaSegCount())*((TextureID1?4:0)+(TextureID2?12:0)); //może nie być poziomego! + else + return (Segment->RaSegCount())*((TextureID1?4:0)+(TextureID2?(fTexWidth!=0.0?6:0)+(fTexSlope!=0.0?6:0):0)); + case 4: //rzeki do przemyślenia + return (Segment->RaSegCount())*((TextureID1?4:0)+(TextureID2?12:0)); + } + return 0; +}; + +void __fastcall TTrack::RaArrayFill(CVertNormTex *Vert,const CVertNormTex *Start) +{//wypełnianie tablic VBO + //Ra: trzeba rozdzielić szyny od podsypki, aby móc grupować wg tekstur + double fHTW=0.5*fabs(fTrackWidth); + double side=fabs(fTexWidth); //szerokść podsypki na zewnątrz szyny albo pobocza + double slop=fabs(fTexSlope); //brzeg zewnętrzny + double rozp=fHTW+side+slop; //brzeg zewnętrzny + double hypot1=hypot(slop,fTexHeight1); //rozmiar pochylenia do liczenia normalnych + if (hypot1==0.0) hypot1=1.0; + vector3 normal1=vector3(fTexSlope/hypot1,fTexHeight1/hypot1,0.0); //wektor normalny + double fHTW2,side2,slop2,rozp2,fTexHeight2,hypot2; + vector3 normal2; + if (iTrapezoid&2) //ten bit oznacza, że istnieje odpowiednie pNext + {//Ra: jest OK + fHTW2=0.5*fabs(trNext->fTrackWidth); //połowa rozstawu/nawierzchni + side2=fabs(trNext->fTexWidth); + slop2=fabs(trNext->fTexSlope); //nie jest używane później + rozp2=fHTW2+side2+slop2; + fTexHeight2=trNext->fTexHeight1; + hypot2=hypot(slop2,fTexHeight2); + if (hypot2==0.0) hypot2=1.0; + normal2=vector3(trNext->fTexSlope/hypot2,fTexHeight2/hypot2,0.0); + } + else //gdy nie ma następnego albo jest nieodpowiednim końcem podpięty + {fHTW2=fHTW; side2=side; slop2=slop; rozp2=rozp; fTexHeight2=fTexHeight1; hypot2=hypot1; normal2=normal1;} + double roll1,roll2; + switch (iCategoryFlag&15) + { + case 1: //tor + { + if (Segment) + Segment->GetRolls(roll1,roll2); + else + roll1=roll2=0.0; //dla zwrotnic + double sin1=sin(roll1),cos1=cos(roll1),sin2=sin(roll2),cos2=cos(roll2); + // zwykla szyna: //Ra: czemu główki są asymetryczne na wysokości 0.140? + vector6 rpts1[24],rpts2[24],rpts3[24],rpts4[24]; + int i; + for (i=0;i<12;++i) + {rpts1[i] =vector6(( fHTW+szyna[i].x)*cos1+szyna[i].y*sin1,-( fHTW+szyna[i].x)*sin1+szyna[i].y*cos1,szyna[i].z ,+szyna[i].n.x*cos1+szyna[i].n.y*sin1,-szyna[i].n.x*sin1+szyna[i].n.y*cos1,0.0); + rpts2[11-i]=vector6((-fHTW-szyna[i].x)*cos1+szyna[i].y*sin1,-(-fHTW-szyna[i].x)*sin1+szyna[i].y*cos1,szyna[i].z ,-szyna[i].n.x*cos1+szyna[i].n.y*sin1,+szyna[i].n.x*sin1+szyna[i].n.y*cos1,0.0); + } + if (iTrapezoid) //trapez albo przechyłki, to oddzielne punkty na końcu + for (i=0;i<12;++i) + {rpts1[12+i]=vector6(( fHTW2+szyna[i].x)*cos2+szyna[i].y*sin2,-( fHTW2+szyna[i].x)*sin2+szyna[i].y*cos2,szyna[i].z ,+szyna[i].n.x*cos2+szyna[i].n.y*sin2,-szyna[i].n.x*sin2+szyna[i].n.y*cos2,0.0); + rpts2[23-i]=vector6((-fHTW2-szyna[i].x)*cos2+szyna[i].y*sin2,-(-fHTW2-szyna[i].x)*sin2+szyna[i].y*cos2,szyna[i].z ,-szyna[i].n.x*cos2+szyna[i].n.y*sin2,+szyna[i].n.x*sin2+szyna[i].n.y*cos2,0.0); + } + switch (eType) //dalej zależnie od typu + { + case tt_Table: //obrotnica jak zwykły tor, tylko animacja dochodzi + SwitchExtension->iLeftVBO=Vert-Start; //indeks toru obrotnicy + case tt_Normal: + if (TextureID2) + {//podsypka z podkładami jest tylko dla zwykłego toru + vector6 bpts1[8]; //punkty głównej płaszczyzny nie przydają się do robienia boków + if (fTexLength==4.0) //jeśli stare mapowanie + {//stare mapowanie z różną gęstością pikseli i oddzielnymi teksturami na każdy profil + if (iTrapezoid) //trapez albo przechyłki + {//podsypka z podkladami trapezowata + //ewentualnie poprawić mapowanie, żeby środek mapował się na 1.435/4.671 ((0.3464,0.6536) + //bo się tekstury podsypki rozjeżdżają po zmianie proporcji profilu + bpts1[0]=vector6(rozp, -fTexHeight1-0.18, 0.00,-0.707,0.707,0.0); //lewy brzeg + bpts1[1]=vector6((fHTW+side)*cos1, -(fHTW+side)*sin1-0.18, 0.33,-0.707,0.707,0.0); //krawędź załamania + bpts1[2]=vector6(-bpts1[1].x, +(fHTW+side)*sin1-0.18, 0.67,0.707,0.707,0.0); //prawy brzeg początku symetrycznie + bpts1[3]=vector6(-rozp, -fTexHeight1-0.18, 1.00,0.707,0.707,0.0); //prawy skos + //końcowy przekrój + bpts1[4]=vector6(rozp2, -fTexHeight2-0.18, 0.00,-0.707,0.707,0.0); //lewy brzeg + bpts1[5]=vector6((fHTW2+side2)*cos2,-(fHTW2+side2)*sin2-0.18,0.33,-0.707,0.707,0.0); //krawędź załamania + bpts1[6]=vector6(-bpts1[5].x, +(fHTW2+side2)*sin2-0.18,0.67,0.707,0.707,0.0); //prawy brzeg początku symetrycznie + bpts1[7]=vector6(-rozp2, -fTexHeight2-0.18, 1.00,0.707,0.707,0.0); //prawy skos + } + else + {bpts1[0]=vector6(rozp, -fTexHeight1-0.18,0.0,-0.707,0.707,0.0); //lewy brzeg + bpts1[1]=vector6(fHTW+side, -0.18,0.33,-0.707,0.707,0.0); //krawędź załamania + bpts1[2]=vector6(-fHTW-side,-0.18,0.67,0.707,0.707,0.0); //druga + bpts1[3]=vector6(-rozp, -fTexHeight1-0.18,1.0,0.707,0.707,0.0); //prawy skos + } + } + else + {//mapowanie proporcjonalne do powierzchni, rozmiar w poprzek określa fTexLength + double max=fTexRatio2*fTexLength; //szerokość proporcjonalna do długości + double map11=max>0.0?(fHTW+side)/max:0.25; //załamanie od strony 1 + double map12=max>0.0?(fHTW+side+hypot1)/max:0.5; //brzeg od strony 1 + if (iTrapezoid) //trapez albo przechyłki + {//podsypka z podkladami trapezowata + double map21=max>0.0?(fHTW2+side2)/max:0.25; //załamanie od strony 2 + double map22=max>0.0?(fHTW2+side2+hypot2)/max:0.5; //brzeg od strony 2 + //ewentualnie poprawić mapowanie, żeby środek mapował się na 1.435/4.671 ((0.3464,0.6536) + //bo się tekstury podsypki rozjeżdżają po zmianie proporcji profilu + bpts1[0]=vector6(rozp, -fTexHeight1-0.18 ,0.5-map12,normal1.x,-normal1.y,0.0); //lewy brzeg + bpts1[1]=vector6((fHTW+side)*cos1, -(fHTW+side)*sin1-0.18 ,0.5-map11,0.0,1.0,0.0); //krawędź załamania + bpts1[2]=vector6(-bpts1[1].x, +(fHTW+side)*sin1-0.18 ,0.5+map11,0.0,1.0,0.0); //prawy brzeg początku symetrycznie + bpts1[3]=vector6(-rozp, -fTexHeight1-0.18 ,0.5+map12,-normal1.x,-normal1.y,0.0); //prawy skos + //przekrój końcowy + bpts1[4]=vector6(rozp2, -fTexHeight2-0.18 ,0.5-map22,normal2.x,-normal2.y,0.0); //lewy brzeg + bpts1[5]=vector6((fHTW2+side2)*cos2,-(fHTW2+side2)*sin2-0.18,0.5-map21,0.0,1.0,0.0); //krawędź załamania + bpts1[6]=vector6(-bpts1[5].x, +(fHTW2+side2)*sin2-0.18,0.5+map21,0.0,1.0,0.0); //prawy brzeg początku symetrycznie + bpts1[7]=vector6(-rozp2, -fTexHeight2-0.18 ,0.5+map22,-normal2.x,-normal2.y,0.0); //prawy skos + } + else + {bpts1[0]=vector6(rozp, -fTexHeight1-0.18,0.5-map12,+normal1.x,-normal1.y,0.0); //lewy brzeg + bpts1[1]=vector6(fHTW+side, -0.18 ,0.5-map11,+normal1.x,-normal1.y,0.0); //krawędź załamania + bpts1[2]=vector6(-fHTW-side,-0.18 ,0.5+map11,-normal1.x,-normal1.y,0.0); //druga + bpts1[3]=vector6(-rozp, -fTexHeight1-0.18,0.5+map12,-normal1.x,-normal1.y,0.0); //prawy skos + } + } + Segment->RaRenderLoft(Vert,bpts1,iTrapezoid?-4:4,fTexLength); + } + if (TextureID1) + {// szyny - generujemy dwie, najwyżej rysować się będzie jedną + Segment->RaRenderLoft(Vert,rpts1,iTrapezoid?-nnumPts:nnumPts,fTexLength); + Segment->RaRenderLoft(Vert,rpts2,iTrapezoid?-nnumPts:nnumPts,fTexLength); + } + break; + case tt_Switch: //dla zwrotnicy dwa razy szyny + if (TextureID1) //Ra: !!!! tu jest do poprawienia + {//iglice liczone tylko dla zwrotnic + vector6 rpts3[24],rpts4[24]; + for (i=0;i<12;++i) + {rpts3[i] =vector6(+(fHTW+iglica[i].x)*cos1+iglica[i].y*sin1,-(+fHTW+iglica[i].x)*sin1+iglica[i].y*cos1,iglica[i].z); + rpts3[i+12]=vector6(+(fHTW2+szyna[i].x)*cos2+ szyna[i].y*sin2,-(+fHTW2+szyna[i].x)*sin2+iglica[i].y*cos2, szyna[i].z); + rpts4[11-i]=vector6((-fHTW-iglica[i].x)*cos1+iglica[i].y*sin1,-(-fHTW-iglica[i].x)*sin1+iglica[i].y*cos1,iglica[i].z); + rpts4[23-i]=vector6((-fHTW2-szyna[i].x)*cos2+ szyna[i].y*sin2,-(-fHTW2-szyna[i].x)*sin2+iglica[i].y*cos2, szyna[i].z); + } + if (SwitchExtension->RightSwitch) + {//nowa wersja z SPKS, ale odwrotnie lewa/prawa + SwitchExtension->iLeftVBO=Vert-Start; //indeks lewej iglicy + SwitchExtension->Segments[0]->RaRenderLoft(Vert,rpts3,-nnumPts,fTexLength,0,2,SwitchExtension->fOffset2); + SwitchExtension->Segments[0]->RaRenderLoft(Vert,rpts1,nnumPts,fTexLength,2); + SwitchExtension->Segments[0]->RaRenderLoft(Vert,rpts2,nnumPts,fTexLength); + SwitchExtension->Segments[1]->RaRenderLoft(Vert,rpts1,nnumPts,fTexLength); + SwitchExtension->iRightVBO=Vert-Start; //indeks prawej iglicy + SwitchExtension->Segments[1]->RaRenderLoft(Vert,rpts4,-nnumPts,fTexLength,0,2,-fMaxOffset+SwitchExtension->fOffset1); + SwitchExtension->Segments[1]->RaRenderLoft(Vert,rpts2,nnumPts,fTexLength,2); + } + else + {//lewa działa lepiej niż prawa + SwitchExtension->Segments[0]->RaRenderLoft(Vert,rpts1,nnumPts,fTexLength); //lewa szyna normalna cała + SwitchExtension->iLeftVBO=Vert-Start; //indeks lewej iglicy + SwitchExtension->Segments[0]->RaRenderLoft(Vert,rpts4,-nnumPts,fTexLength,0,2,-SwitchExtension->fOffset2); //prawa iglica + SwitchExtension->Segments[0]->RaRenderLoft(Vert,rpts2,nnumPts,fTexLength,2); //prawa szyna za iglicą + SwitchExtension->iRightVBO=Vert-Start; //indeks prawej iglicy + SwitchExtension->Segments[1]->RaRenderLoft(Vert,rpts3,-nnumPts,fTexLength,0,2,fMaxOffset-SwitchExtension->fOffset1); //lewa iglica + SwitchExtension->Segments[1]->RaRenderLoft(Vert,rpts1,nnumPts,fTexLength,2); //lewa szyna za iglicą + SwitchExtension->Segments[1]->RaRenderLoft(Vert,rpts2,nnumPts,fTexLength); //prawa szyna normalnie cała + } + } + break; + } + } //koniec obsługi torów + break; + case 2: //McZapkie-260302 - droga - rendering + switch (eType) //dalej zależnie od typu + { + case tt_Normal: //drogi proste, bo skrzyżowania osobno + {vector6 bpts1[4]; //punkty głównej płaszczyzny przydają się do robienia boków + if (TextureID1||TextureID2) //punkty się przydadzą, nawet jeśli nawierzchni nie ma + {//double max=2.0*(fHTW>fHTW2?fHTW:fHTW2); //z szerszej strony jest 100% + double max=(iCategoryFlag&4)?0.0:fTexLength; //test: szerokość dróg proporcjonalna do długości + double map1=max>0.0?fHTW/max:0.5; //obcięcie tekstury od strony 1 + double map2=max>0.0?fHTW2/max:0.5; //obcięcie tekstury od strony 2 + if (iTrapezoid) //trapez albo przechyłki + {//nawierzchnia trapezowata + Segment->GetRolls(roll1,roll2); + bpts1[0]=vector6(fHTW*cos(roll1),-fHTW*sin(roll1),0.5-map1); //lewy brzeg początku + bpts1[1]=vector6(-bpts1[0].x,-bpts1[0].y,0.5+map1); //prawy brzeg początku symetrycznie + bpts1[2]=vector6(fHTW2*cos(roll2),-fHTW2*sin(roll2),0.5-map2); //lewy brzeg końca + bpts1[3]=vector6(-bpts1[2].x,-bpts1[2].y,0.5+map2); //prawy brzeg początku symetrycznie + } + else + {bpts1[0]=vector6( fHTW,0.0,0.5-map1); //zawsze standardowe mapowanie + bpts1[1]=vector6(-fHTW,0.0,0.5+map1); + } + } + if (TextureID1) //jeśli podana była tekstura, generujemy trójkąty + {//tworzenie trójkątów nawierzchni szosy + Segment->RaRenderLoft(Vert,bpts1,iTrapezoid?-2:2,fTexLength); + } + if (TextureID2) + {//pobocze drogi - poziome przy przechyłce (a może krawężnik i chodnik zrobić jak w Midtown Madness 2?) + vector6 rpts1[6],rpts2[6]; //współrzędne przekroju i mapowania dla prawej i lewej strony + if (fTexHeight1>=0.0) + {//standardowo: od zewnątrz pochylenie, a od wewnątrz poziomo + rpts1[0]=vector6(rozp,-fTexHeight1,0.0); //lewy brzeg podstawy + rpts1[1]=vector6(bpts1[0].x+side,bpts1[0].y,0.5), //lewa krawędź załamania + rpts1[2]=vector6(bpts1[0].x,bpts1[0].y,1.0); //lewy brzeg pobocza (mapowanie może być inne + rpts2[0]=vector6(bpts1[1].x,bpts1[1].y,1.0); //prawy brzeg pobocza + rpts2[1]=vector6(bpts1[1].x-side,bpts1[1].y,0.5); //prawa krawędź załamania + rpts2[2]=vector6(-rozp,-fTexHeight1,0.0); //prawy brzeg podstawy + if (iTrapezoid) //trapez albo przechyłki + {//pobocza do trapezowatej nawierzchni - dodatkowe punkty z drugiej strony odcinka + rpts1[3]=vector6(rozp2,-fTexHeight2,0.0); //lewy brzeg lewego pobocza + rpts1[4]=vector6(bpts1[2].x+side2,bpts1[2].y,0.5); //krawędź załamania + rpts1[5]=vector6(bpts1[2].x,bpts1[2].y,1.0); //brzeg pobocza + rpts2[3]=vector6(bpts1[3].x,bpts1[3].y,1.0); + rpts2[4]=vector6(bpts1[3].x-side2,bpts1[3].y,0.5); + rpts2[5]=vector6(-rozp2,-fTexHeight2,0.0); //prawy brzeg prawego pobocza + Segment->RaRenderLoft(Vert,rpts1,-3,fTexLength); + Segment->RaRenderLoft(Vert,rpts2,-3,fTexLength); + } + else + {//pobocza zwykłe, brak przechyłki + Segment->RaRenderLoft(Vert,rpts1,3,fTexLength); + Segment->RaRenderLoft(Vert,rpts2,3,fTexLength); + } + } + else + {//wersja dla chodnika: skos 1:3.75, każdy chodnik innej szerokości + //mapowanie propocjonalne do szerokości chodnika + //krawężnik jest mapowany od 31/64 do 32/64 lewy i od 32/64 do 33/64 prawy + double d=-fTexHeight1/3.75; //krawężnik o wysokości 150mm jest pochylony 40mm + double max=fTexRatio2*fTexLength; //test: szerokość proporcjonalna do długości + double map1l=max>0.0?side/max:0.484375; //obcięcie tekstury od lewej strony punktu 1 + double map1r=max>0.0?slop/max:0.484375; //obcięcie tekstury od prawej strony punktu 1 + double h1r=(slop>d)?-fTexHeight1:0; + double h1l=(side>d)?-fTexHeight1:0; + rpts1[0]=vector6(bpts1[0].x+slop,bpts1[0].y+h1r,0.515625+map1r ); //prawy brzeg prawego chodnika + rpts1[1]=vector6(bpts1[0].x+d, bpts1[0].y+h1r,0.515625 ); //prawy krawężnik u góry + rpts1[2]=vector6(bpts1[0].x, bpts1[0].y, 0.515625-d/2.56); //prawy krawężnik u dołu + rpts2[0]=vector6(bpts1[1].x, bpts1[1].y, 0.484375+d/2.56); //lewy krawężnik u dołu + rpts2[1]=vector6(bpts1[1].x-d, bpts1[1].y+h1l,0.484375 ); //lewy krawężnik u góry + rpts2[2]=vector6(bpts1[1].x-side,bpts1[1].y+h1l,0.484375-map1l ); //lewy brzeg lewego chodnika + if (iTrapezoid) //trapez albo przechyłki + {//pobocza do trapezowatej nawierzchni - dodatkowe punkty z drugiej strony odcinka + slop2=fabs((iTrapezoid&2)?slop2:slop); //szerokość chodnika po prawej + double map2l=max>0.0?side2/max:0.484375; //obcięcie tekstury od lewej strony punktu 2 + double map2r=max>0.0?slop2/max:0.484375; //obcięcie tekstury od prawej strony punktu 2 + double h2r=(slop2>d)?-fTexHeight2:0; + double h2l=(side2>d)?-fTexHeight2:0; + rpts1[3]=vector6(bpts1[2].x+slop2,bpts1[2].y+h2r,0.515625+map2r ); //prawy brzeg prawego chodnika + rpts1[4]=vector6(bpts1[2].x+d, bpts1[2].y+h2r,0.515625 ); //prawy krawężnik u góry + rpts1[5]=vector6(bpts1[2].x, bpts1[2].y, 0.515625-d/2.56); //prawy krawężnik u dołu + rpts2[3]=vector6(bpts1[3].x, bpts1[3].y, 0.484375+d/2.56); //lewy krawężnik u dołu + rpts2[4]=vector6(bpts1[3].x-d, bpts1[3].y+h2l,0.484375 ); //lewy krawężnik u góry + rpts2[5]=vector6(bpts1[3].x-side2,bpts1[3].y+h2l,0.484375-map2l ); //lewy brzeg lewego chodnika + if (slop!=0.0) + Segment->RaRenderLoft(Vert,rpts1,-3,fTexLength); + if (side!=0.0) + Segment->RaRenderLoft(Vert,rpts2,-3,fTexLength); + } + else + {//pobocza zwykłe, brak przechyłki + if (slop!=0.0) + Segment->RaRenderLoft(Vert,rpts1,3,fTexLength); + if (side!=0.0) + Segment->RaRenderLoft(Vert,rpts2,3,fTexLength); + } + } + } + } + } + break; + case 4: //Ra: rzeki na razie jak drogi, przechyłki na pewno nie mają + switch (eType) //dalej zależnie od typu + { + case tt_Normal: //drogi proste, bo skrzyżowania osobno + {vector6 bpts1[4]; //punkty głównej płaszczyzny przydają się do robienia boków + if (TextureID1||TextureID2) //punkty się przydadzą, nawet jeśli nawierzchni nie ma + {//double max=2.0*(fHTW>fHTW2?fHTW:fHTW2); //z szerszej strony jest 100% + double max=(iCategoryFlag&4)?0.0:fTexLength; //test: szerokość dróg proporcjonalna do długości + double map1=max>0.0?fHTW/max:0.5; //obcięcie tekstury od strony 1 + double map2=max>0.0?fHTW2/max:0.5; //obcięcie tekstury od strony 2 + if (iTrapezoid) //trapez albo przechyłki + {//nawierzchnia trapezowata + Segment->GetRolls(roll1,roll2); + bpts1[0]=vector6(fHTW*cos(roll1),-fHTW*sin(roll1),0.5-map1); //lewy brzeg początku + bpts1[1]=vector6(-bpts1[0].x,-bpts1[0].y,0.5+map1); //prawy brzeg początku symetrycznie + bpts1[2]=vector6(fHTW2*cos(roll2),-fHTW2*sin(roll2),0.5-map2); //lewy brzeg końca + bpts1[3]=vector6(-bpts1[2].x,-bpts1[2].y,0.5+map2); //prawy brzeg początku symetrycznie + } + else + {bpts1[0]=vector6( fHTW,0.0,0.5-map1); //zawsze standardowe mapowanie + bpts1[1]=vector6(-fHTW,0.0,0.5+map1); + } + } + if (TextureID1) //jeśli podana była tekstura, generujemy trójkąty + {//tworzenie trójkątów nawierzchni szosy + Segment->RaRenderLoft(Vert,bpts1,iTrapezoid?-2:2,fTexLength); + } + if (TextureID2) + {//pobocze drogi - poziome przy przechyłce (a może krawężnik i chodnik zrobić jak w Midtown Madness 2?) + vector6 rpts1[6],rpts2[6]; //współrzędne przekroju i mapowania dla prawej i lewej strony + rpts1[0]=vector6(rozp,-fTexHeight1,0.0); //lewy brzeg podstawy + rpts1[1]=vector6(bpts1[0].x+side,bpts1[0].y,0.5), //lewa krawędź załamania + rpts1[2]=vector6(bpts1[0].x,bpts1[0].y,1.0); //lewy brzeg pobocza (mapowanie może być inne + rpts2[0]=vector6(bpts1[1].x,bpts1[1].y,1.0); //prawy brzeg pobocza + rpts2[1]=vector6(bpts1[1].x-side,bpts1[1].y,0.5); //prawa krawędź załamania + rpts2[2]=vector6(-rozp,-fTexHeight1,0.0); //prawy brzeg podstawy + if (iTrapezoid) //trapez albo przechyłki + {//pobocza do trapezowatej nawierzchni - dodatkowe punkty z drugiej strony odcinka + rpts1[3]=vector6(rozp2,-fTexHeight2,0.0); //lewy brzeg lewego pobocza + rpts1[4]=vector6(bpts1[2].x+side2,bpts1[2].y,0.5); //krawędź załamania + rpts1[5]=vector6(bpts1[2].x,bpts1[2].y,1.0); //brzeg pobocza + rpts2[3]=vector6(bpts1[3].x,bpts1[3].y,1.0); + rpts2[4]=vector6(bpts1[3].x-side2,bpts1[3].y,0.5); + rpts2[5]=vector6(-rozp2,-fTexHeight2,0.0); //prawy brzeg prawego pobocza + Segment->RaRenderLoft(Vert,rpts1,-3,fTexLength); + Segment->RaRenderLoft(Vert,rpts2,-3,fTexLength); + } + else + {//pobocza zwykłe, brak przechyłki + Segment->RaRenderLoft(Vert,rpts1,3,fTexLength); + Segment->RaRenderLoft(Vert,rpts2,3,fTexLength); + } + } + } + } + break; + } +}; + +void __fastcall TTrack::RaRenderVBO(int iPtr) +{//renderowanie z użyciem VBO + //Ra 2014-07: trzeba wymienić GL_TRIANGLE_STRIP na GL_TRIANGLES i renderować trójkąty sektora dla kolejnych tekstur! + EnvironmentSet(); + int seg; + int i; + switch (iCategoryFlag&15) + { + case 1: //tor + if (eType==tt_Switch) //dla zwrotnicy tylko szyny + {if (TextureID1) + if ((seg=SwitchExtension->Segments[0]->RaSegCount())>0) + {glBindTexture(GL_TEXTURE_2D,TextureID1); //szyny + + for (i=0;iSegments[1]->RaSegCount())>0) + {glBindTexture(GL_TEXTURE_2D,TextureID2); //szyny - + for (i=0;iRaSegCount())>0) + {if (TextureID2) + {glBindTexture(GL_TEXTURE_2D,TextureID2); //podsypka + for (i=0;iRaSegCount())>0) + {if (TextureID1) + {glBindTexture(GL_TEXTURE_2D,TextureID1); //nawierzchnia + for (i=0;i=0.0) + {//normalna droga z poboczem + for (i=0;iRaSegCount())>0) + {if (TextureID1) + {glBindTexture(GL_TEXTURE_2D,TextureID1); //nawierzchnia + for (i=0;iRender(); //sam sprawdza, czy VBO; zmienia kontekst VBO! + //EnvironmentReset(); +}; + +void __fastcall TTrack::RenderDynAlpha() +{//renderowanie przezroczystych fragmentów pojazdów + if (!iNumDynamics) return; //po co kombinować, jeśli nie ma pojazdów? + //EnvironmentSet(); //Ra: pojazdy sobie same teraz liczą cienie + for (int i=0;iRenderAlpha(); //sam sprawdza, czy VBO; zmienia kontekst VBO! + //EnvironmentReset(); +}; + +void __fastcall TTrack::RenderDynSounds() +{//odtwarzanie dźwięków pojazdów jest niezależne od ich wyświetlania + for (int i=0;iRenderSounds(); +}; +//--------------------------------------------------------------------------- +bool __fastcall TTrack::SetConnections(int i) +{//przepisanie aktualnych połączeń toru do odpowiedniego segmentu + if (SwitchExtension) + { + SwitchExtension->pNexts[i]=trNext; + SwitchExtension->pPrevs[i]=trPrev; + SwitchExtension->iNextDirection[i]=iNextDirection; + SwitchExtension->iPrevDirection[i]=iPrevDirection; + if (eType==tt_Switch) + {//zwrotnica jest wyłącznie w punkcie 1, więc tor od strony Prev jest zawsze ten sam + SwitchExtension->pPrevs[i^1]=trPrev; + SwitchExtension->iPrevDirection[i^1]=iPrevDirection; + } + else + if (eType==tt_Cross) + if (SwitchExtension->iRoads==3) + { + } + if (i) Switch(0); //po przypisaniu w punkcie 4 włączyć stan zasadniczy + return true; + } + Error("Cannot set connections"); + return false; +} + +bool __fastcall TTrack::Switch(int i,double t,double d) +{//przełączenie torów z uruchomieniem animacji + if (SwitchExtension) //tory przełączalne mają doklejkę + if (eType==tt_Switch) + {//przekładanie zwrotnicy jak zwykle + if (t>0.0) //prędkość liniowa ruchu iglic + SwitchExtension->fOffsetSpeed=t; //prędkość łatwiej zgrać z animacją modelu + if (d>=0.0) //dodatkowy ruch drugiej iglicy (zamknięcie nastawnicze) + SwitchExtension->fOffsetDelay=d; + i&=1; //ograniczenie błędów !!!! + SwitchExtension->fDesiredOffset=i?fMaxOffset+SwitchExtension->fOffsetDelay:-SwitchExtension->fOffsetDelay; + SwitchExtension->CurrentIndex=i; + Segment=SwitchExtension->Segments[i]; //wybranie aktywnej drogi - potrzebne to? + trNext=SwitchExtension->pNexts[i]; //przełączenie końców + trPrev=SwitchExtension->pPrevs[i]; + iNextDirection=SwitchExtension->iNextDirection[i]; + iPrevDirection=SwitchExtension->iPrevDirection[i]; + fRadius=fRadiusTable[i]; //McZapkie: wybor promienia toru + if (SwitchExtension->fVelocity<=-2) //-1 oznacza maksymalną prędkość, a dalsze ujemne to ograniczenie na bok + fVelocity=i?-SwitchExtension->fVelocity:-1; + if (SwitchExtension->pOwner?SwitchExtension->pOwner->RaTrackAnimAdd(this):true) //jeśli nie dodane do animacji + {//nie ma się co bawić + SwitchExtension->fOffset=SwitchExtension->fDesiredOffset; + RaAnimate(); //przeliczenie położenia iglic; czy zadziała na niewyświetlanym sektorze w VBO? + } + return true; + } + else if (eType==tt_Table) + {//blokowanie (0, szukanie torów) lub odblokowanie (1, rozłączenie) obrotnicy + if (i) + {//0: rozłączenie sąsiednich torów od obrotnicy + if (trPrev) //jeśli jest tor od Point1 obrotnicy + if (iPrevDirection) //0:dołączony Point1, 1:dołączony Point2 + trPrev->trNext=NULL; //rozłączamy od Point2 + else + trPrev->trPrev=NULL; //rozłączamy od Point1 + if (trNext) //jeśli jest tor od Point2 obrotnicy + if (iNextDirection) //0:dołączony Point1, 1:dołączony Point2 + trNext->trNext=NULL; //rozłączamy od Point2 + else + trNext->trPrev=NULL; //rozłączamy od Point1 + trNext=trPrev=NULL; //na końcu rozłączamy obrotnicę (wkaźniki do sąsiadów już niepotrzebne) + fVelocity=0.0; //AI, nie ruszaj się! + if (SwitchExtension->pOwner) + SwitchExtension->pOwner->RaTrackAnimAdd(this); //dodanie do listy animacyjnej + } + else + {//1: ustalenie finalnego położenia (gdy nie było animacji) + RaAnimate(); //ostatni etap animowania + //zablokowanie pozycji i połączenie do sąsiednich torów + Global::pGround->TrackJoin(SwitchExtension->pMyNode); + if (trNext||trPrev) + {fVelocity=6.0; //jazda dozwolona + if (trPrev) + if (trPrev->fVelocity==0.0) //ustawienie 0 da możliwość zatrzymania AI na obrotnicy + trPrev->VelocitySet(6.0); //odblokowanie dołączonego toru do jazdy + if (trNext) + if (trNext->fVelocity==0.0) + trNext->VelocitySet(6.0); + if (SwitchExtension->evPlus) //w starych sceneriach może nie być + Global::AddToQuery(SwitchExtension->evPlus,NULL); //potwierdzenie wykonania (np. odpala WZ) + } + } + SwitchExtension->CurrentIndex=i; //zapamiętanie stanu zablokowania + return true; + } + else if (eType==tt_Cross) + {//to jest przydatne tylko do łączenia odcinków + i&=1; + SwitchExtension->CurrentIndex=i; + Segment=SwitchExtension->Segments[i]; //wybranie aktywnej drogi - potrzebne to? + trNext=SwitchExtension->pNexts[i]; //przełączenie końców + trPrev=SwitchExtension->pPrevs[i]; + iNextDirection=SwitchExtension->iNextDirection[i]; + iPrevDirection=SwitchExtension->iPrevDirection[i]; + return true; + } + if (iCategoryFlag==1) + iDamageFlag=(iDamageFlag&127)+128*(i&1); //przełączanie wykolejenia + else + Error("Cannot switch normal track"); + return false; +}; + +bool __fastcall TTrack::SwitchForced(int i,TDynamicObject *o) +{//rozprucie rozjazdu + if (SwitchExtension) + if (eType==tt_Switch) + {// + if (i!=SwitchExtension->CurrentIndex) + {switch (i) + {case 0: + if (SwitchExtension->evPlus) + Global::AddToQuery(SwitchExtension->evPlus,o); //dodanie do kolejki + break; + case 1: + if (SwitchExtension->evMinus) + Global::AddToQuery(SwitchExtension->evMinus,o); //dodanie do kolejki + break; + } + Switch(i); //jeśli się tu nie przełączy, to każdy pojazd powtórzy event rozrprucia + } + } + else if (eType==tt_Cross) + {//ustawienie wskaźnika na wskazany segment + Segment=SwitchExtension->Segments[i]; + } + return true; +}; + +int __fastcall TTrack::CrossSegment(int from,int into) +{//ustawienie wskaźnika na segement w pożądanym kierunku (into) od strony (from) + //zwraca kod segmentu, z kierunkiem jazdy jako znakiem ± + int i=0; + switch (into) + {case 0: //stop + //WriteLog("Crossing from P"+AnsiString(from+1)+" into stop on "+pMyNode->asName); + break; + case 1: //left + //WriteLog("Crossing from P"+AnsiString(from+1)+" to left on "+pMyNode->asName); + i=(SwitchExtension->iRoads==4)?iLewo4[from]:iLewo3[from]; + break; + case 2: //right + //WriteLog("Crossing from P"+AnsiString(from+1)+" to right on "+pMyNode->asName); + i=(SwitchExtension->iRoads==4)?iPrawo4[from]:iPrawo3[from]; + break; + case 3: //stright + //WriteLog("Crossing from P"+AnsiString(from+1)+" to straight on "+pMyNode->asName); + i=(SwitchExtension->iRoads==4)?iProsto4[from]:iProsto3[from]; + break; + } + if (i) + {Segment=SwitchExtension->Segments[abs(i)-1]; + //WriteLog("Selected segment: "+AnsiString(abs(i)-1)); + } + return i; +}; + +void __fastcall TTrack::RaAnimListAdd(TTrack *t) +{//dodanie toru do listy animacyjnej + if (SwitchExtension) + {if (t==this) return; //siebie nie dodajemy drugi raz do listy + if (!t->SwitchExtension) return; //nie podlega animacji + if (SwitchExtension->pNextAnim) + {if (SwitchExtension->pNextAnim==t) + return; //gdy już taki jest + else + SwitchExtension->pNextAnim->RaAnimListAdd(t); + } + else + {SwitchExtension->pNextAnim=t; + t->SwitchExtension->pNextAnim=NULL; //nowo dodawany nie może mieć ogona + } + } +}; + +TTrack* __fastcall TTrack::RaAnimate() +{//wykonanie rekurencyjne animacji, wywoływane przed wyświetleniem sektora + //zwraca wskaźnik toru wymagającego dalszej animacji + if (SwitchExtension->pNextAnim) + SwitchExtension->pNextAnim=SwitchExtension->pNextAnim->RaAnimate(); + bool m=true; //animacja trwa + if (eType==tt_Switch) //dla zwrotnicy tylko szyny + {double v=SwitchExtension->fDesiredOffset-SwitchExtension->fOffset; //kierunek + SwitchExtension->fOffset+=sign(v)*Timer::GetDeltaTime()*SwitchExtension->fOffsetSpeed; + //Ra: trzeba dać to do klasy... + SwitchExtension->fOffset1=SwitchExtension->fOffset; + SwitchExtension->fOffset2=SwitchExtension->fOffset; + if (SwitchExtension->fOffset1>=fMaxOffset) + SwitchExtension->fOffset1=fMaxOffset; //ograniczenie animacji zewnętrznej iglicy + if (SwitchExtension->fOffset2<=0.00) + SwitchExtension->fOffset2=0.0; //ograniczenie animacji wewnętrznej iglicy + if (v<0) + {//jak na pierwszy z torów + if (SwitchExtension->fOffset<=SwitchExtension->fDesiredOffset) + {SwitchExtension->fOffset=SwitchExtension->fDesiredOffset; + m=false; //koniec animacji + } + } + else + {//jak na drugi z torów + if (SwitchExtension->fOffset>=SwitchExtension->fDesiredOffset) + {SwitchExtension->fOffset=SwitchExtension->fDesiredOffset; + m=false; //koniec animacji + } + } + if (Global::bUseVBO) + {//dla OpenGL 1.4 odświeży się cały sektor, w późniejszych poprawiamy fragment + if (Global::bOpenGL_1_5) //dla OpenGL 1.4 to się nie wykona poprawnie + if (TextureID1) //Ra: !!!! tu jest do poprawienia + {//iglice liczone tylko dla zwrotnic + vector6 rpts3[24],rpts4[24]; + double fHTW=0.5*fabs(fTrackWidth); + double fHTW2=fHTW; //Ra: na razie niech tak będzie + double cos1=1.0,sin1=0.0,cos2=1.0,sin2=0.0; //Ra: ... + for (int i=0;i<12;++i) + {rpts3[i] =vector6((fHTW+iglica[i].x)*cos1+iglica[i].y*sin1,-(fHTW+iglica[i].x)*sin1+iglica[i].y*cos1,iglica[i].z); + rpts3[i+12]=vector6((fHTW2+szyna[i].x)*cos2+szyna[i].y*sin2,-(fHTW2+szyna[i].x)*sin2+iglica[i].y*cos2,szyna[i].z); + rpts4[11-i]=vector6((-fHTW-iglica[i].x)*cos1+iglica[i].y*sin1,-(-fHTW-iglica[i].x)*sin1+iglica[i].y*cos1,iglica[i].z); + rpts4[23-i]=vector6((-fHTW2-szyna[i].x)*cos2+szyna[i].y*sin2,-(-fHTW2-szyna[i].x)*sin2+iglica[i].y*cos2,szyna[i].z); + } + CVertNormTex Vert[2*2*12]; //na razie 2 segmenty + CVertNormTex *v=Vert; //bo RaAnimate() modyfikuje wskaźnik + glGetBufferSubData(GL_ARRAY_BUFFER,SwitchExtension->iLeftVBO*sizeof(CVertNormTex),2*2*12*sizeof(CVertNormTex),&Vert);//pobranie fragmentu bufora VBO + if (SwitchExtension->RightSwitch) + {//nowa wersja z SPKS, ale odwrotnie lewa/prawa + SwitchExtension->Segments[0]->RaAnimate(v,rpts3,-nnumPts,fTexLength,0,2,SwitchExtension->fOffset2); + glBufferSubData(GL_ARRAY_BUFFER,SwitchExtension->iLeftVBO*sizeof(CVertNormTex),2*2*12*sizeof(CVertNormTex),&Vert); //wysłanie fragmentu bufora VBO + v=Vert; + glGetBufferSubData(GL_ARRAY_BUFFER,SwitchExtension->iRightVBO*sizeof(CVertNormTex),2*2*12*sizeof(CVertNormTex),&Vert);//pobranie fragmentu bufora VBO + SwitchExtension->Segments[1]->RaAnimate(v,rpts4,-nnumPts,fTexLength,0,2,-fMaxOffset+SwitchExtension->fOffset1); + } + else + {//oryginalnie lewa działała lepiej niż prawa + SwitchExtension->Segments[0]->RaAnimate(v,rpts4,-nnumPts,fTexLength,0,2,-SwitchExtension->fOffset2); //prawa iglica + glBufferSubData(GL_ARRAY_BUFFER,SwitchExtension->iLeftVBO*sizeof(CVertNormTex),2*2*12*sizeof(CVertNormTex),&Vert);//wysłanie fragmentu bufora VBO + v=Vert; + glGetBufferSubData(GL_ARRAY_BUFFER,SwitchExtension->iRightVBO*sizeof(CVertNormTex),2*2*12*sizeof(CVertNormTex),&Vert); //pobranie fragmentu bufora VBO + SwitchExtension->Segments[1]->RaAnimate(v,rpts3,-nnumPts,fTexLength,0,2,fMaxOffset-SwitchExtension->fOffset1); //lewa iglica + } + glBufferSubData(GL_ARRAY_BUFFER,SwitchExtension->iRightVBO*sizeof(CVertNormTex),2*2*12*sizeof(CVertNormTex),&Vert); //wysłanie fragmentu bufora VBO + } + } + else //gdy Display List + Release(); //niszczenie skompilowanej listy, aby się wygenerowała nowa + } + else if (eType==tt_Table) //dla obrotnicy - szyny i podsypka + { + if (SwitchExtension->pModel&&SwitchExtension->CurrentIndex) //0=zablokowana się nie animuje + {//trzeba każdorazowo porównywać z kątem modelu + //SwitchExtension->fOffset1=SwitchExtension->pAnim?SwitchExtension->pAnim->AngleGet():0.0; //pobranie kąta z modelu + TAnimContainer *ac=SwitchExtension->pModel?SwitchExtension->pModel->GetContainer(NULL):NULL; //pobranie głównego submodelu + //if (ac) ac->EventAssign(SwitchExtension->evMinus); //event zakończenia animacji, trochę bez sensu tutaj + if (ac) + if ((ac->AngleGet()!=SwitchExtension->fOffset)||!(ac->TransGet()==SwitchExtension->vTrans)) //czy przemieściło się od ostatniego sprawdzania + {double hlen=0.5*SwitchExtension->Segments[0]->GetLength(); //połowa długości + SwitchExtension->fOffset=ac->AngleGet(); //pobranie kąta z submodelu + double sina=-hlen*sin(DegToRad(SwitchExtension->fOffset)),cosa=-hlen*cos(DegToRad(SwitchExtension->fOffset)); + SwitchExtension->vTrans=ac->TransGet(); + vector3 middle=SwitchExtension->pMyNode->pCenter+SwitchExtension->vTrans; //SwitchExtension->Segments[0]->FastGetPoint(0.5); + Segment->Init(middle+vector3(sina,0.0,cosa),middle-vector3(sina,0.0,cosa),5.0); //nowy odcinek + for (int i=0;iMove(0.000001); //minimalny ruch, aby przeliczyć pozycję i kąty + if (Global::bUseVBO) + {//dla OpenGL 1.4 odświeży się cały sektor, w późniejszych poprawiamy fragment + //aktualizacja pojazdów na torze + if (Global::bOpenGL_1_5) //dla OpenGL 1.4 to się nie wykona poprawnie + {int size=RaArrayPrepare(); //wielkość tabeli potrzebna dla tej obrotnicy + CVertNormTex *Vert=new CVertNormTex[size]; //bufor roboczy + //CVertNormTex *v=Vert; //zmieniane przez + RaArrayFill(Vert,Vert-SwitchExtension->iLeftVBO); //iLeftVBO powinno zostać niezmienione + glBufferSubData(GL_ARRAY_BUFFER,SwitchExtension->iLeftVBO*sizeof(CVertNormTex),size*sizeof(CVertNormTex),Vert); //wysłanie fragmentu bufora VBO + } + } + else //gdy Display List + Release(); //niszczenie skompilowanej listy, aby się wygenerowała nowa + } //animacja trwa nadal + } else m=false; //koniec animacji albo w ogóle nie połączone z modelem + } + return m?this:SwitchExtension->pNextAnim; //zwraca obiekt do dalszej animacji +}; +//--------------------------------------------------------------------------- +void __fastcall TTrack::RadioStop() +{//przekazanie pojazdom rozkazu zatrzymania + for (int i=0;iRadioStop(); +}; + +double __fastcall TTrack::WidthTotal() +{//szerokość z poboczem + if (iCategoryFlag&2) //jesli droga + if (fTexHeight1>=0.0) //i ma boki zagięte w dół (chodnik jest w górę) + return 2.0*fabs(fTexWidth)+0.5*fabs(fTrackWidth+fTrackWidth2); //dodajemy pobocze + return 0.5*fabs(fTrackWidth+fTrackWidth2); //a tak tylko zwykła średnia szerokość +}; + +bool __fastcall TTrack::IsGroupable() +{//czy wyświetlanie toru może być zgrupwane z innymi + if ((eType==tt_Switch)||(eType==tt_Table)) return false; //tory ruchome nie są grupowane + if ((eEnvironment==e_canyon)||(eEnvironment==e_tunnel)) return false; //tory ze zmianą światła + return true; +}; + +bool __fastcall Equal(vector3 v1, vector3 *v2) +{//sprawdzenie odległości punktów + //Ra: powinno być do 100cm wzdłuż toru i ze 2cm w poprzek (na prostej może nie być długiego kawałka) + //Ra: z automatycznie dodawanym stukiem, jeśli dziura jest większa niż 2mm. + if (fabs(v1.x-v2->x)>0.02) return false; //sześcian zamiast kuli + if (fabs(v1.z-v2->z)>0.02) return false; + if (fabs(v1.y-v2->y)>0.02) return false; + return true; + //return (SquareMagnitude(v1-*v2)<0.00012); //0.011^2=0.00012 +}; + +int __fastcall TTrack::TestPoint(vector3 *Point) +{//sprawdzanie, czy tory można połączyć + switch (eType) + { + case tt_Normal: //zwykły odcinek + if (trPrev==NULL) + if (Equal(Segment->FastGetPoint_0(),Point)) + return 0; + if (trNext==NULL) + if (Equal(Segment->FastGetPoint_1(),Point)) + return 1; + break; + case tt_Switch: //zwrotnica + {int state=GetSwitchState(); //po co? + //Ra: TODO: jak się zmieni na bezpośrednie odwołania do segmentow zwrotnicy, + //to się wykoleja, ponieważ trNext zależy od przełożenia + Switch(0); + if (trPrev==NULL) + //if (Equal(SwitchExtension->Segments[0]->FastGetPoint_0(),Point)) + if (Equal(Segment->FastGetPoint_0(),Point)) + { + Switch(state); + return 2; + } + if (trNext==NULL) + //if (Equal(SwitchExtension->Segments[0]->FastGetPoint_1(),Point)) + if (Equal(Segment->FastGetPoint_1(),Point)) + { + Switch(state); + return 3; + } + Switch(1); //można by się pozbyć tego przełączania + if (trPrev==NULL) //Ra: z tym chyba nie potrzeba łączyć + //if (Equal(SwitchExtension->Segments[1]->FastGetPoint_0(),Point)) + if (Equal(Segment->FastGetPoint_0(),Point)) + { + Switch(state);//Switch(0); + return 4; + } + if (trNext==NULL) //TODO: to zależy od przełożenia zwrotnicy + //if (Equal(SwitchExtension->Segments[1]->FastGetPoint_1(),Point)) + if (Equal(Segment->FastGetPoint_1(),Point)) + { + Switch(state);//Switch(0); + return 5; + } + Switch(state); + } + break; + case tt_Cross: //skrzyżowanie dróg + //if (trPrev==NULL) + if (Equal(SwitchExtension->Segments[0]->FastGetPoint_0(),Point)) + return 2; + //if (trNext==NULL) + if (Equal(SwitchExtension->Segments[0]->FastGetPoint_1(),Point)) + return 3; + //if (trPrev==NULL) + if (Equal(SwitchExtension->Segments[1]->FastGetPoint_0(),Point)) + return 4; + //if (trNext==NULL) + if (Equal(SwitchExtension->Segments[1]->FastGetPoint_1(),Point)) + return 5; + break; + } + return -1; +}; + +void __fastcall TTrack::MovedUp1(double dh) +{//poprawienie przechyłki wymaga wydłużenia podsypki + fTexHeight1+=dh; +}; + +AnsiString __fastcall TTrack::NameGet() +{//ustalenie nazwy toru + if (this) + if (pMyNode) + return pMyNode->asName; + return "none"; +}; + +void __fastcall TTrack::VelocitySet(float v) +{//ustawienie prędkości z ograniczeniem do pierwotnej wartości (zapisanej w scenerii) + if (SwitchExtension?SwitchExtension->fVelocity>=0.0:false) + {//zwrotnica może mieć odgórne ograniczenie, nieprzeskakiwalne eventem + if (v>SwitchExtension->fVelocity?true:v<0.0) + return void(fVelocity=SwitchExtension->fVelocity); //maksymalnie tyle, ile było we wpisie + } + fVelocity=v; //nie ma ograniczenia +}; + +float __fastcall TTrack::VelocityGet() +{//pobranie dozwolonej prędkości podczas skanowania + return ((iDamageFlag&128)?0.0f:fVelocity); //tor uszkodzony = prędkość zerowa +}; + +void __fastcall TTrack::ConnectionsLog() +{//wypisanie informacji o połączeniach + int i; + WriteLog("--> tt_Cross named "+pMyNode->asName); + if (eType==tt_Cross) + for (i=0;i<2;++i) + { + if (SwitchExtension->pPrevs[i]) + WriteLog("Point "+AnsiString(i+i+1)+" -> track "+SwitchExtension->pPrevs[i]->pMyNode->asName+":"+AnsiString(int(SwitchExtension->iPrevDirection[i]))); + if (SwitchExtension->pNexts[i]) + WriteLog("Point "+AnsiString(i+i+2)+" -> track "+SwitchExtension->pNexts[i]->pMyNode->asName+":"+AnsiString(int(SwitchExtension->iNextDirection[i]))); + } +}; + +TTrack* __fastcall TTrack::Neightbour(int s,double &d) +{//zwraca wskaźnik na sąsiedni tor, w kierunku określonym znakiem (s), odwraca (d) w razie niezgodności kierunku torów + TTrack *t; //nie zmieniamy kierunku (d), jeśli nie ma toru dalej + if (eType!=tt_Cross) + {//jeszcze trzeba sprawdzić zgodność + t=(s>0)?trNext:trPrev; + if (t) //o ile jest na co przejść, zmieniamy znak kierunku na nowym torze + if (t->eType==tt_Cross) + {//jeśli wjazd na skrzyżowanie, trzeba ustalić segment, bo od tego zależy zmiana kierunku (d) + //if (r) //gdy nie podano (r), to nie zmieniać (d) + // if (s*t->CrossSegment(((s>0)?iNextDirection:iPrevDirection),r)<0) + // d=-d; + } + else + {if ((s>0)?iNextDirection:!iPrevDirection) + d=-d; //następuje zmiana kierunku wózka albo kierunku skanowania + //s=((s>0)?iNextDirection:iPrevDirection)?-1:1; //kierunek toru po zmianie + } + return (t); //zwrotnica ma odpowiednio ustawione (trNext) + } + switch ((SwitchExtension->iRoads==4)?iEnds4[s+6]:iEnds3[s+6]) //numer końca 0..3, -1 to błąd + {//zjazd ze skrzyżowania + case 0: if (SwitchExtension->pPrevs[0]) if ((s>0)==SwitchExtension->iPrevDirection[0]) d=-d; return SwitchExtension->pPrevs[0]; + case 1: if (SwitchExtension->pNexts[0]) if ((s>0)==SwitchExtension->iNextDirection[0]) d=-d; return SwitchExtension->pNexts[0]; + case 2: if (SwitchExtension->pPrevs[1]) if ((s>0)==SwitchExtension->iPrevDirection[1]) d=-d; return SwitchExtension->pPrevs[1]; + case 3: if (SwitchExtension->pNexts[1]) if ((s>0)==SwitchExtension->iNextDirection[1]) d=-d; return SwitchExtension->pNexts[1]; + } + return NULL; +}; + diff --git a/Track.h b/Track.h new file mode 100644 index 00000000..a9ce3222 --- /dev/null +++ b/Track.h @@ -0,0 +1,224 @@ +//--------------------------------------------------------------------------- + +#ifndef TrackH +#define TrackH + +#include "Segment.h" +#include "ResourceManager.h" +#include "opengl/glew.h" +#include +#include "Classes.h" + + +class TEvent; + +typedef enum { tt_Unknown, tt_Normal, tt_Switch, tt_Table, tt_Cross, tt_Tributary } TTrackType; +//McZapkie-100502 +typedef enum {e_unknown=-1, e_flat=0, e_mountains, e_canyon, e_tunnel, e_bridge, e_bank} TEnvironmentType; +//Ra: opracować alternatywny system cieni/świateł z definiowaniem koloru oświetlenia w halach + +class TTrack; +class TGroundNode; +class TSubRect; +class TTraction; + +class TSwitchExtension +{//dodatkowe dane do toru, który jest zwrotnicą +public: + __fastcall TSwitchExtension(TTrack *owner,int what); + __fastcall ~TSwitchExtension(); + TSegment *Segments[6]; //dwa tory od punktu 1, pozostałe dwa od 2? Ra 140101: 6 połączeń dla skrzyżowań + //TTrack *trNear[4]; //tory dołączone do punktów 1, 2, 3 i 4 + //dotychczasowe [2]+[2] wskaźniki zamienić na nowe [4] + TTrack *pNexts[2]; //tory dołączone do punktów 2 i 4 + TTrack *pPrevs[2]; //tory dołączone do punktów 1 i 3 + int iNextDirection[2]; //to też z [2]+[2] przerobić na [4] + int iPrevDirection[2]; + int CurrentIndex; //dla zwrotnicy + double fOffset,fDesiredOffset; //aktualne i docelowe położenie napędu iglic + double fOffsetSpeed; //prędkość liniowa ruchu iglic + double fOffsetDelay; //opóźnienie ruchu drugiej iglicy względem pierwszej + union + { + struct + {//zmienne potrzebne tylko dla zwrotnicy + double fOffset1,fOffset2; //przesunięcia iglic - 0=na wprost + bool RightSwitch; //czy zwrotnica w prawo + }; + struct + {//zmienne potrzebne tylko dla obrotnicy/przesuwnicy + TGroundNode *pMyNode; //dla obrotnicy do wtórnego podłączania torów + //TAnimContainer *pAnim; //animator modelu dla obrotnicy + TAnimModel *pModel; //na razie model + }; + struct + {//zmienne dla skrzyżowania + vector3 *vPoints; //tablica wierzchołków nawierzchni, generowana przez pobocze + int iPoints; //liczba faktycznie użytych wierzchołków nawierzchni + bool bPoints; //czy utworzone? + int iRoads; //ile dróg się spotyka? + }; + }; + bool bMovement; //czy w trakcie animacji + int iLeftVBO,iRightVBO; //indeksy iglic w VBO + TSubRect *pOwner; //sektor, któremu trzeba zgłosić animację + TTrack *pNextAnim; //następny tor do animowania + TEvent *evPlus,*evMinus; //zdarzenia sygnalizacji rozprucia + float fVelocity; //maksymalne ograniczenie prędkości (ustawianej eventem) + vector3 vTrans; //docelowa translacja przesuwnicy +private: +}; + +const int iMaxNumDynamics=40; //McZapkie-100303 + +class TIsolated +{//obiekt zbierający zajętości z kilku odcinków + int iAxles; //ilość osi na odcinkach obsługiwanych przez obiekt + TIsolated *pNext; //odcinki izolowane są trzymane w postaci listy jednikierunkowej + static TIsolated *pRoot; //początek listy +public: + AnsiString asName; //nazwa obiektu, baza do nazw eventów + TEvent *evBusy; //zdarzenie wyzwalane po zajęciu grupy + TEvent *evFree; //zdarzenie wyzwalane po całkowitym zwolnieniu zajętości grupy + TMemCell *pMemCell; //automatyczna komórka pamięci, która współpracuje z odcinkiem izolowanym + __fastcall TIsolated(); + __fastcall TIsolated(const AnsiString &n,TIsolated *i); + __fastcall ~TIsolated(); + static TIsolated* __fastcall Find(const AnsiString &n); //znalezienie obiektu albo utworzenie nowego + void __fastcall Modify(int i,TDynamicObject *o); //dodanie lub odjęcie osi + bool __fastcall Busy() { return (iAxles>0); }; + static TIsolated* __fastcall Root() { return (pRoot); }; + TIsolated* __fastcall Next() { return (pNext); }; +}; + +class TTrack : public Resource +{//trajektoria ruchu - opakowanie +private: + TSwitchExtension *SwitchExtension; //dodatkowe dane do toru, który jest zwrotnicą + TSegment *Segment; + TTrack *trNext; //odcinek od strony punktu 2 - to powinno być w segmencie + TTrack *trPrev; //odcinek od strony punktu 1 + //McZapkie-070402: dodalem zmienne opisujace rozmiary tekstur + GLuint TextureID1; //tekstura szyn albo nawierzchni + GLuint TextureID2; //tekstura automatycznej podsypki albo pobocza + float fTexLength; //długość powtarzania tekstury w metrach + float fTexRatio1; //proporcja rozmiarów tekstury dla nawierzchni drogi + float fTexRatio2; //proporcja rozmiarów tekstury dla chodnika + float fTexHeight1; //wysokość brzegu względem trajektorii + float fTexWidth; //szerokość boku + float fTexSlope; + double fRadiusTable[2]; //dwa promienie, drugi dla zwrotnicy + int iTrapezoid; //0-standard, 1-przechyłka, 2-trapez, 3-oba + GLuint DisplayListID; + TIsolated *pIsolated; //obwód izolowany obsługujący zajęcia/zwolnienia grupy torów + TGroundNode *pMyNode; //Ra: proteza, żeby tor znał swoją nazwę TODO: odziedziczyć TTrack z TGroundNode +public: + int iNumDynamics; + TDynamicObject *Dynamics[iMaxNumDynamics]; + int iEvents; //Ra: flaga informująca o obecności eventów + TEvent *evEventall0; //McZapkie-140302: wyzwalany gdy pojazd stoi + TEvent *evEventall1; + TEvent *evEventall2; + TEvent *evEvent0; //McZapkie-280503: wyzwalany tylko gdy headdriver + TEvent *evEvent1; + TEvent *evEvent2; + AnsiString asEventall0Name; //nazwy eventów + AnsiString asEventall1Name; + AnsiString asEventall2Name; + AnsiString asEvent0Name; + AnsiString asEvent1Name; + AnsiString asEvent2Name; + int iNextDirection; //0:Point1, 1:Point2, 3:do odchylonego na zwrotnicy + int iPrevDirection; + TTrackType eType; + int iCategoryFlag; //0x100 - usuwanie pojazów + float fTrackWidth; //szerokość w punkcie 1 + float fTrackWidth2; //szerokość w punkcie 2 (głównie drogi i rzeki) + float fFriction; //współczynnik tarcia + float fSoundDistance; + int iQualityFlag; + int iDamageFlag; + TEnvironmentType eEnvironment; //dźwięk i oświetlenie + bool bVisible; //czy rysowany + int iAction; //czy modyfikowany eventami (specjalna obsługa przy skanowaniu) + float fOverhead; //informacja o stanie sieci: 0-jazda bezprądowa, >0-z opuszczonym i ograniczeniem prędkości +private: + double fVelocity; //prędkość dla AI (powyżej rośnie prawdopowobieństwo wykolejenia) +public: + //McZapkie-100502: + double fTrackLength; //długość z wpisu, nigdzie nie używana + double fRadius; //promień, dla zwrotnicy kopiowany z tabeli + bool ScannedFlag; //McZapkie: do zaznaczania kolorem torów skanowanych przez AI + TTraction *hvOverhead; //drut zasilający do szybkiego znalezienia (nie używany) + TGroundNode *nFouling[2]; //współrzędne ukresu albo oporu kozła + TTrack *trColides; //tor kolizyjny, na którym trzeba sprawdzać pojazdy pod kątem zderzenia + + __fastcall TTrack(TGroundNode *g); + __fastcall ~TTrack(); + void __fastcall Init(); + static TTrack* __fastcall Create400m(int what,double dx); + TTrack* __fastcall NullCreate(int dir); + inline bool __fastcall IsEmpty() { return (iNumDynamics<=0); }; + void __fastcall ConnectPrevPrev(TTrack *pNewPrev,int typ); + void __fastcall ConnectPrevNext(TTrack *pNewPrev,int typ); + void __fastcall ConnectNextPrev(TTrack *pNewNext,int typ); + void __fastcall ConnectNextNext(TTrack *pNewNext,int typ); + inline double __fastcall Length() { return Segment->GetLength(); }; + inline TSegment* __fastcall CurrentSegment() { return Segment; }; + inline TTrack* __fastcall CurrentNext() {return (trNext);}; + inline TTrack* __fastcall CurrentPrev() {return (trPrev);}; + TTrack* __fastcall Neightbour(int s,double &d); + bool __fastcall SetConnections(int i); + bool __fastcall Switch(int i,double t=-1.0,double d=-1.0); + bool __fastcall SwitchForced(int i,TDynamicObject *o); + int __fastcall CrossSegment(int from,int into); + inline int __fastcall GetSwitchState() { return (SwitchExtension?SwitchExtension->CurrentIndex:-1); }; + void __fastcall Load(cParser *parser, vector3 pOrigin,AnsiString name); + bool __fastcall AssignEvents(TEvent *NewEvent0, TEvent *NewEvent1, TEvent *NewEvent2); + bool __fastcall AssignallEvents(TEvent *NewEvent0, TEvent *NewEvent1, TEvent *NewEvent2); + bool __fastcall AssignForcedEvents(TEvent *NewEventPlus, TEvent *NewEventMinus); + bool __fastcall CheckDynamicObject(TDynamicObject *Dynamic); + bool __fastcall AddDynamicObject(TDynamicObject *Dynamic); + bool __fastcall RemoveDynamicObject(TDynamicObject *Dynamic); + void __fastcall MoveMe(vector3 pPosition); + + void Release(); + void __fastcall Compile(GLuint tex=0); + + void __fastcall Render(); //renderowanie z Display Lists + int __fastcall RaArrayPrepare(); //zliczanie rozmiaru dla VBO sektroa + void __fastcall RaArrayFill(CVertNormTex *Vert,const CVertNormTex *Start); //wypełnianie VBO + void __fastcall RaRenderVBO(int iPtr); //renderowanie z VBO sektora + void __fastcall RenderDyn(); //renderowanie nieprzezroczystych pojazdów (oba tryby) + void __fastcall RenderDynAlpha(); //renderowanie przezroczystych pojazdów (oba tryby) + void __fastcall RenderDynSounds(); //odtwarzanie dźwięków pojazdów jest niezależne od ich wyświetlania + + void __fastcall RaOwnerSet(TSubRect *o) + {if (SwitchExtension) SwitchExtension->pOwner=o;}; + bool __fastcall InMovement(); //czy w trakcie animacji? + void __fastcall RaAssign(TGroundNode *gn,TAnimContainer *ac); + void __fastcall RaAssign(TGroundNode *gn,TAnimModel *am,TEvent *done,TEvent *joined); + void __fastcall RaAnimListAdd(TTrack *t); + TTrack* __fastcall RaAnimate(); + + void __fastcall RadioStop(); + void __fastcall AxleCounter(int i,TDynamicObject *o) + {if (pIsolated) pIsolated->Modify(i,o);}; //dodanie lub odjęcie osi + AnsiString __fastcall IsolatedName(); + bool __fastcall IsolatedEventsAssign(TEvent *busy,TEvent *free); + double __fastcall WidthTotal(); + GLuint TextureGet(int i) {return i?TextureID1:TextureID2;}; + bool __fastcall IsGroupable(); + int __fastcall TestPoint(vector3 *Point); + void __fastcall MovedUp1(double dh); + AnsiString __fastcall NameGet(); + void __fastcall VelocitySet(float v); + float __fastcall VelocityGet(); + void __fastcall ConnectionsLog(); +private: + void __fastcall EnvironmentSet(); + void __fastcall EnvironmentReset(); +}; + +//--------------------------------------------------------------------------- +#endif diff --git a/Traction.cpp b/Traction.cpp new file mode 100644 index 00000000..e389275c --- /dev/null +++ b/Traction.cpp @@ -0,0 +1,624 @@ +//--------------------------------------------------------------------------- +/* + MaSzyna EU07 locomotive simulator + Copyright (C) 2001-2004 Marcin Wozniak, Maciej Czapkiewicz and others + +*/ + +#include "system.hpp" +#include "classes.hpp" +#pragma hdrstop + +#include "Traction.h" +#include "mctools.hpp" +#include "Globals.h" +#include "Usefull.h" +#include "TractionPower.h" + +//--------------------------------------------------------------------------- + +#pragma package(smart_init) +/* + +=== Koncepcja dwustronnego zasilania sekcji sieci trakcyjnej, Ra 2014-02 === +0. Każde przęsło sieci może mieć wpisaną nazwę zasilacza, a także napięcie +nominalne i maksymalny prąd, które stanowią redundancję do danych zasilacza. +Rezystancja może się zmieniać, materiał i grubość drutu powinny być wspólny +dla segmentu. Podanie punktów umożliwia łączenie przęseł w listy dwukierunkowe, +co usprawnia wyszukiwania kolejnych przeseł podczas jazdy. Dla bieżni wspólnej +powinna być podana nazwa innego przęsła w parametrze "parallel". Wskaźniki +na przęsła bieżni wspólnej mają być układane w jednokierunkowy pierścień. +1. Problemem jest ustalenie topologii sekcji dla linii dwutorowych. Nad każdym +torem powinna znajdować się oddzielna sekcja sieci, aby mogła zostać odłączona +w przypadku zwarcia. Sekcje nad równoległymi torami są również łączone +równolegle przez kabiny sekcyjne, co zmniejsza płynące prądy i spadki napięć. +2. Drugim zagadnieniem jest zasilanie sekcji jednocześnie z dwóch stron, czyli +sekcja musi mieć swoją nazwę oraz wskazanie dwóch zasilaczy ze wskazaniem +geograficznym ich położenia. Dodatkową trudnością jest brak połączenia +pomiędzy segmentami naprężania. Podsumowując, każdy segment naprężania powinien +mieć przypisanie do sekcji zasilania, a dodatkowo skrajne segmenty powinny +wskazywać dwa różne zasilacze. +3. Zasilaczem sieci może być podstacja, która w wersji 3kV powinna generować +pod obciążeniem napięcie maksymalne rzędu 3600V, a spadek napięcia następuje +na jej rezystancji wewnętrznej oraz na przewodach trakcyjnych. Zasilaczem może +być również kabina sekcyjna, która jest zasilana z podstacji poprzez przewody +trakcyjne. +4. Dla uproszczenia można przyjąć, że zasilanie pojazdu odbywać się będzie z +dwóch sąsiednich podstacji, pomiędzy którymi może być dowolna liczba kabin +sekcyjnych. W przypadku wyłączenia jednej z tych podstacji, zasilanie może +być pobierane z kolejnej. Łącznie należy rozważać 4 najbliższe podstacje, +przy czym do obliczeń można przyjmować 2 z nich. +5. Przęsła sieci są łączone w listę dwukierunkową, więc wystarczy nazwę +sekcji wpisać w jednym z nich, wpisanie w każdym nie przeszkadza. +Alternatywnym sposobem łączenia segmentów naprężania może być wpisywanie +nazw przęseł jako "parallel", co może być uciążliwe dla autorów scenerii. +W skrajnych przęsłach należałoby dodatkowo wpisać nazwę zasilacza, będzie +to jednocześnie wskazanie przęsła, do którego podłączone są przewody +zasilające. Konieczne jest odróżnienie nazwy sekcji od nazwy zasilacza, co +można uzyskać różnicując ich nazwy albo np. specyficznie ustawiając wartość +prądu albo napięcia przęsła. +6. Jeśli dany segment naprężania jest wspólny dla dwóch sekcji zasilania, +to jedno z przęseł musi mieć nazwę "*" (gwiazdka), co będzie oznaczało, że +ma zamontowany izolator. Dla uzyskania efektów typu łuk elektryczny, należało +by wskazać położenie izolatora i jego długość (ew. typ). +7. Również w parametrach zasilacza należało by określić, czy jest podstacją, +czy jedynie kabiną sekcyjną. Różnić się one będą fizyką działania. +8. Dla zbudowanej topologii sekcji i zasilaczy należało by zbudować dynamiczny +schemat zastępczy. Dynamika polega na wyłączaniu sekcji ze zwarciem oraz +przeciążonych podstacji. Musi być też możliwość wyłączenia sekcji albo +podstacji za pomocą eventu. +9. Dla każdej sekcji musi być tworzony obiekt, wskazujący na podstacje +zasilające na końcach, stan włączenia, zwarcia, przepięcia. Do tego obiektu +musi wskazywać każde przęsło z aktywnym zasilaniem. + + z.1 z.2 z.3 + -=-a---1*1---c-=---c---=-c--2*2--e---=---e-3-*-3--g-=- + -=-b---1*1---d-=---d---=-d--2*2--f---=---e-3-*-3--h-=- + + nazwy sekcji (@): a,b,c,d,e,f,g,h + nazwy zasilaczy (#): 1,2,3 + przęsło z izolatorem: * + przęsła bez wskazania nazwy sekcji/zasilacza: - + segment napręzania: =-x-= + segment naprężania z izolatorem: =---@---#*#---@---= + segment naprężania bez izolatora: =--------@------= + +Obecnie brak nazwy sekcji nie jest akceptowany i każde przęsło musi mieć wpisaną +jawnie nazwę sekcji, ewentualnie nazwę zasilacza (zostanie zastąpiona wskazaniem +sekcji z sąsiedniego przęsła). +*/ + + +TTraction::TTraction() +{ + pPoint1=pPoint2=pPoint3=pPoint4=vector3(0,0,0); + //vFront=vector3(0,0,1); + //vUp=vector3(0,1,0); + //vLeft=vector3(1,0,0); + fHeightDifference=0; + iNumSections=0; + iLines=0; +// dwFlags= 0; + Wires=2; +// fU=fR= 0; + uiDisplayList=0; + asPowerSupplyName=""; +// mdPole= NULL; +// ReplacableSkinID= 0; + hvNext[0]=hvNext[1]=NULL; + iLast=1; //że niby ostatni drut + psPowered=psPower[0]=psPower[1]=NULL; //na początku zasilanie nie podłączone + psSection=NULL; //na początku nie podłączone + hvParallel=NULL; //normalnie brak bieżni wspólnej + fResistance[0]=fResistance[1]=-1.0; //trzeba dopiero policzyć + iTries=0; //ile razy próbować podłączyć, ustawiane później +} + +TTraction::~TTraction() +{ + if (!Global::bUseVBO) + glDeleteLists(uiDisplayList,1); +} + +void __fastcall TTraction::Optimize() +{ + if (Global::bUseVBO) return; + uiDisplayList=glGenLists(1); + glNewList(uiDisplayList,GL_COMPILE); + + glBindTexture(GL_TEXTURE_2D, 0); +// glColor3ub(0,0,0); McZapkie: to do render + +// glPushMatrix(); +// glTranslatef(pPosition.x,pPosition.y,pPosition.z); + + if (Wires!=0) + { + //Dlugosc odcinka trakcji 'Winger + double ddp=hypot(pPoint2.x-pPoint1.x,pPoint2.z-pPoint1.z); + + if (Wires==2) WireOffset=0; + //Przewoz jezdny 1 'Marcin + glBegin(GL_LINE_STRIP); + glVertex3f(pPoint1.x-(pPoint2.z/ddp-pPoint1.z/ddp)*WireOffset,pPoint1.y,pPoint1.z-(-pPoint2.x/ddp+pPoint1.x/ddp)*WireOffset); + glVertex3f(pPoint2.x-(pPoint2.z/ddp-pPoint1.z/ddp)*WireOffset,pPoint2.y,pPoint2.z-(-pPoint2.x/ddp+pPoint1.x/ddp)*WireOffset); + glEnd(); + //Nie wiem co 'Marcin + vector3 pt1,pt2,pt3,pt4,v1,v2; + v1= pPoint4-pPoint3; + v2= pPoint2-pPoint1; + float step= 0; + if (iNumSections>0) + step= 1.0f/(float)iNumSections; + float f= step; + float mid= 0.5; + float t; + + //Przewod nosny 'Marcin + if (Wires != 1) + { + glBegin(GL_LINE_STRIP); + glVertex3f(pPoint3.x,pPoint3.y,pPoint3.z); + for (int i=0; i 2) + { + glBegin(GL_LINE_STRIP); + glVertex3f(pPoint1.x+(pPoint2.z/ddp-pPoint1.z/ddp)*WireOffset,pPoint1.y,pPoint1.z+(-pPoint2.x/ddp+pPoint1.x/ddp)*WireOffset); + glVertex3f(pPoint2.x+(pPoint2.z/ddp-pPoint1.z/ddp)*WireOffset,pPoint2.y,pPoint2.z+(-pPoint2.x/ddp+pPoint1.x/ddp)*WireOffset); + glEnd(); + } + + f= step; + + if (Wires == 4) + { + glBegin(GL_LINE_STRIP); + glVertex3f(pPoint3.x,pPoint3.y-0.65f*fHeightDifference,pPoint3.z); + for (int i=0; i1.2) linealpha=1.2; //zbyt grube nie są dobre + glLineWidth(linealpha); + if (linealpha>1.0) linealpha = 1.0; + //McZapkie-261102: kolor zalezy od materialu i zasniedzenia + float r,g,b; + switch (Material) + {//Ra: kolory podzieliłem przez 2, bo po zmianie ambient za jasne były + //trzeba uwzględnić kierunek świecenia Słońca - tylko ze Słońcem widać kolor + case 1: + if (TestFlag(DamageFlag,1)) + { + r=0.00000; g=0.32549; b=0.2882353; //zielona miedź + } + else + { + r=0.35098; g=0.22549; b=0.1; //czerwona miedź + } + break; + case 2: + if (TestFlag(DamageFlag,1)) + { + r=0.10; g=0.10; b=0.10; //czarne Al + } + else + { + r=0.25; g=0.25; b=0.25; //srebrne Al + } + break; + //tymczasowo pokazanie zasilanych odcinków + case 4: r=0.5; g=0.5; b=1.0; break; //niebieskie z podłączonym zasilaniem + case 5: r=1.0; g=0.0; b=0.0; break; //czerwone z podłączonym zasilaniem 1 + case 6: r=0.0; g=1.0; b=0.0; break; //zielone z podłączonym zasilaniem 2 + case 7: r=1.0; g=1.0; b=0.0; break; //żółte z podłączonym zasilaniem z obu stron + } + if (DebugModeFlag) + if (hvParallel) + {//jeśli z bieżnią wspólną, to dodatkowo przyciemniamy + r*=0.6; g*=0.6; b*=0.6; + } + r*=Global::ambientDayLight[0]; //w zaleźności od koloru swiatła + g*=Global::ambientDayLight[1]; + b*=Global::ambientDayLight[2]; + if (linealpha>1.0) linealpha=1.0; //trzeba ograniczyć do <=1 + glColor4f(r,g,b,linealpha); + if (!uiDisplayList) + Optimize(); //generowanie DL w miarę potrzeby + glCallList(uiDisplayList); + glLineWidth(1.0); + glEnable(GL_LINE_SMOOTH); + //glEnable(GL_LIGHTING); //bez tego się modele nie oświetlają + } +} + +int __fastcall TTraction::RaArrayPrepare() +{//przygotowanie tablic do skopiowania do VBO (zliczanie wierzchołków) + //if (bVisible) //o ile w ogóle widać + switch (Wires) + { + case 1: iLines=2; break; + case 2: iLines=iNumSections?4*(iNumSections)-2+2:4; break; + case 3: iLines=iNumSections?4*(iNumSections)-2+4:6; break; + case 4: iLines=iNumSections?4*(iNumSections)-2+6:8; break; + default: iLines=0; + } + //else iLines=0; + return iLines; +}; + +void __fastcall TTraction::RaArrayFill(CVertNormTex *Vert) +{//wypełnianie tablic VBO + CVertNormTex *old=Vert; + double ddp=hypot(pPoint2.x-pPoint1.x,pPoint2.z-pPoint1.z); + if (Wires==2) WireOffset=0; + //jezdny + Vert->x=pPoint1.x-(pPoint2.z/ddp-pPoint1.z/ddp)*WireOffset; + Vert->y=pPoint1.y; + Vert->z=pPoint1.z-(-pPoint2.x/ddp+pPoint1.x/ddp)*WireOffset; + ++Vert; + Vert->x=pPoint2.x-(pPoint2.z/ddp-pPoint1.z/ddp)*WireOffset; + Vert->y=pPoint2.y; + Vert->z=pPoint2.z-(-pPoint2.x/ddp+pPoint1.x/ddp)*WireOffset; + ++Vert; + //Nie wiem co 'Marcin + vector3 pt1,pt2,pt3,pt4,v1,v2; + v1=pPoint4-pPoint3; + v2=pPoint2-pPoint1; + float step=0; + if (iNumSections>0) + step=1.0f/(float)iNumSections; + float f=step; + float mid=0.5; + float t; + //Przewod nosny 'Marcin + if (Wires>1) + {//lina nośna w kawałkach + Vert->x=pPoint3.x; + Vert->y=pPoint3.y; + Vert->z=pPoint3.z; + ++Vert; + for (int i=0;ix=pt3.x; + Vert->y=pt3.y-sqrt(t)*fHeightDifference; + Vert->z=pt3.z; + ++Vert; + Vert->x=pt3.x; //drugi raz, bo nie jest line_strip + Vert->y=pt3.y-sqrt(t)*fHeightDifference; + Vert->z=pt3.z; + ++Vert; + f+=step; + } + Vert->x=pPoint4.x; + Vert->y=pPoint4.y; + Vert->z=pPoint4.z; + ++Vert; + } + //Drugi przewod jezdny 'Winger + if (Wires==3) + { + Vert->x=pPoint1.x+(pPoint2.z/ddp-pPoint1.z/ddp)*WireOffset; + Vert->y=pPoint1.y; + Vert->z=pPoint1.z+(-pPoint2.x/ddp+pPoint1.x/ddp)*WireOffset; + ++Vert; + Vert->x=pPoint2.x+(pPoint2.z/ddp-pPoint1.z/ddp)*WireOffset; + Vert->y=pPoint2.y; + Vert->z=pPoint2.z+(-pPoint2.x/ddp+pPoint1.x/ddp)*WireOffset; + ++Vert; + } + f=step; + //Przewody pionowe (wieszaki) 'Marcin, poprawki na 2 przewody jezdne 'Winger + if (Wires>1) + { + for (int i=0;ix=pt3.x; + Vert->y=pt3.y-sqrt(t)*fHeightDifference; + Vert->z=pt3.z; + ++Vert; + if ((i%2)==0) + { + Vert->x=pt4.x-(pPoint2.z/ddp-pPoint1.z/ddp)*WireOffset; + Vert->y=pt4.y; + Vert->z=pt4.z-(-pPoint2.x/ddp+pPoint1.x/ddp)*WireOffset; + } + else + { + Vert->x=pt4.x+(pPoint2.z/ddp-pPoint1.z/ddp)*WireOffset; + Vert->y=pt4.y; + Vert->z=pt4.z+(-pPoint2.x/ddp+pPoint1.x/ddp)*WireOffset; + } + ++Vert; + f+=step; + } + } + if ((Vert-old)!=iLines) + WriteLog("!!! Wygenerowano punktów "+AnsiString(Vert-old)+", powinno być "+AnsiString(iLines)); +}; + +void __fastcall TTraction::RenderVBO(float mgn,int iPtr) +{//renderowanie z użyciem VBO + if (Wires!=0 && !TestFlag(DamageFlag,128)) //rysuj jesli sa druty i nie zerwana + { + glBindTexture(GL_TEXTURE_2D,0); + glDisable(GL_LIGHTING); //aby nie używało wektorów normalnych do kolorowania + glColor4f(0,0,0,1); //jak nieznany kolor to czarne nieprzezroczyste + if (!Global::bSmoothTraction) + glDisable(GL_LINE_SMOOTH); //na liniach kiepsko wygląda - robi gradient + float linealpha=5000*WireThickness/(mgn+1.0); //*WireThickness + if (linealpha>1.2) linealpha=1.2; //zbyt grube nie są dobre + glLineWidth(linealpha); + //McZapkie-261102: kolor zalezy od materialu i zasniedzenia + float r,g,b; + switch (Material) + {//Ra: kolory podzieliłem przez 2, bo po zmianie ambient za jasne były + //trzeba uwzględnić kierunek świecenia Słońca - tylko ze Słońcem widać kolor + case 1: + if (TestFlag(DamageFlag,1)) + { + r=0.00000; g=0.32549; b=0.2882353; //zielona miedź + } + else + { + r=0.35098; g=0.22549; b=0.1; //czerwona miedź + } + break; + case 2: + if (TestFlag(DamageFlag,1)) + { + r=0.10; g=0.10; b=0.10; //czarne Al + } + else + { + r=0.25; g=0.25; b=0.25; //srebrne Al + } + break; + //tymczasowo pokazanie zasilanych odcinków + case 4: r=0.5; g=0.5; b=1.0; break; //niebieskie z podłączonym zasilaniem + case 5: r=1.0; g=0.0; b=0.0; break; //czerwone z podłączonym zasilaniem 1 + case 6: r=0.0; g=1.0; b=0.0; break; //zielone z podłączonym zasilaniem 2 + case 7: r=1.0; g=1.0; b=0.0; break; //żółte z podłączonym zasilaniem z obu stron + } + r=r*Global::ambientDayLight[0]; //w zaleznosci od koloru swiatla + g=g*Global::ambientDayLight[1]; + b=b*Global::ambientDayLight[2]; + if (linealpha>1.0) linealpha=1.0; //trzeba ograniczyć do <=1 + glColor4f(r,g,b,linealpha); + glDrawArrays(GL_LINES,iPtr,iLines); + glLineWidth(1.0); + glEnable(GL_LINE_SMOOTH); + glEnable(GL_LIGHTING); //bez tego się modele nie oświetlają + } +}; + +int __fastcall TTraction::TestPoint(vector3 *Point) +{//sprawdzanie, czy przęsła można połączyć + if (!hvNext[0]) + if (pPoint1.Equal(Point)) + return 0; + if (!hvNext[1]) + if (pPoint2.Equal(Point)) + return 1; + return -1; +}; + +void __fastcall TTraction::Connect(int my,TTraction *with,int to) +{//łączenie segmentu (with) od strony (my) do jego (to) + if (my) + {//do mojego Point2 + hvNext[1]=with; + iNext[1]=to; + } + else + {//do mojego Point1 + hvNext[0]=with; + iNext[0]=to; + } + if (to) + {//do jego Point2 + with->hvNext[1]=this; + with->iNext[1]=my; + } + else + {//do jego Point1 + with->hvNext[0]=this; + with->iNext[0]=my; + } + if (hvNext[0]) //jeśli z obu stron podłączony + if (hvNext[1]) + iLast=0; //to nie jest ostatnim + if (with->hvNext[0]) //temu też, bo drugi raz łączenie się nie nie wykona + if (with->hvNext[1]) + with->iLast=0; //to nie jest ostatnim +}; + +bool __fastcall TTraction::WhereIs() +{//ustalenie przedostatnich przęseł + if (iLast) return (iLast==1); //ma już ustaloną informację o położeniu + if (hvNext[0]?hvNext[0]->iLast==1:false) //jeśli poprzedni jest ostatnim + iLast=2; //jest przedostatnim + else + if (hvNext[1]?hvNext[1]->iLast==1:false) //jeśli następny jest ostatnim + iLast=2; //jest przedostatnim + return (iLast==1); //ostatnie będą dostawać zasilanie +}; + +void __fastcall TTraction::Init() +{//przeliczenie parametrów + vParametric=pPoint2-pPoint1; //wektor mnożników parametru dla równania parametrycznego +}; + +void __fastcall TTraction::ResistanceCalc(int d,double r,TTractionPowerSource *ps) +{//(this) jest przęsłem zasilanym, o rezystancji (r), policzyć rezystancję zastępczą sąsiednich + if (d>=0) + {//podążanie we wskazanym kierunku + TTraction *t=hvNext[d],*p; + if (ps) + psPower[d^1]=ps; //podłączenie podanego + else + ps=psPower[d^1]; //zasilacz od przeciwnej strony niż idzie analiza + d=iNext[d]; //kierunek + //double r; //sumaryczna rezystancja + if (DebugModeFlag) //tylko podczas testów + Material=4; //pokazanie, że to przęsło ma podłączone zasilanie + while (t?!t->psPower[d]:false) //jeśli jest jakiś kolejny i nie ma ustalonego zasilacza + {//ustawienie zasilacza i policzenie rezystancji zastępczej + if (DebugModeFlag) //tylko podczas testów + if (t->Material!=4) //przęsła zasilającego nie modyfikować + {if (t->Material<4) t->Material=4; //tymczasowo, aby zmieniła kolor + t->Material|=d?2:1; //kolor zależny od strony, z której jest zasilanie + } + t->psPower[d]=ps; //skopiowanie wskaźnika zasilacza od danej strony + t->fResistance[d]=r; //wpisanie rezystancji w kierunku tego zasilacza + r+=t->fResistivity*Length3(t->vParametric); //doliczenie oporu kolejnego odcinka + p=t; //zapamiętanie dotychczasowego + t=p->hvNext[d^1]; //podążanie w tę samą stronę + d=p->iNext[d^1]; + //w przypadku zapętlenia sieci może się zawiesić? + } + } + else + {//podążanie w obu kierunkach, można by rekurencją, ale szkoda zasobów + r=0.5*fResistivity*Length3(vParametric); //powiedzmy, że w zasilanym przęśle jest połowa + if (fResistance[0]==0.0) ResistanceCalc(0,r); //do tyłu (w stronę Point1) + if (fResistance[1]==0.0) ResistanceCalc(1,r); //do przodu (w stronę Point2) + } +}; + +void __fastcall TTraction::PowerSet(TTractionPowerSource *ps) +{//podłączenie przęsła do zasilacza + if (ps->bSection) + psSection=ps; //ustalenie sekcji zasilania + else + {//ustalenie punktu zasilania (nie ma jeszcze połączeń między przęsłami) + psPowered=ps; //ustawienie bezpośredniego zasilania dla przęsła + psPower[0]=psPower[1]=ps; //a to chyba nie jest dobry pomysł, bo nawet zasilane przęsło powinno mieć wskazania na inne + fResistance[0]=fResistance[1]=0.0; //a liczy się tylko rezystancja zasilacza + } +}; + +double __fastcall TTraction::VoltageGet(double u,double i) +{//pobranie napięcia na przęśle po podłączeniu do niego rezystancji (res) - na razie jest to prąd + if (!psSection) + if (!psPowered) + return NominalVoltage; //jak nie ma zasilacza, to napięcie podane w przęśle + //na początek można założyć, że wszystkie podstacje mają to samo napięcie i nie płynie prąd pomiędzy nimi + //dla danego przęsła mamy 3 źródła zasilania + //1. zasilacz psPower[0] z rezystancją fResistance[0] oraz jego wewnętrzną + //2. zasilacz psPower[1] z rezystancją fResistance[1] oraz jego wewnętrzną + //3. zasilacz psPowered z jego wewnętrzną rezystancją dla przęseł zasilanych bezpośrednio + double res=(i!=0.0)?fabs(u/i):10000.0; + if (psPowered) return psPowered->CurrentGet(res)*res; //yB: dla zasilanego nie baw się w gwiazdy, tylko bierz bezpośrednio + double r0t,r1t,r0g,r1g; + double u0,u1,i0,i1; + r0t=fResistance[0]; //średni pomysł, ale lepsze niż nic + r1t=fResistance[1]; //bo nie uwzględnia spadków z innych pojazdów + if (psPower[0]&&psPower[1]) + {//gdy przęsło jest zasilane z obu stron - mamy trójkąt: res, r0t, r1t + //yB: Gdy wywali podstacja, to zaczyna się robić nieciekawie - napięcie w sekcji na jednym końcu jest równe zasilaniu, + //yB: a na drugim końcu jest równe 0. Kolejna sprawa to rozróżnienie uszynienia sieci na podstacji/odłączniku (czyli + //yB: potencjał masy na sieci) od braku zasilania (czyli odłączenie źródła od sieci i brak jego wpływu na napięcie). + if ((r0t>0.0)&&(r1t>0.0)) + {//rezystancje w mianowniku nie mogą być zerowe + r0g=res+r0t+(res*r0t)/r1t; //przeliczenie z trójkąta na gwiazdę + r1g=res+r1t+(res*r1t)/r0t; + //pobierane są prądy dla każdej rezystancji, a suma jest mnożona przez rezystancję pojazdu w celu uzyskania napięcia + i0=psPower[0]->CurrentGet(r0g); //oddzielnie dla sprawdzenia + i1=psPower[1]->CurrentGet(r1g); + return (i0+i1)*res; + } + else if (r0t>=0.0) + return psPower[0]->CurrentGet(res+r0t)*res; + else if (r1t>=0.0) + return psPower[1]->CurrentGet(res+r1t)*res; + else + return 0.0; //co z tym zrobić? + } + else if (psPower[0]&&(r0t>=0.0)) + {//jeśli odcinek podłączony jest tylko z jednej strony + return psPower[0]->CurrentGet(res+r0t)*res; + } + else if (psPower[1]&&(r1t>=0.0)) + return psPower[1]->CurrentGet(res+r1t)*res; + return 0.0; //gdy nie podłączony wcale? +}; diff --git a/Traction.h b/Traction.h new file mode 100644 index 00000000..83f89c9f --- /dev/null +++ b/Traction.h @@ -0,0 +1,77 @@ +//--------------------------------------------------------------------------- + +#ifndef TractionH +#define TractionH + +#include "opengl/glew.h" +#include "dumb3d.h" +#include "VBO.h" + +using namespace Math3D; + +class TTractionPowerSource; + +class TTraction +{//drut zasilający, dla wskaźników używać przedrostka "hv" +private: + //vector3 vUp,vFront,vLeft; + //matrix4x4 mMatrix; + //matryca do wyliczania pozycji drutu w zależności od [X,Y,kąt] w scenerii: + // - x: odległość w bok (czy odbierak się nie zsunął) + // - y: przyjmuje wartość <0,1>, jeśli pod drutem (wzdłuż) + // - z: wysokość bezwzględna drutu w danym miejsu +public: //na razie + TTractionPowerSource *psPower[2]; //najbliższe zasilacze z obu kierunków + TTractionPowerSource *psPowered; //ustawione tylko dla bezpośrednio zasilanego przęsła + TTraction *hvNext[2]; //łączenie drutów w sieć + int iNext[2]; //do którego końca się łączy + int iLast; //ustawiony bit 0, jeśli jest ostatnim drutem w sekcji; bit1 - przedostatni +public: + GLuint uiDisplayList; + vector3 pPoint1,pPoint2,pPoint3,pPoint4; + vector3 vParametric; //współczynniki równania parametrycznego odcinka + double fHeightDifference;//,fMiddleHeight; + //int iCategory,iMaterial,iDamageFlag; + //float fU,fR,fMaxI,fWireThickness; + int iNumSections; + int iLines; //ilosc linii dla VBO + float NominalVoltage; + float MaxCurrent; + float fResistivity; //[om/m], przeliczone z [om/km] + DWORD Material; //1: Cu, 2: Al + float WireThickness; + DWORD DamageFlag; //1: zasniedziale, 128: zerwana + int Wires; + float WireOffset; + AnsiString asPowerSupplyName; //McZapkie: nazwa podstacji trakcyjnej + TTractionPowerSource *psSection; //zasilacz (opcjonalnie może to być pulpit sterujący EL2 w hali!) + AnsiString asParallel; //nazwa przęsła, z którym może być bieżnia wspólna + TTraction *hvParallel; //jednokierunkowa i zapętlona lista przęseł ewentualnej bieżni wspólnej + float fResistance[2]; //rezystancja zastępcza do punktu zasilania (0: przęsło zasilane, <0: do policzenia) + int iTries; + //bool bVisible; + //DWORD dwFlags; + + void __fastcall Optimize(); + + TTraction(); + ~TTraction(); + +// virtual void __fastcall InitCenter(vector3 Angles, vector3 pOrigin); +// virtual bool __fastcall Hit(double x, double z, vector3 &hitPoint, vector3 &hitDirection) { return TNode::Hit(x,z,hitPoint,hitDirection); }; + // virtual bool __fastcall Move(double dx, double dy, double dz) { return false; }; +// virtual void __fastcall SelectedRender(); + void __fastcall RenderDL(float mgn); + int __fastcall RaArrayPrepare(); + void __fastcall RaArrayFill(CVertNormTex *Vert); + void __fastcall RenderVBO(float mgn,int iPtr); + int __fastcall TestPoint(vector3 *Point); + void __fastcall Connect(int my,TTraction *with,int to); + void __fastcall Init(); + bool __fastcall WhereIs(); + void __fastcall ResistanceCalc(int d=-1,double r=0,TTractionPowerSource *ps=NULL); + void __fastcall PowerSet(TTractionPowerSource *ps); + double __fastcall VoltageGet(double u,double i); +}; +//--------------------------------------------------------------------------- +#endif diff --git a/TractionPower.cpp b/TractionPower.cpp new file mode 100644 index 00000000..e5ad7e9a --- /dev/null +++ b/TractionPower.cpp @@ -0,0 +1,156 @@ +//--------------------------------------------------------------------------- + +/* + MaSzyna EU07 locomotive simulator component + Copyright (C) 2004 Maciej Czapkiewicz and others + +*/ + + +#include "system.hpp" +#include "classes.hpp" +#pragma hdrstop + +#include "Mover.h" +#include "mctools.hpp" +#include "Timer.h" +#include "Globals.h" +#include "TractionPower.h" + +#include "Usefull.h" +#include "Ground.h" + +//--------------------------------------------------------------------------- + +__fastcall TTractionPowerSource::TTractionPowerSource() +{ + NominalVoltage=0; + VoltageFrequency=0; + InternalRes=0.2; + MaxOutputCurrent=0; + FastFuseTimeOut=1; + FastFuseRepetition=3; + SlowFuseTimeOut=60; + Recuperation=false; + + TotalAdmitance=1e-10; //10Mom - jakaś tam upływność + TotalPreviousAdmitance=1e-10; //zero jest szkodliwe + OutputVoltage=0; + FastFuse=false; + SlowFuse=false; + FuseTimer=0; + FuseCounter=0; + psNode[0]=NULL; //sekcje zostaną podłączone do zasilaczy + psNode[1]=NULL; + bSection=false; //sekcja nie jest źródłem zasilania, tylko grupuje przęsła +}; + +__fastcall TTractionPowerSource::~TTractionPowerSource() +{ +}; + +void __fastcall TTractionPowerSource::Init(double u,double i) +{//ustawianie zasilacza przy braku w scenerii + NominalVoltage=u; + VoltageFrequency=0; + MaxOutputCurrent=i; +}; + +bool __fastcall TTractionPowerSource::Load(cParser *parser) +{ + std::string token; + //AnsiString str; + //str= Parser->GetNextSymbol()LowerCase(); + //asName= str; + parser->getTokens(5); + *parser >> NominalVoltage >> VoltageFrequency >> InternalRes >> MaxOutputCurrent >> FastFuseTimeOut; + parser->getTokens(); + *parser >> FastFuseRepetition; + parser->getTokens(); + *parser >> SlowFuseTimeOut; + parser->getTokens(); + *parser >> token; + if (token.compare("recuperation")==0) + Recuperation=true; + else if (token.compare("section")==0) //odłącznik sekcyjny + bSection=true; //nie jest źródłem zasilania, a jedynie informuje o prądzie odłączenia sekcji z obwodu + parser->getTokens(); + *parser >> token; + if (token.compare("end")!=0) + Error("tractionpowersource end statement missing"); + //if (!bSection) //odłącznik sekcji zasadniczo nie ma impedancji (0.01 jest OK) + if (InternalRes<0.1) //coś mała ta rezystancja była... + InternalRes=0.2; //tak około 0.2, wg http://www.ikolej.pl/fileadmin/user_upload/Seminaria_IK/13_05_07_Prezentacja_Kruczek.pdf + return true; +}; + + +bool __fastcall TTractionPowerSource::Render() +{ + return true; +}; + +bool __fastcall TTractionPowerSource::Update(double dt) +{//powinno być wykonane raz na krok fizyki + if (NominalVoltage*TotalPreviousAdmitance>MaxOutputCurrent) //iloczyn napięcia i admitancji daje prąd + { + FastFuse=true; + FuseCounter+=1; + if (FuseCounter>FastFuseRepetition) + {SlowFuse=true; + ErrorLog("Power overload: \""+gMyNode->asName+"\" disabled for "+AnsiString(SlowFuseTimeOut)+"s"); + } + else + ErrorLog("Power overload: \""+gMyNode->asName+"\" disabled for "+AnsiString(FastFuseTimeOut)+"s"); + FuseTimer=0; + } + if (FastFuse||SlowFuse) + {//jeśli któryś z bezpieczników zadziałał + TotalAdmitance=0; + FuseTimer+=dt; + if (!SlowFuse) + {//gdy szybki, odczekać krótko i załączyć + if (FuseTimer>FastFuseTimeOut) + FastFuse=false; + } + else + if (FuseTimer>SlowFuseTimeOut) + {SlowFuse=false; + FuseCounter=0; //dajemy znów szansę + } + } + TotalPreviousAdmitance=TotalAdmitance; //używamy admitancji z poprzedniego kroku + if (TotalPreviousAdmitance==0.0) + TotalPreviousAdmitance=1e-10; //przynajmniej minimalna upływność + TotalAdmitance=1e-10; //a w aktualnym kroku sumujemy admitancję + return true; +}; + +double __fastcall TTractionPowerSource::CurrentGet(double res) +{//pobranie wartości prądu przypadającego na rezystancję (res) + //niech pamięta poprzednią admitancję i wg niej przydziela prąd + if (SlowFuse||FastFuse) + {//czekanie na zanik obciążenia sekcji + if (res<100.0) //liczenie czasu dopiero, gdy obciążenie zniknie + FuseTimer=0; + return 0; + } + if ((res>0)||((res<0)&&(Recuperation))) + TotalAdmitance+=1.0/res; //połączenie równoległe rezystancji jest równoważne sumie admitancji + TotalCurrent=(TotalPreviousAdmitance!=0.0)?NominalVoltage/(InternalRes+1.0/TotalPreviousAdmitance):0.0; //napięcie dzielone przez sumę rezystancji wewnętrznej i obciążenia + OutputVoltage=NominalVoltage-InternalRes*TotalCurrent; //napięcie na obciążeniu + return TotalCurrent/(res*TotalPreviousAdmitance); //prąd proporcjonalny do udziału (1/res) w całkowitej admitancji +}; + +void __fastcall TTractionPowerSource::PowerSet(TTractionPowerSource *ps) +{//wskazanie zasilacza w obiekcie sekcji + if (!psNode[0]) + psNode[0]=ps; + else if (!psNode[1]) + psNode[1]=ps; + //else ErrorLog("nie może być więcej punktów zasilania niż dwa"); +}; + +//--------------------------------------------------------------------------- + +#pragma package(smart_init) diff --git a/TractionPower.h b/TractionPower.h new file mode 100644 index 00000000..a75e6e91 --- /dev/null +++ b/TractionPower.h @@ -0,0 +1,49 @@ +//--------------------------------------------------------------------------- + +#ifndef TractionPowerH +#define TractionPowerH +#include "parser.h" //Tolaris-010603 + +class TGroundNode; + +class TTractionPowerSource +{ +private: + double NominalVoltage; + double VoltageFrequency; + double InternalRes; + double MaxOutputCurrent; + double FastFuseTimeOut; + int FastFuseRepetition; + double SlowFuseTimeOut; + bool Recuperation; + + double TotalCurrent; + double TotalAdmitance; + double TotalPreviousAdmitance; + double OutputVoltage; + bool FastFuse; + bool SlowFuse; + double FuseTimer; + int FuseCounter; +protected: + +public: //zmienne publiczne + TTractionPowerSource *psNode[2]; //zasilanie na końcach dla sekcji + bool bSection; //czy jest sekcją + TGroundNode *gMyNode; //Ra 2015-03: znowu prowizorka, aby mieć nazwę do logowania +public: + //AnsiString asName; + __fastcall TTractionPowerSource(); + __fastcall ~TTractionPowerSource(); + void __fastcall Init(double u,double i); + bool __fastcall Load(cParser *parser); + bool __fastcall Render(); + bool __fastcall Update(double dt); + double __fastcall CurrentGet(double res); + void __fastcall VoltageSet(double v) {NominalVoltage=v;}; + void __fastcall PowerSet(TTractionPowerSource *ps); +}; + +//--------------------------------------------------------------------------- +#endif diff --git a/Train.cpp b/Train.cpp new file mode 100644 index 00000000..8db41bcd --- /dev/null +++ b/Train.cpp @@ -0,0 +1,5279 @@ +//--------------------------------------------------------------------------- +/* + MaSzyna EU07 locomotive simulator + Copyright (C) 2001-2004 Marcin Wozniak, Maciej Czapkiewicz and others + +*/ + +#include "system.hpp" +#include "classes.hpp" +#pragma hdrstop + +#include "Train.h" +#include "MdlMngr.h" +#include "Globals.h" +#include "Timer.h" +#include "Driver.h" +#include "Console.h" +//--------------------------------------------------------------------------- + +#pragma package(smart_init) + +using namespace Timer; + +__fastcall TCab::TCab() +{ + CabPos1.x=-1.0; CabPos1.y=1.0; CabPos1.z=1.0; + CabPos2.x=1.0; CabPos2.y=1.0; CabPos2.z=-1.0; + bEnabled=false; + bOccupied=true; + dimm_r=dimm_g=dimm_b=1; + intlit_r=intlit_g=intlit_b=0; + intlitlow_r=intlitlow_g=intlitlow_b=0; + iGaugesMax=100; //95 - trzeba pobierać to z pliku konfiguracyjnego + ggList=new TGauge[iGaugesMax]; + iGauges=0; //na razie nie są dodane + iButtonsMax=60; //55 - trzeba pobierać to z pliku konfiguracyjnego + btList=new TButton[iButtonsMax]; + iButtons=0; +} + +void __fastcall TCab::Init(double Initx1,double Inity1,double Initz1,double Initx2,double Inity2,double Initz2,bool InitEnabled,bool InitOccupied) +{ + CabPos1.x=Initx1; CabPos1.y=Inity1; CabPos1.z=Initz1; + CabPos2.x=Initx2; CabPos2.y=Inity2; CabPos2.z=Initz2; + bEnabled=InitEnabled; + bOccupied=InitOccupied; +} + +void __fastcall TCab::Load(TQueryParserComp *Parser) +{ + AnsiString str=Parser->GetNextSymbol().LowerCase(); + if (str==AnsiString("cablight")) + { + dimm_r=Parser->GetNextSymbol().ToDouble(); + dimm_g=Parser->GetNextSymbol().ToDouble(); + dimm_b=Parser->GetNextSymbol().ToDouble(); + intlit_r=Parser->GetNextSymbol().ToDouble(); + intlit_g=Parser->GetNextSymbol().ToDouble(); + intlit_b=Parser->GetNextSymbol().ToDouble(); + intlitlow_r=Parser->GetNextSymbol().ToDouble(); + intlitlow_g=Parser->GetNextSymbol().ToDouble(); + intlitlow_b=Parser->GetNextSymbol().ToDouble(); + str=Parser->GetNextSymbol().LowerCase(); + } + CabPos1.x=str.ToDouble(); + CabPos1.y=Parser->GetNextSymbol().ToDouble(); + CabPos1.z=Parser->GetNextSymbol().ToDouble(); + CabPos2.x=Parser->GetNextSymbol().ToDouble(); + CabPos2.y=Parser->GetNextSymbol().ToDouble(); + CabPos2.z=Parser->GetNextSymbol().ToDouble(); + + bEnabled=True; + bOccupied=True; +} + +__fastcall TCab::~TCab() +{ + delete[] ggList; + delete[] btList; +}; + +TGauge* __fastcall TCab::Gauge(int n) +{//pobranie adresu obiektu aniomowanego ruchem + if (n<0) + {//rezerwacja wolnego + ggList[iGauges].Clear(); + return ggList+iGauges++; + } + else if (nMechanik) + DynamicObject->Mechanik->TakeControl(true); //likwidacja kabiny wymaga przejęcia przez AI +} + +bool __fastcall TTrain::Init(TDynamicObject *NewDynamicObject,bool e3d) +{//powiązanie ręcznego sterowania kabiną z pojazdem + //Global::pUserDynamic=NewDynamicObject; //pojazd renderowany bez trzęsienia + DynamicSet(NewDynamicObject); + if (!e3d) + if (DynamicObject->Mechanik==NULL) + return false; + //if (DynamicObject->Mechanik->AIControllFlag==AIdriver) + // return false; + DynamicObject->MechInside=true; + +/* iPozSzereg=28; + for (int i=1; iMainCtrlPosNo; i++) + { + if (mvControlled->RList[i].Bn>1) + { + iPozSzereg=i-1; + i=mvControlled->MainCtrlPosNo+1; + } + } +*/ + MechSpring.Init(0,500); + vMechVelocity=vector3(0,0,0); + pMechOffset=vector3(-0.4,3.3,5.5); + fMechCroach=0.5; + fMechSpringX=1; + fMechSpringY=0.1; + fMechSpringZ=0.1; + fMechMaxSpring=0.15; + fMechRoll=0.05; + fMechPitch=0.1; + fMainRelayTimer=0; //Hunter, do k...y nędzy, ustawiaj wartości początkowe zmiennych! + + if (!LoadMMediaFile(DynamicObject->asBaseDir+DynamicObject->MoverParameters->TypeName+".mmd")) + return false; + +//McZapkie: w razie wykolejenia +// dsbDerailment=TSoundsManager::GetFromName("derail.wav"); +//McZapkie: jazda luzem: +// dsbRunningNoise=TSoundsManager::GetFromName("runningnoise.wav"); + +// McZapkie? - dzwieki slyszalne tylko wewnatrz kabiny - generowane przez obiekt sterowany: + + +//McZapkie-080302 sWentylatory.Init("wenton.wav","went.wav","wentoff.wav"); +//McZapkie-010302 +// sCompressor.Init("compressor-start.wav","compressor.wav","compressor-stop.wav"); + +// sHorn1.Init("horn1.wav",0.3); +// sHorn2.Init("horn2.wav",0.3); + +// sHorn1.Init("horn1-start.wav","horn1.wav","horn1-stop.wav"); +// sHorn2.Init("horn2-start.wav","horn2.wav","horn2-stop.wav"); + +// sConverter.Init("converter.wav",1.5); //NBMX obsluga przez AdvSound + iCabn=0; + //Ra: taka proteza - przesłanie kierunku do członów connected + if (mvControlled->ActiveDir>0) + {//było do przodu + mvControlled->DirectionBackward(); + mvControlled->DirectionForward(); + } + else if (mvControlled->ActiveDir<0) + {mvControlled->DirectionForward(); + mvControlled->DirectionBackward(); + } + return true; +} + + +void __fastcall TTrain::OnKeyDown(int cKey) +{//naciśnięcie klawisza + bool isEztOer; + isEztOer=((mvControlled->TrainType==dt_EZT)&&(mvControlled->Battery==true)&&(mvControlled->EpFuse==true)&&(mvOccupied->BrakeSubsystem==ss_ESt)&&(mvControlled->ActiveDir!=0)); //od yB + //isEztOer=(mvControlled->TrainType==dt_EZT)&&(mvControlled->Mains)&&(mvOccupied->BrakeSubsystem==ss_ESt)&&(mvControlled->ActiveDir!=0); + //isEztOer=((mvControlled->TrainType==dt_EZT)&&(mvControlled->Battery==true)&&(mvControlled->EpFuse==true)&&(mvOccupied->BrakeSubsystem==Oerlikon)&&(mvControlled->ActiveDir!=0)); + + if (GetAsyncKeyState(VK_SHIFT)<0) + {//wciśnięty [Shift] + if (cKey==Global::Keys[k_IncMainCtrlFAST]) //McZapkie-200702: szybkie przelaczanie na poz. bezoporowa + { + if (mvControlled->IncMainCtrl(2)) + { + dsbNastawnikJazdy->SetCurrentPosition(0); + dsbNastawnikJazdy->Play(0,0,0); + } + } + else + if (cKey==Global::Keys[k_DirectionBackward]) + { + if (mvControlled->Radio==false) + if (GetAsyncKeyState(VK_CONTROL)>=0) + { + dsbSwitch->SetVolume(DSBVOLUME_MAX); + dsbSwitch->Play(0,0,0); + mvControlled->Radio=true; + } + } + else + + if (cKey==Global::Keys[k_DecMainCtrlFAST]) + if (mvControlled->DecMainCtrl(2)) + { + dsbNastawnikJazdy->SetCurrentPosition(0); + dsbNastawnikJazdy->Play(0,0,0); + } + else; + else + if (cKey==Global::Keys[k_IncScndCtrlFAST]) + if (mvControlled->IncScndCtrl(2)) + { + if (dsbNastawnikBocz) //hunter-081211 + { + dsbNastawnikBocz->SetCurrentPosition(0); + dsbNastawnikBocz->Play(0,0,0); + } + else if (!dsbNastawnikBocz) + { + dsbNastawnikJazdy->SetCurrentPosition(0); + dsbNastawnikJazdy->Play(0,0,0); + } + } + else; + else + if (cKey==Global::Keys[k_DecScndCtrlFAST]) + if (mvControlled->DecScndCtrl(2)) + { + if (dsbNastawnikBocz) //hunter-081211 + { + dsbNastawnikBocz->SetCurrentPosition(0); + dsbNastawnikBocz->Play(0,0,0); + } + else if (!dsbNastawnikBocz) + { + dsbNastawnikJazdy->SetCurrentPosition(0); + dsbNastawnikJazdy->Play(0,0,0); + } + } + else; + else + if (cKey==Global::Keys[k_IncLocalBrakeLevelFAST]) + if (mvOccupied->IncLocalBrakeLevel(2)); + else; + else + if (cKey==Global::Keys[k_DecLocalBrakeLevelFAST]) + if (mvOccupied->DecLocalBrakeLevel(2)); + else; + // McZapkie-240302 - wlaczanie glownego obwodu klawiszem M+shift + //----------- + //hunter-141211: wyl. szybki zalaczony przeniesiony do TTrain::Update() + /* if (cKey==Global::Keys[k_Main]) + { + ggMainOnButton.PutValue(1); + if (mvControlled->MainSwitch(true)) + { + if (mvControlled->EngineType==DieselEngine) + dsbDieselIgnition->Play(0,0,0); + else + dsbNastawnikJazdy->Play(0,0,0); + } + } + else */ + if (cKey==Global::Keys[k_Battery]) + { + //if (((mvControlled->TrainType==dt_EZT)||(mvControlled->EngineType==ElectricSeriesMotor)||(mvControlled->EngineType==DieselElectric))&&(!mvControlled->Battery)) + if (!mvControlled->Battery) + {//wyłącznik jest też w SN61, ewentualnie załączać prąd na stałe z poziomu FIZ + if (mvOccupied->BatterySwitch(true)) //bateria potrzebna np. do zapalenia świateł + { + dsbSwitch->Play(0,0,0); + if (TestFlag(mvOccupied->SecuritySystem.SystemType,2)) //Ra: znowu w kabinie jest coś, co być nie powinno! + { + SetFlag(mvOccupied->SecuritySystem.Status,s_active); + SetFlag(mvOccupied->SecuritySystem.Status,s_SHPalarm); + } + } + } + } + else + if (cKey==Global::Keys[k_StLinOff]) + { + if(mvControlled->TrainType==dt_EZT) + { + if ((mvControlled->Signalling==false)) + { + dsbSwitch->Play(0,0,0); + mvControlled->Signalling=true; + } + } + } + else + if (cKey==Global::Keys[k_Sand]) + { + if(mvControlled->TrainType==dt_EZT) + { + if (!mvControlled->DoorSignalling) + { + dsbSwitch->Play(0,0,0); + mvControlled->DoorSignalling=true; + } + } + } + if (cKey==Global::Keys[k_Main]) + { + if (fabs(ggMainOnButton.GetValue())<0.001) + if (dsbSwitch) + { + dsbSwitch->SetVolume(DSBVOLUME_MAX); + dsbSwitch->Play(0,0,0); + } + } + else + //----------- + + if (cKey==Global::Keys[k_BrakeProfile]) //McZapkie-240302-B: przelacznik opoznienia hamowania + {//yB://ABu: male poprawki, zeby bylo mozna ustawic dowolny wagon + int CouplNr=-2; + if (!FreeFlyModeFlag) + { + if (GetAsyncKeyState(VK_CONTROL)<0) + if (mvOccupied->BrakeDelaySwitch(bdelay_R+bdelay_M)) + { + dsbPneumaticRelay->SetVolume(DSBVOLUME_MAX); + dsbPneumaticRelay->Play(0,0,0); + } + else; + else + if (mvOccupied->BrakeDelaySwitch(bdelay_P)) + { + dsbPneumaticRelay->SetVolume(DSBVOLUME_MAX); + dsbPneumaticRelay->Play(0,0,0); + } + } + else + { + TDynamicObject *temp; + temp=(DynamicObject->ABuScanNearestObject(DynamicObject->GetTrack(),-1, 1500, CouplNr)); + if (temp==NULL) + { + CouplNr=-2; + temp=(DynamicObject->ABuScanNearestObject(DynamicObject->GetTrack(),1, 1500, CouplNr)); + } + if (temp) + { + if (GetAsyncKeyState(VK_CONTROL)<0) + if (temp->MoverParameters->BrakeDelaySwitch(bdelay_R+bdelay_M)) + { + dsbPneumaticRelay->SetVolume(DSBVOLUME_MAX); + dsbPneumaticRelay->Play(0,0,0); + } + else; + else + if (temp->MoverParameters->BrakeDelaySwitch(bdelay_P)) + { + dsbPneumaticRelay->SetVolume(DSBVOLUME_MAX); + dsbPneumaticRelay->Play(0,0,0); + } + } + } + } + else + //----------- + //hunter-261211: przetwornica i sprzezarka przeniesione do TTrain::Update() + /* if (cKey==Global::Keys[k_Converter]) //NBMX 14-09-2003: przetwornica wl + { + if ((mvControlled->PantFrontVolt) || (mvControlled->PantRearVolt) || (mvControlled->EnginePowerSource.SourceType!=CurrentCollector) || (!Global::bLiveTraction)) + if (mvControlled->ConverterSwitch(true)) + { + dsbSwitch->SetVolume(DSBVOLUME_MAX); + dsbSwitch->Play(0,0,0); + } + } + else + if (cKey==Global::Keys[k_Compressor]) //NBMX 14-09-2003: sprezarka wl + { + if ((mvControlled->ConverterFlag) || (mvControlled->CompressorPower<2)) + if (mvControlled->CompressorSwitch(true)) + { + dsbSwitch->SetVolume(DSBVOLUME_MAX); + dsbSwitch->Play(0,0,0); + } + } + else */ + + if (cKey==Global::Keys[k_Converter]) + { + if (ggConverterButton.GetValue()==0) + { + dsbSwitch->SetVolume(DSBVOLUME_MAX); + dsbSwitch->Play(0,0,0); + } + } + else + //if ((cKey==Global::Keys[k_Compressor])&&((mvControlled->EngineType==ElectricSeriesMotor)||(mvControlled->TrainType==dt_EZT))) //hunter-110212: poprawka dla EZT + if ((cKey==Global::Keys[k_Compressor])&&(mvControlled->CompressorPower<2)) //hunter-091012: tak jest poprawnie + { + if (ggCompressorButton.GetValue()==0) + { + dsbSwitch->SetVolume(DSBVOLUME_MAX); + dsbSwitch->Play(0,0,0); + } + } + else if (cKey==Global::Keys[k_SmallCompressor]) //Winger 160404: mala sprezarka wl + {//Ra: dźwięk, gdy razem z [Shift] + if ((mvControlled->TrainType&dt_EZT)?mvControlled==mvOccupied:!mvOccupied->ActiveCab) //tylko w maszynowym + if (Console::Pressed(VK_CONTROL)) //z [Ctrl] + mvControlled->bPantKurek3=true; //zbiornik pantografu połączony jest ze zbiornikiem głównym (pompowanie nie ma sensu) + else if (!mvControlled->PantCompFlag) //jeśli wyłączona + if (mvControlled->Battery) //jeszcze musi być załączona bateria + if (mvControlled->PantPress<4.8) //piszą, że to tak nie działa + { + mvControlled->PantCompFlag=true; + dsbSwitch->SetVolume(DSBVOLUME_MAX); + dsbSwitch->Play(0,0,0); //dźwięk tylko po naciśnięciu klawisza + } + } + else if (cKey==VkKeyScan('q')) //ze Shiftem - włączenie AI + {//McZapkie-240302 - wlaczanie automatycznego pilota (zadziala tylko w trybie debugmode) + if (DynamicObject->Mechanik) + { + if (DebugModeFlag) + if (DynamicObject->Mechanik->AIControllFlag) //żeby nie trzeba było rozłączać dla zresetowania + DynamicObject->Mechanik->TakeControl(false); + DynamicObject->Mechanik->TakeControl(true); + } + } + else if (cKey==Global::Keys[k_MaxCurrent]) //McZapkie-160502: F - wysoki rozruch + { + if ((mvControlled->EngineType==DieselElectric)&&(mvControlled->ShuntModeAllow) && (mvControlled->MainCtrlPos==0)) + { + mvControlled->ShuntMode=true; + } + if (mvControlled->CurrentSwitch(true)) + { + dsbSwitch->SetVolume(DSBVOLUME_MAX); + dsbSwitch->Play(0,0,0); + } +/* Ra: przeniesione do Mover.cpp + if (mvControlled->TrainType!=dt_EZT) //to powinno być w fizyce, a nie w kabinie! + if (mvControlled->MinCurrentSwitch(true)) + { + dsbSwitch->SetVolume(DSBVOLUME_MAX); + dsbSwitch->Play(0,0,0); + } +*/ + } + else if (cKey==Global::Keys[k_CurrentAutoRelay]) //McZapkie-241002: G - wlaczanie PSR + { + if (mvControlled->AutoRelaySwitch(true)) + { + dsbSwitch->SetVolume(DSBVOLUME_MAX); + dsbSwitch->Play(0,0,0); + } + } + else + if (cKey==Global::Keys[k_FailedEngineCutOff]) //McZapkie-060103: E - wylaczanie sekcji silnikow + { + if (mvControlled->CutOffEngine()) + { + dsbSwitch->SetVolume(DSBVOLUME_MAX); + dsbSwitch->Play(0,0,0); + } + } + else + if (cKey==Global::Keys[k_OpenLeft]) //NBMX 17-09-2003: otwieranie drzwi + { + if (mvOccupied->DoorOpenCtrl==1) + if (mvOccupied->CabNo<0?mvOccupied->DoorRight(true):mvOccupied->DoorLeft(true)) + { + dsbSwitch->SetVolume(DSBVOLUME_MAX); + dsbSwitch->Play(0,0,0); + if (dsbDoorOpen) + { + dsbDoorOpen->SetCurrentPosition(0); + dsbDoorOpen->Play(0,0,0); + } + } + } + else + if (cKey==Global::Keys[k_OpenRight]) //NBMX 17-09-2003: otwieranie drzwi + { + if (mvOccupied->DoorCloseCtrl==1) + if (mvOccupied->CabNo<0?mvOccupied->DoorLeft(true):mvOccupied->DoorRight(true)) + { + dsbSwitch->SetVolume(DSBVOLUME_MAX); + dsbSwitch->Play(0,0,0); + if (dsbDoorOpen) + { + dsbDoorOpen->SetCurrentPosition(0); + dsbDoorOpen->Play(0,0,0); + } + } + } + else + //----------- + //hunter-131211: dzwiek dla przelacznika universala podniesionego + //hunter-091012: ubajerowanie swiatla w kabinie (wyrzucenie przyciemnienia pod Univ4) + if (cKey==Global::Keys[k_Univ3]) + { + if (Console::Pressed(VK_CONTROL)) + { + if (bCabLight==false)//(ggCabLightButton.GetValue()==0) + { + dsbSwitch->SetVolume(DSBVOLUME_MAX); + dsbSwitch->Play(0,0,0); + } + } + else + { + if (ggUniversal3Button.GetValue()==0) + { + dsbSwitch->SetVolume(DSBVOLUME_MAX); + dsbSwitch->Play(0,0,0); + } + /* + if (Console::Pressed(VK_CONTROL)) + {//z [Ctrl] zapalamy albo gasimy światełko w kabinie + if (iCabLightFlag<2) ++iCabLightFlag; //zapalenie + } + */ + } + } + else + //----------- + //hunter-091012: dzwiek dla przyciemnienia swiatelka w kabinie + if (cKey==Global::Keys[k_Univ4]) + { + if (Console::Pressed(VK_CONTROL)) + { + if (bCabLightDim==false) //(ggCabLightDimButton.GetValue()==0) + { + dsbSwitch->SetVolume(DSBVOLUME_MAX); + dsbSwitch->Play(0,0,0); + } + } + } + else + //----------- + if (cKey==Global::Keys[k_PantFrontUp]) + {//Winger 160204: podn. przedn. pantografu + if (mvOccupied->ActiveCab==1)//||((mvOccupied->ActiveCab<1)&&((mvControlled->TrainType&(dt_ET40|dt_ET41|dt_ET42|dt_EZT))==0))) + {//przedni gdy w kabinie 1 lub (z wyjątkiem ET40, ET41, ET42 i EZT) gdy w kabinie -1 + mvControlled->PantFrontSP=false; + if (mvControlled->PantFront(true)) + if (mvControlled->PantFrontStart!=1) + { + dsbSwitch->SetVolume(DSBVOLUME_MAX); + dsbSwitch->Play(0,0,0); + } + } + else + //if ((mvOccupied->ActiveCab<1)&&(mvControlled->TrainType&(dt_ET40|dt_ET41|dt_ET42|dt_EZT))) + {//w kabinie -1 dla ET40, ET41, ET42 i EZT + mvControlled->PantRearSP=false; + if(mvControlled->PantRear(true)) + if(mvControlled->PantRearStart!=1) + { + dsbSwitch->SetVolume(DSBVOLUME_MAX); + dsbSwitch->Play(0,0,0); + } + } + } + else + if (cKey==Global::Keys[k_PantRearUp]) + {//Winger 160204: podn. tyln. pantografu względem kierunku jazdy + if (mvOccupied->ActiveCab==1)//||((mvOccupied->ActiveCab<1)&&((mvControlled->TrainType&(dt_ET40|dt_ET41|dt_ET42|dt_EZT))==0))) + {//tylny gdy w kabinie 1 lub (z wyjątkiem ET40, ET41, ET42 i EZT) gdy w kabinie -1 + mvControlled->PantRearSP=false; + if (mvControlled->PantRear(true)) + if (mvControlled->PantRearStart!=1) + { + dsbSwitch->SetVolume(DSBVOLUME_MAX); + dsbSwitch->Play(0,0,0); + } + } + else + //if ((mvOccupied->ActiveCab<1)&&(mvControlled->TrainType&(dt_ET40|dt_ET41|dt_ET42|dt_EZT))) + {//przedni w kabinie -1 dla ET40, ET41, ET42 i EZT + mvControlled->PantFrontSP=false; + if(mvControlled->PantFront(true)) + if (mvControlled->PantFrontStart!=1) + { + dsbSwitch->SetVolume(DSBVOLUME_MAX); + dsbSwitch->Play(0,0,0); + } + } + } + else + if (cKey==Global::Keys[k_Active]) //yB 300407: przelacznik rozrzadu + {//Ra 2014-06: uruchomiłem to, aby aktywować czuwak w zajmowanym członie, a wyłączyć w innych + //Ra 2014-03: aktywacja czuwaka przepięta na ustawienie kierunku w mvOccupied + //if (mvControlled->Battery) //jeśli bateria jest już załączona + // mvOccupied->BatterySwitch(true); //to w ten oto durny sposób aktywuje się CA/SHP +// if (mvControlled->CabActivisation()) +// { +// dsbSwitch->SetVolume(DSBVOLUME_MAX); +// dsbSwitch->Play(0,0,0); +// } + } + else + if (cKey==Global::Keys[k_Heating]) //Winger 020304: ogrzewanie skladu - wlaczenie + {//Ra 2014-09: w trybie latania obsługa jest w World.cpp + if (!FreeFlyModeFlag) + { + if ((mvControlled->Heating==false)&&((mvControlled->EngineType==ElectricSeriesMotor)&&(mvControlled->Mains==true)||(mvControlled->ConverterFlag))) + { + mvControlled->Heating=true; + dsbSwitch->SetVolume(DSBVOLUME_MAX); + dsbSwitch->Play(0,0,0); + } + } + } + else + //ABu 060205: dzielo Wingera po malutkim liftingu: + if (cKey==Global::Keys[k_LeftSign]) //lewe swiatlo - włączenie + { + if ((GetAsyncKeyState(VK_CONTROL)<0)&&(ggRearLeftLightButton.SubModel)) //hunter-230112 - z controlem zapala z tylu + { + //------------------------------ + if (mvOccupied->ActiveCab==1) + {//kabina 1 + if (((DynamicObject->iLights[1])&3)==0) + { + DynamicObject->iLights[1]|=1; + dsbSwitch->SetVolume(DSBVOLUME_MAX); + dsbSwitch->Play(0,0,0); + ggRearLeftLightButton.PutValue(1); + } + if (((DynamicObject->iLights[1])&3)==2) + { + DynamicObject->iLights[1]&=(255-2); + dsbSwitch->SetVolume(DSBVOLUME_MAX); + dsbSwitch->Play(0,0,0); + if (ggRearLeftEndLightButton.SubModel) + { + ggRearLeftEndLightButton.PutValue(0); + ggRearLeftLightButton.PutValue(0); + } + else + ggRearLeftLightButton.PutValue(0); + } + } + else + {//kabina -1 + if (((DynamicObject->iLights[0])&3)==0) + { + DynamicObject->iLights[0]|=1; + dsbSwitch->SetVolume(DSBVOLUME_MAX); + dsbSwitch->Play(0,0,0); + ggRearLeftLightButton.PutValue(1); + } + if (((DynamicObject->iLights[0])&3)==2) + { + DynamicObject->iLights[0]&=(255-2); + dsbSwitch->SetVolume(DSBVOLUME_MAX); + dsbSwitch->Play(0,0,0); + if (ggRearLeftEndLightButton.SubModel) + { + ggRearLeftEndLightButton.PutValue(0); + ggRearLeftLightButton.PutValue(0); + } + else + ggRearLeftLightButton.PutValue(0); + } + } + //---------------------- + } + else + { + if (mvOccupied->ActiveCab==1) + {//kabina 1 + if (((DynamicObject->iLights[0])&3)==0) + { + DynamicObject->iLights[0]|=1; + dsbSwitch->SetVolume(DSBVOLUME_MAX); + dsbSwitch->Play(0,0,0); + ggLeftLightButton.PutValue(1); + } + if (((DynamicObject->iLights[0])&3)==2) + { + DynamicObject->iLights[0]&=(255-2); + dsbSwitch->SetVolume(DSBVOLUME_MAX); + dsbSwitch->Play(0,0,0); + if (ggLeftEndLightButton.SubModel) + { + ggLeftEndLightButton.PutValue(0); + ggLeftLightButton.PutValue(0); + } + else + ggLeftLightButton.PutValue(0); + } + } + else + {//kabina -1 + if (((DynamicObject->iLights[1])&3)==0) + { + DynamicObject->iLights[1]|=1; + dsbSwitch->SetVolume(DSBVOLUME_MAX); + dsbSwitch->Play(0,0,0); + ggLeftLightButton.PutValue(1); + } + if (((DynamicObject->iLights[1])&3)==2) + { + DynamicObject->iLights[1]&=(255-2); + dsbSwitch->SetVolume(DSBVOLUME_MAX); + dsbSwitch->Play(0,0,0); + if (ggLeftEndLightButton.SubModel) + { + ggLeftEndLightButton.PutValue(0); + ggLeftLightButton.PutValue(0); + } + else + ggLeftLightButton.PutValue(0); + } + } + } //----------- + } + else + if (cKey==Global::Keys[k_UpperSign]) //ABu 060205: światło górne - włączenie + { + if ((GetAsyncKeyState(VK_CONTROL)<0)&&(ggRearUpperLightButton.SubModel)) //hunter-230112 - z controlem zapala z tylu + { + //------------------------------ + if ((mvOccupied->ActiveCab)==1) + { //kabina 1 + if (((DynamicObject->iLights[1])&12)==0) + { + DynamicObject->iLights[1]|=4; + dsbSwitch->SetVolume(DSBVOLUME_MAX); + dsbSwitch->Play(0,0,0); + ggRearUpperLightButton.PutValue(1); + } + } + else + {//kabina -1 + if (((DynamicObject->iLights[0])&12)==0) + { + DynamicObject->iLights[0]|=4; + dsbSwitch->SetVolume(DSBVOLUME_MAX); + dsbSwitch->Play(0,0,0); + ggRearUpperLightButton.PutValue(1); + } + } + } //------------------------------ + else + { + if ((mvOccupied->ActiveCab)==1) + { //kabina 1 + if (((DynamicObject->iLights[0])&12)==0) + { + DynamicObject->iLights[0]|=4; + dsbSwitch->SetVolume(DSBVOLUME_MAX); + dsbSwitch->Play(0,0,0); + ggUpperLightButton.PutValue(1); + } + } + else + {//kabina -1 + if (((DynamicObject->iLights[1])&12)==0) + { + DynamicObject->iLights[1]|=4; + dsbSwitch->SetVolume(DSBVOLUME_MAX); + dsbSwitch->Play(0,0,0); + ggUpperLightButton.PutValue(1); + } + } + } + } + else + if (cKey==Global::Keys[k_RightSign]) //Winger 070304: swiatla tylne (koncowki) - wlaczenie + { + if ((GetAsyncKeyState(VK_CONTROL)<0)&&(ggRearRightLightButton.SubModel)) //hunter-230112 - z controlem zapala z tylu + { + //------------------------------ + if (mvOccupied->ActiveCab==1) + {//kabina 1 + if (((DynamicObject->iLights[1])&48)==0) + { + DynamicObject->iLights[1]|=16; + dsbSwitch->SetVolume(DSBVOLUME_MAX); + dsbSwitch->Play(0,0,0); + ggRearRightLightButton.PutValue(1); + } + if (((DynamicObject->iLights[1])&48)==32) + { + DynamicObject->iLights[1]&=(255-32); + dsbSwitch->SetVolume(DSBVOLUME_MAX); + dsbSwitch->Play(0,0,0); + if (ggRearRightEndLightButton.SubModel) + { + ggRearRightEndLightButton.PutValue(0); + ggRearRightLightButton.PutValue(0); + } + else + ggRearRightLightButton.PutValue(0); + } + } + else + {//kabina -1 + if (((DynamicObject->iLights[0])&48)==0) + { + DynamicObject->iLights[0]|=16; + dsbSwitch->SetVolume(DSBVOLUME_MAX); + dsbSwitch->Play(0,0,0); + ggRearRightLightButton.PutValue(1); + } + if (((DynamicObject->iLights[0])&48)==32) + { + DynamicObject->iLights[0]&=(255-32); + dsbSwitch->SetVolume(DSBVOLUME_MAX); + dsbSwitch->Play(0,0,0); + if (ggRearRightEndLightButton.SubModel) + { + ggRearRightEndLightButton.PutValue(0); + ggRearRightLightButton.PutValue(0); + } + else + ggRearRightLightButton.PutValue(0); + } + } + } //------------------------------ + else + { + if (mvOccupied->ActiveCab==1) + {//kabina 1 + if (((DynamicObject->iLights[0])&48)==0) + { + DynamicObject->iLights[0]|=16; + dsbSwitch->SetVolume(DSBVOLUME_MAX); + dsbSwitch->Play(0,0,0); + ggRightLightButton.PutValue(1); + } + if (((DynamicObject->iLights[0])&48)==32) + { + DynamicObject->iLights[0]&=(255-32); + dsbSwitch->SetVolume(DSBVOLUME_MAX); + dsbSwitch->Play(0,0,0); + if (ggRightEndLightButton.SubModel) + { + ggRightEndLightButton.PutValue(0); + ggRightLightButton.PutValue(0); + } + else + ggRightLightButton.PutValue(0); + } + } + else + {//kabina -1 + if (((DynamicObject->iLights[1])&48)==0) + { + DynamicObject->iLights[1]|=16; + dsbSwitch->SetVolume(DSBVOLUME_MAX); + dsbSwitch->Play(0,0,0); + ggRightLightButton.PutValue(1); + } + if (((DynamicObject->iLights[1])&48)==32) + { + DynamicObject->iLights[1]&=(255-32); + dsbSwitch->SetVolume(DSBVOLUME_MAX); + dsbSwitch->Play(0,0,0); + if (ggRightEndLightButton.SubModel) + { + ggRightEndLightButton.PutValue(0); + ggRightLightButton.PutValue(0); + } + else + ggRightLightButton.PutValue(0); + } + } + } + } + } + else //McZapkie-240302 - klawisze bez shifta + { + if (cKey==Global::Keys[k_IncMainCtrl]) + { + if (mvControlled->IncMainCtrl(1)) + { + dsbNastawnikJazdy->SetCurrentPosition(0); + dsbNastawnikJazdy->Play(0,0,0); + } + } + else if (cKey==Global::Keys[k_DecMainCtrl]) + if (mvControlled->DecMainCtrl(1)) + { + dsbNastawnikJazdy->SetCurrentPosition(0); + dsbNastawnikJazdy->Play(0,0,0); + } + else; + else + if (cKey==Global::Keys[k_IncScndCtrl]) +// if (MoverParameters->ScndCtrlPosScndCtrlPosNo) +// if (mvControlled->EnginePowerSource.SourceType==CurrentCollector) + if (mvControlled->ShuntMode) + { + mvControlled->AnPos+=(GetDeltaTime()/0.85f); + if (mvControlled->AnPos > 1) + mvControlled->AnPos=1; + } + else + if (mvControlled->IncScndCtrl(1)) + { + if (dsbNastawnikBocz) //hunter-081211 + { + dsbNastawnikBocz->SetCurrentPosition(0); + dsbNastawnikBocz->Play(0,0,0); + } + else if (!dsbNastawnikBocz) + { + dsbNastawnikJazdy->SetCurrentPosition(0); + dsbNastawnikJazdy->Play(0,0,0); + } + } + else; + else + if (cKey==Global::Keys[k_DecScndCtrl]) + // if (mvControlled->EnginePowerSource.SourceType==CurrentCollector) + if (mvControlled->ShuntMode) + { + mvControlled->AnPos-=(GetDeltaTime()/0.55f); + if (mvControlled->AnPos < 0) + mvControlled->AnPos=0; + } + else + + if (mvControlled->DecScndCtrl(1)) + // if (MoverParameters->ScndCtrlPos>0) + { + if (dsbNastawnikBocz) //hunter-081211 + { + dsbNastawnikBocz->SetCurrentPosition(0); + dsbNastawnikBocz->Play(0,0,0); + } + else if (!dsbNastawnikBocz) + { + dsbNastawnikJazdy->SetCurrentPosition(0); + dsbNastawnikJazdy->Play(0,0,0); + } + } + else; + else + if (cKey==Global::Keys[k_IncLocalBrakeLevel]) + {//Ra 2014-09: w trybie latania obsługa jest w World.cpp + if (!FreeFlyModeFlag) + { + if (GetAsyncKeyState(VK_CONTROL)<0) + if ((mvOccupied->LocalBrake==ManualBrake)||(mvOccupied->MBrake==true)) + { + mvOccupied->IncManualBrakeLevel(1); + } + else; + else if (mvOccupied->LocalBrake!=ManualBrake) + mvOccupied->IncLocalBrakeLevel(1); + } + } + else + if (cKey==Global::Keys[k_DecLocalBrakeLevel]) + {//Ra 2014-06: wersja dla swobodnego latania przeniesiona do World.cpp + if (!FreeFlyModeFlag) + { + if (GetAsyncKeyState(VK_CONTROL)<0) + if ((mvOccupied->LocalBrake==ManualBrake)||(mvOccupied->MBrake==true)) + mvOccupied->DecManualBrakeLevel(1); + else; + else //Ra 1014-06: AI potrafi zahamować pomocniczym mimo jego braku - odhamować jakoś trzeba + if ((mvOccupied->LocalBrake!=ManualBrake)||mvOccupied->LocalBrakePos) + mvOccupied->DecLocalBrakeLevel(1); + } + } + else + if ((cKey==Global::Keys[k_IncBrakeLevel])&&(mvOccupied->BrakeHandle!=FV4a)) + //if (mvOccupied->IncBrakeLevel()) + if (mvOccupied->BrakeLevelAdd(Global::fBrakeStep)) //nieodpowiedni warunek; true, jeśli można dalej kręcić + { + keybrakecount=0; + if ((isEztOer) && (mvOccupied->BrakeCtrlPos<3)) + {//Ra: uzależnić dźwięk od zmiany stanu EP, nie od klawisza + dsbPneumaticSwitch->SetVolume(-10); + dsbPneumaticSwitch->Play(0,0,0); + } + } + else; + else + if ((cKey==Global::Keys[k_DecBrakeLevel])&&(mvOccupied->BrakeHandle!=FV4a)) + { +//nową wersję dostarczył ZiomalCl ("fixed looped sound in ezt when using NUM_9 key") + if ((mvOccupied->BrakeCtrlPos>-1) || (keybrakecount>1)) + { + + if ((isEztOer) && (mvControlled->Mains) && (mvOccupied->BrakeCtrlPos!=-1)) + {//Ra: uzależnić dźwięk od zmiany stanu EP, nie od klawisza + dsbPneumaticSwitch->SetVolume(-10); + dsbPneumaticSwitch->Play(0,0,0); + } + //mvOccupied->DecBrakeLevel(); + mvOccupied->BrakeLevelAdd(-Global::fBrakeStep); + + } + else keybrakecount+=1; +//koniec wersji dostarczonej przez ZiomalCl +/* wersja poprzednia - ten pierwszy if ze średnikiem nie działał jak warunek + if ((mvOccupied->BrakeCtrlPos>-1)|| (keybrakecount>1)) + { + if (mvOccupied->DecBrakeLevel()); + { + if ((isEztOer) && (mvOccupied->BrakeCtrlPos<2)&&(keybrakecount<=1)) + { + dsbPneumaticSwitch->SetVolume(-10); + dsbPneumaticSwitch->Play(0,0,0); + } + } + } + else keybrakecount+=1; +*/ + } + else + if (cKey==Global::Keys[k_EmergencyBrake]) + { + //while (mvOccupied->IncBrakeLevel()); + mvOccupied->BrakeLevelSet(mvOccupied->Handle->GetPos(bh_EB)); + if(mvOccupied->BrakeCtrlPosNo<=0.1) //hamulec bezpieczeństwa dla wagonów + mvOccupied->EmergencyBrakeFlag=true; + } + else + if (cKey==Global::Keys[k_Brake3]) + { + if ((isEztOer) && ((mvOccupied->BrakeCtrlPos==1)||(mvOccupied->BrakeCtrlPos==-1))) + { + dsbPneumaticSwitch->SetVolume(-10); + dsbPneumaticSwitch->Play(0,0,0); + } + //while (mvOccupied->BrakeCtrlPos>mvOccupied->BrakeCtrlPosNo-1 && mvOccupied->DecBrakeLevel()); + //while (mvOccupied->BrakeCtrlPosBrakeCtrlPosNo-1 && mvOccupied->IncBrakeLevel()); + mvOccupied->BrakeLevelSet(mvOccupied->BrakeCtrlPosNo-1); + } + else + if (cKey==Global::Keys[k_Brake2]) + { + if ((isEztOer) && ((mvOccupied->BrakeCtrlPos==1)||(mvOccupied->BrakeCtrlPos==-1))) + { + dsbPneumaticSwitch->SetVolume(-10); + dsbPneumaticSwitch->Play(0,0,0); + } + //while (mvOccupied->BrakeCtrlPos>mvOccupied->BrakeCtrlPosNo/2 && mvOccupied->DecBrakeLevel()); + //while (mvOccupied->BrakeCtrlPosBrakeCtrlPosNo/2 && mvOccupied->IncBrakeLevel()); + mvOccupied->BrakeLevelSet(mvOccupied->BrakeCtrlPosNo/2+(mvOccupied->BrakeHandle==FV4a?1:0)); + if (GetAsyncKeyState(VK_CONTROL)<0) + mvOccupied->BrakeLevelSet(mvOccupied->Handle->GetPos(bh_NP)); //yB: czy ten stos funkcji nie powinien być jako oddzielna funkcja movera? + } + else + if (cKey==Global::Keys[k_Brake1]) + { + if ((isEztOer)&& (mvOccupied->BrakeCtrlPos!=1)) + { + dsbPneumaticSwitch->SetVolume(-10); + dsbPneumaticSwitch->Play(0,0,0); + } + //while (mvOccupied->BrakeCtrlPos>1 && mvOccupied->DecBrakeLevel()); + //while (mvOccupied->BrakeCtrlPos<1 && mvOccupied->IncBrakeLevel()); + mvOccupied->BrakeLevelSet(1); + } + else + if (cKey==Global::Keys[k_Brake0]) + { + if (Console::Pressed(VK_CONTROL)) + { + mvOccupied->BrakeCtrlPos2= 0; //wyrownaj kapturek + } + else + { + if ((isEztOer) && ((mvOccupied->BrakeCtrlPos==1)||(mvOccupied->BrakeCtrlPos==-1))) + { + dsbPneumaticSwitch->SetVolume(-10); + dsbPneumaticSwitch->Play(0,0,0); + } + //while (mvOccupied->BrakeCtrlPos>0 && mvOccupied->DecBrakeLevel()); + //while (mvOccupied->BrakeCtrlPos<0 && mvOccupied->IncBrakeLevel()); + mvOccupied->BrakeLevelSet(0); + } + } + else + if (cKey==Global::Keys[k_WaveBrake]) //[Num.] + { + if ((isEztOer) && (mvControlled->Mains) && (mvOccupied->BrakeCtrlPos!=-1)) + { + dsbPneumaticSwitch->SetVolume(-10); + dsbPneumaticSwitch->Play(0,0,0); + } + //while (mvOccupied->BrakeCtrlPos>-1 && mvOccupied->DecBrakeLevel()); + //while (mvOccupied->BrakeCtrlPos<-1 && mvOccupied->IncBrakeLevel()); + mvOccupied->BrakeLevelSet(-1); + } + else + //--------------- + //hunter-131211: zbicie czuwaka przeniesione do TTrain::Update() + if (cKey==Global::Keys[k_Czuwak]) + {//Ra: tu został tylko dźwięk + //dsbBuzzer->Stop(); + //if (mvOccupied->SecuritySystemReset()) + if (fabs(ggSecurityResetButton.GetValue())<0.001) + { + dsbSwitch->SetVolume(DSBVOLUME_MAX); + dsbSwitch->Play(0,0,0); + } + //ggSecurityResetButton.PutValue(1); + } + else + //--------------- + //hunter-221211: hamulec przeciwposlizgowy przeniesiony do TTrain::Update() + if (cKey==Global::Keys[k_AntiSlipping]) + { + if (mvOccupied->BrakeSystem!=ElectroPneumatic) + { + //if (mvControlled->AntiSlippingButton()) + if (fabs(ggAntiSlipButton.GetValue())<0.001) + { + //Dlaczego bylo '-50'??? + //dsbSwitch->SetVolume(-50); + dsbSwitch->SetVolume(DSBVOLUME_MAX); + dsbSwitch->Play(0,0,0); + } + //ggAntiSlipButton.PutValue(1); + } + } + else + //--------------- + + if (cKey==Global::Keys[k_Fuse]) + { + if (GetAsyncKeyState(VK_CONTROL)<0) //z controlem + { + ggConverterFuseButton.PutValue(1); //hunter-261211 + if ((mvControlled->Mains==false)&&(ggConverterButton.GetValue()==0)) + mvControlled->ConvOvldFlag=false; + } + else + { + ggFuseButton.PutValue(1); + mvControlled->FuseOn(); + } + } + else + // McZapkie-240302 - zmiana kierunku: 'd' do przodu, 'r' do tylu + if (cKey==Global::Keys[k_DirectionForward]) + { + if (mvOccupied->DirectionForward()) + { + //------------ + //hunter-121211: dzwiek kierunkowego + if (dsbReverserKey) + { + dsbReverserKey->SetCurrentPosition(0); + dsbReverserKey->SetVolume(DSBVOLUME_MAX); + dsbReverserKey->Play(0,0,0); + } + else if (!dsbReverserKey) + if (dsbSwitch) + { + dsbSwitch->SetVolume(DSBVOLUME_MAX); + dsbSwitch->Play(0,0,0); + } + //------------ + if (mvOccupied->ActiveDir) //jeśli kierunek niezerowy + if (DynamicObject->Mechanik) //na wszelki wypadek + DynamicObject->Mechanik->CheckVehicles(Change_direction); //aktualizacja skrajnych pojazdów w składzie + } + } + else + if (cKey==Global::Keys[k_DirectionBackward]) //r + { + if (GetAsyncKeyState(VK_CONTROL)<0) + {//wciśnięty [Ctrl] + if (mvControlled->Radio==true) + { + dsbSwitch->SetVolume(DSBVOLUME_MAX); + dsbSwitch->Play(0,0,0); + mvControlled->Radio=false; + } + } + else + if (mvOccupied->DirectionBackward()) + { + //------------ + //hunter-121211: dzwiek kierunkowego + if (dsbReverserKey) + { + dsbReverserKey->SetCurrentPosition(0); + dsbReverserKey->SetVolume(DSBVOLUME_MAX); + dsbReverserKey->Play(0,0,0); + } + else if (!dsbReverserKey) + if (dsbSwitch) + { + dsbSwitch->SetVolume(DSBVOLUME_MAX); + dsbSwitch->Play(0,0,0); + } + //------------ + if (mvOccupied->ActiveDir) //jeśli kierunek niezerowy + if (DynamicObject->Mechanik) //na wszelki wypadek + DynamicObject->Mechanik->CheckVehicles(Change_direction); //aktualizacja skrajnych pojazdów w składzie + } + } + else + // McZapkie-240302 - wylaczanie glownego obwodu + //----------- + //hunter-141211: wyl. szybki wylaczony przeniesiony do TTrain::Update() + if (cKey==Global::Keys[k_Main]) + { + if (fabs(ggMainOffButton.GetValue())<0.001) + if (dsbSwitch) + { + dsbSwitch->SetVolume(DSBVOLUME_MAX); + dsbSwitch->Play(0,0,0); + } + } + else + + if (cKey==Global::Keys[k_Battery]) + { + //if ((mvControlled->TrainType==dt_EZT) || (mvControlled->EngineType==ElectricSeriesMotor)|| (mvControlled->EngineType==DieselElectric)) + if (mvOccupied->BatterySwitch(false)) + {//ewentualnie zablokować z FIZ, np. w samochodach się nie odłącza akumulatora + dsbSwitch->Play(0,0,0); + //mvOccupied->SecuritySystem.Status=0; + mvControlled->PantFront(false); + mvControlled->PantRear(false); + } + } + + //----------- +// if (cKey==Global::Keys[k_Active]) //yB 300407: przelacznik rozrzadu +// { +// if (mvControlled->CabDeactivisation()) +// { +// dsbSwitch->SetVolume(DSBVOLUME_MAX); +// dsbSwitch->Play(0,0,0); +// } +// } +// else + if (cKey==Global::Keys[k_BrakeProfile]) + {//yB://ABu: male poprawki, zeby bylo mozna ustawic dowolny wagon + int CouplNr=-2; + if (!FreeFlyModeFlag) + { + if (GetAsyncKeyState(VK_CONTROL)<0) + if (mvOccupied->BrakeDelaySwitch(bdelay_R)) + { + dsbPneumaticRelay->SetVolume(DSBVOLUME_MAX); + dsbPneumaticRelay->Play(0,0,0); + } + else; + else + if (mvOccupied->BrakeDelaySwitch(bdelay_G)) + { + dsbPneumaticRelay->SetVolume(DSBVOLUME_MAX); + dsbPneumaticRelay->Play(0,0,0); + } + } + else + { + TDynamicObject *temp; + temp=(DynamicObject->ABuScanNearestObject(DynamicObject->GetTrack(),-1, 1500, CouplNr)); + if (temp==NULL) + { + CouplNr=-2; + temp=(DynamicObject->ABuScanNearestObject(DynamicObject->GetTrack(),1, 1500, CouplNr)); + } + if (temp) + { + if (GetAsyncKeyState(VK_CONTROL)<0) + if (temp->MoverParameters->BrakeDelaySwitch(bdelay_R)) + { + dsbPneumaticRelay->SetVolume(DSBVOLUME_MAX); + dsbPneumaticRelay->Play(0,0,0); + } + else; + else + if (temp->MoverParameters->BrakeDelaySwitch(bdelay_G)) + { + dsbPneumaticRelay->SetVolume(DSBVOLUME_MAX); + dsbPneumaticRelay->Play(0,0,0); + } + } + } + + } + else + //----------- + //hunter-261211: przetwornica i sprzezarka przeniesione do TTrain::Update() + if (cKey==Global::Keys[k_Converter]) + { + if (ggConverterButton.GetValue()!=0) + { + dsbSwitch->SetVolume(DSBVOLUME_MAX); + dsbSwitch->Play(0,0,0); + } + } + else + //if ((cKey==Global::Keys[k_Compressor])&&((mvControlled->EngineType==ElectricSeriesMotor)||(mvControlled->TrainType==dt_EZT))) //hunter-110212: poprawka dla EZT + if ((cKey==Global::Keys[k_Compressor])&&(mvControlled->CompressorPower<2)) //hunter-091012: tak jest poprawnie + { + if (ggCompressorButton.GetValue()!=0) + { + dsbSwitch->SetVolume(DSBVOLUME_MAX); + dsbSwitch->Play(0,0,0); + } + } + else + //----------- + if (cKey==Global::Keys[k_Releaser]) //odluzniacz + { + if (!FreeFlyModeFlag) + { + if ((mvControlled->EngineType==ElectricSeriesMotor)||(mvControlled->EngineType==DieselElectric)||(mvControlled->EngineType==ElectricInductionMotor)) + if (mvControlled->TrainType!=dt_EZT) + if (mvOccupied->BrakeCtrlPosNo>0) + { + ggReleaserButton.PutValue(1); + if (mvOccupied->BrakeReleaser(1)) + { + dsbPneumaticRelay->SetVolume(-80); + dsbPneumaticRelay->Play(0,0,0); + } + } + } + } + else if (cKey==Global::Keys[k_SmallCompressor]) //Winger 160404: mala sprezarka wl + {//Ra: bez [Shift] też dać dźwięk + if ((mvControlled->TrainType&dt_EZT)?mvControlled==mvOccupied:!mvOccupied->ActiveCab) //tylko w maszynowym + if (Console::Pressed(VK_CONTROL)) //z [Ctrl] + mvControlled->bPantKurek3=false; //zbiornik pantografu połączony jest z małą sprężarką (pompowanie ma sens, ale potem trzeba przełączyć) + else if (!mvControlled->PantCompFlag) //jeśli wyłączona + if (mvControlled->Battery) //jeszcze musi być załączona bateria + if (mvControlled->PantPress<4.8) //piszą, że to tak nie działa + { + mvControlled->PantCompFlag=true; + dsbSwitch->SetVolume(DSBVOLUME_MAX); + dsbSwitch->Play(0,0,0); //dźwięk tylko po naciśnięciu klawisza + } + } + //McZapkie-240302 - wylaczanie automatycznego pilota (w trybie ~debugmode mozna tylko raz) + else if (cKey==VkKeyScan('q')) //bez Shift + { + if (DynamicObject->Mechanik) + DynamicObject->Mechanik->TakeControl(false); + } + else + if (cKey==Global::Keys[k_MaxCurrent]) //McZapkie-160502: f - niski rozruch + { + if ((mvControlled->EngineType==DieselElectric) && (mvControlled->ShuntModeAllow) && (mvControlled->MainCtrlPos==0)) + { + mvControlled->ShuntMode=false; + } + if (mvControlled->CurrentSwitch(false)) + { + dsbSwitch->SetVolume(DSBVOLUME_MAX); + dsbSwitch->Play(0,0,0); + } +/* Ra: przeniesione do Mover.cpp + if (mvControlled->TrainType!=dt_EZT) + if (mvControlled->MinCurrentSwitch(false)) + { + dsbSwitch->SetVolume(DSBVOLUME_MAX); + dsbSwitch->Play(0,0,0); + } +*/ + } + else + if (cKey==Global::Keys[k_CurrentAutoRelay]) //McZapkie-241002: g - wylaczanie PSR + { + if (mvControlled->AutoRelaySwitch(false)) + { + dsbSwitch->SetVolume(DSBVOLUME_MAX); + dsbSwitch->Play(0,0,0); + } + } + else + //hunter-201211: piasecznica poprawiona oraz przeniesiona do TTrain::Update() + if (cKey==Global::Keys[k_Sand]) + { + /* + if (mvControlled->TrainType!=dt_EZT) + { + if (mvControlled->SandDoseOn()) + if (mvControlled->SandDose) + { + dsbPneumaticRelay->SetVolume(-30); + dsbPneumaticRelay->Play(0,0,0); + } + } + */ + if (mvControlled->TrainType==dt_EZT) + { + if (mvControlled->DoorSignalling) + { + dsbSwitch->Play(0,0,0); + mvControlled->DoorSignalling=false; + } + } + } + else + if (cKey==Global::Keys[k_CabForward]) + { + if (!CabChange(1)) + if (TestFlag(DynamicObject->MoverParameters->Couplers[0].CouplingFlag,ctrain_passenger)) + {//przejscie do nastepnego pojazdu + Global::changeDynObj=DynamicObject->PrevConnected; + Global::changeDynObj->MoverParameters->ActiveCab=DynamicObject->PrevConnectedNo?-1:1; + } + if (DynamicObject->MoverParameters->ActiveCab) + mvControlled->PantCompFlag=false; //wyjście z maszynowego wyłącza sprężarkę + } + else if (cKey==Global::Keys[k_CabBackward]) + { + if (!CabChange(-1)) + if (TestFlag(DynamicObject->MoverParameters->Couplers[1].CouplingFlag,ctrain_passenger)) + {//przejscie do poprzedniego + Global::changeDynObj=DynamicObject->NextConnected; + Global::changeDynObj->MoverParameters->ActiveCab=DynamicObject->NextConnectedNo?-1:1; + } + if (DynamicObject->MoverParameters->ActiveCab) + mvControlled->PantCompFlag=false; //wyjście z maszynowego wyłącza sprężarkę pomocniczą + } + else + if (cKey==Global::Keys[k_Couple]) + {//ABu051104: male zmiany, zeby mozna bylo laczyc odlegle wagony + //da sie zoptymalizowac, ale nie ma na to czasu :( + if (iCabn>0) + { + if (!FreeFlyModeFlag) //tryb 'kabinowy' + {/* + if (mvControlled->Couplers[iCabn-1].CouplingFlag==0) + { + if (mvControlled->Attach(iCabn-1,mvControlled->Couplers[iCabn-1].Connected,ctrain_coupler)) + { + dsbCouplerAttach->SetVolume(DSBVOLUME_MAX); + dsbCouplerAttach->Play(0,0,0); + //ABu: aha, a guzik, nie dziala i nie bedzie, a przydalo by sie cos takiego: + //DynamicObject->NextConnected=mvControlled->Couplers[iCabn-1].Connected; + //DynamicObject->PrevConnected=mvControlled->Couplers[iCabn-1].Connected; + } + } + else + if (!TestFlag(mvControlled->Couplers[iCabn-1].CouplingFlag,ctrain_pneumatic)) + { + //ABu021104: zeby caly czas bylo widac sprzegi: + if (mvControlled->Attach(iCabn-1,mvControlled->Couplers[iCabn-1].Connected,mvControlled->Couplers[iCabn-1].CouplingFlag+ctrain_pneumatic)) + //if (mvControlled->Attach(iCabn-1,mvControlled->Couplers[iCabn-1].Connected,ctrain_pneumatic)) + { + rsHiss.Play(1,DSBPLAY_LOOPING,true,DynamicObject->GetPosition()); + } + }*/ + } + else + {//tryb freefly + int CouplNr=-1; //normalnie żaden ze sprzęgów + TDynamicObject *tmp; + tmp=DynamicObject->ABuScanNearestObject(DynamicObject->GetTrack(),1,1500,CouplNr); + if (tmp==NULL) + tmp=DynamicObject->ABuScanNearestObject(DynamicObject->GetTrack(),-1,1500,CouplNr); + if (tmp&&(CouplNr!=-1)) + { + if (tmp->MoverParameters->Couplers[CouplNr].CouplingFlag==0) //najpierw hak + { + if ((tmp->MoverParameters->Couplers[CouplNr].Connected->Couplers[CouplNr].AllowedFlag&tmp->MoverParameters->Couplers[CouplNr].AllowedFlag&ctrain_coupler)==ctrain_coupler) + if (tmp->MoverParameters->Attach(CouplNr,2,tmp->MoverParameters->Couplers[CouplNr].Connected,ctrain_coupler)) + { + //tmp->MoverParameters->Couplers[CouplNr].Render=true; //podłączony sprzęg będzie widoczny + if (DynamicObject->Mechanik) //na wszelki wypadek + DynamicObject->Mechanik->CheckVehicles(Connect); //aktualizacja flag kierunku w składzie + dsbCouplerAttach->SetVolume(DSBVOLUME_MAX); + dsbCouplerAttach->Play(0,0,0); + } + else + WriteLog("Mechanical coupling failed."); + } + else + if (!TestFlag(tmp->MoverParameters->Couplers[CouplNr].CouplingFlag,ctrain_pneumatic)) //pneumatyka + { + if ((tmp->MoverParameters->Couplers[CouplNr].Connected->Couplers[CouplNr].AllowedFlag&tmp->MoverParameters->Couplers[CouplNr].AllowedFlag&ctrain_pneumatic)==ctrain_pneumatic) + if (tmp->MoverParameters->Attach(CouplNr,2,tmp->MoverParameters->Couplers[CouplNr].Connected,tmp->MoverParameters->Couplers[CouplNr].CouplingFlag+ctrain_pneumatic)) + { + rsHiss.Play(1,DSBPLAY_LOOPING,true,tmp->GetPosition()); + DynamicObject->SetPneumatic(CouplNr,1); //Ra: to mi się nie podoba !!!! + tmp->SetPneumatic(CouplNr,1); + } + } + else + if (!TestFlag(tmp->MoverParameters->Couplers[CouplNr].CouplingFlag,ctrain_scndpneumatic)) //zasilajacy + { + if ((tmp->MoverParameters->Couplers[CouplNr].Connected->Couplers[CouplNr].AllowedFlag&tmp->MoverParameters->Couplers[CouplNr].AllowedFlag&ctrain_scndpneumatic)==ctrain_scndpneumatic) + if (tmp->MoverParameters->Attach(CouplNr,2,tmp->MoverParameters->Couplers[CouplNr].Connected,tmp->MoverParameters->Couplers[CouplNr].CouplingFlag+ctrain_scndpneumatic)) + { +// rsHiss.Play(1,DSBPLAY_LOOPING,true,tmp->GetPosition()); + dsbCouplerDetach->SetVolume(DSBVOLUME_MAX); + dsbCouplerDetach->Play(0,0,0); + DynamicObject->SetPneumatic(CouplNr,0); //Ra: to mi się nie podoba !!!! + tmp->SetPneumatic(CouplNr,0); + } + } + else + if (!TestFlag(tmp->MoverParameters->Couplers[CouplNr].CouplingFlag,ctrain_controll)) //ukrotnionko + { + if ((tmp->MoverParameters->Couplers[CouplNr].Connected->Couplers[CouplNr].AllowedFlag&tmp->MoverParameters->Couplers[CouplNr].AllowedFlag&ctrain_controll)==ctrain_controll) + if (tmp->MoverParameters->Attach(CouplNr,2,tmp->MoverParameters->Couplers[CouplNr].Connected,tmp->MoverParameters->Couplers[CouplNr].CouplingFlag+ctrain_controll)) + { + dsbCouplerAttach->SetVolume(DSBVOLUME_MAX); + dsbCouplerAttach->Play(0,0,0); + } + } + else + if (!TestFlag(tmp->MoverParameters->Couplers[CouplNr].CouplingFlag,ctrain_passenger)) //mostek + { + if ((tmp->MoverParameters->Couplers[CouplNr].Connected->Couplers[CouplNr].AllowedFlag&tmp->MoverParameters->Couplers[CouplNr].AllowedFlag&ctrain_passenger)==ctrain_passenger) + if (tmp->MoverParameters->Attach(CouplNr,2,tmp->MoverParameters->Couplers[CouplNr].Connected,tmp->MoverParameters->Couplers[CouplNr].CouplingFlag+ctrain_passenger)) + { +// rsHiss.Play(1,DSBPLAY_LOOPING,true,tmp->GetPosition()); + dsbCouplerDetach->SetVolume(DSBVOLUME_MAX); + dsbCouplerDetach->Play(0,0,0); + DynamicObject->SetPneumatic(CouplNr,0); + tmp->SetPneumatic(CouplNr,0); + } + } + } + } + } + } + else + if (cKey==Global::Keys[k_DeCouple]) + { //ABu051104: male zmiany, zeby mozna bylo rozlaczac odlegle wagony + if (iCabn>0) + { + if (!FreeFlyModeFlag) //tryb 'kabinowy' (pozwala również rozłączyć sprzęgi zablokowane) + { + if (DynamicObject->DettachStatus(iCabn-1)<0) //jeśli jest co odczepić + if (DynamicObject->Dettach(iCabn-1)) //iCab==1:przód,iCab==2:tył + { + dsbCouplerDetach->SetVolume(DSBVOLUME_MAX); //w kabinie ten dźwięk? + dsbCouplerDetach->Play(0,0,0); + } + } + else + {//tryb freefly + int CouplNr=-1; + TDynamicObject *tmp; + tmp=DynamicObject->ABuScanNearestObject(DynamicObject->GetTrack(),1,1500,CouplNr); + if (tmp==NULL) + tmp=DynamicObject->ABuScanNearestObject(DynamicObject->GetTrack(),-1,1500,CouplNr); + if (tmp&&(CouplNr!=-1)) + { + if ((tmp->MoverParameters->Couplers[CouplNr].CouplingFlag&ctrain_depot)==0) //jeżeli sprzęg niezablokowany + if (tmp->DettachStatus(CouplNr)<0) //jeśli jest co odczepić i się da + if (!tmp->Dettach(CouplNr)) + {//dźwięk odczepiania + dsbCouplerDetach->SetVolume(DSBVOLUME_MAX); + dsbCouplerDetach->Play(0,0,0); + } + } + } + if (DynamicObject->Mechanik) //na wszelki wypadek + DynamicObject->Mechanik->CheckVehicles(Disconnect); //aktualizacja skrajnych pojazdów w składzie + } + } + else + if (cKey==Global::Keys[k_CloseLeft]) //NBMX 17-09-2003: zamykanie drzwi + { + if (mvOccupied->CabNo<0?mvOccupied->DoorRight(false):mvOccupied->DoorLeft(false)) + { + dsbSwitch->SetVolume(DSBVOLUME_MAX); + dsbSwitch->Play(0,0,0); + if (dsbDoorClose) + { + dsbDoorClose->SetCurrentPosition(0); + dsbDoorClose->Play(0,0,0); + } + } + } + else if (cKey==Global::Keys[k_CloseRight]) //NBMX 17-09-2003: zamykanie drzwi + { + if (mvOccupied->CabNo<0?mvOccupied->DoorLeft(false):mvOccupied->DoorRight(false)) + { + dsbSwitch->SetVolume(DSBVOLUME_MAX); + dsbSwitch->Play(0,0,0); + if (dsbDoorClose) + { + dsbDoorClose->SetCurrentPosition(0); + dsbDoorClose->Play(0,0,0); + } + } + } + else + //----------- + //hunter-131211: dzwiek dla przelacznika universala + //hunter-091012: ubajerowanie swiatla w kabinie (wyrzucenie przyciemnienia pod Univ4) + if (cKey==Global::Keys[k_Univ3]) + { + if (Console::Pressed(VK_CONTROL)) + { + if (bCabLight==true)//(ggCabLightButton.GetValue()!=0) + { + dsbSwitch->SetVolume(DSBVOLUME_MAX); + dsbSwitch->Play(0,0,0); + } + } + else + { + if (ggUniversal3Button.GetValue()!=0) + { + dsbSwitch->SetVolume(DSBVOLUME_MAX); + dsbSwitch->Play(0,0,0); + } + /* + if (Console::Pressed(VK_CONTROL)) + {//z [Ctrl] zapalamy albo gasimy światełko w kabinie + if (iCabLightFlag) --iCabLightFlag; //gaszenie + } */ + } + } + else + //----------- + //hunter-091012: dzwiek dla przyciemnienia swiatelka w kabinie + if (cKey==Global::Keys[k_Univ4]) + { + if (Console::Pressed(VK_CONTROL)) + { + if (bCabLightDim==true) //(ggCabLightDimButton.GetValue()!=0) + { + dsbSwitch->SetVolume(DSBVOLUME_MAX); + dsbSwitch->Play(0,0,0); + } + } + } + //----------- + else + if (cKey==Global::Keys[k_PantFrontDown]) //Winger 160204: opuszczanie prz. patyka + { + if (mvOccupied->ActiveCab==1)//||((mvOccupied->ActiveCab<1)&&(mvControlled->TrainType!=dt_ET40)&&(mvControlled->TrainType!=dt_ET41)&&(mvControlled->TrainType!=dt_ET42)&&(mvControlled->TrainType!=dt_EZT))) + { + //if (!mvControlled->PantFrontUp) //jeśli był opuszczony + // if () //jeśli połamany + // //to powtórzone opuszczanie naprawia + if (mvControlled->PantFront(false)) + { + dsbSwitch->SetVolume(DSBVOLUME_MAX); + dsbSwitch->Play(0,0,0); + } + } + else + //if ((mvOccupied->ActiveCab<1)&&((mvControlled->TrainType==dt_ET40)||(mvControlled->TrainType==dt_ET41)||(mvControlled->TrainType==dt_ET42)||(mvControlled->TrainType==dt_EZT))) + { + if (mvControlled->PantRear(false)) + { + dsbSwitch->SetVolume(DSBVOLUME_MAX); + dsbSwitch->Play(0,0,0); + } + } + } + else if (cKey==Global::Keys[k_PantRearDown]) //Winger 160204: opuszczanie tyl. patyka + { + if (mvOccupied->ActiveCab==1)//||((mvOccupied->ActiveCab<1)&&(mvControlled->TrainType!=dt_ET40)&&(mvControlled->TrainType!=dt_ET41)&&(mvControlled->TrainType!=dt_ET42)&&(mvControlled->TrainType!=dt_EZT))) + { + if (mvControlled->PantSwitchType=="impulse") + ggPantFrontButtonOff.PutValue(1); + if (mvControlled->PantRear(false)) + { + dsbSwitch->SetVolume(DSBVOLUME_MAX); + dsbSwitch->Play(0,0,0); + } + } + else + //if ((mvOccupied->ActiveCab<1)&&((mvControlled->TrainType==dt_ET40)||(mvControlled->TrainType==dt_ET41)||(mvControlled->TrainType==dt_ET42)||(mvControlled->TrainType==dt_EZT))) + { + /* if (mvControlled->PantSwitchType=="impulse") + ggPantRearButtonOff.PutValue(1); */ + if (mvControlled->PantFront(false)) + { + dsbSwitch->SetVolume(DSBVOLUME_MAX); + dsbSwitch->Play(0,0,0); + } + } + } + else if (cKey==Global::Keys[k_Heating]) //Winger 020304: ogrzewanie - wylaczenie + {//Ra 2014-09: w trybie latania obsługa jest w World.cpp + if (!FreeFlyModeFlag) + { + if (mvControlled->Heating==true) + { + dsbSwitch->SetVolume(DSBVOLUME_MAX); + dsbSwitch->Play(0,0,0); + mvControlled->Heating=false; + } + } + } + else + if (cKey==Global::Keys[k_LeftSign]) //ABu 060205: lewe swiatlo - wylaczenie + { + if ((GetAsyncKeyState(VK_CONTROL)<0)&&(ggRearLeftLightButton.SubModel)) //hunter-230112 - z controlem gasi z tylu + { + //------------------------------ + if (mvOccupied->ActiveCab==1) + {//kabina 1 + if (((DynamicObject->iLights[1])&3)==0) + { + DynamicObject->iLights[1]|=2; + dsbSwitch->SetVolume(DSBVOLUME_MAX); + dsbSwitch->Play(0,0,0); + if (ggRearLeftEndLightButton.SubModel) + { + ggRearLeftEndLightButton.PutValue(1); + ggRearLeftLightButton.PutValue(0); + } + else + ggRearLeftLightButton.PutValue(-1); + } + if (((DynamicObject->iLights[1])&3)==1) + { + DynamicObject->iLights[1]&=(255-1); + dsbSwitch->SetVolume(DSBVOLUME_MAX); + dsbSwitch->Play(0,0,0); + ggRearLeftLightButton.PutValue(0); + } + } + else + {//kabina -1 + if (((DynamicObject->iLights[0])&3)==0) + { + DynamicObject->iLights[0]|=2; + dsbSwitch->SetVolume(DSBVOLUME_MAX); + dsbSwitch->Play(0,0,0); + if (ggRearLeftEndLightButton.SubModel) + { + ggRearLeftEndLightButton.PutValue(1); + ggRearLeftLightButton.PutValue(0); + } + else + ggRearLeftLightButton.PutValue(-1); + } + if (((DynamicObject->iLights[1])&3)==1) + { + DynamicObject->iLights[1]&=(255-1); + dsbSwitch->SetVolume(DSBVOLUME_MAX); + dsbSwitch->Play(0,0,0); + ggLeftLightButton.PutValue(0); + } + } + } //------------------------------ + else + { + if (mvOccupied->ActiveCab==1) + {//kabina 1 + if (((DynamicObject->iLights[0])&3)==0) + { + DynamicObject->iLights[0]|=2; + dsbSwitch->SetVolume(DSBVOLUME_MAX); + dsbSwitch->Play(0,0,0); + if (ggLeftEndLightButton.SubModel) + { + ggLeftEndLightButton.PutValue(1); + ggLeftLightButton.PutValue(0); + } + else + ggLeftLightButton.PutValue(-1); + } + if (((DynamicObject->iLights[0])&3)==1) + { + DynamicObject->iLights[0]&=(255-1); + dsbSwitch->SetVolume(DSBVOLUME_MAX); + dsbSwitch->Play(0,0,0); + ggLeftLightButton.PutValue(0); + } + } + else + {//kabina -1 + if (((DynamicObject->iLights[1])&3)==0) + { + DynamicObject->iLights[1]|=2; + dsbSwitch->SetVolume(DSBVOLUME_MAX); + dsbSwitch->Play(0,0,0); + if (ggLeftEndLightButton.SubModel) + { + ggLeftEndLightButton.PutValue(1); + ggLeftLightButton.PutValue(0); + } + else + ggLeftLightButton.PutValue(-1); + } + if (((DynamicObject->iLights[1])&3)==1) + { + DynamicObject->iLights[1]&=(255-1); + dsbSwitch->SetVolume(DSBVOLUME_MAX); + dsbSwitch->Play(0,0,0); + ggLeftLightButton.PutValue(0); + } + } + } + } + else + if (cKey==Global::Keys[k_UpperSign]) //ABu 060205: światło górne - wyłączenie + { + if ((GetAsyncKeyState(VK_CONTROL)<0)&&(ggRearUpperLightButton.SubModel)) //hunter-230112 - z controlem gasi z tylu + { + //------------------------------ + if (mvOccupied->ActiveCab==1) + {//kabina 1 + if (((DynamicObject->iLights[1])&12)==4) + { + DynamicObject->iLights[1]&=(255-4); + dsbSwitch->SetVolume(DSBVOLUME_MAX); + dsbSwitch->Play(0,0,0); + ggRearUpperLightButton.PutValue(0); + } + } + else + {//kabina -1 + if (((DynamicObject->iLights[0])&12)==4) + { + DynamicObject->iLights[0]&=(255-4); + dsbSwitch->SetVolume(DSBVOLUME_MAX); + dsbSwitch->Play(0,0,0); + ggRearUpperLightButton.PutValue(0); + } + } + } //------------------------------ + else + { + if (mvOccupied->ActiveCab==1) + {//kabina 1 + if (((DynamicObject->iLights[0])&12)==4) + { + DynamicObject->iLights[0]&=(255-4); + dsbSwitch->SetVolume(DSBVOLUME_MAX); + dsbSwitch->Play(0,0,0); + ggUpperLightButton.PutValue(0); + } + } + else + {//kabina -1 + if (((DynamicObject->iLights[1])&12)==4) + { + DynamicObject->iLights[1]&=(255-4); + dsbSwitch->SetVolume(DSBVOLUME_MAX); + dsbSwitch->Play(0,0,0); + ggUpperLightButton.PutValue(0); + } + } + } + } + if (cKey==Global::Keys[k_RightSign]) //Winger 070304: swiatla tylne (koncowki) - wlaczenie + { + if ((GetAsyncKeyState(VK_CONTROL)<0)&&(ggRearRightLightButton.SubModel)) //hunter-230112 - z controlem gasi z tylu + { + //------------------------------ + if (mvOccupied->ActiveCab==1) + {//kabina 1 (od strony 0) + if (((DynamicObject->iLights[1])&48)==0) + { + DynamicObject->iLights[1]|=32; + dsbSwitch->SetVolume(DSBVOLUME_MAX); + dsbSwitch->Play(0,0,0); + if (ggRearRightEndLightButton.SubModel) + { + ggRearRightEndLightButton.PutValue(1); + ggRearRightLightButton.PutValue(0); + } + else + ggRearRightLightButton.PutValue(-1); + } + if (((DynamicObject->iLights[1])&48)==16) + { + DynamicObject->iLights[1]&=(255-16); + dsbSwitch->SetVolume(DSBVOLUME_MAX); + dsbSwitch->Play(0,0,0); + ggRearRightLightButton.PutValue(0); + } + } + else + {//kabina -1 + if (((DynamicObject->iLights[0])&48)==0) + { + DynamicObject->iLights[0]|=32; + dsbSwitch->SetVolume(DSBVOLUME_MAX); + dsbSwitch->Play(0,0,0); + if (ggRearRightEndLightButton.SubModel) + { + ggRearRightEndLightButton.PutValue(1); + ggRearRightLightButton.PutValue(0); + } + else + ggRearRightLightButton.PutValue(-1); + } + if (((DynamicObject->iLights[0])&48)==16) + { + DynamicObject->iLights[0]&=(255-16); + dsbSwitch->SetVolume(DSBVOLUME_MAX); + dsbSwitch->Play(0,0,0); + ggRearRightLightButton.PutValue(0); + } + } + } //------------------------------ + else + { + if (mvOccupied->ActiveCab==1) + { //kabina 0 + if (((DynamicObject->iLights[0])&48)==0) + { + DynamicObject->iLights[0]|=32; + dsbSwitch->SetVolume(DSBVOLUME_MAX); + dsbSwitch->Play(0,0,0); + if (ggRightEndLightButton.SubModel) + { + ggRightEndLightButton.PutValue(1); + ggRightLightButton.PutValue(0); + } + else + ggRightLightButton.PutValue(-1); + } + if (((DynamicObject->iLights[0])&48)==16) + { + DynamicObject->iLights[0]&=(255-16); + dsbSwitch->SetVolume(DSBVOLUME_MAX); + dsbSwitch->Play(0,0,0); + ggRightLightButton.PutValue(0); + } + } + else + {//kabina -1 + if (((DynamicObject->iLights[1])&48)==0) + { + DynamicObject->iLights[1]|=32; + dsbSwitch->SetVolume(DSBVOLUME_MAX); + dsbSwitch->Play(0,0,0); + if (ggRightEndLightButton.SubModel) + { + ggRightEndLightButton.PutValue(1); + ggRightLightButton.PutValue(0); + } + else + ggRightLightButton.PutValue(-1); + } + if (((DynamicObject->iLights[1])&48)==16) + { + DynamicObject->iLights[1]&=(255-16); + dsbSwitch->SetVolume(DSBVOLUME_MAX); + dsbSwitch->Play(0,0,0); + ggRightLightButton.PutValue(0); + } + } + } + } + else + if (cKey==Global::Keys[k_StLinOff]) //Winger 110904: wylacznik st. liniowych + { + if ((mvControlled->TrainType!=dt_EZT)&&(mvControlled->TrainType!=dt_EP05)&& (mvControlled->TrainType!=dt_ET40)) + { + ggStLinOffButton.PutValue(1); //Ra: było Fuse... + dsbSwitch->SetVolume(DSBVOLUME_MAX); + dsbSwitch->Play(0,0,0); + if (mvControlled->MainCtrlPosNo>0) + { + mvControlled->StLinFlag=false; //yBARC - zmienione na przeciwne, bo true to zalaczone + dsbRelay->SetVolume(DSBVOLUME_MAX); + dsbRelay->Play(0,0,0); + } + } + if(mvControlled->TrainType==dt_EZT) + { + if(mvControlled->Signalling==true) + { + dsbSwitch->Play(0,0,0); + mvControlled->Signalling=false; + } + } + } + else + { + //McZapkie: poruszanie sie po kabinie, w updatemechpos zawarte sa wiezy + + //double dt=Timer::GetDeltaTime(); + if (mvOccupied->ActiveCab<0) + fMechCroach=-0.5; + else + fMechCroach=0.5; +// if (!GetAsyncKeyState(VK_SHIFT)<0) // bez shifta + if (!Console::Pressed(VK_CONTROL)) //gdy [Ctrl] zwolniony (dodatkowe widoki) + { + if (cKey==Global::Keys[k_MechLeft]) + {vMechMovement.x+=fMechCroach; + if (DynamicObject->Mechanik) + if (!FreeFlyModeFlag) //żeby nie mieszać obserwując z zewnątrz + DynamicObject->Mechanik->RouteSwitch(1); //na skrzyżowaniu skręci w lewo + } + else + if (cKey==Global::Keys[k_MechRight]) + {vMechMovement.x-=fMechCroach; + if (DynamicObject->Mechanik) + if (!FreeFlyModeFlag) //żeby nie mieszać obserwując z zewnątrz + DynamicObject->Mechanik->RouteSwitch(2); //na skrzyżowaniu skręci w prawo + } + else + if (cKey==Global::Keys[k_MechBackward]) + {vMechMovement.z-=fMechCroach; + //if (DynamicObject->Mechanik) + // if (!FreeFlyModeFlag) //żeby nie mieszać obserwując z zewnątrz + // DynamicObject->Mechanik->RouteSwitch(0); //na skrzyżowaniu stanie i poczeka + } + else + if (cKey==Global::Keys[k_MechForward]) + {vMechMovement.z+=fMechCroach; + if (DynamicObject->Mechanik) + if (!FreeFlyModeFlag) //żeby nie mieszać obserwując z zewnątrz + DynamicObject->Mechanik->RouteSwitch(3); //na skrzyżowaniu pojedzie prosto + } + else + if (cKey==Global::Keys[k_MechUp]) + pMechOffset.y+=0.2; //McZapkie-120302 - wstawanie + else + if (cKey==Global::Keys[k_MechDown]) + pMechOffset.y-=0.2; //McZapkie-120302 - siadanie + } + } + + // else + if (DebugModeFlag) + {//przesuwanie składu o 100m + TDynamicObject *d=DynamicObject; + if (cKey==VkKeyScan('[')) + {while (d) + {d->Move(100.0*d->DirectionGet()); + d=d->Next(); //pozostałe też + } + d=DynamicObject->Prev(); + while (d) + {d->Move(100.0*d->DirectionGet()); + d=d->Prev(); //w drugą stronę też + } + } + else + if (cKey==VkKeyScan(']')) + {while (d) + {d->Move(-100.0*d->DirectionGet()); + d=d->Next(); //pozostałe też + } + d=DynamicObject->Prev(); + while (d) + {d->Move(-100.0*d->DirectionGet()); + d=d->Prev(); //w drugą stronę też + } + } + } + if (cKey==VkKeyScan('-')) + {//zmniejszenie numeru kanału radiowego + if (iRadioChannel>0) --iRadioChannel; //0=wyłączony + } + else if (cKey==VkKeyScan('=')) + {//zmniejszenie numeru kanału radiowego + if (iRadioChannel<8) ++iRadioChannel; //0=wyłączony + } + } +} + +void __fastcall TTrain::OnKeyUp(int cKey) +{//zwolnienie klawisza + if (GetAsyncKeyState(VK_SHIFT)<0) + {//wciśnięty [Shift] + } + else + { + if (cKey==Global::Keys[k_StLinOff]) //Winger 110904: wylacznik st. liniowych + {//zwolnienie klawisza daje powrót przycisku do zwykłego stanu + if ((mvControlled->TrainType!=dt_EZT)&&(mvControlled->TrainType!=dt_EP05)&& (mvControlled->TrainType!=dt_ET40)) + ggStLinOffButton.PutValue(0); + } + } +}; + +void __fastcall TTrain::UpdateMechPosition(double dt) +{//Ra: mechanik powinien być telepany niezależnie od pozycji pojazdu + //Ra: trzeba zrobić model bujania głową i wczepić go do pojazdu + + //DynamicObject->vFront=DynamicObject->GetDirection(); //to jest już policzone + + //Ra: tu by się przydało uwzględnić rozkład sił: + // - na postoju horyzont prosto, kabina skosem + // - przy szybkiej jeździe kabina prosto, horyzont pochylony + + vector3 pNewMechPosition; + //McZapkie: najpierw policzę pozycję w/m kabiny + + //ABu: rzucamy kabina tylko przy duzym FPS! + //Mala histereza, zeby bez przerwy nie przelaczalo przy FPS~17 + //Granice mozna ustalic doswiadczalnie. Ja proponuje 14:20 + double r1,r2,r3; + int iVel=DynamicObject->GetVelocity(); + if (iVel>150) iVel=150; + if (!Global::iSlowMotion //musi być pełna prędkość + &&(pMechOffset.y<4.0)) //Ra 15-01: przy oglądaniu pantografu bujanie przeszkadza + { + if (!(random((GetFPS()+1)/15)>0)) + { + if ((iVel>0) && (random(155-iVel)<16)) + { + r1=(double(random(iVel*2)-iVel)/((iVel*2)*4))*fMechSpringX; + r2=(double(random(iVel*2)-iVel)/((iVel*2)*4))*fMechSpringY; + r3=(double(random(iVel*2)-iVel)/((iVel*2)*4))*fMechSpringZ; + MechSpring.ComputateForces(vector3(r1,r2,r3),pMechShake); + // MechSpring.ComputateForces(vector3(double(random(200)-100)/200,double(random(200)-100)/200,double(random(200)-100)/500),pMechShake); + } + else + MechSpring.ComputateForces(vector3(-mvControlled->AccN*dt,mvControlled->AccV*dt*10,-mvControlled->AccS*dt),pMechShake); + } + vMechVelocity-=(MechSpring.vForce2+vMechVelocity*100)*(fMechSpringX+fMechSpringY+fMechSpringZ)/(200); + + //McZapkie: + pMechShake+=vMechVelocity*dt; + //Ra 2015-01: dotychczasowe rzucanie + pMechOffset+=vMechMovement*dt; + if ((pMechShake.y>fMechMaxSpring) || (pMechShake.y<-fMechMaxSpring)) + vMechVelocity.y=-vMechVelocity.y; + //ABu011104: 5*pMechShake.y, zeby ladnie pudlem rzucalo :) + pNewMechPosition=pMechOffset+vector3(pMechShake.x,5*pMechShake.y,pMechShake.z); + vMechMovement=0.5*vMechMovement; + } + else + {//hamowanie rzucania przy spadku FPS + pMechShake-=pMechShake*Min0R(dt,1); //po tym chyba potrafią zostać jakieś ułamki, które powodują zjazd + pMechOffset+=vMechMovement*dt; + vMechVelocity.y=0.5*vMechVelocity.y; + pNewMechPosition=pMechOffset+vector3(pMechShake.x,5*pMechShake.y,pMechShake.z); + vMechMovement=0.5*vMechMovement; + } + //numer kabiny (-1: kabina B) + if (DynamicObject->Mechanik) //może nie być? + if (DynamicObject->Mechanik->AIControllFlag) //jeśli prowadzi AI + {//Ra: przesiadka, jeśli AI zmieniło kabinę (a człon?)... + if (iCabn!=(DynamicObject->MoverParameters->ActiveCab==-1?2:DynamicObject->MoverParameters->ActiveCab)) + InitializeCab(DynamicObject->MoverParameters->ActiveCab,DynamicObject->asBaseDir+DynamicObject->MoverParameters->TypeName+".mmd"); + } + iCabn=(DynamicObject->MoverParameters->ActiveCab==-1?2:DynamicObject->MoverParameters->ActiveCab); + if (!DebugModeFlag) + {//sprawdzaj więzy //Ra: nie tu! + if (pNewMechPosition.xCabine[iCabn].CabPos2.x) pNewMechPosition.x=Cabine[iCabn].CabPos2.x; + if (pNewMechPosition.zCabine[iCabn].CabPos2.z) pNewMechPosition.z=Cabine[iCabn].CabPos2.z; + if (pNewMechPosition.y>Cabine[iCabn].CabPos1.y+1.8) pNewMechPosition.y=Cabine[iCabn].CabPos1.y+1.8; + if (pNewMechPosition.yCabine[iCabn].CabPos2.x) pMechOffset.x=Cabine[iCabn].CabPos2.x; + if (pMechOffset.zCabine[iCabn].CabPos2.z) pMechOffset.z=Cabine[iCabn].CabPos2.z; + if (pMechOffset.y>Cabine[iCabn].CabPos1.y+1.8) pMechOffset.y=Cabine[iCabn].CabPos1.y+1.8; + if (pMechOffset.ymMatrix*pNewMechPosition; //położenie względem środka pojazdu w układzie scenerii + pMechPosition+=DynamicObject->GetPosition(); +}; + +bool __fastcall TTrain::Update() +{ + DWORD stat; + double dt=Timer::GetDeltaTime(); + if (DynamicObject->mdKabina) + {//Ra: TODO: odczyty klawiatury/pulpitu nie powinny być uzależnione od istnienia modelu kabiny + tor=DynamicObject->GetTrack(); //McZapkie-180203 + //McZapkie: predkosc wyswietlana na tachometrze brana jest z obrotow kol + float maxtacho=3; + fTachoVelocity=Min0R(fabs(11.31*mvControlled->WheelDiameter*mvControlled->nrot),mvControlled->Vmax*1.05); + {//skacze osobna zmienna + float ff=floor(GlobalTime->mr); //skacze co sekunde - pol sekundy pomiar, pol sekundy ustawienie + if (ff!=fTachoTimer) //jesli w tej sekundzie nie zmienial + { + if (fTachoVelocity>1) //jedzie + fTachoVelocityJump=fTachoVelocity+(2-random(3)+random(3))*0.5; + else fTachoVelocityJump=0; //stoi + fTachoTimer=ff; //juz zmienil + } + } + if (fTachoVelocity>1) //McZapkie-270503: podkrecanie tachometru + { + if (fTachoCount0) + fTachoCount-=dt*0.66; //schodz powoli - niektore haslery to ze 4 sekundy potrafia stukac + +/* Ra: to by trzeba było przemyśleć, zmienione na szybko problemy robi + //McZapkie: predkosc wyswietlana na tachometrze brana jest z obrotow kol + double vel=fabs(11.31*mvControlled->WheelDiameter*mvControlled->nrot); + if (iSekunda!=floor(GlobalTime->mr)||(vel<1.0)) + {fTachoVelocity=vel; + if (fTachoVelocity>1.0) //McZapkie-270503: podkrecanie tachometru + { + if (fTachoCount0) + fTachoCount-=dt; + if (mvControlled->TrainType==dt_EZT) + //dla EZT wskazówka porusza się niestabilnie + if (fTachoVelocity>7.0) + {fTachoVelocity=floor(0.5+fTachoVelocity+random(5)-random(5)); //*floor(0.2*fTachoVelocity); + if (fTachoVelocity<0.0) fTachoVelocity=0.0; + } + iSekunda=floor(GlobalTime->mr); + } +*/ + //Ra 2014-09: napięcia i prądy muszą być ustalone najpierw, bo wysyłane są ewentualnie na PoKeys + if (mvControlled->EngineType!=DieselElectric) //Ra 2014-09: czy taki rozdział ma sens? + fHVoltage=mvControlled->RunningTraction.TractionVoltage; //Winger czy to nie jest zle? *mvControlled->Mains); + else + fHVoltage=mvControlled->Voltage; + if (ShowNextCurrent) + {//jeśli pokazywać drugi człon + if (mvSecond) + {//o ile jest ten drugi + fHCurrent[0]=mvSecond->ShowCurrent(0)*1.05; + fHCurrent[1]=mvSecond->ShowCurrent(1)*1.05; + fHCurrent[2]=mvSecond->ShowCurrent(2)*1.05; + fHCurrent[3]=mvSecond->ShowCurrent(3)*1.05; + } + else + fHCurrent[0]=fHCurrent[1]=fHCurrent[2]=fHCurrent[3]=0.0; //gdy nie ma człona + } + else + {//normalne pokazywanie + fHCurrent[0]=mvControlled->ShowCurrent(0); + fHCurrent[1]=mvControlled->ShowCurrent(1); + fHCurrent[2]=mvControlled->ShowCurrent(2); + fHCurrent[3]=mvControlled->ShowCurrent(3); + } + if (Global::iFeedbackMode==4) + {//wykonywać tylko gdy wyprowadzone na pulpit + Console::ValueSet(0,mvOccupied->Compressor); //Ra: sterowanie miernikiem: zbiornik główny + Console::ValueSet(1,mvOccupied->PipePress); //Ra: sterowanie miernikiem: przewód główny + Console::ValueSet(2,mvOccupied->BrakePress); //Ra: sterowanie miernikiem: cylinder hamulcowy + Console::ValueSet(3,fHVoltage); //woltomierz wysokiego napięcia + Console::ValueSet(4,fHCurrent[2]); //Ra: sterowanie miernikiem: drugi amperomierz + Console::ValueSet(5,fHCurrent[(mvControlled->TrainType&dt_EZT)?0:1]); //pierwszy amperomierz; dla EZT prąd całkowity + Console::ValueSet(6,fTachoVelocity); ////Ra: prędkość na pin 43 - wyjście analogowe (to nie jest PWM); skakanie zapewnia mechanika napędu + } + + //hunter-080812: wyrzucanie szybkiego na elektrykach gdy nie ma napiecia przy dowolnym ustawieniu kierunkowego + //Ra: to już jest w T_MoverParameters::TractionForce(), ale zależy od kierunku + if (mvControlled->EngineType==ElectricSeriesMotor) + if (fabs(mvControlled->RunningTraction.TractionVoltage)<0.5*mvControlled->EnginePowerSource.MaxVoltage) //minimalne napięcie pobierać z FIZ? + mvControlled->MainSwitch(false); + + //hunter-091012: swiatlo + if (bCabLight==true) + { + if (bCabLightDim==true) + iCabLightFlag=1; + else + iCabLightFlag=2; + } + else iCabLightFlag=0; + + //------------------ + //hunter-261211: nadmiarowy przetwornicy i ogrzewania + //Ra 15-01: to musi stąd wylecieć - zależności nie mogą być w kabinie + if (mvControlled->ConverterFlag==true) + { + fConverterTimer+=dt; + if ((mvControlled->CompressorFlag==true)&&(mvControlled->CompressorPower==1)&&((mvControlled->EngineType==ElectricSeriesMotor)||(mvControlled->TrainType==dt_EZT))&&(DynamicObject->Controller==Humandriver)) //hunter-110212: poprawka dla EZT + { //hunter-091012: poprawka (zmiana warunku z CompressorPower /rozne od 0/ na /rowne 1/) + if (fConverterTimerConvOvldFlag=true; + mvControlled->MainSwitch(false); + } + else if (fConverterTimer>=fConverterPrzekaznik) + mvControlled->CompressorSwitch(true); + } + } + else + fConverterTimer=0; + //------------------ + + + double vol=0; +// int freq=1; + double dfreq; + +//McZapkie-280302 - syczenie + if ((mvOccupied->BrakeHandle==FV4a)||(mvOccupied->BrakeHandle==FVel6)) + { + if (rsHiss.AM!=0) //upuszczanie z PG + { + fPPress=(1*fPPress+mvOccupied->Handle->GetSound(s_fv4a_b))/(2); + if (fPPress>0) + { + vol=2*rsHiss.AM*fPPress; + } + if (vol>0.001) + { + rsHiss.Play(vol,DSBPLAY_LOOPING,true,DynamicObject->GetPosition()); + } + else + { + rsHiss.Stop(); + } + } + if (rsHissU.AM!=0) //upuszczanie z PG + { + fNPress=(1*fNPress+mvOccupied->Handle->GetSound(s_fv4a_u))/(2); + if (fNPress>0) + { + vol=rsHissU.AM*fNPress; + } + if (vol>0.001) + { + rsHissU.Play(vol,DSBPLAY_LOOPING,true,DynamicObject->GetPosition()); + } + else + { + rsHissU.Stop(); + } + } + if (rsHissE.AM!=0) //upuszczanie przy naglym + { + vol=mvOccupied->Handle->GetSound(s_fv4a_e)*rsHissE.AM; + if (vol>0.001) + { + rsHissE.Play(vol,DSBPLAY_LOOPING,true,DynamicObject->GetPosition()); + } + else + { + rsHissE.Stop(); + } + } + if (rsHissX.AM!=0) //upuszczanie sterujacego fala + { + vol=mvOccupied->Handle->GetSound(s_fv4a_x)*rsHissX.AM; + if (vol>0.001) + { + rsHissX.Play(vol,DSBPLAY_LOOPING,true,DynamicObject->GetPosition()); + } + else + { + rsHissX.Stop(); + } + } + if (rsHissT.AM!=0) //upuszczanie z czasowego + { + vol=mvOccupied->Handle->GetSound(s_fv4a_t)*rsHissT.AM; + if (vol>0.001) + { + rsHissT.Play(vol,DSBPLAY_LOOPING,true,DynamicObject->GetPosition()); + } + else + { + rsHissT.Stop(); + } + } + + } //koniec FV4a + else //jesli nie FV4a + { + if (rsHiss.AM!=0) //upuszczanie z PG + { + fPPress=(4*fPPress+Max0R(mvOccupied->dpLocalValve,mvOccupied->dpMainValve))/(4+1); + if (fPPress>0) + { + vol=2*rsHiss.AM*fPPress*0.01; + } + if (vol>0.01) + { + rsHiss.Play(vol,DSBPLAY_LOOPING,true,DynamicObject->GetPosition()); + } + else + { + rsHiss.Stop(); + } + } + if (rsHissU.AM!=0) //napelnianie PG + { + fNPress=(4*fNPress+Min0R(mvOccupied->dpLocalValve,mvOccupied->dpMainValve))/(4+1); + if (fNPress<0) + { + vol=-2*rsHissU.AM*fNPress*0.004; + } + if (vol>0.01) + { + rsHissU.Play(vol,DSBPLAY_LOOPING,true,DynamicObject->GetPosition()); + } + else + { + rsHissU.Stop(); + } + } + } //koniec nie FV4a + +//Winger-160404 - syczenie pomocniczego (luzowanie) +/* if (rsSBHiss.AM!=0) + { + fSPPress=(mvOccupied->LocalBrakeRatio())-(mvOccupied->LocalBrakePos); + if (fSPPress>0) + { + vol=2*rsSBHiss.AM*fSPPress; + } + if (vol>0.1) + { + rsSBHiss.Play(vol,DSBPLAY_LOOPING,true,DynamicObject->GetPosition()); + } + else + { + rsSBHiss.Stop(); + } + } +*/ +//szum w czasie jazdy + vol=0.0; + dfreq=1.0; + if (rsRunningNoise.AM!=0) + { + if (DynamicObject->GetVelocity()!=0) + { + if (!TestFlag(mvOccupied->DamageFlag,dtrain_wheelwear)) //McZpakie-221103: halas zalezny od kola + { + dfreq=rsRunningNoise.FM*mvOccupied->Vel+rsRunningNoise.FA; + vol=rsRunningNoise.AM*mvOccupied->Vel+rsRunningNoise.AA; + switch (tor->eEnvironment) + { + case e_tunnel: + { + vol*=3; + dfreq*=0.95; + } + break; + case e_canyon: + { + vol*=1.1; + } + break; + case e_bridge: + { + vol*=2; + dfreq*=0.98; + } + break; + } + + } + else //uszkodzone kolo (podkucie) + if (fabs(mvOccupied->nrot)>0.01) + { + dfreq=rsRunningNoise.FM*mvOccupied->Vel+rsRunningNoise.FA; + vol=rsRunningNoise.AM*mvOccupied->Vel+rsRunningNoise.AA; + switch (tor->eEnvironment) + { + case e_tunnel: + { + vol*=2; + } + break; + case e_canyon: + { + vol*=1.1; + } + break; + case e_bridge: + { + vol*=1.5; + } + break; + } + } + if (fabs(mvOccupied->nrot)>0.01) + vol*=1+mvOccupied->UnitBrakeForce/(1+mvOccupied->MaxBrakeForce); //hamulce wzmagaja halas + vol=vol*(20.0+tor->iDamageFlag)/21; + rsRunningNoise.AdjFreq(dfreq,0); + rsRunningNoise.Play(vol, DSBPLAY_LOOPING, true, DynamicObject->GetPosition()); + } + else + rsRunningNoise.Stop(); + } + + if (rsBrake.AM!=0) + { + if ((!mvOccupied->SlippingWheels) && (mvOccupied->UnitBrakeForce>10.0) && (DynamicObject->GetVelocity()>0.01)) + { +// vol=rsBrake.AA+rsBrake.AM*(DynamicObject->GetVelocity()*100+mvOccupied->UnitBrakeForce); + vol=rsBrake.AM*sqrt((DynamicObject->GetVelocity()*mvOccupied->UnitBrakeForce)); + dfreq=rsBrake.FA+rsBrake.FM*DynamicObject->GetVelocity(); + rsBrake.AdjFreq(dfreq,0); + rsBrake.Play(vol,DSBPLAY_LOOPING,true,DynamicObject->GetPosition()); + } + else + { + rsBrake.Stop(); + } + } + + + if (rsEngageSlippery.AM!=0) + { + if /*((fabs(mvControlled->dizel_engagedeltaomega)>0.2) && */ (mvControlled->dizel_engage>0.1) + { + if (fabs(mvControlled->dizel_engagedeltaomega)>0.2) + { + dfreq=rsEngageSlippery.FA+rsEngageSlippery.FM*fabs(mvControlled->dizel_engagedeltaomega); + vol=rsEngageSlippery.AA+rsEngageSlippery.AM*(mvControlled->dizel_engage); + } + else + { + dfreq=1; //rsEngageSlippery.FA+0.7*rsEngageSlippery.FM*(fabs(mvControlled->enrot)+mvControlled->nmax); + if (mvControlled->dizel_engage>0.2) + vol=rsEngageSlippery.AA+0.2*rsEngageSlippery.AM*(mvControlled->enrot/mvControlled->nmax); + else + vol=0; + } + rsEngageSlippery.AdjFreq(dfreq,0); + rsEngageSlippery.Play(vol,DSBPLAY_LOOPING,true,DynamicObject->GetPosition()); + } + else + { + rsEngageSlippery.Stop(); + } + } + + if (FreeFlyModeFlag) + rsFadeSound.Stop(); //wyłącz to cholerne cykanie! + else + rsFadeSound.Play(1,DSBPLAY_LOOPING,true,DynamicObject->GetPosition()); + +// McZapkie! - to wazne - SoundFlag wystawiane jest przez moje moduly +// gdy zachodza pewne wydarzenia komentowane dzwiekiem. +// Mysle ze wystarczy sprawdzac a potem zerowac SoundFlag tutaj +// a nie w DynObject - gdyby cos poszlo zle to po co szarpac dzwiekiem co 10ms. + + if (TestFlag(mvOccupied->SoundFlag,sound_relay)) // przekaznik - gdy bezpiecznik, automatyczny rozruch itp + { + if (mvOccupied->EventFlag || TestFlag(mvOccupied->SoundFlag,sound_loud)) + { + mvOccupied->EventFlag=false; //Ra: w kabinie? + dsbRelay->SetVolume(DSBVOLUME_MAX); + } + else + { + dsbRelay->SetVolume(-40); + } + if (!TestFlag(mvOccupied->SoundFlag,sound_manyrelay)) + dsbRelay->Play(0,0,0); + else + { + if (TestFlag(mvOccupied->SoundFlag,sound_loud)) + dsbWejscie_na_bezoporow->Play(0,0,0); + else + dsbWejscie_na_drugi_uklad->Play(0,0,0); + } + } + // potem dorobic bufory, sprzegi jako RealSound. + if (TestFlag(mvOccupied->SoundFlag,sound_bufferclamp)) // zderzaki uderzaja o siebie + { + if (TestFlag(mvOccupied->SoundFlag,sound_loud)) + dsbBufferClamp->SetVolume(DSBVOLUME_MAX); + else + dsbBufferClamp->SetVolume(-20); + dsbBufferClamp->Play(0,0,0); + } + if (dsbCouplerStretch) + if (TestFlag(mvOccupied->SoundFlag,sound_couplerstretch)) // sprzegi sie rozciagaja + { + if (TestFlag(mvOccupied->SoundFlag,sound_loud)) + dsbCouplerStretch->SetVolume(DSBVOLUME_MAX); + else + dsbCouplerStretch->SetVolume(-20); + dsbCouplerStretch->Play(0,0,0); + } + + if (mvOccupied->SoundFlag==0) + if (mvOccupied->EventFlag) + if (TestFlag(mvOccupied->DamageFlag,dtrain_wheelwear)) + {//Ra: przenieść do DynObj! + if (rsRunningNoise.AM!=0) + { + rsRunningNoise.Stop(); + //float aa=rsRunningNoise.AA; + float am=rsRunningNoise.AM; + float fa=rsRunningNoise.FA; + float fm=rsRunningNoise.FM; + rsRunningNoise.Init("lomotpodkucia.wav",-1,0,0,0,true); //MC: zmiana szumu na lomot + if (rsRunningNoise.AM==1) + rsRunningNoise.AM=am; + rsRunningNoise.AA=0.7; + rsRunningNoise.FA=fa; + rsRunningNoise.FM-fm; + } + mvOccupied->EventFlag=false; + } + + mvOccupied->SoundFlag=0; +/* + for (int b=0; b<2; b++) //MC: aby zerowac stukanie przekaznikow w czlonie silnikowym + if (TestFlag(mvControlled->Couplers[b].CouplingFlag,ctrain_controll)) + if (mvControlled->Couplers[b].Connected.Power>0.01) + mvControlled->Couplers[b]->Connected->SoundFlag=0; +*/ + + // McZapkie! - koniec obslugi dzwiekow z mover.pas + +//youBy - prad w drugim czlonie: galaz lub calosc +{ + TDynamicObject *tmp; + tmp=NULL; + if (DynamicObject->NextConnected) + if ((TestFlag(mvControlled->Couplers[1].CouplingFlag,ctrain_controll)) && (mvOccupied->ActiveCab==1)) + tmp=DynamicObject->NextConnected; + if (DynamicObject->PrevConnected) + if ((TestFlag(mvControlled->Couplers[0].CouplingFlag,ctrain_controll)) && (mvOccupied->ActiveCab==-1)) + tmp=DynamicObject->PrevConnected; + if (tmp) + if (tmp->MoverParameters->Power>0) + { + if (ggI1B.SubModel) + { + ggI1B.UpdateValue(tmp->MoverParameters->ShowCurrent(1)); + ggI1B.Update(); + } + if (ggI2B.SubModel) + { + ggI2B.UpdateValue(tmp->MoverParameters->ShowCurrent(2)); + ggI2B.Update(); + } + if (ggI3B.SubModel) + { + ggI3B.UpdateValue(tmp->MoverParameters->ShowCurrent(3)); + ggI3B.Update(); + } + if (ggItotalB.SubModel) + { + ggItotalB.UpdateValue(tmp->MoverParameters->ShowCurrent(0)); + ggItotalB.Update(); + } + } +} +/* +//McZapkie-240302 ggVelocity.UpdateValue(DynamicObject->GetVelocity()); + //fHaslerTimer+=dt; + //if (fHaslerTimer>fHaslerTime) + {//Ra: ryzykowne jest to, gdyż może się nie uaktualniać prędkość + //Ra: prędkość się powinna zaokrąglać tam gdzie się liczy fTachoVelocity + if (ggVelocity.SubModel) + {//ZiomalCl: wskazanie Haslera w kabinie A ze zwloka czasowa oraz odpowiednia tolerancja + //Nalezy sie zastanowic na przyszlosc nad rozroznieniem predkosciomierzy (dokladnosc wskazan, zwloka czasowa wskazania, inne funkcje) + //ZiomalCl: W ezt typu stare EN57 wskazania haslera sa mniej dokladne (linka) + //ggVelocity.UpdateValue(fTachoVelocity>2?fTachoVelocity+0.5-random(mvControlled->TrainType==dt_EZT?5:2)/2:0); + ggVelocity.UpdateValue(Min0R(fTachoVelocity,mvControlled->Vmax*1.05)); //ograniczenie maksymalnego wskazania na analogowym + ggVelocity.Update(); + } + if (ggVelocityDgt.SubModel) + {//Ra 2014-07: prędkościomierz cyfrowy + ggVelocityDgt.UpdateValue(fTachoVelocity); + ggVelocityDgt.Update(); + } + if (ggVelocity_B.SubModel) + {//ZiomalCl: wskazanie Haslera w kabinie B ze zwloka czasowa oraz odpowiednia tolerancja + //Nalezy sie zastanowic na przyszlosc nad rozroznieniem predkosciomierzy (dokladnosc wskazan, zwloka czasowa wskazania, inne funkcje) + //Velocity_B.UpdateValue(fTachoVelocity>2?fTachoVelocity+0.5-random(mvControlled->TrainType==dt_EZT?5:2)/2:0); + ggVelocity_B.UpdateValue(fTachoVelocity); + ggVelocity_B.Update(); + } + //fHaslerTimer-=fHaslerTime; //1.2s (???) + } +*/ +//McZapkie-300302: zegarek + if (ggClockMInd.SubModel) + { + ggClockSInd.UpdateValue(int(GlobalTime->mr)); + ggClockSInd.Update(); + ggClockMInd.UpdateValue(GlobalTime->mm); + ggClockMInd.Update(); + ggClockHInd.UpdateValue(GlobalTime->hh+GlobalTime->mm/60.0); + ggClockHInd.Update(); + } + + Cabine[iCabn].Update(); //nowy sposób ustawienia animacji + if (ggZbS.SubModel) + { + ggZbS.UpdateValue(mvOccupied->Handle->GetCP()); + ggZbS.Update(); + } + +//youBy - napiecie na silnikach + if (ggEngineVoltage.SubModel) + { + if (mvControlled->DynamicBrakeFlag) + { ggEngineVoltage.UpdateValue(abs(mvControlled->Im*5)); } + else + { + int x; + if ((mvControlled->TrainType==dt_ET42)&&(mvControlled->Imax==mvControlled->ImaxHi)) + x=1;else x=2; + if ((mvControlled->RList[mvControlled->MainCtrlActualPos].Mn>0) && (abs(mvControlled->Im)>0)) + { ggEngineVoltage.UpdateValue((x*(mvControlled->RunningTraction.TractionVoltage-mvControlled->RList[mvControlled->MainCtrlActualPos].R*abs(mvControlled->Im))/mvControlled->RList[mvControlled->MainCtrlActualPos].Mn)); } + else + { ggEngineVoltage.UpdateValue(0); }} + ggEngineVoltage.Update(); + } + +//Winger 140404 - woltomierz NN + if (ggLVoltage.SubModel) + { + if (mvControlled->Battery==true) + ggLVoltage.UpdateValue(mvControlled->BatteryVoltage); + else + ggLVoltage.UpdateValue(0); + ggLVoltage.Update(); + } + + if (mvControlled->EngineType==DieselElectric) + {//ustawienie zmiennych dla silnika spalinowego + fEngine[1]=mvControlled->ShowEngineRotation(1); + fEngine[2]=mvControlled->ShowEngineRotation(2); + //if (ggEnrot1m.SubModel) + //{ + // ggEnrot1m.UpdateValue(mvControlled->ShowEngineRotation(1)); + // ggEnrot1m.Update(); + //} + //if (ggEnrot2m.SubModel) + //{ + // ggEnrot2m.UpdateValue(mvControlled->ShowEngineRotation(2)); + // ggEnrot2m.Update(); + //} + } + + + + else if (mvControlled->EngineType==DieselEngine) + {//albo dla innego spalinowego + fEngine[1]=mvControlled->ShowEngineRotation(1); + fEngine[2]=mvControlled->ShowEngineRotation(2); + fEngine[3]=mvControlled->ShowEngineRotation(3); + //if (ggEnrot1m.SubModel) + //{ + // ggEnrot1m.UpdateValue(mvControlled->ShowEngineRotation(1)); + // ggEnrot1m.Update(); + //} + //if (ggEnrot2m.SubModel) + //{ + // ggEnrot2m.UpdateValue(mvControlled->ShowEngineRotation(2)); + // ggEnrot2m.Update(); + //} + //if (ggEnrot3m.SubModel) + // if (mvControlled->Couplers[1].Connected) + // { + // ggEnrot3m.UpdateValue(mvControlled->ShowEngineRotation(3)); + // ggEnrot3m.Update(); + // } + //if (ggEngageRatio.SubModel) + //{ + // ggEngageRatio.UpdateValue(mvControlled->dizel_engage); + // ggEngageRatio.Update(); + //} + if (ggMainGearStatus.SubModel) + { + if (mvControlled->Mains) + ggMainGearStatus.UpdateValue(1.1-fabs(mvControlled->dizel_automaticgearstatus)); + else + ggMainGearStatus.UpdateValue(0); + ggMainGearStatus.Update(); + } + if (ggIgnitionKey.SubModel) + { + ggIgnitionKey.UpdateValue(mvControlled->dizel_enginestart); + ggIgnitionKey.Update(); + } + } + + if (mvControlled->SlippingWheels) + {//Ra 2014-12: lokomotywy 181/182 dostają SlippingWheels po zahamowaniu powyżej 2.85 bara i buczały + double veldiff=(DynamicObject->GetVelocity()-fTachoVelocity)/mvControlled->Vmax; + if (veldiff<-0.01) //1% Vmax rezerwy, żeby 181/182 nie buczały po zahamowaniu, ale to proteza + { + if (fabs(mvControlled->Im)>10.0) + btLampkaPoslizg.TurnOn(); + rsSlippery.Play(-rsSlippery.AM*veldiff+rsSlippery.AA,DSBPLAY_LOOPING,true,DynamicObject->GetPosition()); + if (mvControlled->TrainType==dt_181) //alarm przy poslizgu dla 181/182 - BOMBARDIER + if (dsbSlipAlarm) dsbSlipAlarm->Play(0,0,DSBPLAY_LOOPING); + } + else + { + if ((mvOccupied->UnitBrakeForce>100.0) && (DynamicObject->GetVelocity()>1.0)) + { + rsSlippery.Play(rsSlippery.AM*veldiff+rsSlippery.AA,DSBPLAY_LOOPING,true,DynamicObject->GetPosition()); + if (mvControlled->TrainType==dt_181) + if (dsbSlipAlarm) dsbSlipAlarm->Stop(); + } + } + } + else + { + btLampkaPoslizg.TurnOff(); + rsSlippery.Stop(); + if (mvControlled->TrainType==dt_181) + if (dsbSlipAlarm) dsbSlipAlarm->Stop(); + } + + if (mvControlled->Mains) + { + btLampkaWylSzybki.TurnOn(); + btLampkaOpory.Turn(mvControlled->StLinFlag?mvControlled->ResistorsFlagCheck():false); + btLampkaBezoporowa.Turn(mvControlled->ResistorsFlagCheck()||(mvControlled->MainCtrlActualPos==0)); //do EU04 + if ( (mvControlled->Itot!=0) || (mvOccupied->BrakePress > 2) || ( mvOccupied->PipePress < 3.6 )) + btLampkaStyczn.TurnOff(); //Ra: czy to jest udawanie działania styczników liniowych? + else + if (mvOccupied->BrakePress < 1) + btLampkaStyczn.TurnOn(); //mozna prowadzic rozruch + if (((TestFlag(mvControlled->Couplers[1].CouplingFlag,ctrain_controll)) && (mvControlled->CabNo==1)) || + ((TestFlag(mvControlled->Couplers[0].CouplingFlag,ctrain_controll)) && (mvControlled->CabNo==-1))) + btLampkaUkrotnienie.TurnOn(); + else + btLampkaUkrotnienie.TurnOff(); + +// if ((TestFlag(mvControlled->BrakeStatus,+b_Rused+b_Ractive)))//Lampka drugiego stopnia hamowania + btLampkaHamPosp.Turn((TestFlag(mvOccupied->BrakeStatus,1))) ;//lampka drugiego stopnia hamowania //TODO: youBy wyciągnąć flagę wysokiego stopnia + + //hunter-111211: wylacznik cisnieniowy - Ra: tutaj? w kabinie? //yBARC - omujborzegrzesiuzniszczylesmicalydzien +// if (mvControlled->TrainType!=dt_EZT) +// if (((mvOccupied->BrakePress > 2) || ( mvOccupied->PipePress < 3.6 )) && ( mvControlled->MainCtrlPos != 0 )) +// mvControlled->StLinFlag=true; + //------- + + //hunter-121211: lampka zanikowo-pradowego wentylatorow: + btLampkaNadmWent.Turn((mvControlled->RventRot<5.0)&&mvControlled->ResistorsFlagCheck()); + //------- + + btLampkaNadmSil.Turn(mvControlled->FuseFlagCheck()); + btLampkaWysRozr.Turn(mvControlled->Imax==mvControlled->ImaxHi); + if ((( mvControlled->ScndCtrlActualPos > 0) || ( (mvControlled->RList[mvControlled->MainCtrlActualPos].ScndAct!=0)&&(mvControlled->RList[mvControlled->MainCtrlActualPos].ScndAct!=255)))&&(!mvControlled->DelayCtrlFlag)) + btLampkaBoczniki.TurnOn(); + else + btLampkaBoczniki.TurnOff(); + + + btLampkaNapNastHam.Turn(mvControlled->ActiveDir!=0); //napiecie na nastawniku hamulcowym + btLampkaSprezarka.Turn(mvControlled->CompressorFlag); //mutopsitka dziala + //boczniki + unsigned char scp; //Ra: dopisałem "unsigned" + //Ra: w SU45 boczniki wchodzą na MainCtrlPos, a nie na MainCtrlActualPos - pokićkał ktoś? + scp=mvControlled->RList[mvControlled->MainCtrlPos].ScndAct; + scp=(scp==255?0:scp); //Ra: whatta hella is this? + if ((mvControlled->ScndCtrlPos>0)||(mvControlled->ScndInMain)&&(scp>0)) + {//boczniki pojedynczo + btLampkaBocznik1.TurnOn(); + btLampkaBocznik2.Turn(mvControlled->ScndCtrlPos>1); + btLampkaBocznik3.Turn(mvControlled->ScndCtrlPos>2); + btLampkaBocznik4.Turn(mvControlled->ScndCtrlPos>3); + } + else + {//wyłączone wszystkie cztery + btLampkaBocznik1.TurnOff(); + btLampkaBocznik2.TurnOff(); + btLampkaBocznik3.TurnOff(); + btLampkaBocznik4.TurnOff(); + } +/* + { //sprezarka w drugim wozie + bool comptemp=false; + if (DynamicObject->NextConnected) + if (TestFlag(mvControlled->Couplers[1].CouplingFlag,ctrain_controll)) + comptemp=DynamicObject->NextConnected->MoverParameters->CompressorFlag; + if ((DynamicObject->PrevConnected) && (!comptemp)) + if (TestFlag(mvControlled->Couplers[0].CouplingFlag,ctrain_controll)) + comptemp=DynamicObject->PrevConnected->MoverParameters->CompressorFlag; + btLampkaSprezarkaB.Turn(comptemp); +*/ + } + else //wylaczone + { + btLampkaWylSzybki.TurnOff(); + btLampkaOpory.TurnOff(); + btLampkaStyczn.TurnOff(); + btLampkaNadmSil.TurnOff(); + btLampkaUkrotnienie.TurnOff(); + btLampkaHamPosp.TurnOff(); + btLampkaBoczniki.TurnOff(); + btLampkaNapNastHam.TurnOff(); + btLampkaSprezarka.TurnOff(); + btLampkaBezoporowa.TurnOff(); + } +if ( mvControlled->Signalling==true ) + { + + if ((mvOccupied->BrakePress>=0.145f)&&(mvControlled->Battery==true)&&(mvControlled->Signalling==true)) + { btLampkaHamowanie1zes.TurnOn(); } + if (mvControlled->BrakePress<0.075f) + { btLampkaHamowanie1zes.TurnOff(); } + } + else + { + btLampkaHamowanie1zes.TurnOff(); + } + btLampkaBlokadaDrzwi.Turn(mvControlled->DoorSignalling?mvOccupied->DoorBlockedFlag()&&mvControlled->Battery:false); + + + + +{ //yB - wskazniki drugiego czlonu + TDynamicObject *tmp; //=mvControlled->mvSecond; //Ra 2014-07: trzeba to jeszcze wyjąć z kabiny... +// Ra 2014-07: no nie ma potrzeby szukać tego w każdej klatce + tmp=NULL; + if ((TestFlag(mvControlled->Couplers[1].CouplingFlag,ctrain_controll)) && (mvOccupied->ActiveCab>0)) + tmp=DynamicObject->NextConnected; + if ((TestFlag(mvControlled->Couplers[0].CouplingFlag,ctrain_controll)) && (mvOccupied->ActiveCab<0)) + tmp=DynamicObject->PrevConnected; + + if (tmp) + if (tmp->MoverParameters->Mains) + { + btLampkaWylSzybkiB.TurnOn(); + btLampkaOporyB.Turn(tmp->MoverParameters->ResistorsFlagCheck()); + btLampkaBezoporowaB.Turn(tmp->MoverParameters->ResistorsFlagCheck()||(tmp->MoverParameters->MainCtrlActualPos==0)); //do EU04 + if ( (tmp->MoverParameters->Itot!=0) || (tmp->MoverParameters->BrakePress > 0.2) || ( tmp->MoverParameters->PipePress < 0.36 )) + btLampkaStycznB.TurnOff(); // + else + if (tmp->MoverParameters->BrakePress < 0.1) + btLampkaStycznB.TurnOn(); //mozna prowadzic rozruch + + //----------------- +// //hunter-271211: brak jazdy w drugim czlonie, gdy w pierwszym tez nie ma (i odwrotnie) - Ra: tutaj? w kabinie? +// if (tmp->MoverParameters->TrainType!=dt_EZT) +// if (((tmp->MoverParameters->BrakePress > 2) || ( tmp->MoverParameters->PipePress < 3.6 )) && ( tmp->MoverParameters->MainCtrlPos != 0 )) +// { +// tmp->MoverParameters->MainCtrlActualPos=0; //inaczej StLinFlag nie zmienia sie na false w drugim pojezdzie +// //tmp->MoverParameters->StLinFlag=true; +// mvControlled->StLinFlag=true; +// } +// if (mvControlled->StLinFlag==true) +// tmp->MoverParameters->MainCtrlActualPos=0; //tmp->MoverParameters->StLinFlag=true; + + //----------------- + //hunter-271211: sygnalizacja poslizgu w pierwszym pojezdzie, gdy wystapi w drugim + btLampkaPoslizg.Turn(tmp->MoverParameters->SlippingWheels); + //----------------- + + + btLampkaSprezarkaB.Turn(tmp->MoverParameters->CompressorFlag); //mutopsitka dziala + if (( tmp->MoverParameters->BrakePress>=0.145f*10 )&&(mvControlled->Battery==true)&&(mvControlled->Signalling==true)) + { btLampkaHamowanie2zes.TurnOn(); } + if(( tmp->MoverParameters->BrakePress<0.075f*10 )|| (mvControlled->Battery==false)||(mvControlled->Signalling==false)) + { btLampkaHamowanie2zes.TurnOff(); } + btLampkaNadmPrzetwB.Turn(tmp->MoverParameters->ConvOvldFlag); //nadmiarowy przetwornicy? + btLampkaPrzetwB.Turn(!tmp->MoverParameters->ConverterFlag); //zalaczenie przetwornicy + } + else //wylaczone + { + btLampkaWylSzybkiB.TurnOff(); + btLampkaOporyB.TurnOff(); + btLampkaStycznB.TurnOff(); + btLampkaSprezarkaB.TurnOff(); + btLampkaBezoporowaB.TurnOff(); + btLampkaHamowanie2zes.TurnOff(); + btLampkaNadmPrzetwB.TurnOn(); + btLampkaPrzetwB.TurnOff(); + } + + //hunter-261211: jakis stary kod (i niezgodny z prawda), zahaszowalem + //if (tmp) + // if (tmp->MoverParameters->ConverterFlag==true) + // btLampkaNadmPrzetwB.TurnOff(); + // else + // btLampkaNadmPrzetwB.TurnOn(); + +} //**************************************************** */ + if (mvControlled->Battery) + { + switch (mvControlled->TrainType) + {//zależnie od typu lokomotywy + case dt_EZT: + btLampkaHamienie.Turn((mvControlled->BrakePress>=0.2)&&mvControlled->Signalling); break; + case dt_ET41: //odhamowanie drugiego członu + if (mvSecond) //bo może komuś przyjść do głowy jeżdżenie jednym członem + btLampkaHamienie.Turn(mvSecond->BrakePress<0.4); + break; + default: + btLampkaHamienie.Turn((mvOccupied->BrakePress>=0.1)||mvControlled->DynamicBrakeFlag); + } + //KURS90 + btLampkaMaxSila.Turn(abs(mvControlled->Im)>=350); + btLampkaPrzekrMaxSila.Turn(abs(mvControlled->Im)>=450); + btLampkaRadio.Turn(mvControlled->Radio); + btLampkaHamulecReczny.Turn(mvOccupied->ManualBrakePos>0); + //NBMX wrzesien 2003 - drzwi oraz sygnał odjazdu + btLampkaDoorLeft.Turn(mvOccupied->DoorLeftOpened); + btLampkaDoorRight.Turn(mvOccupied->DoorRightOpened); + btLampkaNapNastHam.Turn((mvControlled->ActiveDir!=0)&&(mvOccupied->EpFuse)); //napiecie na nastawniku hamulcowym + btLampkaForward.Turn(mvControlled->ActiveDir>0); //jazda do przodu + btLampkaBackward.Turn(mvControlled->ActiveDir<0); //jazda do tyłu + } + else + {//gdy bateria wyłączona + btLampkaHamienie.TurnOff(); + btLampkaMaxSila.TurnOff(); + btLampkaPrzekrMaxSila.TurnOff(); + btLampkaRadio.TurnOff(); + btLampkaHamulecReczny.TurnOff(); + btLampkaDoorLeft.TurnOff(); + btLampkaDoorRight.TurnOff(); + btLampkaNapNastHam.TurnOff(); + btLampkaForward.TurnOff(); + btLampkaBackward.TurnOff(); + } +//McZapkie-080602: obroty (albo translacje) regulatorow + if (ggMainCtrl.SubModel) + { + if (mvControlled->CoupledCtrl) + ggMainCtrl.UpdateValue(double(mvControlled->MainCtrlPos+mvControlled->ScndCtrlPos)); + else + ggMainCtrl.UpdateValue(double(mvControlled->MainCtrlPos)); + ggMainCtrl.Update(); + } + if (ggMainCtrlAct.SubModel) + { + if (mvControlled->CoupledCtrl) + ggMainCtrlAct.UpdateValue(double(mvControlled->MainCtrlActualPos+mvControlled->ScndCtrlActualPos)); + else + ggMainCtrlAct.UpdateValue(double(mvControlled->MainCtrlActualPos)); + ggMainCtrlAct.Update(); + } + if (ggScndCtrl.SubModel) + {//Ra: od byte odejmowane boolean i konwertowane potem na double? + ggScndCtrl.UpdateValue(double(mvControlled->ScndCtrlPos-((mvControlled->TrainType==dt_ET42)&&mvControlled->DynamicBrakeFlag))); + ggScndCtrl.Update(); + } + if (ggDirKey.SubModel) + { + if (mvControlled->TrainType!=dt_EZT) + ggDirKey.UpdateValue(double(mvControlled->ActiveDir)); + else + ggDirKey.UpdateValue(double(mvControlled->ActiveDir)+ + double(mvControlled->Imin== + mvControlled->IminHi)); + ggDirKey.Update(); + } + if (ggBrakeCtrl.SubModel) + {if (DynamicObject->Mechanik?(DynamicObject->Mechanik->AIControllFlag?false:Global::iFeedbackMode==4):false) //nie blokujemy AI + {//Ra: nie najlepsze miejsce, ale na początek gdzieś to dać trzeba + double b=Console::AnalogGet(0); //odczyt z pulpitu i modyfikacja pozycji kranu + if ((b>=0.0)&&((mvOccupied->BrakeHandle==FV4a)||(mvOccupied->BrakeHandle==FVel6))) //może można usunąć ograniczenie do FV4a i FVel6? + {b=(((Global::fCalibrateIn[0][3]*b)+Global::fCalibrateIn[0][2])*b+Global::fCalibrateIn[0][1])*b+Global::fCalibrateIn[0][0]; + if (b<-2.0) b=-2.0; else if (b>mvOccupied->BrakeCtrlPosNo) b=mvOccupied->BrakeCtrlPosNo; + ggBrakeCtrl.UpdateValue(b); //przesów bez zaokrąglenia + mvOccupied->BrakeLevelSet(b); + } + //else //standardowa prodedura z kranem powiązanym z klawiaturą + // ggBrakeCtrl.UpdateValue(double(mvOccupied->BrakeCtrlPos)); + } + //else //standardowa prodedura z kranem powiązanym z klawiaturą + // ggBrakeCtrl.UpdateValue(double(mvOccupied->BrakeCtrlPos)); + ggBrakeCtrl.UpdateValue(mvOccupied->fBrakeCtrlPos); + ggBrakeCtrl.Update(); + } + if (ggLocalBrake.SubModel) + {if (DynamicObject->Mechanik?(DynamicObject->Mechanik->AIControllFlag?false:Global::iFeedbackMode==4):false) //nie blokujemy AI + {//Ra: nie najlepsze miejsce, ale na początek gdzieś to dać trzeba + double b=Console::AnalogGet(1); //odczyt z pulpitu i modyfikacja pozycji kranu + if ((b>=0.0)&&(mvOccupied->BrakeLocHandle==FD1)) + {b=(((Global::fCalibrateIn[1][3]*b)+Global::fCalibrateIn[1][2])*b+Global::fCalibrateIn[1][1])*b+Global::fCalibrateIn[1][0]; + if (b<0.0) b=0.0; else if (b>Hamulce::LocalBrakePosNo) b=Hamulce::LocalBrakePosNo; + ggLocalBrake.UpdateValue(b); //przesów bez zaokrąglenia + mvOccupied->LocalBrakePos=int(1.09*b); //sposób zaokrąglania jest do ustalenia + } + else //standardowa prodedura z kranem powiązanym z klawiaturą + ggLocalBrake.UpdateValue(double(mvOccupied->LocalBrakePos)); + } + else //standardowa prodedura z kranem powiązanym z klawiaturą + ggLocalBrake.UpdateValue(double(mvOccupied->LocalBrakePos)); + ggLocalBrake.Update(); + } + if (ggManualBrake.SubModel!=NULL) + { + ggManualBrake.UpdateValue(double(mvOccupied->ManualBrakePos)); + ggManualBrake.Update(); + } + if (ggBrakeProfileCtrl.SubModel) + { + ggBrakeProfileCtrl.UpdateValue(double(mvOccupied->BrakeDelayFlag==4?2:mvOccupied->BrakeDelayFlag-1)); + ggBrakeProfileCtrl.Update(); + } + if (ggBrakeProfileG.SubModel) + { + ggBrakeProfileG.UpdateValue(double(mvOccupied->BrakeDelayFlag==bdelay_G?1:0)); + ggBrakeProfileG.Update(); + } + if (ggBrakeProfileR.SubModel) + { + ggBrakeProfileR.UpdateValue(double(mvOccupied->BrakeDelayFlag==bdelay_R?1:0)); + ggBrakeProfileR.Update(); + } + + if (ggMaxCurrentCtrl.SubModel) + { + ggMaxCurrentCtrl.UpdateValue(double(mvControlled->Imax==mvControlled->ImaxHi)); + ggMaxCurrentCtrl.Update(); + } + +// NBMX wrzesien 2003 - drzwi + if (ggDoorLeftButton.SubModel) + { + ggDoorLeftButton.PutValue(mvOccupied->DoorLeftOpened?1:0); + ggDoorLeftButton.Update(); + } + if (ggDoorRightButton.SubModel) + { + ggDoorRightButton.PutValue(mvOccupied->DoorRightOpened?1:0); + ggDoorRightButton.Update(); + } + if (ggDepartureSignalButton.SubModel) + { +// ggDepartureSignalButton.UpdateValue(double()); + ggDepartureSignalButton.Update(); + } + +//NBMX dzwignia sprezarki + if (ggCompressorButton.SubModel) //hunter-261211: poprawka + ggCompressorButton.Update(); + if (ggMainButton.SubModel) + ggMainButton.Update(); + if (ggRadioButton.SubModel) + { + ggRadioButton.PutValue(mvControlled->Radio?1:0); + ggRadioButton.Update(); + } + if (ggConverterButton.SubModel) + ggConverterButton.Update(); + if (ggConverterOffButton.SubModel) + ggConverterOffButton.Update(); + + if (((DynamicObject->iLights[0])==0) + &&((DynamicObject->iLights[1])==0)) + { + ggRightLightButton.PutValue(0); + ggLeftLightButton.PutValue(0); + ggUpperLightButton.PutValue(0); + ggRightEndLightButton.PutValue(0); + ggLeftEndLightButton.PutValue(0); + } + + //--------- + //hunter-101211: poprawka na zle obracajace sie przelaczniki + /* + if (((DynamicObject->iLights[0]&1)==1) + ||((DynamicObject->iLights[1]&1)==1)) + ggLeftLightButton.PutValue(1); + if (((DynamicObject->iLights[0]&16)==16) + ||((DynamicObject->iLights[1]&16)==16)) + ggRightLightButton.PutValue(1); + if (((DynamicObject->iLights[0]&4)==4) + ||((DynamicObject->iLights[1]&4)==4)) + ggUpperLightButton.PutValue(1); + + if (((DynamicObject->iLights[0]&2)==2) + ||((DynamicObject->iLights[1]&2)==2)) + if (ggLeftEndLightButton.SubModel) + { + ggLeftEndLightButton.PutValue(1); + ggLeftLightButton.PutValue(0); + } + else + ggLeftLightButton.PutValue(-1); + + if (((DynamicObject->iLights[0]&32)==32) + ||((DynamicObject->iLights[1]&32)==32)) + if (ggRightEndLightButton.SubModel) + { + ggRightEndLightButton.PutValue(1); + ggRightLightButton.PutValue(0); + } + else + ggRightLightButton.PutValue(-1); + */ + + //-------------- + //hunter-230112 + + //REFLEKTOR LEWY + //glowne oswietlenie + if ((DynamicObject->iLights[0]&1)==1) + if ((mvOccupied->ActiveCab)==1) + ggLeftLightButton.PutValue(1); + else if ((mvOccupied->ActiveCab)==-1) + ggRearLeftLightButton.PutValue(1); + + if ((DynamicObject->iLights[1]&1)==1) + if ((mvOccupied->ActiveCab)==-1) + ggLeftLightButton.PutValue(1); + else if ((mvOccupied->ActiveCab)==1) + ggRearLeftLightButton.PutValue(1); + + + //końcówki + if ((DynamicObject->iLights[0]&2)==2) + if ((mvOccupied->ActiveCab)==1) + { + if (ggLeftEndLightButton.SubModel) + { + ggLeftEndLightButton.PutValue(1); + ggLeftLightButton.PutValue(0); + } + else + ggLeftLightButton.PutValue(-1); + } + else if ((mvOccupied->ActiveCab)==-1) + { + if (ggRearLeftEndLightButton.SubModel) + { + ggRearLeftEndLightButton.PutValue(1); + ggRearLeftLightButton.PutValue(0); + } + else + ggRearLeftLightButton.PutValue(-1); + } + + if ((DynamicObject->iLights[1]&2)==2) + if ((mvOccupied->ActiveCab)==-1) + { + if (ggLeftEndLightButton.SubModel) + { + ggLeftEndLightButton.PutValue(1); + ggLeftLightButton.PutValue(0); + } + else + ggLeftLightButton.PutValue(-1); + } + else if ((mvOccupied->ActiveCab)==1) + { + if (ggRearLeftEndLightButton.SubModel) + { + ggRearLeftEndLightButton.PutValue(1); + ggRearLeftLightButton.PutValue(0); + } + else + ggRearLeftLightButton.PutValue(-1); + } + //-------------- + //REFLEKTOR GORNY + if ((DynamicObject->iLights[0]&4)==4) + if ((mvOccupied->ActiveCab)==1) + ggUpperLightButton.PutValue(1); + else if ((mvOccupied->ActiveCab)==-1) + ggRearUpperLightButton.PutValue(1); + + if ((DynamicObject->iLights[1]&4)==4) + if ((mvOccupied->ActiveCab)==-1) + ggUpperLightButton.PutValue(1); + else if ((mvOccupied->ActiveCab)==1) + ggRearUpperLightButton.PutValue(1); + //-------------- + //REFLEKTOR PRAWY + //główne oświetlenie + if ((DynamicObject->iLights[0]&16)==16) + if ((mvOccupied->ActiveCab)==1) + ggRightLightButton.PutValue(1); + else if ((mvOccupied->ActiveCab)==-1) + ggRearRightLightButton.PutValue(1); + + if ((DynamicObject->iLights[1]&16)==16) + if ((mvOccupied->ActiveCab)==-1) + ggRightLightButton.PutValue(1); + else if ((mvOccupied->ActiveCab)==1) + ggRearRightLightButton.PutValue(1); + + + //końcówki + if ((DynamicObject->iLights[0]&32)==32) + if ((mvOccupied->ActiveCab)==1) + { + if (ggRightEndLightButton.SubModel) + { + ggRightEndLightButton.PutValue(1); + ggRightLightButton.PutValue(0); + } + else + ggRightLightButton.PutValue(-1); + } + else if ((mvOccupied->ActiveCab)==-1) + { + if (ggRearRightEndLightButton.SubModel) + { + ggRearRightEndLightButton.PutValue(1); + ggRearRightLightButton.PutValue(0); + } + else + ggRearRightLightButton.PutValue(-1); + } + + if ((DynamicObject->iLights[1]&32)==32) + if ((mvOccupied->ActiveCab)==-1) + { + if (ggRightEndLightButton.SubModel) + { + ggRightEndLightButton.PutValue(1); + ggRightLightButton.PutValue(0); + } + else + ggRightLightButton.PutValue(-1); + } + else if ((mvOccupied->ActiveCab)==1) + { + if (ggRearRightEndLightButton.SubModel) + { + ggRearRightEndLightButton.PutValue(1); + ggRearRightLightButton.PutValue(0); + } + else + ggRearRightLightButton.PutValue(-1); + } + + //--------- +//Winger 010304 - pantografy + if (ggPantFrontButton.SubModel) + { + if (mvControlled->PantFrontUp) + ggPantFrontButton.PutValue(1); + else + ggPantFrontButton.PutValue(0); + ggPantFrontButton.Update(); + } + if (ggPantRearButton.SubModel) + { + ggPantRearButton.PutValue(mvControlled->PantRearUp?1:0); + ggPantRearButton.Update(); + } + if (ggPantFrontButtonOff.SubModel) + { + ggPantFrontButtonOff.Update(); + } +//Winger 020304 - ogrzewanie + //---------- + //hunter-080812: poprawka na ogrzewanie w elektrykach - usuniete uzaleznienie od przetwornicy + if (ggTrainHeatingButton.SubModel) + { + if (mvControlled->Heating) + { + ggTrainHeatingButton.PutValue(1); + //if (mvControlled->ConverterFlag==true) + // btLampkaOgrzewanieSkladu.TurnOn(); + } + else + { + ggTrainHeatingButton.PutValue(0); + //btLampkaOgrzewanieSkladu.TurnOff(); + } + ggTrainHeatingButton.Update(); + } + if (ggSignallingButton.SubModel!=NULL) + { + ggSignallingButton.PutValue(mvControlled->Signalling?1:0); + ggSignallingButton.Update(); + } + if (ggDoorSignallingButton.SubModel!=NULL) + { + ggDoorSignallingButton.PutValue(mvControlled->DoorSignalling?1:0); + ggDoorSignallingButton.Update(); + } + //if (ggDistCounter.SubModel) + //{//Ra 2014-07: licznik kilometrów + // ggDistCounter.PutValue(mvControlled->DistCounter); + // ggDistCounter.Update(); + //} + if ((((mvControlled->EngineType==ElectricSeriesMotor)&&(mvControlled->Mains==true)&&(mvControlled->ConvOvldFlag==false))||(mvControlled->ConverterFlag))&&(mvControlled->Heating==true)) + btLampkaOgrzewanieSkladu.TurnOn(); + else + btLampkaOgrzewanieSkladu.TurnOff(); + + //---------- + //hunter-261211: jakis stary kod (i niezgodny z prawda), + //zahaszowalem i poprawilem + //youBy-220913: ale przyda sie do lampki samej przetwornicy + btLampkaPrzetw.Turn(!mvControlled->ConverterFlag); + btLampkaNadmPrzetw.Turn(mvControlled->ConvOvldFlag); + //---------- + + +//McZapkie-141102: SHP i czuwak, TODO: sygnalizacja kabinowa + if (mvOccupied->SecuritySystem.Status>0) + { + if (fBlinkTimer>fCzuwakBlink) + fBlinkTimer=-fCzuwakBlink; + else + fBlinkTimer+=dt; + + //hunter-091012: dodanie testu czuwaka + if ((TestFlag(mvOccupied->SecuritySystem.Status,s_aware))||(TestFlag(mvOccupied->SecuritySystem.Status,s_CAtest))) + { + btLampkaCzuwaka.Turn(fBlinkTimer>0); + } + else btLampkaCzuwaka.TurnOff(); + btLampkaSHP.Turn(TestFlag(mvOccupied->SecuritySystem.Status,s_active)); + + //hunter-091012: rozdzielenie alarmow + //if (TestFlag(mvOccupied->SecuritySystem.Status,s_alarm)) + if (TestFlag(mvOccupied->SecuritySystem.Status,s_CAalarm)||TestFlag(mvOccupied->SecuritySystem.Status,s_SHPalarm)) + { + dsbBuzzer->GetStatus(&stat); + if (!(stat&DSBSTATUS_PLAYING)) + dsbBuzzer->Play(0,0,DSBPLAY_LOOPING); + } + else + { + dsbBuzzer->GetStatus(&stat); + if (stat&DSBSTATUS_PLAYING) + dsbBuzzer->Stop(); + } + } + else //wylaczone + { + btLampkaCzuwaka.TurnOff(); + btLampkaSHP.TurnOff(); + dsbBuzzer->GetStatus(&stat); + if (stat&DSBSTATUS_PLAYING) + dsbBuzzer->Stop(); + } + + //****************************************** + //przelaczniki + + if (Console::Pressed(Global::Keys[k_Horn])) + { + if (Console::Pressed(VK_SHIFT)) + { + SetFlag(mvOccupied->WarningSignal,2); + mvOccupied->WarningSignal&=(255-1); + if (ggHornButton.SubModel) + ggHornButton.UpdateValue(1); + } + else + { + SetFlag(mvOccupied->WarningSignal,1); + mvOccupied->WarningSignal&=(255-2); + if (ggHornButton.SubModel) + ggHornButton.UpdateValue(-1); + } + } + else + { + mvOccupied->WarningSignal=0; + if (ggHornButton.SubModel) + ggHornButton.UpdateValue(0); + } + + if ( Console::Pressed(Global::Keys[k_Horn2]) ) + if (Global::Keys[k_Horn2]!=Global::Keys[k_Horn]) + { + SetFlag(mvOccupied->WarningSignal,2); + } + + //---------------- + //hunter-141211: wyl. szybki zalaczony i wylaczony przeniesiony z OnKeyPress() + if ( Console::Pressed(VK_SHIFT)&&Console::Pressed(Global::Keys[k_Main]) ) + { + fMainRelayTimer+=dt; + ggMainOnButton.PutValue(1); + if (mvControlled->Mains!=true) //hunter-080812: poprawka + mvControlled->ConverterSwitch(false); + if (fMainRelayTimer>mvControlled->InitialCtrlDelay) //wlaczanie WSa z opoznieniem + if (mvControlled->MainSwitch(true)) + { +// if (mvControlled->MainCtrlPos!=0) //zabezpieczenie, by po wrzuceniu pozycji przed wlaczonym +// mvControlled->StLinFlag=true; //WSem nie wrzucilo na ta pozycje po jego zalaczeniu //yBARC - co to tutaj robi?! + if (mvControlled->EngineType==DieselEngine) + dsbDieselIgnition->Play(0,0,0); + } + } + else + { + if (ggConverterButton.GetValue()!=0) //po puszczeniu przycisku od WSa odpalanie potwora + mvControlled->ConverterSwitch(true); + //hunter-091012: przeniesione z mover.pas, zeby dzwiek sie nie zapetlal, drugi warunek zeby nie odtwarzalo w nieskonczonosc i przeniesienie zerowania timera + if ((mvControlled->Mains!=true)&&(fMainRelayTimer>0)) + { + dsbRelay->Play(0,0,0); + fMainRelayTimer=0; + } + ggMainOnButton.UpdateValue(0); + } + //--- + + if ( !Console::Pressed(VK_SHIFT)&&Console::Pressed(Global::Keys[k_Main]) ) + { + ggMainOffButton.PutValue(1); + if (mvControlled->MainSwitch(false)) + dsbRelay->Play(0,0,0); + } + else + ggMainOffButton.UpdateValue(0); + + /* if (cKey==Global::Keys[k_Main]) //z shiftem + { + ggMainOnButton.PutValue(1); + if (mvControlled->MainSwitch(true)) + { + if (mvControlled->MainCtrlPos!=0) //hunter-131211: takie zabezpieczenie + mvControlled->StLinFlag=true; + + if (mvControlled->EngineType==DieselEngine) + dsbDieselIgnition->Play(0,0,0); + else + dsbNastawnikJazdy->Play(0,0,0); + } + } + else */ + + /* if (cKey==Global::Keys[k_Main]) //bez shifta + { + ggMainOffButton.PutValue(1); + if (mvControlled->MainSwitch(false)) + { + dsbNastawnikJazdy->Play(0,0,0); + } + } + else */ + + //---------------- + //hunter-131211: czuwak przeniesiony z OnKeyPress + //hunter-091012: zrobiony test czuwaka + if ( Console::Pressed(Global::Keys[k_Czuwak]) ) + {//czuwak testuje kierunek, ale podobno w EZT nie, więc może być w rozrządczym + fCzuwakTestTimer+=dt; + ggSecurityResetButton.PutValue(1); + if (CAflag==false) + { + CAflag=true; + mvOccupied->SecuritySystemReset(); + } + else if (fCzuwakTestTimer>1.0) + SetFlag(mvOccupied->SecuritySystem.Status,s_CAtest); + } + else + { + fCzuwakTestTimer=0; + ggSecurityResetButton.UpdateValue(0); + if (TestFlag(mvOccupied->SecuritySystem.Status,s_CAtest))//&&(!TestFlag(mvControlled->SecuritySystem.Status,s_CAebrake))) + { + SetFlag(mvOccupied->SecuritySystem.Status,-s_CAtest); + mvOccupied->s_CAtestebrake=false; + mvOccupied->SecuritySystem.SystemBrakeCATestTimer=0; +// if ((!TestFlag(mvOccupied->SecuritySystem.Status,s_SHPebrake)) +// ||(!TestFlag(mvOccupied->SecuritySystem.Status,s_CAebrake))) +// mvControlled->EmergencyBrakeFlag=false; //YB-HN + } + CAflag=false; + } + /* + if ( Console::Pressed(Global::Keys[k_Czuwak]) ) + { + ggSecurityResetButton.PutValue(1); + if ((mvOccupied->SecuritySystem.Status&s_aware)&& + (mvOccupied->SecuritySystem.Status&s_active)) + { + mvOccupied->SecuritySystem.SystemTimer=0; + mvOccupied->SecuritySystem.Status-=s_aware; + mvOccupied->SecuritySystem.VelocityAllowed=-1; + CAflag=1; + } + else if (CAflag!=1) + mvOccupied->SecuritySystemReset(); + } + else + { + ggSecurityResetButton.UpdateValue(0); + CAflag=0; + } + */ + + //----------------- + //hunter-201211: piasecznica przeniesiona z OnKeyPress, wlacza sie tylko, + //gdy trzymamy przycisk, a nie tak jak wczesniej (raz nacisnelo sie 's' + //i sypala caly czas) + /* + if (cKey==Global::Keys[k_Sand]) + { + if (mvControlled->SandDoseOn()) + if (mvControlled->SandDose) + { + dsbPneumaticRelay->SetVolume(-30); + dsbPneumaticRelay->Play(0,0,0); + } + } + */ + + + if ( Console::Pressed(Global::Keys[k_Sand]) ) + { + mvControlled->SandDose=true; + //mvControlled->SandDoseOn(true); + } + else + { + mvControlled->SandDose=false; + //mvControlled->SandDoseOn(false); + //dsbPneumaticRelay->SetVolume(-30); + //dsbPneumaticRelay->Play(0,0,0); + } + + //----------------- + //hunter-221211: hamowanie przy poslizgu + if ( Console::Pressed(Global::Keys[k_AntiSlipping]) ) + { + if (mvControlled->BrakeSystem!=ElectroPneumatic) + { + ggAntiSlipButton.PutValue(1); + mvControlled->AntiSlippingBrake(); + } + } + else + ggAntiSlipButton.UpdateValue(0); + //----------------- + //hunter-261211: przetwornica i sprezarka + if ( Console::Pressed(VK_SHIFT)&&Console::Pressed(Global::Keys[k_Converter]) ) //NBMX 14-09-2003: przetwornica wl + { //(mvControlled->CompressorPower<2) + ggConverterButton.PutValue(1); + if ((mvControlled->PantFrontVolt!=0.0)||(mvControlled->PantRearVolt!=0.0)||(mvControlled->EnginePowerSource.SourceType!=CurrentCollector)/*||(!Global::bLiveTraction)*/) + mvControlled->ConverterSwitch(true); + //if ((mvControlled->EngineType!=ElectricSeriesMotor)&&(mvControlled->TrainType!=dt_EZT)) //hunter-110212: poprawka dla EZT + if (mvControlled->CompressorPower==2) //hunter-091012: tak jest poprawnie + mvControlled->CompressorSwitch(true); + } + else + { + if (mvControlled->ConvSwitchType=="impulse") + { + ggConverterButton.PutValue(0); + ggConverterOffButton.PutValue(0); + } + } + +// if ( Console::Pressed(VK_SHIFT)&&Console::Pressed(Global::Keys[k_Compressor])&&((mvControlled->EngineType==ElectricSeriesMotor)||(mvControlled->TrainType==dt_EZT)) ) //NBMX 14-09-2003: sprezarka wl + if ( Console::Pressed(VK_SHIFT)&&Console::Pressed(Global::Keys[k_Compressor])&&(mvControlled->CompressorPower<2)) //hunter-091012: tak jest poprawnie + { //hunter-110212: poprawka dla EZT + ggCompressorButton.PutValue(1); + mvControlled->CompressorSwitch(true); + } + + if ( !Console::Pressed(VK_SHIFT)&&Console::Pressed(Global::Keys[k_Converter]) ) //NBMX 14-09-2003: przetwornica wl + { + ggConverterButton.PutValue(0); + ggConverterOffButton.PutValue(1); + mvControlled->ConverterSwitch(false); + } + +// if ( !Console::Pressed(VK_SHIFT)&&Console::Pressed(Global::Keys[k_Compressor])&&((mvControlled->EngineType==ElectricSeriesMotor)||(mvControlled->TrainType==dt_EZT)) ) //NBMX 14-09-2003: sprezarka wl + if ( !Console::Pressed(VK_SHIFT)&&Console::Pressed(Global::Keys[k_Compressor])&&(mvControlled->CompressorPower<2)) //hunter-091012: tak jest poprawnie + { //hunter-110212: poprawka dla EZT + ggCompressorButton.PutValue(0); + mvControlled->CompressorSwitch(false); + } + + /* + bez szifta + if (cKey==Global::Keys[k_Converter]) //NBMX wyl przetwornicy + { + if (mvControlled->ConverterSwitch(false)) + { + dsbSwitch->SetVolume(DSBVOLUME_MAX); + dsbSwitch->Play(0,0,0);; + } + } + else + if (cKey==Global::Keys[k_Compressor]) //NBMX wyl sprezarka + { + if (mvControlled->CompressorSwitch(false)) + { + dsbSwitch->SetVolume(DSBVOLUME_MAX); + dsbSwitch->Play(0,0,0);; + } + } + else + */ + //----------------- + + if (!FreeFlyModeFlag) + { + if (Console::Pressed(Global::Keys[k_Releaser])) //yB: odluzniacz caly czas trzymany, warunki powinny byc takie same, jak przy naciskaniu. Wlasciwie stamtad mozna wyrzucic sprawdzanie nacisniecia. + { + if ((mvControlled->EngineType==ElectricSeriesMotor)||(mvControlled->EngineType==DieselElectric)) + if (mvControlled->TrainType!=dt_EZT) + if ((mvOccupied->BrakeCtrlPosNo>0)&&(mvControlled->ActiveDir!=0)) + { + ggReleaserButton.PutValue(1); + mvOccupied->BrakeReleaser(1); + } + } //releaser + else mvOccupied->BrakeReleaser(0); + } //FFMF + + + + + if (Console::Pressed(Global::Keys[k_Univ1])) + { + if (!DebugModeFlag) + { + if (ggUniversal1Button.SubModel) + if (Console::Pressed(VK_SHIFT)) + ggUniversal1Button.IncValue(dt/2); + else + ggUniversal1Button.DecValue(dt/2); + } + } + if (!Console::Pressed(Global::Keys[k_SmallCompressor])) + //Ra: przecieść to na zwolnienie klawisza + if (DynamicObject->Mechanik?!DynamicObject->Mechanik->AIControllFlag:false) //nie wyłączać, gdy AI + mvControlled->PantCompFlag=false; //wyłączona, gdy nie trzymamy klawisza + if (Console::Pressed(Global::Keys[k_Univ2])) + { + if (!DebugModeFlag) + { + if (ggUniversal2Button.SubModel) + if (Console::Pressed(VK_SHIFT)) + ggUniversal2Button.IncValue(dt/2); + else + ggUniversal2Button.DecValue(dt/2); + } + } + + //hunter-091012: zrobione z uwzglednieniem przelacznika swiatla + if ( Console::Pressed(Global::Keys[k_Univ3]) ) + { + if (Console::Pressed(VK_SHIFT)) + { + if (Console::Pressed(VK_CONTROL)) + { + bCabLight=true; + if (ggCabLightButton.SubModel) + { + ggCabLightButton.PutValue(1); + btCabLight.TurnOn(); + } + } + else + { + if (ggUniversal3Button.SubModel) + { + ggUniversal3Button.PutValue(1); //hunter-131211: z UpdateValue na PutValue - by zachowywal sie jak pozostale przelaczniki + if (btLampkaUniversal3.Active()) + LampkaUniversal3_st=true; + } + } + } + else + { + if (Console::Pressed(VK_CONTROL)) + { + bCabLight=false; + if (ggCabLightButton.SubModel) + { + ggCabLightButton.PutValue(0); + btCabLight.TurnOff(); + } + } + else + { + if (ggUniversal3Button.SubModel) + { + ggUniversal3Button.PutValue(0); //hunter-131211: z UpdateValue na PutValue - by zachowywal sie jak pozostale przelaczniki + if (btLampkaUniversal3.Active()) + LampkaUniversal3_st=false; + } + } + } + } + + + //hunter-091012: to w ogole jest bez sensu i tak namodzone ze nie wiadomo o co chodzi - zakomentowalem i zrobilem po swojemu + /* + if ( Console::Pressed(Global::Keys[k_Univ3]) ) + { + if (ggUniversal3Button.SubModel) + + + if (Console::Pressed(VK_CONTROL)) + {//z [Ctrl] zapalamy albo gasimy światełko w kabinie + //tutaj jest bez sensu, trzeba reagować na wciskanie klawisza! + if (Console::Pressed(VK_SHIFT)) + {//zapalenie + if (iCabLightFlag<2) ++iCabLightFlag; + } + else + {//gaszenie + if (iCabLightFlag) --iCabLightFlag; + } + + } + else + {//bez [Ctrl] przełączamy cośtem + if (Console::Pressed(VK_SHIFT)) + { + ggUniversal3Button.PutValue(1); //hunter-131211: z UpdateValue na PutValue - by zachowywal sie jak pozostale przelaczniki + if (btLampkaUniversal3.Active()) + LampkaUniversal3_st=true; + } + else + { + ggUniversal3Button.PutValue(0); //hunter-131211: z UpdateValue na PutValue - by zachowywal sie jak pozostale przelaczniki + if (btLampkaUniversal3.Active()) + LampkaUniversal3_st=false; + } + } + } */ + + //ABu030405 obsluga lampki uniwersalnej: + if (btLampkaUniversal3.Active()) //w ogóle jest + if (LampkaUniversal3_st) //załączona + switch (LampkaUniversal3_typ) + {case 0: btLampkaUniversal3.Turn(mvControlled->Battery); break; + case 1: btLampkaUniversal3.Turn(mvControlled->Mains); break; + case 2: btLampkaUniversal3.Turn(mvControlled->ConverterFlag); break; + default: + btLampkaUniversal3.TurnOff(); + } + else + btLampkaUniversal3.TurnOff(); + + /* + if (Console::Pressed(Global::Keys[k_Univ4])) + { + if (ggUniversal4Button.SubModel) + if (Console::Pressed(VK_SHIFT)) + { + ActiveUniversal4=true; + //ggUniversal4Button.UpdateValue(1); + } + else + { + ActiveUniversal4=false; + //ggUniversal4Button.UpdateValue(0); + } + } + */ + + //hunter-091012: przepisanie univ4 i zrobione z uwzglednieniem przelacznika swiatla + if ( Console::Pressed(Global::Keys[k_Univ4]) ) + { + if (Console::Pressed(VK_SHIFT)) + { + if (Console::Pressed(VK_CONTROL)) + { + bCabLightDim=true; + if (ggCabLightDimButton.SubModel) + { + ggCabLightDimButton.PutValue(1); + } + } + else + { + ActiveUniversal4=true; + //ggUniversal4Button.UpdateValue(1); + } + } + else + { + if (Console::Pressed(VK_CONTROL)) + { + bCabLightDim=false; + if (ggCabLightDimButton.SubModel) + { + ggCabLightDimButton.PutValue(0); //hunter-131211: z UpdateValue na PutValue - by zachowywal sie jak pozostale przelaczniki + } + } + else + { + ActiveUniversal4=false; + //ggUniversal4Button.UpdateValue(0); + } + } + } + // Odskakiwanie hamulce EP + if ((!Console::Pressed(Global::Keys[k_DecBrakeLevel]))&&(!Console::Pressed(Global::Keys[k_WaveBrake]))&&(mvOccupied->BrakeCtrlPos==-1)&&(mvOccupied->BrakeHandle==FVel6)&&(DynamicObject->Controller!=AIdriver)&&(Global::iFeedbackMode!=4)) + { + //mvOccupied->BrakeCtrlPos=(mvOccupied->BrakeCtrlPos)+1; + //mvOccupied->IncBrakeLevel(); + mvOccupied->BrakeLevelSet(mvOccupied->BrakeCtrlPos+1); + keybrakecount=0; + if ((mvOccupied->TrainType==dt_EZT)&&(mvControlled->Mains)&&(mvControlled->ActiveDir!=0)) + { + dsbPneumaticSwitch->SetVolume(-10); + dsbPneumaticSwitch->Play(0,0,0); + } + } + + //Ra: przeklejka z SPKS - płynne poruszanie hamulcem + //if ((mvOccupied->BrakeHandle==FV4a)&&(Console::Pressed(Global::Keys[k_IncBrakeLevel]))) + if ((Console::Pressed(Global::Keys[k_IncBrakeLevel]))) + { + if (Console::Pressed(VK_CONTROL)) + { + //mvOccupied->BrakeCtrlPos2-=dt/20.0; + //if (mvOccupied->BrakeCtrlPos2<-1.5) mvOccupied->BrakeCtrlPos2=-1.5; + } + else + { + //mvOccupied->BrakeCtrlPosR+=(mvOccupied->BrakeCtrlPosR>mvOccupied->BrakeCtrlPosNo?0:dt*2); + //mvOccupied->BrakeCtrlPos= floor(mvOccupied->BrakeCtrlPosR+0.499); + } + } + //if ((mvOccupied->BrakeHandle==FV4a)&&(Console::Pressed(Global::Keys[k_DecBrakeLevel]))) + if ((Console::Pressed(Global::Keys[k_DecBrakeLevel]))) + { + if (Console::Pressed(VK_CONTROL)) + { + //mvOccupied->BrakeCtrlPos2+=(mvOccupied->BrakeCtrlPos2>2?0:dt/20.0); + //if (mvOccupied->BrakeCtrlPos2<-3) mvOccupied->BrakeCtrlPos2=-3; + //mvOccupied->BrakeLevelAdd(mvOccupied->fBrakeCtrlPos<-1?0:dt*2); + } + else + { + //mvOccupied->BrakeCtrlPosR-=(mvOccupied->BrakeCtrlPosR<-1?0:dt*2); + //mvOccupied->BrakeCtrlPos= floor(mvOccupied->BrakeCtrlPosR+0.499); + //mvOccupied->BrakeLevelAdd(mvOccupied->fBrakeCtrlPos<-1?0:-dt*2); + } + } + + if ((mvOccupied->BrakeHandle==FV4a)&&(Console::Pressed(Global::Keys[k_IncBrakeLevel]))) + { + if (Console::Pressed(VK_CONTROL)) + { + mvOccupied->BrakeCtrlPos2-=dt/20.0; + if(mvOccupied->BrakeCtrlPos2<-1.5) mvOccupied->BrakeCtrlPos2=-1.5; + } + else + { +// mvOccupied->BrakeCtrlPosR+=(mvOccupied->BrakeCtrlPosR>mvOccupied->BrakeCtrlPosNo?0:dt*2); + mvOccupied->BrakeLevelAdd(dt*2); +// mvOccupied->BrakeCtrlPos= floor(mvOccupied->BrakeCtrlPosR+0.499); + } + } + + if ((mvOccupied->BrakeHandle==FV4a)&&(Console::Pressed(Global::Keys[k_DecBrakeLevel]))) + { + if (Console::Pressed(VK_CONTROL)) + { + mvOccupied->BrakeCtrlPos2+=(mvOccupied->BrakeCtrlPos2>2?0:dt/20.0); + if(mvOccupied->BrakeCtrlPos2<-3) mvOccupied->BrakeCtrlPos2=-3; + } + else + { +// mvOccupied->BrakeCtrlPosR-=(mvOccupied->BrakeCtrlPosR<-1?0:dt*2); +// mvOccupied->BrakeCtrlPos= floor(mvOccupied->BrakeCtrlPosR+0.499); + mvOccupied->BrakeLevelAdd(-dt*2); + } + } + + + +// bool kEP; +// kEP=(mvOccupied->BrakeSubsystem==Knorr)||(mvOccupied->BrakeSubsystem==Hik)||(mvOccupied->BrakeSubsystem==Kk); + if ((mvOccupied->BrakeSystem==ElectroPneumatic)&&((mvOccupied->BrakeHandle==St113))&&(mvControlled->EpFuse==true)) + if (Console::Pressed(Global::Keys[k_AntiSlipping])) //kEP + { + ggAntiSlipButton.UpdateValue(1); + if (mvOccupied->SwitchEPBrake(1)) + { + dsbPneumaticSwitch->SetVolume(-10); + dsbPneumaticSwitch->Play(0,0,0); + } + } + else + { + if (mvOccupied->SwitchEPBrake(0)) + { + dsbPneumaticSwitch->SetVolume(-10); + dsbPneumaticSwitch->Play(0,0,0); + } + } + + if ( Console::Pressed(Global::Keys[k_DepartureSignal]) ) + { + ggDepartureSignalButton.PutValue(1); + btLampkaDepartureSignal.TurnOn(); + mvControlled->DepartureSignal=true; + } + else + { + btLampkaDepartureSignal.TurnOff(); + if (DynamicObject->Mechanik) //może nie być? + if (!DynamicObject->Mechanik->AIControllFlag) //tylko jeśli nie prowadzi AI + mvControlled->DepartureSignal=false; + } + +if ( Console::Pressed(Global::Keys[k_Main]) ) //[] + { + if (Console::Pressed(VK_SHIFT)) + ggMainButton.PutValue(1); + else + ggMainButton.PutValue(0); + } + else + ggMainButton.PutValue(0); + +if ( Console::Pressed(Global::Keys[k_CurrentNext])) + { + if (mvControlled->TrainType!=dt_EZT) + { + if (ShowNextCurrent==false) + { + if (ggNextCurrentButton.SubModel) + { + ggNextCurrentButton.UpdateValue(1); + dsbSwitch->SetVolume(DSBVOLUME_MAX); + dsbSwitch->Play(0,0,0); + ShowNextCurrent=true; + } + } + } + else + { + if (Console::Pressed(VK_SHIFT)) + { +// if (Console::Pressed(k_CurrentNext)) + {//Ra: było pod VK_F3 + if ((mvOccupied->EpFuseSwitch(true))) + { + dsbPneumaticSwitch->SetVolume(-10); + dsbPneumaticSwitch->Play(0,0,0); + } + } + } + else + { +// if (Console::Pressed(k_CurrentNext)) + {//Ra: było pod VK_F3 + if (Console::Pressed(VK_CONTROL)) + { + if ((mvOccupied->EpFuseSwitch(false))) + { + dsbPneumaticSwitch->SetVolume(-10); + dsbPneumaticSwitch->Play(0,0,0); + } + } + } + } + } + } +else + { + if (ShowNextCurrent==true) + { + if (ggNextCurrentButton.SubModel) + { + ggNextCurrentButton.UpdateValue(0); + dsbSwitch->SetVolume(DSBVOLUME_MAX); + dsbSwitch->Play(0,0,0); + ShowNextCurrent=false; + } + } + } + +//Winger 010304 PantAllDownButton + if ( Console::Pressed(Global::Keys[k_PantFrontUp]) ) + { + if (Console::Pressed(VK_SHIFT)) + ggPantFrontButton.PutValue(1); + else + ggPantAllDownButton.PutValue(1); + } + else + if (mvControlled->PantSwitchType=="impulse") + { + ggPantFrontButton.PutValue(0); + ggPantAllDownButton.PutValue(0); + } + + if ( Console::Pressed(Global::Keys[k_PantRearUp]) ) + { + if (Console::Pressed(VK_SHIFT)) + ggPantRearButton.PutValue(1); + else + ggPantFrontButtonOff.PutValue(1); + } + else + if (mvControlled->PantSwitchType=="impulse") + { + ggPantRearButton.PutValue(0); + ggPantFrontButtonOff.PutValue(0); + } + +/* if ((mvControlled->Mains) && (mvControlled->EngineType==ElectricSeriesMotor)) + { +//tu dac w przyszlosci zaleznosc od wlaczenia przetwornicy + if (mvControlled->ConverterFlag) //NBMX -obsluga przetwornicy + { + //glosnosc zalezna od nap. sieci + //-2000 do 0 + long tmpVol; + int trackVol; + trackVol=3550-2000; + if (mvControlled->RunningTraction.TractionVoltage<2000) + { + tmpVol=0; + } + else + { + tmpVol=mvControlled->RunningTraction.TractionVoltage-2000; + } + sConverter.Volume(-2000*(trackVol-tmpVol)/trackVol); + + if (!sConverter.Playing()) + sConverter.TurnOn(); + } + else //wyl przetwornicy + sConverter.TurnOff(); + } + else + { + if (sConverter.Playing()) + sConverter.TurnOff(); + } + sConverter.Update(); +*/ + +// if (fabs(DynamicObject->GetVelocity())>0.5) + if (FreeFlyModeFlag?false:fTachoCount>maxtacho) + { + dsbHasler->GetStatus(&stat); + if (!(stat&DSBSTATUS_PLAYING)) + dsbHasler->Play(0,0,DSBPLAY_LOOPING ); + } + else + { + if (FreeFlyModeFlag?true:fTachoCount<1) + { + dsbHasler->GetStatus(&stat); + if (stat&DSBSTATUS_PLAYING) + dsbHasler->Stop(); + } + } + +// koniec mieszania z dzwiekami + +// guziki: + ggMainOffButton.Update(); + ggMainOnButton.Update(); + ggMainButton.Update(); + ggSecurityResetButton.Update(); + ggReleaserButton.Update(); + ggAntiSlipButton.Update(); + ggFuseButton.Update(); + ggConverterFuseButton.Update(); + ggStLinOffButton.Update(); + ggRadioButton.Update(); + ggDepartureSignalButton.Update(); + ggPantFrontButton.Update(); + ggPantRearButton.Update(); + ggPantFrontButtonOff.Update(); + ggUpperLightButton.Update(); + ggLeftLightButton.Update(); + ggRightLightButton.Update(); + ggLeftEndLightButton.Update(); + ggRightEndLightButton.Update(); + //hunter-230112 + ggRearUpperLightButton.Update(); + ggRearLeftLightButton.Update(); + ggRearRightLightButton.Update(); + ggRearLeftEndLightButton.Update(); + ggRearRightEndLightButton.Update(); + //------------ + ggPantAllDownButton.Update(); + ggConverterButton.Update(); + ggConverterOffButton.Update(); + ggTrainHeatingButton.Update(); + ggSignallingButton.Update(); + ggNextCurrentButton.Update(); + ggHornButton.Update(); + ggUniversal1Button.Update(); + ggUniversal2Button.Update(); + ggUniversal3Button.Update(); + //hunter-091012 + ggCabLightButton.Update(); + ggCabLightDimButton.Update(); + //------ + if (ActiveUniversal4) + ggUniversal4Button.PermIncValue(dt); + + ggUniversal4Button.Update(); + ggMainOffButton.UpdateValue(0); + ggMainOnButton.UpdateValue(0); + ggSecurityResetButton.UpdateValue(0); + ggReleaserButton.UpdateValue(0); + ggAntiSlipButton.UpdateValue(0); + ggDepartureSignalButton.UpdateValue(0); + ggFuseButton.UpdateValue(0); + ggConverterFuseButton.UpdateValue(0); + } + //wyprowadzenie sygnałów dla haslera na PoKeys (zaznaczanie na taśmie) + btHaslerBrakes.Turn(DynamicObject->MoverParameters->BrakePress>0.4); //ciśnienie w cylindrach + btHaslerCurrent.Turn(DynamicObject->MoverParameters->Im!=0.0); //prąd na silnikach + return true; //(DynamicObject->Update(dt)); +} //koniec update + + +bool TTrain::CabChange(int iDirection) +{//McZapkie-090902: zmiana kabiny 1->0->2 i z powrotem + if (DynamicObject->Mechanik?DynamicObject->Mechanik->AIControllFlag:true) //jeśli prowadzi AI albo jest w innym członie + {//jak AI prowadzi, to nie można mu mieszać + if (abs(DynamicObject->MoverParameters->ActiveCab+iDirection)>1) + return false; //ewentualna zmiana pojazdu + DynamicObject->MoverParameters->ActiveCab=DynamicObject->MoverParameters->ActiveCab+iDirection; + } + else + {//jeśli pojazd prowadzony ręcznie albo wcale (wagon) + DynamicObject->MoverParameters->CabDeactivisation(); + if (DynamicObject->MoverParameters->ChangeCab(iDirection)) + if (InitializeCab(DynamicObject->MoverParameters->ActiveCab,DynamicObject->asBaseDir+DynamicObject->MoverParameters->TypeName+".mmd")) + {//zmiana kabiny w ramach tego samego pojazdu + DynamicObject->MoverParameters->CabActivisation(); //załączenie rozrządu (wirtualne kabiny) + return true; //udało się zmienić kabinę + } + DynamicObject->MoverParameters->CabActivisation(); //aktywizacja poprzedniej, bo jeszcze nie wiadomo, czy jakiś pojazd jest + } + return false; //ewentualna zmiana pojazdu +} + +//McZapkie-310302 +//wczytywanie pliku z danymi multimedialnymi (dzwieki, kontrolki, kabiny) +bool __fastcall TTrain::LoadMMediaFile(AnsiString asFileName) +{ + double dSDist; + TFileStream *fs; + fs=new TFileStream(asFileName , fmOpenRead | fmShareCompat ); + AnsiString str=""; +// DecimalSeparator='.'; + int size=fs->Size; + str.SetLength(size); + fs->Read(str.c_str(),size); + str+=""; + delete fs; + TQueryParserComp *Parser; + Parser=new TQueryParserComp(NULL); + Parser->TextToParse=str; +// Parser->LoadStringToParse(asFile); + Parser->First(); + str=""; + dsbPneumaticSwitch=TSoundsManager::GetFromName("silence1.wav",true); + while ((!Parser->EndOfFile) && (str!=AnsiString("internaldata:"))) + { + str=Parser->GetNextSymbol().LowerCase(); + } + if (str==AnsiString("internaldata:")) + { + while (!Parser->EndOfFile) + { + str=Parser->GetNextSymbol().LowerCase(); +//SEKCJA DZWIEKOW + if (str==AnsiString("ctrl:")) //nastawnik: + { + str=Parser->GetNextSymbol().LowerCase(); + dsbNastawnikJazdy=TSoundsManager::GetFromName(str.c_str(),true); + } + else + //--------------- + //hunter-081211: nastawnik bocznikowania + if (str==AnsiString("ctrlscnd:")) //nastawnik bocznikowania: + { + str=Parser->GetNextSymbol().LowerCase(); + dsbNastawnikBocz=TSoundsManager::GetFromName(str.c_str(),true); + } + else + //--------------- + //hunter-131211: dzwiek kierunkowego + if (str==AnsiString("reverserkey:")) //nastawnik kierunkowy + { + str=Parser->GetNextSymbol().LowerCase(); + dsbReverserKey=TSoundsManager::GetFromName(str.c_str(),true); + } + else + //--------------- + if (str==AnsiString("buzzer:")) //bzyczek shp: + { + str=Parser->GetNextSymbol().LowerCase(); + dsbBuzzer=TSoundsManager::GetFromName(str.c_str(),true); + } + else + if (str==AnsiString("slipalarm:")) //Bombardier 011010: alarm przy poslizgu: + { + str=Parser->GetNextSymbol().LowerCase(); + dsbSlipAlarm=TSoundsManager::GetFromName(str.c_str(),true); + } + else + if (str==AnsiString("tachoclock:")) //cykanie rejestratora: + { + str=Parser->GetNextSymbol().LowerCase(); + dsbHasler=TSoundsManager::GetFromName(str.c_str(),true); + } + else + if (str==AnsiString("switch:")) //przelaczniki: + { + str=Parser->GetNextSymbol().LowerCase(); + dsbSwitch=TSoundsManager::GetFromName(str.c_str(),true); + } + else + if (str==AnsiString("pneumaticswitch:")) //stycznik EP: + { + str=Parser->GetNextSymbol().LowerCase(); + dsbPneumaticSwitch=TSoundsManager::GetFromName(str.c_str(),true); + } + else + //--------------- + //hunter-111211: wydzielenie wejscia na bezoporowa i na drugi uklad do pliku + if (str==AnsiString("wejscie_na_bezoporow:")) + { + str=Parser->GetNextSymbol().LowerCase(); + dsbWejscie_na_bezoporow=TSoundsManager::GetFromName(str.c_str(),true); + } + else + if (str==AnsiString("wejscie_na_drugi_uklad:")) + { + str=Parser->GetNextSymbol().LowerCase(); + dsbWejscie_na_drugi_uklad=TSoundsManager::GetFromName(str.c_str(),true); + } + else + //--------------- + if (str==AnsiString("relay:")) //styczniki itp: + { + str=Parser->GetNextSymbol().LowerCase(); + dsbRelay=TSoundsManager::GetFromName(str.c_str(),true); + if (!dsbWejscie_na_bezoporow) //hunter-111211: domyslne, gdy brak + dsbWejscie_na_bezoporow=TSoundsManager::GetFromName("wejscie_na_bezoporow.wav",true); + if (!dsbWejscie_na_drugi_uklad) + dsbWejscie_na_drugi_uklad=TSoundsManager::GetFromName("wescie_na_drugi_uklad.wav",true); + } + else + if (str==AnsiString("pneumaticrelay:")) //wylaczniki pneumatyczne: + { + str=Parser->GetNextSymbol().LowerCase(); + dsbPneumaticRelay=TSoundsManager::GetFromName(str.c_str(),true); + } + else + if (str==AnsiString("couplerattach:")) //laczenie: + { + str=Parser->GetNextSymbol().LowerCase(); + dsbCouplerAttach=TSoundsManager::GetFromName(str.c_str(),true); + dsbCouplerStretch=TSoundsManager::GetFromName("en57_couplerstretch.wav",true); //McZapkie-090503: PROWIZORKA!!! + } + else + if (str==AnsiString("couplerdetach:")) //rozlaczanie: + { + str=Parser->GetNextSymbol().LowerCase(); + dsbCouplerDetach=TSoundsManager::GetFromName(str.c_str(),true); + dsbBufferClamp=TSoundsManager::GetFromName("en57_bufferclamp.wav",true); //McZapkie-090503: PROWIZORKA!!! + } + else + if (str==AnsiString("ignition:")) + {//odpalanie silnika + str=Parser->GetNextSymbol().LowerCase(); + dsbDieselIgnition=TSoundsManager::GetFromName(str.c_str(),true); + } + else + if (str==AnsiString("brakesound:")) //hamowanie zwykle: + { + str=Parser->GetNextSymbol(); + rsBrake.Init(str.c_str(),-1,0,0,0,true,true); + rsBrake.AM=Parser->GetNextSymbol().ToDouble()/(1+mvOccupied->MaxBrakeForce*1000); + rsBrake.AA=Parser->GetNextSymbol().ToDouble(); + rsBrake.FM=Parser->GetNextSymbol().ToDouble()/(1+mvOccupied->Vmax); + rsBrake.FA=Parser->GetNextSymbol().ToDouble(); + } + else + if (str==AnsiString("slipperysound:")) //sanie: + { + str=Parser->GetNextSymbol(); + rsSlippery.Init(str.c_str(),-1,0,0,0,true); + rsSlippery.AM=Parser->GetNextSymbol().ToDouble()/(1+mvOccupied->Vmax); + rsSlippery.AA=Parser->GetNextSymbol().ToDouble(); + rsSlippery.FM=0.0; + rsSlippery.FA=1.0; + } + else + if (str==AnsiString("airsound:")) //syk: + { + str=Parser->GetNextSymbol(); + rsHiss.Init(str.c_str(),-1,0,0,0,true); + rsHiss.AM=Parser->GetNextSymbol().ToDouble(); + rsHiss.AA=Parser->GetNextSymbol().ToDouble(); + rsHiss.FM=0.0; + rsHiss.FA=1.0; + } + else + if (str==AnsiString("airsound2:")) //syk: + { + str=Parser->GetNextSymbol(); + rsHissU.Init(str.c_str(),-1,0,0,0,true); + rsHissU.AM=Parser->GetNextSymbol().ToDouble(); + rsHissU.AA=Parser->GetNextSymbol().ToDouble(); + rsHissU.FM=0.0; + rsHissU.FA=1.0; + } + else + if (str==AnsiString("airsound3:")) //syk: + { + str=Parser->GetNextSymbol(); + rsHissE.Init(str.c_str(),-1,0,0,0,true); + rsHissE.AM=Parser->GetNextSymbol().ToDouble(); + rsHissE.AA=Parser->GetNextSymbol().ToDouble(); + rsHissE.FM=0.0; + rsHissE.FA=1.0; + } + else + if (str==AnsiString("airsound4:")) //syk: + { + str=Parser->GetNextSymbol(); + rsHissX.Init(str.c_str(),-1,0,0,0,true); + rsHissX.AM=Parser->GetNextSymbol().ToDouble(); + rsHissX.AA=Parser->GetNextSymbol().ToDouble(); + rsHissX.FM=0.0; + rsHissX.FA=1.0; + } + else + if (str==AnsiString("airsound5:")) //syk: + { + str=Parser->GetNextSymbol(); + rsHissT.Init(str.c_str(),-1,0,0,0,true); + rsHissT.AM=Parser->GetNextSymbol().ToDouble(); + rsHissT.AA=Parser->GetNextSymbol().ToDouble(); + rsHissT.FM=0.0; + rsHissT.FA=1.0; + } + else + if (str==AnsiString("fadesound:")) //syk: + { + str=Parser->GetNextSymbol(); + rsFadeSound.Init(str.c_str(),-1,0,0,0,true); + rsFadeSound.AM=1.0; + rsFadeSound.AA=1.0; + rsFadeSound.FM=1.0; + rsFadeSound.FA=1.0; + } + else + if (str==AnsiString("localbrakesound:")) //syk: + { + str=Parser->GetNextSymbol(); + rsSBHiss.Init(str.c_str(),-1,0,0,0,true); + rsSBHiss.AM=Parser->GetNextSymbol().ToDouble(); + rsSBHiss.AA=Parser->GetNextSymbol().ToDouble(); + rsSBHiss.FM=0.0; + rsSBHiss.FA=1.0; + } + else + if (str==AnsiString("runningnoise:")) //szum podczas jazdy: + { + str=Parser->GetNextSymbol(); + rsRunningNoise.Init(str.c_str(),-1,0,0,0,true,true); + rsRunningNoise.AM=Parser->GetNextSymbol().ToDouble()/(1+mvOccupied->Vmax); + rsRunningNoise.AA=Parser->GetNextSymbol().ToDouble(); + rsRunningNoise.FM=Parser->GetNextSymbol().ToDouble()/(1+mvOccupied->Vmax); + rsRunningNoise.FA=Parser->GetNextSymbol().ToDouble(); + } + else + if (str==AnsiString("engageslippery:")) //tarcie tarcz sprzegla: + { + str=Parser->GetNextSymbol(); + rsEngageSlippery.Init(str.c_str(),-1,0,0,0,true,true); + rsEngageSlippery.AM=Parser->GetNextSymbol().ToDouble(); + rsEngageSlippery.AA=Parser->GetNextSymbol().ToDouble(); + rsEngageSlippery.FM=Parser->GetNextSymbol().ToDouble()/(1+mvOccupied->nmax); + rsEngageSlippery.FA=Parser->GetNextSymbol().ToDouble(); + } + else + if (str==AnsiString("mechspring:")) //parametry bujania kamery: + { + str=Parser->GetNextSymbol(); + MechSpring.Init(0,str.ToDouble(),Parser->GetNextSymbol().ToDouble()); + fMechSpringX=Parser->GetNextSymbol().ToDouble(); + fMechSpringY=Parser->GetNextSymbol().ToDouble(); + fMechSpringZ=Parser->GetNextSymbol().ToDouble(); + fMechMaxSpring=Parser->GetNextSymbol().ToDouble(); + fMechRoll=Parser->GetNextSymbol().ToDouble(); + fMechPitch=Parser->GetNextSymbol().ToDouble(); + } + else + if (str==AnsiString("pantographup:")) //podniesienie patyka: + { + str=Parser->GetNextSymbol().LowerCase(); + dsbPantUp=TSoundsManager::GetFromName(str.c_str(),true); + } + else + if (str==AnsiString("pantographdown:")) //podniesienie patyka: + { + str=Parser->GetNextSymbol().LowerCase(); + dsbPantDown=TSoundsManager::GetFromName(str.c_str(),true); + } + else + if (str==AnsiString("doorclose:")) //zamkniecie drzwi: + { + str=Parser->GetNextSymbol().LowerCase(); + dsbDoorClose=TSoundsManager::GetFromName(str.c_str(),true); + } + else + if (str==AnsiString("dooropen:")) //wotwarcie drzwi: + { + str=Parser->GetNextSymbol().LowerCase(); + dsbDoorOpen=TSoundsManager::GetFromName(str.c_str(),true); + } + } + } + else return false; //nie znalazl sekcji internal + delete Parser; //Ra: jak się coś newuje, to trzeba zdeletować, inaczej syf się robi + if (!InitializeCab(mvOccupied->ActiveCab,asFileName)) //zle zainicjowana kabina + return false; + else + { + if (DynamicObject->Controller==Humandriver) + DynamicObject->bDisplayCab=true; //McZapkie-030303: mozliwosc wyswietlania kabiny, w przyszlosci dac opcje w mmd + return true; + } +} + + +bool TTrain::InitializeCab(int NewCabNo, AnsiString asFileName) +{ + bool parse=false; + double dSDist; + TFileStream *fs; + fs=new TFileStream(asFileName,fmOpenRead|fmShareCompat); + AnsiString str=""; + //DecimalSeparator='.'; + int size=fs->Size; + str.SetLength(size); + fs->Read(str.c_str(),size); + str+=""; + delete fs; + TQueryParserComp *Parser; + Parser=new TQueryParserComp(NULL); + Parser->TextToParse=str; + //Parser->LoadStringToParse(asFile); + Parser->First(); + str=""; + int cabindex=0; + TGauge *gg; //roboczy wsaźnik na obiekt animujący gałkę + DynamicObject->mdKabina=NULL; //likwidacja wskaźnika na dotychczasową kabinę + switch (NewCabNo) + {//ustalenie numeru kabiny do wczytania + case -1: cabindex=2; break; + case 1: cabindex=1; break; + case 0: cabindex=0; + } + AnsiString cabstr=AnsiString("cab")+cabindex+AnsiString("definition:"); + while ((!Parser->EndOfFile) && (AnsiCompareStr(str,cabstr)!=0)) + str=Parser->GetNextSymbol().LowerCase(); //szukanie kabiny + if (cabindex!=1) + if (AnsiCompareStr(str,cabstr)!=0) //jeśli nie znaleziony wpis kabiny + {//próba szukania kabiny 1 + cabstr=AnsiString("cab1definition:"); + Parser->First(); + while ((!Parser->EndOfFile) && (AnsiCompareStr(str,cabstr)!=0)) + str=Parser->GetNextSymbol().LowerCase(); //szukanie kabiny + } + if (AnsiCompareStr(str,cabstr)==0) //jeśli znaleziony wpis kabiny + { + Cabine[cabindex].Load(Parser); + str=Parser->GetNextSymbol().LowerCase(); + if (AnsiCompareStr(AnsiString("driver")+cabindex+AnsiString("pos:"),str)==0) //pozycja poczatkowa maszynisty + { + pMechOffset.x=Parser->GetNextSymbol().ToDouble(); + pMechOffset.y=Parser->GetNextSymbol().ToDouble(); + pMechOffset.z=Parser->GetNextSymbol().ToDouble(); + pMechSittingPosition.x=pMechOffset.x; + pMechSittingPosition.y=pMechOffset.y; + pMechSittingPosition.z=pMechOffset.z; + } + //ABu: pozycja siedzaca mechanika + str=Parser->GetNextSymbol().LowerCase(); + if (AnsiCompareStr(AnsiString("driver")+cabindex+AnsiString("sitpos:"),str)==0) //ABu 180404 pozycja siedzaca maszynisty + { + pMechSittingPosition.x=Parser->GetNextSymbol().ToDouble(); + pMechSittingPosition.y=Parser->GetNextSymbol().ToDouble(); + pMechSittingPosition.z=Parser->GetNextSymbol().ToDouble(); + parse=true; + } + //else parse=false; + while (!Parser->EndOfFile) + {//ABu: wstawione warunki, wczesniej tylko to: + // str=Parser->GetNextSymbol().LowerCase(); + if (parse) + str=Parser->GetNextSymbol().LowerCase(); + else + parse=true; + //inicjacja kabiny + //Ra 2014-08: zmieniamy zasady - zamiast przypisywać submodel do istniejących obiektów animujących + //będziemy teraz uaktywniać obiekty animujące z tablicy i podawać im submodel oraz wskaźnik na parametr + if (AnsiCompareStr(AnsiString("cab")+cabindex+AnsiString("model:"),str)==0) //model kabiny + { + str=Parser->GetNextSymbol().LowerCase(); + if (str!=AnsiString("none")) + { + str=DynamicObject->asBaseDir+str; + Global::asCurrentTexturePath=DynamicObject->asBaseDir; //bieżąca sciezka do tekstur to dynamic/... + TModel3d *k=TModelsManager::GetModel(str.c_str(),true); //szukaj kabinę jako oddzielny model + Global::asCurrentTexturePath=AnsiString(szTexturePath); //z powrotem defaultowa sciezka do tekstur + //if (DynamicObject->mdKabina!=k) + if (k) + DynamicObject->mdKabina=k; //nowa kabina + //(mdKabina) może zostać to samo po przejściu do innego członu bez zmiany kabiny, przy powrocie musi być wiązanie ponowne + //else + // break; //wyjście z pętli, bo model zostaje bez zmian + } + else if (cabindex==1) //model tylko, gdy nie ma kabiny 1 + DynamicObject->mdKabina=DynamicObject->mdModel; //McZapkie-170103: szukaj elementy kabiny w glownym modelu + ActiveUniversal4=false; + ggMainCtrl.Clear(); + ggMainCtrlAct.Clear(); + ggScndCtrl.Clear(); + ggDirKey.Clear(); + ggBrakeCtrl.Clear(); + ggLocalBrake.Clear(); + ggManualBrake.Clear(); + ggBrakeProfileCtrl.Clear(); + ggBrakeProfileG.Clear(); + ggBrakeProfileR.Clear(); + ggMaxCurrentCtrl.Clear(); + ggMainOffButton.Clear(); + ggMainOnButton.Clear(); + ggSecurityResetButton.Clear(); + ggReleaserButton.Clear(); + ggAntiSlipButton.Clear(); + ggHornButton.Clear(); + ggNextCurrentButton.Clear(); + ggUniversal1Button.Clear(); + ggUniversal2Button.Clear(); + ggUniversal3Button.Clear(); + //hunter-091012 + ggCabLightButton.Clear(); + ggCabLightDimButton.Clear(); + //------- + ggUniversal4Button.Clear(); + ggFuseButton.Clear(); + ggConverterFuseButton.Clear(); + ggStLinOffButton.Clear(); + ggDoorLeftButton.Clear(); + ggDoorRightButton.Clear(); + ggDepartureSignalButton.Clear(); + ggCompressorButton.Clear(); + ggConverterButton.Clear(); + ggPantFrontButton.Clear(); + ggPantRearButton.Clear(); + ggPantFrontButtonOff.Clear(); + ggPantAllDownButton.Clear(); + ggZbS.Clear(); + ggI1B.Clear(); + ggI2B.Clear(); + ggI3B.Clear(); + ggItotalB.Clear(); + + ggClockSInd.Clear(); + ggClockMInd.Clear(); + ggClockHInd.Clear(); + ggEngineVoltage.Clear(); + ggLVoltage.Clear(); + //ggLVoltage.Output(0); //Ra: sterowanie miernikiem: niskie napięcie + //ggEnrot1m.Clear(); + //ggEnrot2m.Clear(); + //ggEnrot3m.Clear(); + //ggEngageRatio.Clear(); + ggMainGearStatus.Clear(); + ggIgnitionKey.Clear(); + btLampkaPoslizg.Clear(6); + btLampkaStyczn.Clear(5); + btLampkaNadmPrzetw.Clear((mvControlled->TrainType&(dt_EZT))?-1:7); //EN57 nie ma tej lampki + btLampkaPrzetw.Clear((mvControlled->TrainType&(dt_EZT))?7:-1); //za to ma tę + btLampkaPrzekRozn.Clear(); + btLampkaPrzekRoznPom.Clear(); + btLampkaNadmSil.Clear(4); + btLampkaUkrotnienie.Clear(); + btLampkaHamPosp.Clear(); + btLampkaWylSzybki.Clear(3); + btLampkaNadmWent.Clear(9); + btLampkaNadmSpr.Clear(8); + btLampkaOpory.Clear(2); + btLampkaWysRozr.Clear((mvControlled->TrainType&(dt_ET22))?-1:10); //ET22 nie ma tej lampki + btLampkaBezoporowa.Clear(); + btLampkaBezoporowaB.Clear(); + btLampkaMaxSila.Clear(); + btLampkaPrzekrMaxSila.Clear(); + btLampkaRadio.Clear(); + btLampkaHamulecReczny.Clear(); + btLampkaBlokadaDrzwi.Clear(); + btLampkaUniversal3.Clear(); + btLampkaWentZaluzje.Clear(); + btLampkaOgrzewanieSkladu.Clear(11); + btLampkaSHP.Clear(0); + btLampkaCzuwaka.Clear(1); + btLampkaDoorLeft.Clear(); + btLampkaDoorRight.Clear(); + btLampkaDepartureSignal.Clear(); + btLampkaRezerwa.Clear(); + btLampkaBoczniki.Clear(); + btLampkaBocznik1.Clear(); + btLampkaBocznik2.Clear(); + btLampkaBocznik3.Clear(); + btLampkaBocznik4.Clear(); + btLampkaRadiotelefon.Clear(); + btLampkaHamienie.Clear(); + btLampkaSprezarka.Clear(); + btLampkaSprezarkaB.Clear(); + btLampkaNapNastHam.Clear(); + btLampkaJazda.Clear(); + btLampkaStycznB.Clear(); + btLampkaHamowanie1zes.Clear(); + btLampkaHamowanie2zes.Clear(); + btLampkaNadmPrzetwB.Clear(); + btLampkaPrzetwB.Clear(); + btLampkaWylSzybkiB.Clear(); + btLampkaForward.Clear(); + btLampkaBackward.Clear(); + btCabLight.Clear(); //hunter-171012 + ggLeftLightButton.Clear(); + ggRightLightButton.Clear(); + ggUpperLightButton.Clear(); + ggLeftEndLightButton.Clear(); + ggRightEndLightButton.Clear(); + //hunter-230112 + ggRearLeftLightButton.Clear(); + ggRearRightLightButton.Clear(); + ggRearUpperLightButton.Clear(); + ggRearLeftEndLightButton.Clear(); + ggRearRightEndLightButton.Clear(); + btHaslerBrakes.Clear(12); //ciśnienie w cylindrach do odbijania na haslerze + btHaslerCurrent.Clear(13); //prąd na silnikach do odbijania na haslerze + } + //SEKCJA REGULATOROW + else if (str==AnsiString("mainctrl:")) //nastawnik + { + if (!DynamicObject->mdKabina) + { + delete Parser; + WriteLog("Cab not initialised!"); + return false; + } + else + ggMainCtrl.Load(Parser,DynamicObject->mdKabina); + } + else if (str==AnsiString("mainctrlact:")) //zabek pozycji aktualnej + ggMainCtrlAct.Load(Parser,DynamicObject->mdKabina); + else if (str==AnsiString("scndctrl:")) //bocznik + ggScndCtrl.Load(Parser,DynamicObject->mdKabina); + else if (str==AnsiString("dirkey:")) //klucz kierunku + ggDirKey.Load(Parser,DynamicObject->mdKabina); + else if (str==AnsiString("brakectrl:")) //hamulec zasadniczy + ggBrakeCtrl.Load(Parser,DynamicObject->mdKabina); + else if (str==AnsiString("localbrake:")) //hamulec pomocniczy + ggLocalBrake.Load(Parser,DynamicObject->mdKabina); + else if (str==AnsiString("manualbrake:")) //hamulec reczny + ggManualBrake.Load(Parser,DynamicObject->mdKabina); + //sekcja przelacznikow obrotowych + else if (str==AnsiString("brakeprofile_sw:")) //przelacznik tow/osob/posp + ggBrakeProfileCtrl.Load(Parser,DynamicObject->mdKabina); + else if (str==AnsiString("brakeprofileg_sw:")) //przelacznik tow/osob + ggBrakeProfileG.Load(Parser,DynamicObject->mdKabina); + else if (str==AnsiString("brakeprofiler_sw:")) //przelacznik osob/posp + ggBrakeProfileR.Load(Parser,DynamicObject->mdKabina); + else if (str==AnsiString("maxcurrent_sw:")) //przelacznik rozruchu + ggMaxCurrentCtrl.Load(Parser,DynamicObject->mdKabina); + //SEKCJA przyciskow sprezynujacych + else if (str==AnsiString("main_off_bt:")) //przycisk wylaczajacy (w EU07 wyl szybki czerwony) + ggMainOffButton.Load(Parser,DynamicObject->mdKabina); + else if (str==AnsiString("main_on_bt:")) //przycisk wlaczajacy (w EU07 wyl szybki zielony) + ggMainOnButton.Load(Parser,DynamicObject->mdKabina); + else if (str==AnsiString("security_reset_bt:")) //przycisk zbijajacy SHP/czuwak + ggSecurityResetButton.Load(Parser,DynamicObject->mdKabina); + else if (str==AnsiString("releaser_bt:")) //przycisk odluzniacza + ggReleaserButton.Load(Parser,DynamicObject->mdKabina); + else if (str==AnsiString("releaser_bt:")) //przycisk odluzniacza + ggReleaserButton.Load(Parser,DynamicObject->mdKabina); + else if (str==AnsiString("antislip_bt:")) //przycisk antyposlizgowy + ggAntiSlipButton.Load(Parser,DynamicObject->mdKabina); + else if (str==AnsiString("horn_bt:")) //dzwignia syreny + ggHornButton.Load(Parser,DynamicObject->mdKabina); + else if (str==AnsiString("fuse_bt:")) //bezp. nadmiarowy + ggFuseButton.Load(Parser,DynamicObject->mdKabina); + else if (str==AnsiString("converterfuse_bt:")) //hunter-261211: odblokowanie przekaznika nadm. przetw. i ogrz. + ggConverterFuseButton.Load(Parser,DynamicObject->mdKabina); + else if (str==AnsiString("stlinoff_bt:")) //st. liniowe + ggStLinOffButton.Load(Parser,DynamicObject->mdKabina); + else if (str==AnsiString("door_left_sw:")) //drzwi lewe + ggDoorLeftButton.Load(Parser,DynamicObject->mdKabina); + else if (str==AnsiString("door_right_sw:")) //drzwi prawe + ggDoorRightButton.Load(Parser,DynamicObject->mdKabina); + else if (str==AnsiString("departure_signal_bt:")) //sygnal odjazdu + ggDepartureSignalButton.Load(Parser,DynamicObject->mdKabina); + else if (str==AnsiString("upperlight_sw:")) //swiatlo + ggUpperLightButton.Load(Parser,DynamicObject->mdKabina); + else if (str==AnsiString("leftlight_sw:")) //swiatlo + ggLeftLightButton.Load(Parser,DynamicObject->mdKabina); + else if (str==AnsiString("rightlight_sw:")) //swiatlo + ggRightLightButton.Load(Parser,DynamicObject->mdKabina); + else if (str==AnsiString("leftend_sw:")) //swiatlo + ggLeftEndLightButton.Load(Parser,DynamicObject->mdKabina); + else if (str==AnsiString("rightend_sw:")) //swiatlo + ggRightEndLightButton.Load(Parser,DynamicObject->mdKabina); + //--------------------- + //hunter-230112: przelaczniki swiatel tylnich + else if (str==AnsiString("rearupperlight_sw:")) //swiatlo + ggRearUpperLightButton.Load(Parser,DynamicObject->mdKabina); + else if (str==AnsiString("rearleftlight_sw:")) //swiatlo + ggRearLeftLightButton.Load(Parser,DynamicObject->mdKabina); + else if (str==AnsiString("rearrightlight_sw:")) //swiatlo + ggRearRightLightButton.Load(Parser,DynamicObject->mdKabina); + else if (str==AnsiString("rearleftend_sw:")) //swiatlo + ggRearLeftEndLightButton.Load(Parser,DynamicObject->mdKabina); + else if (str==AnsiString("rearrightend_sw:")) //swiatlo + ggRearRightEndLightButton.Load(Parser,DynamicObject->mdKabina); + //------------------ + else if (str==AnsiString("compressor_sw:")) //sprezarka + ggCompressorButton.Load(Parser,DynamicObject->mdKabina); + else if (str==AnsiString("converter_sw:")) //przetwornica + ggConverterButton.Load(Parser,DynamicObject->mdKabina); + else if (str==AnsiString("converteroff_sw:")) //przetwornica wyl + ggConverterOffButton.Load(Parser,DynamicObject->mdKabina); + else if (str==AnsiString("main_sw:")) //wyl szybki (ezt) + ggMainButton.Load(Parser,DynamicObject->mdKabina); + else if (str==AnsiString("radio_sw:")) //radio + ggRadioButton.Load(Parser,DynamicObject->mdKabina); + else if (str==AnsiString("pantfront_sw:")) //patyk przedni + ggPantFrontButton.Load(Parser,DynamicObject->mdKabina); + else if (str==AnsiString("pantrear_sw:")) //patyk tylny + ggPantRearButton.Load(Parser,DynamicObject->mdKabina); + else if (str==AnsiString("pantfrontoff_sw:")) //patyk przedni w dol + ggPantFrontButtonOff.Load(Parser,DynamicObject->mdKabina); + else if (str==AnsiString("pantalloff_sw:")) //patyk przedni w dol + ggPantAllDownButton.Load(Parser,DynamicObject->mdKabina); + else if (str==AnsiString("trainheating_sw:")) //grzanie skladu + ggTrainHeatingButton.Load(Parser,DynamicObject->mdKabina); + else if (str==AnsiString("signalling_sw:")) //Sygnalizacja hamowania + ggSignallingButton.Load(Parser,DynamicObject->mdKabina); + else if (str==AnsiString("door_signalling_sw:")) //Sygnalizacja blokady drzwi + ggDoorSignallingButton.Load(Parser,DynamicObject->mdKabina); + else if (str==AnsiString("nextcurrent_sw:")) //grzanie skladu + ggNextCurrentButton.Load(Parser,DynamicObject->mdKabina); + else if (str==AnsiString("cablight_sw:")) //hunter-091012: swiatlo w kabinie + ggCabLightButton.Load(Parser,DynamicObject->mdKabina); + else if (str==AnsiString("cablightdim_sw:")) + ggCabLightDimButton.Load(Parser,DynamicObject->mdKabina); //hunter-091012: przyciemnienie swiatla w kabinie + //ABu 090305: uniwersalne przyciski lub inne rzeczy + else if (str==AnsiString("universal1:")) + ggUniversal1Button.Load(Parser,DynamicObject->mdKabina,DynamicObject->mdModel); + else if (str==AnsiString("universal2:")) + ggUniversal2Button.Load(Parser,DynamicObject->mdKabina,DynamicObject->mdModel); + else if (str==AnsiString("universal3:")) + ggUniversal3Button.Load(Parser,DynamicObject->mdKabina,DynamicObject->mdModel); + else if (str==AnsiString("universal4:")) + ggUniversal4Button.Load(Parser,DynamicObject->mdKabina,DynamicObject->mdModel); + //SEKCJA WSKAZNIKOW + else if ((str==AnsiString("tachometer:"))||(str==AnsiString("tachometerb:"))) + {//predkosciomierz wskazówkowy z szarpaniem + gg=Cabine[cabindex].Gauge(-1); //pierwsza wolna gałka + gg->Load(Parser,DynamicObject->mdKabina); + gg->AssignFloat(&fTachoVelocityJump); + } + else if (str==AnsiString("tachometern:")) + {//predkosciomierz wskazówkowy bez szarpania + gg=Cabine[cabindex].Gauge(-1); //pierwsza wolna gałka + gg->Load(Parser,DynamicObject->mdKabina); + gg->AssignFloat(&fTachoVelocity); + } + else if (str==AnsiString("tachometerd:")) + {//predkosciomierz cyfrowy + gg=Cabine[cabindex].Gauge(-1); //pierwsza wolna gałka + gg->Load(Parser,DynamicObject->mdKabina); + gg->AssignFloat(&fTachoVelocity); + } + else if ((str==AnsiString("hvcurrent1:"))||(str==AnsiString("hvcurrent1b:"))) + {//1szy amperomierz + gg=Cabine[cabindex].Gauge(-1); //pierwsza wolna gałka + gg->Load(Parser,DynamicObject->mdKabina); + gg->AssignFloat(fHCurrent+1); + } + else if ((str==AnsiString("hvcurrent2:"))||(str==AnsiString("hvcurrent2b:"))) + {//2gi amperomierz + gg=Cabine[cabindex].Gauge(-1); //pierwsza wolna gałka + gg->Load(Parser,DynamicObject->mdKabina); + gg->AssignFloat(fHCurrent+2); + } + else if ((str==AnsiString("hvcurrent3:"))||(str==AnsiString("hvcurrent3b:"))) + {//3ci amperomierz + gg=Cabine[cabindex].Gauge(-1); //pierwsza wolna gałka + gg->Load(Parser,DynamicObject->mdKabina); + gg->AssignFloat(fHCurrent+3); + } + else if ((str==AnsiString("hvcurrent:"))||(str==AnsiString("hvcurrentb:"))) + {//amperomierz calkowitego pradu + gg=Cabine[cabindex].Gauge(-1); //pierwsza wolna gałka + gg->Load(Parser,DynamicObject->mdKabina); + gg->AssignFloat(fHCurrent); + } + else if ((str==AnsiString("brakepress:"))||(str==AnsiString("brakepressb:"))) + {//manometr cylindrow hamulcowych //Ra 2014-08: przeniesione do TCab + gg=Cabine[cabindex].Gauge(-1); //pierwsza wolna gałka + gg->Load(Parser,DynamicObject->mdKabina,NULL,0.1); + gg->AssignDouble(&mvOccupied->BrakePress); + } + else if ((str==AnsiString("pipepress:"))||(str==AnsiString("pipepressb:"))) + {//manometr przewodu hamulcowego + TGauge *gg=Cabine[cabindex].Gauge(-1); //pierwsza wolna gałka + gg->Load(Parser,DynamicObject->mdKabina,NULL,0.1); + gg->AssignDouble(&mvOccupied->PipePress); + } + else if (str==AnsiString("limpipepress:")) //manometr zbiornika sterujacego zaworu maszynisty + ggZbS.Load(Parser,DynamicObject->mdKabina,NULL,0.1); + else if (str==AnsiString("cntrlpress:")) + {//manometr zbiornika kontrolnego/rorządu + gg=Cabine[cabindex].Gauge(-1); //pierwsza wolna gałka + gg->Load(Parser,DynamicObject->mdKabina,NULL,0.1); + gg->AssignDouble(&mvControlled->PantPress); + } + else if ((str==AnsiString("compressor:"))||(str==AnsiString("compressorb:"))) + {//manometr sprezarki/zbiornika glownego + gg=Cabine[cabindex].Gauge(-1); //pierwsza wolna gałka + gg->Load(Parser,DynamicObject->mdKabina,NULL,0.1); + gg->AssignDouble(&mvOccupied->Compressor); + } + //yB - dla drugiej sekcji + else if (str==AnsiString("hvbcurrent1:")) //1szy amperomierz + ggI1B.Load(Parser,DynamicObject->mdKabina); + else if (str==AnsiString("hvbcurrent2:")) //2gi amperomierz + ggI2B.Load(Parser,DynamicObject->mdKabina); + else if (str==AnsiString("hvbcurrent3:")) //3ci amperomierz + ggI3B.Load(Parser,DynamicObject->mdKabina); + else if (str==AnsiString("hvbcurrent:")) //amperomierz calkowitego pradu + ggItotalB.Load(Parser,DynamicObject->mdKabina); + //************************************************************* + else if (str==AnsiString("clock:")) //zegar analogowy + { + if (Parser->GetNextSymbol()==AnsiString("analog")) + { + //McZapkie-300302: zegarek + ggClockSInd.Init(DynamicObject->mdKabina->GetFromName("ClockShand"),gt_Rotate,0.016666667,0,0); + ggClockMInd.Init(DynamicObject->mdKabina->GetFromName("ClockMhand"),gt_Rotate,0.016666667,0,0); + ggClockHInd.Init(DynamicObject->mdKabina->GetFromName("ClockHhand"),gt_Rotate,0.083333333,0,0); + } + } + else if (str==AnsiString("evoltage:")) //woltomierz napiecia silnikow + ggEngineVoltage.Load(Parser,DynamicObject->mdKabina); + else if (str==AnsiString("hvoltage:")) + {//woltomierz wysokiego napiecia + gg=Cabine[cabindex].Gauge(-1); //pierwsza wolna gałka + gg->Load(Parser,DynamicObject->mdKabina); + gg->AssignFloat(&fHVoltage); + } + else if (str==AnsiString("lvoltage:")) //woltomierz niskiego napiecia + ggLVoltage.Load(Parser,DynamicObject->mdKabina); + else if (str==AnsiString("enrot1m:")) + {//obrotomierz + gg=Cabine[cabindex].Gauge(-1); //pierwsza wolna gałka + gg->Load(Parser,DynamicObject->mdKabina); + gg->AssignFloat(fEngine+1); + } //ggEnrot1m.Load(Parser,DynamicObject->mdKabina); + else if (str==AnsiString("enrot2m:")) + {//obrotomierz + gg=Cabine[cabindex].Gauge(-1); //pierwsza wolna gałka + gg->Load(Parser,DynamicObject->mdKabina); + gg->AssignFloat(fEngine+2); + } //ggEnrot2m.Load(Parser,DynamicObject->mdKabina); + else if (str==AnsiString("enrot3m:")) + {//obrotomierz + gg=Cabine[cabindex].Gauge(-1); //pierwsza wolna gałka + gg->Load(Parser,DynamicObject->mdKabina); + gg->AssignFloat(fEngine+3); + } //ggEnrot3m.Load(Parser,DynamicObject->mdKabina); + else if (str==AnsiString("engageratio:")) + {//np. ciśnienie sterownika sprzęgła + gg=Cabine[cabindex].Gauge(-1); //pierwsza wolna gałka + gg->Load(Parser,DynamicObject->mdKabina); + gg->AssignDouble(&mvControlled->dizel_engage); + } //ggEngageRatio.Load(Parser,DynamicObject->mdKabina); + else if (str==AnsiString("maingearstatus:")) //np. ciśnienie sterownika skrzyni biegów + ggMainGearStatus.Load(Parser,DynamicObject->mdKabina); + else if (str==AnsiString("ignitionkey:")) // + ggIgnitionKey.Load(Parser,DynamicObject->mdKabina); + else if (str==AnsiString("distcounter:")) + {//Ra 2014-07: licznik kilometrów + gg=Cabine[cabindex].Gauge(-1); //pierwsza wolna gałka + gg->Load(Parser,DynamicObject->mdKabina); + gg->AssignDouble(&mvControlled->DistCounter); + } + //SEKCJA LAMPEK + else if (str==AnsiString("i-maxft:")) + btLampkaMaxSila.Load(Parser,DynamicObject->mdKabina); + else if (str==AnsiString("i-maxftt:")) + btLampkaPrzekrMaxSila.Load(Parser,DynamicObject->mdKabina); + else if (str==AnsiString("i-radio:")) + btLampkaRadio.Load(Parser,DynamicObject->mdKabina); + else if (str==AnsiString("i-manual_brake:")) + btLampkaHamulecReczny.Load(Parser,DynamicObject->mdKabina); + else if (str==AnsiString("i-door_blocked:")) + btLampkaBlokadaDrzwi.Load(Parser,DynamicObject->mdKabina); + else if (str==AnsiString("i-slippery:")) + btLampkaPoslizg.Load(Parser,DynamicObject->mdKabina); + else if (str==AnsiString("i-contactors:")) + btLampkaStyczn.Load(Parser,DynamicObject->mdKabina); + else if (str==AnsiString("i-conv_ovld:")) + btLampkaNadmPrzetw.Load(Parser,DynamicObject->mdKabina); + else if (str==AnsiString("i-converter:")) + btLampkaPrzetw.Load(Parser,DynamicObject->mdKabina); + else if (str==AnsiString("i-diff_relay:")) + btLampkaPrzekRozn.Load(Parser,DynamicObject->mdKabina); + else if (str==AnsiString("i-diff_relay2:")) + btLampkaPrzekRoznPom.Load(Parser,DynamicObject->mdKabina); + else if (str==AnsiString("i-motor_ovld:")) + btLampkaNadmSil.Load(Parser,DynamicObject->mdKabina); + else if (str==AnsiString("i-train_controll:")) + btLampkaUkrotnienie.Load(Parser,DynamicObject->mdKabina); + else if (str==AnsiString("i-brake_delay_r:")) + btLampkaHamPosp.Load(Parser,DynamicObject->mdKabina); + else if (str==AnsiString("i-mainbreaker:")) + btLampkaWylSzybki.Load(Parser,DynamicObject->mdKabina); + else if (str==AnsiString("i-vent_ovld:")) + btLampkaNadmWent.Load(Parser,DynamicObject->mdKabina); + else if (str==AnsiString("i-comp_ovld:")) + btLampkaNadmSpr.Load(Parser,DynamicObject->mdKabina); + else if (str==AnsiString("i-resistors:")) + btLampkaOpory.Load(Parser,DynamicObject->mdKabina); + else if (str==AnsiString("i-no_resistors:")) + btLampkaBezoporowa.Load(Parser,DynamicObject->mdKabina); + else if (str==AnsiString("i-no_resistors_b:")) + btLampkaBezoporowaB.Load(Parser,DynamicObject->mdKabina); + else if (str==AnsiString("i-highcurrent:")) + btLampkaWysRozr.Load(Parser,DynamicObject->mdKabina); + else if (str==AnsiString("i-universal3:")) + { + btLampkaUniversal3.Load(Parser,DynamicObject->mdKabina,DynamicObject->mdModel); + LampkaUniversal3_typ=0; + } + else if (str==AnsiString("i-universal3_M:")) + { + btLampkaUniversal3.Load(Parser,DynamicObject->mdKabina,DynamicObject->mdModel); + LampkaUniversal3_typ=1; + } + else if (str==AnsiString("i-universal3_C:")) + { + btLampkaUniversal3.Load(Parser,DynamicObject->mdKabina,DynamicObject->mdModel); + LampkaUniversal3_typ=2; + } + else if (str==AnsiString("i-vent_trim:")) + btLampkaWentZaluzje.Load(Parser,DynamicObject->mdKabina); + else if (str==AnsiString("i-trainheating:")) + btLampkaOgrzewanieSkladu.Load(Parser,DynamicObject->mdKabina); + else if (str==AnsiString("i-security_aware:")) + btLampkaCzuwaka.Load(Parser,DynamicObject->mdKabina); + else if (str==AnsiString("i-security_cabsignal:")) + btLampkaSHP.Load(Parser,DynamicObject->mdKabina); + else if (str==AnsiString("i-door_left:")) + btLampkaDoorLeft.Load(Parser,DynamicObject->mdKabina); + else if (str==AnsiString("i-door_right:")) + btLampkaDoorRight.Load(Parser,DynamicObject->mdKabina); + else if (str==AnsiString("i-departure_signal:")) + btLampkaDepartureSignal.Load(Parser,DynamicObject->mdKabina); + else if (str==AnsiString("i-reserve:")) + btLampkaRezerwa.Load(Parser,DynamicObject->mdKabina); + else if (str==AnsiString("i-scnd:")) + btLampkaBoczniki.Load(Parser,DynamicObject->mdKabina); + else if (str==AnsiString("i-scnd1:")) + btLampkaBocznik1.Load(Parser,DynamicObject->mdKabina); + else if (str==AnsiString("i-scnd2:")) + btLampkaBocznik2.Load(Parser,DynamicObject->mdKabina); + else if (str==AnsiString("i-scnd3:")) + btLampkaBocznik3.Load(Parser,DynamicObject->mdKabina); + else if (str==AnsiString("i-scnd4:")) + btLampkaBocznik4.Load(Parser,DynamicObject->mdKabina); + else if (str==AnsiString("i-braking:")) + btLampkaHamienie.Load(Parser,DynamicObject->mdKabina); + else if (str==AnsiString("i-braking-ezt:")) + btLampkaHamowanie1zes.Load(Parser,DynamicObject->mdKabina); + else if (str==AnsiString("i-braking-ezt2:")) + btLampkaHamowanie2zes.Load(Parser,DynamicObject->mdKabina); + else if (str==AnsiString("i-compressor:")) + btLampkaSprezarka.Load(Parser,DynamicObject->mdKabina); + else if (str==AnsiString("i-compressorb:")) + btLampkaSprezarkaB.Load(Parser,DynamicObject->mdKabina); + else if (str==AnsiString("i-voltbrake:")) + btLampkaNapNastHam.Load(Parser,DynamicObject->mdKabina); + else if (str==AnsiString("i-mainbreakerb:")) + btLampkaWylSzybkiB.Load(Parser,DynamicObject->mdKabina); + else if (str==AnsiString("i-resistorsb:")) + btLampkaOporyB.Load(Parser,DynamicObject->mdKabina); + else if (str==AnsiString("i-contactorsb:")) + btLampkaStycznB.Load(Parser,DynamicObject->mdKabina); + else if (str==AnsiString("i-conv_ovldb:")) + btLampkaNadmPrzetwB.Load(Parser,DynamicObject->mdKabina); + else if (str==AnsiString("i-converterb:")) + btLampkaPrzetwB.Load(Parser,DynamicObject->mdKabina); + else if (str==AnsiString("i-forward:")) + btLampkaForward.Load(Parser,DynamicObject->mdKabina); + else if (str==AnsiString("i-backward:")) + btLampkaBackward.Load(Parser,DynamicObject->mdKabina); + else if (str==AnsiString("i-cablight:")) //hunter-171012 + btCabLight.Load(Parser,DynamicObject->mdKabina); + //btLampkaUnknown.Init("unknown",mdKabina,false); + } + } + else + {delete Parser; + return false; + } + //ABu 050205: tego wczesniej nie bylo: + delete Parser; + if (DynamicObject->mdKabina) + { + DynamicObject->mdKabina->Init(); //obrócenie modelu oraz optymalizacja, również zapisanie binarnego + return true; + } + return AnsiCompareStr(str,AnsiString("none")); +} + +void __fastcall TTrain::MechStop() +{//likwidacja ruchu kamery w kabinie (po powrocie przez [F4]) + pMechPosition=vector3(0,0,0); + pMechShake=vector3(0,0,0); + vMechMovement=vector3(0,0,0); + vMechVelocity=vector3(0,0,0); //tu zostawały jakieś ułamki, powodujące uciekanie kamery +}; + +vector3 __fastcall TTrain::MirrorPosition(bool lewe) +{//zwraca współrzędne widoku kamery z lusterka + switch (iCabn) + { + case 1: //przednia (1) + return DynamicObject->mMatrix*vector3(lewe?Cabine[iCabn].CabPos2.x:Cabine[iCabn].CabPos1.x,1.5+Cabine[iCabn].CabPos1.y,Cabine[iCabn].CabPos2.z); + case 2: //tylna (-1) + return DynamicObject->mMatrix*vector3(lewe?Cabine[iCabn].CabPos1.x:Cabine[iCabn].CabPos2.x,1.5+Cabine[iCabn].CabPos1.y,Cabine[iCabn].CabPos1.z); + } + return DynamicObject->GetPosition(); //współrzędne środka pojazdu +}; + +void __fastcall TTrain::DynamicSet(TDynamicObject *d) +{//taka proteza: chcę podłączyć kabinę EN57 bezpośrednio z silnikowym, aby nie robić tego przez ukrotnienie + //drugi silnikowy i tak musi być ukrotniony, podobnie jak kolejna jednostka + //problem się robi ze światłami, które będą zapalane w silnikowym, ale muszą świecić się w rozrządczych + //dla EZT światła czołowe będą "zapalane w silnikowym", ale widziane z rozrządczych + //również wczytywanie MMD powinno dotyczyć aktualnego członu + //problematyczna może być kwestia wybranej kabiny (w silnikowym...) + //jeśli silnikowy będzie zapięty odwrotnie (tzn. -1), to i tak powinno jeździć dobrze + //również hamowanie wykonuje się zaworem w członie, a nie w silnikowym... + DynamicObject=d; //jedyne miejsce zmiany + mvOccupied=mvControlled=d?DynamicObject->MoverParameters:NULL; //albo silnikowy w EZT + if (!DynamicObject) return; + if (mvControlled->TrainType&dt_EZT) //na razie dotyczy to EZT + if (DynamicObject->NextConnected?mvControlled->Couplers[1].AllowedFlag&ctrain_depot:false) + {//gdy jest człon od sprzęgu 1, a sprzęg łączony warsztatowo (powiedzmy) + if ((mvControlled->Power<1.0)&&(mvControlled->Couplers[1].Connected->Power>1.0)) //my nie mamy mocy, ale ten drugi ma + mvControlled=DynamicObject->NextConnected->MoverParameters; //będziemy sterować tym z mocą + } + else if (DynamicObject->PrevConnected?mvControlled->Couplers[0].AllowedFlag&ctrain_depot:false) + {//gdy jest człon od sprzęgu 0, a sprzęg łączony warsztatowo (powiedzmy) + if ((mvControlled->Power<1.0)&&(mvControlled->Couplers[0].Connected->Power>1.0)) //my nie mamy mocy, ale ten drugi ma + mvControlled=DynamicObject->PrevConnected->MoverParameters; //będziemy sterować tym z mocą + } + mvSecond=NULL; //gdyby się nic nie znalazło + if (mvOccupied->Power>1.0) //dwuczłonowe lub ukrotnienia, żeby nie szukać każdorazowo + if (mvOccupied->Couplers[1].Connected?mvOccupied->Couplers[1].AllowedFlag&ctrain_controll:false) + {//gdy jest człon od sprzęgu 1, a sprzęg łączony warsztatowo (powiedzmy) + if (mvOccupied->Couplers[1].Connected->Power>1.0) //ten drugi ma moc + mvSecond=(TMoverParameters*)mvOccupied->Couplers[1].Connected; //wskaźnik na drugiego + } + else if (mvOccupied->Couplers[0].Connected?mvOccupied->Couplers[0].AllowedFlag&ctrain_controll:false) + {//gdy jest człon od sprzęgu 0, a sprzęg łączony warsztatowo (powiedzmy) + if (mvOccupied->Couplers[0].Connected->Power>1.0) //ale ten drugi ma moc + mvSecond=(TMoverParameters*)mvOccupied->Couplers[0].Connected; //wskaźnik na drugiego + } +}; + +void __fastcall TTrain::Silence() +{//wyciszenie dźwięków przy wychodzeniu + if (dsbNastawnikJazdy) dsbNastawnikJazdy->Stop(); + if (dsbNastawnikBocz) dsbNastawnikBocz->Stop(); + if (dsbRelay) dsbRelay->Stop(); + if (dsbPneumaticRelay) dsbPneumaticRelay->Stop(); + if (dsbSwitch) dsbSwitch->Stop(); + if (dsbPneumaticSwitch) dsbPneumaticSwitch->Stop(); + if (dsbReverserKey) dsbReverserKey->Stop(); + if (dsbCouplerAttach) dsbCouplerAttach->Stop(); + if (dsbCouplerDetach) dsbCouplerDetach->Stop(); + if (dsbDieselIgnition) dsbDieselIgnition->Stop(); + if (dsbDoorClose) dsbDoorClose->Stop(); + if (dsbDoorOpen) dsbDoorOpen->Stop(); + if (dsbPantUp) dsbPantUp->Stop(); + if (dsbPantDown) dsbPantDown->Stop(); + if (dsbWejscie_na_bezoporow) dsbWejscie_na_bezoporow->Stop(); + if (dsbWejscie_na_drugi_uklad) dsbWejscie_na_drugi_uklad->Stop(); + rsBrake.Stop(); + rsSlippery.Stop(); + rsHiss.Stop(); + rsHissU.Stop(); + rsHissE.Stop(); + rsHissX.Stop(); + rsHissT.Stop(); + rsSBHiss.Stop(); + rsRunningNoise.Stop(); + rsEngageSlippery.Stop(); + rsFadeSound.Stop(); + if (dsbHasler) dsbHasler->Stop(); //wyłączenie dźwięków opuszczanej kabiny + if (dsbBuzzer) dsbBuzzer->Stop(); + if (dsbSlipAlarm) dsbSlipAlarm->Stop(); //dźwięk alarmu przy poślizgu + //sConverter.Stop(); + //sSmallCompressor->Stop(); + if (dsbCouplerStretch) dsbCouplerStretch->Stop(); + if (dsbEN57_CouplerStretch) dsbEN57_CouplerStretch->Stop(); + if (dsbBufferClamp) dsbBufferClamp->Stop(); +}; + diff --git a/Train.h b/Train.h new file mode 100644 index 00000000..b718e359 --- /dev/null +++ b/Train.h @@ -0,0 +1,376 @@ +//--------------------------------------------------------------------------- + +#ifndef TrainH +#define TrainH + +#include "Track.h" +#include "TrkFoll.h" +#include "Model3d.h" +#include "Spring.h" +#include "Gauge.h" +#include "Button.h" +#include "DynObj.h" +#include "mtable.hpp" + +#include "Sound.h" +#include "AdvSound.h" +#include "RealSound.h" +#include "FadeSound.h" + + +// typedef enum {st_Off, st_Starting, st_On, st_ShuttingDown} T4State; + +const int maxcab=2; + +// const double fCzuwakTime= 90.0f; +const double fCzuwakBlink=0.15; +const float fConverterPrzekaznik=1.5; //hunter-261211: do przekaznika nadmiarowego przetwornicy + //0.33f +// const double fBuzzerTime= 5.0f; +const float fHaslerTime=1.2; + +// const double fStycznTime= 0.5f; +// const double fDblClickTime= 0.2f; + +class TCab +{ +public: + __fastcall TCab(); + __fastcall ~TCab(); + void __fastcall Init(double Initx1,double Inity1,double Initz1,double Initx2,double Inity2,double Initz2,bool InitEnabled,bool InitOccupied); + void __fastcall Load(TQueryParserComp *Parser); + vector3 CabPos1; + vector3 CabPos2; + bool bEnabled; + bool bOccupied; + double dimm_r, dimm_g, dimm_b; //McZapkie-120503: tlumienie swiatla + double intlit_r, intlit_g, intlit_b; //McZapkie-120503: oswietlenie kabiny + double intlitlow_r, intlitlow_g, intlitlow_b; //McZapkie-120503: przyciemnione oswietlenie kabiny +private: + //bool bChangePossible; + TGauge *ggList; //Ra 2014-08: lista animacji macierzowych (gałek) w kabinie + int iGaugesMax,iGauges; //ile miejsca w tablicy i ile jest w użyciu + TButton *btList; //Ra 2014-08: lista animacji dwustanowych (lampek) w kabinie + int iButtonsMax,iButtons; //ile miejsca w tablicy i ile jest w użyciu +public: + TGauge* __fastcall Gauge(int n=-1); //pobranie adresu obiektu + TButton* __fastcall Button(int n=-1); //pobranie adresu obiektu + void __fastcall Update(); +}; + + +class TTrain +{ +public: + bool CabChange(int iDirection); + bool ActiveUniversal4; + bool ShowNextCurrent; //pokaz przd w podlaczonej lokomotywie (ET41) + bool InitializeCab(int NewCabNo, AnsiString asFileName); + __fastcall TTrain(); + __fastcall ~TTrain(); +// bool __fastcall Init(TTrack *Track); +//McZapkie-010302 + bool __fastcall Init(TDynamicObject *NewDynamicObject,bool e3d=false); + void __fastcall OnKeyDown(int cKey); + void __fastcall OnKeyUp(int cKey); + +// bool __fastcall SHP() { fShpTimer= 0; }; + + inline vector3 __fastcall GetDirection() { return DynamicObject->VectorFront(); }; + inline vector3 __fastcall GetUp() { return DynamicObject->VectorUp(); }; + void __fastcall UpdateMechPosition(double dt); + bool __fastcall Update(); + void __fastcall MechStop(); +// virtual bool __fastcall RenderAlpha(); +//McZapkie-310302: ladowanie parametrow z pliku + bool __fastcall LoadMMediaFile(AnsiString asFileName); + +private: //żeby go nic z zewnątrz nie przestawiało + TDynamicObject *DynamicObject; //przestawia zmiana pojazdu [F5] +private: //żeby go nic z zewnątrz nie przestawiało + TMoverParameters *mvControlled; //człon, w którym sterujemy silnikiem + TMoverParameters *mvOccupied; //człon, w którym sterujemy hamulcem + TMoverParameters *mvSecond; //drugi człon (ET40, ET41, ET42, ukrotnienia) + TMoverParameters *mvThird; //trzeci człon (SN61) +public: //reszta może być publiczna + + //AnsiString asMessage; + +//McZapkie: definicje wskaźników +//Ra 2014-08: częsciowo przeniesione do tablicy w TCab + TGauge ggZbS; + TGauge ggClockSInd; + TGauge ggClockMInd; + TGauge ggClockHInd; + //TGauge ggHVoltage; + TGauge ggLVoltage; + //TGauge ggEnrot1m; + //TGauge ggEnrot2m; + //TGauge ggEnrot3m; + //TGauge ggEngageRatio; + TGauge ggMainGearStatus; + + TGauge ggEngineVoltage; + TGauge ggI1B; //drugi człon w postaci jawnej + TGauge ggI2B; + TGauge ggI3B; + TGauge ggItotalB; + +//McZapkie: definicje regulatorow + TGauge ggMainCtrl; + TGauge ggMainCtrlAct; + TGauge ggScndCtrl; + TGauge ggScndCtrlButton; + TGauge ggDirKey; + TGauge ggBrakeCtrl; + TGauge ggLocalBrake; + TGauge ggManualBrake; + TGauge ggBrakeProfileCtrl; //nastawiacz GPR - przelacznik obrotowy + TGauge ggBrakeProfileG; //nastawiacz GP - hebelek towarowy + TGauge ggBrakeProfileR; //nastawiacz PR - hamowanie dwustopniowe + + TGauge ggMaxCurrentCtrl; + + TGauge ggMainOffButton; + TGauge ggMainOnButton; + TGauge ggMainButton; //EZT + TGauge ggSecurityResetButton; + TGauge ggReleaserButton; + TGauge ggAntiSlipButton; + TGauge ggFuseButton; + TGauge ggConverterFuseButton; //hunter-261211: przycisk odblokowania nadmiarowego przetwornic i ogrzewania + TGauge ggStLinOffButton; + TGauge ggRadioButton; + TGauge ggUpperLightButton; + TGauge ggLeftLightButton; + TGauge ggRightLightButton; + TGauge ggLeftEndLightButton; + TGauge ggRightEndLightButton; + + //hunter-230112: przelacznik swiatel tylnich + TGauge ggRearUpperLightButton; + TGauge ggRearLeftLightButton; + TGauge ggRearRightLightButton; + TGauge ggRearLeftEndLightButton; + TGauge ggRearRightEndLightButton; + + TGauge ggIgnitionKey; + + TGauge ggCompressorButton; + TGauge ggConverterButton; + TGauge ggConverterOffButton; + +//ABu 090305 - syrena i prad nastepnego czlonu + TGauge ggHornButton; + TGauge ggNextCurrentButton; +//ABu 090305 - uniwersalne przyciski + TGauge ggUniversal1Button; + TGauge ggUniversal2Button; + TGauge ggUniversal3Button; + TGauge ggUniversal4Button; + + TGauge ggCabLightButton; //hunter-091012: przelacznik oswietlania kabiny + TGauge ggCabLightDimButton; //hunter-091012: przelacznik przyciemnienia oswietlenia kabiny + +//NBMX wrzesien 2003 - obsluga drzwi + TGauge ggDoorLeftButton; + TGauge ggDoorRightButton; + TGauge ggDepartureSignalButton; + +//Winger 160204 - obsluga pantografow - ZROBIC + TGauge ggPantFrontButton; + TGauge ggPantRearButton; + TGauge ggPantFrontButtonOff; //EZT + TGauge ggPantAllDownButton; +//Winger 020304 - wlacznik ogrzewania + TGauge ggTrainHeatingButton; + TGauge ggSignallingButton; + TGauge ggDoorSignallingButton; +// TModel3d *mdKabina; McZapkie-030303: to do dynobj + //TGauge ggDistCounter; //Ra 2014-07: licznik kilometrów + //TGauge ggVelocityDgt; //i od razu prędkościomierz + + TButton btLampkaPoslizg; + TButton btLampkaStyczn; + TButton btLampkaNadmPrzetw; + TButton btLampkaPrzetw; + TButton btLampkaPrzekRozn; + TButton btLampkaPrzekRoznPom; + TButton btLampkaNadmSil; + TButton btLampkaWylSzybki; + TButton btLampkaNadmWent; + TButton btLampkaNadmSpr; +//yB: drugie lampki dla EP05 i ET42 + TButton btLampkaOporyB; + TButton btLampkaStycznB; + TButton btLampkaWylSzybkiB; + TButton btLampkaNadmPrzetwB; + TButton btLampkaPrzetwB; + //KURS90 lampki jazdy bezoporowej dla EU04 + TButton btLampkaBezoporowaB; + TButton btLampkaBezoporowa; + TButton btLampkaUkrotnienie; + TButton btLampkaHamPosp; + TButton btLampkaRadio; + TButton btLampkaHamowanie1zes; + TButton btLampkaHamowanie2zes; +// TButton btLampkaUnknown; + TButton btLampkaOpory; + TButton btLampkaWysRozr; + TButton btLampkaUniversal3; + int LampkaUniversal3_typ; //ABu 030405 - swiecenie uzaleznione od: 0-nic, 1-obw.gl, 2-przetw. + bool LampkaUniversal3_st; + TButton btLampkaWentZaluzje; //ET22 + TButton btLampkaOgrzewanieSkladu; + TButton btLampkaSHP; + TButton btLampkaCzuwaka; //McZapkie-141102 + TButton btLampkaRezerwa; +//youBy - jakies dodatkowe lampki + TButton btLampkaNapNastHam; + TButton btLampkaSprezarka; + TButton btLampkaSprezarkaB; + TButton btLampkaBocznik1; + TButton btLampkaBocznik2; + TButton btLampkaBocznik3; + TButton btLampkaBocznik4; + TButton btLampkaRadiotelefon; + TButton btLampkaHamienie; + TButton btLampkaJazda; //Ra: nie używane +//KURS90 + TButton btLampkaBoczniki; + TButton btLampkaMaxSila; + TButton btLampkaPrzekrMaxSila; +// TButton bt; +// + TButton btLampkaDoorLeft; + TButton btLampkaDoorRight; + TButton btLampkaDepartureSignal; + TButton btLampkaBlokadaDrzwi; + TButton btLampkaHamulecReczny; + TButton btLampkaForward; //Ra: lampki w przód i w tył dla komputerowych kabin + TButton btLampkaBackward; + + TButton btCabLight; //hunter-171012: lampa oswietlajaca kabine + //Ra 2013-12: wirtualne "lampki" do odbijania na haslerze w PoKeys + TButton btHaslerBrakes; //ciśnienie w cylindrach + TButton btHaslerCurrent; //prąd na silnikach + + vector3 pPosition; + vector3 pMechOffset; //driverNpos + vector3 vMechMovement; + vector3 pMechPosition; + vector3 pMechShake; + vector3 vMechVelocity; +//McZapkie: do poruszania sie po kabinie + double fMechCroach; +//McZapkie: opis kabiny - obszar poruszania sie mechanika oraz zajetosc + TCab Cabine[maxcab+1]; //przedzial maszynowy, kabina 1 (A), kabina 2 (B) + int iCabn; + TSpring MechSpring; + double fMechSpringX; //McZapkie-250303: parametry bujania + double fMechSpringY; + double fMechSpringZ; + double fMechMaxSpring; + double fMechRoll; + double fMechPitch; + + PSound dsbNastawnikJazdy; + PSound dsbNastawnikBocz; //hunter-081211 + PSound dsbRelay; + PSound dsbPneumaticRelay; + PSound dsbSwitch; + PSound dsbPneumaticSwitch; + PSound dsbReverserKey; //hunter-121211 + + PSound dsbCouplerAttach; //Ra: w kabinie???? + PSound dsbCouplerDetach; //Ra: w kabinie??? + + PSound dsbDieselIgnition; //Ra: w kabinie??? + + PSound dsbDoorClose; //Ra: w kabinie??? + PSound dsbDoorOpen; //Ra: w kabinie??? + +//Winger 010304 + PSound dsbPantUp; + PSound dsbPantDown; + + PSound dsbWejscie_na_bezoporow; + PSound dsbWejscie_na_drugi_uklad; //hunter-081211: poprawka literowki + + +// PSound dsbHiss1; + // PSound dsbHiss2; + +//McZapkie-280302 + TRealSound rsBrake; + TRealSound rsSlippery; + TRealSound rsHiss; //upuszczanie + TRealSound rsHissU; //napelnianie + TRealSound rsHissE; //nagle + TRealSound rsHissX; //fala + TRealSound rsHissT; //czasowy + TRealSound rsSBHiss; + TRealSound rsRunningNoise; + TRealSound rsEngageSlippery; + TRealSound rsFadeSound; + + PSound dsbHasler; + PSound dsbBuzzer; + PSound dsbSlipAlarm; //Bombardier 011010: alarm przy poslizgu dla 181/182 + //TFadeSound sConverter; //przetwornica + //TFadeSound sSmallCompressor; //przetwornica + + int iCabLightFlag; //McZapkie:120503: oswietlenie kabiny (0: wyl, 1: przyciemnione, 2: pelne) + bool bCabLight; //hunter-091012: czy swiatlo jest zapalone? + bool bCabLightDim; //hunter-091012: czy przyciemnienie kabiny jest zapalone? + + vector3 pMechSittingPosition; //ABu 180404 + vector3 __fastcall MirrorPosition(bool lewe); +private: + //PSound dsbBuzzer; + PSound dsbCouplerStretch; + PSound dsbEN57_CouplerStretch; + PSound dsbBufferClamp; +// TSubModel *smCzuwakShpOn; +// TSubModel *smCzuwakOn; +// TSubModel *smShpOn; +// TSubModel *smCzuwakShpOff; +// double fCzuwakTimer; + double fBlinkTimer; + float fHaslerTimer; + float fConverterTimer; //hunter-261211: dla przekaznika + float fMainRelayTimer; //hunter-141211: zalaczanie WSa z opoznieniem + float fCzuwakTestTimer; //hunter-091012: do testu czuwaka + + int CAflag; //hunter-131211: dla osobnego zbijania CA i SHP + + double fPoslizgTimer; +// double fShpTimer; +// double fDblClickTimer; + //ABu: Przeniesione do public. - Wiem, ze to nieladnie... + //bool CabChange(int iDirection); + //bool InitializeCab(int NewCabNo, AnsiString asFileName); + TTrack *tor; + int keybrakecount; +//McZapkie-240302 - przyda sie do tachometru + float fTachoVelocity; + float fTachoVelocityJump; //ze skakaniem + float fTachoTimer; + float fTachoCount; + float fHVoltage; //napięcie dla dynamicznych gałek + float fHCurrent[4]; //prądy: suma i amperomierze 1,2,3 + float fEngine[4]; //obroty też trzeba pobrać +//McZapkie: do syczenia + float fPPress,fNPress; + float fSPPress,fSNPress; + int iSekunda; //Ra: sekunda aktualizacji prędkości + int iRadioChannel; //numer aktualnego kanału radiowego +public: + int __fastcall RadioChannel() {return iRadioChannel;}; + inline TDynamicObject* __fastcall Dynamic() {return DynamicObject;}; + inline TMoverParameters* __fastcall Controlled() {return mvControlled;}; + void __fastcall DynamicSet(TDynamicObject *d); + void __fastcall Silence(); +}; +//--------------------------------------------------------------------------- +#endif diff --git a/TrkFoll.cpp b/TrkFoll.cpp new file mode 100644 index 00000000..da958057 --- /dev/null +++ b/TrkFoll.cpp @@ -0,0 +1,295 @@ +//--------------------------------------------------------------------------- + +/* + MaSzyna EU07 locomotive simulator + Copyright (C) 2001-2004 Marcin Wozniak and others + +*/ + +#include "system.hpp" +#include "classes.hpp" + +#include "opengl/glew.h" +#include "opengl/glut.h" + +#pragma hdrstop + +#include "TrkFoll.h" +#include "Globals.h" +#include "DynObj.h" +#include "Ground.h" +#include "Event.h" + +__fastcall TTrackFollower::TTrackFollower() +{ + pCurrentTrack=NULL; + pCurrentSegment=NULL; + fCurrentDistance=0; + pPosition=vAngles=vector3(0,0,0); + fDirection=1; //jest przodem do Point2 + fOffsetH=0.0; //na starcie stoi na środku +} + +__fastcall TTrackFollower::~TTrackFollower() +{ +} + +bool __fastcall TTrackFollower::Init(TTrack *pTrack,TDynamicObject *NewOwner,double fDir) +{ + fDirection=fDir; + Owner=NewOwner; + SetCurrentTrack(pTrack,0); + iEventFlag=3; //na torze startowym również wykonać eventy 1/2 + iEventallFlag=3; + if ((pCurrentSegment))// && (pCurrentSegment->GetLength()eType) + {case tt_Switch: //jeśli zwrotnica, to przekładamy ją, aby uzyskać dobry segment + {int i=(end?pCurrentTrack->iNextDirection:pCurrentTrack->iPrevDirection); + if (i>0) //jeżeli wjazd z ostrza + pTrack->SwitchForced(i>>1,Owner); //to przełożenie zwrotnicy - rozprucie! + } + break; + case tt_Cross: //skrzyżowanie trzeba tymczasowo przełączyć, aby wjechać na właściwy tor + {iSegment=Owner->RouteWish(pTrack); //nr segmentu został ustalony podczas skanowania + //Ra 2014-08: aby ustalić dalszą trasę, należy zapytać AI - trasa jest ustalana podczas skanowania + //Ra 15-01: zapytanie AI nie wybiera segmentu - kolejny skanujący może przestawić + //pTrack->CrossSegment(end?pCurrentTrack->iNextDirection:pCurrentTrack->iPrevDirection,i); //ustawienie właściwego wskaźnika + //powinno zwracać kierunek do zapamiętania, bo segmenty mogą mieć różny kierunek + //if fDirection=(iSegment>0)?1.0:-1.0; //kierunek na tym segmencie jest ustalany bezpośrednio + if (iSegment==0) + {//to jest błędna sytuacja - generuje pętle zawracające za skrzyżowaniem - ustalić, kiedy powstaje! + iSegment=1; //doraźna poprawka + } + if ((end?iSegment:-iSegment)<0) + fDirection=-fDirection; //wtórna zmiana + pTrack->SwitchForced(abs(iSegment)-1,NULL); //wybór zapamiętanego segmentu + } + break; + } + if (!pTrack) + {//gdy nie ma toru w kierunku jazdy + pTrack=pCurrentTrack->NullCreate(end); //tworzenie toru wykolejącego na przedłużeniu pCurrentTrack + if (!end) //jeśli dodana od strony zero, to zmiana kierunku + fDirection=-fDirection; //wtórna zmiana + //if (pTrack->iCategoryFlag&2) + //{//jeśli samochód, zepsuć na miejscu + // Owner->MoverParameters->V=0; //zatrzymać + // Owner->MoverParameters->Power=0; //ukraść silnik + // Owner->MoverParameters->AccS=0; //wchłonąć moc + // Global::iPause|=1; //zapauzowanie symulacji + //} + } + else + {//najpierw +1, później -1, aby odcinek izolowany wspólny dla tych torów nie wykrył zera + pTrack->AxleCounter(+1,Owner); //zajęcie nowego toru + if (pCurrentTrack) pCurrentTrack->AxleCounter(-1,Owner); //opuszczenie tamtego toru + } + pCurrentTrack=pTrack; + pCurrentSegment=(pCurrentTrack?pCurrentTrack->CurrentSegment():NULL); + if (!pCurrentTrack) + Error(Owner->MoverParameters->Name+" at NULL track"); + return pCurrentTrack; +}; + +bool __fastcall TTrackFollower::Move(double fDistance,bool bPrimary) +{//przesuwanie wózka po torach o odległość (fDistance), z wyzwoleniem eventów + //bPrimary=true - jest pierwszą osią w pojeździe, czyli generuje eventy i przepisuje pojazd + //Ra: zwraca false, jeśli pojazd ma być usunięty + fDistance*=fDirection; //dystans mnożnony przez kierunek + double s; //roboczy dystans + double dir; //zapamiętany kierunek do sprawdzenia, czy się zmienił + bool bCanSkip; //czy przemieścić pojazd na inny tor + while (true) //pętla wychodzi, gdy przesunięcie wyjdzie zerowe + {//pętla przesuwająca wózek przez kolejne tory, aż do trafienia w jakiś + if (!pCurrentTrack) return false; //nie ma toru, to nie ma przesuwania + if (pCurrentTrack->iEvents) //sumaryczna informacja o eventach + {//omijamy cały ten blok, gdy tor nie ma on żadnych eventów (większość nie ma) + if (fDistance<0) + { + if (iSetFlag(iEventFlag,-1)) //zawsze zeruje flagę sprawdzenia, jak mechanik dosiądzie, to się nie wykona + if (Owner->Mechanik) //tylko dla jednego członu + //if (TestFlag(iEventFlag,1)) //McZapkie-280503: wyzwalanie event tylko dla pojazdow z obsada + if (bPrimary && pCurrentTrack->evEvent1 && (!pCurrentTrack->evEvent1->iQueued)) + Global::AddToQuery(pCurrentTrack->evEvent1,Owner); //dodanie do kolejki + //Owner->RaAxleEvent(pCurrentTrack->Event1); //Ra: dynamic zdecyduje, czy dodać do kolejki + //if (TestFlag(iEventallFlag,1)) + if (iSetFlag(iEventallFlag,-1)) //McZapkie-280503: wyzwalanie eventall dla wszystkich pojazdow + if (bPrimary && pCurrentTrack->evEventall1 && (!pCurrentTrack->evEventall1->iQueued)) + Global::AddToQuery(pCurrentTrack->evEventall1,Owner); //dodanie do kolejki + //Owner->RaAxleEvent(pCurrentTrack->Eventall1); //Ra: dynamic zdecyduje, czy dodać do kolejki + } + else if (fDistance>0) + { + if (iSetFlag(iEventFlag,-2)) //zawsze ustawia flagę sprawdzenia, jak mechanik dosiądzie, to się nie wykona + if (Owner->Mechanik) //tylko dla jednego członu + //if (TestFlag(iEventFlag,2)) //sprawdzanie jest od razu w pierwszym warunku + if (bPrimary && pCurrentTrack->evEvent2 && (!pCurrentTrack->evEvent2->iQueued)) + Global::AddToQuery(pCurrentTrack->evEvent2,Owner); + //Owner->RaAxleEvent(pCurrentTrack->Event2); //Ra: dynamic zdecyduje, czy dodać do kolejki + //if (TestFlag(iEventallFlag,2)) + if (iSetFlag(iEventallFlag,-2)) //sprawdza i zeruje na przyszłość, true jeśli zmieni z 2 na 0 + if (bPrimary && pCurrentTrack->evEventall2 && (!pCurrentTrack->evEventall2->iQueued)) + Global::AddToQuery(pCurrentTrack->evEventall2,Owner); + //Owner->RaAxleEvent(pCurrentTrack->Eventall2); //Ra: dynamic zdecyduje, czy dodać do kolejki + } + else //if (fDistance==0) //McZapkie-140602: wyzwalanie zdarzenia gdy pojazd stoi + { + if (Owner->Mechanik) //tylko dla jednego członu + if (pCurrentTrack->evEvent0) + if (!pCurrentTrack->evEvent0->iQueued) + Global::AddToQuery(pCurrentTrack->evEvent0,Owner); + //Owner->RaAxleEvent(pCurrentTrack->Event0); //Ra: dynamic zdecyduje, czy dodać do kolejki + if (pCurrentTrack->evEventall0) + if (!pCurrentTrack->evEventall0->iQueued) + Global::AddToQuery(pCurrentTrack->evEventall0,Owner); + //Owner->RaAxleEvent(pCurrentTrack->Eventall0); //Ra: dynamic zdecyduje, czy dodać do kolejki + } + } + if (!pCurrentSegment) //jeżeli nie ma powiązanego segmentu toru? + return false; + //if (fDistance==0.0) return true; //Ra: jak stoi, to chyba dalej nie ma co kombinować? + s=fCurrentDistance+fDistance; //doliczenie przesunięcia + //Ra: W Point2 toru może znajdować się "dziura", która zamieni energię kinetyczną + // ruchu wzdłużnego na energię potencjalną, zamieniającą się potem na energię + // sprężystości na amortyzatorach. Należałoby we wpisie toru umieścić współczynnik + // podziału energii kinetycznej. + // Współczynnik normalnie 1, z dziurą np. 0.99, a -1 będzie oznaczało 100% odbicia (kozioł). + // Albo w postaci kąta: normalnie 0°, a 180° oznacza 100% odbicia (cosinus powyższego). +/* + if (pCurrentTrack->eType==tt_Cross) + {//zjazdu ze skrzyżowania nie da się określić przez (iPrevDirection) i (iNextDirection) + //int segment=Owner->RouteWish(pCurrentTrack); //numer segmentu dla skrzyżowań + //pCurrentTrack->SwitchForced(abs(segment)-1,NULL); //tymczasowo ustawienie tego segmentu + //pCurrentSegment=pCurrentTrack->CurrentSegment(); //odświeżyć sobie wskaźnik segmentu (?) + } +*/ + if (s<0) + {//jeśli przekroczenie toru od strony Point1 + bCanSkip=bPrimary?pCurrentTrack->CheckDynamicObject(Owner):false; + if (bCanSkip) //tylko główna oś przenosi pojazd do innego toru + Owner->MyTrack->RemoveDynamicObject(Owner); //zdejmujemy pojazd z dotychczasowego toru + dir=fDirection; + if (pCurrentTrack->eType==tt_Cross) + {if (!SetCurrentTrack(pCurrentTrack->Neightbour(iSegment,fDirection),0)) + return false; //wyjście z błędem + } + else if (!SetCurrentTrack(pCurrentTrack->Neightbour(-1,fDirection),0)) //ustawia fDirection + return false; //wyjście z błędem + if (dir==fDirection) //(pCurrentTrack->iPrevDirection) + {//gdy kierunek bez zmiany (Point1->Point2) + fCurrentDistance=pCurrentSegment->GetLength(); + fDistance=s; + } + else + {//gdy zmiana kierunku toru (Point1->Point1) + fCurrentDistance=0; + fDistance=-s; + } + if (bCanSkip) + {//jak główna oś, to dodanie pojazdu do nowego toru + pCurrentTrack->AddDynamicObject(Owner); + iEventFlag=3; //McZapkie-020602: umozliwienie uruchamiania event1,2 po zmianie toru + iEventallFlag=3; //McZapkie-280503: jw, dla eventall1,2 + if (!Owner->MyTrack) return false; + } + continue; + } + else if (s>pCurrentSegment->GetLength()) + {//jeśli przekroczenie toru od strony Point2 + bCanSkip=bPrimary?pCurrentTrack->CheckDynamicObject(Owner):false; + if (bCanSkip) //tylko główna oś przenosi pojazd do innego toru + Owner->MyTrack->RemoveDynamicObject(Owner); //zdejmujemy pojazd z dotychczasowego toru + fDistance=s-pCurrentSegment->GetLength(); + dir=fDirection; + if (pCurrentTrack->eType==tt_Cross) + {if (!SetCurrentTrack(pCurrentTrack->Neightbour(iSegment,fDirection),1)) + return false; //wyjście z błędem + } + else if (!SetCurrentTrack(pCurrentTrack->Neightbour(1,fDirection),1)) //ustawia fDirection + return false; //wyjście z błędem + if (dir!=fDirection) //(pCurrentTrack->iNextDirection) + {//gdy zmiana kierunku toru (Point2->Point2) + fDistance=-fDistance; //(s-pCurrentSegment->GetLength()); + fCurrentDistance=pCurrentSegment->GetLength(); + } + else //gdy kierunek bez zmiany (Point2->Point1) + fCurrentDistance=0; + if (bCanSkip) + {//jak główna oś, to dodanie pojazdu do nowego toru + pCurrentTrack->AddDynamicObject(Owner); + iEventFlag=3; //McZapkie-020602: umozliwienie uruchamiania event1,2 po zmianie toru + iEventallFlag=3; + if (!Owner->MyTrack) return false; + } + continue; + } + else + {//gdy zostaje na tym samym torze (przesuwanie już nie zmienia toru) + if (bPrimary) + {//tylko gdy początkowe ustawienie, dodajemy eventy stania do kolejki + if (Owner->MoverParameters->ActiveCab!=0) + //if (Owner->MoverParameters->CabNo!=0) + { + if (pCurrentTrack->evEvent1 && pCurrentTrack->evEvent1->fDelay<=-1.0f) + Global::AddToQuery(pCurrentTrack->evEvent1,Owner); + if (pCurrentTrack->evEvent2 && pCurrentTrack->evEvent2->fDelay<=-1.0f) + Global::AddToQuery(pCurrentTrack->evEvent2,Owner); + } + if (pCurrentTrack->evEventall1 && pCurrentTrack->evEventall1->fDelay<=-1.0f) + Global::AddToQuery(pCurrentTrack->evEventall1,Owner); + if (pCurrentTrack->evEventall2 && pCurrentTrack->evEventall2->fDelay<=-1.0f) + Global::AddToQuery(pCurrentTrack->evEventall2,Owner); + } + fCurrentDistance=s; + //fDistance=0; + return ComputatePosition(); //przeliczenie XYZ, true o ile nie wyjechał na NULL + } + } +}; + +bool __fastcall TTrackFollower::ComputatePosition() +{//ustalenie współrzędnych XYZ + if (pCurrentSegment) //o ile jest tor + { + pCurrentSegment->RaPositionGet(fCurrentDistance,pPosition,vAngles); + if (fDirection<0) //kąty zależą jeszcze od zwrotu na torze + {//kąty są w przedziale <-M_PI;M_PI> + vAngles.x=-vAngles.x; //przechyłka jest w przecinwą stronę + vAngles.y=-vAngles.y; //pochylenie jest w przecinwą stronę + vAngles.z+=(vAngles.z>=M_PI)?-M_PI:M_PI; //ale kierunek w planie jest obrócony o 180° + } + if (fOffsetH!=0.0) + {//jeśli przesunięcie względem osi toru, to je doliczyć + + } + return true; + } + return false; +} +#if RENDER_CONE +#include "opengl/glew.h" +#include "opengl/glut.h" +void __fastcall TTrackFollower::Render(float fNr) +{//funkcja rysująca stożek w miejscu osi + glPushMatrix(); //matryca kamery + glTranslatef(pPosition.x,pPosition.y+6,pPosition.z); //6m ponad + glRotated(RadToDeg(-vAngles.z),0,1,0); //obrót względem osi OY + //glRotated(RadToDeg(vAngles.z),0,1,0); //obrót względem osi OY + glDisable(GL_LIGHTING); + glColor3f(1.0,1.0-fNr,1.0-fNr); //biały dla 0, czerwony dla 1 + //glutWireCone(promień podstawy,wysokość,kątność podstawy,ilość segmentów na wysokość) + glutWireCone(0.5,2,4,1); //rysowanie stożka (ostrosłupa o podstawie wieloboka) + glEnable(GL_LIGHTING); + glPopMatrix(); +} +#endif +//--------------------------------------------------------------------------- + +#pragma package(smart_init) diff --git a/TrkFoll.h b/TrkFoll.h new file mode 100644 index 00000000..67b56b8b --- /dev/null +++ b/TrkFoll.h @@ -0,0 +1,42 @@ +//--------------------------------------------------------------------------- + +#ifndef TrkFollH +#define TrkFollH + +#include "Track.h" + +class TDynamicObject; + +class TTrackFollower +{//oś poruszająca się po torze +private: + TTrack *pCurrentTrack; //na którym torze się znajduje + TSegment *pCurrentSegment; //zwrotnice mogą mieć dwa segmenty + double fCurrentDistance; //przesunięcie względem Point1 w stronę Point2 + double fDirection; //ustawienie względem toru: -1.0 albo 1.0, mnożone przez dystans + bool __fastcall ComputatePosition(); //przeliczenie pozycji na torze + TDynamicObject *Owner; //pojazd posiadający + int iEventFlag; //McZapkie-020602: informacja o tym czy wyzwalac zdarzenie: 0,1,2,3 + int iEventallFlag; + int iSegment; //który segment toru jest używany (żeby nie przeskakiwało po przestawieniu zwrotnicy pod taborem) +public: + double fOffsetH; //Ra: odległość środka osi od osi toru (dla samochodów) - użyć do wężykowania + vector3 pPosition; //współrzędne XYZ w układzie scenerii + vector3 vAngles; //x:przechyłka, y:pochylenie, z:kierunek w planie (w radianach) + __fastcall TTrackFollower(); + __fastcall ~TTrackFollower(); + TTrack* __fastcall SetCurrentTrack(TTrack *pTrack,int end); + bool __fastcall Move(double fDistance,bool bPrimary); + inline TTrack* __fastcall GetTrack() {return pCurrentTrack;}; + inline double __fastcall GetRoll() {return vAngles.x;}; //przechyłka policzona przy ustalaniu pozycji + //{return pCurrentSegment->GetRoll(fCurrentDistance)*fDirection;}; //zamiast liczyć można pobrać + inline double __fastcall GetDirection() {return fDirection;}; //zwrot na torze + inline double __fastcall GetTranslation() {return fCurrentDistance;}; //ABu-030403 + //inline double __fastcall GetLength(vector3 p1, vector3 cp1, vector3 cp2, vector3 p2) + //{ return pCurrentSegment->ComputeLength(p1,cp1,cp2,p2); }; + //inline double __fastcall GetRadius(double L, double d); //McZapkie-150503 + bool __fastcall Init(TTrack *pTrack,TDynamicObject *NewOwner,double fDir); + void __fastcall Render(float fNr); +}; +//--------------------------------------------------------------------------- +#endif diff --git a/VBO.cpp b/VBO.cpp new file mode 100644 index 00000000..4ea89f62 --- /dev/null +++ b/VBO.cpp @@ -0,0 +1,95 @@ +//--------------------------------------------------------------------------- + +#include +#pragma hdrstop + +#include "VBO.h" +#include "opengl/glew.h" +#include "usefull.h" +//--------------------------------------------------------------------------- + +#pragma package(smart_init) + +__fastcall CMesh::CMesh() +{//utworzenie pustego obiektu + m_pVNT=NULL; + m_nVertexCount=-1; + m_nVBOVertices=0; //nie zarezerwowane +}; + +__fastcall CMesh::~CMesh() +{//usuwanie obiektu + Clear(); //zwolnienie zasobów +}; + +void __fastcall CMesh::MakeArray(int n) +{//tworzenie tablic + m_nVertexCount=n; + m_pVNT=new CVertNormTex[m_nVertexCount]; // przydzielenie pamięci dla tablicy +}; + +void __fastcall CMesh::BuildVBOs(bool del) +{//tworzenie VBO i kasowanie już niepotrzebnych tablic + //pobierz numer VBO oraz ustaw go jako aktywny + glGenBuffersARB(1,&m_nVBOVertices); //pobierz numer + glBindBufferARB(GL_ARRAY_BUFFER_ARB,m_nVBOVertices); //ustaw bufor jako aktualny + glBufferDataARB(GL_ARRAY_BUFFER_ARB,m_nVertexCount*sizeof(CVertNormTex),m_pVNT,GL_STATIC_DRAW_ARB); + //WriteLog("Assigned VBO number "+AnsiString(m_nVBOVertices)+", vertices: "+AnsiString(m_nVertexCount)); + if (del) SafeDeleteArray(m_pVNT); //wierzchołki już się nie przydadzą +}; + +void __fastcall CMesh::Clear() +{//niewirtualne zwolnienie zasobów przez sprzątacz albo destruktor + //inna nazwa, żeby nie mieszało się z funkcją wirtualną sprzątacza + if (m_nVBOVertices) //jeśli było coś rezerwowane + { + glDeleteBuffersARB(1,&m_nVBOVertices); // Free The Memory + //WriteLog("Released VBO number "+AnsiString(m_nVBOVertices)); + } + m_nVBOVertices=0; + m_nVertexCount=-1; //do ponownego zliczenia + SafeDeleteArray(m_pVNT); //usuwanie tablic, gdy były użyte do Vertex Array +}; + +bool __fastcall CMesh::StartVBO() +{//początek rysowania elementów z VBO + if (m_nVertexCount<=0) return false; //nie ma nic do rysowania w ten sposób + glEnableClientState(GL_VERTEX_ARRAY); + glEnableClientState(GL_NORMAL_ARRAY); + glEnableClientState(GL_TEXTURE_COORD_ARRAY); + if (m_nVBOVertices) + { + glBindBufferARB(GL_ARRAY_BUFFER_ARB,m_nVBOVertices); + glVertexPointer(3,GL_FLOAT,sizeof(CVertNormTex),((char*)NULL)); //pozycje + glNormalPointer(GL_FLOAT,sizeof(CVertNormTex),((char*)NULL)+12); //normalne + glTexCoordPointer(2,GL_FLOAT,sizeof(CVertNormTex),((char*)NULL)+24); //wierzchołki + } + return true; //można rysować z VBO +}; + +bool __fastcall CMesh::StartColorVBO() +{//początek rysowania punktów świecących z VBO + if (m_nVertexCount<=0) return false; //nie ma nic do rysowania w ten sposób + glEnableClientState(GL_VERTEX_ARRAY); + glEnableClientState(GL_COLOR_ARRAY); + if (m_nVBOVertices) + { + glBindBufferARB(GL_ARRAY_BUFFER_ARB,m_nVBOVertices); + glVertexPointer(3,GL_FLOAT,sizeof(CVertNormTex),((char*)NULL)); //pozycje + //glColorPointer(3,GL_UNSIGNED_BYTE,sizeof(CVertNormTex),((char*)NULL)+12); //kolory + glColorPointer(3,GL_FLOAT,sizeof(CVertNormTex),((char*)NULL)+12); //kolory + } + return true; //można rysować z VBO +}; + +void __fastcall CMesh::EndVBO() +{//koniec użycia VBO + glDisableClientState(GL_VERTEX_ARRAY); + glDisableClientState(GL_NORMAL_ARRAY); + glDisableClientState(GL_TEXTURE_COORD_ARRAY); + glDisableClientState(GL_COLOR_ARRAY); + //glBindBuffer(GL_ARRAY_BUFFER,0); //takie coś psuje, mimo iż polecali użyć + glBindBufferARB(GL_ARRAY_BUFFER_ARB,0); + glBindBufferARB(GL_ELEMENT_ARRAY_BUFFER_ARB,0); //Ra: to na przyszłość +}; + diff --git a/VBO.h b/VBO.h new file mode 100644 index 00000000..99ace3fb --- /dev/null +++ b/VBO.h @@ -0,0 +1,36 @@ +//--------------------------------------------------------------------------- + +#ifndef VBOH +#define VBOH +//--------------------------------------------------------------------------- +class CVertNormTex +{ +public: + float x; //X wierzchołka + float y; //Y wierzchołka + float z; //Z wierzchołka + float nx; //X wektora normalnego + float ny; //Y wektora normalnego + float nz; //Z wektora normalnego + float u; //U mapowania + float v; //V mapowania +}; + +class CMesh +{//wsparcie dla VBO +public: + int m_nVertexCount; //liczba wierzchołków + CVertNormTex *m_pVNT; + unsigned int m_nVBOVertices; //numer VBO z wierzchołkami + __fastcall CMesh(); + __fastcall ~CMesh(); + void __fastcall MakeArray(int n); //tworzenie tablicy z elementami VNT + void __fastcall BuildVBOs(bool del=true); //zamiana tablic na VBO + void __fastcall Clear(); //zwolnienie zasobów + bool __fastcall StartVBO(); + void __fastcall EndVBO(); + bool __fastcall StartColorVBO(); +}; + +#endif + diff --git a/World.cpp b/World.cpp new file mode 100644 index 00000000..a57fc715 --- /dev/null +++ b/World.cpp @@ -0,0 +1,2547 @@ +//--------------------------------------------------------------------------- +/* + MaSzyna EU07 locomotive simulator + Copyright (C) 2001-2004 Marcin Wozniak, Maciej Czapkiewicz and others + +*/ + +#include "system.hpp" +#include "classes.hpp" + +#include "opengl/glew.h" +#include "opengl/glut.h" +#pragma hdrstop + +#include "Timer.h" +#include "mtable.hpp" +#include "Sound.h" +#include "World.h" +#include "Logs.h" +#include "Globals.h" +#include "Camera.h" +#include "ResourceManager.h" +#include "Event.h" +#include "Train.h" +#include "Driver.h" +#include "Console.h" + +#define TEXTURE_FILTER_CONTROL_EXT 0x8500 +#define TEXTURE_LOD_BIAS_EXT 0x8501 +//--------------------------------------------------------------------------- +#pragma package(smart_init) + +typedef void (APIENTRY *FglutBitmapCharacter)(void *font,int character); //typ funkcji +FglutBitmapCharacter glutBitmapCharacterDLL=NULL; //deklaracja zmiennej +HINSTANCE hinstGLUT32=NULL; //wskaźnik do GLUT32.DLL +//GLUTAPI void APIENTRY glutBitmapCharacterDLL(void *font, int character); +TDynamicObject *Controlled=NULL; //pojazd, który prowadzimy + +using namespace Timer; + +const double fTimeMax=1.00; //[s] maksymalny czas aktualizacji w jednek klatce + +__fastcall TWorld::TWorld() +{ + //randomize(); + //Randomize(); + Train=NULL; + //Aspect=1; + for (int i=0;i<10;++i) + KeyEvents[i]=NULL; //eventy wyzwalane klawiszami cyfrowymi + Global::iSlowMotion=0; + //Global::changeDynObj=NULL; + OutText1=""; //teksty wyświetlane na ekranie + OutText2=""; + OutText3=""; + iCheckFPS=0; //kiedy znów sprawdzić FPS, żeby wyłączać optymalizacji od razu do zera + pDynamicNearest=NULL; + fTimeBuffer=0.0; //bufor czasu aktualizacji dla stałego kroku fizyki + fMaxDt=0.01; //[s] początkowy krok czasowy fizyki + fTime50Hz=0.0; //bufor czasu dla komunikacji z PoKeys +} + +__fastcall TWorld::~TWorld() +{ + Global::bManageNodes=false; //Ra: wyłączenie wyrejestrowania, bo się sypie + TrainDelete(); + //Ground.Free(); //Ra: usunięcie obiektów przed usunięciem dźwięków - sypie się + TSoundsManager::Free(); + TModelsManager::Free(); + TTexturesManager::Free(); + glDeleteLists(base,96); + if (hinstGLUT32) + FreeLibrary(hinstGLUT32); +} + +void __fastcall TWorld::TrainDelete(TDynamicObject *d) +{//usunięcie pojazdu prowadzonego przez użytkownika + if (d) + if (Train) + if (Train->Dynamic()!=d) + return; //nie tego usuwać + delete Train; //i nie ma czym sterować + Train=NULL; + Controlled=NULL; //tego też już nie ma + mvControlled=NULL; + Global::pUserDynamic=NULL; //tego też nie ma +}; + +GLvoid __fastcall TWorld::glPrint(const char *txt) //custom GL "Print" routine +{//wypisywanie tekstu 2D na ekranie + if (!txt) return; + if (Global::bGlutFont) + {//tekst generowany przez GLUT + int i,len=strlen(txt); + for (i=0;iglver.Pos(".")) + glver=glver.SubString(1,glver.LastDelimiter(".")-1); //obcięcie od drugiej kropki + double ogl; + try {ogl=glver.ToDouble();} catch (...) {ogl=0.0;} + if (Global::fOpenGL>0.0) //jeśli była wpisane maksymalna wersja w EU07.INI + {if (ogl>0.0) //zakładając, że się odczytało dobrze + if (ogl=1.5); //są fragmentaryczne animacje VBO + + WriteLog("Supported extensions:"); + WriteLog((char*)glGetString(GL_EXTENSIONS)); + if (glewGetExtension("GL_ARB_vertex_buffer_object")) //czy jest VBO w karcie graficznej + { + if (AnsiString((char*)glGetString(GL_VENDOR)).Pos("Intel")) //wymuszenie tylko dla kart Intel + {//karty Intel nie nadają się do grafiki 3D, ale robimy wyjątek, bo to w końcu symulator + Global::iMultisampling=0; //to robi problemy na "Intel(R) HD Graphics Family" - czarny ekran + if (Global::fOpenGL>=1.4) //1.4 miało obsługę VBO, ale bez opcji modyfikacji fragmentu bufora + Global::bUseVBO=true; //VBO włączane tylko, jeśli jest obsługa oraz nie ustawiono niższego numeru + } + if (Global::bUseVBO) + WriteLog("Ra: The VBO is found and will be used."); + else + WriteLog("Ra: The VBO is found, but Display Lists are selected."); + } + else + {WriteLog("Ra: No VBO found - Display Lists used. Graphics card too old?"); + Global::bUseVBO=false; //może być włączone parametrem w INI + } + if (Global::bDecompressDDS) //jeśli sprzętowa (domyślnie jest false) + WriteLog("DDS textures support at OpenGL level is disabled in INI file."); + else + {Global::bDecompressDDS=!glewGetExtension("GL_EXT_texture_compression_s3tc"); //czy obsługiwane? + if (Global::bDecompressDDS) //czy jest obsługa DDS w karcie graficznej + WriteLog("DDS textures are not supported."); + else //brak obsługi DDS - trzeba włączyć programową dekompresję + WriteLog("DDS textures are supported."); + } + if (Global::iMultisampling) + WriteLog("Used multisampling of "+AnsiString(Global::iMultisampling)+" samples."); + {//ograniczenie maksymalnego rozmiaru tekstur - parametr dla skalowania tekstur + GLint i; + glGetIntegerv(GL_MAX_TEXTURE_SIZE,&i); + if (i=1.2) //poniższe nie działa w 1.1 + glTexEnvf(TEXTURE_FILTER_CONTROL_EXT,TEXTURE_LOD_BIAS_EXT,-1); + GLfloat FogColor[]={1.0f,1.0f,1.0f,1.0f}; + glMatrixMode(GL_MODELVIEW); // Select The Modelview Matrix + glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT); // Clear screen and depth buffer + glLoadIdentity(); + //WriteLog("glClearColor (FogColor[0], FogColor[1], FogColor[2], 0.0); "); + //glClearColor (1.0, 0.0, 0.0, 0.0); // Background Color + //glClearColor (FogColor[0], FogColor[1], FogColor[2], 0.0); // Background Color + glClearColor (0.2, 0.4, 0.33, 1.0); // Background Color + + WriteLog("glFogfv(GL_FOG_COLOR, FogColor);"); + glFogfv(GL_FOG_COLOR, FogColor); // Set Fog Color + + WriteLog("glClearDepth(1.0f); "); + glClearDepth(1.0f); // ZBuffer Value + + + // glEnable(GL_NORMALIZE); +// glEnable(GL_RESCALE_NORMAL); + +// glEnable(GL_CULL_FACE); + WriteLog("glEnable(GL_TEXTURE_2D);"); + glEnable(GL_TEXTURE_2D); // Enable Texture Mapping + WriteLog("glShadeModel(GL_SMOOTH);"); + glShadeModel(GL_SMOOTH); // Enable Smooth Shading + WriteLog("glEnable(GL_DEPTH_TEST);"); + glEnable(GL_DEPTH_TEST); + +//McZapkie:261102-uruchomienie polprzezroczystosci (na razie linie) pod kierunkiem Marcina + //if (Global::bRenderAlpha) //Ra: wywalam tę flagę + { + WriteLog("glEnable(GL_BLEND);"); + glEnable(GL_BLEND); + WriteLog("glEnable(GL_ALPHA_TEST);"); + glEnable(GL_ALPHA_TEST); + WriteLog("glAlphaFunc(GL_GREATER,0.04);"); + glAlphaFunc(GL_GREATER,0.04); + WriteLog("glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);"); + glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA); + WriteLog("glDepthFunc(GL_LEQUAL);"); + glDepthFunc(GL_LEQUAL); + } +/* + else + { + WriteLog("glEnable(GL_ALPHA_TEST);"); + glEnable(GL_ALPHA_TEST); + WriteLog("glAlphaFunc(GL_GREATER,0.5);"); + glAlphaFunc(GL_GREATER,0.5); + WriteLog("glDepthFunc(GL_LEQUAL);"); + glDepthFunc(GL_LEQUAL); + WriteLog("glDisable(GL_BLEND);"); + glDisable(GL_BLEND); + } +*/ +/* zakomentowanie to co bylo kiedys mieszane + WriteLog("glEnable(GL_ALPHA_TEST);"); + glEnable(GL_ALPHA_TEST);//glGetIntegerv() + WriteLog("glAlphaFunc(GL_GREATER,0.5);"); +// glAlphaFunc(GL_LESS,0.5); + glAlphaFunc(GL_GREATER,0.5); +// glBlendFunc(GL_SRC_ALPHA,GL_ONE); + WriteLog("glDepthFunc(GL_LEQUAL);"); + glDepthFunc(GL_LEQUAL);//EQUAL); // The Type Of Depth Testing To Do + // glEnable(GL_BLEND); +// glBlendFunc(GL_SRC_ALPHA,GL_ONE_MINUS_SRC_ALPHA); +*/ + + WriteLog("glHint(GL_PERSPECTIVE_CORRECTION_HINT, GL_NICEST);"); + glHint(GL_PERSPECTIVE_CORRECTION_HINT, GL_NICEST); // Really Nice Perspective Calculations + + + WriteLog("glPolygonMode(GL_FRONT, GL_FILL);"); + glPolygonMode(GL_FRONT, GL_FILL); + WriteLog("glFrontFace(GL_CCW);"); + glFrontFace(GL_CCW); // Counter clock-wise polygons face out + WriteLog("glEnable(GL_CULL_FACE); "); + glEnable(GL_CULL_FACE); // Cull back-facing triangles + WriteLog("glLineWidth(1.0f);"); + glLineWidth(1.0f); +// glLineWidth(2.0f); + WriteLog("glPointSize(2.0f);"); + glPointSize(2.0f); + +// ----------- LIGHTING SETUP ----------- + // Light values and coordinates + + vector3 lp= Normalize(vector3(-500,500,200)); + + Global::lightPos[0]=lp.x; + Global::lightPos[1]=lp.y; + Global::lightPos[2]=lp.z; + Global::lightPos[3]=0.0f; + + //Ra: światła by sensowniej było ustawiać po wczytaniu scenerii + + //Ra: szczątkowe światło rozproszone - żeby było cokolwiek widać w ciemności + WriteLog("glLightModelfv(GL_LIGHT_MODEL_AMBIENT,darkLight);"); + glLightModelfv(GL_LIGHT_MODEL_AMBIENT,Global::darkLight); + + //Ra: światło 0 - główne światło zewnętrzne (Słońce, Księżyc) + WriteLog("glLightfv(GL_LIGHT0,GL_AMBIENT,ambientLight);"); + glLightfv(GL_LIGHT0,GL_AMBIENT,Global::ambientDayLight); + WriteLog("glLightfv(GL_LIGHT0,GL_DIFFUSE,diffuseLight);"); + glLightfv(GL_LIGHT0,GL_DIFFUSE,Global::diffuseDayLight); + WriteLog("glLightfv(GL_LIGHT0,GL_SPECULAR,specularLight);"); + glLightfv(GL_LIGHT0,GL_SPECULAR,Global::specularDayLight); + WriteLog("glLightfv(GL_LIGHT0,GL_POSITION,lightPos);"); + glLightfv(GL_LIGHT0,GL_POSITION,Global::lightPos); + WriteLog("glEnable(GL_LIGHT0);"); + glEnable(GL_LIGHT0); + + + //glColor() ma zmieniać kolor wybrany w glColorMaterial() + WriteLog("glEnable(GL_COLOR_MATERIAL);"); + glEnable(GL_COLOR_MATERIAL); + + WriteLog("glColorMaterial(GL_FRONT, GL_AMBIENT_AND_DIFFUSE);"); + glColorMaterial(GL_FRONT, GL_AMBIENT_AND_DIFFUSE); + +// WriteLog("glMaterialfv( GL_FRONT, GL_AMBIENT, whiteLight );"); +// glMaterialfv( GL_FRONT, GL_AMBIENT, Global::whiteLight ); + + WriteLog("glMaterialfv( GL_FRONT, GL_AMBIENT_AND_DIFFUSE, whiteLight );"); + glMaterialfv( GL_FRONT, GL_AMBIENT_AND_DIFFUSE, Global::whiteLight ); + +/* + WriteLog("glMaterialfv( GL_FRONT, GL_SPECULAR, noLight );"); + glMaterialfv( GL_FRONT, GL_SPECULAR, Global::noLight ); +*/ + + WriteLog("glEnable(GL_LIGHTING);"); + glEnable(GL_LIGHTING); + + + WriteLog("glFogi(GL_FOG_MODE, GL_LINEAR);"); + glFogi(GL_FOG_MODE, GL_LINEAR); // Fog Mode + WriteLog("glFogfv(GL_FOG_COLOR, FogColor);"); + glFogfv(GL_FOG_COLOR, FogColor); // Set Fog Color +// glFogf(GL_FOG_DENSITY, 0.594f); // How Dense Will The Fog Be +// glHint(GL_FOG_HINT, GL_NICEST); // Fog Hint Value + WriteLog("glFogf(GL_FOG_START, 1000.0f);"); + glFogf(GL_FOG_START, 10.0f); // Fog Start Depth + WriteLog("glFogf(GL_FOG_END, 2000.0f);"); + glFogf(GL_FOG_END, 200.0f); // Fog End Depth + WriteLog("glEnable(GL_FOG);"); + glEnable(GL_FOG); // Enables GL_FOG + + //Ra: ustawienia testowe + glHint(GL_LINE_SMOOTH_HINT,GL_NICEST); + glHint(GL_POLYGON_SMOOTH_HINT,GL_NICEST); + +/*--------------------Render Initialization End---------------------*/ + + WriteLog("Font init"); //początek inicjacji fontów 2D + if (Global::bGlutFont) //jeśli wybrano GLUT font, próbujemy zlinkować GLUT32.DLL + { + UINT mode=SetErrorMode(SEM_NOOPENFILEERRORBOX); //aby nie wrzeszczał, że znaleźć nie może + hinstGLUT32=LoadLibrary(TEXT("GLUT32.DLL")); //get a handle to the DLL module + SetErrorMode(mode); + // If the handle is valid, try to get the function address. + if (hinstGLUT32) + glutBitmapCharacterDLL=(FglutBitmapCharacter)GetProcAddress(hinstGLUT32,"glutBitmapCharacter"); + else + WriteLog("Missed GLUT32.DLL."); + if (glutBitmapCharacterDLL) + WriteLog("Used font from GLUT32.DLL."); + else + Global::bGlutFont=false; //nie udało się, trzeba spróbować na Display List + } + if (!Global::bGlutFont) + {//jeśli bezGLUTowy font + HFONT font; // Windows Font ID + base=glGenLists(96); //storage for 96 characters + font=CreateFont( -15, //height of font + 0, //width of font + 0, //angle of escapement + 0, //orientation angle + FW_BOLD, //font weight + FALSE, //italic + FALSE, //underline + FALSE, //strikeout + ANSI_CHARSET, //character set identifier + OUT_TT_PRECIS, //output precision + CLIP_DEFAULT_PRECIS, //clipping precision + ANTIALIASED_QUALITY, //output quality + FF_DONTCARE|DEFAULT_PITCH, //family and pitch + "Courier New"); //font name + SelectObject(hDC,font); //selects the font we want + wglUseFontBitmapsA(hDC,32,96,base); //builds 96 characters starting at character 32 + WriteLog("Display Lists font used."); //+AnsiString(glGetError()) + } + WriteLog("Font init OK"); //+AnsiString(glGetError()) + + Timer::ResetTimers(); + + hWnd= NhWnd; + glColor4f(1.0f,3.0f,3.0f,0.0f); +// SwapBuffers(hDC); // Swap Buffers (Double Buffering) +// glClear(GL_COLOR_BUFFER_BIT); +// glFlush(); + + SetForegroundWindow(hWnd); + WriteLog("Sound Init"); + + + glLoadIdentity(); +// glColor4f(0.3f,0.0f,0.0f,0.0f); + glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT); + glTranslatef(0.0f,0.0f,-0.50f); +// glRasterPos2f(-0.25f, -0.10f); + glDisable(GL_DEPTH_TEST); // Disables depth testing + glColor3f(3.0f,3.0f,3.0f); + + GLuint logo; + logo=TTexturesManager::GetTextureID(szTexturePath,szSceneryPath,"logo",6); + glBindTexture(GL_TEXTURE_2D,logo); // Select our texture + + glBegin(GL_QUADS); // Drawing using triangles + glTexCoord2f(0.0f, 0.0f); glVertex3f(-0.28f, -0.22f, 0.0f); //bottom left of the texture and quad + glTexCoord2f(1.0f, 0.0f); glVertex3f( 0.28f, -0.22f, 0.0f); //bottom right of the texture and quad + glTexCoord2f(1.0f, 1.0f); glVertex3f( 0.28f, 0.22f, 0.0f); //top right of the texture and quad + glTexCoord2f(0.0f, 1.0f); glVertex3f(-0.28f, 0.22f, 0.0f); //top left of the texture and quad + glEnd(); + //~logo; Ra: to jest bez sensu zapis + glColor3f(0.0f,0.0f,100.0f); + if (Global::detonatoryOK) + { + glRasterPos2f(-0.25f, -0.09f); + glPrint("Uruchamianie / Initializing..."); + glRasterPos2f(-0.25f, -0.10f); + glPrint("Dzwiek / Sound..."); + } + SwapBuffers(hDC); // Swap Buffers (Double Buffering) + + glEnable(GL_LIGHTING); +/*-----------------------Sound Initialization-----------------------*/ + TSoundsManager::Init(hWnd); + //TSoundsManager::LoadSounds( "" ); +/*---------------------Sound Initialization End---------------------*/ + WriteLog("Sound Init OK"); + if (Global::detonatoryOK) + { + glRasterPos2f(-0.25f, -0.11f); + glPrint("OK."); + } + SwapBuffers(hDC); // Swap Buffers (Double Buffering) + + int i; + + Paused= true; + WriteLog("Textures init"); + if(Global::detonatoryOK) + { + glRasterPos2f(-0.25f, -0.12f); + glPrint("Tekstury / Textures..."); + } + SwapBuffers(hDC); // Swap Buffers (Double Buffering) + + TTexturesManager::Init(); + WriteLog("Textures init OK"); + if(Global::detonatoryOK) + { + glRasterPos2f(-0.25f, -0.13f); + glPrint("OK."); + } + SwapBuffers(hDC); // Swap Buffers (Double Buffering) + + WriteLog("Models init"); + if(Global::detonatoryOK) + { + glRasterPos2f(-0.25f, -0.14f); + glPrint("Modele / Models..."); + } + SwapBuffers(hDC); // Swap Buffers (Double Buffering) +//McZapkie: dodalem sciezke zeby mozna bylo definiowac skad brac modele ale to malo eleganckie +// TModelsManager::LoadModels(asModelsPatch); + TModelsManager::Init(); + WriteLog("Models init OK"); + if (Global::detonatoryOK) + { + glRasterPos2f(-0.25f, -0.15f); + glPrint("OK."); + } + SwapBuffers(hDC); // Swap Buffers (Double Buffering) + + WriteLog("Ground init"); + if (Global::detonatoryOK) + { + glRasterPos2f(-0.25f, -0.16f); + glPrint("Sceneria / Scenery (please wait)..."); + } + SwapBuffers(hDC); // Swap Buffers (Double Buffering) + + Ground.Init(Global::szSceneryFile,hDC); +// Global::tSinceStart= 0; + Clouds.Init(); + WriteLog("Ground init OK"); + if (Global::detonatoryOK) + { + glRasterPos2f(-0.25f, -0.17f); + glPrint("OK."); + } + SwapBuffers(hDC); // Swap Buffers (Double Buffering) + +// TTrack *Track=Ground.FindGroundNode("train_start",TP_TRACK)->pTrack; + +// Camera.Init(vector3(2700,10,6500),0,M_PI,0); +// Camera.Init(vector3(00,40,000),0,M_PI,0); +// Camera.Init(vector3(1500,5,-4000),0,M_PI,0); +//McZapkie-130302 - coby nie przekompilowywac: +// Camera.Init(Global::pFreeCameraInit,0,M_PI,0); + Camera.Init(Global::pFreeCameraInit[0],Global::pFreeCameraInitAngle[0]); + + char buff[255]="Player train init: "; + if (Global::detonatoryOK) + { + glRasterPos2f(-0.25f,-0.18f); + glPrint("Przygotowanie kabiny do sterowania..."); + } + SwapBuffers(hDC); // Swap Buffers (Double Buffering) + + strcat(buff,Global::asHumanCtrlVehicle.c_str()); + WriteLog(buff); + TGroundNode *nPlayerTrain=NULL; + if (Global::asHumanCtrlVehicle!="ghostview") + nPlayerTrain=Ground.DynamicFind(Global::asHumanCtrlVehicle); //szukanie w tych z obsadą + if (nPlayerTrain) + { + Train=new TTrain(); + if (Train->Init(nPlayerTrain->DynamicObject)) + { + Controlled=Train->Dynamic(); + mvControlled=Controlled->ControlledFind()->MoverParameters; + Global::pUserDynamic=Controlled; //renerowanie pojazdu względem kabiny + WriteLog("Player train init OK"); + if (Global::detonatoryOK) + { + glRasterPos2f(-0.25f, -0.19f); + glPrint("OK."); + } + FollowView(); + SwapBuffers(hDC); // Swap Buffers (Double Buffering) + } + else + { + Error("Player train init failed!"); + FreeFlyModeFlag=true; //Ra: automatycznie włączone latanie + if (Global::detonatoryOK) + { + glRasterPos2f(-0.25f, -0.20f); + glPrint("Blad inicjalizacji sterowanego pojazdu!"); + } + SwapBuffers(hDC); // Swap Buffers (Double Buffering) + Controlled=NULL; + mvControlled=NULL; + Camera.Type=tp_Free; + } + } + else + { + if (Global::asHumanCtrlVehicle!="ghostview") + {Error("Player train not exist!"); + if (Global::detonatoryOK) + { + glRasterPos2f(-0.25f, -0.20f); + glPrint("Wybrany pojazd nie istnieje w scenerii!"); + } + } + FreeFlyModeFlag=true; //Ra: automatycznie włączone latanie + SwapBuffers(hDC); //swap buffers (double buffering) + Controlled=NULL; + mvControlled=NULL; + Camera.Type=tp_Free; + } + glEnable(GL_DEPTH_TEST); + //Ground.pTrain=Train; + //if (!Global::bMultiplayer) //na razie włączone + {//eventy aktywowane z klawiatury tylko dla jednego użytkownika + KeyEvents[0]=Ground.FindEvent("keyctrl00"); + KeyEvents[1]=Ground.FindEvent("keyctrl01"); + KeyEvents[2]=Ground.FindEvent("keyctrl02"); + KeyEvents[3]=Ground.FindEvent("keyctrl03"); + KeyEvents[4]=Ground.FindEvent("keyctrl04"); + KeyEvents[5]=Ground.FindEvent("keyctrl05"); + KeyEvents[6]=Ground.FindEvent("keyctrl06"); + KeyEvents[7]=Ground.FindEvent("keyctrl07"); + KeyEvents[8]=Ground.FindEvent("keyctrl08"); + KeyEvents[9]=Ground.FindEvent("keyctrl09"); + } + //glTexEnvf(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_MODULATE); //{Texture blends with object background} + light=TTexturesManager::GetTextureID(szTexturePath,szSceneryPath,"smuga.tga"); + //Camera.Reset(); + ResetTimers(); + WriteLog("Load time: "+FloatToStrF((86400.0*((double)Now()-time)),ffFixed,7,1)+" seconds"); + if (DebugModeFlag) //w Debugmode automatyczne włączenie AI + if (Train) + if (Train->Dynamic()->Mechanik) + Train->Dynamic()->Mechanik->TakeControl(true); + return true; +}; + +void __fastcall TWorld::OnKeyDown(int cKey) +{//(cKey) to kod klawisza, cyfrowe i literowe się zgadzają + //Ra 2014-09: tu by można dodać tabelę konwersji: 256 wirtualnych kodów w kontekście dwóch przełączników [Shift] i [Ctrl] + //na każdy kod wirtualny niech przypadają 4 bajty: 2 dla naciśnięcia i 2 dla zwolnienia + //powtórzone 256 razy da 1kB na każdy stan przełączników, łącznie będzie 4kB pierwszej tabeli przekodowania + if (!Global::iPause) + {//podczas pauzy klawisze nie działają + AnsiString info="Key pressed: ["; + if (Console::Pressed(VK_SHIFT)) info+="Shift]+["; + if (Console::Pressed(VK_CONTROL)) info+="Ctrl]+["; + if (cKey>192) //coś tam jeszcze ciekawego jest? + { + if (cKey<255) //255 to [Fn] w laptopach + WriteLog(info+AnsiString(char(cKey-128))+"]"); + } + else if (cKey>=186) + WriteLog(info+AnsiString(";=,-./~").SubString(cKey-185,1)+"]"); + else if (cKey>123) //coś tam jeszcze ciekawego jest? + WriteLog(info+AnsiString(cKey)+"]"); //numer klawisza + else if (cKey>=112) //funkcyjne + WriteLog(info+"F"+AnsiString(cKey-111)+"]"); + else if (cKey>=96) + WriteLog(info+"Num"+AnsiString("0123456789*+?-./").SubString(cKey-95,1)+"]"); + else if (((cKey>='0')&&(cKey<='9'))||((cKey>='A')&&(cKey<='Z'))||(cKey==' ')) + WriteLog(info+AnsiString(char(cKey))+"]"); + else if (cKey=='-') + WriteLog(info+"Insert]"); + else if (cKey=='.') + WriteLog(info+"Delete]"); + else if (cKey=='$') + WriteLog(info+"Home]"); + else if (cKey=='#') + WriteLog(info+"End]"); + else if (cKey>'Z') //żeby nie logować kursorów + WriteLog(info+AnsiString(cKey)+"]"); //numer klawisza + } + if ((cKey<='9')?(cKey>='0'):false) //klawisze cyfrowe + {int i=cKey-'0'; //numer klawisza + if (Console::Pressed(VK_SHIFT)) + {//z [Shift] uruchomienie eventu + if (!Global::iPause) //podczas pauzy klawisze nie działają + if (KeyEvents[i]) + Ground.AddToQuery(KeyEvents[i],NULL); + } + else //zapamiętywanie kamery może działać podczas pauzy + if (FreeFlyModeFlag) //w trybie latania można przeskakiwać do ustawionych kamer + if ((Global::iTextMode!=VK_F12)&&(Global::iTextMode!=VK_F3)) //ograniczamy użycie kamer + {if ((!Global::pFreeCameraInit[i].x&&!Global::pFreeCameraInit[i].y&&!Global::pFreeCameraInit[i].z)) + {//jeśli kamera jest w punkcie zerowym, zapamiętanie współrzędnych i kątów + Global::pFreeCameraInit[i]=Camera.Pos; + Global::pFreeCameraInitAngle[i].x=Camera.Pitch; + Global::pFreeCameraInitAngle[i].y=Camera.Yaw; + Global::pFreeCameraInitAngle[i].z=Camera.Roll; + //logowanie, żeby można było do scenerii przepisać + WriteLog("camera " + +FloatToStrF(Global::pFreeCameraInit[i].x,ffFixed,7,3)+" " + +FloatToStrF(Global::pFreeCameraInit[i].y,ffFixed,7,3)+" " + +FloatToStrF(Global::pFreeCameraInit[i].z,ffFixed,7,3)+" " + +FloatToStrF(RadToDeg(Global::pFreeCameraInitAngle[i].x),ffFixed,7,3)+" " + +FloatToStrF(RadToDeg(Global::pFreeCameraInitAngle[i].y),ffFixed,7,3)+" " + +FloatToStrF(RadToDeg(Global::pFreeCameraInitAngle[i].z),ffFixed,7,3)+" " + +AnsiString(i)+" endcamera"); + } + else //również przeskakiwanie + {//Ra: to z tą kamerą (Camera.Pos i Global::pCameraPosition) jest trochę bez sensu + Global::SetCameraPosition(Global::pFreeCameraInit[i]); //nowa pozycja dla generowania obiektów + Ground.Silence(Camera.Pos); //wyciszenie wszystkiego z poprzedniej pozycji + Camera.Init(Global::pFreeCameraInit[i],Global::pFreeCameraInitAngle[i]); //przestawienie + } + } + //będzie jeszcze załączanie sprzęgów z [Ctrl] + } + else if ((cKey>=VK_F1)?(cKey<=VK_F12):false) + { + switch (cKey) + {case VK_F1: //czas i relacja + case VK_F3: + case VK_F5: //przesiadka do innego pojazdu + case VK_F8: //FPS + case VK_F9: //wersja, typ wyświetlania, błędy OpenGL + case VK_F10: + if (Global::iTextMode==cKey) + Global::iTextMode=(Global::iPause&&(cKey!=VK_F1)?VK_F1:0); //wyłączenie napisów, chyba że pauza + else + Global::iTextMode=cKey; + break; + case VK_F2: //parametry pojazdu + if (Global::iTextMode==cKey) //jeśli kolejne naciśnięcie + ++Global::iScreenMode[cKey-VK_F1]; //kolejny ekran + else + {//pierwsze naciśnięcie daje pierwszy (tzn. zerowy) ekran + Global::iTextMode=cKey; + Global::iScreenMode[cKey-VK_F1]=0; + } + break; + case VK_F12: //coś tam jeszcze + if (Console::Pressed(VK_CONTROL)&&Console::Pressed(VK_SHIFT)) + DebugModeFlag=!DebugModeFlag; //taka opcjonalna funkcja, może się czasem przydać +/* //Ra 2F1P: teraz włączanie i wyłączanie klawiszami cyfrowymi po użyciu [F12] + else if (Console::Pressed(VK_SHIFT)) + {//odpalenie logu w razie "W" + if ((Global::iWriteLogEnabled&2)==0) //nie było okienka + {//otwarcie okna + AllocConsole(); + SetConsoleTextAttribute(GetStdHandle(STD_OUTPUT_HANDLE),FOREGROUND_GREEN); + } + Global::iWriteLogEnabled|=3; + } */ + else + Global::iTextMode=cKey; + break; + case VK_F4: + InOutKey(); + break; + case VK_F6: + if (DebugModeFlag) + {//przyspieszenie symulacji do testowania scenerii... uwaga na FPS! + //Global::iViewMode=VK_F6; + if (Console::Pressed(VK_CONTROL)) + Global::fTimeSpeed=(Console::Pressed(VK_SHIFT)?10.0:5.0); + else + Global::fTimeSpeed=(Console::Pressed(VK_SHIFT)?2.0:1.0); + } + break; + } + //if (cKey!=VK_F4) + return; //nie są przekazywane do pojazdu wcale + } + if (Global::iTextMode==VK_F10) //wyświetlone napisy klawiszem F10 + {//i potwierdzenie + Global::iTextMode=(cKey=='Y')?-1:0; //flaga wyjścia z programu + return; //nie przekazujemy do pociągu + } + else if ((Global::iTextMode==VK_F12)?(cKey>='0')&&(cKey<='9'):false) + {//tryb konfiguracji debugmode (przestawianie kamery już wyłączone + if (!Console::Pressed(VK_SHIFT)) //bez [Shift] + {if (cKey=='1') + Global::iWriteLogEnabled^=1; //włącz/wyłącz logowanie do pliku + else if (cKey=='2') + {//włącz/wyłącz okno konsoli + Global::iWriteLogEnabled^=2; + if ((Global::iWriteLogEnabled&2)==0) //nie było okienka + {//otwarcie okna + AllocConsole(); //jeśli konsola już jest, to zwróci błąd; uwalniać nie ma po co, bo się odłączy + SetConsoleTextAttribute(GetStdHandle(STD_OUTPUT_HANDLE),FOREGROUND_GREEN); + } + } + //else if (cKey=='3') Global::iWriteLogEnabled^=4; //wypisywanie nazw torów + } + } + else if (cKey==3) //[Ctrl]+[Break] + {//hamowanie wszystkich pojazdów w okolicy + Ground.RadioStop(Camera.Pos); + } + else if (!Global::iPause) //||(cKey==VK_F4)) //podczas pauzy sterownaie nie działa, F4 tak + if (Train) + if (Controlled) + if ((Controlled->Controller==Humandriver)?true:DebugModeFlag||(cKey=='Q')) + Train->OnKeyDown(cKey); //przekazanie klawisza do kabiny + if (FreeFlyModeFlag) //aby nie odluźniało wagonu za lokomotywą + {//operacje wykonywane na dowolnym pojeździe, przeniesione tu z kabiny + if (cKey==Global::Keys[k_Releaser]) //odluźniacz + {//działa globalnie, sprawdzić zasięg + TDynamicObject *temp=Global::DynamicNearest(); + if (temp) + { + if (GetAsyncKeyState(VK_CONTROL)<0) //z ctrl odcinanie + { + temp->MoverParameters->BrakeStatus^=128; + } + else + if (temp->MoverParameters->BrakeReleaser(1)) + { + //temp->sBrakeAcc-> + //dsbPneumaticRelay->SetVolume(DSBVOLUME_MAX); + //dsbPneumaticRelay->Play(0,0,0); //temp->Position()-Camera.Pos //??? + } + } + } + else if (cKey==Global::Keys[k_Heating]) //Ra: klawisz nie jest najszczęśliwszy + {//zmiana próżny/ładowny; Ra: zabrane z kabiny + TDynamicObject *temp=Global::DynamicNearest(); + if (temp) + { + if (Console::Pressed(VK_SHIFT)?temp->MoverParameters->IncBrakeMult():temp->MoverParameters->DecBrakeMult()) + if (Train) + {//dźwięk oczywiście jest w kabinie + Train->dsbSwitch->SetVolume(DSBVOLUME_MAX); + Train->dsbSwitch->Play(0,0,0); + } + } + } + else if (cKey==Global::Keys[k_EndSign]) + {//Ra 2014-07: zabrane z kabiny + TDynamicObject *tmp=Global::CouplerNearest(); //domyślnie wyszukuje do 20m + if (tmp) + { + int CouplNr=(LengthSquared3(tmp->HeadPosition()-Camera.Pos)>LengthSquared3(tmp->RearPosition()-Camera.Pos)?1:-1)*tmp->DirectionGet(); + if (CouplNr<0) CouplNr=0; //z [-1,1] zrobić [0,1] + int mask,set=0; //Ra: [Shift]+[Ctrl]+[T] odpala mi jakąś idiotyczną zmianę tapety pulpitu :/ + if (GetAsyncKeyState(VK_SHIFT)<0) //z [Shift] zapalanie + set=mask=64; //bez [Ctrl] założyć tabliczki + else if (GetAsyncKeyState(VK_CONTROL)<0) + set=mask=2+32; //z [Ctrl] zapalić światła czerwone + else + mask=2+32+64; //wyłączanie ściąga wszystko + if (((tmp->iLights[CouplNr])&mask)!=set) + { + tmp->iLights[CouplNr]=(tmp->iLights[CouplNr]&~mask)|set; + if (Train) + {//Ra: ten dźwięk z kabiny to przegięcie, ale na razie zostawiam + Train->dsbSwitch->SetVolume(DSBVOLUME_MAX); + Train->dsbSwitch->Play(0,0,0); + } + } + } + } + else if (cKey==Global::Keys[k_IncLocalBrakeLevel]) + {//zahamowanie dowolnego pojazdu + TDynamicObject *temp=Global::DynamicNearest(); + if (temp) + { + if (GetAsyncKeyState(VK_CONTROL)<0) + if ((temp->MoverParameters->LocalBrake==ManualBrake)||(temp->MoverParameters->MBrake==true)) + temp->MoverParameters->IncManualBrakeLevel(1); + else; + else + if (temp->MoverParameters->LocalBrake!=ManualBrake) + if (temp->MoverParameters->IncLocalBrakeLevelFAST()) + if (Train) + {//dźwięk oczywiście jest w kabinie + Train->dsbPneumaticRelay->SetVolume(-80); + Train->dsbPneumaticRelay->Play(0,0,0); + } + } + } + else if (cKey==Global::Keys[k_DecLocalBrakeLevel]) + {//odhamowanie dowolnego pojazdu + TDynamicObject *temp=Global::DynamicNearest(); + if (temp) + { + if (GetAsyncKeyState(VK_CONTROL)<0) + if ((temp->MoverParameters->LocalBrake==ManualBrake)||(temp->MoverParameters->MBrake==true)) + temp->MoverParameters->DecManualBrakeLevel(1); + else; + else + if (temp->MoverParameters->LocalBrake!=ManualBrake) + if (temp->MoverParameters->DecLocalBrakeLevelFAST()) + if (Train) + {//dźwięk oczywiście jest w kabinie + Train->dsbPneumaticRelay->SetVolume(-80); + Train->dsbPneumaticRelay->Play(0,0,0); + } + } + } + } + //switch (cKey) + //{case 'a': //ignorowanie repetycji + // case 'A': Global::iKeyLast=cKey; break; + // default: Global::iKeyLast=0; + //} +} + +void __fastcall TWorld::OnKeyUp(int cKey) +{//zwolnienie klawisza; (cKey) to kod klawisza, cyfrowe i literowe się zgadzają + if (!Global::iPause) //podczas pauzy sterownaie nie działa + if (Train) + if (Controlled) + if ((Controlled->Controller==Humandriver)?true:DebugModeFlag||(cKey=='Q')) + Train->OnKeyUp(cKey); //przekazanie zwolnienia klawisza do kabiny +}; + +void __fastcall TWorld::OnMouseMove(double x, double y) +{//McZapkie:060503-definicja obracania myszy + Camera.OnCursorMove(x*Global::fMouseXScale,-y*Global::fMouseYScale); +} + +void __fastcall TWorld::InOutKey() +{//przełączenie widoku z kabiny na zewnętrzny i odwrotnie + FreeFlyModeFlag=!FreeFlyModeFlag; //zmiana widoku + if (FreeFlyModeFlag) + {//jeżeli poza kabiną, przestawiamy w jej okolicę - OK + Global::pUserDynamic=NULL; //bez renderowania względem kamery + if (Train) + {//Train->Dynamic()->ABuSetModelShake(vector3(0,0,0)); + Train->Silence(); //wyłączenie dźwięków kabiny + Train->Dynamic()->bDisplayCab=false; + DistantView(); + } + } + else + {//jazda w kabinie + if (Train) + {Global::pUserDynamic=Controlled; //renerowanie względem kamery + Train->Dynamic()->bDisplayCab=true; + Train->Dynamic()->ABuSetModelShake(vector3(0,0,0)); //zerowanie przesunięcia przed powrotem? + //Camera.Stop(); //zatrzymanie ruchu + Train->MechStop(); + FollowView(); //na pozycję mecha + } + else + FreeFlyModeFlag=true; //nadal poza kabiną + } +}; + +void __fastcall TWorld::DistantView() +{//ustawienie widoku pojazdu z zewnątrz + if (Controlled) //jest pojazd do prowadzenia? + {//na prowadzony + Camera.Pos=Controlled->GetPosition()+(Controlled->MoverParameters->ActiveCab>=0?30:-30)*Controlled->VectorFront()+vector3(0,5,0); + Camera.LookAt=Controlled->GetPosition(); + Camera.RaLook(); //jednorazowe przestawienie kamery + } + else if (pDynamicNearest) //jeśli jest pojazd wykryty blisko + {//patrzenie na najbliższy pojazd + Camera.Pos=pDynamicNearest->GetPosition()+(pDynamicNearest->MoverParameters->ActiveCab>=0?30:-30)*pDynamicNearest->VectorFront()+vector3(0,5,0); + Camera.LookAt=pDynamicNearest->GetPosition(); + Camera.RaLook(); //jednorazowe przestawienie kamery + } +}; + +void __fastcall TWorld::FollowView(bool wycisz) +{//ustawienie śledzenia pojazdu + //ABu 180404 powrot mechanika na siedzenie albo w okolicę pojazdu + //if (Console::Pressed(VK_F4)) Global::iViewMode=VK_F4; + //Ra: na zewnątrz wychodzimy w Train.cpp + Camera.Reset(); //likwidacja obrotów - patrzy horyzontalnie na południe + if (Controlled) //jest pojazd do prowadzenia? + { + vector3 camStara=Camera.Pos; //przestawianie kamery jest bez sensu: do przerobienia na potem + //Controlled->ABuSetModelShake(vector3(0,0,0)); + if (FreeFlyModeFlag) + {//jeżeli poza kabiną, przestawiamy w jej okolicę - OK + if (Train) + Train->Dynamic()->ABuSetModelShake(vector3(0,0,0)); //wyłączenie trzęsienia na siłę? + //Camera.Pos=Train->pMechPosition+Normalize(Train->GetDirection())*20; + DistantView(); //przestawienie kamery + //żeby nie bylo numerów z 'fruwajacym' lokiem - konsekwencja bujania pudła + Global::SetCameraPosition(Camera.Pos); //tu ustawić nową, bo od niej liczą się odległości + Ground.Silence(camStara); //wyciszenie dźwięków z poprzedniej pozycji + } + else if (Train) + {//korekcja ustawienia w kabinie - OK + vector3 camStara=Camera.Pos; //przestawianie kamery jest bez sensu: do przerobienia na potem + //Ra: czy to tu jest potrzebne, bo przelicza się kawałek dalej? + Camera.Pos=Train->pMechPosition;//Train.GetPosition1(); + Camera.Roll=atan(Train->pMechShake.x*Train->fMechRoll); //hustanie kamery na boki + Camera.Pitch-=atan(Train->vMechVelocity.z*Train->fMechPitch); //hustanie kamery przod tyl + if (Train->Dynamic()->MoverParameters->ActiveCab==0) + Camera.LookAt=Train->pMechPosition+Train->GetDirection(); + else //patrz w strone wlasciwej kabiny + Camera.LookAt=Train->pMechPosition+Train->GetDirection()*Train->Dynamic()->MoverParameters->ActiveCab; + Train->pMechOffset.x=Train->pMechSittingPosition.x; + Train->pMechOffset.y=Train->pMechSittingPosition.y; + Train->pMechOffset.z=Train->pMechSittingPosition.z; + Global::SetCameraPosition(Train->Dynamic()->GetPosition()); //tu ustawić nową, bo od niej liczą się odległości + if (wycisz) //trzymanie prawego w kabinie daje marny efekt + Ground.Silence(camStara); //wyciszenie dźwięków z poprzedniej pozycji + } + } + else DistantView(); +}; + +bool __fastcall TWorld::Update() +{ +#ifdef USE_SCENERY_MOVING + vector3 tmpvector = Global::GetCameraPosition(); + tmpvector = vector3( + -int(tmpvector.x)+int(tmpvector.x)%10000, + -int(tmpvector.y)+int(tmpvector.y)%10000, + -int(tmpvector.z)+int(tmpvector.z)%10000); + if(tmpvector.x || tmpvector.y || tmpvector.z) + { + WriteLog("Moving scenery"); + Ground.MoveGroundNode(tmpvector); + WriteLog("Scenery moved"); + }; +#endif + if (iCheckFPS) + --iCheckFPS; + else + {//jak doszło do zera, to sprawdzamy wydajność + if (GetFPS()Global::fFpsMax) //jeśli jest dużo FPS + if (Global::iSegmentsRenderedGlobal::iFpsRadiusMax) //5.6km (22*22*M_PI) + Global::iSegmentsRendered=Global::iFpsRadiusMax; + } + if ((GetFPS()<12)&&(Global::iSlowMotion<7)) + {Global::iSlowMotion=(Global::iSlowMotion<<1)+1; //zapalenie kolejnego bitu + if (Global::iSlowMotionMask&1) + if (Global::iMultisampling) //a multisampling jest włączony + glDisable(GL_MULTISAMPLE); //wyłączenie multisamplingu powinno poprawić FPS + } + else if ((GetFPS()>20)&&Global::iSlowMotion) + {//FPS się zwiększył, można włączyć bajery + Global::iSlowMotion=(Global::iSlowMotion>>1); //zgaszenie bitu + if (Global::iSlowMotion==0) //jeśli jest pełna prędkość + if (Global::iMultisampling) //a multisampling jest włączony + glEnable(GL_MULTISAMPLE); + } +/* + if (!Global::bPause) + if (GetFPS()<=5) + {//zwiększenie kroku fizyki przy słabym FPS + if (fMaxDt<0.05) + {fMaxDt=0.05; //Ra: tak nie może być, bo są problemy na sprzęgach + WriteLog("Phisics step switched to 0.05s!"); + } + } + else if (GetFPS()>12) + if (fMaxDt>0.01) + {//powrót do podstawowego kroku fizyki + fMaxDt=0.01; + WriteLog("Phisics step switched to 0.01s!"); + } +*/ + iCheckFPS=0.25*GetFPS(); //tak za 0.25 sekundy sprawdzić ponownie (jeszcze przycina?) + } + UpdateTimers(Global::iPause); + if (!Global::iPause) + {//jak pauza, to nie ma po co tego przeliczać + GlobalTime->UpdateMTableTime(GetDeltaTime()); //McZapkie-300302: czas rozkladowy + //Ra 2014-07: przeliczenie kąta czasu (do animacji zależnych od czasu) + Global::fTimeAngleDeg=GlobalTime->hh*15.0+GlobalTime->mm*0.25+GlobalTime->mr/240.0; + Global::fClockAngleDeg[0]=36.0*(int(GlobalTime->mr)%10); //jednostki sekund + Global::fClockAngleDeg[1]=36.0*(int(GlobalTime->mr)/10); //dziesiątki sekund + Global::fClockAngleDeg[2]=36.0*(GlobalTime->mm%10); //jednostki minut + Global::fClockAngleDeg[3]=36.0*(GlobalTime->mm/10); //dziesiątki minut + Global::fClockAngleDeg[4]=36.0*(GlobalTime->hh%10); //jednostki godzin + Global::fClockAngleDeg[5]=36.0*(GlobalTime->hh/10); //dziesiątki godzin + if (Global::fMoveLight>=0.0) + {//testowo ruch światła + //double a=Global::fTimeAngleDeg/180.0*M_PI-M_PI; //kąt godzinny w radianach + double a=fmod(Global::fTimeAngleDeg,360.0)/180.0*M_PI-M_PI; //kąt godzinny w radianach + //(a) jest traktowane jako czas miejscowy, nie uwzględniający stref czasowych ani czasu letniego + //aby wyznaczyć strefę czasową, trzeba uwzględnić południk miejscowy + //aby uwzględnić czas letni, trzeba sprawdzić dzień roku + double L=Global::fLatitudeDeg/180.0*M_PI; //szerokość geograficzna + double H=asin(cos(L)*cos(Global::fSunDeclination)*cos(a)+sin(L)*sin(Global::fSunDeclination)); //kąt ponad horyzontem + //double A=asin(cos(d)*sin(M_PI-a)/cos(H)); + //Declination=((0.322003-22.971*cos(t)-0.357898*cos(2*t)-0.14398*cos(3*t)+3.94638*sin(t)+0.019334*sin(2*t)+0.05928*sin(3*t)))*Pi/180 + //Altitude=asin(sin(Declination)*sin(latitude)+cos(Declination)*cos(latitude)*cos((15*(time-12))*(Pi/180))); + //Azimuth=(acos((cos(latitude)*sin(Declination)-cos(Declination)*sin(latitude)*cos((15*(time-12))*(Pi/180)))/cos(Altitude))); + //double A=acos(cos(L)*sin(d)-cos(d)*sin(L)*cos(M_PI-a)/cos(H)); + //dAzimuth = atan2(-sin( dHourAngle ),tan( dDeclination )*dCos_Latitude - dSin_Latitude*dCos_HourAngle ); + double A=atan2(sin(a),tan(Global::fSunDeclination)*cos(L)-sin(L)*cos(a)); + vector3 lp=vector3(sin(A),tan(H),cos(A)); + lp=Normalize(lp); //przeliczenie na wektor długości 1.0 + Global::lightPos[0]=(float)lp.x; + Global::lightPos[1]=(float)lp.y; + Global::lightPos[2]=(float)lp.z; + glLightfv(GL_LIGHT0,GL_POSITION,Global::lightPos); //daylight position + if (H>0) + {//słońce ponad horyzontem + Global::ambientDayLight[0]=Global::ambientLight[0]; + Global::ambientDayLight[1]=Global::ambientLight[1]; + Global::ambientDayLight[2]=Global::ambientLight[2]; + if (H>0.02) //ponad 1.146° zaczynają się cienie + {Global::diffuseDayLight[0]=Global::diffuseLight[0]; //od wschodu do zachodu maksimum ??? + Global::diffuseDayLight[1]=Global::diffuseLight[1]; + Global::diffuseDayLight[2]=Global::diffuseLight[2]; + Global::specularDayLight[0]=Global::specularLight[0]; //podobnie specular + Global::specularDayLight[1]=Global::specularLight[1]; + Global::specularDayLight[2]=Global::specularLight[2]; + } + else + {Global::diffuseDayLight[0]=50*H*Global::diffuseLight[0]; //wschód albo zachód + Global::diffuseDayLight[1]=50*H*Global::diffuseLight[1]; + Global::diffuseDayLight[2]=50*H*Global::diffuseLight[2]; + Global::specularDayLight[0]=50*H*Global::specularLight[0]; //podobnie specular + Global::specularDayLight[1]=50*H*Global::specularLight[1]; + Global::specularDayLight[2]=50*H*Global::specularLight[2]; + } + } + else + {//słońce pod horyzontem + GLfloat lum=3.1831*(H>-0.314159?0.314159+H:0.0); //po zachodzie ambient się ściemnia + Global::ambientDayLight[0]=lum*Global::ambientLight[0]; + Global::ambientDayLight[1]=lum*Global::ambientLight[1]; + Global::ambientDayLight[2]=lum*Global::ambientLight[2]; + Global::diffuseDayLight[0]=Global::noLight[0]; //od zachodu do wschodu nie ma diffuse + Global::diffuseDayLight[1]=Global::noLight[1]; + Global::diffuseDayLight[2]=Global::noLight[2]; + Global::specularDayLight[0]=Global::noLight[0]; //ani specular + Global::specularDayLight[1]=Global::noLight[1]; + Global::specularDayLight[2]=Global::noLight[2]; + } + // Calculate sky colour according to time of day. + //GLfloat sin_t = sin(PI * time_of_day / 12.0); + //back_red = 0.3 * (1.0 - sin_t); + //back_green = 0.9 * sin_t; + //back_blue = sin_t + 0.4, 1.0; + //aktualizacja świateł + glLightfv(GL_LIGHT0,GL_AMBIENT,Global::ambientDayLight); + glLightfv(GL_LIGHT0,GL_DIFFUSE,Global::diffuseDayLight); + glLightfv(GL_LIGHT0,GL_SPECULAR,Global::specularDayLight); + } + Global::fLuminance= //to posłuży również do zapalania latarń + +0.150*(Global::diffuseDayLight[0]+Global::ambientDayLight[0]) //R + +0.295*(Global::diffuseDayLight[1]+Global::ambientDayLight[1]) //G + +0.055*(Global::diffuseDayLight[2]+Global::ambientDayLight[2]); //B + if (Global::fMoveLight>=0.0) + {//przeliczenie koloru nieba + vector3 sky=vector3(Global::AtmoColor[0],Global::AtmoColor[1],Global::AtmoColor[2]); + if (Global::fLuminance<0.25) + {//przyspieszenie zachodu/wschodu + sky*=4.0*Global::fLuminance; //nocny kolor nieba + GLfloat fog[3]; + fog[0]=Global::FogColor[0]*4.0*Global::fLuminance; + fog[1]=Global::FogColor[1]*4.0*Global::fLuminance; + fog[2]=Global::FogColor[2]*4.0*Global::fLuminance; + glFogfv(GL_FOG_COLOR,fog); //nocny kolor mgły + } + else + glFogfv(GL_FOG_COLOR,Global::FogColor); //kolor mgły + glClearColor(sky.x,sky.y,sky.z,0.0); //kolor nieba + } + } //koniec działań niewykonywanych podczas pauzy + //Console::Update(); //tu jest zależne od FPS, co nie jest korzystne + if (Global::bActive) + {//obsługa ruchu kamery tylko gdy okno jest aktywne + if (Console::Pressed(VK_LBUTTON)) + { + Camera.Reset(); //likwidacja obrotów - patrzy horyzontalnie na południe + //if (!FreeFlyModeFlag) //jeśli wewnątrz - patrzymy do tyłu + // Camera.LookAt=Train->pMechPosition-Normalize(Train->GetDirection())*10; + if (Controlled?LengthSquared3(Controlled->GetPosition()-Camera.Pos)<2250000:false) //gdy bliżej niż 1.5km + Camera.LookAt=Controlled->GetPosition(); + else + {TDynamicObject *d=Ground.DynamicNearest(Camera.Pos,300); //szukaj w promieniu 300m + if (!d) + d=Ground.DynamicNearest(Camera.Pos,1000); //dalej szukanie, jesli bliżej nie ma + if (d&&pDynamicNearest) //jeśli jakiś jest znaleziony wcześniej + if (100.0*LengthSquared3(d->GetPosition()-Camera.Pos)>LengthSquared3(pDynamicNearest->GetPosition()-Camera.Pos)) + d=pDynamicNearest; //jeśli najbliższy nie jest 10 razy bliżej niż poprzedni najbliższy, zostaje poprzedni + if (d) pDynamicNearest=d; //zmiana na nowy, jeśli coś znaleziony niepusty + if (pDynamicNearest) Camera.LookAt=pDynamicNearest->GetPosition(); + } + if (FreeFlyModeFlag) + Camera.RaLook(); //jednorazowe przestawienie kamery + } + else if (Console::Pressed(VK_RBUTTON))//||Console::Pressed(VK_F4)) + FollowView(false); //bez wyciszania dźwięków + else if (Global::iTextMode==-1) + {//tu mozna dodac dopisywanie do logu przebiegu lokomotywy + WriteLog("Number of textures used: "+AnsiString(Global::iTextures)); + return false; + } + Camera.Update(); //uwzględnienie ruchu wywołanego klawiszami + } //koniec bloku pomijanego przy nieaktywnym oknie + //poprzednie jakoś tam działało + double dt=GetDeltaRenderTime(); //nie uwzględnia pauzowania ani mnożenia czasu + fTime50Hz+=dt; //w pauzie też trzeba zliczać czas, bo przy dużym FPS będzie problem z odczytem ramek + if (fTime50Hz>=0.2) + Console::Update(); //to i tak trzeba wywoływać + dt=GetDeltaTime(); //0.0 gdy pauza + fTimeBuffer+=dt; //[s] dodanie czasu od poprzedniej ramki + if (fTimeBuffer>=fMaxDt) //jest co najmniej jeden krok; normalnie 0.01s + {//Ra: czas dla fizyki jest skwantowany - fizykę lepiej przeliczać stałym krokiem + //tak można np. moc silników itp., ale ruch musi być przeliczany w każdej klatce, bo inaczej skacze + Global::tranTexts.Update(); //obiekt obsługujący stenogramy dźwięków na ekranie + Console::Update(); //obsługa cykli PoKeys (np. aktualizacja wyjść analogowych) + double iter=ceil(fTimeBuffer/fMaxDt); //ile kroków się zmieściło od ostatniego sprawdzania? + int n=int(iter); //ile kroków jako int + fTimeBuffer-=iter*fMaxDt; //reszta czasu na potem (do bufora) + if (n>20) n=20; //Ra: jeżeli FPS jest zatrważająco niski, to fizyka nie może zająć całkowicie procesora +#if 0 + Ground.UpdatePhys(fMaxDt,n); //Ra: teraz czas kroku jest (względnie) stały + if (DebugModeFlag) + if (Global::bActive) //nie przyspieszać, gdy jedzie w tle :) + if (GetAsyncKeyState(VK_ESCAPE)<0) + {//yB dodał przyspieszacz fizyki + Ground.UpdatePhys(fMaxDt,n); + Ground.UpdatePhys(fMaxDt,n); + Ground.UpdatePhys(fMaxDt,n); + Ground.UpdatePhys(fMaxDt,n); //w sumie 5 razy + } +#endif + } + //awaria PoKeys mogła włączyć pauzę - przekazać informację + if (Global::iMultiplayer) //dajemy znać do serwera o wykonaniu + if (iPause!=Global::iPause) + {//przesłanie informacji o pauzie do programu nadzorującego + Ground.WyslijParam(5,3); //ramka 5 z czasem i stanem zapauzowania + iPause=Global::iPause; + } + double iter; + int n=1; + if (dt>fMaxDt) //normalnie 0.01s + { + iter=ceil(dt/fMaxDt); + n=iter; + dt=dt/iter; //Ra: fizykę lepiej by było przeliczać ze stałym krokiem + if (n>20) n=20; //McZapkie-081103: przesuniecie granicy FPS z 10 na 5 + } + //else n=1; + //blablabla + //Ground.UpdatePhys(dt,n); //na razie tu //2014-12: yB przeniósł do Ground.Update() :( + Ground.Update(dt,n); //tu zrobić tylko coklatkową aktualizację przesunięć + if (DebugModeFlag) + if (Global::bActive) //nie przyspieszać, gdy jedzie w tle :) + if (GetAsyncKeyState(VK_ESCAPE)<0) + {//yB dodał przyspieszacz fizyki + Ground.Update(dt,n); + Ground.Update(dt,n); + Ground.Update(dt,n); + Ground.Update(dt,n); //5 razy + } + dt=GetDeltaTime(); //czas niekwantowany + if (Camera.Type==tp_Follow) + {if (Train) + {//jeśli jazda w kabinie, przeliczyć trzeba parametry kamery + Train->UpdateMechPosition(dt/Global::fTimeSpeed); //ograniczyć telepanie po przyspieszeniu + vector3 tempangle; + double modelrotate; + tempangle=Controlled->VectorFront()*(Controlled->MoverParameters->ActiveCab==-1 ? -1 : 1); + modelrotate=atan2(-tempangle.x,tempangle.z); + if (Console::Pressed(VK_CONTROL)?(Console::Pressed(Global::Keys[k_MechLeft])||Console::Pressed(Global::Keys[k_MechRight])):false) + {//jeśli lusterko lewe albo prawe (bez rzucania na razie) + bool lr=Console::Pressed(Global::Keys[k_MechLeft]); +#if 0 + Camera.Pos=Train->MirrorPosition(lr); //robocza wartość + if (Controlled->MoverParameters->ActiveCab<0) lr=!lr; //w drugiej kabinie odwrotnie jest środek + Camera.LookAt=Controlled->GetPosition()+vector3(lr?2.0:-2.0,Camera.Pos.y,0); //trochę na zewnątrz, użyć szerokości pojazdu + //Camera.LookAt=Train->pMechPosition+Train->GetDirection()*Train->Dynamic()->MoverParameters->ActiveCab; + Camera.Pos+=Controlled->GetPosition(); + //Camera.RaLook(); //jednorazowe przestawienie kamery + Camera.Yaw=0; //odchylenie na bok od Camera.LookAt +#else + //Camera.Yaw powinno być wyzerowane, aby po powrocie patrzeć do przodu + Camera.Pos=Controlled->GetPosition()+Train->MirrorPosition(lr); //pozycja lusterka + Camera.Yaw=0; //odchylenie na bok od Camera.LookAt + if (Train->Dynamic()->MoverParameters->ActiveCab==0) + Camera.LookAt=Camera.Pos-Train->GetDirection(); //gdy w korytarzu + else + if (Console::Pressed(VK_SHIFT)) + {//patrzenie w bok przez szybę + Camera.LookAt=Camera.Pos-(lr?-1:1)*Train->Dynamic()->VectorLeft()*Train->Dynamic()->MoverParameters->ActiveCab; + Global::SetCameraRotation(-modelrotate); + } + else + {//patrzenie w kierunku osi pojazdu, z uwzględnieniem kabiny - jakby z lusterka, ale bez odbicia + Camera.LookAt=Camera.Pos-Train->GetDirection()*Train->Dynamic()->MoverParameters->ActiveCab; //-1 albo 1 + Global::SetCameraRotation(M_PI-modelrotate); //tu już trzeba uwzględnić lusterka + } +#endif + Camera.Roll=atan(Train->pMechShake.x*Train->fMechRoll); //hustanie kamery na boki + Camera.Pitch=atan(Train->vMechVelocity.z*Train->fMechPitch); //hustanie kamery przod tyl + Camera.vUp=Controlled->VectorUp(); + } + else + {//patrzenie standardowe + Camera.Pos=Train->pMechPosition;//Train.GetPosition1(); + if (!Global::iPause) + {//podczas pauzy nie przeliczać kątów przypadkowymi wartościami + Camera.Roll=atan(Train->pMechShake.x*Train->fMechRoll); //hustanie kamery na boki + Camera.Pitch-=atan(Train->vMechVelocity.z*Train->fMechPitch); //hustanie kamery przod tyl //Ra: tu jest uciekanie kamery w górę!!! + } + //ABu011104: rzucanie pudlem + vector3 temp; + if (abs(Train->pMechShake.y)<0.25) + temp=vector3(0,0,6*Train->pMechShake.y); + else + if ((Train->pMechShake.y)>0) + temp=vector3(0,0,6*0.25); + else + temp=vector3(0,0,-6*0.25); + if (Controlled) Controlled->ABuSetModelShake(temp); + //ABu: koniec rzucania + + if (Train->Dynamic()->MoverParameters->ActiveCab==0) + Camera.LookAt=Train->pMechPosition+Train->GetDirection(); //gdy w korytarzu + else //patrzenie w kierunku osi pojazdu, z uwzględnieniem kabiny + Camera.LookAt=Train->pMechPosition+Train->GetDirection()*Train->Dynamic()->MoverParameters->ActiveCab; //-1 albo 1 + Camera.vUp=Train->GetUp(); + Global::SetCameraRotation(Camera.Yaw-modelrotate); //tu już trzeba uwzględnić lusterka + } + } + } + else + {//kamera nieruchoma + Global::SetCameraRotation(Camera.Yaw-M_PI); + } + Ground.CheckQuery(); + //przy 0.25 smuga gaśnie o 6:37 w Quarku, a mogłaby już 5:40 + //Ra 2014-12: przy 0.15 się skarżyli, że nie widać smug => zmieniłem na 0.25 + if (Train) //jeśli nie usunięty + Global::bSmudge=FreeFlyModeFlag?false:((Train->Dynamic()->fShade<=0.0)?(Global::fLuminance<=0.25):(Train->Dynamic()->fShade*Global::fLuminance<=0.25)); + + if (!Render()) return false; + +//********************************************************************************************************** + + if (Train) + {//rendering kabiny gdy jest oddzielnym modelem i ma byc wyswietlana + glPushMatrix(); + //ABu: Rendering kabiny jako ostatniej, zeby bylo widac przez szyby, tylko w widoku ze srodka + if ((Train->Dynamic()->mdKabina!=Train->Dynamic()->mdModel) && Train->Dynamic()->bDisplayCab && !FreeFlyModeFlag) + { + vector3 pos=Train->Dynamic()->GetPosition(); //wszpółrzędne pojazdu z kabiną + //glTranslatef(pos.x,pos.y,pos.z); //przesunięcie o wektor (tak było i trzęsło) + //aby pozbyć się choć trochę trzęsienia, trzeba by nie przeliczać kabiny do punktu zerowego scenerii + glLoadIdentity(); //zacząć od macierzy jedynkowej + Camera.SetCabMatrix(pos); //widok z kamery po przesunięciu + glMultMatrixd(Train->Dynamic()->mMatrix.getArray()); //ta macierz nie ma przesunięcia + +//*yB: moje smuuugi 1 + if (Global::bSmudge) + {//Ra: uwzględniłem zacienienie pojazdu przy zapalaniu smug + //1. warunek na smugę wyznaczyc wcześniej + //2. jeśli smuga włączona, nie renderować pojazdu użytkownika w DynObj + //3. jeśli smuga właczona, wyrenderować pojazd użytkownia po dodaniu smugi do sceny + if (Train->Controlled()->Battery) + {//trochę na skróty z tą baterią + glBlendFunc(GL_ONE_MINUS_SRC_ALPHA, GL_ONE); +// glBlendFunc(GL_ONE_MINUS_DST_COLOR, GL_DST_COLOR); +// glBlendFunc(GL_SRC_ALPHA_SATURATE,GL_ONE); + glDisable(GL_DEPTH_TEST); + glDisable(GL_LIGHTING); + glDisable(GL_FOG); + glColor4f(1.0f,1.0f,1.0f,1.0f); + glBindTexture(GL_TEXTURE_2D,light); // Select our texture + glBegin(GL_QUADS); + float fSmudge=Train->Dynamic()->MoverParameters->DimHalf.y+7; //gdzie zaczynać smugę + if (Train->Controlled()->iLights[0]&21) + {//wystarczy jeden zapalony z przodu + glTexCoord2f(0,0); glVertex3f( 15.0,0.0,+fSmudge); //rysowanie względem położenia modelu + glTexCoord2f(1,0); glVertex3f(-15.0,0.0,+fSmudge); + glTexCoord2f(1,1); glVertex3f(-15.0,2.5, 250.0); + glTexCoord2f(0,1); glVertex3f( 15.0,2.5, 250.0); + } + if (Train->Controlled()->iLights[1]&21) + {//wystarczy jeden zapalony z tyłu + glTexCoord2f(0,0); glVertex3f(-15.0,0.0,-fSmudge); + glTexCoord2f(1,0); glVertex3f( 15.0,0.0,-fSmudge); + glTexCoord2f(1,1); glVertex3f( 15.0,2.5,-250.0); + glTexCoord2f(0,1); glVertex3f(-15.0,2.5,-250.0); + } + glEnd(); + + glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA); + glEnable(GL_DEPTH_TEST); + //glEnable(GL_LIGHTING); //i tak się włączy potem + glEnable(GL_FOG); + } + glEnable(GL_LIGHTING); //po renderowaniu smugi jest to wyłączone + //Ra: pojazd użytkownika należało by renderować po smudze, aby go nie rozświetlała + Global::bSmudge=false; //aby model użytkownika się teraz wyrenderował + Train->Dynamic()->Render(); + Train->Dynamic()->RenderAlpha(); //przezroczyste fragmenty pojazdów na torach + } //yB: moje smuuugi 1 - koniec*/ + else + glEnable(GL_LIGHTING); //po renderowaniu drutów może być to wyłączone + + if (Train->Dynamic()->mdKabina) //bo mogła zniknąć przy przechodzeniu do innego pojazdu + {//oswietlenie kabiny + GLfloat ambientCabLight[4]= { 0.5f, 0.5f, 0.5f, 1.0f }; + GLfloat diffuseCabLight[4]= { 0.5f, 0.5f, 0.5f, 1.0f }; + GLfloat specularCabLight[4]={ 0.5f, 0.5f, 0.5f, 1.0f }; + for (int li=0; li<3; li++) + {//przyciemnienie standardowe + ambientCabLight[li]= Global::ambientDayLight[li]*0.9; + diffuseCabLight[li]= Global::diffuseDayLight[li]*0.5; + specularCabLight[li]=Global::specularDayLight[li]*0.5; + } + switch (Train->Dynamic()->MyTrack->eEnvironment) + {//wpływ świetła zewnętrznego + case e_canyon: + { + for (int li=0; li<3; li++) + { + diffuseCabLight[li] *=0.6; + specularCabLight[li]*=0.7; + } + } + break; + case e_tunnel: + { + for (int li=0; li<3; li++) + { + ambientCabLight[li] *=0.3; + diffuseCabLight[li] *=0.1; + specularCabLight[li]*=0.2; + } + } + break; + } + switch (Train->iCabLightFlag) //Ra: uzeleżnic od napięcia w obwodzie sterowania + { //hunter-091012: uzaleznienie jasnosci od przetwornicy + case 0: //światło wewnętrzne zgaszone + break; + case 1: //światło wewnętrzne przygaszone (255 216 176) + if (Train->Dynamic()->MoverParameters->ConverterFlag==true) //jasnosc dla zalaczonej przetwornicy + { + ambientCabLight[0]=Max0R(0.700,ambientCabLight[0])*0.75; //R + ambientCabLight[1]=Max0R(0.593,ambientCabLight[1])*0.75; //G + ambientCabLight[2]=Max0R(0.483,ambientCabLight[2])*0.75; //B + + for (int i=0;i<3;i++) + if (ambientCabLight[i]<=(Global::ambientDayLight[i]*0.9)) + ambientCabLight[i]=Global::ambientDayLight[i]*0.9; + } + else + { + ambientCabLight[0]=Max0R(0.700,ambientCabLight[0])*0.375; //R + ambientCabLight[1]=Max0R(0.593,ambientCabLight[1])*0.375; //G + ambientCabLight[2]=Max0R(0.483,ambientCabLight[2])*0.375; //B + + for (int i=0;i<3;i++) + if (ambientCabLight[i]<=(Global::ambientDayLight[i]*0.9)) + ambientCabLight[i]=Global::ambientDayLight[i]*0.9; + } + break; + case 2: //światło wewnętrzne zapalone (255 216 176) + if (Train->Dynamic()->MoverParameters->ConverterFlag==true) //jasnosc dla zalaczonej przetwornicy + { + ambientCabLight[0]=Max0R(1.000,ambientCabLight[0]); //R + ambientCabLight[1]=Max0R(0.847,ambientCabLight[1]); //G + ambientCabLight[2]=Max0R(0.690,ambientCabLight[2]); //B + + for (int i=0;i<3;i++) + if (ambientCabLight[i]<=(Global::ambientDayLight[i]*0.9)) + ambientCabLight[i]=Global::ambientDayLight[i]*0.9; + } + else + { + ambientCabLight[0]=Max0R(1.000,ambientCabLight[0])*0.5; //R + ambientCabLight[1]=Max0R(0.847,ambientCabLight[1])*0.5; //G + ambientCabLight[2]=Max0R(0.690,ambientCabLight[2])*0.5; //B + + for (int i=0;i<3;i++) + if (ambientCabLight[i]<=(Global::ambientDayLight[i]*0.9)) + ambientCabLight[i]=Global::ambientDayLight[i]*0.9; + } + break; + } + glLightfv(GL_LIGHT0,GL_AMBIENT,ambientCabLight); + glLightfv(GL_LIGHT0,GL_DIFFUSE,diffuseCabLight); + glLightfv(GL_LIGHT0,GL_SPECULAR,specularCabLight); + if (Global::bUseVBO) + {//renderowanie z użyciem VBO + Train->Dynamic()->mdKabina->RaRender(0.0,Train->Dynamic()->ReplacableSkinID,Train->Dynamic()->iAlpha); + Train->Dynamic()->mdKabina->RaRenderAlpha(0.0,Train->Dynamic()->ReplacableSkinID,Train->Dynamic()->iAlpha); + } + else + {//renderowanie z Display List + Train->Dynamic()->mdKabina->Render(0.0,Train->Dynamic()->ReplacableSkinID,Train->Dynamic()->iAlpha); + Train->Dynamic()->mdKabina->RenderAlpha(0.0,Train->Dynamic()->ReplacableSkinID,Train->Dynamic()->iAlpha); + } + //przywrócenie standardowych, bo zawsze są zmieniane + glLightfv(GL_LIGHT0,GL_AMBIENT,Global::ambientDayLight); + glLightfv(GL_LIGHT0,GL_DIFFUSE,Global::diffuseDayLight); + glLightfv(GL_LIGHT0,GL_SPECULAR,Global::specularDayLight); + } + } //koniec: if (Train->Dynamic()->mdKabina) + glPopMatrix(); +//********************************************************************************************************** + } //koniec: if (Train) + if (DebugModeFlag&&!Global::iTextMode) + { + OutText1=" FPS: "; + OutText1+=FloatToStrF(GetFPS(),ffFixed,6,2); + OutText1+=Global::iSlowMotion?"s":"n"; + + OutText1+=(GetDeltaTime()>=0.2)?"!":" "; + //if (GetDeltaTime()>=0.2) //Ra: to za bardzo miota tekstem! + // { + // OutText1+= " Slowing Down !!! "; + // } + } + /*if (Console::Pressed(VK_F5)) + {Global::slowmotion=true;}; + if (Console::Pressed(VK_F6)) + {Global::slowmotion=false;};*/ + + if (Global::iTextMode==VK_F8) + { + Global::iViewMode=VK_F8; + OutText1=" FPS: "; + OutText1+=FloatToStrF(GetFPS(),ffFixed,6,2); + if (Global::iSlowMotion) + OutText1+=" (slowmotion "+AnsiString(Global::iSlowMotion)+")"; + OutText1+=", sectors: "; + OutText1+=AnsiString(Ground.iRendered); + } + + //if (Console::Pressed(VK_F7)) + //{ + // OutText1=FloatToStrF(Controlled->MoverParameters->Couplers[0].CouplingFlag,ffFixed,2,0)+", "; + // OutText1+=FloatToStrF(Controlled->MoverParameters->Couplers[1].CouplingFlag,ffFixed,2,0); + //} + + + /* + if (Console::Pressed(VK_F5)) + { + int line=2; + OutText1="Time: "+FloatToStrF(GlobalTime->hh,ffFixed,2,0)+":" + +FloatToStrF(GlobalTime->mm,ffFixed,2,0)+", "; + OutText1+="distance: "; + OutText1+="34.94"; + OutText2="Next station: "; + OutText2+=FloatToStrF(Controlled->TrainParams->TimeTable[line].km,ffFixed,2,2)+" km, "; + OutText2+=AnsiString(Controlled->TrainParams->TimeTable[line].StationName)+", "; + OutText2+=AnsiString(Controlled->TrainParams->TimeTable[line].StationWare); + OutText3="Arrival: "; + if(Controlled->TrainParams->TimeTable[line].Ah==-1) + { + OutText3+="--:--"; + } + else + { + OutText3+=FloatToStrF(Controlled->TrainParams->TimeTable[line].Ah,ffFixed,2,0)+":"; + OutText3+=FloatToStrF(Controlled->TrainParams->TimeTable[line].Am,ffFixed,2,0)+" "; + } + OutText3+=" Departure: "; + OutText3+=FloatToStrF(Controlled->TrainParams->TimeTable[line].Dh,ffFixed,2,0)+":"; + OutText3+=FloatToStrF(Controlled->TrainParams->TimeTable[line].Dm,ffFixed,2,0)+" "; + }; +// */ + /* + if (Console::Pressed(VK_F6)) + { + //GlobalTime->UpdateMTableTime(100); + //OutText1=FloatToStrF(SquareMagnitude(Global::pCameraPosition-Controlled->GetPosition()),ffFixed,10,0); + //OutText1=FloatToStrF(Global::TnijSzczegoly,ffFixed,7,0)+", "; + //OutText1+=FloatToStrF(dta,ffFixed,2,4)+", "; + OutText1+= FloatToStrF(GetFPS(),ffFixed,6,2); + OutText1+= FloatToStrF(Global::ABuDebug,ffFixed,6,15); + }; + */ + if (Global::changeDynObj) + {//ABu zmiana pojazdu - przejście do innego + //Ra: to nie może być tak robione, to zbytnia proteza jest + Train->Silence(); //wyłączenie dźwięków opuszczanej kabiny + if (Train->Dynamic()->Mechanik) //AI może sobie samo pójść + if (!Train->Dynamic()->Mechanik->AIControllFlag) //tylko jeśli ręcznie prowadzony + {//jeśli prowadzi AI, to mu nie robimy dywersji! + Train->Dynamic()->MoverParameters->CabDeactivisation(); + Train->Dynamic()->Controller=AIdriver; + //Train->Dynamic()->MoverParameters->SecuritySystem.Status=0; //rozwala CA w EZT + Train->Dynamic()->MoverParameters->ActiveCab=0; + Train->Dynamic()->MoverParameters->BrakeLevelSet(-2); + Train->Dynamic()->MechInside=false; + } + //int CabNr; + TDynamicObject *temp=Global::changeDynObj; + //CabNr=temp->MoverParameters->ActiveCab; +/* + if (Train->Dynamic()->MoverParameters->ActiveCab==-1) + { + temp=Train->Dynamic()->NextConnected; //pojazd od strony sprzęgu 1 + CabNr=(Train->Dynamic()->NextConnectedNo==0)?1:-1; + } + else + { + temp=Train->Dynamic()->PrevConnected; //pojazd od strony sprzęgu 0 + CabNr=(Train->Dynamic()->PrevConnectedNo==0)?1:-1; + } +*/ + Train->Dynamic()->bDisplayCab=false; + Train->Dynamic()->ABuSetModelShake(vector3(0,0,0)); + ///Train->Dynamic()->MoverParameters->LimPipePress=-1; + ///Train->Dynamic()->MoverParameters->ActFlowSpeed=0; + ///Train->Dynamic()->Mechanik->CloseLog(); + ///SafeDelete(Train->Dynamic()->Mechanik); + + //Train->Dynamic()->mdKabina=NULL; + if (Train->Dynamic()->Mechanik) //AI może sobie samo pójść + if (!Train->Dynamic()->Mechanik->AIControllFlag) //tylko jeśli ręcznie prowadzony + Train->Dynamic()->Mechanik->MoveTo(temp); //przsunięcie obiektu zarządzającego + //Train->DynamicObject=NULL; + Train->DynamicSet(temp); + Controlled=temp; + mvControlled=Controlled->ControlledFind()->MoverParameters; + Global::asHumanCtrlVehicle=Train->Dynamic()->GetName(); + if (Train->Dynamic()->Mechanik) //AI może sobie samo pójść + if (!Train->Dynamic()->Mechanik->AIControllFlag) //tylko jeśli ręcznie prowadzony + {Train->Dynamic()->MoverParameters->LimPipePress=Controlled->MoverParameters->PipePress; + //Train->Dynamic()->MoverParameters->ActFlowSpeed=0; + //Train->Dynamic()->MoverParameters->SecuritySystem.Status=1; + //Train->Dynamic()->MoverParameters->ActiveCab=CabNr; + Train->Dynamic()->MoverParameters->CabActivisation(); //załączenie rozrządu (wirtualne kabiny) + Train->Dynamic()->Controller=Humandriver; + Train->Dynamic()->MechInside=true; + //Train->Dynamic()->Mechanik=new TController(l,r,Controlled->Controller,&Controlled->MoverParameters,&Controlled->TrainParams,Aggressive); + //Train->InitializeCab(CabNr,Train->Dynamic()->asBaseDir+Train->Dynamic()->MoverParameters->TypeName+".mmd"); + } + Train->InitializeCab(Train->Dynamic()->MoverParameters->CabNo,Train->Dynamic()->asBaseDir+Train->Dynamic()->MoverParameters->TypeName+".mmd"); + if (!FreeFlyModeFlag) + {Global::pUserDynamic=Controlled; //renerowanie względem kamery + Train->Dynamic()->bDisplayCab=true; + Train->Dynamic()->ABuSetModelShake(vector3(0,0,0)); //zerowanie przesunięcia przed powrotem? + Train->MechStop(); + FollowView(); //na pozycję mecha + } + Global::changeDynObj=NULL; + } + + glDisable(GL_LIGHTING); + if (Controlled) + SetWindowText(hWnd,AnsiString(Controlled->MoverParameters->Name).c_str()); + else + SetWindowText(hWnd,Global::szSceneryFile); //nazwa scenerii + glBindTexture(GL_TEXTURE_2D, 0); + glColor4f(1.0f,0.0f,0.0f,1.0f); + glLoadIdentity(); + glTranslatef(0.0f,0.0f,-0.50f); + + + if (Global::iTextMode==VK_F1) + {//tekst pokazywany po wciśnięciu [F1] + //Global::iViewMode=VK_F1; + glColor3f(1.0f,1.0f,1.0f); //a, damy białym + OutText1="Time: "+AnsiString((int)GlobalTime->hh)+":"; + int i=GlobalTime->mm; //bo inaczej potrafi zrobić "hh:010" + if (i<10) OutText1+="0"; + OutText1+=AnsiString(i); //minuty + OutText1+=":"; + i=floor(GlobalTime->mr); //bo inaczej potrafi zrobić "hh:mm:010" + if (i<10) OutText1+="0"; + OutText1+=AnsiString(i); + if (Global::iPause) OutText1+=" - paused"; + if (Controlled) + if (Controlled->Mechanik) + {OutText2=Controlled->Mechanik->Relation(); + if (!OutText2.IsEmpty()) //jeśli jest podana relacja, to dodajemy punkt następnego zatrzymania + OutText2=Global::Bezogonkow(OutText2+": -> "+Controlled->Mechanik->NextStop(),true); //dopisanie punktu zatrzymania + } + //double CtrlPos=mvControlled->MainCtrlPos; + //double CtrlPosNo=mvControlled->MainCtrlPosNo; + //OutText2="defrot="+FloatToStrF(1+0.4*(CtrlPos/CtrlPosNo),ffFixed,2,5); + OutText3=""; //Pomoc w sterowaniu - [F9]"; + //OutText3=AnsiString(Global::pCameraRotationDeg); //kąt kamery względem północy + } + else if (Global::iTextMode==VK_F12) + {//opcje włączenia i wyłączenia logowania + OutText1="[0] Debugmode "+AnsiString(DebugModeFlag?"(on)":"(off)"); + OutText2="[1] log.txt "+AnsiString((Global::iWriteLogEnabled&1)?"(on)":"(off)"); + OutText3="[2] Console "+AnsiString((Global::iWriteLogEnabled&2)?"(on)":"(off)"); + } + else if (Global::iTextMode==VK_F2) + {//ABu: info dla najblizszego pojazdu! + TDynamicObject *tmp=FreeFlyModeFlag?Ground.DynamicNearest(Camera.Pos):Controlled; //w trybie latania lokalizujemy wg mapy + if (tmp) + { + if (Global::iScreenMode[Global::iTextMode-VK_F1]==0) + {//jeśli domyślny ekran po pierwszym naciśnięciu + OutText3=""; + OutText1="Vehicle name: "+AnsiString(tmp->MoverParameters->Name); +//yB OutText1+="; d: "+FloatToStrF(tmp->ABuGetDirection(),ffFixed,2,0); + //OutText1=FloatToStrF(tmp->MoverParameters->Couplers[0].CouplingFlag,ffFixed,3,2)+", "; + //OutText1+=FloatToStrF(tmp->MoverParameters->Couplers[1].CouplingFlag,ffFixed,3,2); + if (tmp->Mechanik) //jeśli jest prowadzący + {//ostatnia komenda dla AI + OutText1+=", command: "+tmp->Mechanik->OrderCurrent(); + } + else if (tmp->ctOwner) + OutText1+=", owned by "+AnsiString(tmp->ctOwner->OwnerName()); + if (!tmp->MoverParameters->CommandLast.IsEmpty()) + OutText1+=AnsiString(", put: ")+tmp->MoverParameters->CommandLast; + //OutText1+="; Cab="+AnsiString(tmp->MoverParameters->CabNo); + OutText2="Damage status: "+tmp->MoverParameters->EngineDescription(0);//+" Engine status: "; + OutText2+="; Brake delay: "; + if((tmp->MoverParameters->BrakeDelayFlag&bdelay_G)==bdelay_G) + OutText2+="G"; + if((tmp->MoverParameters->BrakeDelayFlag&bdelay_P)==bdelay_P) + OutText2+="P"; + if((tmp->MoverParameters->BrakeDelayFlag&bdelay_R)==bdelay_R) + OutText2+="R"; + if((tmp->MoverParameters->BrakeDelayFlag&bdelay_M)==bdelay_M) + OutText2+="+Mg"; + OutText2+=AnsiString(", BTP:")+FloatToStrF(tmp->MoverParameters->LoadFlag,ffFixed,5,0); + //if ((tmp->MoverParameters->EnginePowerSource.SourceType==CurrentCollector) || (tmp->MoverParameters->TrainType==dt_EZT)) + {OutText2+=AnsiString("; pant. ")+FloatToStrF(tmp->MoverParameters->PantPress,ffFixed,8,2); + OutText2+=(tmp->MoverParameters->bPantKurek3?"MoverParameters->u,ffFixed,3,3); +// OutText2+=AnsiString(", N:")+FloatToStrF(tmp->MoverParameters->Ntotal,ffFixed,4,0); + OutText2+=AnsiString(", Ft:")+FloatToStrF(tmp->MoverParameters->Ft,ffFixed,4,0); +// OutText3= AnsiString("BP: ")+FloatToStrF(tmp->MoverParameters->BrakePress,ffFixed,5,2)+AnsiString(", "); +// OutText3+= AnsiString("PP: ")+FloatToStrF(tmp->MoverParameters->PipePress,ffFixed,5,2)+AnsiString(", "); +// OutText3+= AnsiString("BVP: ")+FloatToStrF(tmp->MoverParameters->Volume,ffFixed,5,3)+AnsiString(", "); +// OutText3+= FloatToStrF(tmp->MoverParameters->CntrlPipePress,ffFixed,5,3)+AnsiString(", "); +// OutText3+= FloatToStrF(tmp->MoverParameters->Hamulec->GetCRP(),ffFixed,5,3)+AnsiString(", "); +// OutText3+= FloatToStrF(tmp->MoverParameters->BrakeStatus,ffFixed,5,0)+AnsiString(", "); +// OutText3+= AnsiString("HP: ")+FloatToStrF(tmp->MoverParameters->ScndPipePress,ffFixed,5,2)+AnsiString(". "); +// OutText2+= FloatToStrF(tmp->MoverParameters->CompressorPower,ffFixed,5,0)+AnsiString(", "); +//yB if(tmp->MoverParameters->BrakeSubsystem==Knorr) OutText2+=" Knorr"; +//yB if(tmp->MoverParameters->BrakeSubsystem==Oerlikon) OutText2+=" Oerlikon"; +//yB if(tmp->MoverParameters->BrakeSubsystem==Hik) OutText2+=" Hik"; +//yB if(tmp->MoverParameters->BrakeSubsystem==WeLu) OutText2+=" Łestinghałs"; + //OutText2= " GetFirst: "+AnsiString(tmp->GetFirstDynamic(1)->MoverParameters->Name)+" Damage status="+tmp->MoverParameters->EngineDescription(0)+" Engine status: "; + //OutText2+= " GetLast: "+AnsiString(tmp->GetLastDynamic(1)->MoverParameters->Name)+" Damage status="+tmp->MoverParameters->EngineDescription(0)+" Engine status: "; + OutText3=AnsiString("BP: ")+FloatToStrF(tmp->MoverParameters->BrakePress,ffFixed,5,2)+AnsiString(", "); + OutText3+=FloatToStrF(tmp->MoverParameters->BrakeStatus,ffFixed,5,0)+AnsiString(", "); + OutText3+=AnsiString("PP: ")+FloatToStrF(tmp->MoverParameters->PipePress,ffFixed,5,2)+AnsiString("/"); + OutText3+=FloatToStrF(tmp->MoverParameters->ScndPipePress,ffFixed,5,2)+AnsiString("/"); + OutText3+=FloatToStrF(tmp->MoverParameters->EqvtPipePress,ffFixed,5,2)+AnsiString(", "); + OutText3+=AnsiString("BVP: ")+FloatToStrF(tmp->MoverParameters->Volume,ffFixed,5,3)+AnsiString(", "); + OutText3+=FloatToStrF(tmp->MoverParameters->CntrlPipePress,ffFixed,5,3)+AnsiString(", "); + OutText3+=FloatToStrF(tmp->MoverParameters->Hamulec->GetCRP(),ffFixed,5,3)+AnsiString(", "); + OutText3+=FloatToStrF(tmp->MoverParameters->BrakeStatus,ffFixed,5,0)+AnsiString(", "); +// OutText3+=AnsiString("BVP: ")+FloatToStrF(tmp->MoverParameters->BrakeVP(),ffFixed,5,2)+AnsiString(", "); + +// OutText3+=FloatToStrF(tmp->MoverParameters->CntrlPipePress,ffFixed,5,2)+AnsiString(", "); +// OutText3+=FloatToStrF(tmp->MoverParameters->HighPipePress,ffFixed,5,2)+AnsiString(", "); +// OutText3+=FloatToStrF(tmp->MoverParameters->LowPipePress,ffFixed,5,2)+AnsiString(", "); + + if (tmp->MoverParameters->ManualBrakePos>0) + OutText3+=AnsiString("manual brake active. "); + else if (tmp->MoverParameters->LocalBrakePos>0) + OutText3+=AnsiString("local brake active. "); + else + OutText3+=AnsiString("local brake inactive. "); +/* + //OutText3+=AnsiString("LSwTim: ")+FloatToStrF(tmp->MoverParameters->LastSwitchingTime,ffFixed,5,2); + //OutText3+=AnsiString(" Physic: ")+FloatToStrF(tmp->MoverParameters->PhysicActivation,ffFixed,5,2); + //OutText3+=AnsiString(" ESF: ")+FloatToStrF(tmp->MoverParameters->EndSignalsFlag,ffFixed,5,0); + OutText3+=AnsiString(" dPAngF: ")+FloatToStrF(tmp->dPantAngleF,ffFixed,5,0); + OutText3+=AnsiString(" dPAngFT: ")+FloatToStrF(-(tmp->PantTraction1*28.9-136.938),ffFixed,5,0); + if (tmp->lastcabf==1) + { + OutText3+=AnsiString(" pcabc1: ")+FloatToStrF(tmp->MoverParameters->PantFrontUp,ffFixed,5,0); + OutText3+=AnsiString(" pcabc2: ")+FloatToStrF(tmp->MoverParameters->PantRearUp,ffFixed,5,0); + } + if (tmp->lastcabf==-1) + { + OutText3+=AnsiString(" pcabc1: ")+FloatToStrF(tmp->MoverParameters->PantRearUp,ffFixed,5,0); + OutText3+=AnsiString(" pcabc2: ")+FloatToStrF(tmp->MoverParameters->PantFrontUp,ffFixed,5,0); + } +*/ + OutText4=""; + if (tmp->Mechanik) + {//o ile jest ktoś w środku + //OutText4=tmp->Mechanik->StopReasonText(); + //if (!OutText4.IsEmpty()) OutText4+="; "; //aby ładniejszy odstęp był + //if (Controlled->Mechanik && (Controlled->Mechanik->AIControllFlag==AIdriver)) + AnsiString flags="bwaccmlshhhoibsgvdp; "; //flagi AI (definicja w Driver.h) + for (int i=0,j=1;i<19;++i,j<<=1) + if (tmp->Mechanik->DrivigFlags()&j) //jak bit ustawiony + flags[i+1]^=0x20; //to zmiana na wielką literę + OutText4=flags; + OutText4+=AnsiString("Driver: Vd=")+FloatToStrF(tmp->Mechanik->VelDesired,ffFixed,4,0) + +AnsiString(" ad=")+FloatToStrF(tmp->Mechanik->AccDesired,ffFixed,5,2) + +AnsiString(" Pd=")+FloatToStrF(tmp->Mechanik->ActualProximityDist,ffFixed,4,0) + +AnsiString(" Vn=")+FloatToStrF(tmp->Mechanik->VelNext,ffFixed,4,0); + if (tmp->Mechanik->VelNext==0.0) + if (tmp->Mechanik->eSignNext) + {//jeśli ma zapamiętany event semafora + //if (!OutText4.IsEmpty()) OutText4+=", "; //aby ładniejszy odstęp był + OutText4+=" ("+Global::Bezogonkow(tmp->Mechanik->eSignNext->asName)+")"; //nazwa eventu semafora + } + } + if (!OutText4.IsEmpty()) OutText4+="; "; //aby ładniejszy odstęp był + //informacja o sprzęgach nawet bez mechanika + OutText4+="C0="+(tmp->PrevConnected?tmp->PrevConnected->GetName()+":"+AnsiString(tmp->MoverParameters->Couplers[0].CouplingFlag):AnsiString("NULL")); + OutText4+=" C1="+(tmp->NextConnected?tmp->NextConnected->GetName()+":"+AnsiString(tmp->MoverParameters->Couplers[1].CouplingFlag):AnsiString("NULL")); + if (Console::Pressed(VK_F2)) + {WriteLog(OutText1); + WriteLog(OutText2); + WriteLog(OutText3); + WriteLog(OutText4); + } + } //koniec treści podstawowego ekranu FK_V2 + else + {//ekran drugi, czyli tabelka skanowania AI + if (tmp->Mechanik) //żeby była tabelka, musi być AI + {//tabelka jest na użytek testujących scenerie, więc nie musi być "ładna" + glColor3f(0.0f,1.0f,0.0f); //a, damy zielony + //glTranslatef(0.0f,0.0f,-0.50f); + glRasterPos2f(-0.25f,0.20f); + //OutText1="Scan distance: "+AnsiString(tmp->Mechanik->scanmax)+", back: "+AnsiString(tmp->Mechanik->scanback); + OutText1="Time: "+AnsiString((int)GlobalTime->hh)+":"; + int i=GlobalTime->mm; //bo inaczej potrafi zrobić "hh:010" + if (i<10) OutText1+="0"; + OutText1+=AnsiString(i); //minuty + OutText1+=":"; + i=floor(GlobalTime->mr); //bo inaczej potrafi zrobić "hh:mm:010" + if (i<10) OutText1+="0"; + OutText1+=AnsiString(i); + OutText1+=AnsiString(". Vel: ")+FloatToStrF(tmp->GetVelocity(),ffFixed,6,1); + OutText1+=". Scan table:"; + glPrint(Global::Bezogonkow(OutText1).c_str()); + i=-1; + while ((OutText1=tmp->Mechanik->TableText(++i))!="") + {//wyświetlenie pozycji z tabelki + glRasterPos2f(-0.25f,0.19f-0.01f*i); + glPrint(Global::Bezogonkow(OutText1).c_str()); + } + //podsumowanie sensu tabelki + OutText4=AnsiString("Driver: Vd=")+FloatToStrF(tmp->Mechanik->VelDesired,ffFixed,4,0) + +AnsiString(" ad=")+FloatToStrF(tmp->Mechanik->AccDesired,ffFixed,5,2) + +AnsiString(" Pd=")+FloatToStrF(tmp->Mechanik->ActualProximityDist,ffFixed,4,0) + +AnsiString(" Vn=")+FloatToStrF(tmp->Mechanik->VelNext,ffFixed,4,0); + if (tmp->Mechanik->VelNext==0.0) + if (tmp->Mechanik->eSignNext) + {//jeśli ma zapamiętany event semafora + //if (!OutText4.IsEmpty()) OutText4+=", "; //aby ładniejszy odstęp był + OutText4+=" ("+Global::Bezogonkow(tmp->Mechanik->eSignNext->asName)+")"; //nazwa eventu semafora + } + glRasterPos2f(-0.25f,0.19f-0.01f*i); + glPrint(Global::Bezogonkow(OutText4).c_str()); + } + } //koniec ekanu skanowania + } //koniec obsługi, gdy mamy wskaźnik do pojazdu + else + {//wyświetlenie współrzędnych w scenerii oraz kąta kamery, gdy nie mamy wskaźnika + OutText1="Camera position: "+FloatToStrF(Camera.Pos.x,ffFixed,6,2)+" "+FloatToStrF(Camera.Pos.y,ffFixed,6,2)+" "+FloatToStrF(Camera.Pos.z,ffFixed,6,2); + OutText1+=", azimuth: "+FloatToStrF(180.0-RadToDeg(Camera.Yaw),ffFixed,3,0); //ma być azymut, czyli 0 na północy i rośnie na wschód + OutText1+=" "+AnsiString("S SEE NEN NWW SW").SubString(1+2*floor(fmod(8+(Camera.Yaw+0.5*M_PI_4)/M_PI_4,8)),2); + } + //OutText3= AnsiString(" Online documentation (PL, ENG, DE, soon CZ): http://www.eu07.pl"); + //OutText3="enrot="+FloatToStrF(Controlled->MoverParameters->enrot,ffFixed,6,2); + //OutText3="; n="+FloatToStrF(Controlled->MoverParameters->n,ffFixed,6,2); + } //koniec treści podstawowego ekranu FK_V2 + else if (Global::iTextMode==VK_F5) + {//przesiadka do innego pojazdu + if (FreeFlyModeFlag) //jeśli tryb latania + {TDynamicObject *tmp=Ground.DynamicNearest(Camera.Pos,50,true); //łapiemy z obsadą + if (tmp) + if (tmp!=Controlled) + {if (Controlled) //jeśli mielismy pojazd + if (Controlled->Mechanik) //na skutek jakiegoś błędu może czasem zniknąć + Controlled->Mechanik->TakeControl(true); //oddajemy dotychczasowy AI + if (DebugModeFlag?true:tmp->MoverParameters->Vel<=5.0) + {Controlled=tmp; //przejmujemy nowy + mvControlled=Controlled->ControlledFind()->MoverParameters; + if (Train) + Train->Silence(); //wyciszenie dźwięków opuszczanego pojazdu + else + Train=new TTrain(); //jeśli niczym jeszcze nie jeździlismy + if (Train->Init(Controlled)) + {//przejmujemy sterowanie + if (!DebugModeFlag) //w DebugMode nadal prowadzi AI + Controlled->Mechanik->TakeControl(false); + } + else + SafeDelete(Train); //i nie ma czym sterować + //Global::pUserDynamic=Controlled; //renerowanie pojazdu względem kabiny + //Global::iTextMode=VK_F4; + if (Train) InOutKey(); //do kabiny + } + } + Global::iTextMode=0; //tryb neutralny + } +/* + + OutText1=OutText2=OutText3=OutText4=""; + AnsiString flag[10]={"vmax", "tory", "smfr", "pjzd", "mnwr", "pstk", "brak", "brak", "brak", "brak"}; + if(tmp) + if(tmp->Mechanik) + { + for(int i=0;i<15;i++) + { + int tmppar=floor(tmp->Mechanik->ProximityTable[i].Vel); + OutText2+=(tmppar<1000?(tmppar<100?((tmppar<10)&&(tmppar>=0)?" ":" "):" "):"")+IntToStr(tmppar)+" "; + tmppar=floor(tmp->Mechanik->ProximityTable[i].Dist); + OutText3+=(tmppar<1000?(tmppar<100?((tmppar<10)&&(tmppar>=0)?" ":" "):" "):"")+IntToStr(tmppar)+" "; + OutText1+=flag[tmp->Mechanik->ProximityTable[i].Flag]+" "; + } + for(int i=0;i<6;i++) + { + int tmppar=floor(tmp->Mechanik->ReducedTable[i]); + OutText4+=flag[i]+":"+(tmppar<1000?(tmppar<100?((tmppar<10)&&(tmppar>=0)?" ":" "):" "):"")+IntToStr(tmppar)+" "; + } + } +*/ + } + else if (Global::iTextMode==VK_F10) + {//tu mozna dodac dopisywanie do logu przebiegu lokomotywy + //Global::iViewMode=VK_F10; + //return false; + OutText1=AnsiString("To quit press [Y] key."); + OutText3=AnsiString("Aby zakonczyc program, przycisnij klawisz [Y]."); + } + else + if (Controlled && DebugModeFlag && !Global::iTextMode) + { + OutText1+=AnsiString("; vel ")+FloatToStrF(Controlled->GetVelocity(),ffFixed,6,2); + OutText1+=AnsiString("; pos ")+FloatToStrF(Controlled->GetPosition().x,ffFixed,6,2); + OutText1+=AnsiString(" ; ")+FloatToStrF(Controlled->GetPosition().y,ffFixed,6,2); + OutText1+=AnsiString(" ; ")+FloatToStrF(Controlled->GetPosition().z,ffFixed,6,2); + OutText1+=AnsiString("; dist=")+FloatToStrF(Controlled->MoverParameters->DistCounter,ffFixed,8,4); + + //double a= acos( DotProduct(Normalize(Controlled->GetDirection()),vWorldFront)); +// OutText+= AnsiString("; angle ")+FloatToStrF(a/M_PI*180,ffFixed,6,2); + OutText1+=AnsiString("; d_omega ")+FloatToStrF(Controlled->MoverParameters->dizel_engagedeltaomega,ffFixed,6,3); + OutText2 =AnsiString("HamZ=")+FloatToStrF(Controlled->MoverParameters->fBrakeCtrlPos,ffFixed,6,1); + OutText2+=AnsiString("; HamP=")+AnsiString(Controlled->MoverParameters->LocalBrakePos); + //mvControlled->MainCtrlPos; + //if (mvControlled->MainCtrlPos<0) + // OutText2+= AnsiString("; nastawnik 0"); +// if (mvControlled->MainCtrlPos>iPozSzereg) + OutText2+= AnsiString("; NasJ=")+AnsiString(mvControlled->MainCtrlPos); +// else +// OutText2+= AnsiString("; nastawnik S") + mvControlled->MainCtrlPos; + OutText2+=AnsiString("(")+AnsiString(mvControlled->MainCtrlActualPos); + + OutText2+=AnsiString("); NasB=")+AnsiString(mvControlled->ScndCtrlPos); + OutText2+=AnsiString("(")+AnsiString(mvControlled->ScndCtrlActualPos); + if (mvControlled->TrainType==dt_EZT) + OutText2+=AnsiString("); I=")+AnsiString(int(mvControlled->ShowCurrent(0))); + else + OutText2+=AnsiString("); I=")+AnsiString(int(mvControlled->Im)); + //OutText2+=AnsiString("; I2=")+FloatToStrF(Controlled->NextConnected->MoverParameters->Im,ffFixed,6,2); + OutText2+=AnsiString("; U=")+AnsiString(int(mvControlled->RunningTraction.TractionVoltage+0.5)); + //OutText2+=AnsiString("; rvent=")+FloatToStrF(mvControlled->RventRot,ffFixed,6,2); + OutText2+=AnsiString("; R=")+FloatToStrF(Controlled->MoverParameters->RunningShape.R,ffFixed,4,1); + OutText2+=AnsiString(" An=")+FloatToStrF(Controlled->MoverParameters->AccN,ffFixed,4,2); //przyspieszenie poprzeczne + OutText2+=AnsiString("; As=")+FloatToStrF(Controlled->MoverParameters->AccS,ffFixed,4,2); //przyspieszenie wzdłużne + //OutText2+=AnsiString("; P=")+FloatToStrF(mvControlled->EnginePower,ffFixed,6,1); + OutText3+=AnsiString("cyl.ham. ")+FloatToStrF(Controlled->MoverParameters->BrakePress,ffFixed,5,2); + OutText3+=AnsiString("; prz.gl. ")+FloatToStrF(Controlled->MoverParameters->PipePress,ffFixed,5,2); + OutText3+=AnsiString("; zb.gl. ")+FloatToStrF(Controlled->MoverParameters->CompressedVolume,ffFixed,6,2); +//youBy - drugi wezyk + OutText3+=AnsiString("; p.zas. ")+FloatToStrF(Controlled->MoverParameters->ScndPipePress,ffFixed,6,2); + + if(Controlled->MoverParameters->EngineType==ElectricInductionMotor) + { + //glTranslatef(0.0f,0.0f,-0.50f); + glColor3f(1.0f,1.0f,1.0f); //a, damy białym + for(int i=0;i<=20;i++) + { + glRasterPos2f(-0.25f,0.16f-0.01f*i); + if(Controlled->MoverParameters->eimc[i]<10) + OutText4=FloatToStrF(Controlled->MoverParameters->eimc[i],ffFixed,6,3); + else + OutText4=FloatToStrF(Controlled->MoverParameters->eimc[i],ffGeneral,5,3); + glPrint(OutText4.c_str()); + } + for(int i=0;i<=20;i++) + { + glRasterPos2f(-0.2f,0.16f-0.01f*i); + if(Controlled->MoverParameters->eimv[i]<10) + OutText4=FloatToStrF(Controlled->MoverParameters->eimv[i],ffFixed,6,3); + else + OutText4=FloatToStrF(Controlled->MoverParameters->eimv[i],ffGeneral,5,3); + glPrint(OutText4.c_str()); + } + OutText4=""; + //glTranslatef(0.0f,0.0f,+0.50f); + glColor3f(1.0f,0.0f,0.0f); //a, damy czerwonym + } + + + //ABu: testy sprzegow-> (potem przeniesc te zmienne z public do protected!) + //OutText3+=AnsiString("; EnginePwr=")+FloatToStrF(mvControlled->EnginePower,ffFixed,1,5); + //OutText3+=AnsiString("; nn=")+FloatToStrF(Controlled->NextConnectedNo,ffFixed,1,0); + //OutText3+=AnsiString("; PR=")+FloatToStrF(Controlled->dPantAngleR,ffFixed,3,0); + //OutText3+=AnsiString("; PF=")+FloatToStrF(Controlled->dPantAngleF,ffFixed,3,0); + //if(Controlled->bDisplayCab==true) + //OutText3+=AnsiString("; Wysw. kab");//+Controlled->mdKabina->GetSMRoot()->Name; + //else + //OutText3+=AnsiString("; test:")+AnsiString(Controlled->MoverParameters->TrainType[1]); + + //OutText3+=FloatToStrF(Train->Dynamic()->MoverParameters->EndSignalsFlag,ffFixed,3,0);; + + //OutText3+=FloatToStrF(Train->Dynamic()->MoverParameters->EndSignalsFlag&byte(((((1+Train->Dynamic()->MoverParameters->CabNo)/2)*30)+2)),ffFixed,3,0);; + + //OutText3+=AnsiString("; Ftmax=")+FloatToStrF(Controlled->MoverParameters->Ftmax,ffFixed,3,0); + //OutText3+=AnsiString("; FTotal=")+FloatToStrF(Controlled->MoverParameters->FTotal/1000.0f,ffFixed,3,2); + //OutText3+=AnsiString("; FTrain=")+FloatToStrF(Controlled->MoverParameters->FTrain/1000.0f,ffFixed,3,2); + //Controlled->mdModel->GetSMRoot()->SetTranslate(vector3(0,1,0)); + + //McZapkie: warto wiedziec w jakim stanie sa przelaczniki + if (mvControlled->ConvOvldFlag) + OutText3+=" C! "; + else if (mvControlled->FuseFlag) + OutText3+=" F! "; + else if (!mvControlled->Mains) + OutText3+=" () "; + else + switch (mvControlled->ActiveDir*(mvControlled->Imin==mvControlled->IminLo?1:2)) + { + case 2: {OutText3+=" >> "; break;} + case 1: {OutText3+=" -> "; break;} + case 0: {OutText3+=" -- "; break;} + case -1: {OutText3+=" <- "; break;} + case -2: {OutText3+=" << "; break;} + } + //OutText3+=AnsiString("; dpLocal ")+FloatToStrF(Controlled->MoverParameters->dpLocalValve,ffFixed,10,8); + //OutText3+=AnsiString("; dpMain ")+FloatToStrF(Controlled->MoverParameters->dpMainValve,ffFixed,10,8); + //McZapkie: predkosc szlakowa + if (Controlled->MoverParameters->RunningTrack.Velmax==-1) + {OutText3+=AnsiString(" Vtrack=Vmax");} + else + {OutText3+=AnsiString(" Vtrack ")+FloatToStrF(Controlled->MoverParameters->RunningTrack.Velmax,ffFixed,8,2);} +// WriteLog(Controlled->MoverParameters->TrainType.c_str()); + if ((mvControlled->EnginePowerSource.SourceType==CurrentCollector) || (mvControlled->TrainType==dt_EZT)) + {OutText3+=AnsiString("; pant. ")+FloatToStrF(mvControlled->PantPress,ffFixed,8,2); + OutText3+=(mvControlled->bPantKurek3?"=ZG":"|ZG"); + } + //McZapkie: komenda i jej parametry + if (Controlled->MoverParameters->CommandIn.Command!=AnsiString("")) + OutText4=AnsiString("C:")+AnsiString(Controlled->MoverParameters->CommandIn.Command) + +AnsiString(" V1=")+FloatToStrF(Controlled->MoverParameters->CommandIn.Value1,ffFixed,5,0) + +AnsiString(" V2=")+FloatToStrF(Controlled->MoverParameters->CommandIn.Value2,ffFixed,5,0); + if (Controlled->Mechanik && (Controlled->Mechanik->AIControllFlag==AIdriver)) + OutText4+=AnsiString("AI: Vd=")+FloatToStrF(Controlled->Mechanik->VelDesired,ffFixed,4,0) + +AnsiString(" ad=")+FloatToStrF(Controlled->Mechanik->AccDesired,ffFixed,5,2) + +AnsiString(" Pd=")+FloatToStrF(Controlled->Mechanik->ActualProximityDist,ffFixed,4,0) + +AnsiString(" Vn=")+FloatToStrF(Controlled->Mechanik->VelNext,ffFixed,4,0); + } + +//ABu 150205: prosty help, zeby sie na forum nikt nie pytal, jak ma ruszyc :) + + if (Global::detonatoryOK) + { + //if (Console::Pressed(VK_F9)) ShowHints(); //to nie działa prawidłowo - prosili wyłączyć + if (Global::iTextMode==VK_F9) + {//informacja o wersji, sposobie wyświetlania i błędach OpenGL + //Global::iViewMode=VK_F9; + OutText1=Global::asVersion; //informacja o wersji + OutText2=AnsiString("Rendering mode: ")+(Global::bUseVBO?"VBO":"Display Lists"); + if (Global::iMultiplayer) OutText2+=". Multiplayer is active"; + OutText2+="."; + GLenum err=glGetError(); + if (err!=GL_NO_ERROR) + { + OutText3="OpenGL error "+AnsiString(err)+": "+Global::Bezogonkow(AnsiString((char *)gluErrorString(err))); + } + } + if (Global::iTextMode==VK_F3) + {//wyświetlenie rozkładu jazdy, na razie jakkolwiek + TDynamicObject *tmp=FreeFlyModeFlag?Ground.DynamicNearest(Camera.Pos):Controlled; //w trybie latania lokalizujemy wg mapy + Mtable::TTrainParameters *tt=NULL; + if (tmp) + if (tmp->Mechanik) + {tt=tmp->Mechanik->Timetable(); + if (tt) //musi być rozkład + {//wyświetlanie rozkładu + glColor3f(1.0f,1.0f,1.0f); //a, damy białym + //glTranslatef(0.0f,0.0f,-0.50f); + glRasterPos2f(-0.25f,0.20f); + OutText1=tmp->Mechanik->Relation()+" ("+tmp->Mechanik->Timetable()->TrainName+")"; + glPrint(Global::Bezogonkow(OutText1,true).c_str()); + glRasterPos2f(-0.25f,0.19f); + //glPrint("|============================|=======|=======|=====|"); + //glPrint("| Posterunek | Przyj.| Odjazd| Vmax|"); + //glPrint("|============================|=======|=======|=====|"); + glPrint("|----------------------------|-------|-------|-----|"); + TMTableLine *t; + for (int i=tmp->Mechanik->iStationStart;i<=tt->StationCount;++i) + {//wyświetlenie pozycji z rozkładu + t=tt->TimeTable+i; //linijka rozkładu + OutText1=AnsiString(AnsiString(t->StationName)+" ").SubString(1,26); + OutText2=(t->Ah>=0)?AnsiString(int(100+t->Ah)).SubString(2,2)+":"+AnsiString(int(100+t->Am)).SubString(2,2):AnsiString(" "); + OutText3=(t->Dh>=0)?AnsiString(int(100+t->Dh)).SubString(2,2)+":"+AnsiString(int(100+t->Dm)).SubString(2,2):AnsiString(" "); + OutText4=" "+FloatToStrF(t->vmax,ffFixed,3,0); + OutText4=OutText4.SubString(OutText4.Length()-2,3); //z wyrównaniem do prawej + //if (AnsiString(t->StationWare).Pos("@")) + OutText1="| "+OutText1+" | "+OutText2+" | "+OutText3+" | "+OutText4+" | "+AnsiString(t->StationWare); + glRasterPos2f(-0.25f,0.18f-0.02f*(i-tmp->Mechanik->iStationStart)); + if ((tmp->Mechanik->iStationStartStationIndex)?(iStationIndex):false) + {//czas minął i odjazd był, to nazwa stacji będzie na zielono + glColor3f(0.0f,1.0f,0.0f); //zielone + glRasterPos2f(-0.25f,0.18f-0.02f*(i-tmp->Mechanik->iStationStart)); //dopiero ustawienie pozycji ustala kolor, dziwne... + glPrint(Global::Bezogonkow(OutText1,true).c_str()); + glColor3f(1.0f,1.0f,1.0f); //a reszta białym + } + else //normalne wyświetlanie, bez zmiany kolorów + glPrint(Global::Bezogonkow(OutText1,true).c_str()); + glRasterPos2f(-0.25f,0.17f-0.02f*(i-tmp->Mechanik->iStationStart)); + glPrint("|----------------------------|-------|-------|-----|"); + } + } + } + OutText1=OutText2=OutText3=OutText4=""; + } + else if (OutText1!="") + {//ABu: i od razu czyszczenie tego, co bylo napisane + //glTranslatef(0.0f,0.0f,-0.50f); + glRasterPos2f(-0.25f,0.20f); + glPrint(OutText1.c_str()); + OutText1=""; + if (OutText2!="") + {glRasterPos2f(-0.25f,0.19f); + glPrint(OutText2.c_str()); + OutText2=""; + } + if (OutText3!="") + {glRasterPos2f(-0.25f,0.18f); + glPrint(OutText3.c_str()); + OutText3=""; + if (OutText4!="") + {glRasterPos2f(-0.25f, 0.17f); + glPrint(OutText4.c_str()); + OutText4=""; + } + } + } + //if ((Global::iTextMode!=VK_F3)) + {//stenogramy dźwięków (ukryć, gdy tabelka skanowania lub rozkład?) + glColor3f(1.0f,1.0f,0.0f); //żółte + for (int i=0;i<5;++i) + {//kilka linijek + if (Global::asTranscript[i].IsEmpty()) + break; //dalej nie trzeba + else + { + glRasterPos2f(-0.20f,-0.05f-0.01f*i); + glPrint(Global::Bezogonkow(Global::asTranscript[i]).c_str()); + } + } + } + } + //if (Global::iViewMode!=Global::iTextMode) + //{//Ra: taka maksymalna prowizorka na razie + // WriteLog("Pressed function key F"+AnsiString(Global::iViewMode-111)); + // Global::iTextMode=Global::iViewMode; + //} + glEnable(GL_LIGHTING); + return (true); +}; + +bool __fastcall TWorld::Render() +{ + glColor3b(255, 255, 255); + //glColor3b(255, 0, 255); + glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT); + glMatrixMode(GL_MODELVIEW); // Select The Modelview Matrix + glLoadIdentity(); + Camera.SetMatrix(); //ustawienie macierzy kamery względem początku scenerii + glLightfv(GL_LIGHT0,GL_POSITION,Global::lightPos); + + if (!Global::bWireFrame) + {//bez nieba w trybie rysowania linii + glDisable(GL_FOG); + Clouds.Render(); + glEnable(GL_FOG); + } + if (Global::bUseVBO) + {//renderowanie przez VBO + if (!Ground.RenderVBO(Camera.Pos)) return false; + if (!Ground.RenderAlphaVBO(Camera.Pos)) + return false; + } + else + {//renderowanie przez Display List + if (!Ground.RenderDL(Camera.Pos)) return false; + if (!Ground.RenderAlphaDL(Camera.Pos)) + return false; + } + TSubModel::iInstance=(int)(Train?Train->Dynamic():0); //żeby nie robić cudzych animacji + //if (Camera.Type==tp_Follow) + if (Train) Train->Update(); + //if (Global::bRenderAlpha) + // if (Controlled) + // Train->RenderAlpha(); + glFlush(); + //Global::bReCompile=false; //Ra: już zrobiona rekompilacja + ResourceManager::Sweep(Timer::GetSimulationTime()); + return true; +}; + +void TWorld::ShowHints(void) +{//Ra: nie używać tego, bo źle działa + glBindTexture(GL_TEXTURE_2D, 0); + glColor4f(0.3f,1.0f,0.3f,1.0f); + glLoadIdentity(); + glTranslatef(0.0f,0.0f,-0.50f); + //glRasterPos2f(-0.25f, 0.20f); + //OutText1="Uruchamianie lokomotywy - pomoc dla niezaawansowanych"; + //glPrint(OutText1.c_str()); + + //if(TestFlag(Controlled->MoverParameters->SecuritySystem.Status,s_ebrake)) + //hunter-091012 + if(TestFlag(Controlled->MoverParameters->SecuritySystem.Status,s_SHPebrake)||TestFlag(Controlled->MoverParameters->SecuritySystem.Status,s_CAebrake)) + { + OutText1="Gosciu, ale refleks to ty masz szachisty. Teraz zaczekaj."; + OutText2="W tej sytuacji czuwak mozesz zbic dopiero po zatrzymaniu pociagu. "; + if(Controlled->MoverParameters->Vel==0) + OutText3=" (mozesz juz nacisnac spacje)"; + } + else + //if(TestFlag(Controlled->MoverParameters->SecuritySystem.Status,s_alarm)) + if(TestFlag(Controlled->MoverParameters->SecuritySystem.Status,s_CAalarm)||TestFlag(Controlled->MoverParameters->SecuritySystem.Status,s_SHPalarm)) + { + OutText1="Natychmiast zbij czuwak, bo pociag sie zatrzyma!"; + OutText2=" (szybko nacisnij spacje!)"; + } + else + if(TestFlag(Controlled->MoverParameters->SecuritySystem.Status,s_aware)) + { + OutText1="Zbij czuwak, zeby udowodnic, ze nie spisz :) "; + OutText2=" (nacisnij spacje)"; + } + else + if (mvControlled->FuseFlag) + { + OutText1="Czlowieku, delikatniej troche! Gdzie sie spieszysz?"; + OutText2="Wybilo Ci bezpiecznik nadmiarowy, teraz musisz wlaczyc go ponownie."; + OutText3=" ('N', wczesniej nastawnik i boczniki na zero -> '-' oraz '*' do oporu)"; + + } + else + if (mvControlled->V==0) + { + if ((mvControlled->PantFrontVolt==0.0)||(mvControlled->PantRearVolt==0.0)) + { + OutText1="Jezdziles juz kiedys lokomotywa? Pierwszy raz? Dobra, to zaczynamy."; + OutText2="No to co, trzebaby chyba podniesc pantograf?"; + OutText3=" (wcisnij 'shift+P' - przedni, 'shift+O' - tylny)"; + } + else + if (!mvControlled->Mains) + { + OutText1="Dobra, mozemy zalaczyc wylacznik szybki lokomotywy."; + OutText2=" (wcisnij 'shift+M')"; + } + else + if (!mvControlled->ConverterAllow) + { + OutText1="Teraz wlacz przetwornice."; + OutText2=" (wcisnij 'shift+X')"; + } + else + if (!mvControlled->CompressorAllow) + { + OutText1="Teraz wlacz sprezarke."; + OutText2=" (wcisnij 'shift+C')"; + } + else + if (mvControlled->ActiveDir==0) + { + OutText1="Ustaw nastawnik kierunkowy na kierunek, w ktorym chcesz jechac."; + OutText2=" ('d' - do przodu, 'r' - do tylu)"; + } + else + if (Controlled->GetFirstDynamic(1)->MoverParameters->BrakePress>0) + { + OutText1="Odhamuj sklad i zaczekaj az Ci powiem - to moze troche potrwac."; + OutText2=" ('.' na klawiaturze numerycznej)"; + } + else + if (Controlled->MoverParameters->BrakeCtrlPos!=0) + { + OutText1="Przelacz kran hamulca w pozycje 'jazda'."; + OutText2=" ('4' na klawiaturze numerycznej)"; + } + else + if (mvControlled->MainCtrlPos==0) + { + OutText1="Teraz juz mozesz ruszyc ustawiajac pierwsza pozycje na nastawniku jazdy."; + OutText2=" (jeden raz '+' na klawiaturze numerycznej)"; + } + else + if((mvControlled->MainCtrlPos>0)&&(mvControlled->ShowCurrent(1)!=0)) + { + OutText1="Dobrze, mozesz teraz wlaczac kolejne pozycje nastawnika."; + OutText2=" ('+' na klawiaturze numerycznej, tylko z wyczuciem)"; + } + if((mvControlled->MainCtrlPos>1)&&(mvControlled->ShowCurrent(1)==0)) + { + OutText1="Spieszysz sie gdzies? Zejdz nastawnikiem na zero i probuj jeszcze raz!"; + OutText2=" (teraz do oporu '-' na klawiaturze numerycznej)"; + } + } + else + { + OutText1="Aby przyspieszyc mozesz wrzucac kolejne pozycje nastawnika."; + if(mvControlled->MainCtrlPos==28) + {OutText1="Przy tym ustawienu mozesz bocznikowac silniki - sprobuj: '/' i '*' ";} + if(mvControlled->MainCtrlPos==43) + {OutText1="Przy tym ustawienu mozesz bocznikowac silniki - sprobuj: '/' i '*' ";} + + OutText2="Aby zahamowac zejdz nastawnikiem do 0 ('-' do oporu) i ustaw kran hamulca"; + OutText3="w zaleznosci od sily hamowania, jakiej potrzebujesz ('2', '5' lub '8' na kl. num.)"; + + //else + //if() OutText1="teraz mozesz ruszyc naciskajac jeden raz '+' na klawiaturze numerycznej"; + //else + //if() OutText1="teraz mozesz ruszyc naciskajac jeden raz '+' na klawiaturze numerycznej"; + } + //OutText3=FloatToStrF(Controlled->MoverParameters->SecuritySystem.Status,ffFixed,3,0); + + if(OutText1!="") + { + glRasterPos2f(-0.25f, 0.19f); + glPrint(OutText1.c_str()); + OutText1=""; + } + if(OutText2!="") + { + glRasterPos2f(-0.25f, 0.18f); + glPrint(OutText2.c_str()); + OutText2=""; + } + if(OutText3!="") + { + glRasterPos2f(-0.25f, 0.17f); + glPrint(OutText3.c_str()); + OutText3=""; + } +}; + +//--------------------------------------------------------------------------- +void __fastcall TWorld::OnCommandGet(DaneRozkaz *pRozkaz) +{//odebranie komunikatu z serwera + if (pRozkaz->iSygn=='EU07') + switch (pRozkaz->iComm) + { + case 0: //odesłanie identyfikatora wersji + Ground.WyslijString(Global::asVersion,0); //przedsatwienie się + break; + case 1: //odesłanie identyfikatora wersji + Ground.WyslijString(Global::szSceneryFile,1); //nazwa scenerii + break; + case 2: //event + if (Global::iMultiplayer) + {//WriteLog("Komunikat: "+AnsiString(pRozkaz->Name1)); + TEvent *e=Ground.FindEvent(AnsiString(pRozkaz->cString+1,(unsigned)(pRozkaz->cString[0]))); + if (e) + if ((e->Type==tp_Multiple)||(e->Type==tp_Lights)||bool(e->evJoined)) //tylko jawne albo niejawne Multiple + Ground.AddToQuery(e,NULL); //drugi parametr to dynamic wywołujący - tu brak + } + break; + case 3: //rozkaz dla AI + if (Global::iMultiplayer) + {int i=int(pRozkaz->cString[8]); //długość pierwszego łańcucha (z przodu dwa floaty) + TGroundNode* t=Ground.DynamicFind(AnsiString(pRozkaz->cString+11+i,(unsigned)pRozkaz->cString[10+i])); //nazwa pojazdu jest druga + if (t) + if (t->DynamicObject->Mechanik) + { + t->DynamicObject->Mechanik->PutCommand(AnsiString(pRozkaz->cString+9,i),pRozkaz->fPar[0],pRozkaz->fPar[1],NULL,stopExt); //floaty są z przodu + WriteLog("AI command: "+AnsiString(pRozkaz->cString+9,i)); + } + } + break; + case 4: //badanie zajętości toru + { + TGroundNode* t=Ground.FindGroundNode(AnsiString(pRozkaz->cString+1,(unsigned)(pRozkaz->cString[0])),TP_TRACK); + if (t) + if (t->pTrack->IsEmpty()) + Ground.WyslijWolny(t->asName); + } + break; + case 5: //ustawienie parametrów + { + if (*pRozkaz->iPar&1) //ustawienie czasu + {double t=pRozkaz->fPar[1]; + GlobalTime->dd=floor(t); //niby nie powinno być dnia, ale... + if (Global::fMoveLight>=0) + Global::fMoveLight=t; //trzeba by deklinację Słońca przeliczyć + GlobalTime->hh=floor(24*t)-24.0*GlobalTime->dd; + GlobalTime->mm=floor(60*24*t)-60.0*(24.0*GlobalTime->dd+GlobalTime->hh); + GlobalTime->mr=floor(60*60*24*t)-60.0*(60.0*(24.0*GlobalTime->dd+GlobalTime->hh)+GlobalTime->mm); + } + if (*pRozkaz->iPar&2) + {//ustawienie flag zapauzowania + Global::iPause=pRozkaz->fPar[2]; //zakładamy, że wysyłający wie, co robi + } + } + break; + case 6: //pobranie parametrów ruchu pojazdu + if (Global::iMultiplayer) + {//Ra 2014-12: to ma działać również dla pojazdów bez obsady + if (pRozkaz->cString[0]) //jeśli długość nazwy jest niezerowa + {//szukamy pierwszego pojazdu o takiej nazwie i odsyłamy parametry ramką #7 + TGroundNode *t; + if (pRozkaz->cString[1]=='*') + t=Ground.DynamicFind(Global::asHumanCtrlVehicle); //nazwa pojazdu użytkownika + else + t=Ground.DynamicFindAny(AnsiString(pRozkaz->cString+1,(unsigned)pRozkaz->cString[0])); //nazwa pojazdu + if (t) + Ground.WyslijNamiary(t); //wysłanie informacji o pojeździe + } + else + {//dla pustego wysyłamy ramki 6 z nazwami pojazdów AI (jeśli potrzebne wszystkie, to rozpoznać np. "*") + Ground.DynamicList(); + } + } + break; + case 8: //ponowne wysłanie informacji o zajętych odcinkach toru + Ground.TrackBusyList(); + break; + case 9: //ponowne wysłanie informacji o zajętych odcinkach izolowanych + Ground.IsolatedBusyList(); + break; + case 10: //badanie zajętości jednego odcinka izolowanego + Ground.IsolatedBusy(AnsiString(pRozkaz->cString+1,(unsigned)(pRozkaz->cString[0]))); + break; + case 11: //ustawienie paerametrów ruchu pojazdu +// Ground.IsolatedBusy(AnsiString(pRozkaz->cString+1,(unsigned)(pRozkaz->cString[0]))); + break; + + } +}; + +//--------------------------------------------------------------------------- +void __fastcall TWorld::ModifyTGA(const AnsiString &dir) +{//rekurencyjna modyfikacje plików TGA + TSearchRec sr; + if (FindFirst(dir+"*.*",faDirectory|faArchive,sr)==0) + {do + { + if (sr.Name[1]!='.') + if ((sr.Attr&faDirectory)) //jeśli katalog, to rekurencja + ModifyTGA(dir+sr.Name+"/"); + else + if (sr.Name.LowerCase().SubString(sr.Name.Length()-3,4)==".tga") + TTexturesManager::GetTextureID(NULL,NULL,AnsiString(dir+sr.Name).c_str()); + } while (FindNext(sr)==0); + FindClose(sr); + } +}; +//--------------------------------------------------------------------------- +AnsiString last; //zmienne używane w rekurencji +double shift=0; +void __fastcall TWorld::CreateE3D(const AnsiString &dir,bool dyn) +{//rekurencyjna generowanie plików E3D + TTrack *trk; + double at; + TSearchRec sr; + if (FindFirst(dir+"*.*",faDirectory|faArchive,sr)==0) + {do + { + if (sr.Name[1]!='.') + if ((sr.Attr&faDirectory)) //jeśli katalog, to rekurencja + CreateE3D(dir+sr.Name+"\\",dyn); + else + if (dyn) + { + if (sr.Name.LowerCase().SubString(sr.Name.Length()-3,4)==".mmd") + { + //konwersja pojazdów będzie ułomna, bo nie poustawiają się animacje na submodelach określonych w MMD + //TModelsManager::GetModel(AnsiString(dir+sr.Name).c_str(),true); + if (last!=dir) + {//utworzenie toru dla danego pojazdu + last=dir; + trk=TTrack::Create400m(1,shift); + shift+=10.0; //następny tor będzie deczko dalej, aby nie zabić FPS + at=400.0; + //if (shift>1000) break; //bezpiecznik + } + TGroundNode *tmp=new TGroundNode(); + tmp->DynamicObject=new TDynamicObject(); + //Global::asCurrentTexturePath=dir; //pojazdy mają tekstury we własnych katalogach + at-=tmp->DynamicObject->Init("",dir.SubString(9,dir.Length()-9),"none",sr.Name.SubString(1,sr.Name.Length()-4),trk,at,"nobody",0.0,"none",0.0,"",false,""); + //po wczytaniu CHK zrobić pętlę po ładunkach, aby każdy z nich skonwertować + AnsiString loads,load; + loads=tmp->DynamicObject->MoverParameters->LoadAccepted; //typy ładunków + if (!loads.IsEmpty()) + {loads+=","; //przecinek na końcu + int i=loads.Pos(","); + while (i>1) + {//wypadało by sprawdzić, czy T3D ładunku jest + load=loads.SubString(1,i-1); + if (FileExists(dir+load+".t3d")) //o ile jest plik ładunku, bo inaczej nie ma to sensu + if (!FileExists(dir+load+".e3d")) //a nie ma jeszcze odpowiednika binarnego + at-=tmp->DynamicObject->Init("",dir.SubString(9,dir.Length()-9),"none",sr.Name.SubString(1,sr.Name.Length()-4),trk,at,"nobody",0.0,"none",1.0,load,false,""); + loads.Delete(1,i); //usunięcie z następującym przecinkiem + i=loads.Pos(","); + } + } + if (tmp->DynamicObject->iCabs) + {//jeśli ma jakąkolwiek kabinę + delete Train; + Train=new TTrain(); + if (tmp->DynamicObject->iCabs&1) + {tmp->DynamicObject->MoverParameters->ActiveCab=1; + Train->Init(tmp->DynamicObject,true); + } + if (tmp->DynamicObject->iCabs&4) + {tmp->DynamicObject->MoverParameters->ActiveCab=-1; + Train->Init(tmp->DynamicObject,true); + } + if (tmp->DynamicObject->iCabs&2) + {tmp->DynamicObject->MoverParameters->ActiveCab=0; + Train->Init(tmp->DynamicObject,true); + } + } + Global::asCurrentTexturePath=AnsiString(szTexturePath); //z powrotem defaultowa sciezka do tekstur + } + } + else if (sr.Name.LowerCase().SubString(sr.Name.Length()-3,4)==".t3d") + {//z modelami jest prościej + Global::asCurrentTexturePath=dir; + TModelsManager::GetModel(AnsiString(dir+sr.Name).c_str(),false); + } + } while (FindNext(sr)==0); + FindClose(sr); + } +}; +//--------------------------------------------------------------------------- +void __fastcall TWorld::CabChange(TDynamicObject *old,TDynamicObject *now) +{//ewentualna zmiana kabiny użytkownikowi + if (Train) + if (Train->Dynamic()==old) + Global::changeDynObj=now; //uruchomienie protezy +}; +//--------------------------------------------------------------------------- + diff --git a/World.h b/World.h new file mode 100644 index 00000000..6e977700 --- /dev/null +++ b/World.h @@ -0,0 +1,64 @@ +//--------------------------------------------------------------------------- + +#ifndef WorldH +#define WorldH + + +#include "Usefull.h" +#include "Classes.h" +#include "Texture.h" +#include "Camera.h" +#include "Ground.h" +#include "MdlMngr.h" +#include "Globals.h" +#include "sky.h" +//#include + +class TWorld +{ + void __fastcall InOutKey(); + void __fastcall FollowView(bool wycisz=true); + void __fastcall DistantView(); +public: + bool __fastcall Init(HWND NhWnd, HDC hDC); + HWND hWnd; + GLvoid __fastcall glPrint(const char *fmt); + void __fastcall OnKeyDown(int cKey); + void __fastcall OnKeyUp(int cKey); + //void __fastcall UpdateWindow(); + void __fastcall OnMouseMove(double x, double y); + void __fastcall OnCommandGet(DaneRozkaz *pRozkaz); + bool __fastcall Update(); + void __fastcall TrainDelete(TDynamicObject *d=NULL); + __fastcall TWorld(); + __fastcall ~TWorld(); + //double Aspect; +private: + AnsiString OutText1; //teksty na ekranie + AnsiString OutText2; + AnsiString OutText3; + AnsiString OutText4; + void ShowHints(); + bool __fastcall Render(); + TCamera Camera; + TGround Ground; + TTrain *Train; + TDynamicObject *pDynamicNearest; + bool Paused; + GLuint base; //numer DL dla znaków w napisach + GLuint light; //numer tekstury dla smugi + TSky Clouds; + TEvent *KeyEvents[10]; //eventy wyzwalane z klawiaury + TMoverParameters *mvControlled; //wskaźnik na człon silnikowy, do wyświetlania jego parametrów + int iCheckFPS; //kiedy znów sprawdzić FPS, żeby wyłączać optymalizacji od razu do zera + double fTime50Hz; //bufor czasu dla komunikacji z PoKeys + double fTimeBuffer; //bufor czasu aktualizacji dla stałego kroku fizyki + double fMaxDt; //[s] krok czasowy fizyki (0.01 dla normalnych warunków) + int iPause; //wykrywanie zmian w zapauzowaniu +public: + void __fastcall ModifyTGA(const AnsiString &dir=""); + void __fastcall CreateE3D(const AnsiString &dir="",bool dyn=false); + void __fastcall CabChange(TDynamicObject *old,TDynamicObject *now); +}; +//--------------------------------------------------------------------------- +#endif diff --git a/dumb3d.cpp b/dumb3d.cpp new file mode 100644 index 00000000..f5195b04 --- /dev/null +++ b/dumb3d.cpp @@ -0,0 +1,362 @@ +#include "dumb3d.h" +#include "fastmath.h" +#include + +namespace Math3D { + +void __fastcall vector3::RotateX(double angle) +{ + double ty= y; + y= (cos(angle)*y-z*sin(angle)); + z= (z*cos(angle)+sin(angle)*ty); +}; +void __fastcall vector3::RotateY(double angle) +{ + double tx= x; + x= (cos(angle)*x+z*sin(angle)); + z= (z*cos(angle)-sin(angle)*tx); +}; +void __fastcall vector3::RotateZ(double angle) +{ + double ty= y; + y= (cos(angle)*y+x*sin(angle)); + x= (x*cos(angle)-sin(angle)*ty); +}; + +void inline __fastcall vector3::SafeNormalize() +{ + double l= Length(); + if (l==0) + { + x=y=z=0; + } + else + { + x/= l; + y/= l; + z/= l; + } +} + +// From code in Graphics Gems; p. 766 +inline scalar_t det2x2 (scalar_t a, scalar_t b, scalar_t c, scalar_t d) { + return a*d - b*c; +} + +inline scalar_t det3x3 ( scalar_t a1, scalar_t a2, scalar_t a3, + scalar_t b1, scalar_t b2, scalar_t b3, + scalar_t c1, scalar_t c2, scalar_t c3) { + return a1 * det2x2(b2, b3, c2, c3) + - b1 * det2x2(a2, a3, c2, c3) + + c1 * det2x2(a2, a3, b2, b3); +} + +scalar_t Determinant (const matrix4x4& m) { + scalar_t a1 = m[0][0]; scalar_t a2 = m[1][0]; scalar_t a3 = m[2][0]; scalar_t a4 = m[3][0]; + scalar_t b1 = m[0][1]; scalar_t b2 = m[1][1]; scalar_t b3 = m[2][1]; scalar_t b4 = m[3][1]; + scalar_t c1 = m[0][2]; scalar_t c2 = m[1][2]; scalar_t c3 = m[2][2]; scalar_t c4 = m[3][2]; + scalar_t d1 = m[0][3]; scalar_t d2 = m[1][3]; scalar_t d3 = m[2][3]; scalar_t d4 = m[3][3]; + + return a1 * det3x3(b2, b3, b4, c2, c3, c4, d2, d3, d4) + - b1 * det3x3(a2, a3, a4, c2, c3, c4, d2, d3, d4) + + c1 * det3x3(a2, a3, a4, b2, b3, b4, d2, d3, d4) + - d1 * det3x3(a2, a3, a4, b2, b3, b4, c2, c3, c4); +} + +matrix4x4 Adjoint (const matrix4x4& m) { + scalar_t a1 = m[0][0]; scalar_t a2 = m[0][1]; scalar_t a3 = m[0][2]; scalar_t a4 = m[0][3]; + scalar_t b1 = m[1][0]; scalar_t b2 = m[1][1]; scalar_t b3 = m[1][2]; scalar_t b4 = m[1][3]; + scalar_t c1 = m[2][0]; scalar_t c2 = m[2][1]; scalar_t c3 = m[2][2]; scalar_t c4 = m[2][3]; + scalar_t d1 = m[3][0]; scalar_t d2 = m[3][1]; scalar_t d3 = m[3][2]; scalar_t d4 = m[3][3]; + + // Adjoint(x,y) = -1^(x+y) * a(y,x) + // Where a(i,j) is the 3x3 determinant of m with row i and col j removed + matrix4x4 retVal; + retVal(0)[0] = det3x3(b2, b3, b4, c2, c3, c4, d2, d3, d4); + retVal(0)[1] = -det3x3(a2, a3, a4, c2, c3, c4, d2, d3, d4); + retVal(0)[2] = det3x3(a2, a3, a4, b2, b3, b4, d2, d3, d4); + retVal(0)[3] = -det3x3(a2, a3, a4, b2, b3, b4, c2, c3, c4); + + retVal(1)[0] = -det3x3(b1, b3, b4, c1, c3, c4, d1, d3, d4); + retVal(1)[1] = det3x3(a1, a3, a4, c1, c3, c4, d1, d3, d4); + retVal(1)[2] = -det3x3(a1, a3, a4, b1, b3, b4, d1, d3, d4); + retVal(1)[3] = det3x3(a1, a3, a4, b1, b3, b4, c1, c3, c4); + + retVal(2)[0] = det3x3(b1, b2, b4, c1, c2, c4, d1, d2, d4); + retVal(2)[1] = -det3x3(a1, a2, a4, c1, c2, c4, d1, d2, d4); + retVal(2)[2] = det3x3(a1, a2, a4, b1, b2, b4, d1, d2, d4); + retVal(2)[3] = -det3x3(a1, a2, a4, b1, b2, b4, c1, c2, c4); + + retVal(3)[0] = -det3x3(b1, b2, b3, c1, c2, c3, d1, d2, d3); + retVal(3)[1] = det3x3(a1, a2, a3, c1, c2, c3, d1, d2, d3); + retVal(3)[2] = -det3x3(a1, a2, a3, b1, b2, b3, d1, d2, d3); + retVal(3)[3] = det3x3(a1, a2, a3, b1, b2, b3, c1, c2, c3); + + return retVal; +} + +matrix4x4 Inverse (const matrix4x4& m) { + matrix4x4 retVal = Adjoint(m); + scalar_t det = Determinant(m); + assert(det); + + for (int i=0;i<4;++i) { + for (int j=0;j<4;++j) { + retVal(i)[j] /= det; + } + } + + return retVal; +} +} + + + +//************************************** +// Testing from here on. +//************************************** +#ifdef TEST_MATH3D +#include + +using namespace Math3D; +using namespace std; + +static int failures = 0; + +void ReportFailure (const char* className, const char* testName, bool passed) { + cout << className; + if (passed) + cout << " passed test "; + else { + cout << " FAILED test "; + ++failures; + } + cout << testName << "." << endl; +} + +const char* vector3Name = "vector3"; +const char* matrix4x4Name = "matrix4x4"; + +void Testvector3Constructors(void) { + // Default ctor... just make sure it compiles + vector3 defaultCtorTest; + + // Initializer ctor test (3 param) + vector3 initCtorTest(1, 2, 3); + ReportFailure (vector3Name, "initialized ctor (3 parameter version)", (initCtorTest[0] == 1 && initCtorTest[1] == 2 && initCtorTest[2] == 3 && initCtorTest[3] == 1)); + + // Initializer ctor test (4 param) + vector3 initCtorTest2 (1,2,3,4); + ReportFailure (vector3Name, "initialized ctor (4 parameter version)", (initCtorTest2[0] == 1 && initCtorTest2[1] == 2 && initCtorTest2[2] == 3 && initCtorTest2[3] == 4)); + + scalar_t initArray[] = { 1, 2, 3, 4}; + vector3 initCtorArrayTest3 (initArray); + ReportFailure (vector3Name, "array initialized ctor (3 parameter version)", (initCtorArrayTest3[0] == 1 && initCtorArrayTest3[1] == 2 && initCtorArrayTest3[2] == 3 && initCtorArrayTest3[3] == 1)); + + vector3 initCtorArrayTest4 (initArray, 4); + ReportFailure (vector3Name, "array initialized ctor (4 parameter version)", (initCtorArrayTest4[0] == 1 && initCtorArrayTest4[1] == 2 && initCtorArrayTest4[2] == 3 && initCtorArrayTest4[3] == 4)); + + // Copy ctor test + vector3 copyCtorTest(initCtorTest2); + ReportFailure (vector3Name, "copy ctor", (copyCtorTest[0] == 1 && copyCtorTest[1] == 2 && copyCtorTest[2] == 3 && copyCtorTest[3] == 4)); +} + +void Testvector3Comparison(void) { + vector3 alpha(1,1,1); + vector3 beta(alpha); + vector3 gamma(2,3,4); + + ReportFailure (vector3Name, "equivalence operator test 1", (alpha==beta)); + ReportFailure (vector3Name, "equivalence operator test 2", (!(alpha == gamma))); + ReportFailure (vector3Name, "comparison operator test 1", !(alpha < beta)); + ReportFailure (vector3Name, "comparison operator test 2", (alpha < gamma)); + ReportFailure (vector3Name, "comparison operator test 3", !(gamma < beta)); +} + +void Testvector3Assignment (void) { + vector3 alpha(1,1,1,1); + vector3 beta(10,10,10,10); + alpha = beta; + ReportFailure (vector3Name, "assignment operator", (alpha == beta)); +} + +void Testvector3UnaryOps (void) { + vector3 alpha(10,10,10,10); + vector3 beta(-10,-10,-10,-10); + alpha = -alpha; + ReportFailure(vector3Name, "negation operator", (alpha==beta)); + + ReportFailure(vector3Name, "length squared 3 element version", LengthSquared3(alpha) == 300); + ReportFailure(vector3Name, "length 3 element version", Length3(alpha) == SQRT_FUNCTION(300)); + ReportFailure(vector3Name, "length squared 4 element version", LengthSquared4(alpha) == 400); + ReportFailure(vector3Name, "length 4 element version", Length4(alpha) == SQRT_FUNCTION(400)); + + // Manually normalize beta + // Done without /= on vector3, as we want to be independant of failure of /= + // Earlier failures should be resolved before later ones (just like C++) + beta = alpha; + for (int i=0;i<3;++i) beta(i) /= SQRT_FUNCTION(300); + beta(3) = 1; + ReportFailure(vector3Name, "normalize 3 element version", Normalize3(alpha) == beta); + + beta = alpha; + for (int i=0;i<4;++i) beta(i) /= SQRT_FUNCTION(400); + ReportFailure(vector3Name, "normalize 4 element version", Normalize4(alpha) == beta); +} + +void Testvector3BinaryOps (void) { + // Vector * Matrix is tested in Testmatrix4x4BinaryOps + vector3 testVec(1,1,1,1); + vector3 deltaVec(1,2,3,4); + vector3 crossVec(1, -2, 1, 1); // testVec x deltaVec + + vector3 factorVec(10,10,10,10); + vector3 sumVec(2,3,4,5); + vector3 difVec(0,-1,-2,-3); + vector3 testVec2; + + ReportFailure(vector3Name, "scalar multiply 1", (testVec * 10) == factorVec); + ReportFailure(vector3Name, "scalar multiply 2", (10 * testVec) == factorVec); + testVec2 = testVec; + ReportFailure(vector3Name, "scalar multiply and store", (testVec2 *= 10) == factorVec); + + ReportFailure(vector3Name, "scalar divide", (factorVec / 10) == testVec); + testVec2 = factorVec; + ReportFailure(vector3Name, "scalar divide and store", (testVec2 /= 10) == testVec); + + ReportFailure(vector3Name, "vector addition", (testVec + deltaVec) == sumVec); + testVec2 = testVec; + ReportFailure(vector3Name, "vector addition and store", (testVec2 += deltaVec) == sumVec); + + ReportFailure(vector3Name, "vector subtraction", (testVec - deltaVec) == difVec); + testVec2 = testVec; + ReportFailure(vector3Name, "vector subtraction and store", (testVec2 -= deltaVec) == difVec); + + ReportFailure(vector3Name, "3 element dot product", 6 == DotProduct3(testVec, deltaVec)); + ReportFailure(vector3Name, "4 element dot product", 10 == DotProduct4(testVec, deltaVec)); + + ReportFailure(vector3Name, "cross product", crossVec == CrossProduct(testVec, deltaVec)); +} + +void Testvector3 (void) { + // Accessors cannot be tested effectively... + // They are really trivial, and so don't really need testing, + // but more importantly, how do you test the ctors without assuming + // the accessors work? Conversely, how do you test the acccessors + // without assuming the ctors work? Chicken and egg problem, and I + // decided on testing the ctors, not the accessors. + Testvector3Constructors(); + Testvector3Comparison(); + Testvector3Assignment(); + Testvector3UnaryOps(); + Testvector3BinaryOps(); +} + +void Testmatrix4x4Constructors (void) { + // Check if default ctor compiles + matrix4x4 defaultTest; + + scalar_t initArray[] = { 0, 1, 2, 3, + 4, 5, 6, 7, + 8, 9, 10, 11, + 12, 13, 14, 15 }; + matrix4x4 arrayTest; + arrayTest.C_Matrix(initArray); + bool passedTest = true; + for (int x=0;x<4;++x) for (int y=0;y<4;++y) + if (arrayTest[x][y] != initArray[(y<<2) + x]) passedTest = false; + ReportFailure(matrix4x4Name, "array constructor", passedTest); + + matrix4x4 copyTest(arrayTest); + passedTest = true; + for (int x=0;x<4;++x) for (int y=0;y<4;++y) + if (arrayTest[x][y] != copyTest[x][y]) passedTest = false; + ReportFailure(matrix4x4Name, "copy constructor", passedTest); +} + +void Testmatrix4x4Comparison (void) { + scalar_t initArray[] = { 0, 1, 2, 3, + 4, 5, 6, 7, + 8, 9, 10, 11, + 12, 13, 14, 15 }; + scalar_t initArray2[] = { 1, 1, 1, 1, + 1, 1, 1, 1, + 1, 1, 1, 1, + 1, 1, 1, 1 }; + matrix4x4 alpha, beta, gamma; + alpha.C_Matrix(initArray); + beta.C_Matrix(initArray); + gamma.C_Matrix(initArray2); + + ReportFailure(matrix4x4Name, "equality test 1", alpha == beta); + ReportFailure(matrix4x4Name, "equality test 2", !(alpha == gamma)); + ReportFailure(matrix4x4Name, "comparison test 1", alpha < gamma); + ReportFailure(matrix4x4Name, "comparison test 2", !(gamma < alpha)); + ReportFailure(matrix4x4Name, "comparison test 3", !(alpha < beta)); +} + +void Testmatrix4x4BinaryOps (void) { + scalar_t initVector[] = { 0, 1, 2, 3 }; + scalar_t initMatrix[] = { 0, 1, 2, 3, + 4, 5, 6, 7, + 8, 9, 10, 11, + 12, 13, 14, 15 }; + scalar_t resultVector[] = { 0 * 0 + 1 * 1 + 2 * 2 + 3 * 3, + 0 * 4 + 1 * 5 + 2 * 6 + 3 * 7, + 0 * 8 + 1 * 9 + 2 * 10 + 3 * 11, + 0 * 12 + 1 * 13 + 2 * 14 + 3 * 15 }; + + vector3 vector1 (initVector, 4); + matrix4x4 matrix1; + matrix1.C_Matrix(initMatrix); + vector3 vectorTest (resultVector, 4); + ReportFailure (matrix4x4Name, "matrix * vector", vectorTest == matrix1 * vector1); + + scalar_t initMatrix2[] = { 15, 14, 13, 12, + 11, 10, 9, 8, + 7, 6, 5, 4, + 3, 2, 1, 0 }; + + matrix4x4 matrix2; + matrix2.C_Matrix(initMatrix2); + matrix4x4 resultMatrix; + for (int x=0;x<4;++x) for (int y=0;y<4;++y) { + resultMatrix(x)[y] = 0; + for (int i=0;i<4;++i) resultMatrix(x)[y] += matrix1[i][y] * matrix2[x][i]; + } + ReportFailure (matrix4x4Name, "matrix * matrix", resultMatrix == matrix1 * matrix2); +} + +void Testmatrix4x4 (void) { + Testmatrix4x4Constructors(); + Testmatrix4x4Comparison(); + Testmatrix4x4BinaryOps(); +} + +int main (int, char*[]) { + int vectorFailures = 0; + int matrixFailures = 0; + Testvector3(); + vectorFailures = failures; + failures = 0; + + Testmatrix4x4(); + matrixFailures = failures; + + cout << endl << "****************************************" << endl; + cout << "* *" << endl; + if (vectorFailures + matrixFailures == 0) + cout << "* No failures detected in Math3D *" << endl; + else { + cout << "* FAILURES DETECTED IN MATH3D! *" << endl; + cout << "* Total vector3 failures: " << vectorFailures << " *" << endl; + cout << "* Total matrix4x4 failures: " << matrixFailures << " *" << endl; + cout << "* Total Failures in Math3D: " << vectorFailures + matrixFailures << " *" << endl; + + } + cout << "* *" << endl; + cout << "****************************************" << endl; + + return 0; +} +#endif \ No newline at end of file diff --git a/dumb3d.h b/dumb3d.h new file mode 100644 index 00000000..fa9b73c1 --- /dev/null +++ b/dumb3d.h @@ -0,0 +1,475 @@ +#ifndef MATH3D_H +#define MATH3D_H + +//#include +#include + +namespace Math3D { + +// Define this to have Math3D.cp generate a main which tests these classes +//#define TEST_MATH3D + +// Define this to allow streaming output of vectors and matrices +// Automatically enabled by TEST_MATH3D +//#define OSTREAM_MATH3D + +// definition of the scalar type +typedef double scalar_t; +// inline pass-throughs to various basic math functions +// written in this style to allow for easy substitution with more efficient versions +inline scalar_t SINE_FUNCTION (scalar_t x) { return sin(x); } +inline scalar_t COSINE_FUNCTION (scalar_t x) { return cos(x); } +inline scalar_t SQRT_FUNCTION (scalar_t x) { return sqrt(x); } + +// 2 element vector +class vector2 { +public: + vector2 (void) {} + __fastcall vector2 (scalar_t a, scalar_t b) + { x=a; y=b; } + double x; + union + { + double y; + double z; + }; +}; +// 3 element vector +class vector3 { +public: + vector3 (void) {} + __fastcall vector3 (scalar_t a, scalar_t b, scalar_t c) + { x=a; y=b; z=c; } + + // The int parameter is the number of elements to copy from initArray (3 or 4) +// explicit vector3(scalar_t* initArray, int arraySize = 3) +// { for (int i = 0;ix)>0.02) return false; //sześcian zamiast kuli + if (fabs(z-v->z)>0.02) return false; + if (fabs(y-v->y)>0.02) return false; + return true; + }; + +private: +}; + +// 4 element matrix +class matrix4x4 { +public: + matrix4x4 (void) {} + + // When defining matrices in C arrays, it is easiest to define them with + // the column increasing fastest. However, some APIs (OpenGL in particular) do this + // backwards, hence the "constructor" from C matrices, or from OpenGL matrices. + // Note that matrices are stored internally in OpenGL format. + void C_Matrix (scalar_t* initArray) + { int i = 0; for (int y=0;y<4;++y) for (int x=0;x<4;++x) (*this)(x)[y] = initArray[i++]; } + void OpenGL_Matrix (scalar_t* initArray) + { int i = 0; for (int x = 0; x < 4; ++x) for (int y=0;y<4;++y) (*this)(x)[y] = initArray[i++]; } + + // [] is to read, () is to write (const correctness) + // m[x][y] or m(x)[y] is the correct form + const scalar_t* operator[] (int i) const { return &e[i<<2]; } + scalar_t* operator() (int i) { return &e[i<<2]; } + + // Low-level access to the array. + const scalar_t* readArray (void) { return e; } + scalar_t* getArray(void) { return e; } + + // Construct various matrices; REPLACES CURRENT CONTENTS OF THE MATRIX! + // Written this way to work in-place and hence be somewhat more efficient + void Identity (void) { for (int i=0;i<16;++i) e[i] = 0; e[0] = 1; e[5] = 1; e[10] = 1; e[15] = 1; } + inline matrix4x4& Rotation (scalar_t angle, vector3 axis); + inline matrix4x4& Translation(const vector3& translation); + inline matrix4x4& Scale (scalar_t x, scalar_t y, scalar_t z); + inline matrix4x4& BasisChange (const vector3& v, const vector3& n); + inline matrix4x4& BasisChange (const vector3& u, const vector3& v, const vector3& n); + inline matrix4x4& ProjectionMatrix (bool perspective, scalar_t l, scalar_t r, scalar_t t, scalar_t b, scalar_t n, scalar_t f); + void InitialRotate() + {//taka specjalna rotacja, nie ma co ciągać trygonometrii + double f; + for (int i=0;i<16;i+=4) + {e[i]=-e[i]; //zmiana znaku X + f=e[i+1]; e[i+1]=e[i+2]; e[i+2]=f; //zamiana Y i Z + } + }; + inline bool IdentityIs() + {//sprawdzenie jednostkowości + for (int i=0;i<16;++i) + if (e[i]!=((i%5)?0.0:1.0)) //jedynki tylko na 0, 5, 10 i 15 + return false; + return true; + } + +private: + scalar_t e[16]; +}; + +// Scalar operations + +// Returns false if there are 0 solutions +inline bool SolveQuadratic (scalar_t a, scalar_t b, scalar_t c, scalar_t* x1, scalar_t* x2); + +// Vector operations +inline bool operator== (const vector3&, const vector3&); +inline bool operator< (const vector3&, const vector3&); + +inline vector3 operator- (const vector3&); +inline vector3 operator* (const vector3&, scalar_t); +inline vector3 operator* (scalar_t, const vector3&); +inline vector3& operator*= (vector3&, scalar_t); +inline vector3 operator/ (const vector3&, scalar_t); +inline vector3& operator/= (vector3&, scalar_t); + +inline vector3 operator+ (const vector3&, const vector3&); +inline vector3& operator+= (vector3&, const vector3&); +inline vector3 operator- (const vector3&, const vector3&); +inline vector3& operator-= (vector3&, const vector3&); + +// X3 is the 3 element version of a function, X4 is four element +inline scalar_t LengthSquared3 (const vector3&); +inline scalar_t LengthSquared4 (const vector3&); +inline scalar_t Length3 (const vector3&); +inline scalar_t Length4 (const vector3&); +inline vector3 Normalize (const vector3&); +inline vector3 Normalize4 (const vector3&); +inline scalar_t DotProduct (const vector3&, const vector3&); +inline scalar_t DotProduct4 (const vector3&, const vector3&); +// Cross product is only defined for 3 elements +inline vector3 CrossProduct (const vector3&, const vector3&); + +inline vector3 operator* (const matrix4x4&, const vector3&); + +// Matrix operations +inline bool operator== (const matrix4x4&, const matrix4x4&); +inline bool operator< (const matrix4x4&, const matrix4x4&); + +inline matrix4x4 operator* (const matrix4x4&, const matrix4x4&); + +inline matrix4x4 Transpose (const matrix4x4&); +scalar_t Determinant (const matrix4x4&); +matrix4x4 Adjoint (const matrix4x4&); +matrix4x4 Inverse (const matrix4x4&); + +// Inline implementations follow +inline bool SolveQuadratic (scalar_t a, scalar_t b, scalar_t c, scalar_t* x1, scalar_t* x2) { + // If a == 0, solve a linear equation + if (a == 0) { + if (b == 0) return false; + *x1 = c / b; + *x2 = *x1; + return true; + } else { + scalar_t det = b * b - 4 * a * c; + if (det < 0) return false; + det = SQRT_FUNCTION(det) / (2 * a); + scalar_t prefix = -b / (2*a); + *x1 = prefix + det; + *x2 = prefix - det; + return true; + } +} + +inline bool operator== (const vector3& v1, const vector3& v2) +{ return (v1.x==v2.x&&v1.y==v2.y&&v1.z==v2.z); } + +inline bool operator< (const vector3& v1, const vector3& v2) { +// for (int i=0;i<4;++i) + // if (v1[i] < v2[i]) return true; + // else if (v1[i] > v2[i]) return false; + + return false; +} + +inline vector3 operator- (const vector3& v) +{ return vector3(-v.x, -v.y, -v.z); } + +inline vector3 operator* (const vector3& v, scalar_t k) +{ return vector3(k*v.x, k*v.y, k*v.z); } + +inline vector3 operator* (scalar_t k, const vector3& v) +{ return v * k; } + +inline vector3& operator*= (vector3& v, scalar_t k) +{ v.x*= k; v.y*= k; v.z*= k; return v; }; + +inline vector3 operator/ (const vector3& v, scalar_t k) +{ return vector3(v.x/k, v.y/k, v.z/k); } + +inline vector3& operator/= (vector3& v, scalar_t k) +{ v.x/= k; v.y/= k; v.z/= k; return v; } + +inline scalar_t LengthSquared3 (const vector3& v) +{ return DotProduct(v,v); } +inline scalar_t LengthSquared4 (const vector3& v) +{ return DotProduct4(v,v); } + +inline scalar_t Length3 (const vector3& v) +{ return SQRT_FUNCTION(LengthSquared3(v)); } +inline scalar_t Length4 (const vector3& v) +{ return SQRT_FUNCTION(LengthSquared4(v)); } + +inline vector3 Normalize (const vector3& v) +{ vector3 retVal = v / Length3(v); return retVal; } +inline vector3 SafeNormalize(const vector3& v) +{ + double l= Length3(v); + vector3 retVal; + if (l==0) + retVal.x=retVal.y=retVal.z=0; + else + retVal=v/l; + return retVal; +} +inline vector3 Normalize4 (const vector3& v) +{ return v / Length4(v); } + +inline vector3 operator+ (const vector3& v1, const vector3& v2) +{ return vector3(v1.x+v2.x, v1.y+v2.y, v1.z+v2.z); } + +inline vector3& operator+= (vector3& v1, const vector3& v2) +{ v1.x+= v2.x; v1.y+= v2.y; v1.z+= v2.z; return v1;} + +inline vector3 operator- (const vector3& v1, const vector3& v2) +{ return vector3(v1.x-v2.x, v1.y-v2.y, v1.z-v2.z); } + +inline vector3& operator-= (vector3& v1, const vector3& v2) +{ v1.x-= v2.x; v1.y-= v2.y; v1.z-= v2.z; return v1;} + +inline scalar_t DotProduct (const vector3& v1, const vector3& v2) +{ return v1.x*v2.x + v1.y*v2.y + v1.z*v2.z; } + +inline scalar_t DotProduct4 (const vector3& v1, const vector3& v2) +{ return v1.x*v2.x + v1.y*v2.y + v1.z*v2.z; } + +inline vector3 CrossProduct (const vector3& v1, const vector3& v2) { +return vector3( v1.y * v2.z - v1.z * v2.y + ,v2.x * v1.z - v2.z * v1.x + ,v1.x * v2.y - v1.y * v2.x); +} + +inline vector3 operator* (const matrix4x4& m, const vector3& v) { + return vector3( v.x*m[0][0] + v.y*m[1][0] + v.z*m[2][0] + m[3][0], + v.x*m[0][1] + v.y*m[1][1] + v.z*m[2][1] + m[3][1], + v.x*m[0][2] + v.y*m[1][2] + v.z*m[2][2] + m[3][2]); + +} + +void inline __fastcall vector3::Normalize() +{ + double il= 1/Length(); + x*= il; + y*= il; + z*= il; +} + +double inline __fastcall vector3::Length() +{ + return SQRT_FUNCTION(x*x+y*y+z*z); +} + +inline bool operator== (const matrix4x4& m1, const matrix4x4& m2) { + for (int x=0;x<4;++x) for (int y=0;y<4;++y) + if (m1[x][y] != m2[x][y]) return false; + return true; +} + +inline bool operator< (const matrix4x4& m1, const matrix4x4& m2) { + for (int x=0;x<4;++x) for (int y=0;y<4;++y) + if (m1[x][y] < m2[x][y]) return true; + else if (m1[x][y] > m2[x][y]) return false; + return false; +} + +inline matrix4x4 operator* (const matrix4x4& m1, const matrix4x4& m2) { + matrix4x4 retVal; + for (int x=0;x<4;++x) for (int y=0;y<4;++y) { + retVal(x)[y] = 0; + for (int i=0;i<4;++i) retVal(x)[y] += m1[i][y] * m2[x][i]; + } + return retVal; +} + +inline matrix4x4 Transpose (const matrix4x4& m) { + matrix4x4 retVal; + for (int x=0;x<4;++x) for (int y=0;y<4;++y) + retVal(x)[y] = m[y][x]; + return retVal; +} + +inline matrix4x4& matrix4x4::Rotation (scalar_t angle, vector3 axis) { + scalar_t c = COSINE_FUNCTION(angle); + scalar_t s = SINE_FUNCTION(angle); + // One minus c (short name for legibility of formulai) + scalar_t omc = (1 - c); + + if (LengthSquared3(axis) != 1) axis = Normalize(axis); + + scalar_t x = axis.x; + scalar_t y = axis.y; + scalar_t z = axis.z; + scalar_t xs = x * s; + scalar_t ys = y * s; + scalar_t zs = z * s; + scalar_t xyomc = x * y * omc; + scalar_t xzomc = x * z * omc; + scalar_t yzomc = y * z * omc; + + e[0] = x*x*omc + c; + e[1] = xyomc + zs; + e[2] = xzomc - ys; + e[3] = 0; + + e[4] = xyomc - zs; + e[5] = y*y*omc + c; + e[6] = yzomc + xs; + e[7] = 0; + + e[8] = xzomc + ys; + e[9] = yzomc - xs; + e[10] = z*z*omc + c; + e[11] = 0; + + e[12] = 0; + e[13] = 0; + e[14] = 0; + e[15] = 1; + + return *this; +} + +inline matrix4x4& matrix4x4::Translation(const vector3& translation) { + Identity(); + e[12] = translation.x; + e[13] = translation.y; + e[14] = translation.z; + return *this; +} + +inline matrix4x4& matrix4x4::Scale (scalar_t x, scalar_t y, scalar_t z) { + Identity(); + e[0] = x; + e[5] = y; + e[10] = z; + return *this; +} + +inline matrix4x4& matrix4x4::BasisChange (const vector3& u, const vector3& v, const vector3& n) { + e[0] = u.x; + e[1] = v.x; + e[2] = n.x; + e[3] = 0; + + e[4] = u.y; + e[5] = v.y; + e[6] = n.y; + e[7] = 0; + + e[8] = u.z; + e[9] = v.z; + e[10] = n.z; + e[11] = 0; + + e[12] = 0; + e[13] = 0; + e[14] = 0; + e[15] = 1; + + return *this; +} + +inline matrix4x4& matrix4x4::BasisChange (const vector3& v, const vector3& n) { + vector3 u = CrossProduct(v,n); + return BasisChange (u, v, n); +} + +inline matrix4x4& matrix4x4::ProjectionMatrix (bool perspective, scalar_t left_plane, scalar_t right_plane, + scalar_t top_plane, scalar_t bottom_plane, + scalar_t near_plane, scalar_t far_plane) +{ + scalar_t A = (right_plane + left_plane) / (right_plane - left_plane); + scalar_t B = (top_plane + bottom_plane) / (top_plane - bottom_plane); + scalar_t C = (far_plane + near_plane) / (far_plane - near_plane); + + Identity(); + if (perspective) { + e[0] = 2 * near_plane / (right_plane - left_plane); + e[5] = 2 * near_plane / (top_plane - bottom_plane); + e[8] = A; + e[9] = B; + e[10] = C; + e[11] = -1; + e[14] = 2 * far_plane * near_plane / (far_plane - near_plane); + } else { + e[0] = 2 / (right_plane - left_plane); + e[5] = 2 / (top_plane - bottom_plane); + e[10] = -2 / (far_plane - near_plane); + e[12] = A; + e[13] = B; + e[14] = C; + } + return *this; +} + +double inline __fastcall SquareMagnitude(const vector3& v) +{ + return v.x*v.x+v.y*v.y+v.z*v.z; +} + +} // close namespace + +// If we're testing, then we need OSTREAM support +#ifdef TEST_MATH3D +#define OSTREAM_MATH3D +#endif + +#ifdef OSTREAM_MATH3D +#include +// Streaming support +std::ostream& operator<< (std::ostream& os, const Math3D::vector3& v) { + os << '['; + for (int i=0; i<4; ++i) + os << ' ' << v[i]; + return os << ']'; +} + +std::ostream& operator<< (std::ostream& os, const Math3D::matrix4x4& m) { + for (int y=0; y<4; ++y) { + os << '['; + for (int x=0;x<4;++x) + os << ' ' << m[x][y]; + os << " ]" << std::endl; + } + return os; +} +#endif // OSTREAM_MATH3D + +#endif diff --git a/eu07.ico b/eu07.ico new file mode 100644 index 00000000..29b0bba1 Binary files /dev/null and b/eu07.ico differ diff --git a/geometry.cpp b/geometry.cpp new file mode 100644 index 00000000..2a4b517d --- /dev/null +++ b/geometry.cpp @@ -0,0 +1,116 @@ +//--------------------------------------------------------------------------- +#include +#pragma hdrstop + +#include "Geometry.h" + +inline double __fastcall sqr(double a) { return ( a*a ); }; + +__fastcall TLine::TLine() +{ +}; + +__fastcall TLine::TLine(vector3 NPoint, vector3 NVector) +{ + Vector= NVector; Point= NPoint; +}; + +__fastcall TLine::~TLine() +{ +}; + +TPlane __fastcall TLine::GetPlane() +{ + return(TPlane(Point,Vector)); +}; + +double __fastcall TLine::GetDistance(vector3 Point1) +{ + return ( (sqr((Point1.x-Point.x)*Vector.x-(Point1.y-Point.y)*Vector.y)- + sqr((Point1.y-Point.y)*Vector.y-(Point1.z-Point.z)*Vector.z)- + sqr((Point1.z-Point.z)*Vector.z-(Point1.x-Point.x)*Vector.x))/ + (sqr(Vector.x)+sqr(Vector.y)+sqr(Vector.z)) ); + ; + + +}; + +//--------------------------------------------------------------------------- + +__fastcall TPlane::TPlane() +{ + Vector= vector3(0,0,0); + d= 0; +}; + +__fastcall TPlane::TPlane(vector3 NVector, double nd) +{ + Vector= NVector; d= nd; +} + +__fastcall TPlane::TPlane(vector3 Point, vector3 NVector) +{ + Vector= NVector; d= -NVector.x*Point.x-NVector.y*Point.y-NVector.z*Point.z; +}; + +__fastcall TPlane::TPlane(vector3 Point1, vector3 Vector1, vector3 Vector2) +{ + Vector= CrossProduct(Vector1,Vector2); d= -Vector.x*Point1.x-Vector.y*Point1.y-Vector.z*Point1.z; +}; + +__fastcall TPlane::~TPlane() +{ +}; + +void __fastcall TPlane::Normalize() +{ + double mgn= Vector.Length(); + Vector= Vector/mgn; d/= mgn; +}; + +double __fastcall TPlane::GetSide(vector3 Point) +{ + return (Vector.x*Point.x+Vector.y*Point.y+Vector.z*Point.z+d); +}; + +//void __fastcall TPlane::Transform(D3DMATRIX &Transformations) +//{ +// vector3 src= Vector; +// D3DMath_VectorMatrixMultiply(Vector,src,Transformations); +//}; + +bool __fastcall TPlane::Defined() +{ + return !(Vector==vector3(0,0,0)); +}; + +//--------------------------------------------------------------------------- + +inline double __fastcall Sum(vector3 &Vector) +{ + return( Vector.x+Vector.y+Vector.z ); +}; + + +bool __fastcall CrossPoint(vector3 &RetPoint, TLine &Line, TPlane &Plane) +{ + double ro= DotProduct(Plane.Vector,Line.Vector); + if (ro==0) + return( false ); + ro= (DotProduct(Plane.Vector,Line.Point)+Plane.d)/ro; + RetPoint= Line.Point-(Line.Vector*ro); + return( true ); +}; + +inline double __fastcall GetLength(vector3& Vector) +{ + return ( Vector.Length() ); +}; + +inline vector3 __fastcall SetLength(vector3& Vector, double Length) +{ + Vector.Normalize(); + return ( Vector*Length ); +}; +//--------------------------------------------------------------------------- +//#pragma package(smart_init) diff --git a/geometry.h b/geometry.h new file mode 100644 index 00000000..0c0f4497 --- /dev/null +++ b/geometry.h @@ -0,0 +1,47 @@ +//--------------------------------------------------------------------------- +#ifndef GeometryH +#define GeometryH + +#include "opengl/glew.h" +#include "dumb3d.h" +using namespace Math3D; +//--------------------------------------------------------------------------- + +class TPlane; + +class TLine +{ +public: + vector3 Vector, Point; + __fastcall TLine(); + __fastcall TLine(vector3 NPoint, vector3 NVector); + __fastcall ~TLine(); + TPlane __fastcall GetPlane(); + double __fastcall GetDistance(vector3 Point1); +}; + +//--------------------------------------------------------------------------- + +class TPlane +{ +public: + vector3 Vector; + double d; + __fastcall TPlane(); + __fastcall TPlane(vector3 NVector, double nd); + __fastcall TPlane(vector3 NPoint, vector3 NVector); + __fastcall TPlane(vector3 Point1, vector3 Vector1, vector3 Vector2); + __fastcall ~TPlane(); + void __fastcall Normalize(); + double __fastcall GetSide(vector3 Point); +// void __fastcall Transform(D3DMATRIX &Transformations); + bool __fastcall Defined(); +}; + +//--------------------------------------------------------------------------- + +inline double __fastcall Sum(vector3 &Vector); +bool __fastcall CrossPoint(vector3 &RetPoint, TLine &Line, TPlane &Plane); + +//--------------------------------------------------------------------------- +#endif diff --git a/opengl/ARB_Multisample.cpp b/opengl/ARB_Multisample.cpp new file mode 100644 index 00000000..e943bfc6 --- /dev/null +++ b/opengl/ARB_Multisample.cpp @@ -0,0 +1,124 @@ +/*======================================================================================== + + Name: ARB_multisample.cpp + Author: Colt "MainRoach" McAnlis + Date: 4/29/04 + Desc: This file contains the context to load a WGL extension from a string + As well as collect the sample format available based upon the graphics card. + +========================================================================================*/ + +#include +#include +#include +#include "wglext.h" //WGL extensions +#include "glext.h" //GL extensions + + +#include "arb_multisample.h" + +// Declairations We'll Use +#define WGL_SAMPLE_BUFFERS_ARB 0x2041 +#define WGL_SAMPLES_ARB 0x2042 + +bool arbMultisampleSupported = false; +int arbMultisampleFormat = 0; + +// WGLisExtensionSupported: This Is A Form Of The Extension For WGL +bool WGLisExtensionSupported(const char *extension) +{ + const size_t extlen = strlen(extension); + const char *supported = NULL; + + // Try To Use wglGetExtensionStringARB On Current DC, If Possible + PROC wglGetExtString = wglGetProcAddress("wglGetExtensionsStringARB"); + + if (wglGetExtString) + supported = ((char*(__stdcall*)(HDC))wglGetExtString)(wglGetCurrentDC()); + + // If That Failed, Try Standard Opengl Extensions String + if (supported == NULL) + supported = (char*)glGetString(GL_EXTENSIONS); + + // If That Failed Too, Must Be No Extensions Supported + if (supported == NULL) + return false; + + // Begin Examination At Start Of String, Increment By 1 On False Match + for (const char* p = supported; ; p++) + { + // Advance p Up To The Next Possible Match + p = strstr(p, extension); + + if (p == NULL) + return false; // No Match + + // Make Sure That Match Is At The Start Of The String Or That + // The Previous Char Is A Space, Or Else We Could Accidentally + // Match "wglFunkywglExtension" With "wglExtension" + + // Also, Make Sure That The Following Character Is Space Or NULL + // Or Else "wglExtensionTwo" Might Match "wglExtension" + if ((p==supported || p[-1]==' ') && (p[extlen]=='\0' || p[extlen]==' ')) + return true; // Match + } +} + +int InitMultisample(HINSTANCE hInstance,HWND hWnd,PIXELFORMATDESCRIPTOR pfd,int mode) +{//used to query the multisample frequencies + arbMultisampleSupported=false; + //see if the string exists in WGL! + if (!WGLisExtensionSupported("WGL_ARB_multisample")) + return 0; + //get our pixel format + PFNWGLCHOOSEPIXELFORMATARBPROC wglChoosePixelFormatARB=(PFNWGLCHOOSEPIXELFORMATARBPROC)wglGetProcAddress("wglChoosePixelFormatARB"); + if (!wglChoosePixelFormatARB) + return 0; + //get our current device context + HDC hDC=GetDC(hWnd); + int pixelFormat; + int valid; + UINT numFormats; + float fAttributes[]={0,0}; + // These attributes are the bits we want to test for in our sample + // everything is pretty standard, the only one we want to + // really focus on is the SAMPLE BUFFERS ARB and WGL SAMPLES + // these two are going to do the main testing for whether or not + // we support multisampling on this hardware. + int iAttributes[]= + { + WGL_DRAW_TO_WINDOW_ARB,GL_TRUE, + WGL_SUPPORT_OPENGL_ARB,GL_TRUE, + WGL_ACCELERATION_ARB,WGL_FULL_ACCELERATION_ARB, + WGL_COLOR_BITS_ARB,24, + WGL_ALPHA_BITS_ARB,8, + WGL_DEPTH_BITS_ARB,16, + WGL_STENCIL_BITS_ARB,0, + WGL_DOUBLE_BUFFER_ARB,GL_TRUE, + WGL_SAMPLE_BUFFERS_ARB,GL_TRUE, + WGL_SAMPLES_ARB,mode, + 0,0 + }; +/* + //first we check to see if we can get a pixel format for 4 samples + valid=wglChoosePixelFormatARB(hDC,iAttributes,fAttributes,1,&pixelFormat,&numFormats); + if (valid&&(numFormats>=1)) + {//if we returned true, and our format count is greater than 1 + arbMultisampleSupported=true; + arbMultisampleFormat=pixelFormat; + return arbMultisampleSupported; + } +*/ + while (iAttributes[19]>1) + {//our pixel format with (mode) samples failed, test for less samples + valid=wglChoosePixelFormatARB(hDC,iAttributes,fAttributes,1,&pixelFormat,&numFormats); + if (valid&&(numFormats>=1)) + {//if we returned true, and our format count is greater than 1 + arbMultisampleSupported=true; + arbMultisampleFormat=pixelFormat; + return iAttributes[19]; //return number of samples + } + iAttributes[19]>>=1; + } + return 0; +} diff --git a/opengl/ARB_Multisample.h b/opengl/ARB_Multisample.h new file mode 100644 index 00000000..984a5925 --- /dev/null +++ b/opengl/ARB_Multisample.h @@ -0,0 +1,28 @@ +/*==================================== + Name: ARB_multisample.h + Author: Colt "MainRoach" McAnlis + Date: 4/29/04 + Desc: + This file contains our external items + +====================================*/ + +#ifndef __ARB_MULTISAMPLE_H__ +#define __ARB_MULTISAMPLE_H__ + +//#include "wglext.h" //WGL extensions +//#include "glext.h" //GL extensions +#include + + +//Globals +extern bool arbMultisampleSupported; +extern int arbMultisampleFormat; + +//If you don't want multisampling, set this to 0 +#define CHECK_FOR_MULTISAMPLE 1 + +//to check for our sampling +int InitMultisample(HINSTANCE hInstance,HWND hWnd,PIXELFORMATDESCRIPTOR pfd,int mode=4); + +#endif diff --git a/opengl/GLUT.H b/opengl/GLUT.H new file mode 100644 index 00000000..109d877d --- /dev/null +++ b/opengl/GLUT.H @@ -0,0 +1,711 @@ +#ifndef __glut_h__ +#define __glut_h__ + +/* Copyright (c) Mark J. Kilgard, 1994, 1995, 1996, 1998. */ + +/* This program is freely distributable without licensing fees and is + provided without guarantee or warrantee expressed or implied. This + program is -not- in the public domain. */ + +#if defined(_WIN32) + +/* GLUT 3.7 now tries to avoid including + to avoid name space pollution, but Win32's + needs APIENTRY and WINGDIAPI defined properly. */ +# if 0 + /* This would put tons of macros and crap in our clean name space. */ +# define WIN32_LEAN_AND_MEAN +# include +# else + /* XXX This is from Win32's */ +# ifndef APIENTRY +# define GLUT_APIENTRY_DEFINED +# if (_MSC_VER >= 800) || defined(_STDCALL_SUPPORTED) || defined(__BORLANDC__) +# define APIENTRY __stdcall +# else +# define APIENTRY +# endif +# endif + /* XXX This is from Win32's */ +# ifndef CALLBACK +# if (defined(_M_MRX000) || defined(_M_IX86) || defined(_M_ALPHA) || defined(_M_PPC)) && !defined(MIDL_PASS) +# define CALLBACK __stdcall +# else +# define CALLBACK +# endif +# endif + /* XXX This is from Win32's and */ +# ifndef WINGDIAPI +# define GLUT_WINGDIAPI_DEFINED +# define WINGDIAPI __declspec(dllimport) +# endif + /* XXX This is from Win32's */ +# ifndef _WCHAR_T_DEFINED +typedef unsigned short wchar_t; +# define _WCHAR_T_DEFINED +# endif +# endif + +#define GLUT_BUILDING_LIB /* disable automatic library usage for GLUT */ +/* To disable automatic library usage for GLUT, define GLUT_NO_LIB_PRAGMA + in your compile preprocessor options. */ +# if !defined(GLUT_BUILDING_LIB) && !defined(GLUT_NO_LIB_PRAGMA) +# pragma comment (lib, "winmm.lib") /* link with Windows MultiMedia lib */ +/* To enable automatic SGI OpenGL for Windows library usage for GLUT, + define GLUT_USE_SGI_OPENGL in your compile preprocessor options. */ +# ifdef GLUT_USE_SGI_OPENGL +# pragma comment (lib, "opengl.lib") /* link with SGI OpenGL for Windows lib */ +# pragma comment (lib, "glu.lib") /* link with SGI OpenGL Utility lib */ +# pragma comment (lib, "glut.lib") /* link with Win32 GLUT for SGI OpenGL lib */ +# else +# pragma comment (lib, "opengl32.lib") /* link with Microsoft OpenGL lib */ +# pragma comment (lib, "glu32.lib") /* link with Microsoft OpenGL Utility lib */ +# pragma comment (lib, "glut32.lib") /* link with Win32 GLUT lib */ +# endif +# endif + +/* To disable supression of annoying warnings about floats being promoted + to doubles, define GLUT_NO_WARNING_DISABLE in your compile preprocessor + options. */ +# ifndef GLUT_NO_WARNING_DISABLE +# pragma warning (disable:4244) /* Disable bogus VC++ 4.2 conversion warnings. */ +# pragma warning (disable:4305) /* VC++ 5.0 version of above warning. */ +# endif + +/* Win32 has an annoying issue where there are multiple C run-time + libraries (CRTs). If the executable is linked with a different CRT + from the GLUT DLL, the GLUT DLL will not share the same CRT static + data seen by the executable. In particular, atexit callbacks registered + in the executable will not be called if GLUT calls its (different) + exit routine). GLUT is typically built with the + "/MD" option (the CRT with multithreading DLL support), but the Visual + C++ linker default is "/ML" (the single threaded CRT). + + One workaround to this issue is requiring users to always link with + the same CRT as GLUT is compiled with. That requires users supply a + non-standard option. GLUT 3.7 has its own built-in workaround where + the executable's "exit" function pointer is covertly passed to GLUT. + GLUT then calls the executable's exit function pointer to ensure that + any "atexit" calls registered by the application are called if GLUT + needs to exit. + + Note that the __glut*WithExit routines should NEVER be called directly. + To avoid the atexit workaround, #define GLUT_DISABLE_ATEXIT_HACK. */ + +/* XXX This is from Win32's */ +# if !defined(_MSC_VER) && !defined(__cdecl) + /* Define __cdecl for non-Microsoft compilers. */ +# define __cdecl +# define GLUT_DEFINED___CDECL +# endif +# ifndef _CRTIMP +# ifdef _NTSDK + /* Definition compatible with NT SDK */ +# define _CRTIMP +# else + /* Current definition */ +# ifdef _DLL +# define _CRTIMP __declspec(dllimport) +# else +# define _CRTIMP +# endif +# endif +# define GLUT_DEFINED__CRTIMP +# endif + +/* GLUT API entry point declarations for Win32. */ +# ifdef GLUT_BUILDING_LIB +# define GLUTAPI __declspec(dllexport) +# else +# ifdef _DLL +# define GLUTAPI __declspec(dllimport) +# else +# define GLUTAPI extern +# endif +# endif + +/* GLUT callback calling convention for Win32. */ +# define GLUTCALLBACK __cdecl + +#endif /* _WIN32 */ + +#include +#include + +#ifdef __cplusplus +extern "C" { +#endif + +#if defined(_WIN32) +# ifndef GLUT_BUILDING_LIB +//extern _CRTIMP void __cdecl exit(int); +# endif +#else +/* non-Win32 case. */ +/* Define APIENTRY and CALLBACK to nothing if we aren't on Win32. */ +# define APIENTRY +# define GLUT_APIENTRY_DEFINED +# define CALLBACK +/* Define GLUTAPI and GLUTCALLBACK as below if we aren't on Win32. */ +# define GLUTAPI extern +# define GLUTCALLBACK +/* Prototype exit for the non-Win32 case (see above). */ +extern void exit(int); +#endif + +/** + GLUT API revision history: + + GLUT_API_VERSION is updated to reflect incompatible GLUT + API changes (interface changes, semantic changes, deletions, + or additions). + + GLUT_API_VERSION=1 First public release of GLUT. 11/29/94 + + GLUT_API_VERSION=2 Added support for OpenGL/GLX multisampling, + extension. Supports new input devices like tablet, dial and button + box, and Spaceball. Easy to query OpenGL extensions. + + GLUT_API_VERSION=3 glutMenuStatus added. + + GLUT_API_VERSION=4 glutInitDisplayString, glutWarpPointer, + glutBitmapLength, glutStrokeLength, glutWindowStatusFunc, dynamic + video resize subAPI, glutPostWindowRedisplay, glutKeyboardUpFunc, + glutSpecialUpFunc, glutIgnoreKeyRepeat, glutSetKeyRepeat, + glutJoystickFunc, glutForceJoystickFunc (NOT FINALIZED!). +**/ +#ifndef GLUT_API_VERSION /* allow this to be overriden */ +#define GLUT_API_VERSION 3 +#endif + +/** + GLUT implementation revision history: + + GLUT_XLIB_IMPLEMENTATION is updated to reflect both GLUT + API revisions and implementation revisions (ie, bug fixes). + + GLUT_XLIB_IMPLEMENTATION=1 mjk's first public release of + GLUT Xlib-based implementation. 11/29/94 + + GLUT_XLIB_IMPLEMENTATION=2 mjk's second public release of + GLUT Xlib-based implementation providing GLUT version 2 + interfaces. + + GLUT_XLIB_IMPLEMENTATION=3 mjk's GLUT 2.2 images. 4/17/95 + + GLUT_XLIB_IMPLEMENTATION=4 mjk's GLUT 2.3 images. 6/?/95 + + GLUT_XLIB_IMPLEMENTATION=5 mjk's GLUT 3.0 images. 10/?/95 + + GLUT_XLIB_IMPLEMENTATION=7 mjk's GLUT 3.1+ with glutWarpPoitner. 7/24/96 + + GLUT_XLIB_IMPLEMENTATION=8 mjk's GLUT 3.1+ with glutWarpPoitner + and video resize. 1/3/97 + + GLUT_XLIB_IMPLEMENTATION=9 mjk's GLUT 3.4 release with early GLUT 4 routines. + + GLUT_XLIB_IMPLEMENTATION=11 Mesa 2.5's GLUT 3.6 release. + + GLUT_XLIB_IMPLEMENTATION=12 mjk's GLUT 3.6 release with early GLUT 4 routines + signal handling. + + GLUT_XLIB_IMPLEMENTATION=13 mjk's GLUT 3.7 beta with GameGLUT support. + + GLUT_XLIB_IMPLEMENTATION=14 mjk's GLUT 3.7 beta with f90gl friend interface. + + GLUT_XLIB_IMPLEMENTATION=15 mjk's GLUT 3.7 beta sync'ed with Mesa +**/ +#ifndef GLUT_XLIB_IMPLEMENTATION /* Allow this to be overriden. */ +#define GLUT_XLIB_IMPLEMENTATION 15 +#endif + +/* Display mode bit masks. */ +#define GLUT_RGB 0 +#define GLUT_RGBA GLUT_RGB +#define GLUT_INDEX 1 +#define GLUT_SINGLE 0 +#define GLUT_DOUBLE 2 +#define GLUT_ACCUM 4 +#define GLUT_ALPHA 8 +#define GLUT_DEPTH 16 +#define GLUT_STENCIL 32 +#if (GLUT_API_VERSION >= 2) +#define GLUT_MULTISAMPLE 128 +#define GLUT_STEREO 256 +#endif +#if (GLUT_API_VERSION >= 3) +#define GLUT_LUMINANCE 512 +#endif + +/* Mouse buttons. */ +#define GLUT_LEFT_BUTTON 0 +#define GLUT_MIDDLE_BUTTON 1 +#define GLUT_RIGHT_BUTTON 2 + +/* Mouse button state. */ +#define GLUT_DOWN 0 +#define GLUT_UP 1 + +#if (GLUT_API_VERSION >= 2) +/* function keys */ +#define GLUT_KEY_F1 1 +#define GLUT_KEY_F2 2 +#define GLUT_KEY_F3 3 +#define GLUT_KEY_F4 4 +#define GLUT_KEY_F5 5 +#define GLUT_KEY_F6 6 +#define GLUT_KEY_F7 7 +#define GLUT_KEY_F8 8 +#define GLUT_KEY_F9 9 +#define GLUT_KEY_F10 10 +#define GLUT_KEY_F11 11 +#define GLUT_KEY_F12 12 +/* directional keys */ +#define GLUT_KEY_LEFT 100 +#define GLUT_KEY_UP 101 +#define GLUT_KEY_RIGHT 102 +#define GLUT_KEY_DOWN 103 +#define GLUT_KEY_PAGE_UP 104 +#define GLUT_KEY_PAGE_DOWN 105 +#define GLUT_KEY_HOME 106 +#define GLUT_KEY_END 107 +#define GLUT_KEY_INSERT 108 +#endif + +/* Entry/exit state. */ +#define GLUT_LEFT 0 +#define GLUT_ENTERED 1 + +/* Menu usage state. */ +#define GLUT_MENU_NOT_IN_USE 0 +#define GLUT_MENU_IN_USE 1 + +/* Visibility state. */ +#define GLUT_NOT_VISIBLE 0 +#define GLUT_VISIBLE 1 + +/* Window status state. */ +#define GLUT_HIDDEN 0 +#define GLUT_FULLY_RETAINED 1 +#define GLUT_PARTIALLY_RETAINED 2 +#define GLUT_FULLY_COVERED 3 + +/* Color index component selection values. */ +#define GLUT_RED 0 +#define GLUT_GREEN 1 +#define GLUT_BLUE 2 + +#if defined(_WIN32) +/* Stroke font constants (use these in GLUT program). */ +#define GLUT_STROKE_ROMAN ((void*)0) +#define GLUT_STROKE_MONO_ROMAN ((void*)1) + +/* Bitmap font constants (use these in GLUT program). */ +#define GLUT_BITMAP_9_BY_15 ((void*)2) +#define GLUT_BITMAP_8_BY_13 ((void*)3) +#define GLUT_BITMAP_TIMES_ROMAN_10 ((void*)4) +#define GLUT_BITMAP_TIMES_ROMAN_24 ((void*)5) +#if (GLUT_API_VERSION >= 3) +#define GLUT_BITMAP_HELVETICA_10 ((void*)6) +#define GLUT_BITMAP_HELVETICA_12 ((void*)7) +#define GLUT_BITMAP_HELVETICA_18 ((void*)8) +#endif +#else +/* Stroke font opaque addresses (use constants instead in source code). */ +GLUTAPI void *glutStrokeRoman; +GLUTAPI void *glutStrokeMonoRoman; + +/* Stroke font constants (use these in GLUT program). */ +#define GLUT_STROKE_ROMAN (&glutStrokeRoman) +#define GLUT_STROKE_MONO_ROMAN (&glutStrokeMonoRoman) + +/* Bitmap font opaque addresses (use constants instead in source code). */ +GLUTAPI void *glutBitmap9By15; +GLUTAPI void *glutBitmap8By13; +GLUTAPI void *glutBitmapTimesRoman10; +GLUTAPI void *glutBitmapTimesRoman24; +GLUTAPI void *glutBitmapHelvetica10; +GLUTAPI void *glutBitmapHelvetica12; +GLUTAPI void *glutBitmapHelvetica18; + +/* Bitmap font constants (use these in GLUT program). */ +#define GLUT_BITMAP_9_BY_15 (&glutBitmap9By15) +#define GLUT_BITMAP_8_BY_13 (&glutBitmap8By13) +#define GLUT_BITMAP_TIMES_ROMAN_10 (&glutBitmapTimesRoman10) +#define GLUT_BITMAP_TIMES_ROMAN_24 (&glutBitmapTimesRoman24) +#if (GLUT_API_VERSION >= 3) +#define GLUT_BITMAP_HELVETICA_10 (&glutBitmapHelvetica10) +#define GLUT_BITMAP_HELVETICA_12 (&glutBitmapHelvetica12) +#define GLUT_BITMAP_HELVETICA_18 (&glutBitmapHelvetica18) +#endif +#endif + +/* glutGet parameters. */ +#define GLUT_WINDOW_X ((GLenum) 100) +#define GLUT_WINDOW_Y ((GLenum) 101) +#define GLUT_WINDOW_WIDTH ((GLenum) 102) +#define GLUT_WINDOW_HEIGHT ((GLenum) 103) +#define GLUT_WINDOW_BUFFER_SIZE ((GLenum) 104) +#define GLUT_WINDOW_STENCIL_SIZE ((GLenum) 105) +#define GLUT_WINDOW_DEPTH_SIZE ((GLenum) 106) +#define GLUT_WINDOW_RED_SIZE ((GLenum) 107) +#define GLUT_WINDOW_GREEN_SIZE ((GLenum) 108) +#define GLUT_WINDOW_BLUE_SIZE ((GLenum) 109) +#define GLUT_WINDOW_ALPHA_SIZE ((GLenum) 110) +#define GLUT_WINDOW_ACCUM_RED_SIZE ((GLenum) 111) +#define GLUT_WINDOW_ACCUM_GREEN_SIZE ((GLenum) 112) +#define GLUT_WINDOW_ACCUM_BLUE_SIZE ((GLenum) 113) +#define GLUT_WINDOW_ACCUM_ALPHA_SIZE ((GLenum) 114) +#define GLUT_WINDOW_DOUBLEBUFFER ((GLenum) 115) +#define GLUT_WINDOW_RGBA ((GLenum) 116) +#define GLUT_WINDOW_PARENT ((GLenum) 117) +#define GLUT_WINDOW_NUM_CHILDREN ((GLenum) 118) +#define GLUT_WINDOW_COLORMAP_SIZE ((GLenum) 119) +#if (GLUT_API_VERSION >= 2) +#define GLUT_WINDOW_NUM_SAMPLES ((GLenum) 120) +#define GLUT_WINDOW_STEREO ((GLenum) 121) +#endif +#if (GLUT_API_VERSION >= 3) +#define GLUT_WINDOW_CURSOR ((GLenum) 122) +#endif +#define GLUT_SCREEN_WIDTH ((GLenum) 200) +#define GLUT_SCREEN_HEIGHT ((GLenum) 201) +#define GLUT_SCREEN_WIDTH_MM ((GLenum) 202) +#define GLUT_SCREEN_HEIGHT_MM ((GLenum) 203) +#define GLUT_MENU_NUM_ITEMS ((GLenum) 300) +#define GLUT_DISPLAY_MODE_POSSIBLE ((GLenum) 400) +#define GLUT_INIT_WINDOW_X ((GLenum) 500) +#define GLUT_INIT_WINDOW_Y ((GLenum) 501) +#define GLUT_INIT_WINDOW_WIDTH ((GLenum) 502) +#define GLUT_INIT_WINDOW_HEIGHT ((GLenum) 503) +#define GLUT_INIT_DISPLAY_MODE ((GLenum) 504) +#if (GLUT_API_VERSION >= 2) +#define GLUT_ELAPSED_TIME ((GLenum) 700) +#endif +#if (GLUT_API_VERSION >= 4 || GLUT_XLIB_IMPLEMENTATION >= 13) +#define GLUT_WINDOW_FORMAT_ID ((GLenum) 123) +#endif + +#if (GLUT_API_VERSION >= 2) +/* glutDeviceGet parameters. */ +#define GLUT_HAS_KEYBOARD ((GLenum) 600) +#define GLUT_HAS_MOUSE ((GLenum) 601) +#define GLUT_HAS_SPACEBALL ((GLenum) 602) +#define GLUT_HAS_DIAL_AND_BUTTON_BOX ((GLenum) 603) +#define GLUT_HAS_TABLET ((GLenum) 604) +#define GLUT_NUM_MOUSE_BUTTONS ((GLenum) 605) +#define GLUT_NUM_SPACEBALL_BUTTONS ((GLenum) 606) +#define GLUT_NUM_BUTTON_BOX_BUTTONS ((GLenum) 607) +#define GLUT_NUM_DIALS ((GLenum) 608) +#define GLUT_NUM_TABLET_BUTTONS ((GLenum) 609) +#endif +#if (GLUT_API_VERSION >= 4 || GLUT_XLIB_IMPLEMENTATION >= 13) +#define GLUT_DEVICE_IGNORE_KEY_REPEAT ((GLenum) 610) +#define GLUT_DEVICE_KEY_REPEAT ((GLenum) 611) +#define GLUT_HAS_JOYSTICK ((GLenum) 612) +#define GLUT_OWNS_JOYSTICK ((GLenum) 613) +#define GLUT_JOYSTICK_BUTTONS ((GLenum) 614) +#define GLUT_JOYSTICK_AXES ((GLenum) 615) +#define GLUT_JOYSTICK_POLL_RATE ((GLenum) 616) +#endif + +#if (GLUT_API_VERSION >= 3) +/* glutLayerGet parameters. */ +#define GLUT_OVERLAY_POSSIBLE ((GLenum) 800) +#define GLUT_LAYER_IN_USE ((GLenum) 801) +#define GLUT_HAS_OVERLAY ((GLenum) 802) +#define GLUT_TRANSPARENT_INDEX ((GLenum) 803) +#define GLUT_NORMAL_DAMAGED ((GLenum) 804) +#define GLUT_OVERLAY_DAMAGED ((GLenum) 805) + +#if (GLUT_API_VERSION >= 4 || GLUT_XLIB_IMPLEMENTATION >= 9) +/* glutVideoResizeGet parameters. */ +#define GLUT_VIDEO_RESIZE_POSSIBLE ((GLenum) 900) +#define GLUT_VIDEO_RESIZE_IN_USE ((GLenum) 901) +#define GLUT_VIDEO_RESIZE_X_DELTA ((GLenum) 902) +#define GLUT_VIDEO_RESIZE_Y_DELTA ((GLenum) 903) +#define GLUT_VIDEO_RESIZE_WIDTH_DELTA ((GLenum) 904) +#define GLUT_VIDEO_RESIZE_HEIGHT_DELTA ((GLenum) 905) +#define GLUT_VIDEO_RESIZE_X ((GLenum) 906) +#define GLUT_VIDEO_RESIZE_Y ((GLenum) 907) +#define GLUT_VIDEO_RESIZE_WIDTH ((GLenum) 908) +#define GLUT_VIDEO_RESIZE_HEIGHT ((GLenum) 909) +#endif + +/* glutUseLayer parameters. */ +#define GLUT_NORMAL ((GLenum) 0) +#define GLUT_OVERLAY ((GLenum) 1) + +/* glutGetModifiers return mask. */ +#define GLUT_ACTIVE_SHIFT 1 +#define GLUT_ACTIVE_CTRL 2 +#define GLUT_ACTIVE_ALT 4 + +/* glutSetCursor parameters. */ +/* Basic arrows. */ +#define GLUT_CURSOR_RIGHT_ARROW 0 +#define GLUT_CURSOR_LEFT_ARROW 1 +/* Symbolic cursor shapes. */ +#define GLUT_CURSOR_INFO 2 +#define GLUT_CURSOR_DESTROY 3 +#define GLUT_CURSOR_HELP 4 +#define GLUT_CURSOR_CYCLE 5 +#define GLUT_CURSOR_SPRAY 6 +#define GLUT_CURSOR_WAIT 7 +#define GLUT_CURSOR_TEXT 8 +#define GLUT_CURSOR_CROSSHAIR 9 +/* Directional cursors. */ +#define GLUT_CURSOR_UP_DOWN 10 +#define GLUT_CURSOR_LEFT_RIGHT 11 +/* Sizing cursors. */ +#define GLUT_CURSOR_TOP_SIDE 12 +#define GLUT_CURSOR_BOTTOM_SIDE 13 +#define GLUT_CURSOR_LEFT_SIDE 14 +#define GLUT_CURSOR_RIGHT_SIDE 15 +#define GLUT_CURSOR_TOP_LEFT_CORNER 16 +#define GLUT_CURSOR_TOP_RIGHT_CORNER 17 +#define GLUT_CURSOR_BOTTOM_RIGHT_CORNER 18 +#define GLUT_CURSOR_BOTTOM_LEFT_CORNER 19 +/* Inherit from parent window. */ +#define GLUT_CURSOR_INHERIT 100 +/* Blank cursor. */ +#define GLUT_CURSOR_NONE 101 +/* Fullscreen crosshair (if available). */ +#define GLUT_CURSOR_FULL_CROSSHAIR 102 +#endif + +/* GLUT initialization sub-API. */ +GLUTAPI void APIENTRY glutInit(int *argcp, char **argv); +#if defined(_WIN32) && !defined(GLUT_DISABLE_ATEXIT_HACK) +GLUTAPI void APIENTRY __glutInitWithExit(int *argcp, char **argv, void (__cdecl *exitfunc)(int)); +#ifndef GLUT_BUILDING_LIB +static void APIENTRY glutInit_ATEXIT_HACK(int *argcp, char **argv) { __glutInitWithExit(argcp, argv, exit); } +#define glutInit glutInit_ATEXIT_HACK +#endif +#endif +GLUTAPI void APIENTRY glutInitDisplayMode(unsigned int mode); +#if (GLUT_API_VERSION >= 4 || GLUT_XLIB_IMPLEMENTATION >= 9) +GLUTAPI void APIENTRY glutInitDisplayString(const char *string); +#endif +GLUTAPI void APIENTRY glutInitWindowPosition(int x, int y); +GLUTAPI void APIENTRY glutInitWindowSize(int width, int height); +GLUTAPI void APIENTRY glutMainLoop(void); + +/* GLUT window sub-API. */ +GLUTAPI int APIENTRY glutCreateWindow(const char *title); +#if defined(_WIN32) && !defined(GLUT_DISABLE_ATEXIT_HACK) +GLUTAPI int APIENTRY __glutCreateWindowWithExit(const char *title, void (__cdecl *exitfunc)(int)); +#ifndef GLUT_BUILDING_LIB +static int APIENTRY glutCreateWindow_ATEXIT_HACK(const char *title) { return __glutCreateWindowWithExit(title, exit); } +#define glutCreateWindow glutCreateWindow_ATEXIT_HACK +#endif +#endif +GLUTAPI int APIENTRY glutCreateSubWindow(int win, int x, int y, int width, int height); +GLUTAPI void APIENTRY glutDestroyWindow(int win); +GLUTAPI void APIENTRY glutPostRedisplay(void); +#if (GLUT_API_VERSION >= 4 || GLUT_XLIB_IMPLEMENTATION >= 11) +GLUTAPI void APIENTRY glutPostWindowRedisplay(int win); +#endif +GLUTAPI void APIENTRY glutSwapBuffers(void); +GLUTAPI int APIENTRY glutGetWindow(void); +GLUTAPI void APIENTRY glutSetWindow(int win); +GLUTAPI void APIENTRY glutSetWindowTitle(const char *title); +GLUTAPI void APIENTRY glutSetIconTitle(const char *title); +GLUTAPI void APIENTRY glutPositionWindow(int x, int y); +GLUTAPI void APIENTRY glutReshapeWindow(int width, int height); +GLUTAPI void APIENTRY glutPopWindow(void); +GLUTAPI void APIENTRY glutPushWindow(void); +GLUTAPI void APIENTRY glutIconifyWindow(void); +GLUTAPI void APIENTRY glutShowWindow(void); +GLUTAPI void APIENTRY glutHideWindow(void); +#if (GLUT_API_VERSION >= 3) +GLUTAPI void APIENTRY glutFullScreen(void); +GLUTAPI void APIENTRY glutSetCursor(int cursor); +#if (GLUT_API_VERSION >= 4 || GLUT_XLIB_IMPLEMENTATION >= 9) +GLUTAPI void APIENTRY glutWarpPointer(int x, int y); +#endif + +/* GLUT overlay sub-API. */ +GLUTAPI void APIENTRY glutEstablishOverlay(void); +GLUTAPI void APIENTRY glutRemoveOverlay(void); +GLUTAPI void APIENTRY glutUseLayer(GLenum layer); +GLUTAPI void APIENTRY glutPostOverlayRedisplay(void); +#if (GLUT_API_VERSION >= 4 || GLUT_XLIB_IMPLEMENTATION >= 11) +GLUTAPI void APIENTRY glutPostWindowOverlayRedisplay(int win); +#endif +GLUTAPI void APIENTRY glutShowOverlay(void); +GLUTAPI void APIENTRY glutHideOverlay(void); +#endif + +/* GLUT menu sub-API. */ +GLUTAPI int APIENTRY glutCreateMenu(void (GLUTCALLBACK *func)(int)); +#if defined(_WIN32) && !defined(GLUT_DISABLE_ATEXIT_HACK) +GLUTAPI int APIENTRY __glutCreateMenuWithExit(void (GLUTCALLBACK *func)(int), void (__cdecl *exitfunc)(int)); +#ifndef GLUT_BUILDING_LIB +static int APIENTRY glutCreateMenu_ATEXIT_HACK(void (GLUTCALLBACK *func)(int)) { return __glutCreateMenuWithExit(func, exit); } +#define glutCreateMenu glutCreateMenu_ATEXIT_HACK +#endif +#endif +GLUTAPI void APIENTRY glutDestroyMenu(int menu); +GLUTAPI int APIENTRY glutGetMenu(void); +GLUTAPI void APIENTRY glutSetMenu(int menu); +GLUTAPI void APIENTRY glutAddMenuEntry(const char *label, int value); +GLUTAPI void APIENTRY glutAddSubMenu(const char *label, int submenu); +GLUTAPI void APIENTRY glutChangeToMenuEntry(int item, const char *label, int value); +GLUTAPI void APIENTRY glutChangeToSubMenu(int item, const char *label, int submenu); +GLUTAPI void APIENTRY glutRemoveMenuItem(int item); +GLUTAPI void APIENTRY glutAttachMenu(int button); +GLUTAPI void APIENTRY glutDetachMenu(int button); + +/* GLUT window callback sub-API. */ +GLUTAPI void APIENTRY glutDisplayFunc(void (GLUTCALLBACK *func)(void)); +GLUTAPI void APIENTRY glutReshapeFunc(void (GLUTCALLBACK *func)(int width, int height)); +GLUTAPI void APIENTRY glutKeyboardFunc(void (GLUTCALLBACK *func)(unsigned char key, int x, int y)); +GLUTAPI void APIENTRY glutMouseFunc(void (GLUTCALLBACK *func)(int button, int state, int x, int y)); +GLUTAPI void APIENTRY glutMotionFunc(void (GLUTCALLBACK *func)(int x, int y)); +GLUTAPI void APIENTRY glutPassiveMotionFunc(void (GLUTCALLBACK *func)(int x, int y)); +GLUTAPI void APIENTRY glutEntryFunc(void (GLUTCALLBACK *func)(int state)); +GLUTAPI void APIENTRY glutVisibilityFunc(void (GLUTCALLBACK *func)(int state)); +GLUTAPI void APIENTRY glutIdleFunc(void (GLUTCALLBACK *func)(void)); +GLUTAPI void APIENTRY glutTimerFunc(unsigned int millis, void (GLUTCALLBACK *func)(int value), int value); +GLUTAPI void APIENTRY glutMenuStateFunc(void (GLUTCALLBACK *func)(int state)); +#if (GLUT_API_VERSION >= 2) +GLUTAPI void APIENTRY glutSpecialFunc(void (GLUTCALLBACK *func)(int key, int x, int y)); +GLUTAPI void APIENTRY glutSpaceballMotionFunc(void (GLUTCALLBACK *func)(int x, int y, int z)); +GLUTAPI void APIENTRY glutSpaceballRotateFunc(void (GLUTCALLBACK *func)(int x, int y, int z)); +GLUTAPI void APIENTRY glutSpaceballButtonFunc(void (GLUTCALLBACK *func)(int button, int state)); +GLUTAPI void APIENTRY glutButtonBoxFunc(void (GLUTCALLBACK *func)(int button, int state)); +GLUTAPI void APIENTRY glutDialsFunc(void (GLUTCALLBACK *func)(int dial, int value)); +GLUTAPI void APIENTRY glutTabletMotionFunc(void (GLUTCALLBACK *func)(int x, int y)); +GLUTAPI void APIENTRY glutTabletButtonFunc(void (GLUTCALLBACK *func)(int button, int state, int x, int y)); +#if (GLUT_API_VERSION >= 3) +GLUTAPI void APIENTRY glutMenuStatusFunc(void (GLUTCALLBACK *func)(int status, int x, int y)); +GLUTAPI void APIENTRY glutOverlayDisplayFunc(void (GLUTCALLBACK *func)(void)); +#if (GLUT_API_VERSION >= 4 || GLUT_XLIB_IMPLEMENTATION >= 9) +GLUTAPI void APIENTRY glutWindowStatusFunc(void (GLUTCALLBACK *func)(int state)); +#endif +#if (GLUT_API_VERSION >= 4 || GLUT_XLIB_IMPLEMENTATION >= 13) +GLUTAPI void APIENTRY glutKeyboardUpFunc(void (GLUTCALLBACK *func)(unsigned char key, int x, int y)); +GLUTAPI void APIENTRY glutSpecialUpFunc(void (GLUTCALLBACK *func)(int key, int x, int y)); +GLUTAPI void APIENTRY glutJoystickFunc(void (GLUTCALLBACK *func)(unsigned int buttonMask, int x, int y, int z), int pollInterval); +#endif +#endif +#endif + +/* GLUT color index sub-API. */ +GLUTAPI void APIENTRY glutSetColor(int, GLfloat red, GLfloat green, GLfloat blue); +GLUTAPI GLfloat APIENTRY glutGetColor(int ndx, int component); +GLUTAPI void APIENTRY glutCopyColormap(int win); + +/* GLUT state retrieval sub-API. */ +GLUTAPI int APIENTRY glutGet(GLenum type); +GLUTAPI int APIENTRY glutDeviceGet(GLenum type); +#if (GLUT_API_VERSION >= 2) +/* GLUT extension support sub-API */ +GLUTAPI int APIENTRY glutExtensionSupported(const char *name); +#endif +#if (GLUT_API_VERSION >= 3) +GLUTAPI int APIENTRY glutGetModifiers(void); +GLUTAPI int APIENTRY glutLayerGet(GLenum type); +#endif + +/* GLUT font sub-API */ +GLUTAPI void APIENTRY glutBitmapCharacter(void *font, int character); +GLUTAPI int APIENTRY glutBitmapWidth(void *font, int character); +GLUTAPI void APIENTRY glutStrokeCharacter(void *font, int character); +GLUTAPI int APIENTRY glutStrokeWidth(void *font, int character); +#if (GLUT_API_VERSION >= 4 || GLUT_XLIB_IMPLEMENTATION >= 9) +GLUTAPI int APIENTRY glutBitmapLength(void *font, const unsigned char *string); +GLUTAPI int APIENTRY glutStrokeLength(void *font, const unsigned char *string); +#endif + +/* GLUT pre-built models sub-API */ +GLUTAPI void APIENTRY glutWireSphere(GLdouble radius, GLint slices, GLint stacks); +GLUTAPI void APIENTRY glutSolidSphere(GLdouble radius, GLint slices, GLint stacks); +GLUTAPI void APIENTRY glutWireCone(GLdouble base, GLdouble height, GLint slices, GLint stacks); +GLUTAPI void APIENTRY glutSolidCone(GLdouble base, GLdouble height, GLint slices, GLint stacks); +GLUTAPI void APIENTRY glutWireCube(GLdouble size); +GLUTAPI void APIENTRY glutSolidCube(GLdouble size); +GLUTAPI void APIENTRY glutWireTorus(GLdouble innerRadius, GLdouble outerRadius, GLint sides, GLint rings); +GLUTAPI void APIENTRY glutSolidTorus(GLdouble innerRadius, GLdouble outerRadius, GLint sides, GLint rings); +GLUTAPI void APIENTRY glutWireDodecahedron(void); +GLUTAPI void APIENTRY glutSolidDodecahedron(void); +GLUTAPI void APIENTRY glutWireTeapot(GLdouble size); +GLUTAPI void APIENTRY glutSolidTeapot(GLdouble size); +GLUTAPI void APIENTRY glutWireOctahedron(void); +GLUTAPI void APIENTRY glutSolidOctahedron(void); +GLUTAPI void APIENTRY glutWireTetrahedron(void); +GLUTAPI void APIENTRY glutSolidTetrahedron(void); +GLUTAPI void APIENTRY glutWireIcosahedron(void); +GLUTAPI void APIENTRY glutSolidIcosahedron(void); + +#if (GLUT_API_VERSION >= 4 || GLUT_XLIB_IMPLEMENTATION >= 9) +/* GLUT video resize sub-API. */ +GLUTAPI int APIENTRY glutVideoResizeGet(GLenum param); +GLUTAPI void APIENTRY glutSetupVideoResizing(void); +GLUTAPI void APIENTRY glutStopVideoResizing(void); +GLUTAPI void APIENTRY glutVideoResize(int x, int y, int width, int height); +GLUTAPI void APIENTRY glutVideoPan(int x, int y, int width, int height); + +/* GLUT debugging sub-API. */ +GLUTAPI void APIENTRY glutReportErrors(void); +#endif + +#if (GLUT_API_VERSION >= 4 || GLUT_XLIB_IMPLEMENTATION >= 13) +/* GLUT device control sub-API. */ +/* glutSetKeyRepeat modes. */ +#define GLUT_KEY_REPEAT_OFF 0 +#define GLUT_KEY_REPEAT_ON 1 +#define GLUT_KEY_REPEAT_DEFAULT 2 + +/* Joystick button masks. */ +#define GLUT_JOYSTICK_BUTTON_A 1 +#define GLUT_JOYSTICK_BUTTON_B 2 +#define GLUT_JOYSTICK_BUTTON_C 4 +#define GLUT_JOYSTICK_BUTTON_D 8 + +GLUTAPI void APIENTRY glutIgnoreKeyRepeat(int ignore); +GLUTAPI void APIENTRY glutSetKeyRepeat(int repeatMode); +GLUTAPI void APIENTRY glutForceJoystickFunc(void); + +/* GLUT game mode sub-API. */ +/* glutGameModeGet. */ +#define GLUT_GAME_MODE_ACTIVE ((GLenum) 0) +#define GLUT_GAME_MODE_POSSIBLE ((GLenum) 1) +#define GLUT_GAME_MODE_WIDTH ((GLenum) 2) +#define GLUT_GAME_MODE_HEIGHT ((GLenum) 3) +#define GLUT_GAME_MODE_PIXEL_DEPTH ((GLenum) 4) +#define GLUT_GAME_MODE_REFRESH_RATE ((GLenum) 5) +#define GLUT_GAME_MODE_DISPLAY_CHANGED ((GLenum) 6) + +GLUTAPI void APIENTRY glutGameModeString(const char *string); +GLUTAPI int APIENTRY glutEnterGameMode(void); +GLUTAPI void APIENTRY glutLeaveGameMode(void); +GLUTAPI int APIENTRY glutGameModeGet(GLenum mode); +#endif + +#ifdef __cplusplus +} + +#endif + +#ifdef GLUT_APIENTRY_DEFINED +# undef GLUT_APIENTRY_DEFINED +# undef APIENTRY +#endif + +#ifdef GLUT_WINGDIAPI_DEFINED +# undef GLUT_WINGDIAPI_DEFINED +# undef WINGDIAPI +#endif + +#ifdef GLUT_DEFINED___CDECL +# undef GLUT_DEFINED___CDECL +# undef __cdecl +#endif + +#ifdef GLUT_DEFINED__CRTIMP +# undef GLUT_DEFINED__CRTIMP +# undef _CRTIMP +#endif + +#endif /* __glut_h__ */ diff --git a/opengl/glew.c b/opengl/glew.c new file mode 100644 index 00000000..539c61f4 --- /dev/null +++ b/opengl/glew.c @@ -0,0 +1,12180 @@ +/* +** The OpenGL Extension Wrangler Library +** Copyright (C) 2002-2008, Milan Ikits +** Copyright (C) 2002-2008, Marcelo E. Magallon +** Copyright (C) 2002, Lev Povalahev +** All rights reserved. +** +** Redistribution and use in source and binary forms, with or without +** modification, are permitted provided that the following conditions are met: +** +** * Redistributions of source code must retain the above copyright notice, +** this list of conditions and the following disclaimer. +** * Redistributions in binary form must reproduce the above copyright notice, +** this list of conditions and the following disclaimer in the documentation +** and/or other materials provided with the distribution. +** * The name of the author may be used to endorse or promote products +** derived from this software without specific prior written permission. +** +** THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" +** AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE +** IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE +** ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE +** LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR +** CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF +** SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS +** INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN +** CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) +** ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF +** THE POSSIBILITY OF SUCH DAMAGE. +*/ + +#include "OPENGL/glew.h" +#if defined(_WIN32) +# include "OPENGL/wglew.h" +#elif !defined(__APPLE__) || defined(GLEW_APPLE_GLX) +# include "OPENGL/glxew.h" +#endif + +/* + * Define glewGetContext and related helper macros. + */ +#ifdef GLEW_MX +# define glewGetContext() ctx +# ifdef _WIN32 +# define GLEW_CONTEXT_ARG_DEF_INIT GLEWContext* ctx +# define GLEW_CONTEXT_ARG_VAR_INIT ctx +# define wglewGetContext() ctx +# define WGLEW_CONTEXT_ARG_DEF_INIT WGLEWContext* ctx +# define WGLEW_CONTEXT_ARG_DEF_LIST WGLEWContext* ctx +# else /* _WIN32 */ +# define GLEW_CONTEXT_ARG_DEF_INIT void +# define GLEW_CONTEXT_ARG_VAR_INIT +# define glxewGetContext() ctx +# define GLXEW_CONTEXT_ARG_DEF_INIT void +# define GLXEW_CONTEXT_ARG_DEF_LIST GLXEWContext* ctx +# endif /* _WIN32 */ +# define GLEW_CONTEXT_ARG_DEF_LIST GLEWContext* ctx +#else /* GLEW_MX */ +# define GLEW_CONTEXT_ARG_DEF_INIT void +# define GLEW_CONTEXT_ARG_VAR_INIT +# define GLEW_CONTEXT_ARG_DEF_LIST void +# define WGLEW_CONTEXT_ARG_DEF_INIT void +# define WGLEW_CONTEXT_ARG_DEF_LIST void +# define GLXEW_CONTEXT_ARG_DEF_INIT void +# define GLXEW_CONTEXT_ARG_DEF_LIST void +#endif /* GLEW_MX */ + +#if defined(__APPLE__) +#include +#include +#include + +void* NSGLGetProcAddress (const GLubyte *name) +{ + static const struct mach_header* image = NULL; + NSSymbol symbol; + char* symbolName; + if (NULL == image) + { + image = NSAddImage("/System/Library/Frameworks/OpenGL.framework/Versions/Current/OpenGL", NSADDIMAGE_OPTION_RETURN_ON_ERROR); + } + /* prepend a '_' for the Unix C symbol mangling convention */ + symbolName = malloc(strlen((const char*)name) + 2); + strcpy(symbolName+1, (const char*)name); + symbolName[0] = '_'; + symbol = NULL; + /* if (NSIsSymbolNameDefined(symbolName)) + symbol = NSLookupAndBindSymbol(symbolName); */ + symbol = image ? NSLookupSymbolInImage(image, symbolName, NSLOOKUPSYMBOLINIMAGE_OPTION_BIND | NSLOOKUPSYMBOLINIMAGE_OPTION_RETURN_ON_ERROR) : NULL; + free(symbolName); + return symbol ? NSAddressOfSymbol(symbol) : NULL; +} +#endif /* __APPLE__ */ + +#if defined(__sgi) || defined (__sun) +#include +#include +#include + +void* dlGetProcAddress (const GLubyte* name) +{ + static void* h = NULL; + static void* gpa; + + if (h == NULL) + { + if ((h = dlopen(NULL, RTLD_LAZY | RTLD_LOCAL)) == NULL) return NULL; + gpa = dlsym(h, "glXGetProcAddress"); + } + + if (gpa != NULL) + return ((void*(*)(const GLubyte*))gpa)(name); + else + return dlsym(h, (const char*)name); +} +#endif /* __sgi || __sun */ + +/* + * Define glewGetProcAddress. + */ +#if defined(_WIN32) +# define glewGetProcAddress(name) wglGetProcAddress((LPCSTR)name) +#else +# if defined(__APPLE__) +# define glewGetProcAddress(name) NSGLGetProcAddress(name) +# else +# if defined(__sgi) || defined(__sun) +# define glewGetProcAddress(name) dlGetProcAddress(name) +# else /* __linux */ +# define glewGetProcAddress(name) (*glXGetProcAddressARB)(name) +# endif +# endif +#endif + +/* + * Define GLboolean const cast. + */ +#define CONST_CAST(x) (*(GLboolean*)&x) + +/* + * GLEW, just like OpenGL or GLU, does not rely on the standard C library. + * These functions implement the functionality required in this file. + */ +static GLuint _glewStrLen (const GLubyte* s) +{ + GLuint i=0; + if (s == NULL) return 0; + while (s[i] != '\0') i++; + return i; +} + +static GLuint _glewStrCLen (const GLubyte* s, GLubyte c) +{ + GLuint i=0; + if (s == NULL) return 0; + while (s[i] != '\0' && s[i] != c) i++; + return (s[i] == '\0' || s[i] == c) ? i : 0; +} + +static GLboolean _glewStrSame (const GLubyte* a, const GLubyte* b, GLuint n) +{ + GLuint i=0; + if(a == NULL || b == NULL) + return (a == NULL && b == NULL && n == 0) ? GL_TRUE : GL_FALSE; + while (i < n && a[i] != '\0' && b[i] != '\0' && a[i] == b[i]) i++; + return i == n ? GL_TRUE : GL_FALSE; +} + +static GLboolean _glewStrSame1 (GLubyte** a, GLuint* na, const GLubyte* b, GLuint nb) +{ + while (*na > 0 && (**a == ' ' || **a == '\n' || **a == '\r' || **a == '\t')) + { + (*a)++; + (*na)--; + } + if(*na >= nb) + { + GLuint i=0; + while (i < nb && (*a)+i != NULL && b+i != NULL && (*a)[i] == b[i]) i++; + if(i == nb) + { + *a = *a + nb; + *na = *na - nb; + return GL_TRUE; + } + } + return GL_FALSE; +} + +static GLboolean _glewStrSame2 (GLubyte** a, GLuint* na, const GLubyte* b, GLuint nb) +{ + if(*na >= nb) + { + GLuint i=0; + while (i < nb && (*a)+i != NULL && b+i != NULL && (*a)[i] == b[i]) i++; + if(i == nb) + { + *a = *a + nb; + *na = *na - nb; + return GL_TRUE; + } + } + return GL_FALSE; +} + +static GLboolean _glewStrSame3 (GLubyte** a, GLuint* na, const GLubyte* b, GLuint nb) +{ + if(*na >= nb) + { + GLuint i=0; + while (i < nb && (*a)+i != NULL && b+i != NULL && (*a)[i] == b[i]) i++; + if (i == nb && (*na == nb || (*a)[i] == ' ' || (*a)[i] == '\n' || (*a)[i] == '\r' || (*a)[i] == '\t')) + { + *a = *a + nb; + *na = *na - nb; + return GL_TRUE; + } + } + return GL_FALSE; +} + +#if !defined(_WIN32) || !defined(GLEW_MX) + +PFNGLCOPYTEXSUBIMAGE3DPROC __glewCopyTexSubImage3D = NULL; +PFNGLDRAWRANGEELEMENTSPROC __glewDrawRangeElements = NULL; +PFNGLTEXIMAGE3DPROC __glewTexImage3D = NULL; +PFNGLTEXSUBIMAGE3DPROC __glewTexSubImage3D = NULL; + +PFNGLACTIVETEXTUREPROC __glewActiveTexture = NULL; +PFNGLCLIENTACTIVETEXTUREPROC __glewClientActiveTexture = NULL; +PFNGLCOMPRESSEDTEXIMAGE1DPROC __glewCompressedTexImage1D = NULL; +PFNGLCOMPRESSEDTEXIMAGE2DPROC __glewCompressedTexImage2D = NULL; +PFNGLCOMPRESSEDTEXIMAGE3DPROC __glewCompressedTexImage3D = NULL; +PFNGLCOMPRESSEDTEXSUBIMAGE1DPROC __glewCompressedTexSubImage1D = NULL; +PFNGLCOMPRESSEDTEXSUBIMAGE2DPROC __glewCompressedTexSubImage2D = NULL; +PFNGLCOMPRESSEDTEXSUBIMAGE3DPROC __glewCompressedTexSubImage3D = NULL; +PFNGLGETCOMPRESSEDTEXIMAGEPROC __glewGetCompressedTexImage = NULL; +PFNGLLOADTRANSPOSEMATRIXDPROC __glewLoadTransposeMatrixd = NULL; +PFNGLLOADTRANSPOSEMATRIXFPROC __glewLoadTransposeMatrixf = NULL; +PFNGLMULTTRANSPOSEMATRIXDPROC __glewMultTransposeMatrixd = NULL; +PFNGLMULTTRANSPOSEMATRIXFPROC __glewMultTransposeMatrixf = NULL; +PFNGLMULTITEXCOORD1DPROC __glewMultiTexCoord1d = NULL; +PFNGLMULTITEXCOORD1DVPROC __glewMultiTexCoord1dv = NULL; +PFNGLMULTITEXCOORD1FPROC __glewMultiTexCoord1f = NULL; +PFNGLMULTITEXCOORD1FVPROC __glewMultiTexCoord1fv = NULL; +PFNGLMULTITEXCOORD1IPROC __glewMultiTexCoord1i = NULL; +PFNGLMULTITEXCOORD1IVPROC __glewMultiTexCoord1iv = NULL; +PFNGLMULTITEXCOORD1SPROC __glewMultiTexCoord1s = NULL; +PFNGLMULTITEXCOORD1SVPROC __glewMultiTexCoord1sv = NULL; +PFNGLMULTITEXCOORD2DPROC __glewMultiTexCoord2d = NULL; +PFNGLMULTITEXCOORD2DVPROC __glewMultiTexCoord2dv = NULL; +PFNGLMULTITEXCOORD2FPROC __glewMultiTexCoord2f = NULL; +PFNGLMULTITEXCOORD2FVPROC __glewMultiTexCoord2fv = NULL; +PFNGLMULTITEXCOORD2IPROC __glewMultiTexCoord2i = NULL; +PFNGLMULTITEXCOORD2IVPROC __glewMultiTexCoord2iv = NULL; +PFNGLMULTITEXCOORD2SPROC __glewMultiTexCoord2s = NULL; +PFNGLMULTITEXCOORD2SVPROC __glewMultiTexCoord2sv = NULL; +PFNGLMULTITEXCOORD3DPROC __glewMultiTexCoord3d = NULL; +PFNGLMULTITEXCOORD3DVPROC __glewMultiTexCoord3dv = NULL; +PFNGLMULTITEXCOORD3FPROC __glewMultiTexCoord3f = NULL; +PFNGLMULTITEXCOORD3FVPROC __glewMultiTexCoord3fv = NULL; +PFNGLMULTITEXCOORD3IPROC __glewMultiTexCoord3i = NULL; +PFNGLMULTITEXCOORD3IVPROC __glewMultiTexCoord3iv = NULL; +PFNGLMULTITEXCOORD3SPROC __glewMultiTexCoord3s = NULL; +PFNGLMULTITEXCOORD3SVPROC __glewMultiTexCoord3sv = NULL; +PFNGLMULTITEXCOORD4DPROC __glewMultiTexCoord4d = NULL; +PFNGLMULTITEXCOORD4DVPROC __glewMultiTexCoord4dv = NULL; +PFNGLMULTITEXCOORD4FPROC __glewMultiTexCoord4f = NULL; +PFNGLMULTITEXCOORD4FVPROC __glewMultiTexCoord4fv = NULL; +PFNGLMULTITEXCOORD4IPROC __glewMultiTexCoord4i = NULL; +PFNGLMULTITEXCOORD4IVPROC __glewMultiTexCoord4iv = NULL; +PFNGLMULTITEXCOORD4SPROC __glewMultiTexCoord4s = NULL; +PFNGLMULTITEXCOORD4SVPROC __glewMultiTexCoord4sv = NULL; +PFNGLSAMPLECOVERAGEPROC __glewSampleCoverage = NULL; + +PFNGLBLENDCOLORPROC __glewBlendColor = NULL; +PFNGLBLENDEQUATIONPROC __glewBlendEquation = NULL; +PFNGLBLENDFUNCSEPARATEPROC __glewBlendFuncSeparate = NULL; +PFNGLFOGCOORDPOINTERPROC __glewFogCoordPointer = NULL; +PFNGLFOGCOORDDPROC __glewFogCoordd = NULL; +PFNGLFOGCOORDDVPROC __glewFogCoorddv = NULL; +PFNGLFOGCOORDFPROC __glewFogCoordf = NULL; +PFNGLFOGCOORDFVPROC __glewFogCoordfv = NULL; +PFNGLMULTIDRAWARRAYSPROC __glewMultiDrawArrays = NULL; +PFNGLMULTIDRAWELEMENTSPROC __glewMultiDrawElements = NULL; +PFNGLPOINTPARAMETERFPROC __glewPointParameterf = NULL; +PFNGLPOINTPARAMETERFVPROC __glewPointParameterfv = NULL; +PFNGLPOINTPARAMETERIPROC __glewPointParameteri = NULL; +PFNGLPOINTPARAMETERIVPROC __glewPointParameteriv = NULL; +PFNGLSECONDARYCOLOR3BPROC __glewSecondaryColor3b = NULL; +PFNGLSECONDARYCOLOR3BVPROC __glewSecondaryColor3bv = NULL; +PFNGLSECONDARYCOLOR3DPROC __glewSecondaryColor3d = NULL; +PFNGLSECONDARYCOLOR3DVPROC __glewSecondaryColor3dv = NULL; +PFNGLSECONDARYCOLOR3FPROC __glewSecondaryColor3f = NULL; +PFNGLSECONDARYCOLOR3FVPROC __glewSecondaryColor3fv = NULL; +PFNGLSECONDARYCOLOR3IPROC __glewSecondaryColor3i = NULL; +PFNGLSECONDARYCOLOR3IVPROC __glewSecondaryColor3iv = NULL; +PFNGLSECONDARYCOLOR3SPROC __glewSecondaryColor3s = NULL; +PFNGLSECONDARYCOLOR3SVPROC __glewSecondaryColor3sv = NULL; +PFNGLSECONDARYCOLOR3UBPROC __glewSecondaryColor3ub = NULL; +PFNGLSECONDARYCOLOR3UBVPROC __glewSecondaryColor3ubv = NULL; +PFNGLSECONDARYCOLOR3UIPROC __glewSecondaryColor3ui = NULL; +PFNGLSECONDARYCOLOR3UIVPROC __glewSecondaryColor3uiv = NULL; +PFNGLSECONDARYCOLOR3USPROC __glewSecondaryColor3us = NULL; +PFNGLSECONDARYCOLOR3USVPROC __glewSecondaryColor3usv = NULL; +PFNGLSECONDARYCOLORPOINTERPROC __glewSecondaryColorPointer = NULL; +PFNGLWINDOWPOS2DPROC __glewWindowPos2d = NULL; +PFNGLWINDOWPOS2DVPROC __glewWindowPos2dv = NULL; +PFNGLWINDOWPOS2FPROC __glewWindowPos2f = NULL; +PFNGLWINDOWPOS2FVPROC __glewWindowPos2fv = NULL; +PFNGLWINDOWPOS2IPROC __glewWindowPos2i = NULL; +PFNGLWINDOWPOS2IVPROC __glewWindowPos2iv = NULL; +PFNGLWINDOWPOS2SPROC __glewWindowPos2s = NULL; +PFNGLWINDOWPOS2SVPROC __glewWindowPos2sv = NULL; +PFNGLWINDOWPOS3DPROC __glewWindowPos3d = NULL; +PFNGLWINDOWPOS3DVPROC __glewWindowPos3dv = NULL; +PFNGLWINDOWPOS3FPROC __glewWindowPos3f = NULL; +PFNGLWINDOWPOS3FVPROC __glewWindowPos3fv = NULL; +PFNGLWINDOWPOS3IPROC __glewWindowPos3i = NULL; +PFNGLWINDOWPOS3IVPROC __glewWindowPos3iv = NULL; +PFNGLWINDOWPOS3SPROC __glewWindowPos3s = NULL; +PFNGLWINDOWPOS3SVPROC __glewWindowPos3sv = NULL; + +PFNGLBEGINQUERYPROC __glewBeginQuery = NULL; +PFNGLBINDBUFFERPROC __glewBindBuffer = NULL; +PFNGLBUFFERDATAPROC __glewBufferData = NULL; +PFNGLBUFFERSUBDATAPROC __glewBufferSubData = NULL; +PFNGLDELETEBUFFERSPROC __glewDeleteBuffers = NULL; +PFNGLDELETEQUERIESPROC __glewDeleteQueries = NULL; +PFNGLENDQUERYPROC __glewEndQuery = NULL; +PFNGLGENBUFFERSPROC __glewGenBuffers = NULL; +PFNGLGENQUERIESPROC __glewGenQueries = NULL; +PFNGLGETBUFFERPARAMETERIVPROC __glewGetBufferParameteriv = NULL; +PFNGLGETBUFFERPOINTERVPROC __glewGetBufferPointerv = NULL; +PFNGLGETBUFFERSUBDATAPROC __glewGetBufferSubData = NULL; +PFNGLGETQUERYOBJECTIVPROC __glewGetQueryObjectiv = NULL; +PFNGLGETQUERYOBJECTUIVPROC __glewGetQueryObjectuiv = NULL; +PFNGLGETQUERYIVPROC __glewGetQueryiv = NULL; +PFNGLISBUFFERPROC __glewIsBuffer = NULL; +PFNGLISQUERYPROC __glewIsQuery = NULL; +PFNGLMAPBUFFERPROC __glewMapBuffer = NULL; +PFNGLUNMAPBUFFERPROC __glewUnmapBuffer = NULL; + +PFNGLATTACHSHADERPROC __glewAttachShader = NULL; +PFNGLBINDATTRIBLOCATIONPROC __glewBindAttribLocation = NULL; +PFNGLBLENDEQUATIONSEPARATEPROC __glewBlendEquationSeparate = NULL; +PFNGLCOMPILESHADERPROC __glewCompileShader = NULL; +PFNGLCREATEPROGRAMPROC __glewCreateProgram = NULL; +PFNGLCREATESHADERPROC __glewCreateShader = NULL; +PFNGLDELETEPROGRAMPROC __glewDeleteProgram = NULL; +PFNGLDELETESHADERPROC __glewDeleteShader = NULL; +PFNGLDETACHSHADERPROC __glewDetachShader = NULL; +PFNGLDISABLEVERTEXATTRIBARRAYPROC __glewDisableVertexAttribArray = NULL; +PFNGLDRAWBUFFERSPROC __glewDrawBuffers = NULL; +PFNGLENABLEVERTEXATTRIBARRAYPROC __glewEnableVertexAttribArray = NULL; +PFNGLGETACTIVEATTRIBPROC __glewGetActiveAttrib = NULL; +PFNGLGETACTIVEUNIFORMPROC __glewGetActiveUniform = NULL; +PFNGLGETATTACHEDSHADERSPROC __glewGetAttachedShaders = NULL; +PFNGLGETATTRIBLOCATIONPROC __glewGetAttribLocation = NULL; +PFNGLGETPROGRAMINFOLOGPROC __glewGetProgramInfoLog = NULL; +PFNGLGETPROGRAMIVPROC __glewGetProgramiv = NULL; +PFNGLGETSHADERINFOLOGPROC __glewGetShaderInfoLog = NULL; +PFNGLGETSHADERSOURCEPROC __glewGetShaderSource = NULL; +PFNGLGETSHADERIVPROC __glewGetShaderiv = NULL; +PFNGLGETUNIFORMLOCATIONPROC __glewGetUniformLocation = NULL; +PFNGLGETUNIFORMFVPROC __glewGetUniformfv = NULL; +PFNGLGETUNIFORMIVPROC __glewGetUniformiv = NULL; +PFNGLGETVERTEXATTRIBPOINTERVPROC __glewGetVertexAttribPointerv = NULL; +PFNGLGETVERTEXATTRIBDVPROC __glewGetVertexAttribdv = NULL; +PFNGLGETVERTEXATTRIBFVPROC __glewGetVertexAttribfv = NULL; +PFNGLGETVERTEXATTRIBIVPROC __glewGetVertexAttribiv = NULL; +PFNGLISPROGRAMPROC __glewIsProgram = NULL; +PFNGLISSHADERPROC __glewIsShader = NULL; +PFNGLLINKPROGRAMPROC __glewLinkProgram = NULL; +PFNGLSHADERSOURCEPROC __glewShaderSource = NULL; +PFNGLSTENCILFUNCSEPARATEPROC __glewStencilFuncSeparate = NULL; +PFNGLSTENCILMASKSEPARATEPROC __glewStencilMaskSeparate = NULL; +PFNGLSTENCILOPSEPARATEPROC __glewStencilOpSeparate = NULL; +PFNGLUNIFORM1FPROC __glewUniform1f = NULL; +PFNGLUNIFORM1FVPROC __glewUniform1fv = NULL; +PFNGLUNIFORM1IPROC __glewUniform1i = NULL; +PFNGLUNIFORM1IVPROC __glewUniform1iv = NULL; +PFNGLUNIFORM2FPROC __glewUniform2f = NULL; +PFNGLUNIFORM2FVPROC __glewUniform2fv = NULL; +PFNGLUNIFORM2IPROC __glewUniform2i = NULL; +PFNGLUNIFORM2IVPROC __glewUniform2iv = NULL; +PFNGLUNIFORM3FPROC __glewUniform3f = NULL; +PFNGLUNIFORM3FVPROC __glewUniform3fv = NULL; +PFNGLUNIFORM3IPROC __glewUniform3i = NULL; +PFNGLUNIFORM3IVPROC __glewUniform3iv = NULL; +PFNGLUNIFORM4FPROC __glewUniform4f = NULL; +PFNGLUNIFORM4FVPROC __glewUniform4fv = NULL; +PFNGLUNIFORM4IPROC __glewUniform4i = NULL; +PFNGLUNIFORM4IVPROC __glewUniform4iv = NULL; +PFNGLUNIFORMMATRIX2FVPROC __glewUniformMatrix2fv = NULL; +PFNGLUNIFORMMATRIX3FVPROC __glewUniformMatrix3fv = NULL; +PFNGLUNIFORMMATRIX4FVPROC __glewUniformMatrix4fv = NULL; +PFNGLUSEPROGRAMPROC __glewUseProgram = NULL; +PFNGLVALIDATEPROGRAMPROC __glewValidateProgram = NULL; +PFNGLVERTEXATTRIB1DPROC __glewVertexAttrib1d = NULL; +PFNGLVERTEXATTRIB1DVPROC __glewVertexAttrib1dv = NULL; +PFNGLVERTEXATTRIB1FPROC __glewVertexAttrib1f = NULL; +PFNGLVERTEXATTRIB1FVPROC __glewVertexAttrib1fv = NULL; +PFNGLVERTEXATTRIB1SPROC __glewVertexAttrib1s = NULL; +PFNGLVERTEXATTRIB1SVPROC __glewVertexAttrib1sv = NULL; +PFNGLVERTEXATTRIB2DPROC __glewVertexAttrib2d = NULL; +PFNGLVERTEXATTRIB2DVPROC __glewVertexAttrib2dv = NULL; +PFNGLVERTEXATTRIB2FPROC __glewVertexAttrib2f = NULL; +PFNGLVERTEXATTRIB2FVPROC __glewVertexAttrib2fv = NULL; +PFNGLVERTEXATTRIB2SPROC __glewVertexAttrib2s = NULL; +PFNGLVERTEXATTRIB2SVPROC __glewVertexAttrib2sv = NULL; +PFNGLVERTEXATTRIB3DPROC __glewVertexAttrib3d = NULL; +PFNGLVERTEXATTRIB3DVPROC __glewVertexAttrib3dv = NULL; +PFNGLVERTEXATTRIB3FPROC __glewVertexAttrib3f = NULL; +PFNGLVERTEXATTRIB3FVPROC __glewVertexAttrib3fv = NULL; +PFNGLVERTEXATTRIB3SPROC __glewVertexAttrib3s = NULL; +PFNGLVERTEXATTRIB3SVPROC __glewVertexAttrib3sv = NULL; +PFNGLVERTEXATTRIB4NBVPROC __glewVertexAttrib4Nbv = NULL; +PFNGLVERTEXATTRIB4NIVPROC __glewVertexAttrib4Niv = NULL; +PFNGLVERTEXATTRIB4NSVPROC __glewVertexAttrib4Nsv = NULL; +PFNGLVERTEXATTRIB4NUBPROC __glewVertexAttrib4Nub = NULL; +PFNGLVERTEXATTRIB4NUBVPROC __glewVertexAttrib4Nubv = NULL; +PFNGLVERTEXATTRIB4NUIVPROC __glewVertexAttrib4Nuiv = NULL; +PFNGLVERTEXATTRIB4NUSVPROC __glewVertexAttrib4Nusv = NULL; +PFNGLVERTEXATTRIB4BVPROC __glewVertexAttrib4bv = NULL; +PFNGLVERTEXATTRIB4DPROC __glewVertexAttrib4d = NULL; +PFNGLVERTEXATTRIB4DVPROC __glewVertexAttrib4dv = NULL; +PFNGLVERTEXATTRIB4FPROC __glewVertexAttrib4f = NULL; +PFNGLVERTEXATTRIB4FVPROC __glewVertexAttrib4fv = NULL; +PFNGLVERTEXATTRIB4IVPROC __glewVertexAttrib4iv = NULL; +PFNGLVERTEXATTRIB4SPROC __glewVertexAttrib4s = NULL; +PFNGLVERTEXATTRIB4SVPROC __glewVertexAttrib4sv = NULL; +PFNGLVERTEXATTRIB4UBVPROC __glewVertexAttrib4ubv = NULL; +PFNGLVERTEXATTRIB4UIVPROC __glewVertexAttrib4uiv = NULL; +PFNGLVERTEXATTRIB4USVPROC __glewVertexAttrib4usv = NULL; +PFNGLVERTEXATTRIBPOINTERPROC __glewVertexAttribPointer = NULL; + +PFNGLUNIFORMMATRIX2X3FVPROC __glewUniformMatrix2x3fv = NULL; +PFNGLUNIFORMMATRIX2X4FVPROC __glewUniformMatrix2x4fv = NULL; +PFNGLUNIFORMMATRIX3X2FVPROC __glewUniformMatrix3x2fv = NULL; +PFNGLUNIFORMMATRIX3X4FVPROC __glewUniformMatrix3x4fv = NULL; +PFNGLUNIFORMMATRIX4X2FVPROC __glewUniformMatrix4x2fv = NULL; +PFNGLUNIFORMMATRIX4X3FVPROC __glewUniformMatrix4x3fv = NULL; + +PFNGLBEGINCONDITIONALRENDERPROC __glewBeginConditionalRender = NULL; +PFNGLBEGINTRANSFORMFEEDBACKPROC __glewBeginTransformFeedback = NULL; +PFNGLBINDBUFFERBASEPROC __glewBindBufferBase = NULL; +PFNGLBINDBUFFERRANGEPROC __glewBindBufferRange = NULL; +PFNGLBINDFRAGDATALOCATIONPROC __glewBindFragDataLocation = NULL; +PFNGLCLAMPCOLORPROC __glewClampColor = NULL; +PFNGLCLEARBUFFERFIPROC __glewClearBufferfi = NULL; +PFNGLCLEARBUFFERFVPROC __glewClearBufferfv = NULL; +PFNGLCLEARBUFFERIVPROC __glewClearBufferiv = NULL; +PFNGLCLEARBUFFERUIVPROC __glewClearBufferuiv = NULL; +PFNGLCOLORMASKIPROC __glewColorMaski = NULL; +PFNGLDISABLEIPROC __glewDisablei = NULL; +PFNGLENABLEIPROC __glewEnablei = NULL; +PFNGLENDCONDITIONALRENDERPROC __glewEndConditionalRender = NULL; +PFNGLENDTRANSFORMFEEDBACKPROC __glewEndTransformFeedback = NULL; +PFNGLGETBOOLEANI_VPROC __glewGetBooleani_v = NULL; +PFNGLGETFRAGDATALOCATIONPROC __glewGetFragDataLocation = NULL; +PFNGLGETINTEGERI_VPROC __glewGetIntegeri_v = NULL; +PFNGLGETSTRINGIPROC __glewGetStringi = NULL; +PFNGLGETTEXPARAMETERIIVPROC __glewGetTexParameterIiv = NULL; +PFNGLGETTEXPARAMETERIUIVPROC __glewGetTexParameterIuiv = NULL; +PFNGLGETTRANSFORMFEEDBACKVARYINGPROC __glewGetTransformFeedbackVarying = NULL; +PFNGLGETUNIFORMUIVPROC __glewGetUniformuiv = NULL; +PFNGLGETVERTEXATTRIBIIVPROC __glewGetVertexAttribIiv = NULL; +PFNGLGETVERTEXATTRIBIUIVPROC __glewGetVertexAttribIuiv = NULL; +PFNGLISENABLEDIPROC __glewIsEnabledi = NULL; +PFNGLTEXPARAMETERIIVPROC __glewTexParameterIiv = NULL; +PFNGLTEXPARAMETERIUIVPROC __glewTexParameterIuiv = NULL; +PFNGLTRANSFORMFEEDBACKVARYINGSPROC __glewTransformFeedbackVaryings = NULL; +PFNGLUNIFORM1UIPROC __glewUniform1ui = NULL; +PFNGLUNIFORM1UIVPROC __glewUniform1uiv = NULL; +PFNGLUNIFORM2UIPROC __glewUniform2ui = NULL; +PFNGLUNIFORM2UIVPROC __glewUniform2uiv = NULL; +PFNGLUNIFORM3UIPROC __glewUniform3ui = NULL; +PFNGLUNIFORM3UIVPROC __glewUniform3uiv = NULL; +PFNGLUNIFORM4UIPROC __glewUniform4ui = NULL; +PFNGLUNIFORM4UIVPROC __glewUniform4uiv = NULL; +PFNGLVERTEXATTRIBI1IPROC __glewVertexAttribI1i = NULL; +PFNGLVERTEXATTRIBI1IVPROC __glewVertexAttribI1iv = NULL; +PFNGLVERTEXATTRIBI1UIPROC __glewVertexAttribI1ui = NULL; +PFNGLVERTEXATTRIBI1UIVPROC __glewVertexAttribI1uiv = NULL; +PFNGLVERTEXATTRIBI2IPROC __glewVertexAttribI2i = NULL; +PFNGLVERTEXATTRIBI2IVPROC __glewVertexAttribI2iv = NULL; +PFNGLVERTEXATTRIBI2UIPROC __glewVertexAttribI2ui = NULL; +PFNGLVERTEXATTRIBI2UIVPROC __glewVertexAttribI2uiv = NULL; +PFNGLVERTEXATTRIBI3IPROC __glewVertexAttribI3i = NULL; +PFNGLVERTEXATTRIBI3IVPROC __glewVertexAttribI3iv = NULL; +PFNGLVERTEXATTRIBI3UIPROC __glewVertexAttribI3ui = NULL; +PFNGLVERTEXATTRIBI3UIVPROC __glewVertexAttribI3uiv = NULL; +PFNGLVERTEXATTRIBI4BVPROC __glewVertexAttribI4bv = NULL; +PFNGLVERTEXATTRIBI4IPROC __glewVertexAttribI4i = NULL; +PFNGLVERTEXATTRIBI4IVPROC __glewVertexAttribI4iv = NULL; +PFNGLVERTEXATTRIBI4SVPROC __glewVertexAttribI4sv = NULL; +PFNGLVERTEXATTRIBI4UBVPROC __glewVertexAttribI4ubv = NULL; +PFNGLVERTEXATTRIBI4UIPROC __glewVertexAttribI4ui = NULL; +PFNGLVERTEXATTRIBI4UIVPROC __glewVertexAttribI4uiv = NULL; +PFNGLVERTEXATTRIBI4USVPROC __glewVertexAttribI4usv = NULL; +PFNGLVERTEXATTRIBIPOINTERPROC __glewVertexAttribIPointer = NULL; + +PFNGLTBUFFERMASK3DFXPROC __glewTbufferMask3DFX = NULL; + +PFNGLDRAWELEMENTARRAYAPPLEPROC __glewDrawElementArrayAPPLE = NULL; +PFNGLDRAWRANGEELEMENTARRAYAPPLEPROC __glewDrawRangeElementArrayAPPLE = NULL; +PFNGLELEMENTPOINTERAPPLEPROC __glewElementPointerAPPLE = NULL; +PFNGLMULTIDRAWELEMENTARRAYAPPLEPROC __glewMultiDrawElementArrayAPPLE = NULL; +PFNGLMULTIDRAWRANGEELEMENTARRAYAPPLEPROC __glewMultiDrawRangeElementArrayAPPLE = NULL; + +PFNGLDELETEFENCESAPPLEPROC __glewDeleteFencesAPPLE = NULL; +PFNGLFINISHFENCEAPPLEPROC __glewFinishFenceAPPLE = NULL; +PFNGLFINISHOBJECTAPPLEPROC __glewFinishObjectAPPLE = NULL; +PFNGLGENFENCESAPPLEPROC __glewGenFencesAPPLE = NULL; +PFNGLISFENCEAPPLEPROC __glewIsFenceAPPLE = NULL; +PFNGLSETFENCEAPPLEPROC __glewSetFenceAPPLE = NULL; +PFNGLTESTFENCEAPPLEPROC __glewTestFenceAPPLE = NULL; +PFNGLTESTOBJECTAPPLEPROC __glewTestObjectAPPLE = NULL; + +PFNGLBUFFERPARAMETERIAPPLEPROC __glewBufferParameteriAPPLE = NULL; +PFNGLFLUSHMAPPEDBUFFERRANGEAPPLEPROC __glewFlushMappedBufferRangeAPPLE = NULL; + +PFNGLGETTEXPARAMETERPOINTERVAPPLEPROC __glewGetTexParameterPointervAPPLE = NULL; +PFNGLTEXTURERANGEAPPLEPROC __glewTextureRangeAPPLE = NULL; + +PFNGLBINDVERTEXARRAYAPPLEPROC __glewBindVertexArrayAPPLE = NULL; +PFNGLDELETEVERTEXARRAYSAPPLEPROC __glewDeleteVertexArraysAPPLE = NULL; +PFNGLGENVERTEXARRAYSAPPLEPROC __glewGenVertexArraysAPPLE = NULL; +PFNGLISVERTEXARRAYAPPLEPROC __glewIsVertexArrayAPPLE = NULL; + +PFNGLFLUSHVERTEXARRAYRANGEAPPLEPROC __glewFlushVertexArrayRangeAPPLE = NULL; +PFNGLVERTEXARRAYPARAMETERIAPPLEPROC __glewVertexArrayParameteriAPPLE = NULL; +PFNGLVERTEXARRAYRANGEAPPLEPROC __glewVertexArrayRangeAPPLE = NULL; + +PFNGLCLAMPCOLORARBPROC __glewClampColorARB = NULL; + +PFNGLDRAWBUFFERSARBPROC __glewDrawBuffersARB = NULL; + +PFNGLDRAWARRAYSINSTANCEDARBPROC __glewDrawArraysInstancedARB = NULL; +PFNGLDRAWELEMENTSINSTANCEDARBPROC __glewDrawElementsInstancedARB = NULL; + +PFNGLBINDFRAMEBUFFERPROC __glewBindFramebuffer = NULL; +PFNGLBINDRENDERBUFFERPROC __glewBindRenderbuffer = NULL; +PFNGLBLITFRAMEBUFFERPROC __glewBlitFramebuffer = NULL; +PFNGLCHECKFRAMEBUFFERSTATUSPROC __glewCheckFramebufferStatus = NULL; +PFNGLDELETEFRAMEBUFFERSPROC __glewDeleteFramebuffers = NULL; +PFNGLDELETERENDERBUFFERSPROC __glewDeleteRenderbuffers = NULL; +PFNGLFRAMEBUFFERRENDERBUFFERPROC __glewFramebufferRenderbuffer = NULL; +PFNGLFRAMEBUFFERTEXTURLAYERPROC __glewFramebufferTexturLayer = NULL; +PFNGLFRAMEBUFFERTEXTURE1DPROC __glewFramebufferTexture1D = NULL; +PFNGLFRAMEBUFFERTEXTURE2DPROC __glewFramebufferTexture2D = NULL; +PFNGLFRAMEBUFFERTEXTURE3DPROC __glewFramebufferTexture3D = NULL; +PFNGLGENFRAMEBUFFERSPROC __glewGenFramebuffers = NULL; +PFNGLGENRENDERBUFFERSPROC __glewGenRenderbuffers = NULL; +PFNGLGENERATEMIPMAPPROC __glewGenerateMipmap = NULL; +PFNGLGETFRAMEBUFFERATTACHMENTPARAMETERIVPROC __glewGetFramebufferAttachmentParameteriv = NULL; +PFNGLGETRENDERBUFFERPARAMETERIVPROC __glewGetRenderbufferParameteriv = NULL; +PFNGLISFRAMEBUFFERPROC __glewIsFramebuffer = NULL; +PFNGLISRENDERBUFFERPROC __glewIsRenderbuffer = NULL; +PFNGLRENDERBUFFERSTORAGEPROC __glewRenderbufferStorage = NULL; +PFNGLRENDERBUFFERSTORAGEMULTISAMPLEPROC __glewRenderbufferStorageMultisample = NULL; + +PFNGLFRAMEBUFFERTEXTUREARBPROC __glewFramebufferTextureARB = NULL; +PFNGLFRAMEBUFFERTEXTUREFACEARBPROC __glewFramebufferTextureFaceARB = NULL; +PFNGLFRAMEBUFFERTEXTURELAYERARBPROC __glewFramebufferTextureLayerARB = NULL; +PFNGLPROGRAMPARAMETERIARBPROC __glewProgramParameteriARB = NULL; + +PFNGLCOLORSUBTABLEPROC __glewColorSubTable = NULL; +PFNGLCOLORTABLEPROC __glewColorTable = NULL; +PFNGLCOLORTABLEPARAMETERFVPROC __glewColorTableParameterfv = NULL; +PFNGLCOLORTABLEPARAMETERIVPROC __glewColorTableParameteriv = NULL; +PFNGLCONVOLUTIONFILTER1DPROC __glewConvolutionFilter1D = NULL; +PFNGLCONVOLUTIONFILTER2DPROC __glewConvolutionFilter2D = NULL; +PFNGLCONVOLUTIONPARAMETERFPROC __glewConvolutionParameterf = NULL; +PFNGLCONVOLUTIONPARAMETERFVPROC __glewConvolutionParameterfv = NULL; +PFNGLCONVOLUTIONPARAMETERIPROC __glewConvolutionParameteri = NULL; +PFNGLCONVOLUTIONPARAMETERIVPROC __glewConvolutionParameteriv = NULL; +PFNGLCOPYCOLORSUBTABLEPROC __glewCopyColorSubTable = NULL; +PFNGLCOPYCOLORTABLEPROC __glewCopyColorTable = NULL; +PFNGLCOPYCONVOLUTIONFILTER1DPROC __glewCopyConvolutionFilter1D = NULL; +PFNGLCOPYCONVOLUTIONFILTER2DPROC __glewCopyConvolutionFilter2D = NULL; +PFNGLGETCOLORTABLEPROC __glewGetColorTable = NULL; +PFNGLGETCOLORTABLEPARAMETERFVPROC __glewGetColorTableParameterfv = NULL; +PFNGLGETCOLORTABLEPARAMETERIVPROC __glewGetColorTableParameteriv = NULL; +PFNGLGETCONVOLUTIONFILTERPROC __glewGetConvolutionFilter = NULL; +PFNGLGETCONVOLUTIONPARAMETERFVPROC __glewGetConvolutionParameterfv = NULL; +PFNGLGETCONVOLUTIONPARAMETERIVPROC __glewGetConvolutionParameteriv = NULL; +PFNGLGETHISTOGRAMPROC __glewGetHistogram = NULL; +PFNGLGETHISTOGRAMPARAMETERFVPROC __glewGetHistogramParameterfv = NULL; +PFNGLGETHISTOGRAMPARAMETERIVPROC __glewGetHistogramParameteriv = NULL; +PFNGLGETMINMAXPROC __glewGetMinmax = NULL; +PFNGLGETMINMAXPARAMETERFVPROC __glewGetMinmaxParameterfv = NULL; +PFNGLGETMINMAXPARAMETERIVPROC __glewGetMinmaxParameteriv = NULL; +PFNGLGETSEPARABLEFILTERPROC __glewGetSeparableFilter = NULL; +PFNGLHISTOGRAMPROC __glewHistogram = NULL; +PFNGLMINMAXPROC __glewMinmax = NULL; +PFNGLRESETHISTOGRAMPROC __glewResetHistogram = NULL; +PFNGLRESETMINMAXPROC __glewResetMinmax = NULL; +PFNGLSEPARABLEFILTER2DPROC __glewSeparableFilter2D = NULL; + +PFNGLVERTEXATTRIBDIVISORARBPROC __glewVertexAttribDivisorARB = NULL; + +PFNGLFLUSHMAPPEDBUFFERRANGEPROC __glewFlushMappedBufferRange = NULL; +PFNGLMAPBUFFERRANGEPROC __glewMapBufferRange = NULL; + +PFNGLCURRENTPALETTEMATRIXARBPROC __glewCurrentPaletteMatrixARB = NULL; +PFNGLMATRIXINDEXPOINTERARBPROC __glewMatrixIndexPointerARB = NULL; +PFNGLMATRIXINDEXUBVARBPROC __glewMatrixIndexubvARB = NULL; +PFNGLMATRIXINDEXUIVARBPROC __glewMatrixIndexuivARB = NULL; +PFNGLMATRIXINDEXUSVARBPROC __glewMatrixIndexusvARB = NULL; + +PFNGLSAMPLECOVERAGEARBPROC __glewSampleCoverageARB = NULL; + +PFNGLACTIVETEXTUREARBPROC __glewActiveTextureARB = NULL; +PFNGLCLIENTACTIVETEXTUREARBPROC __glewClientActiveTextureARB = NULL; +PFNGLMULTITEXCOORD1DARBPROC __glewMultiTexCoord1dARB = NULL; +PFNGLMULTITEXCOORD1DVARBPROC __glewMultiTexCoord1dvARB = NULL; +PFNGLMULTITEXCOORD1FARBPROC __glewMultiTexCoord1fARB = NULL; +PFNGLMULTITEXCOORD1FVARBPROC __glewMultiTexCoord1fvARB = NULL; +PFNGLMULTITEXCOORD1IARBPROC __glewMultiTexCoord1iARB = NULL; +PFNGLMULTITEXCOORD1IVARBPROC __glewMultiTexCoord1ivARB = NULL; +PFNGLMULTITEXCOORD1SARBPROC __glewMultiTexCoord1sARB = NULL; +PFNGLMULTITEXCOORD1SVARBPROC __glewMultiTexCoord1svARB = NULL; +PFNGLMULTITEXCOORD2DARBPROC __glewMultiTexCoord2dARB = NULL; +PFNGLMULTITEXCOORD2DVARBPROC __glewMultiTexCoord2dvARB = NULL; +PFNGLMULTITEXCOORD2FARBPROC __glewMultiTexCoord2fARB = NULL; +PFNGLMULTITEXCOORD2FVARBPROC __glewMultiTexCoord2fvARB = NULL; +PFNGLMULTITEXCOORD2IARBPROC __glewMultiTexCoord2iARB = NULL; +PFNGLMULTITEXCOORD2IVARBPROC __glewMultiTexCoord2ivARB = NULL; +PFNGLMULTITEXCOORD2SARBPROC __glewMultiTexCoord2sARB = NULL; +PFNGLMULTITEXCOORD2SVARBPROC __glewMultiTexCoord2svARB = NULL; +PFNGLMULTITEXCOORD3DARBPROC __glewMultiTexCoord3dARB = NULL; +PFNGLMULTITEXCOORD3DVARBPROC __glewMultiTexCoord3dvARB = NULL; +PFNGLMULTITEXCOORD3FARBPROC __glewMultiTexCoord3fARB = NULL; +PFNGLMULTITEXCOORD3FVARBPROC __glewMultiTexCoord3fvARB = NULL; +PFNGLMULTITEXCOORD3IARBPROC __glewMultiTexCoord3iARB = NULL; +PFNGLMULTITEXCOORD3IVARBPROC __glewMultiTexCoord3ivARB = NULL; +PFNGLMULTITEXCOORD3SARBPROC __glewMultiTexCoord3sARB = NULL; +PFNGLMULTITEXCOORD3SVARBPROC __glewMultiTexCoord3svARB = NULL; +PFNGLMULTITEXCOORD4DARBPROC __glewMultiTexCoord4dARB = NULL; +PFNGLMULTITEXCOORD4DVARBPROC __glewMultiTexCoord4dvARB = NULL; +PFNGLMULTITEXCOORD4FARBPROC __glewMultiTexCoord4fARB = NULL; +PFNGLMULTITEXCOORD4FVARBPROC __glewMultiTexCoord4fvARB = NULL; +PFNGLMULTITEXCOORD4IARBPROC __glewMultiTexCoord4iARB = NULL; +PFNGLMULTITEXCOORD4IVARBPROC __glewMultiTexCoord4ivARB = NULL; +PFNGLMULTITEXCOORD4SARBPROC __glewMultiTexCoord4sARB = NULL; +PFNGLMULTITEXCOORD4SVARBPROC __glewMultiTexCoord4svARB = NULL; + +PFNGLBEGINQUERYARBPROC __glewBeginQueryARB = NULL; +PFNGLDELETEQUERIESARBPROC __glewDeleteQueriesARB = NULL; +PFNGLENDQUERYARBPROC __glewEndQueryARB = NULL; +PFNGLGENQUERIESARBPROC __glewGenQueriesARB = NULL; +PFNGLGETQUERYOBJECTIVARBPROC __glewGetQueryObjectivARB = NULL; +PFNGLGETQUERYOBJECTUIVARBPROC __glewGetQueryObjectuivARB = NULL; +PFNGLGETQUERYIVARBPROC __glewGetQueryivARB = NULL; +PFNGLISQUERYARBPROC __glewIsQueryARB = NULL; + +PFNGLPOINTPARAMETERFARBPROC __glewPointParameterfARB = NULL; +PFNGLPOINTPARAMETERFVARBPROC __glewPointParameterfvARB = NULL; + +PFNGLATTACHOBJECTARBPROC __glewAttachObjectARB = NULL; +PFNGLCOMPILESHADERARBPROC __glewCompileShaderARB = NULL; +PFNGLCREATEPROGRAMOBJECTARBPROC __glewCreateProgramObjectARB = NULL; +PFNGLCREATESHADEROBJECTARBPROC __glewCreateShaderObjectARB = NULL; +PFNGLDELETEOBJECTARBPROC __glewDeleteObjectARB = NULL; +PFNGLDETACHOBJECTARBPROC __glewDetachObjectARB = NULL; +PFNGLGETACTIVEUNIFORMARBPROC __glewGetActiveUniformARB = NULL; +PFNGLGETATTACHEDOBJECTSARBPROC __glewGetAttachedObjectsARB = NULL; +PFNGLGETHANDLEARBPROC __glewGetHandleARB = NULL; +PFNGLGETINFOLOGARBPROC __glewGetInfoLogARB = NULL; +PFNGLGETOBJECTPARAMETERFVARBPROC __glewGetObjectParameterfvARB = NULL; +PFNGLGETOBJECTPARAMETERIVARBPROC __glewGetObjectParameterivARB = NULL; +PFNGLGETSHADERSOURCEARBPROC __glewGetShaderSourceARB = NULL; +PFNGLGETUNIFORMLOCATIONARBPROC __glewGetUniformLocationARB = NULL; +PFNGLGETUNIFORMFVARBPROC __glewGetUniformfvARB = NULL; +PFNGLGETUNIFORMIVARBPROC __glewGetUniformivARB = NULL; +PFNGLLINKPROGRAMARBPROC __glewLinkProgramARB = NULL; +PFNGLSHADERSOURCEARBPROC __glewShaderSourceARB = NULL; +PFNGLUNIFORM1FARBPROC __glewUniform1fARB = NULL; +PFNGLUNIFORM1FVARBPROC __glewUniform1fvARB = NULL; +PFNGLUNIFORM1IARBPROC __glewUniform1iARB = NULL; +PFNGLUNIFORM1IVARBPROC __glewUniform1ivARB = NULL; +PFNGLUNIFORM2FARBPROC __glewUniform2fARB = NULL; +PFNGLUNIFORM2FVARBPROC __glewUniform2fvARB = NULL; +PFNGLUNIFORM2IARBPROC __glewUniform2iARB = NULL; +PFNGLUNIFORM2IVARBPROC __glewUniform2ivARB = NULL; +PFNGLUNIFORM3FARBPROC __glewUniform3fARB = NULL; +PFNGLUNIFORM3FVARBPROC __glewUniform3fvARB = NULL; +PFNGLUNIFORM3IARBPROC __glewUniform3iARB = NULL; +PFNGLUNIFORM3IVARBPROC __glewUniform3ivARB = NULL; +PFNGLUNIFORM4FARBPROC __glewUniform4fARB = NULL; +PFNGLUNIFORM4FVARBPROC __glewUniform4fvARB = NULL; +PFNGLUNIFORM4IARBPROC __glewUniform4iARB = NULL; +PFNGLUNIFORM4IVARBPROC __glewUniform4ivARB = NULL; +PFNGLUNIFORMMATRIX2FVARBPROC __glewUniformMatrix2fvARB = NULL; +PFNGLUNIFORMMATRIX3FVARBPROC __glewUniformMatrix3fvARB = NULL; +PFNGLUNIFORMMATRIX4FVARBPROC __glewUniformMatrix4fvARB = NULL; +PFNGLUSEPROGRAMOBJECTARBPROC __glewUseProgramObjectARB = NULL; +PFNGLVALIDATEPROGRAMARBPROC __glewValidateProgramARB = NULL; + +PFNGLTEXBUFFERARBPROC __glewTexBufferARB = NULL; + +PFNGLCOMPRESSEDTEXIMAGE1DARBPROC __glewCompressedTexImage1DARB = NULL; +PFNGLCOMPRESSEDTEXIMAGE2DARBPROC __glewCompressedTexImage2DARB = NULL; +PFNGLCOMPRESSEDTEXIMAGE3DARBPROC __glewCompressedTexImage3DARB = NULL; +PFNGLCOMPRESSEDTEXSUBIMAGE1DARBPROC __glewCompressedTexSubImage1DARB = NULL; +PFNGLCOMPRESSEDTEXSUBIMAGE2DARBPROC __glewCompressedTexSubImage2DARB = NULL; +PFNGLCOMPRESSEDTEXSUBIMAGE3DARBPROC __glewCompressedTexSubImage3DARB = NULL; +PFNGLGETCOMPRESSEDTEXIMAGEARBPROC __glewGetCompressedTexImageARB = NULL; + +PFNGLLOADTRANSPOSEMATRIXDARBPROC __glewLoadTransposeMatrixdARB = NULL; +PFNGLLOADTRANSPOSEMATRIXFARBPROC __glewLoadTransposeMatrixfARB = NULL; +PFNGLMULTTRANSPOSEMATRIXDARBPROC __glewMultTransposeMatrixdARB = NULL; +PFNGLMULTTRANSPOSEMATRIXFARBPROC __glewMultTransposeMatrixfARB = NULL; + +PFNGLBINDVERTEXARRAYPROC __glewBindVertexArray = NULL; +PFNGLDELETEVERTEXARRAYSPROC __glewDeleteVertexArrays = NULL; +PFNGLGENVERTEXARRAYSPROC __glewGenVertexArrays = NULL; +PFNGLISVERTEXARRAYPROC __glewIsVertexArray = NULL; + +PFNGLVERTEXBLENDARBPROC __glewVertexBlendARB = NULL; +PFNGLWEIGHTPOINTERARBPROC __glewWeightPointerARB = NULL; +PFNGLWEIGHTBVARBPROC __glewWeightbvARB = NULL; +PFNGLWEIGHTDVARBPROC __glewWeightdvARB = NULL; +PFNGLWEIGHTFVARBPROC __glewWeightfvARB = NULL; +PFNGLWEIGHTIVARBPROC __glewWeightivARB = NULL; +PFNGLWEIGHTSVARBPROC __glewWeightsvARB = NULL; +PFNGLWEIGHTUBVARBPROC __glewWeightubvARB = NULL; +PFNGLWEIGHTUIVARBPROC __glewWeightuivARB = NULL; +PFNGLWEIGHTUSVARBPROC __glewWeightusvARB = NULL; + +PFNGLBINDBUFFERARBPROC __glewBindBufferARB = NULL; +PFNGLBUFFERDATAARBPROC __glewBufferDataARB = NULL; +PFNGLBUFFERSUBDATAARBPROC __glewBufferSubDataARB = NULL; +PFNGLDELETEBUFFERSARBPROC __glewDeleteBuffersARB = NULL; +PFNGLGENBUFFERSARBPROC __glewGenBuffersARB = NULL; +PFNGLGETBUFFERPARAMETERIVARBPROC __glewGetBufferParameterivARB = NULL; +PFNGLGETBUFFERPOINTERVARBPROC __glewGetBufferPointervARB = NULL; +PFNGLGETBUFFERSUBDATAARBPROC __glewGetBufferSubDataARB = NULL; +PFNGLISBUFFERARBPROC __glewIsBufferARB = NULL; +PFNGLMAPBUFFERARBPROC __glewMapBufferARB = NULL; +PFNGLUNMAPBUFFERARBPROC __glewUnmapBufferARB = NULL; + +PFNGLBINDPROGRAMARBPROC __glewBindProgramARB = NULL; +PFNGLDELETEPROGRAMSARBPROC __glewDeleteProgramsARB = NULL; +PFNGLDISABLEVERTEXATTRIBARRAYARBPROC __glewDisableVertexAttribArrayARB = NULL; +PFNGLENABLEVERTEXATTRIBARRAYARBPROC __glewEnableVertexAttribArrayARB = NULL; +PFNGLGENPROGRAMSARBPROC __glewGenProgramsARB = NULL; +PFNGLGETPROGRAMENVPARAMETERDVARBPROC __glewGetProgramEnvParameterdvARB = NULL; +PFNGLGETPROGRAMENVPARAMETERFVARBPROC __glewGetProgramEnvParameterfvARB = NULL; +PFNGLGETPROGRAMLOCALPARAMETERDVARBPROC __glewGetProgramLocalParameterdvARB = NULL; +PFNGLGETPROGRAMLOCALPARAMETERFVARBPROC __glewGetProgramLocalParameterfvARB = NULL; +PFNGLGETPROGRAMSTRINGARBPROC __glewGetProgramStringARB = NULL; +PFNGLGETPROGRAMIVARBPROC __glewGetProgramivARB = NULL; +PFNGLGETVERTEXATTRIBPOINTERVARBPROC __glewGetVertexAttribPointervARB = NULL; +PFNGLGETVERTEXATTRIBDVARBPROC __glewGetVertexAttribdvARB = NULL; +PFNGLGETVERTEXATTRIBFVARBPROC __glewGetVertexAttribfvARB = NULL; +PFNGLGETVERTEXATTRIBIVARBPROC __glewGetVertexAttribivARB = NULL; +PFNGLISPROGRAMARBPROC __glewIsProgramARB = NULL; +PFNGLPROGRAMENVPARAMETER4DARBPROC __glewProgramEnvParameter4dARB = NULL; +PFNGLPROGRAMENVPARAMETER4DVARBPROC __glewProgramEnvParameter4dvARB = NULL; +PFNGLPROGRAMENVPARAMETER4FARBPROC __glewProgramEnvParameter4fARB = NULL; +PFNGLPROGRAMENVPARAMETER4FVARBPROC __glewProgramEnvParameter4fvARB = NULL; +PFNGLPROGRAMLOCALPARAMETER4DARBPROC __glewProgramLocalParameter4dARB = NULL; +PFNGLPROGRAMLOCALPARAMETER4DVARBPROC __glewProgramLocalParameter4dvARB = NULL; +PFNGLPROGRAMLOCALPARAMETER4FARBPROC __glewProgramLocalParameter4fARB = NULL; +PFNGLPROGRAMLOCALPARAMETER4FVARBPROC __glewProgramLocalParameter4fvARB = NULL; +PFNGLPROGRAMSTRINGARBPROC __glewProgramStringARB = NULL; +PFNGLVERTEXATTRIB1DARBPROC __glewVertexAttrib1dARB = NULL; +PFNGLVERTEXATTRIB1DVARBPROC __glewVertexAttrib1dvARB = NULL; +PFNGLVERTEXATTRIB1FARBPROC __glewVertexAttrib1fARB = NULL; +PFNGLVERTEXATTRIB1FVARBPROC __glewVertexAttrib1fvARB = NULL; +PFNGLVERTEXATTRIB1SARBPROC __glewVertexAttrib1sARB = NULL; +PFNGLVERTEXATTRIB1SVARBPROC __glewVertexAttrib1svARB = NULL; +PFNGLVERTEXATTRIB2DARBPROC __glewVertexAttrib2dARB = NULL; +PFNGLVERTEXATTRIB2DVARBPROC __glewVertexAttrib2dvARB = NULL; +PFNGLVERTEXATTRIB2FARBPROC __glewVertexAttrib2fARB = NULL; +PFNGLVERTEXATTRIB2FVARBPROC __glewVertexAttrib2fvARB = NULL; +PFNGLVERTEXATTRIB2SARBPROC __glewVertexAttrib2sARB = NULL; +PFNGLVERTEXATTRIB2SVARBPROC __glewVertexAttrib2svARB = NULL; +PFNGLVERTEXATTRIB3DARBPROC __glewVertexAttrib3dARB = NULL; +PFNGLVERTEXATTRIB3DVARBPROC __glewVertexAttrib3dvARB = NULL; +PFNGLVERTEXATTRIB3FARBPROC __glewVertexAttrib3fARB = NULL; +PFNGLVERTEXATTRIB3FVARBPROC __glewVertexAttrib3fvARB = NULL; +PFNGLVERTEXATTRIB3SARBPROC __glewVertexAttrib3sARB = NULL; +PFNGLVERTEXATTRIB3SVARBPROC __glewVertexAttrib3svARB = NULL; +PFNGLVERTEXATTRIB4NBVARBPROC __glewVertexAttrib4NbvARB = NULL; +PFNGLVERTEXATTRIB4NIVARBPROC __glewVertexAttrib4NivARB = NULL; +PFNGLVERTEXATTRIB4NSVARBPROC __glewVertexAttrib4NsvARB = NULL; +PFNGLVERTEXATTRIB4NUBARBPROC __glewVertexAttrib4NubARB = NULL; +PFNGLVERTEXATTRIB4NUBVARBPROC __glewVertexAttrib4NubvARB = NULL; +PFNGLVERTEXATTRIB4NUIVARBPROC __glewVertexAttrib4NuivARB = NULL; +PFNGLVERTEXATTRIB4NUSVARBPROC __glewVertexAttrib4NusvARB = NULL; +PFNGLVERTEXATTRIB4BVARBPROC __glewVertexAttrib4bvARB = NULL; +PFNGLVERTEXATTRIB4DARBPROC __glewVertexAttrib4dARB = NULL; +PFNGLVERTEXATTRIB4DVARBPROC __glewVertexAttrib4dvARB = NULL; +PFNGLVERTEXATTRIB4FARBPROC __glewVertexAttrib4fARB = NULL; +PFNGLVERTEXATTRIB4FVARBPROC __glewVertexAttrib4fvARB = NULL; +PFNGLVERTEXATTRIB4IVARBPROC __glewVertexAttrib4ivARB = NULL; +PFNGLVERTEXATTRIB4SARBPROC __glewVertexAttrib4sARB = NULL; +PFNGLVERTEXATTRIB4SVARBPROC __glewVertexAttrib4svARB = NULL; +PFNGLVERTEXATTRIB4UBVARBPROC __glewVertexAttrib4ubvARB = NULL; +PFNGLVERTEXATTRIB4UIVARBPROC __glewVertexAttrib4uivARB = NULL; +PFNGLVERTEXATTRIB4USVARBPROC __glewVertexAttrib4usvARB = NULL; +PFNGLVERTEXATTRIBPOINTERARBPROC __glewVertexAttribPointerARB = NULL; + +PFNGLBINDATTRIBLOCATIONARBPROC __glewBindAttribLocationARB = NULL; +PFNGLGETACTIVEATTRIBARBPROC __glewGetActiveAttribARB = NULL; +PFNGLGETATTRIBLOCATIONARBPROC __glewGetAttribLocationARB = NULL; + +PFNGLWINDOWPOS2DARBPROC __glewWindowPos2dARB = NULL; +PFNGLWINDOWPOS2DVARBPROC __glewWindowPos2dvARB = NULL; +PFNGLWINDOWPOS2FARBPROC __glewWindowPos2fARB = NULL; +PFNGLWINDOWPOS2FVARBPROC __glewWindowPos2fvARB = NULL; +PFNGLWINDOWPOS2IARBPROC __glewWindowPos2iARB = NULL; +PFNGLWINDOWPOS2IVARBPROC __glewWindowPos2ivARB = NULL; +PFNGLWINDOWPOS2SARBPROC __glewWindowPos2sARB = NULL; +PFNGLWINDOWPOS2SVARBPROC __glewWindowPos2svARB = NULL; +PFNGLWINDOWPOS3DARBPROC __glewWindowPos3dARB = NULL; +PFNGLWINDOWPOS3DVARBPROC __glewWindowPos3dvARB = NULL; +PFNGLWINDOWPOS3FARBPROC __glewWindowPos3fARB = NULL; +PFNGLWINDOWPOS3FVARBPROC __glewWindowPos3fvARB = NULL; +PFNGLWINDOWPOS3IARBPROC __glewWindowPos3iARB = NULL; +PFNGLWINDOWPOS3IVARBPROC __glewWindowPos3ivARB = NULL; +PFNGLWINDOWPOS3SARBPROC __glewWindowPos3sARB = NULL; +PFNGLWINDOWPOS3SVARBPROC __glewWindowPos3svARB = NULL; + +PFNGLDRAWBUFFERSATIPROC __glewDrawBuffersATI = NULL; + +PFNGLDRAWELEMENTARRAYATIPROC __glewDrawElementArrayATI = NULL; +PFNGLDRAWRANGEELEMENTARRAYATIPROC __glewDrawRangeElementArrayATI = NULL; +PFNGLELEMENTPOINTERATIPROC __glewElementPointerATI = NULL; + +PFNGLGETTEXBUMPPARAMETERFVATIPROC __glewGetTexBumpParameterfvATI = NULL; +PFNGLGETTEXBUMPPARAMETERIVATIPROC __glewGetTexBumpParameterivATI = NULL; +PFNGLTEXBUMPPARAMETERFVATIPROC __glewTexBumpParameterfvATI = NULL; +PFNGLTEXBUMPPARAMETERIVATIPROC __glewTexBumpParameterivATI = NULL; + +PFNGLALPHAFRAGMENTOP1ATIPROC __glewAlphaFragmentOp1ATI = NULL; +PFNGLALPHAFRAGMENTOP2ATIPROC __glewAlphaFragmentOp2ATI = NULL; +PFNGLALPHAFRAGMENTOP3ATIPROC __glewAlphaFragmentOp3ATI = NULL; +PFNGLBEGINFRAGMENTSHADERATIPROC __glewBeginFragmentShaderATI = NULL; +PFNGLBINDFRAGMENTSHADERATIPROC __glewBindFragmentShaderATI = NULL; +PFNGLCOLORFRAGMENTOP1ATIPROC __glewColorFragmentOp1ATI = NULL; +PFNGLCOLORFRAGMENTOP2ATIPROC __glewColorFragmentOp2ATI = NULL; +PFNGLCOLORFRAGMENTOP3ATIPROC __glewColorFragmentOp3ATI = NULL; +PFNGLDELETEFRAGMENTSHADERATIPROC __glewDeleteFragmentShaderATI = NULL; +PFNGLENDFRAGMENTSHADERATIPROC __glewEndFragmentShaderATI = NULL; +PFNGLGENFRAGMENTSHADERSATIPROC __glewGenFragmentShadersATI = NULL; +PFNGLPASSTEXCOORDATIPROC __glewPassTexCoordATI = NULL; +PFNGLSAMPLEMAPATIPROC __glewSampleMapATI = NULL; +PFNGLSETFRAGMENTSHADERCONSTANTATIPROC __glewSetFragmentShaderConstantATI = NULL; + +PFNGLMAPOBJECTBUFFERATIPROC __glewMapObjectBufferATI = NULL; +PFNGLUNMAPOBJECTBUFFERATIPROC __glewUnmapObjectBufferATI = NULL; + +PFNGLPNTRIANGLESFATIPROC __glPNTrianglewesfATI = NULL; +PFNGLPNTRIANGLESIATIPROC __glPNTrianglewesiATI = NULL; + +PFNGLSTENCILFUNCSEPARATEATIPROC __glewStencilFuncSeparateATI = NULL; +PFNGLSTENCILOPSEPARATEATIPROC __glewStencilOpSeparateATI = NULL; + +PFNGLARRAYOBJECTATIPROC __glewArrayObjectATI = NULL; +PFNGLFREEOBJECTBUFFERATIPROC __glewFreeObjectBufferATI = NULL; +PFNGLGETARRAYOBJECTFVATIPROC __glewGetArrayObjectfvATI = NULL; +PFNGLGETARRAYOBJECTIVATIPROC __glewGetArrayObjectivATI = NULL; +PFNGLGETOBJECTBUFFERFVATIPROC __glewGetObjectBufferfvATI = NULL; +PFNGLGETOBJECTBUFFERIVATIPROC __glewGetObjectBufferivATI = NULL; +PFNGLGETVARIANTARRAYOBJECTFVATIPROC __glewGetVariantArrayObjectfvATI = NULL; +PFNGLGETVARIANTARRAYOBJECTIVATIPROC __glewGetVariantArrayObjectivATI = NULL; +PFNGLISOBJECTBUFFERATIPROC __glewIsObjectBufferATI = NULL; +PFNGLNEWOBJECTBUFFERATIPROC __glewNewObjectBufferATI = NULL; +PFNGLUPDATEOBJECTBUFFERATIPROC __glewUpdateObjectBufferATI = NULL; +PFNGLVARIANTARRAYOBJECTATIPROC __glewVariantArrayObjectATI = NULL; + +PFNGLGETVERTEXATTRIBARRAYOBJECTFVATIPROC __glewGetVertexAttribArrayObjectfvATI = NULL; +PFNGLGETVERTEXATTRIBARRAYOBJECTIVATIPROC __glewGetVertexAttribArrayObjectivATI = NULL; +PFNGLVERTEXATTRIBARRAYOBJECTATIPROC __glewVertexAttribArrayObjectATI = NULL; + +PFNGLCLIENTACTIVEVERTEXSTREAMATIPROC __glewClientActiveVertexStreamATI = NULL; +PFNGLNORMALSTREAM3BATIPROC __glewNormalStream3bATI = NULL; +PFNGLNORMALSTREAM3BVATIPROC __glewNormalStream3bvATI = NULL; +PFNGLNORMALSTREAM3DATIPROC __glewNormalStream3dATI = NULL; +PFNGLNORMALSTREAM3DVATIPROC __glewNormalStream3dvATI = NULL; +PFNGLNORMALSTREAM3FATIPROC __glewNormalStream3fATI = NULL; +PFNGLNORMALSTREAM3FVATIPROC __glewNormalStream3fvATI = NULL; +PFNGLNORMALSTREAM3IATIPROC __glewNormalStream3iATI = NULL; +PFNGLNORMALSTREAM3IVATIPROC __glewNormalStream3ivATI = NULL; +PFNGLNORMALSTREAM3SATIPROC __glewNormalStream3sATI = NULL; +PFNGLNORMALSTREAM3SVATIPROC __glewNormalStream3svATI = NULL; +PFNGLVERTEXBLENDENVFATIPROC __glewVertexBlendEnvfATI = NULL; +PFNGLVERTEXBLENDENVIATIPROC __glewVertexBlendEnviATI = NULL; +PFNGLVERTEXSTREAM2DATIPROC __glewVertexStream2dATI = NULL; +PFNGLVERTEXSTREAM2DVATIPROC __glewVertexStream2dvATI = NULL; +PFNGLVERTEXSTREAM2FATIPROC __glewVertexStream2fATI = NULL; +PFNGLVERTEXSTREAM2FVATIPROC __glewVertexStream2fvATI = NULL; +PFNGLVERTEXSTREAM2IATIPROC __glewVertexStream2iATI = NULL; +PFNGLVERTEXSTREAM2IVATIPROC __glewVertexStream2ivATI = NULL; +PFNGLVERTEXSTREAM2SATIPROC __glewVertexStream2sATI = NULL; +PFNGLVERTEXSTREAM2SVATIPROC __glewVertexStream2svATI = NULL; +PFNGLVERTEXSTREAM3DATIPROC __glewVertexStream3dATI = NULL; +PFNGLVERTEXSTREAM3DVATIPROC __glewVertexStream3dvATI = NULL; +PFNGLVERTEXSTREAM3FATIPROC __glewVertexStream3fATI = NULL; +PFNGLVERTEXSTREAM3FVATIPROC __glewVertexStream3fvATI = NULL; +PFNGLVERTEXSTREAM3IATIPROC __glewVertexStream3iATI = NULL; +PFNGLVERTEXSTREAM3IVATIPROC __glewVertexStream3ivATI = NULL; +PFNGLVERTEXSTREAM3SATIPROC __glewVertexStream3sATI = NULL; +PFNGLVERTEXSTREAM3SVATIPROC __glewVertexStream3svATI = NULL; +PFNGLVERTEXSTREAM4DATIPROC __glewVertexStream4dATI = NULL; +PFNGLVERTEXSTREAM4DVATIPROC __glewVertexStream4dvATI = NULL; +PFNGLVERTEXSTREAM4FATIPROC __glewVertexStream4fATI = NULL; +PFNGLVERTEXSTREAM4FVATIPROC __glewVertexStream4fvATI = NULL; +PFNGLVERTEXSTREAM4IATIPROC __glewVertexStream4iATI = NULL; +PFNGLVERTEXSTREAM4IVATIPROC __glewVertexStream4ivATI = NULL; +PFNGLVERTEXSTREAM4SATIPROC __glewVertexStream4sATI = NULL; +PFNGLVERTEXSTREAM4SVATIPROC __glewVertexStream4svATI = NULL; + +PFNGLGETUNIFORMBUFFERSIZEEXTPROC __glewGetUniformBufferSizeEXT = NULL; +PFNGLGETUNIFORMOFFSETEXTPROC __glewGetUniformOffsetEXT = NULL; +PFNGLUNIFORMBUFFEREXTPROC __glewUniformBufferEXT = NULL; + +PFNGLBLENDCOLOREXTPROC __glewBlendColorEXT = NULL; + +PFNGLBLENDEQUATIONSEPARATEEXTPROC __glewBlendEquationSeparateEXT = NULL; + +PFNGLBLENDFUNCSEPARATEEXTPROC __glewBlendFuncSeparateEXT = NULL; + +PFNGLBLENDEQUATIONEXTPROC __glewBlendEquationEXT = NULL; + +PFNGLCOLORSUBTABLEEXTPROC __glewColorSubTableEXT = NULL; +PFNGLCOPYCOLORSUBTABLEEXTPROC __glewCopyColorSubTableEXT = NULL; + +PFNGLLOCKARRAYSEXTPROC __glewLockArraysEXT = NULL; +PFNGLUNLOCKARRAYSEXTPROC __glewUnlockArraysEXT = NULL; + +PFNGLCONVOLUTIONFILTER1DEXTPROC __glewConvolutionFilter1DEXT = NULL; +PFNGLCONVOLUTIONFILTER2DEXTPROC __glewConvolutionFilter2DEXT = NULL; +PFNGLCONVOLUTIONPARAMETERFEXTPROC __glewConvolutionParameterfEXT = NULL; +PFNGLCONVOLUTIONPARAMETERFVEXTPROC __glewConvolutionParameterfvEXT = NULL; +PFNGLCONVOLUTIONPARAMETERIEXTPROC __glewConvolutionParameteriEXT = NULL; +PFNGLCONVOLUTIONPARAMETERIVEXTPROC __glewConvolutionParameterivEXT = NULL; +PFNGLCOPYCONVOLUTIONFILTER1DEXTPROC __glewCopyConvolutionFilter1DEXT = NULL; +PFNGLCOPYCONVOLUTIONFILTER2DEXTPROC __glewCopyConvolutionFilter2DEXT = NULL; +PFNGLGETCONVOLUTIONFILTEREXTPROC __glewGetConvolutionFilterEXT = NULL; +PFNGLGETCONVOLUTIONPARAMETERFVEXTPROC __glewGetConvolutionParameterfvEXT = NULL; +PFNGLGETCONVOLUTIONPARAMETERIVEXTPROC __glewGetConvolutionParameterivEXT = NULL; +PFNGLGETSEPARABLEFILTEREXTPROC __glewGetSeparableFilterEXT = NULL; +PFNGLSEPARABLEFILTER2DEXTPROC __glewSeparableFilter2DEXT = NULL; + +PFNGLBINORMALPOINTEREXTPROC __glewBinormalPointerEXT = NULL; +PFNGLTANGENTPOINTEREXTPROC __glewTangentPointerEXT = NULL; + +PFNGLCOPYTEXIMAGE1DEXTPROC __glewCopyTexImage1DEXT = NULL; +PFNGLCOPYTEXIMAGE2DEXTPROC __glewCopyTexImage2DEXT = NULL; +PFNGLCOPYTEXSUBIMAGE1DEXTPROC __glewCopyTexSubImage1DEXT = NULL; +PFNGLCOPYTEXSUBIMAGE2DEXTPROC __glewCopyTexSubImage2DEXT = NULL; +PFNGLCOPYTEXSUBIMAGE3DEXTPROC __glewCopyTexSubImage3DEXT = NULL; + +PFNGLCULLPARAMETERDVEXTPROC __glewCullParameterdvEXT = NULL; +PFNGLCULLPARAMETERFVEXTPROC __glewCullParameterfvEXT = NULL; + +PFNGLDEPTHBOUNDSEXTPROC __glewDepthBoundsEXT = NULL; + +PFNGLBINDMULTITEXTUREEXTPROC __glewBindMultiTextureEXT = NULL; +PFNGLCHECKNAMEDFRAMEBUFFERSTATUSEXTPROC __glewCheckNamedFramebufferStatusEXT = NULL; +PFNGLCLIENTATTRIBDEFAULTEXTPROC __glewClientAttribDefaultEXT = NULL; +PFNGLCOMPRESSEDMULTITEXIMAGE1DEXTPROC __glewCompressedMultiTexImage1DEXT = NULL; +PFNGLCOMPRESSEDMULTITEXIMAGE2DEXTPROC __glewCompressedMultiTexImage2DEXT = NULL; +PFNGLCOMPRESSEDMULTITEXIMAGE3DEXTPROC __glewCompressedMultiTexImage3DEXT = NULL; +PFNGLCOMPRESSEDMULTITEXSUBIMAGE1DEXTPROC __glewCompressedMultiTexSubImage1DEXT = NULL; +PFNGLCOMPRESSEDMULTITEXSUBIMAGE2DEXTPROC __glewCompressedMultiTexSubImage2DEXT = NULL; +PFNGLCOMPRESSEDMULTITEXSUBIMAGE3DEXTPROC __glewCompressedMultiTexSubImage3DEXT = NULL; +PFNGLCOMPRESSEDTEXTUREIMAGE1DEXTPROC __glewCompressedTextureImage1DEXT = NULL; +PFNGLCOMPRESSEDTEXTUREIMAGE2DEXTPROC __glewCompressedTextureImage2DEXT = NULL; +PFNGLCOMPRESSEDTEXTUREIMAGE3DEXTPROC __glewCompressedTextureImage3DEXT = NULL; +PFNGLCOMPRESSEDTEXTURESUBIMAGE1DEXTPROC __glewCompressedTextureSubImage1DEXT = NULL; +PFNGLCOMPRESSEDTEXTURESUBIMAGE2DEXTPROC __glewCompressedTextureSubImage2DEXT = NULL; +PFNGLCOMPRESSEDTEXTURESUBIMAGE3DEXTPROC __glewCompressedTextureSubImage3DEXT = NULL; +PFNGLCOPYMULTITEXIMAGE1DEXTPROC __glewCopyMultiTexImage1DEXT = NULL; +PFNGLCOPYMULTITEXIMAGE2DEXTPROC __glewCopyMultiTexImage2DEXT = NULL; +PFNGLCOPYMULTITEXSUBIMAGE1DEXTPROC __glewCopyMultiTexSubImage1DEXT = NULL; +PFNGLCOPYMULTITEXSUBIMAGE2DEXTPROC __glewCopyMultiTexSubImage2DEXT = NULL; +PFNGLCOPYMULTITEXSUBIMAGE3DEXTPROC __glewCopyMultiTexSubImage3DEXT = NULL; +PFNGLCOPYTEXTUREIMAGE1DEXTPROC __glewCopyTextureImage1DEXT = NULL; +PFNGLCOPYTEXTUREIMAGE2DEXTPROC __glewCopyTextureImage2DEXT = NULL; +PFNGLCOPYTEXTURESUBIMAGE1DEXTPROC __glewCopyTextureSubImage1DEXT = NULL; +PFNGLCOPYTEXTURESUBIMAGE2DEXTPROC __glewCopyTextureSubImage2DEXT = NULL; +PFNGLCOPYTEXTURESUBIMAGE3DEXTPROC __glewCopyTextureSubImage3DEXT = NULL; +PFNGLDISABLECLIENTSTATEINDEXEDEXTPROC __glewDisableClientStateIndexedEXT = NULL; +PFNGLENABLECLIENTSTATEINDEXEDEXTPROC __glewEnableClientStateIndexedEXT = NULL; +PFNGLFRAMEBUFFERDRAWBUFFEREXTPROC __glewFramebufferDrawBufferEXT = NULL; +PFNGLFRAMEBUFFERDRAWBUFFERSEXTPROC __glewFramebufferDrawBuffersEXT = NULL; +PFNGLFRAMEBUFFERREADBUFFEREXTPROC __glewFramebufferReadBufferEXT = NULL; +PFNGLGENERATEMULTITEXMIPMAPEXTPROC __glewGenerateMultiTexMipmapEXT = NULL; +PFNGLGENERATETEXTUREMIPMAPEXTPROC __glewGenerateTextureMipmapEXT = NULL; +PFNGLGETCOMPRESSEDMULTITEXIMAGEEXTPROC __glewGetCompressedMultiTexImageEXT = NULL; +PFNGLGETCOMPRESSEDTEXTUREIMAGEEXTPROC __glewGetCompressedTextureImageEXT = NULL; +PFNGLGETDOUBLEINDEXEDVEXTPROC __glewGetDoubleIndexedvEXT = NULL; +PFNGLGETFLOATINDEXEDVEXTPROC __glewGetFloatIndexedvEXT = NULL; +PFNGLGETFRAMEBUFFERPARAMETERIVEXTPROC __glewGetFramebufferParameterivEXT = NULL; +PFNGLGETMULTITEXENVFVEXTPROC __glewGetMultiTexEnvfvEXT = NULL; +PFNGLGETMULTITEXENVIVEXTPROC __glewGetMultiTexEnvivEXT = NULL; +PFNGLGETMULTITEXGENDVEXTPROC __glewGetMultiTexGendvEXT = NULL; +PFNGLGETMULTITEXGENFVEXTPROC __glewGetMultiTexGenfvEXT = NULL; +PFNGLGETMULTITEXGENIVEXTPROC __glewGetMultiTexGenivEXT = NULL; +PFNGLGETMULTITEXIMAGEEXTPROC __glewGetMultiTexImageEXT = NULL; +PFNGLGETMULTITEXLEVELPARAMETERFVEXTPROC __glewGetMultiTexLevelParameterfvEXT = NULL; +PFNGLGETMULTITEXLEVELPARAMETERIVEXTPROC __glewGetMultiTexLevelParameterivEXT = NULL; +PFNGLGETMULTITEXPARAMETERIIVEXTPROC __glewGetMultiTexParameterIivEXT = NULL; +PFNGLGETMULTITEXPARAMETERIUIVEXTPROC __glewGetMultiTexParameterIuivEXT = NULL; +PFNGLGETMULTITEXPARAMETERFVEXTPROC __glewGetMultiTexParameterfvEXT = NULL; +PFNGLGETMULTITEXPARAMETERIVEXTPROC __glewGetMultiTexParameterivEXT = NULL; +PFNGLGETNAMEDBUFFERPARAMETERIVEXTPROC __glewGetNamedBufferParameterivEXT = NULL; +PFNGLGETNAMEDBUFFERPOINTERVEXTPROC __glewGetNamedBufferPointervEXT = NULL; +PFNGLGETNAMEDBUFFERSUBDATAEXTPROC __glewGetNamedBufferSubDataEXT = NULL; +PFNGLGETNAMEDFRAMEBUFFERATTACHMENTPARAMETERIVEXTPROC __glewGetNamedFramebufferAttachmentParameterivEXT = NULL; +PFNGLGETNAMEDPROGRAMLOCALPARAMETERIIVEXTPROC __glewGetNamedProgramLocalParameterIivEXT = NULL; +PFNGLGETNAMEDPROGRAMLOCALPARAMETERIUIVEXTPROC __glewGetNamedProgramLocalParameterIuivEXT = NULL; +PFNGLGETNAMEDPROGRAMLOCALPARAMETERDVEXTPROC __glewGetNamedProgramLocalParameterdvEXT = NULL; +PFNGLGETNAMEDPROGRAMLOCALPARAMETERFVEXTPROC __glewGetNamedProgramLocalParameterfvEXT = NULL; +PFNGLGETNAMEDPROGRAMSTRINGEXTPROC __glewGetNamedProgramStringEXT = NULL; +PFNGLGETNAMEDPROGRAMIVEXTPROC __glewGetNamedProgramivEXT = NULL; +PFNGLGETNAMEDRENDERBUFFERPARAMETERIVEXTPROC __glewGetNamedRenderbufferParameterivEXT = NULL; +PFNGLGETPOINTERINDEXEDVEXTPROC __glewGetPointerIndexedvEXT = NULL; +PFNGLGETTEXTUREIMAGEEXTPROC __glewGetTextureImageEXT = NULL; +PFNGLGETTEXTURELEVELPARAMETERFVEXTPROC __glewGetTextureLevelParameterfvEXT = NULL; +PFNGLGETTEXTURELEVELPARAMETERIVEXTPROC __glewGetTextureLevelParameterivEXT = NULL; +PFNGLGETTEXTUREPARAMETERIIVEXTPROC __glewGetTextureParameterIivEXT = NULL; +PFNGLGETTEXTUREPARAMETERIUIVEXTPROC __glewGetTextureParameterIuivEXT = NULL; +PFNGLGETTEXTUREPARAMETERFVEXTPROC __glewGetTextureParameterfvEXT = NULL; +PFNGLGETTEXTUREPARAMETERIVEXTPROC __glewGetTextureParameterivEXT = NULL; +PFNGLMAPNAMEDBUFFEREXTPROC __glewMapNamedBufferEXT = NULL; +PFNGLMATRIXFRUSTUMEXTPROC __glewMatrixFrustumEXT = NULL; +PFNGLMATRIXLOADIDENTITYEXTPROC __glewMatrixLoadIdentityEXT = NULL; +PFNGLMATRIXLOADTRANSPOSEDEXTPROC __glewMatrixLoadTransposedEXT = NULL; +PFNGLMATRIXLOADTRANSPOSEFEXTPROC __glewMatrixLoadTransposefEXT = NULL; +PFNGLMATRIXLOADDEXTPROC __glewMatrixLoaddEXT = NULL; +PFNGLMATRIXLOADFEXTPROC __glewMatrixLoadfEXT = NULL; +PFNGLMATRIXMULTTRANSPOSEDEXTPROC __glewMatrixMultTransposedEXT = NULL; +PFNGLMATRIXMULTTRANSPOSEFEXTPROC __glewMatrixMultTransposefEXT = NULL; +PFNGLMATRIXMULTDEXTPROC __glewMatrixMultdEXT = NULL; +PFNGLMATRIXMULTFEXTPROC __glewMatrixMultfEXT = NULL; +PFNGLMATRIXORTHOEXTPROC __glewMatrixOrthoEXT = NULL; +PFNGLMATRIXPOPEXTPROC __glewMatrixPopEXT = NULL; +PFNGLMATRIXPUSHEXTPROC __glewMatrixPushEXT = NULL; +PFNGLMATRIXROTATEDEXTPROC __glewMatrixRotatedEXT = NULL; +PFNGLMATRIXROTATEFEXTPROC __glewMatrixRotatefEXT = NULL; +PFNGLMATRIXSCALEDEXTPROC __glewMatrixScaledEXT = NULL; +PFNGLMATRIXSCALEFEXTPROC __glewMatrixScalefEXT = NULL; +PFNGLMATRIXTRANSLATEDEXTPROC __glewMatrixTranslatedEXT = NULL; +PFNGLMATRIXTRANSLATEFEXTPROC __glewMatrixTranslatefEXT = NULL; +PFNGLMULTITEXBUFFEREXTPROC __glewMultiTexBufferEXT = NULL; +PFNGLMULTITEXCOORDPOINTEREXTPROC __glewMultiTexCoordPointerEXT = NULL; +PFNGLMULTITEXENVFEXTPROC __glewMultiTexEnvfEXT = NULL; +PFNGLMULTITEXENVFVEXTPROC __glewMultiTexEnvfvEXT = NULL; +PFNGLMULTITEXENVIEXTPROC __glewMultiTexEnviEXT = NULL; +PFNGLMULTITEXENVIVEXTPROC __glewMultiTexEnvivEXT = NULL; +PFNGLMULTITEXGENDEXTPROC __glewMultiTexGendEXT = NULL; +PFNGLMULTITEXGENDVEXTPROC __glewMultiTexGendvEXT = NULL; +PFNGLMULTITEXGENFEXTPROC __glewMultiTexGenfEXT = NULL; +PFNGLMULTITEXGENFVEXTPROC __glewMultiTexGenfvEXT = NULL; +PFNGLMULTITEXGENIEXTPROC __glewMultiTexGeniEXT = NULL; +PFNGLMULTITEXGENIVEXTPROC __glewMultiTexGenivEXT = NULL; +PFNGLMULTITEXIMAGE1DEXTPROC __glewMultiTexImage1DEXT = NULL; +PFNGLMULTITEXIMAGE2DEXTPROC __glewMultiTexImage2DEXT = NULL; +PFNGLMULTITEXIMAGE3DEXTPROC __glewMultiTexImage3DEXT = NULL; +PFNGLMULTITEXPARAMETERIIVEXTPROC __glewMultiTexParameterIivEXT = NULL; +PFNGLMULTITEXPARAMETERIUIVEXTPROC __glewMultiTexParameterIuivEXT = NULL; +PFNGLMULTITEXPARAMETERFEXTPROC __glewMultiTexParameterfEXT = NULL; +PFNGLMULTITEXPARAMETERFVEXTPROC __glewMultiTexParameterfvEXT = NULL; +PFNGLMULTITEXPARAMETERIEXTPROC __glewMultiTexParameteriEXT = NULL; +PFNGLMULTITEXPARAMETERIVEXTPROC __glewMultiTexParameterivEXT = NULL; +PFNGLMULTITEXRENDERBUFFEREXTPROC __glewMultiTexRenderbufferEXT = NULL; +PFNGLMULTITEXSUBIMAGE1DEXTPROC __glewMultiTexSubImage1DEXT = NULL; +PFNGLMULTITEXSUBIMAGE2DEXTPROC __glewMultiTexSubImage2DEXT = NULL; +PFNGLMULTITEXSUBIMAGE3DEXTPROC __glewMultiTexSubImage3DEXT = NULL; +PFNGLNAMEDBUFFERDATAEXTPROC __glewNamedBufferDataEXT = NULL; +PFNGLNAMEDBUFFERSUBDATAEXTPROC __glewNamedBufferSubDataEXT = NULL; +PFNGLNAMEDFRAMEBUFFERRENDERBUFFEREXTPROC __glewNamedFramebufferRenderbufferEXT = NULL; +PFNGLNAMEDFRAMEBUFFERTEXTURE1DEXTPROC __glewNamedFramebufferTexture1DEXT = NULL; +PFNGLNAMEDFRAMEBUFFERTEXTURE2DEXTPROC __glewNamedFramebufferTexture2DEXT = NULL; +PFNGLNAMEDFRAMEBUFFERTEXTURE3DEXTPROC __glewNamedFramebufferTexture3DEXT = NULL; +PFNGLNAMEDFRAMEBUFFERTEXTUREEXTPROC __glewNamedFramebufferTextureEXT = NULL; +PFNGLNAMEDFRAMEBUFFERTEXTUREFACEEXTPROC __glewNamedFramebufferTextureFaceEXT = NULL; +PFNGLNAMEDFRAMEBUFFERTEXTURELAYEREXTPROC __glewNamedFramebufferTextureLayerEXT = NULL; +PFNGLNAMEDPROGRAMLOCALPARAMETER4DEXTPROC __glewNamedProgramLocalParameter4dEXT = NULL; +PFNGLNAMEDPROGRAMLOCALPARAMETER4DVEXTPROC __glewNamedProgramLocalParameter4dvEXT = NULL; +PFNGLNAMEDPROGRAMLOCALPARAMETER4FEXTPROC __glewNamedProgramLocalParameter4fEXT = NULL; +PFNGLNAMEDPROGRAMLOCALPARAMETER4FVEXTPROC __glewNamedProgramLocalParameter4fvEXT = NULL; +PFNGLNAMEDPROGRAMLOCALPARAMETERI4IEXTPROC __glewNamedProgramLocalParameterI4iEXT = NULL; +PFNGLNAMEDPROGRAMLOCALPARAMETERI4IVEXTPROC __glewNamedProgramLocalParameterI4ivEXT = NULL; +PFNGLNAMEDPROGRAMLOCALPARAMETERI4UIEXTPROC __glewNamedProgramLocalParameterI4uiEXT = NULL; +PFNGLNAMEDPROGRAMLOCALPARAMETERI4UIVEXTPROC __glewNamedProgramLocalParameterI4uivEXT = NULL; +PFNGLNAMEDPROGRAMLOCALPARAMETERS4FVEXTPROC __glewNamedProgramLocalParameters4fvEXT = NULL; +PFNGLNAMEDPROGRAMLOCALPARAMETERSI4IVEXTPROC __glewNamedProgramLocalParametersI4ivEXT = NULL; +PFNGLNAMEDPROGRAMLOCALPARAMETERSI4UIVEXTPROC __glewNamedProgramLocalParametersI4uivEXT = NULL; +PFNGLNAMEDPROGRAMSTRINGEXTPROC __glewNamedProgramStringEXT = NULL; +PFNGLNAMEDRENDERBUFFERSTORAGEEXTPROC __glewNamedRenderbufferStorageEXT = NULL; +PFNGLNAMEDRENDERBUFFERSTORAGEMULTISAMPLECOVERAGEEXTPROC __glewNamedRenderbufferStorageMultisampleCoverageEXT = NULL; +PFNGLNAMEDRENDERBUFFERSTORAGEMULTISAMPLEEXTPROC __glewNamedRenderbufferStorageMultisampleEXT = NULL; +PFNGLPROGRAMUNIFORM1FEXTPROC __glewProgramUniform1fEXT = NULL; +PFNGLPROGRAMUNIFORM1FVEXTPROC __glewProgramUniform1fvEXT = NULL; +PFNGLPROGRAMUNIFORM1IEXTPROC __glewProgramUniform1iEXT = NULL; +PFNGLPROGRAMUNIFORM1IVEXTPROC __glewProgramUniform1ivEXT = NULL; +PFNGLPROGRAMUNIFORM1UIEXTPROC __glewProgramUniform1uiEXT = NULL; +PFNGLPROGRAMUNIFORM1UIVEXTPROC __glewProgramUniform1uivEXT = NULL; +PFNGLPROGRAMUNIFORM2FEXTPROC __glewProgramUniform2fEXT = NULL; +PFNGLPROGRAMUNIFORM2FVEXTPROC __glewProgramUniform2fvEXT = NULL; +PFNGLPROGRAMUNIFORM2IEXTPROC __glewProgramUniform2iEXT = NULL; +PFNGLPROGRAMUNIFORM2IVEXTPROC __glewProgramUniform2ivEXT = NULL; +PFNGLPROGRAMUNIFORM2UIEXTPROC __glewProgramUniform2uiEXT = NULL; +PFNGLPROGRAMUNIFORM2UIVEXTPROC __glewProgramUniform2uivEXT = NULL; +PFNGLPROGRAMUNIFORM3FEXTPROC __glewProgramUniform3fEXT = NULL; +PFNGLPROGRAMUNIFORM3FVEXTPROC __glewProgramUniform3fvEXT = NULL; +PFNGLPROGRAMUNIFORM3IEXTPROC __glewProgramUniform3iEXT = NULL; +PFNGLPROGRAMUNIFORM3IVEXTPROC __glewProgramUniform3ivEXT = NULL; +PFNGLPROGRAMUNIFORM3UIEXTPROC __glewProgramUniform3uiEXT = NULL; +PFNGLPROGRAMUNIFORM3UIVEXTPROC __glewProgramUniform3uivEXT = NULL; +PFNGLPROGRAMUNIFORM4FEXTPROC __glewProgramUniform4fEXT = NULL; +PFNGLPROGRAMUNIFORM4FVEXTPROC __glewProgramUniform4fvEXT = NULL; +PFNGLPROGRAMUNIFORM4IEXTPROC __glewProgramUniform4iEXT = NULL; +PFNGLPROGRAMUNIFORM4IVEXTPROC __glewProgramUniform4ivEXT = NULL; +PFNGLPROGRAMUNIFORM4UIEXTPROC __glewProgramUniform4uiEXT = NULL; +PFNGLPROGRAMUNIFORM4UIVEXTPROC __glewProgramUniform4uivEXT = NULL; +PFNGLPROGRAMUNIFORMMATRIX2FVEXTPROC __glewProgramUniformMatrix2fvEXT = NULL; +PFNGLPROGRAMUNIFORMMATRIX2X3FVEXTPROC __glewProgramUniformMatrix2x3fvEXT = NULL; +PFNGLPROGRAMUNIFORMMATRIX2X4FVEXTPROC __glewProgramUniformMatrix2x4fvEXT = NULL; +PFNGLPROGRAMUNIFORMMATRIX3FVEXTPROC __glewProgramUniformMatrix3fvEXT = NULL; +PFNGLPROGRAMUNIFORMMATRIX3X2FVEXTPROC __glewProgramUniformMatrix3x2fvEXT = NULL; +PFNGLPROGRAMUNIFORMMATRIX3X4FVEXTPROC __glewProgramUniformMatrix3x4fvEXT = NULL; +PFNGLPROGRAMUNIFORMMATRIX4FVEXTPROC __glewProgramUniformMatrix4fvEXT = NULL; +PFNGLPROGRAMUNIFORMMATRIX4X2FVEXTPROC __glewProgramUniformMatrix4x2fvEXT = NULL; +PFNGLPROGRAMUNIFORMMATRIX4X3FVEXTPROC __glewProgramUniformMatrix4x3fvEXT = NULL; +PFNGLPUSHCLIENTATTRIBDEFAULTEXTPROC __glewPushClientAttribDefaultEXT = NULL; +PFNGLTEXTUREBUFFEREXTPROC __glewTextureBufferEXT = NULL; +PFNGLTEXTUREIMAGE1DEXTPROC __glewTextureImage1DEXT = NULL; +PFNGLTEXTUREIMAGE2DEXTPROC __glewTextureImage2DEXT = NULL; +PFNGLTEXTUREIMAGE3DEXTPROC __glewTextureImage3DEXT = NULL; +PFNGLTEXTUREPARAMETERIIVEXTPROC __glewTextureParameterIivEXT = NULL; +PFNGLTEXTUREPARAMETERIUIVEXTPROC __glewTextureParameterIuivEXT = NULL; +PFNGLTEXTUREPARAMETERFEXTPROC __glewTextureParameterfEXT = NULL; +PFNGLTEXTUREPARAMETERFVEXTPROC __glewTextureParameterfvEXT = NULL; +PFNGLTEXTUREPARAMETERIEXTPROC __glewTextureParameteriEXT = NULL; +PFNGLTEXTUREPARAMETERIVEXTPROC __glewTextureParameterivEXT = NULL; +PFNGLTEXTURERENDERBUFFEREXTPROC __glewTextureRenderbufferEXT = NULL; +PFNGLTEXTURESUBIMAGE1DEXTPROC __glewTextureSubImage1DEXT = NULL; +PFNGLTEXTURESUBIMAGE2DEXTPROC __glewTextureSubImage2DEXT = NULL; +PFNGLTEXTURESUBIMAGE3DEXTPROC __glewTextureSubImage3DEXT = NULL; +PFNGLUNMAPNAMEDBUFFEREXTPROC __glewUnmapNamedBufferEXT = NULL; + +PFNGLCOLORMASKINDEXEDEXTPROC __glewColorMaskIndexedEXT = NULL; +PFNGLDISABLEINDEXEDEXTPROC __glewDisableIndexedEXT = NULL; +PFNGLENABLEINDEXEDEXTPROC __glewEnableIndexedEXT = NULL; +PFNGLGETBOOLEANINDEXEDVEXTPROC __glewGetBooleanIndexedvEXT = NULL; +PFNGLGETINTEGERINDEXEDVEXTPROC __glewGetIntegerIndexedvEXT = NULL; +PFNGLISENABLEDINDEXEDEXTPROC __glewIsEnabledIndexedEXT = NULL; + +PFNGLDRAWARRAYSINSTANCEDEXTPROC __glewDrawArraysInstancedEXT = NULL; +PFNGLDRAWELEMENTSINSTANCEDEXTPROC __glewDrawElementsInstancedEXT = NULL; + +PFNGLDRAWRANGEELEMENTSEXTPROC __glewDrawRangeElementsEXT = NULL; + +PFNGLFOGCOORDPOINTEREXTPROC __glewFogCoordPointerEXT = NULL; +PFNGLFOGCOORDDEXTPROC __glewFogCoorddEXT = NULL; +PFNGLFOGCOORDDVEXTPROC __glewFogCoorddvEXT = NULL; +PFNGLFOGCOORDFEXTPROC __glewFogCoordfEXT = NULL; +PFNGLFOGCOORDFVEXTPROC __glewFogCoordfvEXT = NULL; + +PFNGLFRAGMENTCOLORMATERIALEXTPROC __glewFragmentColorMaterialEXT = NULL; +PFNGLFRAGMENTLIGHTMODELFEXTPROC __glewFragmentLightModelfEXT = NULL; +PFNGLFRAGMENTLIGHTMODELFVEXTPROC __glewFragmentLightModelfvEXT = NULL; +PFNGLFRAGMENTLIGHTMODELIEXTPROC __glewFragmentLightModeliEXT = NULL; +PFNGLFRAGMENTLIGHTMODELIVEXTPROC __glewFragmentLightModelivEXT = NULL; +PFNGLFRAGMENTLIGHTFEXTPROC __glewFragmentLightfEXT = NULL; +PFNGLFRAGMENTLIGHTFVEXTPROC __glewFragmentLightfvEXT = NULL; +PFNGLFRAGMENTLIGHTIEXTPROC __glewFragmentLightiEXT = NULL; +PFNGLFRAGMENTLIGHTIVEXTPROC __glewFragmentLightivEXT = NULL; +PFNGLFRAGMENTMATERIALFEXTPROC __glewFragmentMaterialfEXT = NULL; +PFNGLFRAGMENTMATERIALFVEXTPROC __glewFragmentMaterialfvEXT = NULL; +PFNGLFRAGMENTMATERIALIEXTPROC __glewFragmentMaterialiEXT = NULL; +PFNGLFRAGMENTMATERIALIVEXTPROC __glewFragmentMaterialivEXT = NULL; +PFNGLGETFRAGMENTLIGHTFVEXTPROC __glewGetFragmentLightfvEXT = NULL; +PFNGLGETFRAGMENTLIGHTIVEXTPROC __glewGetFragmentLightivEXT = NULL; +PFNGLGETFRAGMENTMATERIALFVEXTPROC __glewGetFragmentMaterialfvEXT = NULL; +PFNGLGETFRAGMENTMATERIALIVEXTPROC __glewGetFragmentMaterialivEXT = NULL; +PFNGLLIGHTENVIEXTPROC __glewLightEnviEXT = NULL; + +PFNGLBLITFRAMEBUFFEREXTPROC __glewBlitFramebufferEXT = NULL; + +PFNGLRENDERBUFFERSTORAGEMULTISAMPLEEXTPROC __glewRenderbufferStorageMultisampleEXT = NULL; + +PFNGLBINDFRAMEBUFFEREXTPROC __glewBindFramebufferEXT = NULL; +PFNGLBINDRENDERBUFFEREXTPROC __glewBindRenderbufferEXT = NULL; +PFNGLCHECKFRAMEBUFFERSTATUSEXTPROC __glewCheckFramebufferStatusEXT = NULL; +PFNGLDELETEFRAMEBUFFERSEXTPROC __glewDeleteFramebuffersEXT = NULL; +PFNGLDELETERENDERBUFFERSEXTPROC __glewDeleteRenderbuffersEXT = NULL; +PFNGLFRAMEBUFFERRENDERBUFFEREXTPROC __glewFramebufferRenderbufferEXT = NULL; +PFNGLFRAMEBUFFERTEXTURE1DEXTPROC __glewFramebufferTexture1DEXT = NULL; +PFNGLFRAMEBUFFERTEXTURE2DEXTPROC __glewFramebufferTexture2DEXT = NULL; +PFNGLFRAMEBUFFERTEXTURE3DEXTPROC __glewFramebufferTexture3DEXT = NULL; +PFNGLGENFRAMEBUFFERSEXTPROC __glewGenFramebuffersEXT = NULL; +PFNGLGENRENDERBUFFERSEXTPROC __glewGenRenderbuffersEXT = NULL; +PFNGLGENERATEMIPMAPEXTPROC __glewGenerateMipmapEXT = NULL; +PFNGLGETFRAMEBUFFERATTACHMENTPARAMETERIVEXTPROC __glewGetFramebufferAttachmentParameterivEXT = NULL; +PFNGLGETRENDERBUFFERPARAMETERIVEXTPROC __glewGetRenderbufferParameterivEXT = NULL; +PFNGLISFRAMEBUFFEREXTPROC __glewIsFramebufferEXT = NULL; +PFNGLISRENDERBUFFEREXTPROC __glewIsRenderbufferEXT = NULL; +PFNGLRENDERBUFFERSTORAGEEXTPROC __glewRenderbufferStorageEXT = NULL; + +PFNGLFRAMEBUFFERTEXTUREEXTPROC __glewFramebufferTextureEXT = NULL; +PFNGLFRAMEBUFFERTEXTUREFACEEXTPROC __glewFramebufferTextureFaceEXT = NULL; +PFNGLFRAMEBUFFERTEXTURELAYEREXTPROC __glewFramebufferTextureLayerEXT = NULL; +PFNGLPROGRAMPARAMETERIEXTPROC __glewProgramParameteriEXT = NULL; + +PFNGLPROGRAMENVPARAMETERS4FVEXTPROC __glewProgramEnvParameters4fvEXT = NULL; +PFNGLPROGRAMLOCALPARAMETERS4FVEXTPROC __glewProgramLocalParameters4fvEXT = NULL; + +PFNGLBINDFRAGDATALOCATIONEXTPROC __glewBindFragDataLocationEXT = NULL; +PFNGLGETFRAGDATALOCATIONEXTPROC __glewGetFragDataLocationEXT = NULL; +PFNGLGETUNIFORMUIVEXTPROC __glewGetUniformuivEXT = NULL; +PFNGLGETVERTEXATTRIBIIVEXTPROC __glewGetVertexAttribIivEXT = NULL; +PFNGLGETVERTEXATTRIBIUIVEXTPROC __glewGetVertexAttribIuivEXT = NULL; +PFNGLUNIFORM1UIEXTPROC __glewUniform1uiEXT = NULL; +PFNGLUNIFORM1UIVEXTPROC __glewUniform1uivEXT = NULL; +PFNGLUNIFORM2UIEXTPROC __glewUniform2uiEXT = NULL; +PFNGLUNIFORM2UIVEXTPROC __glewUniform2uivEXT = NULL; +PFNGLUNIFORM3UIEXTPROC __glewUniform3uiEXT = NULL; +PFNGLUNIFORM3UIVEXTPROC __glewUniform3uivEXT = NULL; +PFNGLUNIFORM4UIEXTPROC __glewUniform4uiEXT = NULL; +PFNGLUNIFORM4UIVEXTPROC __glewUniform4uivEXT = NULL; +PFNGLVERTEXATTRIBI1IEXTPROC __glewVertexAttribI1iEXT = NULL; +PFNGLVERTEXATTRIBI1IVEXTPROC __glewVertexAttribI1ivEXT = NULL; +PFNGLVERTEXATTRIBI1UIEXTPROC __glewVertexAttribI1uiEXT = NULL; +PFNGLVERTEXATTRIBI1UIVEXTPROC __glewVertexAttribI1uivEXT = NULL; +PFNGLVERTEXATTRIBI2IEXTPROC __glewVertexAttribI2iEXT = NULL; +PFNGLVERTEXATTRIBI2IVEXTPROC __glewVertexAttribI2ivEXT = NULL; +PFNGLVERTEXATTRIBI2UIEXTPROC __glewVertexAttribI2uiEXT = NULL; +PFNGLVERTEXATTRIBI2UIVEXTPROC __glewVertexAttribI2uivEXT = NULL; +PFNGLVERTEXATTRIBI3IEXTPROC __glewVertexAttribI3iEXT = NULL; +PFNGLVERTEXATTRIBI3IVEXTPROC __glewVertexAttribI3ivEXT = NULL; +PFNGLVERTEXATTRIBI3UIEXTPROC __glewVertexAttribI3uiEXT = NULL; +PFNGLVERTEXATTRIBI3UIVEXTPROC __glewVertexAttribI3uivEXT = NULL; +PFNGLVERTEXATTRIBI4BVEXTPROC __glewVertexAttribI4bvEXT = NULL; +PFNGLVERTEXATTRIBI4IEXTPROC __glewVertexAttribI4iEXT = NULL; +PFNGLVERTEXATTRIBI4IVEXTPROC __glewVertexAttribI4ivEXT = NULL; +PFNGLVERTEXATTRIBI4SVEXTPROC __glewVertexAttribI4svEXT = NULL; +PFNGLVERTEXATTRIBI4UBVEXTPROC __glewVertexAttribI4ubvEXT = NULL; +PFNGLVERTEXATTRIBI4UIEXTPROC __glewVertexAttribI4uiEXT = NULL; +PFNGLVERTEXATTRIBI4UIVEXTPROC __glewVertexAttribI4uivEXT = NULL; +PFNGLVERTEXATTRIBI4USVEXTPROC __glewVertexAttribI4usvEXT = NULL; +PFNGLVERTEXATTRIBIPOINTEREXTPROC __glewVertexAttribIPointerEXT = NULL; + +PFNGLGETHISTOGRAMEXTPROC __glewGetHistogramEXT = NULL; +PFNGLGETHISTOGRAMPARAMETERFVEXTPROC __glewGetHistogramParameterfvEXT = NULL; +PFNGLGETHISTOGRAMPARAMETERIVEXTPROC __glewGetHistogramParameterivEXT = NULL; +PFNGLGETMINMAXEXTPROC __glewGetMinmaxEXT = NULL; +PFNGLGETMINMAXPARAMETERFVEXTPROC __glewGetMinmaxParameterfvEXT = NULL; +PFNGLGETMINMAXPARAMETERIVEXTPROC __glewGetMinmaxParameterivEXT = NULL; +PFNGLHISTOGRAMEXTPROC __glewHistogramEXT = NULL; +PFNGLMINMAXEXTPROC __glewMinmaxEXT = NULL; +PFNGLRESETHISTOGRAMEXTPROC __glewResetHistogramEXT = NULL; +PFNGLRESETMINMAXEXTPROC __glewResetMinmaxEXT = NULL; + +PFNGLINDEXFUNCEXTPROC __glewIndexFuncEXT = NULL; + +PFNGLINDEXMATERIALEXTPROC __glewIndexMaterialEXT = NULL; + +PFNGLAPPLYTEXTUREEXTPROC __glewApplyTextureEXT = NULL; +PFNGLTEXTURELIGHTEXTPROC __glewTextureLightEXT = NULL; +PFNGLTEXTUREMATERIALEXTPROC __glewTextureMaterialEXT = NULL; + +PFNGLMULTIDRAWARRAYSEXTPROC __glewMultiDrawArraysEXT = NULL; +PFNGLMULTIDRAWELEMENTSEXTPROC __glewMultiDrawElementsEXT = NULL; + +PFNGLSAMPLEMASKEXTPROC __glewSampleMaskEXT = NULL; +PFNGLSAMPLEPATTERNEXTPROC __glewSamplePatternEXT = NULL; + +PFNGLCOLORTABLEEXTPROC __glewColorTableEXT = NULL; +PFNGLGETCOLORTABLEEXTPROC __glewGetColorTableEXT = NULL; +PFNGLGETCOLORTABLEPARAMETERFVEXTPROC __glewGetColorTableParameterfvEXT = NULL; +PFNGLGETCOLORTABLEPARAMETERIVEXTPROC __glewGetColorTableParameterivEXT = NULL; + +PFNGLGETPIXELTRANSFORMPARAMETERFVEXTPROC __glewGetPixelTransformParameterfvEXT = NULL; +PFNGLGETPIXELTRANSFORMPARAMETERIVEXTPROC __glewGetPixelTransformParameterivEXT = NULL; +PFNGLPIXELTRANSFORMPARAMETERFEXTPROC __glewPixelTransformParameterfEXT = NULL; +PFNGLPIXELTRANSFORMPARAMETERFVEXTPROC __glewPixelTransformParameterfvEXT = NULL; +PFNGLPIXELTRANSFORMPARAMETERIEXTPROC __glewPixelTransformParameteriEXT = NULL; +PFNGLPIXELTRANSFORMPARAMETERIVEXTPROC __glewPixelTransformParameterivEXT = NULL; + +PFNGLPOINTPARAMETERFEXTPROC __glewPointParameterfEXT = NULL; +PFNGLPOINTPARAMETERFVEXTPROC __glewPointParameterfvEXT = NULL; + +PFNGLPOLYGONOFFSETEXTPROC __glewPolygonOffsetEXT = NULL; + +PFNGLBEGINSCENEEXTPROC __glewBeginSceneEXT = NULL; +PFNGLENDSCENEEXTPROC __glewEndSceneEXT = NULL; + +PFNGLSECONDARYCOLOR3BEXTPROC __glewSecondaryColor3bEXT = NULL; +PFNGLSECONDARYCOLOR3BVEXTPROC __glewSecondaryColor3bvEXT = NULL; +PFNGLSECONDARYCOLOR3DEXTPROC __glewSecondaryColor3dEXT = NULL; +PFNGLSECONDARYCOLOR3DVEXTPROC __glewSecondaryColor3dvEXT = NULL; +PFNGLSECONDARYCOLOR3FEXTPROC __glewSecondaryColor3fEXT = NULL; +PFNGLSECONDARYCOLOR3FVEXTPROC __glewSecondaryColor3fvEXT = NULL; +PFNGLSECONDARYCOLOR3IEXTPROC __glewSecondaryColor3iEXT = NULL; +PFNGLSECONDARYCOLOR3IVEXTPROC __glewSecondaryColor3ivEXT = NULL; +PFNGLSECONDARYCOLOR3SEXTPROC __glewSecondaryColor3sEXT = NULL; +PFNGLSECONDARYCOLOR3SVEXTPROC __glewSecondaryColor3svEXT = NULL; +PFNGLSECONDARYCOLOR3UBEXTPROC __glewSecondaryColor3ubEXT = NULL; +PFNGLSECONDARYCOLOR3UBVEXTPROC __glewSecondaryColor3ubvEXT = NULL; +PFNGLSECONDARYCOLOR3UIEXTPROC __glewSecondaryColor3uiEXT = NULL; +PFNGLSECONDARYCOLOR3UIVEXTPROC __glewSecondaryColor3uivEXT = NULL; +PFNGLSECONDARYCOLOR3USEXTPROC __glewSecondaryColor3usEXT = NULL; +PFNGLSECONDARYCOLOR3USVEXTPROC __glewSecondaryColor3usvEXT = NULL; +PFNGLSECONDARYCOLORPOINTEREXTPROC __glewSecondaryColorPointerEXT = NULL; + +PFNGLACTIVESTENCILFACEEXTPROC __glewActiveStencilFaceEXT = NULL; + +PFNGLTEXSUBIMAGE1DEXTPROC __glewTexSubImage1DEXT = NULL; +PFNGLTEXSUBIMAGE2DEXTPROC __glewTexSubImage2DEXT = NULL; +PFNGLTEXSUBIMAGE3DEXTPROC __glewTexSubImage3DEXT = NULL; + +PFNGLTEXIMAGE3DEXTPROC __glewTexImage3DEXT = NULL; + +PFNGLTEXBUFFEREXTPROC __glewTexBufferEXT = NULL; + +PFNGLCLEARCOLORIIEXTPROC __glewClearColorIiEXT = NULL; +PFNGLCLEARCOLORIUIEXTPROC __glewClearColorIuiEXT = NULL; +PFNGLGETTEXPARAMETERIIVEXTPROC __glewGetTexParameterIivEXT = NULL; +PFNGLGETTEXPARAMETERIUIVEXTPROC __glewGetTexParameterIuivEXT = NULL; +PFNGLTEXPARAMETERIIVEXTPROC __glewTexParameterIivEXT = NULL; +PFNGLTEXPARAMETERIUIVEXTPROC __glewTexParameterIuivEXT = NULL; + +PFNGLARETEXTURESRESIDENTEXTPROC __glewAreTexturesResidentEXT = NULL; +PFNGLBINDTEXTUREEXTPROC __glewBindTextureEXT = NULL; +PFNGLDELETETEXTURESEXTPROC __glewDeleteTexturesEXT = NULL; +PFNGLGENTEXTURESEXTPROC __glewGenTexturesEXT = NULL; +PFNGLISTEXTUREEXTPROC __glewIsTextureEXT = NULL; +PFNGLPRIORITIZETEXTURESEXTPROC __glewPrioritizeTexturesEXT = NULL; + +PFNGLTEXTURENORMALEXTPROC __glewTextureNormalEXT = NULL; + +//PFNGLGETQUERYOBJECTI64VEXTPROC __glewGetQueryObjecti64vEXT = NULL; +//PFNGLGETQUERYOBJECTUI64VEXTPROC __glewGetQueryObjectui64vEXT = NULL; + +PFNGLBEGINTRANSFORMFEEDBACKEXTPROC __glewBeginTransformFeedbackEXT = NULL; +PFNGLBINDBUFFERBASEEXTPROC __glewBindBufferBaseEXT = NULL; +PFNGLBINDBUFFEROFFSETEXTPROC __glewBindBufferOffsetEXT = NULL; +PFNGLBINDBUFFERRANGEEXTPROC __glewBindBufferRangeEXT = NULL; +PFNGLENDTRANSFORMFEEDBACKEXTPROC __glewEndTransformFeedbackEXT = NULL; +PFNGLGETTRANSFORMFEEDBACKVARYINGEXTPROC __glewGetTransformFeedbackVaryingEXT = NULL; +PFNGLTRANSFORMFEEDBACKVARYINGSEXTPROC __glewTransformFeedbackVaryingsEXT = NULL; + +PFNGLARRAYELEMENTEXTPROC __glewArrayElementEXT = NULL; +PFNGLCOLORPOINTEREXTPROC __glewColorPointerEXT = NULL; +PFNGLDRAWARRAYSEXTPROC __glewDrawArraysEXT = NULL; +PFNGLEDGEFLAGPOINTEREXTPROC __glewEdgeFlagPointerEXT = NULL; +PFNGLGETPOINTERVEXTPROC __glewGetPointervEXT = NULL; +PFNGLINDEXPOINTEREXTPROC __glewIndexPointerEXT = NULL; +PFNGLNORMALPOINTEREXTPROC __glewNormalPointerEXT = NULL; +PFNGLTEXCOORDPOINTEREXTPROC __glewTexCoordPointerEXT = NULL; +PFNGLVERTEXPOINTEREXTPROC __glewVertexPointerEXT = NULL; + +PFNGLBEGINVERTEXSHADEREXTPROC __glewBeginVertexShaderEXT = NULL; +PFNGLBINDLIGHTPARAMETEREXTPROC __glewBindLightParameterEXT = NULL; +PFNGLBINDMATERIALPARAMETEREXTPROC __glewBindMaterialParameterEXT = NULL; +PFNGLBINDPARAMETEREXTPROC __glewBindParameterEXT = NULL; +PFNGLBINDTEXGENPARAMETEREXTPROC __glewBindTexGenParameterEXT = NULL; +PFNGLBINDTEXTUREUNITPARAMETEREXTPROC __glewBindTextureUnitParameterEXT = NULL; +PFNGLBINDVERTEXSHADEREXTPROC __glewBindVertexShaderEXT = NULL; +PFNGLDELETEVERTEXSHADEREXTPROC __glewDeleteVertexShaderEXT = NULL; +PFNGLDISABLEVARIANTCLIENTSTATEEXTPROC __glewDisableVariantClientStateEXT = NULL; +PFNGLENABLEVARIANTCLIENTSTATEEXTPROC __glewEnableVariantClientStateEXT = NULL; +PFNGLENDVERTEXSHADEREXTPROC __glewEndVertexShaderEXT = NULL; +PFNGLEXTRACTCOMPONENTEXTPROC __glewExtractComponentEXT = NULL; +PFNGLGENSYMBOLSEXTPROC __glewGenSymbolsEXT = NULL; +PFNGLGENVERTEXSHADERSEXTPROC __glewGenVertexShadersEXT = NULL; +PFNGLGETINVARIANTBOOLEANVEXTPROC __glewGetInvariantBooleanvEXT = NULL; +PFNGLGETINVARIANTFLOATVEXTPROC __glewGetInvariantFloatvEXT = NULL; +PFNGLGETINVARIANTINTEGERVEXTPROC __glewGetInvariantIntegervEXT = NULL; +PFNGLGETLOCALCONSTANTBOOLEANVEXTPROC __glewGetLocalConstantBooleanvEXT = NULL; +PFNGLGETLOCALCONSTANTFLOATVEXTPROC __glewGetLocalConstantFloatvEXT = NULL; +PFNGLGETLOCALCONSTANTINTEGERVEXTPROC __glewGetLocalConstantIntegervEXT = NULL; +PFNGLGETVARIANTBOOLEANVEXTPROC __glewGetVariantBooleanvEXT = NULL; +PFNGLGETVARIANTFLOATVEXTPROC __glewGetVariantFloatvEXT = NULL; +PFNGLGETVARIANTINTEGERVEXTPROC __glewGetVariantIntegervEXT = NULL; +PFNGLGETVARIANTPOINTERVEXTPROC __glewGetVariantPointervEXT = NULL; +PFNGLINSERTCOMPONENTEXTPROC __glewInsertComponentEXT = NULL; +PFNGLISVARIANTENABLEDEXTPROC __glewIsVariantEnabledEXT = NULL; +PFNGLSETINVARIANTEXTPROC __glewSetInvariantEXT = NULL; +PFNGLSETLOCALCONSTANTEXTPROC __glewSetLocalConstantEXT = NULL; +PFNGLSHADEROP1EXTPROC __glewShaderOp1EXT = NULL; +PFNGLSHADEROP2EXTPROC __glewShaderOp2EXT = NULL; +PFNGLSHADEROP3EXTPROC __glewShaderOp3EXT = NULL; +PFNGLSWIZZLEEXTPROC __glewSwizzleEXT = NULL; +PFNGLVARIANTPOINTEREXTPROC __glewVariantPointerEXT = NULL; +PFNGLVARIANTBVEXTPROC __glewVariantbvEXT = NULL; +PFNGLVARIANTDVEXTPROC __glewVariantdvEXT = NULL; +PFNGLVARIANTFVEXTPROC __glewVariantfvEXT = NULL; +PFNGLVARIANTIVEXTPROC __glewVariantivEXT = NULL; +PFNGLVARIANTSVEXTPROC __glewVariantsvEXT = NULL; +PFNGLVARIANTUBVEXTPROC __glewVariantubvEXT = NULL; +PFNGLVARIANTUIVEXTPROC __glewVariantuivEXT = NULL; +PFNGLVARIANTUSVEXTPROC __glewVariantusvEXT = NULL; +PFNGLWRITEMASKEXTPROC __glewWriteMaskEXT = NULL; + +PFNGLVERTEXWEIGHTPOINTEREXTPROC __glewVertexWeightPointerEXT = NULL; +PFNGLVERTEXWEIGHTFEXTPROC __glewVertexWeightfEXT = NULL; +PFNGLVERTEXWEIGHTFVEXTPROC __glewVertexWeightfvEXT = NULL; + +PFNGLFRAMETERMINATORGREMEDYPROC __glewFrameTerminatorGREMEDY = NULL; + +PFNGLSTRINGMARKERGREMEDYPROC __glewStringMarkerGREMEDY = NULL; + +PFNGLGETIMAGETRANSFORMPARAMETERFVHPPROC __glewGetImageTransformParameterfvHP = NULL; +PFNGLGETIMAGETRANSFORMPARAMETERIVHPPROC __glewGetImageTransformParameterivHP = NULL; +PFNGLIMAGETRANSFORMPARAMETERFHPPROC __glewImageTransformParameterfHP = NULL; +PFNGLIMAGETRANSFORMPARAMETERFVHPPROC __glewImageTransformParameterfvHP = NULL; +PFNGLIMAGETRANSFORMPARAMETERIHPPROC __glewImageTransformParameteriHP = NULL; +PFNGLIMAGETRANSFORMPARAMETERIVHPPROC __glewImageTransformParameterivHP = NULL; + +PFNGLMULTIMODEDRAWARRAYSIBMPROC __glewMultiModeDrawArraysIBM = NULL; +PFNGLMULTIMODEDRAWELEMENTSIBMPROC __glewMultiModeDrawElementsIBM = NULL; + +PFNGLCOLORPOINTERLISTIBMPROC __glewColorPointerListIBM = NULL; +PFNGLEDGEFLAGPOINTERLISTIBMPROC __glewEdgeFlagPointerListIBM = NULL; +PFNGLFOGCOORDPOINTERLISTIBMPROC __glewFogCoordPointerListIBM = NULL; +PFNGLINDEXPOINTERLISTIBMPROC __glewIndexPointerListIBM = NULL; +PFNGLNORMALPOINTERLISTIBMPROC __glewNormalPointerListIBM = NULL; +PFNGLSECONDARYCOLORPOINTERLISTIBMPROC __glewSecondaryColorPointerListIBM = NULL; +PFNGLTEXCOORDPOINTERLISTIBMPROC __glewTexCoordPointerListIBM = NULL; +PFNGLVERTEXPOINTERLISTIBMPROC __glewVertexPointerListIBM = NULL; + +PFNGLCOLORPOINTERVINTELPROC __glewColorPointervINTEL = NULL; +PFNGLNORMALPOINTERVINTELPROC __glewNormalPointervINTEL = NULL; +PFNGLTEXCOORDPOINTERVINTELPROC __glewTexCoordPointervINTEL = NULL; +PFNGLVERTEXPOINTERVINTELPROC __glewVertexPointervINTEL = NULL; + +PFNGLTEXSCISSORFUNCINTELPROC __glewTexScissorFuncINTEL = NULL; +PFNGLTEXSCISSORINTELPROC __glewTexScissorINTEL = NULL; + +PFNGLBUFFERREGIONENABLEDEXTPROC __glewBufferRegionEnabledEXT = NULL; +PFNGLDELETEBUFFERREGIONEXTPROC __glewDeleteBufferRegionEXT = NULL; +PFNGLDRAWBUFFERREGIONEXTPROC __glewDrawBufferRegionEXT = NULL; +PFNGLNEWBUFFERREGIONEXTPROC __glewNewBufferRegionEXT = NULL; +PFNGLREADBUFFERREGIONEXTPROC __glewReadBufferRegionEXT = NULL; + +PFNGLRESIZEBUFFERSMESAPROC __glewResizeBuffersMESA = NULL; + +PFNGLWINDOWPOS2DMESAPROC __glewWindowPos2dMESA = NULL; +PFNGLWINDOWPOS2DVMESAPROC __glewWindowPos2dvMESA = NULL; +PFNGLWINDOWPOS2FMESAPROC __glewWindowPos2fMESA = NULL; +PFNGLWINDOWPOS2FVMESAPROC __glewWindowPos2fvMESA = NULL; +PFNGLWINDOWPOS2IMESAPROC __glewWindowPos2iMESA = NULL; +PFNGLWINDOWPOS2IVMESAPROC __glewWindowPos2ivMESA = NULL; +PFNGLWINDOWPOS2SMESAPROC __glewWindowPos2sMESA = NULL; +PFNGLWINDOWPOS2SVMESAPROC __glewWindowPos2svMESA = NULL; +PFNGLWINDOWPOS3DMESAPROC __glewWindowPos3dMESA = NULL; +PFNGLWINDOWPOS3DVMESAPROC __glewWindowPos3dvMESA = NULL; +PFNGLWINDOWPOS3FMESAPROC __glewWindowPos3fMESA = NULL; +PFNGLWINDOWPOS3FVMESAPROC __glewWindowPos3fvMESA = NULL; +PFNGLWINDOWPOS3IMESAPROC __glewWindowPos3iMESA = NULL; +PFNGLWINDOWPOS3IVMESAPROC __glewWindowPos3ivMESA = NULL; +PFNGLWINDOWPOS3SMESAPROC __glewWindowPos3sMESA = NULL; +PFNGLWINDOWPOS3SVMESAPROC __glewWindowPos3svMESA = NULL; +PFNGLWINDOWPOS4DMESAPROC __glewWindowPos4dMESA = NULL; +PFNGLWINDOWPOS4DVMESAPROC __glewWindowPos4dvMESA = NULL; +PFNGLWINDOWPOS4FMESAPROC __glewWindowPos4fMESA = NULL; +PFNGLWINDOWPOS4FVMESAPROC __glewWindowPos4fvMESA = NULL; +PFNGLWINDOWPOS4IMESAPROC __glewWindowPos4iMESA = NULL; +PFNGLWINDOWPOS4IVMESAPROC __glewWindowPos4ivMESA = NULL; +PFNGLWINDOWPOS4SMESAPROC __glewWindowPos4sMESA = NULL; +PFNGLWINDOWPOS4SVMESAPROC __glewWindowPos4svMESA = NULL; + +PFNGLBEGINCONDITIONALRENDERNVPROC __glewBeginConditionalRenderNV = NULL; +PFNGLENDCONDITIONALRENDERNVPROC __glewEndConditionalRenderNV = NULL; + +PFNGLCLEARDEPTHDNVPROC __glewClearDepthdNV = NULL; +PFNGLDEPTHBOUNDSDNVPROC __glewDepthBoundsdNV = NULL; +PFNGLDEPTHRANGEDNVPROC __glewDepthRangedNV = NULL; + +PFNGLEVALMAPSNVPROC __glewEvalMapsNV = NULL; +PFNGLGETMAPATTRIBPARAMETERFVNVPROC __glewGetMapAttribParameterfvNV = NULL; +PFNGLGETMAPATTRIBPARAMETERIVNVPROC __glewGetMapAttribParameterivNV = NULL; +PFNGLGETMAPCONTROLPOINTSNVPROC __glewGetMapControlPointsNV = NULL; +PFNGLGETMAPPARAMETERFVNVPROC __glewGetMapParameterfvNV = NULL; +PFNGLGETMAPPARAMETERIVNVPROC __glewGetMapParameterivNV = NULL; +PFNGLMAPCONTROLPOINTSNVPROC __glewMapControlPointsNV = NULL; +PFNGLMAPPARAMETERFVNVPROC __glewMapParameterfvNV = NULL; +PFNGLMAPPARAMETERIVNVPROC __glewMapParameterivNV = NULL; + +PFNGLGETMULTISAMPLEFVNVPROC __glewGetMultisamplefvNV = NULL; +PFNGLSAMPLEMASKINDEXEDNVPROC __glewSampleMaskIndexedNV = NULL; +PFNGLTEXRENDERBUFFERNVPROC __glewTexRenderbufferNV = NULL; + +PFNGLDELETEFENCESNVPROC __glewDeleteFencesNV = NULL; +PFNGLFINISHFENCENVPROC __glewFinishFenceNV = NULL; +PFNGLGENFENCESNVPROC __glewGenFencesNV = NULL; +PFNGLGETFENCEIVNVPROC __glewGetFenceivNV = NULL; +PFNGLISFENCENVPROC __glewIsFenceNV = NULL; +PFNGLSETFENCENVPROC __glewSetFenceNV = NULL; +PFNGLTESTFENCENVPROC __glewTestFenceNV = NULL; + +PFNGLGETPROGRAMNAMEDPARAMETERDVNVPROC __glewGetProgramNamedParameterdvNV = NULL; +PFNGLGETPROGRAMNAMEDPARAMETERFVNVPROC __glewGetProgramNamedParameterfvNV = NULL; +PFNGLPROGRAMNAMEDPARAMETER4DNVPROC __glewProgramNamedParameter4dNV = NULL; +PFNGLPROGRAMNAMEDPARAMETER4DVNVPROC __glewProgramNamedParameter4dvNV = NULL; +PFNGLPROGRAMNAMEDPARAMETER4FNVPROC __glewProgramNamedParameter4fNV = NULL; +PFNGLPROGRAMNAMEDPARAMETER4FVNVPROC __glewProgramNamedParameter4fvNV = NULL; + +PFNGLRENDERBUFFERSTORAGEMULTISAMPLECOVERAGENVPROC __glewRenderbufferStorageMultisampleCoverageNV = NULL; + +PFNGLPROGRAMVERTEXLIMITNVPROC __glewProgramVertexLimitNV = NULL; + +PFNGLPROGRAMENVPARAMETERI4INVPROC __glewProgramEnvParameterI4iNV = NULL; +PFNGLPROGRAMENVPARAMETERI4IVNVPROC __glewProgramEnvParameterI4ivNV = NULL; +PFNGLPROGRAMENVPARAMETERI4UINVPROC __glewProgramEnvParameterI4uiNV = NULL; +PFNGLPROGRAMENVPARAMETERI4UIVNVPROC __glewProgramEnvParameterI4uivNV = NULL; +PFNGLPROGRAMENVPARAMETERSI4IVNVPROC __glewProgramEnvParametersI4ivNV = NULL; +PFNGLPROGRAMENVPARAMETERSI4UIVNVPROC __glewProgramEnvParametersI4uivNV = NULL; +PFNGLPROGRAMLOCALPARAMETERI4INVPROC __glewProgramLocalParameterI4iNV = NULL; +PFNGLPROGRAMLOCALPARAMETERI4IVNVPROC __glewProgramLocalParameterI4ivNV = NULL; +PFNGLPROGRAMLOCALPARAMETERI4UINVPROC __glewProgramLocalParameterI4uiNV = NULL; +PFNGLPROGRAMLOCALPARAMETERI4UIVNVPROC __glewProgramLocalParameterI4uivNV = NULL; +PFNGLPROGRAMLOCALPARAMETERSI4IVNVPROC __glewProgramLocalParametersI4ivNV = NULL; +PFNGLPROGRAMLOCALPARAMETERSI4UIVNVPROC __glewProgramLocalParametersI4uivNV = NULL; + +PFNGLCOLOR3HNVPROC __glewColor3hNV = NULL; +PFNGLCOLOR3HVNVPROC __glewColor3hvNV = NULL; +PFNGLCOLOR4HNVPROC __glewColor4hNV = NULL; +PFNGLCOLOR4HVNVPROC __glewColor4hvNV = NULL; +PFNGLFOGCOORDHNVPROC __glewFogCoordhNV = NULL; +PFNGLFOGCOORDHVNVPROC __glewFogCoordhvNV = NULL; +PFNGLMULTITEXCOORD1HNVPROC __glewMultiTexCoord1hNV = NULL; +PFNGLMULTITEXCOORD1HVNVPROC __glewMultiTexCoord1hvNV = NULL; +PFNGLMULTITEXCOORD2HNVPROC __glewMultiTexCoord2hNV = NULL; +PFNGLMULTITEXCOORD2HVNVPROC __glewMultiTexCoord2hvNV = NULL; +PFNGLMULTITEXCOORD3HNVPROC __glewMultiTexCoord3hNV = NULL; +PFNGLMULTITEXCOORD3HVNVPROC __glewMultiTexCoord3hvNV = NULL; +PFNGLMULTITEXCOORD4HNVPROC __glewMultiTexCoord4hNV = NULL; +PFNGLMULTITEXCOORD4HVNVPROC __glewMultiTexCoord4hvNV = NULL; +PFNGLNORMAL3HNVPROC __glewNormal3hNV = NULL; +PFNGLNORMAL3HVNVPROC __glewNormal3hvNV = NULL; +PFNGLSECONDARYCOLOR3HNVPROC __glewSecondaryColor3hNV = NULL; +PFNGLSECONDARYCOLOR3HVNVPROC __glewSecondaryColor3hvNV = NULL; +PFNGLTEXCOORD1HNVPROC __glewTexCoord1hNV = NULL; +PFNGLTEXCOORD1HVNVPROC __glewTexCoord1hvNV = NULL; +PFNGLTEXCOORD2HNVPROC __glewTexCoord2hNV = NULL; +PFNGLTEXCOORD2HVNVPROC __glewTexCoord2hvNV = NULL; +PFNGLTEXCOORD3HNVPROC __glewTexCoord3hNV = NULL; +PFNGLTEXCOORD3HVNVPROC __glewTexCoord3hvNV = NULL; +PFNGLTEXCOORD4HNVPROC __glewTexCoord4hNV = NULL; +PFNGLTEXCOORD4HVNVPROC __glewTexCoord4hvNV = NULL; +PFNGLVERTEX2HNVPROC __glewVertex2hNV = NULL; +PFNGLVERTEX2HVNVPROC __glewVertex2hvNV = NULL; +PFNGLVERTEX3HNVPROC __glewVertex3hNV = NULL; +PFNGLVERTEX3HVNVPROC __glewVertex3hvNV = NULL; +PFNGLVERTEX4HNVPROC __glewVertex4hNV = NULL; +PFNGLVERTEX4HVNVPROC __glewVertex4hvNV = NULL; +PFNGLVERTEXATTRIB1HNVPROC __glewVertexAttrib1hNV = NULL; +PFNGLVERTEXATTRIB1HVNVPROC __glewVertexAttrib1hvNV = NULL; +PFNGLVERTEXATTRIB2HNVPROC __glewVertexAttrib2hNV = NULL; +PFNGLVERTEXATTRIB2HVNVPROC __glewVertexAttrib2hvNV = NULL; +PFNGLVERTEXATTRIB3HNVPROC __glewVertexAttrib3hNV = NULL; +PFNGLVERTEXATTRIB3HVNVPROC __glewVertexAttrib3hvNV = NULL; +PFNGLVERTEXATTRIB4HNVPROC __glewVertexAttrib4hNV = NULL; +PFNGLVERTEXATTRIB4HVNVPROC __glewVertexAttrib4hvNV = NULL; +PFNGLVERTEXATTRIBS1HVNVPROC __glewVertexAttribs1hvNV = NULL; +PFNGLVERTEXATTRIBS2HVNVPROC __glewVertexAttribs2hvNV = NULL; +PFNGLVERTEXATTRIBS3HVNVPROC __glewVertexAttribs3hvNV = NULL; +PFNGLVERTEXATTRIBS4HVNVPROC __glewVertexAttribs4hvNV = NULL; +PFNGLVERTEXWEIGHTHNVPROC __glewVertexWeighthNV = NULL; +PFNGLVERTEXWEIGHTHVNVPROC __glewVertexWeighthvNV = NULL; + +PFNGLBEGINOCCLUSIONQUERYNVPROC __glewBeginOcclusionQueryNV = NULL; +PFNGLDELETEOCCLUSIONQUERIESNVPROC __glewDeleteOcclusionQueriesNV = NULL; +PFNGLENDOCCLUSIONQUERYNVPROC __glewEndOcclusionQueryNV = NULL; +PFNGLGENOCCLUSIONQUERIESNVPROC __glewGenOcclusionQueriesNV = NULL; +PFNGLGETOCCLUSIONQUERYIVNVPROC __glewGetOcclusionQueryivNV = NULL; +PFNGLGETOCCLUSIONQUERYUIVNVPROC __glewGetOcclusionQueryuivNV = NULL; +PFNGLISOCCLUSIONQUERYNVPROC __glewIsOcclusionQueryNV = NULL; + +PFNGLPROGRAMBUFFERPARAMETERSIIVNVPROC __glewProgramBufferParametersIivNV = NULL; +PFNGLPROGRAMBUFFERPARAMETERSIUIVNVPROC __glewProgramBufferParametersIuivNV = NULL; +PFNGLPROGRAMBUFFERPARAMETERSFVNVPROC __glewProgramBufferParametersfvNV = NULL; + +PFNGLFLUSHPIXELDATARANGENVPROC __glewFlushPixelDataRangeNV = NULL; +PFNGLPIXELDATARANGENVPROC __glewPixelDataRangeNV = NULL; + +PFNGLPOINTPARAMETERINVPROC __glewPointParameteriNV = NULL; +PFNGLPOINTPARAMETERIVNVPROC __glewPointParameterivNV = NULL; + +//PFNGLGETVIDEOI64VNVPROC __glewGetVideoi64vNV = NULL; +PFNGLGETVIDEOIVNVPROC __glewGetVideoivNV = NULL; +//PFNGLGETVIDEOUI64VNVPROC __glewGetVideoui64vNV = NULL; +PFNGLGETVIDEOUIVNVPROC __glewGetVideouivNV = NULL; +//PFNGLPRESENTFRAMEDUALFILLNVPROC __glewPresentFrameDualFillNV = NULL; +//PFNGLPRESENTFRAMEKEYEDNVPROC __glewPresentFrameKeyedNV = NULL; +PFNGLVIDEOPARAMETERIVNVPROC __glewVideoParameterivNV = NULL; + +PFNGLPRIMITIVERESTARTINDEXNVPROC __glewPrimitiveRestartIndexNV = NULL; +PFNGLPRIMITIVERESTARTNVPROC __glewPrimitiveRestartNV = NULL; + +PFNGLCOMBINERINPUTNVPROC __glewCombinerInputNV = NULL; +PFNGLCOMBINEROUTPUTNVPROC __glewCombinerOutputNV = NULL; +PFNGLCOMBINERPARAMETERFNVPROC __glewCombinerParameterfNV = NULL; +PFNGLCOMBINERPARAMETERFVNVPROC __glewCombinerParameterfvNV = NULL; +PFNGLCOMBINERPARAMETERINVPROC __glewCombinerParameteriNV = NULL; +PFNGLCOMBINERPARAMETERIVNVPROC __glewCombinerParameterivNV = NULL; +PFNGLFINALCOMBINERINPUTNVPROC __glewFinalCombinerInputNV = NULL; +PFNGLGETCOMBINERINPUTPARAMETERFVNVPROC __glewGetCombinerInputParameterfvNV = NULL; +PFNGLGETCOMBINERINPUTPARAMETERIVNVPROC __glewGetCombinerInputParameterivNV = NULL; +PFNGLGETCOMBINEROUTPUTPARAMETERFVNVPROC __glewGetCombinerOutputParameterfvNV = NULL; +PFNGLGETCOMBINEROUTPUTPARAMETERIVNVPROC __glewGetCombinerOutputParameterivNV = NULL; +PFNGLGETFINALCOMBINERINPUTPARAMETERFVNVPROC __glewGetFinalCombinerInputParameterfvNV = NULL; +PFNGLGETFINALCOMBINERINPUTPARAMETERIVNVPROC __glewGetFinalCombinerInputParameterivNV = NULL; + +PFNGLCOMBINERSTAGEPARAMETERFVNVPROC __glewCombinerStageParameterfvNV = NULL; +PFNGLGETCOMBINERSTAGEPARAMETERFVNVPROC __glewGetCombinerStageParameterfvNV = NULL; + +PFNGLACTIVEVARYINGNVPROC __glewActiveVaryingNV = NULL; +PFNGLBEGINTRANSFORMFEEDBACKNVPROC __glewBeginTransformFeedbackNV = NULL; +PFNGLBINDBUFFERBASENVPROC __glewBindBufferBaseNV = NULL; +PFNGLBINDBUFFEROFFSETNVPROC __glewBindBufferOffsetNV = NULL; +PFNGLBINDBUFFERRANGENVPROC __glewBindBufferRangeNV = NULL; +PFNGLENDTRANSFORMFEEDBACKNVPROC __glewEndTransformFeedbackNV = NULL; +PFNGLGETACTIVEVARYINGNVPROC __glewGetActiveVaryingNV = NULL; +PFNGLGETTRANSFORMFEEDBACKVARYINGNVPROC __glewGetTransformFeedbackVaryingNV = NULL; +PFNGLGETVARYINGLOCATIONNVPROC __glewGetVaryingLocationNV = NULL; +PFNGLTRANSFORMFEEDBACKATTRIBSNVPROC __glewTransformFeedbackAttribsNV = NULL; +PFNGLTRANSFORMFEEDBACKVARYINGSNVPROC __glewTransformFeedbackVaryingsNV = NULL; + +PFNGLFLUSHVERTEXARRAYRANGENVPROC __glewFlushVertexArrayRangeNV = NULL; +PFNGLVERTEXARRAYRANGENVPROC __glewVertexArrayRangeNV = NULL; + +PFNGLAREPROGRAMSRESIDENTNVPROC __glewAreProgramsResidentNV = NULL; +PFNGLBINDPROGRAMNVPROC __glewBindProgramNV = NULL; +PFNGLDELETEPROGRAMSNVPROC __glewDeleteProgramsNV = NULL; +PFNGLEXECUTEPROGRAMNVPROC __glewExecuteProgramNV = NULL; +PFNGLGENPROGRAMSNVPROC __glewGenProgramsNV = NULL; +PFNGLGETPROGRAMPARAMETERDVNVPROC __glewGetProgramParameterdvNV = NULL; +PFNGLGETPROGRAMPARAMETERFVNVPROC __glewGetProgramParameterfvNV = NULL; +PFNGLGETPROGRAMSTRINGNVPROC __glewGetProgramStringNV = NULL; +PFNGLGETPROGRAMIVNVPROC __glewGetProgramivNV = NULL; +PFNGLGETTRACKMATRIXIVNVPROC __glewGetTrackMatrixivNV = NULL; +PFNGLGETVERTEXATTRIBPOINTERVNVPROC __glewGetVertexAttribPointervNV = NULL; +PFNGLGETVERTEXATTRIBDVNVPROC __glewGetVertexAttribdvNV = NULL; +PFNGLGETVERTEXATTRIBFVNVPROC __glewGetVertexAttribfvNV = NULL; +PFNGLGETVERTEXATTRIBIVNVPROC __glewGetVertexAttribivNV = NULL; +PFNGLISPROGRAMNVPROC __glewIsProgramNV = NULL; +PFNGLLOADPROGRAMNVPROC __glewLoadProgramNV = NULL; +PFNGLPROGRAMPARAMETER4DNVPROC __glewProgramParameter4dNV = NULL; +PFNGLPROGRAMPARAMETER4DVNVPROC __glewProgramParameter4dvNV = NULL; +PFNGLPROGRAMPARAMETER4FNVPROC __glewProgramParameter4fNV = NULL; +PFNGLPROGRAMPARAMETER4FVNVPROC __glewProgramParameter4fvNV = NULL; +PFNGLPROGRAMPARAMETERS4DVNVPROC __glewProgramParameters4dvNV = NULL; +PFNGLPROGRAMPARAMETERS4FVNVPROC __glewProgramParameters4fvNV = NULL; +PFNGLREQUESTRESIDENTPROGRAMSNVPROC __glewRequestResidentProgramsNV = NULL; +PFNGLTRACKMATRIXNVPROC __glewTrackMatrixNV = NULL; +PFNGLVERTEXATTRIB1DNVPROC __glewVertexAttrib1dNV = NULL; +PFNGLVERTEXATTRIB1DVNVPROC __glewVertexAttrib1dvNV = NULL; +PFNGLVERTEXATTRIB1FNVPROC __glewVertexAttrib1fNV = NULL; +PFNGLVERTEXATTRIB1FVNVPROC __glewVertexAttrib1fvNV = NULL; +PFNGLVERTEXATTRIB1SNVPROC __glewVertexAttrib1sNV = NULL; +PFNGLVERTEXATTRIB1SVNVPROC __glewVertexAttrib1svNV = NULL; +PFNGLVERTEXATTRIB2DNVPROC __glewVertexAttrib2dNV = NULL; +PFNGLVERTEXATTRIB2DVNVPROC __glewVertexAttrib2dvNV = NULL; +PFNGLVERTEXATTRIB2FNVPROC __glewVertexAttrib2fNV = NULL; +PFNGLVERTEXATTRIB2FVNVPROC __glewVertexAttrib2fvNV = NULL; +PFNGLVERTEXATTRIB2SNVPROC __glewVertexAttrib2sNV = NULL; +PFNGLVERTEXATTRIB2SVNVPROC __glewVertexAttrib2svNV = NULL; +PFNGLVERTEXATTRIB3DNVPROC __glewVertexAttrib3dNV = NULL; +PFNGLVERTEXATTRIB3DVNVPROC __glewVertexAttrib3dvNV = NULL; +PFNGLVERTEXATTRIB3FNVPROC __glewVertexAttrib3fNV = NULL; +PFNGLVERTEXATTRIB3FVNVPROC __glewVertexAttrib3fvNV = NULL; +PFNGLVERTEXATTRIB3SNVPROC __glewVertexAttrib3sNV = NULL; +PFNGLVERTEXATTRIB3SVNVPROC __glewVertexAttrib3svNV = NULL; +PFNGLVERTEXATTRIB4DNVPROC __glewVertexAttrib4dNV = NULL; +PFNGLVERTEXATTRIB4DVNVPROC __glewVertexAttrib4dvNV = NULL; +PFNGLVERTEXATTRIB4FNVPROC __glewVertexAttrib4fNV = NULL; +PFNGLVERTEXATTRIB4FVNVPROC __glewVertexAttrib4fvNV = NULL; +PFNGLVERTEXATTRIB4SNVPROC __glewVertexAttrib4sNV = NULL; +PFNGLVERTEXATTRIB4SVNVPROC __glewVertexAttrib4svNV = NULL; +PFNGLVERTEXATTRIB4UBNVPROC __glewVertexAttrib4ubNV = NULL; +PFNGLVERTEXATTRIB4UBVNVPROC __glewVertexAttrib4ubvNV = NULL; +PFNGLVERTEXATTRIBPOINTERNVPROC __glewVertexAttribPointerNV = NULL; +PFNGLVERTEXATTRIBS1DVNVPROC __glewVertexAttribs1dvNV = NULL; +PFNGLVERTEXATTRIBS1FVNVPROC __glewVertexAttribs1fvNV = NULL; +PFNGLVERTEXATTRIBS1SVNVPROC __glewVertexAttribs1svNV = NULL; +PFNGLVERTEXATTRIBS2DVNVPROC __glewVertexAttribs2dvNV = NULL; +PFNGLVERTEXATTRIBS2FVNVPROC __glewVertexAttribs2fvNV = NULL; +PFNGLVERTEXATTRIBS2SVNVPROC __glewVertexAttribs2svNV = NULL; +PFNGLVERTEXATTRIBS3DVNVPROC __glewVertexAttribs3dvNV = NULL; +PFNGLVERTEXATTRIBS3FVNVPROC __glewVertexAttribs3fvNV = NULL; +PFNGLVERTEXATTRIBS3SVNVPROC __glewVertexAttribs3svNV = NULL; +PFNGLVERTEXATTRIBS4DVNVPROC __glewVertexAttribs4dvNV = NULL; +PFNGLVERTEXATTRIBS4FVNVPROC __glewVertexAttribs4fvNV = NULL; +PFNGLVERTEXATTRIBS4SVNVPROC __glewVertexAttribs4svNV = NULL; +PFNGLVERTEXATTRIBS4UBVNVPROC __glewVertexAttribs4ubvNV = NULL; + +PFNGLCLEARDEPTHFOESPROC __glewClearDepthfOES = NULL; +PFNGLCLIPPLANEFOESPROC __glewClipPlanefOES = NULL; +PFNGLDEPTHRANGEFOESPROC __glewDepthRangefOES = NULL; +PFNGLFRUSTUMFOESPROC __glewFrustumfOES = NULL; +PFNGLGETCLIPPLANEFOESPROC __glewGetClipPlanefOES = NULL; +PFNGLORTHOFOESPROC __glewOrthofOES = NULL; + +PFNGLDETAILTEXFUNCSGISPROC __glewDetailTexFuncSGIS = NULL; +PFNGLGETDETAILTEXFUNCSGISPROC __glewGetDetailTexFuncSGIS = NULL; + +PFNGLFOGFUNCSGISPROC __glewFogFuncSGIS = NULL; +PFNGLGETFOGFUNCSGISPROC __glewGetFogFuncSGIS = NULL; + +PFNGLSAMPLEMASKSGISPROC __glewSampleMaskSGIS = NULL; +PFNGLSAMPLEPATTERNSGISPROC __glewSamplePatternSGIS = NULL; + +PFNGLGETSHARPENTEXFUNCSGISPROC __glewGetSharpenTexFuncSGIS = NULL; +PFNGLSHARPENTEXFUNCSGISPROC __glewSharpenTexFuncSGIS = NULL; + +PFNGLTEXIMAGE4DSGISPROC __glewTexImage4DSGIS = NULL; +PFNGLTEXSUBIMAGE4DSGISPROC __glewTexSubImage4DSGIS = NULL; + +PFNGLGETTEXFILTERFUNCSGISPROC __glewGetTexFilterFuncSGIS = NULL; +PFNGLTEXFILTERFUNCSGISPROC __glewTexFilterFuncSGIS = NULL; + +PFNGLASYNCMARKERSGIXPROC __glewAsyncMarkerSGIX = NULL; +PFNGLDELETEASYNCMARKERSSGIXPROC __glewDeleteAsyncMarkersSGIX = NULL; +PFNGLFINISHASYNCSGIXPROC __glewFinishAsyncSGIX = NULL; +PFNGLGENASYNCMARKERSSGIXPROC __glewGenAsyncMarkersSGIX = NULL; +PFNGLISASYNCMARKERSGIXPROC __glewIsAsyncMarkerSGIX = NULL; +PFNGLPOLLASYNCSGIXPROC __glewPollAsyncSGIX = NULL; + +PFNGLFLUSHRASTERSGIXPROC __glewFlushRasterSGIX = NULL; + +PFNGLTEXTUREFOGSGIXPROC __glewTextureFogSGIX = NULL; + +PFNGLFRAGMENTCOLORMATERIALSGIXPROC __glewFragmentColorMaterialSGIX = NULL; +PFNGLFRAGMENTLIGHTMODELFSGIXPROC __glewFragmentLightModelfSGIX = NULL; +PFNGLFRAGMENTLIGHTMODELFVSGIXPROC __glewFragmentLightModelfvSGIX = NULL; +PFNGLFRAGMENTLIGHTMODELISGIXPROC __glewFragmentLightModeliSGIX = NULL; +PFNGLFRAGMENTLIGHTMODELIVSGIXPROC __glewFragmentLightModelivSGIX = NULL; +PFNGLFRAGMENTLIGHTFSGIXPROC __glewFragmentLightfSGIX = NULL; +PFNGLFRAGMENTLIGHTFVSGIXPROC __glewFragmentLightfvSGIX = NULL; +PFNGLFRAGMENTLIGHTISGIXPROC __glewFragmentLightiSGIX = NULL; +PFNGLFRAGMENTLIGHTIVSGIXPROC __glewFragmentLightivSGIX = NULL; +PFNGLFRAGMENTMATERIALFSGIXPROC __glewFragmentMaterialfSGIX = NULL; +PFNGLFRAGMENTMATERIALFVSGIXPROC __glewFragmentMaterialfvSGIX = NULL; +PFNGLFRAGMENTMATERIALISGIXPROC __glewFragmentMaterialiSGIX = NULL; +PFNGLFRAGMENTMATERIALIVSGIXPROC __glewFragmentMaterialivSGIX = NULL; +PFNGLGETFRAGMENTLIGHTFVSGIXPROC __glewGetFragmentLightfvSGIX = NULL; +PFNGLGETFRAGMENTLIGHTIVSGIXPROC __glewGetFragmentLightivSGIX = NULL; +PFNGLGETFRAGMENTMATERIALFVSGIXPROC __glewGetFragmentMaterialfvSGIX = NULL; +PFNGLGETFRAGMENTMATERIALIVSGIXPROC __glewGetFragmentMaterialivSGIX = NULL; + +PFNGLFRAMEZOOMSGIXPROC __glewFrameZoomSGIX = NULL; + +PFNGLPIXELTEXGENSGIXPROC __glewPixelTexGenSGIX = NULL; + +PFNGLREFERENCEPLANESGIXPROC __glewReferencePlaneSGIX = NULL; + +PFNGLSPRITEPARAMETERFSGIXPROC __glewSpriteParameterfSGIX = NULL; +PFNGLSPRITEPARAMETERFVSGIXPROC __glewSpriteParameterfvSGIX = NULL; +PFNGLSPRITEPARAMETERISGIXPROC __glewSpriteParameteriSGIX = NULL; +PFNGLSPRITEPARAMETERIVSGIXPROC __glewSpriteParameterivSGIX = NULL; + +PFNGLTAGSAMPLEBUFFERSGIXPROC __glewTagSampleBufferSGIX = NULL; + +PFNGLCOLORTABLEPARAMETERFVSGIPROC __glewColorTableParameterfvSGI = NULL; +PFNGLCOLORTABLEPARAMETERIVSGIPROC __glewColorTableParameterivSGI = NULL; +PFNGLCOLORTABLESGIPROC __glewColorTableSGI = NULL; +PFNGLCOPYCOLORTABLESGIPROC __glewCopyColorTableSGI = NULL; +PFNGLGETCOLORTABLEPARAMETERFVSGIPROC __glewGetColorTableParameterfvSGI = NULL; +PFNGLGETCOLORTABLEPARAMETERIVSGIPROC __glewGetColorTableParameterivSGI = NULL; +PFNGLGETCOLORTABLESGIPROC __glewGetColorTableSGI = NULL; + +PFNGLFINISHTEXTURESUNXPROC __glewFinishTextureSUNX = NULL; + +PFNGLGLOBALALPHAFACTORBSUNPROC __glewGlobalAlphaFactorbSUN = NULL; +PFNGLGLOBALALPHAFACTORDSUNPROC __glewGlobalAlphaFactordSUN = NULL; +PFNGLGLOBALALPHAFACTORFSUNPROC __glewGlobalAlphaFactorfSUN = NULL; +PFNGLGLOBALALPHAFACTORISUNPROC __glewGlobalAlphaFactoriSUN = NULL; +PFNGLGLOBALALPHAFACTORSSUNPROC __glewGlobalAlphaFactorsSUN = NULL; +PFNGLGLOBALALPHAFACTORUBSUNPROC __glewGlobalAlphaFactorubSUN = NULL; +PFNGLGLOBALALPHAFACTORUISUNPROC __glewGlobalAlphaFactoruiSUN = NULL; +PFNGLGLOBALALPHAFACTORUSSUNPROC __glewGlobalAlphaFactorusSUN = NULL; + +PFNGLREADVIDEOPIXELSSUNPROC __glewReadVideoPixelsSUN = NULL; + +PFNGLREPLACEMENTCODEPOINTERSUNPROC __glewReplacementCodePointerSUN = NULL; +PFNGLREPLACEMENTCODEUBSUNPROC __glewReplacementCodeubSUN = NULL; +PFNGLREPLACEMENTCODEUBVSUNPROC __glewReplacementCodeubvSUN = NULL; +PFNGLREPLACEMENTCODEUISUNPROC __glewReplacementCodeuiSUN = NULL; +PFNGLREPLACEMENTCODEUIVSUNPROC __glewReplacementCodeuivSUN = NULL; +PFNGLREPLACEMENTCODEUSSUNPROC __glewReplacementCodeusSUN = NULL; +PFNGLREPLACEMENTCODEUSVSUNPROC __glewReplacementCodeusvSUN = NULL; + +PFNGLCOLOR3FVERTEX3FSUNPROC __glewColor3fVertex3fSUN = NULL; +PFNGLCOLOR3FVERTEX3FVSUNPROC __glewColor3fVertex3fvSUN = NULL; +PFNGLCOLOR4FNORMAL3FVERTEX3FSUNPROC __glewColor4fNormal3fVertex3fSUN = NULL; +PFNGLCOLOR4FNORMAL3FVERTEX3FVSUNPROC __glewColor4fNormal3fVertex3fvSUN = NULL; +PFNGLCOLOR4UBVERTEX2FSUNPROC __glewColor4ubVertex2fSUN = NULL; +PFNGLCOLOR4UBVERTEX2FVSUNPROC __glewColor4ubVertex2fvSUN = NULL; +PFNGLCOLOR4UBVERTEX3FSUNPROC __glewColor4ubVertex3fSUN = NULL; +PFNGLCOLOR4UBVERTEX3FVSUNPROC __glewColor4ubVertex3fvSUN = NULL; +PFNGLNORMAL3FVERTEX3FSUNPROC __glewNormal3fVertex3fSUN = NULL; +PFNGLNORMAL3FVERTEX3FVSUNPROC __glewNormal3fVertex3fvSUN = NULL; +PFNGLREPLACEMENTCODEUICOLOR3FVERTEX3FSUNPROC __glewReplacementCodeuiColor3fVertex3fSUN = NULL; +PFNGLREPLACEMENTCODEUICOLOR3FVERTEX3FVSUNPROC __glewReplacementCodeuiColor3fVertex3fvSUN = NULL; +PFNGLREPLACEMENTCODEUICOLOR4FNORMAL3FVERTEX3FSUNPROC __glewReplacementCodeuiColor4fNormal3fVertex3fSUN = NULL; +PFNGLREPLACEMENTCODEUICOLOR4FNORMAL3FVERTEX3FVSUNPROC __glewReplacementCodeuiColor4fNormal3fVertex3fvSUN = NULL; +PFNGLREPLACEMENTCODEUICOLOR4UBVERTEX3FSUNPROC __glewReplacementCodeuiColor4ubVertex3fSUN = NULL; +PFNGLREPLACEMENTCODEUICOLOR4UBVERTEX3FVSUNPROC __glewReplacementCodeuiColor4ubVertex3fvSUN = NULL; +PFNGLREPLACEMENTCODEUINORMAL3FVERTEX3FSUNPROC __glewReplacementCodeuiNormal3fVertex3fSUN = NULL; +PFNGLREPLACEMENTCODEUINORMAL3FVERTEX3FVSUNPROC __glewReplacementCodeuiNormal3fVertex3fvSUN = NULL; +PFNGLREPLACEMENTCODEUITEXCOORD2FCOLOR4FNORMAL3FVERTEX3FSUNPROC __glewReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fSUN = NULL; +PFNGLREPLACEMENTCODEUITEXCOORD2FCOLOR4FNORMAL3FVERTEX3FVSUNPROC __glewReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN = NULL; +PFNGLREPLACEMENTCODEUITEXCOORD2FNORMAL3FVERTEX3FSUNPROC __glewReplacementCodeuiTexCoord2fNormal3fVertex3fSUN = NULL; +PFNGLREPLACEMENTCODEUITEXCOORD2FNORMAL3FVERTEX3FVSUNPROC __glewReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN = NULL; +PFNGLREPLACEMENTCODEUITEXCOORD2FVERTEX3FSUNPROC __glewReplacementCodeuiTexCoord2fVertex3fSUN = NULL; +PFNGLREPLACEMENTCODEUITEXCOORD2FVERTEX3FVSUNPROC __glewReplacementCodeuiTexCoord2fVertex3fvSUN = NULL; +PFNGLREPLACEMENTCODEUIVERTEX3FSUNPROC __glewReplacementCodeuiVertex3fSUN = NULL; +PFNGLREPLACEMENTCODEUIVERTEX3FVSUNPROC __glewReplacementCodeuiVertex3fvSUN = NULL; +PFNGLTEXCOORD2FCOLOR3FVERTEX3FSUNPROC __glewTexCoord2fColor3fVertex3fSUN = NULL; +PFNGLTEXCOORD2FCOLOR3FVERTEX3FVSUNPROC __glewTexCoord2fColor3fVertex3fvSUN = NULL; +PFNGLTEXCOORD2FCOLOR4FNORMAL3FVERTEX3FSUNPROC __glewTexCoord2fColor4fNormal3fVertex3fSUN = NULL; +PFNGLTEXCOORD2FCOLOR4FNORMAL3FVERTEX3FVSUNPROC __glewTexCoord2fColor4fNormal3fVertex3fvSUN = NULL; +PFNGLTEXCOORD2FCOLOR4UBVERTEX3FSUNPROC __glewTexCoord2fColor4ubVertex3fSUN = NULL; +PFNGLTEXCOORD2FCOLOR4UBVERTEX3FVSUNPROC __glewTexCoord2fColor4ubVertex3fvSUN = NULL; +PFNGLTEXCOORD2FNORMAL3FVERTEX3FSUNPROC __glewTexCoord2fNormal3fVertex3fSUN = NULL; +PFNGLTEXCOORD2FNORMAL3FVERTEX3FVSUNPROC __glewTexCoord2fNormal3fVertex3fvSUN = NULL; +PFNGLTEXCOORD2FVERTEX3FSUNPROC __glewTexCoord2fVertex3fSUN = NULL; +PFNGLTEXCOORD2FVERTEX3FVSUNPROC __glewTexCoord2fVertex3fvSUN = NULL; +PFNGLTEXCOORD4FCOLOR4FNORMAL3FVERTEX4FSUNPROC __glewTexCoord4fColor4fNormal3fVertex4fSUN = NULL; +PFNGLTEXCOORD4FCOLOR4FNORMAL3FVERTEX4FVSUNPROC __glewTexCoord4fColor4fNormal3fVertex4fvSUN = NULL; +PFNGLTEXCOORD4FVERTEX4FSUNPROC __glewTexCoord4fVertex4fSUN = NULL; +PFNGLTEXCOORD4FVERTEX4FVSUNPROC __glewTexCoord4fVertex4fvSUN = NULL; + +PFNGLADDSWAPHINTRECTWINPROC __glewAddSwapHintRectWIN = NULL; + +#endif /* !WIN32 || !GLEW_MX */ + +#if !defined(GLEW_MX) + +GLboolean __GLEW_VERSION_1_1 = GL_FALSE; +GLboolean __GLEW_VERSION_1_2 = GL_FALSE; +GLboolean __GLEW_VERSION_1_3 = GL_FALSE; +GLboolean __GLEW_VERSION_1_4 = GL_FALSE; +GLboolean __GLEW_VERSION_1_5 = GL_FALSE; +GLboolean __GLEW_VERSION_2_0 = GL_FALSE; +GLboolean __GLEW_VERSION_2_1 = GL_FALSE; +GLboolean __GLEW_VERSION_3_0 = GL_FALSE; +GLboolean __GLEW_3DFX_multisample = GL_FALSE; +GLboolean __GLEW_3DFX_tbuffer = GL_FALSE; +GLboolean __GLEW_3DFX_texture_compression_FXT1 = GL_FALSE; +GLboolean __GLEW_APPLE_client_storage = GL_FALSE; +GLboolean __GLEW_APPLE_element_array = GL_FALSE; +GLboolean __GLEW_APPLE_fence = GL_FALSE; +GLboolean __GLEW_APPLE_float_pixels = GL_FALSE; +GLboolean __GLEW_APPLE_flush_buffer_range = GL_FALSE; +GLboolean __GLEW_APPLE_pixel_buffer = GL_FALSE; +GLboolean __GLEW_APPLE_specular_vector = GL_FALSE; +GLboolean __GLEW_APPLE_texture_range = GL_FALSE; +GLboolean __GLEW_APPLE_transform_hint = GL_FALSE; +GLboolean __GLEW_APPLE_vertex_array_object = GL_FALSE; +GLboolean __GLEW_APPLE_vertex_array_range = GL_FALSE; +GLboolean __GLEW_APPLE_ycbcr_422 = GL_FALSE; +GLboolean __GLEW_ARB_color_buffer_float = GL_FALSE; +GLboolean __GLEW_ARB_depth_buffer_float = GL_FALSE; +GLboolean __GLEW_ARB_depth_texture = GL_FALSE; +GLboolean __GLEW_ARB_draw_buffers = GL_FALSE; +GLboolean __GLEW_ARB_draw_instanced = GL_FALSE; +GLboolean __GLEW_ARB_fragment_program = GL_FALSE; +GLboolean __GLEW_ARB_fragment_program_shadow = GL_FALSE; +GLboolean __GLEW_ARB_fragment_shader = GL_FALSE; +GLboolean __GLEW_ARB_framebuffer_object = GL_FALSE; +GLboolean __GLEW_ARB_framebuffer_sRGB = GL_FALSE; +GLboolean __GLEW_ARB_geometry_shader4 = GL_FALSE; +GLboolean __GLEW_ARB_half_float_pixel = GL_FALSE; +GLboolean __GLEW_ARB_half_float_vertex = GL_FALSE; +GLboolean __GLEW_ARB_imaging = GL_FALSE; +GLboolean __GLEW_ARB_instanced_arrays = GL_FALSE; +GLboolean __GLEW_ARB_map_buffer_range = GL_FALSE; +GLboolean __GLEW_ARB_matrix_palette = GL_FALSE; +GLboolean __GLEW_ARB_multisample = GL_FALSE; +GLboolean __GLEW_ARB_multitexture = GL_FALSE; +GLboolean __GLEW_ARB_occlusion_query = GL_FALSE; +GLboolean __GLEW_ARB_pixel_buffer_object = GL_FALSE; +GLboolean __GLEW_ARB_point_parameters = GL_FALSE; +GLboolean __GLEW_ARB_point_sprite = GL_FALSE; +GLboolean __GLEW_ARB_shader_objects = GL_FALSE; +GLboolean __GLEW_ARB_shading_language_100 = GL_FALSE; +GLboolean __GLEW_ARB_shadow = GL_FALSE; +GLboolean __GLEW_ARB_shadow_ambient = GL_FALSE; +GLboolean __GLEW_ARB_texture_border_clamp = GL_FALSE; +GLboolean __GLEW_ARB_texture_buffer_object = GL_FALSE; +GLboolean __GLEW_ARB_texture_compression = GL_FALSE; +GLboolean __GLEW_ARB_texture_compression_rgtc = GL_FALSE; +GLboolean __GLEW_ARB_texture_cube_map = GL_FALSE; +GLboolean __GLEW_ARB_texture_env_add = GL_FALSE; +GLboolean __GLEW_ARB_texture_env_combine = GL_FALSE; +GLboolean __GLEW_ARB_texture_env_crossbar = GL_FALSE; +GLboolean __GLEW_ARB_texture_env_dot3 = GL_FALSE; +GLboolean __GLEW_ARB_texture_float = GL_FALSE; +GLboolean __GLEW_ARB_texture_mirrored_repeat = GL_FALSE; +GLboolean __GLEW_ARB_texture_non_power_of_two = GL_FALSE; +GLboolean __GLEW_ARB_texture_rectangle = GL_FALSE; +GLboolean __GLEW_ARB_texture_rg = GL_FALSE; +GLboolean __GLEW_ARB_transpose_matrix = GL_FALSE; +GLboolean __GLEW_ARB_vertex_array_object = GL_FALSE; +GLboolean __GLEW_ARB_vertex_blend = GL_FALSE; +GLboolean __GLEW_ARB_vertex_buffer_object = GL_FALSE; +GLboolean __GLEW_ARB_vertex_program = GL_FALSE; +GLboolean __GLEW_ARB_vertex_shader = GL_FALSE; +GLboolean __GLEW_ARB_window_pos = GL_FALSE; +GLboolean __GLEW_ATIX_point_sprites = GL_FALSE; +GLboolean __GLEW_ATIX_texture_env_combine3 = GL_FALSE; +GLboolean __GLEW_ATIX_texture_env_route = GL_FALSE; +GLboolean __GLEW_ATIX_vertex_shader_output_point_size = GL_FALSE; +GLboolean __GLEW_ATI_draw_buffers = GL_FALSE; +GLboolean __GLEW_ATI_element_array = GL_FALSE; +GLboolean __GLEW_ATI_envmap_bumpmap = GL_FALSE; +GLboolean __GLEW_ATI_fragment_shader = GL_FALSE; +GLboolean __GLEW_ATI_map_object_buffer = GL_FALSE; +GLboolean __GLEW_ATI_pn_triangles = GL_FALSE; +GLboolean __GLEW_ATI_separate_stencil = GL_FALSE; +GLboolean __GLEW_ATI_shader_texture_lod = GL_FALSE; +GLboolean __GLEW_ATI_text_fragment_shader = GL_FALSE; +GLboolean __GLEW_ATI_texture_compression_3dc = GL_FALSE; +GLboolean __GLEW_ATI_texture_env_combine3 = GL_FALSE; +GLboolean __GLEW_ATI_texture_float = GL_FALSE; +GLboolean __GLEW_ATI_texture_mirror_once = GL_FALSE; +GLboolean __GLEW_ATI_vertex_array_object = GL_FALSE; +GLboolean __GLEW_ATI_vertex_attrib_array_object = GL_FALSE; +GLboolean __GLEW_ATI_vertex_streams = GL_FALSE; +GLboolean __GLEW_EXT_422_pixels = GL_FALSE; +GLboolean __GLEW_EXT_Cg_shader = GL_FALSE; +GLboolean __GLEW_EXT_abgr = GL_FALSE; +GLboolean __GLEW_EXT_bgra = GL_FALSE; +GLboolean __GLEW_EXT_bindable_uniform = GL_FALSE; +GLboolean __GLEW_EXT_blend_color = GL_FALSE; +GLboolean __GLEW_EXT_blend_equation_separate = GL_FALSE; +GLboolean __GLEW_EXT_blend_func_separate = GL_FALSE; +GLboolean __GLEW_EXT_blend_logic_op = GL_FALSE; +GLboolean __GLEW_EXT_blend_minmax = GL_FALSE; +GLboolean __GLEW_EXT_blend_subtract = GL_FALSE; +GLboolean __GLEW_EXT_clip_volume_hint = GL_FALSE; +GLboolean __GLEW_EXT_cmyka = GL_FALSE; +GLboolean __GLEW_EXT_color_subtable = GL_FALSE; +GLboolean __GLEW_EXT_compiled_vertex_array = GL_FALSE; +GLboolean __GLEW_EXT_convolution = GL_FALSE; +GLboolean __GLEW_EXT_coordinate_frame = GL_FALSE; +GLboolean __GLEW_EXT_copy_texture = GL_FALSE; +GLboolean __GLEW_EXT_cull_vertex = GL_FALSE; +GLboolean __GLEW_EXT_depth_bounds_test = GL_FALSE; +GLboolean __GLEW_EXT_direct_state_access = GL_FALSE; +GLboolean __GLEW_EXT_draw_buffers2 = GL_FALSE; +GLboolean __GLEW_EXT_draw_instanced = GL_FALSE; +GLboolean __GLEW_EXT_draw_range_elements = GL_FALSE; +GLboolean __GLEW_EXT_fog_coord = GL_FALSE; +GLboolean __GLEW_EXT_fragment_lighting = GL_FALSE; +GLboolean __GLEW_EXT_framebuffer_blit = GL_FALSE; +GLboolean __GLEW_EXT_framebuffer_multisample = GL_FALSE; +GLboolean __GLEW_EXT_framebuffer_object = GL_FALSE; +GLboolean __GLEW_EXT_framebuffer_sRGB = GL_FALSE; +GLboolean __GLEW_EXT_geometry_shader4 = GL_FALSE; +GLboolean __GLEW_EXT_gpu_program_parameters = GL_FALSE; +GLboolean __GLEW_EXT_gpu_shader4 = GL_FALSE; +GLboolean __GLEW_EXT_histogram = GL_FALSE; +GLboolean __GLEW_EXT_index_array_formats = GL_FALSE; +GLboolean __GLEW_EXT_index_func = GL_FALSE; +GLboolean __GLEW_EXT_index_material = GL_FALSE; +GLboolean __GLEW_EXT_index_texture = GL_FALSE; +GLboolean __GLEW_EXT_light_texture = GL_FALSE; +GLboolean __GLEW_EXT_misc_attribute = GL_FALSE; +GLboolean __GLEW_EXT_multi_draw_arrays = GL_FALSE; +GLboolean __GLEW_EXT_multisample = GL_FALSE; +GLboolean __GLEW_EXT_packed_depth_stencil = GL_FALSE; +GLboolean __GLEW_EXT_packed_float = GL_FALSE; +GLboolean __GLEW_EXT_packed_pixels = GL_FALSE; +GLboolean __GLEW_EXT_paletted_texture = GL_FALSE; +GLboolean __GLEW_EXT_pixel_buffer_object = GL_FALSE; +GLboolean __GLEW_EXT_pixel_transform = GL_FALSE; +GLboolean __GLEW_EXT_pixel_transform_color_table = GL_FALSE; +GLboolean __GLEW_EXT_point_parameters = GL_FALSE; +GLboolean __GLEW_EXT_polygon_offset = GL_FALSE; +GLboolean __GLEW_EXT_rescale_normal = GL_FALSE; +GLboolean __GLEW_EXT_scene_marker = GL_FALSE; +GLboolean __GLEW_EXT_secondary_color = GL_FALSE; +GLboolean __GLEW_EXT_separate_specular_color = GL_FALSE; +GLboolean __GLEW_EXT_shadow_funcs = GL_FALSE; +GLboolean __GLEW_EXT_shared_texture_palette = GL_FALSE; +GLboolean __GLEW_EXT_stencil_clear_tag = GL_FALSE; +GLboolean __GLEW_EXT_stencil_two_side = GL_FALSE; +GLboolean __GLEW_EXT_stencil_wrap = GL_FALSE; +GLboolean __GLEW_EXT_subtexture = GL_FALSE; +GLboolean __GLEW_EXT_texture = GL_FALSE; +GLboolean __GLEW_EXT_texture3D = GL_FALSE; +GLboolean __GLEW_EXT_texture_array = GL_FALSE; +GLboolean __GLEW_EXT_texture_buffer_object = GL_FALSE; +GLboolean __GLEW_EXT_texture_compression_dxt1 = GL_FALSE; +GLboolean __GLEW_EXT_texture_compression_latc = GL_FALSE; +GLboolean __GLEW_EXT_texture_compression_rgtc = GL_FALSE; +GLboolean __GLEW_EXT_texture_compression_s3tc = GL_FALSE; +GLboolean __GLEW_EXT_texture_cube_map = GL_FALSE; +GLboolean __GLEW_EXT_texture_edge_clamp = GL_FALSE; +GLboolean __GLEW_EXT_texture_env = GL_FALSE; +GLboolean __GLEW_EXT_texture_env_add = GL_FALSE; +GLboolean __GLEW_EXT_texture_env_combine = GL_FALSE; +GLboolean __GLEW_EXT_texture_env_dot3 = GL_FALSE; +GLboolean __GLEW_EXT_texture_filter_anisotropic = GL_FALSE; +GLboolean __GLEW_EXT_texture_integer = GL_FALSE; +GLboolean __GLEW_EXT_texture_lod_bias = GL_FALSE; +GLboolean __GLEW_EXT_texture_mirror_clamp = GL_FALSE; +GLboolean __GLEW_EXT_texture_object = GL_FALSE; +GLboolean __GLEW_EXT_texture_perturb_normal = GL_FALSE; +GLboolean __GLEW_EXT_texture_rectangle = GL_FALSE; +GLboolean __GLEW_EXT_texture_sRGB = GL_FALSE; +GLboolean __GLEW_EXT_texture_shared_exponent = GL_FALSE; +GLboolean __GLEW_EXT_texture_swizzle = GL_FALSE; +GLboolean __GLEW_EXT_timer_query = GL_FALSE; +GLboolean __GLEW_EXT_transform_feedback = GL_FALSE; +GLboolean __GLEW_EXT_vertex_array = GL_FALSE; +GLboolean __GLEW_EXT_vertex_array_bgra = GL_FALSE; +GLboolean __GLEW_EXT_vertex_shader = GL_FALSE; +GLboolean __GLEW_EXT_vertex_weighting = GL_FALSE; +GLboolean __GLEW_GREMEDY_frame_terminator = GL_FALSE; +GLboolean __GLEW_GREMEDY_string_marker = GL_FALSE; +GLboolean __GLEW_HP_convolution_border_modes = GL_FALSE; +GLboolean __GLEW_HP_image_transform = GL_FALSE; +GLboolean __GLEW_HP_occlusion_test = GL_FALSE; +GLboolean __GLEW_HP_texture_lighting = GL_FALSE; +GLboolean __GLEW_IBM_cull_vertex = GL_FALSE; +GLboolean __GLEW_IBM_multimode_draw_arrays = GL_FALSE; +GLboolean __GLEW_IBM_rasterpos_clip = GL_FALSE; +GLboolean __GLEW_IBM_static_data = GL_FALSE; +GLboolean __GLEW_IBM_texture_mirrored_repeat = GL_FALSE; +GLboolean __GLEW_IBM_vertex_array_lists = GL_FALSE; +GLboolean __GLEW_INGR_color_clamp = GL_FALSE; +GLboolean __GLEW_INGR_interlace_read = GL_FALSE; +GLboolean __GLEW_INTEL_parallel_arrays = GL_FALSE; +GLboolean __GLEW_INTEL_texture_scissor = GL_FALSE; +GLboolean __GLEW_KTX_buffer_region = GL_FALSE; +GLboolean __GLEW_MESAX_texture_stack = GL_FALSE; +GLboolean __GLEW_MESA_pack_invert = GL_FALSE; +GLboolean __GLEW_MESA_resize_buffers = GL_FALSE; +GLboolean __GLEW_MESA_window_pos = GL_FALSE; +GLboolean __GLEW_MESA_ycbcr_texture = GL_FALSE; +GLboolean __GLEW_NV_blend_square = GL_FALSE; +GLboolean __GLEW_NV_conditional_render = GL_FALSE; +GLboolean __GLEW_NV_copy_depth_to_color = GL_FALSE; +GLboolean __GLEW_NV_depth_buffer_float = GL_FALSE; +GLboolean __GLEW_NV_depth_clamp = GL_FALSE; +GLboolean __GLEW_NV_depth_range_unclamped = GL_FALSE; +GLboolean __GLEW_NV_evaluators = GL_FALSE; +GLboolean __GLEW_NV_explicit_multisample = GL_FALSE; +GLboolean __GLEW_NV_fence = GL_FALSE; +GLboolean __GLEW_NV_float_buffer = GL_FALSE; +GLboolean __GLEW_NV_fog_distance = GL_FALSE; +GLboolean __GLEW_NV_fragment_program = GL_FALSE; +GLboolean __GLEW_NV_fragment_program2 = GL_FALSE; +GLboolean __GLEW_NV_fragment_program4 = GL_FALSE; +GLboolean __GLEW_NV_fragment_program_option = GL_FALSE; +GLboolean __GLEW_NV_framebuffer_multisample_coverage = GL_FALSE; +GLboolean __GLEW_NV_geometry_program4 = GL_FALSE; +GLboolean __GLEW_NV_geometry_shader4 = GL_FALSE; +GLboolean __GLEW_NV_gpu_program4 = GL_FALSE; +GLboolean __GLEW_NV_half_float = GL_FALSE; +GLboolean __GLEW_NV_light_max_exponent = GL_FALSE; +GLboolean __GLEW_NV_multisample_filter_hint = GL_FALSE; +GLboolean __GLEW_NV_occlusion_query = GL_FALSE; +GLboolean __GLEW_NV_packed_depth_stencil = GL_FALSE; +GLboolean __GLEW_NV_parameter_buffer_object = GL_FALSE; +GLboolean __GLEW_NV_pixel_data_range = GL_FALSE; +GLboolean __GLEW_NV_point_sprite = GL_FALSE; +GLboolean __GLEW_NV_present_video = GL_FALSE; +GLboolean __GLEW_NV_primitive_restart = GL_FALSE; +GLboolean __GLEW_NV_register_combiners = GL_FALSE; +GLboolean __GLEW_NV_register_combiners2 = GL_FALSE; +GLboolean __GLEW_NV_texgen_emboss = GL_FALSE; +GLboolean __GLEW_NV_texgen_reflection = GL_FALSE; +GLboolean __GLEW_NV_texture_compression_vtc = GL_FALSE; +GLboolean __GLEW_NV_texture_env_combine4 = GL_FALSE; +GLboolean __GLEW_NV_texture_expand_normal = GL_FALSE; +GLboolean __GLEW_NV_texture_rectangle = GL_FALSE; +GLboolean __GLEW_NV_texture_shader = GL_FALSE; +GLboolean __GLEW_NV_texture_shader2 = GL_FALSE; +GLboolean __GLEW_NV_texture_shader3 = GL_FALSE; +GLboolean __GLEW_NV_transform_feedback = GL_FALSE; +GLboolean __GLEW_NV_vertex_array_range = GL_FALSE; +GLboolean __GLEW_NV_vertex_array_range2 = GL_FALSE; +GLboolean __GLEW_NV_vertex_program = GL_FALSE; +GLboolean __GLEW_NV_vertex_program1_1 = GL_FALSE; +GLboolean __GLEW_NV_vertex_program2 = GL_FALSE; +GLboolean __GLEW_NV_vertex_program2_option = GL_FALSE; +GLboolean __GLEW_NV_vertex_program3 = GL_FALSE; +GLboolean __GLEW_NV_vertex_program4 = GL_FALSE; +GLboolean __GLEW_OES_byte_coordinates = GL_FALSE; +GLboolean __GLEW_OES_compressed_paletted_texture = GL_FALSE; +GLboolean __GLEW_OES_read_format = GL_FALSE; +GLboolean __GLEW_OES_single_precision = GL_FALSE; +GLboolean __GLEW_OML_interlace = GL_FALSE; +GLboolean __GLEW_OML_resample = GL_FALSE; +GLboolean __GLEW_OML_subsample = GL_FALSE; +GLboolean __GLEW_PGI_misc_hints = GL_FALSE; +GLboolean __GLEW_PGI_vertex_hints = GL_FALSE; +GLboolean __GLEW_REND_screen_coordinates = GL_FALSE; +GLboolean __GLEW_S3_s3tc = GL_FALSE; +GLboolean __GLEW_SGIS_color_range = GL_FALSE; +GLboolean __GLEW_SGIS_detail_texture = GL_FALSE; +GLboolean __GLEW_SGIS_fog_function = GL_FALSE; +GLboolean __GLEW_SGIS_generate_mipmap = GL_FALSE; +GLboolean __GLEW_SGIS_multisample = GL_FALSE; +GLboolean __GLEW_SGIS_pixel_texture = GL_FALSE; +GLboolean __GLEW_SGIS_point_line_texgen = GL_FALSE; +GLboolean __GLEW_SGIS_sharpen_texture = GL_FALSE; +GLboolean __GLEW_SGIS_texture4D = GL_FALSE; +GLboolean __GLEW_SGIS_texture_border_clamp = GL_FALSE; +GLboolean __GLEW_SGIS_texture_edge_clamp = GL_FALSE; +GLboolean __GLEW_SGIS_texture_filter4 = GL_FALSE; +GLboolean __GLEW_SGIS_texture_lod = GL_FALSE; +GLboolean __GLEW_SGIS_texture_select = GL_FALSE; +GLboolean __GLEW_SGIX_async = GL_FALSE; +GLboolean __GLEW_SGIX_async_histogram = GL_FALSE; +GLboolean __GLEW_SGIX_async_pixel = GL_FALSE; +GLboolean __GLEW_SGIX_blend_alpha_minmax = GL_FALSE; +GLboolean __GLEW_SGIX_clipmap = GL_FALSE; +GLboolean __GLEW_SGIX_convolution_accuracy = GL_FALSE; +GLboolean __GLEW_SGIX_depth_texture = GL_FALSE; +GLboolean __GLEW_SGIX_flush_raster = GL_FALSE; +GLboolean __GLEW_SGIX_fog_offset = GL_FALSE; +GLboolean __GLEW_SGIX_fog_texture = GL_FALSE; +GLboolean __GLEW_SGIX_fragment_specular_lighting = GL_FALSE; +GLboolean __GLEW_SGIX_framezoom = GL_FALSE; +GLboolean __GLEW_SGIX_interlace = GL_FALSE; +GLboolean __GLEW_SGIX_ir_instrument1 = GL_FALSE; +GLboolean __GLEW_SGIX_list_priority = GL_FALSE; +GLboolean __GLEW_SGIX_pixel_texture = GL_FALSE; +GLboolean __GLEW_SGIX_pixel_texture_bits = GL_FALSE; +GLboolean __GLEW_SGIX_reference_plane = GL_FALSE; +GLboolean __GLEW_SGIX_resample = GL_FALSE; +GLboolean __GLEW_SGIX_shadow = GL_FALSE; +GLboolean __GLEW_SGIX_shadow_ambient = GL_FALSE; +GLboolean __GLEW_SGIX_sprite = GL_FALSE; +GLboolean __GLEW_SGIX_tag_sample_buffer = GL_FALSE; +GLboolean __GLEW_SGIX_texture_add_env = GL_FALSE; +GLboolean __GLEW_SGIX_texture_coordinate_clamp = GL_FALSE; +GLboolean __GLEW_SGIX_texture_lod_bias = GL_FALSE; +GLboolean __GLEW_SGIX_texture_multi_buffer = GL_FALSE; +GLboolean __GLEW_SGIX_texture_range = GL_FALSE; +GLboolean __GLEW_SGIX_texture_scale_bias = GL_FALSE; +GLboolean __GLEW_SGIX_vertex_preclip = GL_FALSE; +GLboolean __GLEW_SGIX_vertex_preclip_hint = GL_FALSE; +GLboolean __GLEW_SGIX_ycrcb = GL_FALSE; +GLboolean __GLEW_SGI_color_matrix = GL_FALSE; +GLboolean __GLEW_SGI_color_table = GL_FALSE; +GLboolean __GLEW_SGI_texture_color_table = GL_FALSE; +GLboolean __GLEW_SUNX_constant_data = GL_FALSE; +GLboolean __GLEW_SUN_convolution_border_modes = GL_FALSE; +GLboolean __GLEW_SUN_global_alpha = GL_FALSE; +GLboolean __GLEW_SUN_mesh_array = GL_FALSE; +GLboolean __GLEW_SUN_read_video_pixels = GL_FALSE; +GLboolean __GLEW_SUN_slice_accum = GL_FALSE; +GLboolean __GLEW_SUN_triangle_list = GL_FALSE; +GLboolean __GLEW_SUN_vertex = GL_FALSE; +GLboolean __GLEW_WIN_phong_shading = GL_FALSE; +GLboolean __GLEW_WIN_specular_fog = GL_FALSE; +GLboolean __GLEW_WIN_swap_hint = GL_FALSE; + +#endif /* !GLEW_MX */ + +#ifdef GL_VERSION_1_2 + +static GLboolean _glewInit_GL_VERSION_1_2 (GLEW_CONTEXT_ARG_DEF_INIT) +{ + GLboolean r = GL_FALSE; + + r = ((glCopyTexSubImage3D = (PFNGLCOPYTEXSUBIMAGE3DPROC)glewGetProcAddress((const GLubyte*)"glCopyTexSubImage3D")) == NULL) || r; + r = ((glDrawRangeElements = (PFNGLDRAWRANGEELEMENTSPROC)glewGetProcAddress((const GLubyte*)"glDrawRangeElements")) == NULL) || r; + r = ((glTexImage3D = (PFNGLTEXIMAGE3DPROC)glewGetProcAddress((const GLubyte*)"glTexImage3D")) == NULL) || r; + r = ((glTexSubImage3D = (PFNGLTEXSUBIMAGE3DPROC)glewGetProcAddress((const GLubyte*)"glTexSubImage3D")) == NULL) || r; + + return r; +} + +#endif /* GL_VERSION_1_2 */ + +#ifdef GL_VERSION_1_3 + +static GLboolean _glewInit_GL_VERSION_1_3 (GLEW_CONTEXT_ARG_DEF_INIT) +{ + GLboolean r = GL_FALSE; + + r = ((glActiveTexture = (PFNGLACTIVETEXTUREPROC)glewGetProcAddress((const GLubyte*)"glActiveTexture")) == NULL) || r; + r = ((glClientActiveTexture = (PFNGLCLIENTACTIVETEXTUREPROC)glewGetProcAddress((const GLubyte*)"glClientActiveTexture")) == NULL) || r; + r = ((glCompressedTexImage1D = (PFNGLCOMPRESSEDTEXIMAGE1DPROC)glewGetProcAddress((const GLubyte*)"glCompressedTexImage1D")) == NULL) || r; + r = ((glCompressedTexImage2D = (PFNGLCOMPRESSEDTEXIMAGE2DPROC)glewGetProcAddress((const GLubyte*)"glCompressedTexImage2D")) == NULL) || r; + r = ((glCompressedTexImage3D = (PFNGLCOMPRESSEDTEXIMAGE3DPROC)glewGetProcAddress((const GLubyte*)"glCompressedTexImage3D")) == NULL) || r; + r = ((glCompressedTexSubImage1D = (PFNGLCOMPRESSEDTEXSUBIMAGE1DPROC)glewGetProcAddress((const GLubyte*)"glCompressedTexSubImage1D")) == NULL) || r; + r = ((glCompressedTexSubImage2D = (PFNGLCOMPRESSEDTEXSUBIMAGE2DPROC)glewGetProcAddress((const GLubyte*)"glCompressedTexSubImage2D")) == NULL) || r; + r = ((glCompressedTexSubImage3D = (PFNGLCOMPRESSEDTEXSUBIMAGE3DPROC)glewGetProcAddress((const GLubyte*)"glCompressedTexSubImage3D")) == NULL) || r; + r = ((glGetCompressedTexImage = (PFNGLGETCOMPRESSEDTEXIMAGEPROC)glewGetProcAddress((const GLubyte*)"glGetCompressedTexImage")) == NULL) || r; + r = ((glLoadTransposeMatrixd = (PFNGLLOADTRANSPOSEMATRIXDPROC)glewGetProcAddress((const GLubyte*)"glLoadTransposeMatrixd")) == NULL) || r; + r = ((glLoadTransposeMatrixf = (PFNGLLOADTRANSPOSEMATRIXFPROC)glewGetProcAddress((const GLubyte*)"glLoadTransposeMatrixf")) == NULL) || r; + r = ((glMultTransposeMatrixd = (PFNGLMULTTRANSPOSEMATRIXDPROC)glewGetProcAddress((const GLubyte*)"glMultTransposeMatrixd")) == NULL) || r; + r = ((glMultTransposeMatrixf = (PFNGLMULTTRANSPOSEMATRIXFPROC)glewGetProcAddress((const GLubyte*)"glMultTransposeMatrixf")) == NULL) || r; + r = ((glMultiTexCoord1d = (PFNGLMULTITEXCOORD1DPROC)glewGetProcAddress((const GLubyte*)"glMultiTexCoord1d")) == NULL) || r; + r = ((glMultiTexCoord1dv = (PFNGLMULTITEXCOORD1DVPROC)glewGetProcAddress((const GLubyte*)"glMultiTexCoord1dv")) == NULL) || r; + r = ((glMultiTexCoord1f = (PFNGLMULTITEXCOORD1FPROC)glewGetProcAddress((const GLubyte*)"glMultiTexCoord1f")) == NULL) || r; + r = ((glMultiTexCoord1fv = (PFNGLMULTITEXCOORD1FVPROC)glewGetProcAddress((const GLubyte*)"glMultiTexCoord1fv")) == NULL) || r; + r = ((glMultiTexCoord1i = (PFNGLMULTITEXCOORD1IPROC)glewGetProcAddress((const GLubyte*)"glMultiTexCoord1i")) == NULL) || r; + r = ((glMultiTexCoord1iv = (PFNGLMULTITEXCOORD1IVPROC)glewGetProcAddress((const GLubyte*)"glMultiTexCoord1iv")) == NULL) || r; + r = ((glMultiTexCoord1s = (PFNGLMULTITEXCOORD1SPROC)glewGetProcAddress((const GLubyte*)"glMultiTexCoord1s")) == NULL) || r; + r = ((glMultiTexCoord1sv = (PFNGLMULTITEXCOORD1SVPROC)glewGetProcAddress((const GLubyte*)"glMultiTexCoord1sv")) == NULL) || r; + r = ((glMultiTexCoord2d = (PFNGLMULTITEXCOORD2DPROC)glewGetProcAddress((const GLubyte*)"glMultiTexCoord2d")) == NULL) || r; + r = ((glMultiTexCoord2dv = (PFNGLMULTITEXCOORD2DVPROC)glewGetProcAddress((const GLubyte*)"glMultiTexCoord2dv")) == NULL) || r; + r = ((glMultiTexCoord2f = (PFNGLMULTITEXCOORD2FPROC)glewGetProcAddress((const GLubyte*)"glMultiTexCoord2f")) == NULL) || r; + r = ((glMultiTexCoord2fv = (PFNGLMULTITEXCOORD2FVPROC)glewGetProcAddress((const GLubyte*)"glMultiTexCoord2fv")) == NULL) || r; + r = ((glMultiTexCoord2i = (PFNGLMULTITEXCOORD2IPROC)glewGetProcAddress((const GLubyte*)"glMultiTexCoord2i")) == NULL) || r; + r = ((glMultiTexCoord2iv = (PFNGLMULTITEXCOORD2IVPROC)glewGetProcAddress((const GLubyte*)"glMultiTexCoord2iv")) == NULL) || r; + r = ((glMultiTexCoord2s = (PFNGLMULTITEXCOORD2SPROC)glewGetProcAddress((const GLubyte*)"glMultiTexCoord2s")) == NULL) || r; + r = ((glMultiTexCoord2sv = (PFNGLMULTITEXCOORD2SVPROC)glewGetProcAddress((const GLubyte*)"glMultiTexCoord2sv")) == NULL) || r; + r = ((glMultiTexCoord3d = (PFNGLMULTITEXCOORD3DPROC)glewGetProcAddress((const GLubyte*)"glMultiTexCoord3d")) == NULL) || r; + r = ((glMultiTexCoord3dv = (PFNGLMULTITEXCOORD3DVPROC)glewGetProcAddress((const GLubyte*)"glMultiTexCoord3dv")) == NULL) || r; + r = ((glMultiTexCoord3f = (PFNGLMULTITEXCOORD3FPROC)glewGetProcAddress((const GLubyte*)"glMultiTexCoord3f")) == NULL) || r; + r = ((glMultiTexCoord3fv = (PFNGLMULTITEXCOORD3FVPROC)glewGetProcAddress((const GLubyte*)"glMultiTexCoord3fv")) == NULL) || r; + r = ((glMultiTexCoord3i = (PFNGLMULTITEXCOORD3IPROC)glewGetProcAddress((const GLubyte*)"glMultiTexCoord3i")) == NULL) || r; + r = ((glMultiTexCoord3iv = (PFNGLMULTITEXCOORD3IVPROC)glewGetProcAddress((const GLubyte*)"glMultiTexCoord3iv")) == NULL) || r; + r = ((glMultiTexCoord3s = (PFNGLMULTITEXCOORD3SPROC)glewGetProcAddress((const GLubyte*)"glMultiTexCoord3s")) == NULL) || r; + r = ((glMultiTexCoord3sv = (PFNGLMULTITEXCOORD3SVPROC)glewGetProcAddress((const GLubyte*)"glMultiTexCoord3sv")) == NULL) || r; + r = ((glMultiTexCoord4d = (PFNGLMULTITEXCOORD4DPROC)glewGetProcAddress((const GLubyte*)"glMultiTexCoord4d")) == NULL) || r; + r = ((glMultiTexCoord4dv = (PFNGLMULTITEXCOORD4DVPROC)glewGetProcAddress((const GLubyte*)"glMultiTexCoord4dv")) == NULL) || r; + r = ((glMultiTexCoord4f = (PFNGLMULTITEXCOORD4FPROC)glewGetProcAddress((const GLubyte*)"glMultiTexCoord4f")) == NULL) || r; + r = ((glMultiTexCoord4fv = (PFNGLMULTITEXCOORD4FVPROC)glewGetProcAddress((const GLubyte*)"glMultiTexCoord4fv")) == NULL) || r; + r = ((glMultiTexCoord4i = (PFNGLMULTITEXCOORD4IPROC)glewGetProcAddress((const GLubyte*)"glMultiTexCoord4i")) == NULL) || r; + r = ((glMultiTexCoord4iv = (PFNGLMULTITEXCOORD4IVPROC)glewGetProcAddress((const GLubyte*)"glMultiTexCoord4iv")) == NULL) || r; + r = ((glMultiTexCoord4s = (PFNGLMULTITEXCOORD4SPROC)glewGetProcAddress((const GLubyte*)"glMultiTexCoord4s")) == NULL) || r; + r = ((glMultiTexCoord4sv = (PFNGLMULTITEXCOORD4SVPROC)glewGetProcAddress((const GLubyte*)"glMultiTexCoord4sv")) == NULL) || r; + r = ((glSampleCoverage = (PFNGLSAMPLECOVERAGEPROC)glewGetProcAddress((const GLubyte*)"glSampleCoverage")) == NULL) || r; + + return r; +} + +#endif /* GL_VERSION_1_3 */ + +#ifdef GL_VERSION_1_4 + +static GLboolean _glewInit_GL_VERSION_1_4 (GLEW_CONTEXT_ARG_DEF_INIT) +{ + GLboolean r = GL_FALSE; + + r = ((glBlendColor = (PFNGLBLENDCOLORPROC)glewGetProcAddress((const GLubyte*)"glBlendColor")) == NULL) || r; + r = ((glBlendEquation = (PFNGLBLENDEQUATIONPROC)glewGetProcAddress((const GLubyte*)"glBlendEquation")) == NULL) || r; + r = ((glBlendFuncSeparate = (PFNGLBLENDFUNCSEPARATEPROC)glewGetProcAddress((const GLubyte*)"glBlendFuncSeparate")) == NULL) || r; + r = ((glFogCoordPointer = (PFNGLFOGCOORDPOINTERPROC)glewGetProcAddress((const GLubyte*)"glFogCoordPointer")) == NULL) || r; + r = ((glFogCoordd = (PFNGLFOGCOORDDPROC)glewGetProcAddress((const GLubyte*)"glFogCoordd")) == NULL) || r; + r = ((glFogCoorddv = (PFNGLFOGCOORDDVPROC)glewGetProcAddress((const GLubyte*)"glFogCoorddv")) == NULL) || r; + r = ((glFogCoordf = (PFNGLFOGCOORDFPROC)glewGetProcAddress((const GLubyte*)"glFogCoordf")) == NULL) || r; + r = ((glFogCoordfv = (PFNGLFOGCOORDFVPROC)glewGetProcAddress((const GLubyte*)"glFogCoordfv")) == NULL) || r; + r = ((glMultiDrawArrays = (PFNGLMULTIDRAWARRAYSPROC)glewGetProcAddress((const GLubyte*)"glMultiDrawArrays")) == NULL) || r; + r = ((glMultiDrawElements = (PFNGLMULTIDRAWELEMENTSPROC)glewGetProcAddress((const GLubyte*)"glMultiDrawElements")) == NULL) || r; + r = ((glPointParameterf = (PFNGLPOINTPARAMETERFPROC)glewGetProcAddress((const GLubyte*)"glPointParameterf")) == NULL) || r; + r = ((glPointParameterfv = (PFNGLPOINTPARAMETERFVPROC)glewGetProcAddress((const GLubyte*)"glPointParameterfv")) == NULL) || r; + r = ((glPointParameteri = (PFNGLPOINTPARAMETERIPROC)glewGetProcAddress((const GLubyte*)"glPointParameteri")) == NULL) || r; + r = ((glPointParameteriv = (PFNGLPOINTPARAMETERIVPROC)glewGetProcAddress((const GLubyte*)"glPointParameteriv")) == NULL) || r; + r = ((glSecondaryColor3b = (PFNGLSECONDARYCOLOR3BPROC)glewGetProcAddress((const GLubyte*)"glSecondaryColor3b")) == NULL) || r; + r = ((glSecondaryColor3bv = (PFNGLSECONDARYCOLOR3BVPROC)glewGetProcAddress((const GLubyte*)"glSecondaryColor3bv")) == NULL) || r; + r = ((glSecondaryColor3d = (PFNGLSECONDARYCOLOR3DPROC)glewGetProcAddress((const GLubyte*)"glSecondaryColor3d")) == NULL) || r; + r = ((glSecondaryColor3dv = (PFNGLSECONDARYCOLOR3DVPROC)glewGetProcAddress((const GLubyte*)"glSecondaryColor3dv")) == NULL) || r; + r = ((glSecondaryColor3f = (PFNGLSECONDARYCOLOR3FPROC)glewGetProcAddress((const GLubyte*)"glSecondaryColor3f")) == NULL) || r; + r = ((glSecondaryColor3fv = (PFNGLSECONDARYCOLOR3FVPROC)glewGetProcAddress((const GLubyte*)"glSecondaryColor3fv")) == NULL) || r; + r = ((glSecondaryColor3i = (PFNGLSECONDARYCOLOR3IPROC)glewGetProcAddress((const GLubyte*)"glSecondaryColor3i")) == NULL) || r; + r = ((glSecondaryColor3iv = (PFNGLSECONDARYCOLOR3IVPROC)glewGetProcAddress((const GLubyte*)"glSecondaryColor3iv")) == NULL) || r; + r = ((glSecondaryColor3s = (PFNGLSECONDARYCOLOR3SPROC)glewGetProcAddress((const GLubyte*)"glSecondaryColor3s")) == NULL) || r; + r = ((glSecondaryColor3sv = (PFNGLSECONDARYCOLOR3SVPROC)glewGetProcAddress((const GLubyte*)"glSecondaryColor3sv")) == NULL) || r; + r = ((glSecondaryColor3ub = (PFNGLSECONDARYCOLOR3UBPROC)glewGetProcAddress((const GLubyte*)"glSecondaryColor3ub")) == NULL) || r; + r = ((glSecondaryColor3ubv = (PFNGLSECONDARYCOLOR3UBVPROC)glewGetProcAddress((const GLubyte*)"glSecondaryColor3ubv")) == NULL) || r; + r = ((glSecondaryColor3ui = (PFNGLSECONDARYCOLOR3UIPROC)glewGetProcAddress((const GLubyte*)"glSecondaryColor3ui")) == NULL) || r; + r = ((glSecondaryColor3uiv = (PFNGLSECONDARYCOLOR3UIVPROC)glewGetProcAddress((const GLubyte*)"glSecondaryColor3uiv")) == NULL) || r; + r = ((glSecondaryColor3us = (PFNGLSECONDARYCOLOR3USPROC)glewGetProcAddress((const GLubyte*)"glSecondaryColor3us")) == NULL) || r; + r = ((glSecondaryColor3usv = (PFNGLSECONDARYCOLOR3USVPROC)glewGetProcAddress((const GLubyte*)"glSecondaryColor3usv")) == NULL) || r; + r = ((glSecondaryColorPointer = (PFNGLSECONDARYCOLORPOINTERPROC)glewGetProcAddress((const GLubyte*)"glSecondaryColorPointer")) == NULL) || r; + r = ((glWindowPos2d = (PFNGLWINDOWPOS2DPROC)glewGetProcAddress((const GLubyte*)"glWindowPos2d")) == NULL) || r; + r = ((glWindowPos2dv = (PFNGLWINDOWPOS2DVPROC)glewGetProcAddress((const GLubyte*)"glWindowPos2dv")) == NULL) || r; + r = ((glWindowPos2f = (PFNGLWINDOWPOS2FPROC)glewGetProcAddress((const GLubyte*)"glWindowPos2f")) == NULL) || r; + r = ((glWindowPos2fv = (PFNGLWINDOWPOS2FVPROC)glewGetProcAddress((const GLubyte*)"glWindowPos2fv")) == NULL) || r; + r = ((glWindowPos2i = (PFNGLWINDOWPOS2IPROC)glewGetProcAddress((const GLubyte*)"glWindowPos2i")) == NULL) || r; + r = ((glWindowPos2iv = (PFNGLWINDOWPOS2IVPROC)glewGetProcAddress((const GLubyte*)"glWindowPos2iv")) == NULL) || r; + r = ((glWindowPos2s = (PFNGLWINDOWPOS2SPROC)glewGetProcAddress((const GLubyte*)"glWindowPos2s")) == NULL) || r; + r = ((glWindowPos2sv = (PFNGLWINDOWPOS2SVPROC)glewGetProcAddress((const GLubyte*)"glWindowPos2sv")) == NULL) || r; + r = ((glWindowPos3d = (PFNGLWINDOWPOS3DPROC)glewGetProcAddress((const GLubyte*)"glWindowPos3d")) == NULL) || r; + r = ((glWindowPos3dv = (PFNGLWINDOWPOS3DVPROC)glewGetProcAddress((const GLubyte*)"glWindowPos3dv")) == NULL) || r; + r = ((glWindowPos3f = (PFNGLWINDOWPOS3FPROC)glewGetProcAddress((const GLubyte*)"glWindowPos3f")) == NULL) || r; + r = ((glWindowPos3fv = (PFNGLWINDOWPOS3FVPROC)glewGetProcAddress((const GLubyte*)"glWindowPos3fv")) == NULL) || r; + r = ((glWindowPos3i = (PFNGLWINDOWPOS3IPROC)glewGetProcAddress((const GLubyte*)"glWindowPos3i")) == NULL) || r; + r = ((glWindowPos3iv = (PFNGLWINDOWPOS3IVPROC)glewGetProcAddress((const GLubyte*)"glWindowPos3iv")) == NULL) || r; + r = ((glWindowPos3s = (PFNGLWINDOWPOS3SPROC)glewGetProcAddress((const GLubyte*)"glWindowPos3s")) == NULL) || r; + r = ((glWindowPos3sv = (PFNGLWINDOWPOS3SVPROC)glewGetProcAddress((const GLubyte*)"glWindowPos3sv")) == NULL) || r; + + return r; +} + +#endif /* GL_VERSION_1_4 */ + +#ifdef GL_VERSION_1_5 + +static GLboolean _glewInit_GL_VERSION_1_5 (GLEW_CONTEXT_ARG_DEF_INIT) +{ + GLboolean r = GL_FALSE; + + r = ((glBeginQuery = (PFNGLBEGINQUERYPROC)glewGetProcAddress((const GLubyte*)"glBeginQuery")) == NULL) || r; + r = ((glBindBuffer = (PFNGLBINDBUFFERPROC)glewGetProcAddress((const GLubyte*)"glBindBuffer")) == NULL) || r; + r = ((glBufferData = (PFNGLBUFFERDATAPROC)glewGetProcAddress((const GLubyte*)"glBufferData")) == NULL) || r; + r = ((glBufferSubData = (PFNGLBUFFERSUBDATAPROC)glewGetProcAddress((const GLubyte*)"glBufferSubData")) == NULL) || r; + r = ((glDeleteBuffers = (PFNGLDELETEBUFFERSPROC)glewGetProcAddress((const GLubyte*)"glDeleteBuffers")) == NULL) || r; + r = ((glDeleteQueries = (PFNGLDELETEQUERIESPROC)glewGetProcAddress((const GLubyte*)"glDeleteQueries")) == NULL) || r; + r = ((glEndQuery = (PFNGLENDQUERYPROC)glewGetProcAddress((const GLubyte*)"glEndQuery")) == NULL) || r; + r = ((glGenBuffers = (PFNGLGENBUFFERSPROC)glewGetProcAddress((const GLubyte*)"glGenBuffers")) == NULL) || r; + r = ((glGenQueries = (PFNGLGENQUERIESPROC)glewGetProcAddress((const GLubyte*)"glGenQueries")) == NULL) || r; + r = ((glGetBufferParameteriv = (PFNGLGETBUFFERPARAMETERIVPROC)glewGetProcAddress((const GLubyte*)"glGetBufferParameteriv")) == NULL) || r; + r = ((glGetBufferPointerv = (PFNGLGETBUFFERPOINTERVPROC)glewGetProcAddress((const GLubyte*)"glGetBufferPointerv")) == NULL) || r; + r = ((glGetBufferSubData = (PFNGLGETBUFFERSUBDATAPROC)glewGetProcAddress((const GLubyte*)"glGetBufferSubData")) == NULL) || r; + r = ((glGetQueryObjectiv = (PFNGLGETQUERYOBJECTIVPROC)glewGetProcAddress((const GLubyte*)"glGetQueryObjectiv")) == NULL) || r; + r = ((glGetQueryObjectuiv = (PFNGLGETQUERYOBJECTUIVPROC)glewGetProcAddress((const GLubyte*)"glGetQueryObjectuiv")) == NULL) || r; + r = ((glGetQueryiv = (PFNGLGETQUERYIVPROC)glewGetProcAddress((const GLubyte*)"glGetQueryiv")) == NULL) || r; + r = ((glIsBuffer = (PFNGLISBUFFERPROC)glewGetProcAddress((const GLubyte*)"glIsBuffer")) == NULL) || r; + r = ((glIsQuery = (PFNGLISQUERYPROC)glewGetProcAddress((const GLubyte*)"glIsQuery")) == NULL) || r; + r = ((glMapBuffer = (PFNGLMAPBUFFERPROC)glewGetProcAddress((const GLubyte*)"glMapBuffer")) == NULL) || r; + r = ((glUnmapBuffer = (PFNGLUNMAPBUFFERPROC)glewGetProcAddress((const GLubyte*)"glUnmapBuffer")) == NULL) || r; + + return r; +} + +#endif /* GL_VERSION_1_5 */ + +#ifdef GL_VERSION_2_0 + +static GLboolean _glewInit_GL_VERSION_2_0 (GLEW_CONTEXT_ARG_DEF_INIT) +{ + GLboolean r = GL_FALSE; + + r = ((glAttachShader = (PFNGLATTACHSHADERPROC)glewGetProcAddress((const GLubyte*)"glAttachShader")) == NULL) || r; + r = ((glBindAttribLocation = (PFNGLBINDATTRIBLOCATIONPROC)glewGetProcAddress((const GLubyte*)"glBindAttribLocation")) == NULL) || r; + r = ((glBlendEquationSeparate = (PFNGLBLENDEQUATIONSEPARATEPROC)glewGetProcAddress((const GLubyte*)"glBlendEquationSeparate")) == NULL) || r; + r = ((glCompileShader = (PFNGLCOMPILESHADERPROC)glewGetProcAddress((const GLubyte*)"glCompileShader")) == NULL) || r; + r = ((glCreateProgram = (PFNGLCREATEPROGRAMPROC)glewGetProcAddress((const GLubyte*)"glCreateProgram")) == NULL) || r; + r = ((glCreateShader = (PFNGLCREATESHADERPROC)glewGetProcAddress((const GLubyte*)"glCreateShader")) == NULL) || r; + r = ((glDeleteProgram = (PFNGLDELETEPROGRAMPROC)glewGetProcAddress((const GLubyte*)"glDeleteProgram")) == NULL) || r; + r = ((glDeleteShader = (PFNGLDELETESHADERPROC)glewGetProcAddress((const GLubyte*)"glDeleteShader")) == NULL) || r; + r = ((glDetachShader = (PFNGLDETACHSHADERPROC)glewGetProcAddress((const GLubyte*)"glDetachShader")) == NULL) || r; + r = ((glDisableVertexAttribArray = (PFNGLDISABLEVERTEXATTRIBARRAYPROC)glewGetProcAddress((const GLubyte*)"glDisableVertexAttribArray")) == NULL) || r; + r = ((glDrawBuffers = (PFNGLDRAWBUFFERSPROC)glewGetProcAddress((const GLubyte*)"glDrawBuffers")) == NULL) || r; + r = ((glEnableVertexAttribArray = (PFNGLENABLEVERTEXATTRIBARRAYPROC)glewGetProcAddress((const GLubyte*)"glEnableVertexAttribArray")) == NULL) || r; + r = ((glGetActiveAttrib = (PFNGLGETACTIVEATTRIBPROC)glewGetProcAddress((const GLubyte*)"glGetActiveAttrib")) == NULL) || r; + r = ((glGetActiveUniform = (PFNGLGETACTIVEUNIFORMPROC)glewGetProcAddress((const GLubyte*)"glGetActiveUniform")) == NULL) || r; + r = ((glGetAttachedShaders = (PFNGLGETATTACHEDSHADERSPROC)glewGetProcAddress((const GLubyte*)"glGetAttachedShaders")) == NULL) || r; + r = ((glGetAttribLocation = (PFNGLGETATTRIBLOCATIONPROC)glewGetProcAddress((const GLubyte*)"glGetAttribLocation")) == NULL) || r; + r = ((glGetProgramInfoLog = (PFNGLGETPROGRAMINFOLOGPROC)glewGetProcAddress((const GLubyte*)"glGetProgramInfoLog")) == NULL) || r; + r = ((glGetProgramiv = (PFNGLGETPROGRAMIVPROC)glewGetProcAddress((const GLubyte*)"glGetProgramiv")) == NULL) || r; + r = ((glGetShaderInfoLog = (PFNGLGETSHADERINFOLOGPROC)glewGetProcAddress((const GLubyte*)"glGetShaderInfoLog")) == NULL) || r; + r = ((glGetShaderSource = (PFNGLGETSHADERSOURCEPROC)glewGetProcAddress((const GLubyte*)"glGetShaderSource")) == NULL) || r; + r = ((glGetShaderiv = (PFNGLGETSHADERIVPROC)glewGetProcAddress((const GLubyte*)"glGetShaderiv")) == NULL) || r; + r = ((glGetUniformLocation = (PFNGLGETUNIFORMLOCATIONPROC)glewGetProcAddress((const GLubyte*)"glGetUniformLocation")) == NULL) || r; + r = ((glGetUniformfv = (PFNGLGETUNIFORMFVPROC)glewGetProcAddress((const GLubyte*)"glGetUniformfv")) == NULL) || r; + r = ((glGetUniformiv = (PFNGLGETUNIFORMIVPROC)glewGetProcAddress((const GLubyte*)"glGetUniformiv")) == NULL) || r; + r = ((glGetVertexAttribPointerv = (PFNGLGETVERTEXATTRIBPOINTERVPROC)glewGetProcAddress((const GLubyte*)"glGetVertexAttribPointerv")) == NULL) || r; + r = ((glGetVertexAttribdv = (PFNGLGETVERTEXATTRIBDVPROC)glewGetProcAddress((const GLubyte*)"glGetVertexAttribdv")) == NULL) || r; + r = ((glGetVertexAttribfv = (PFNGLGETVERTEXATTRIBFVPROC)glewGetProcAddress((const GLubyte*)"glGetVertexAttribfv")) == NULL) || r; + r = ((glGetVertexAttribiv = (PFNGLGETVERTEXATTRIBIVPROC)glewGetProcAddress((const GLubyte*)"glGetVertexAttribiv")) == NULL) || r; + r = ((glIsProgram = (PFNGLISPROGRAMPROC)glewGetProcAddress((const GLubyte*)"glIsProgram")) == NULL) || r; + r = ((glIsShader = (PFNGLISSHADERPROC)glewGetProcAddress((const GLubyte*)"glIsShader")) == NULL) || r; + r = ((glLinkProgram = (PFNGLLINKPROGRAMPROC)glewGetProcAddress((const GLubyte*)"glLinkProgram")) == NULL) || r; + r = ((glShaderSource = (PFNGLSHADERSOURCEPROC)glewGetProcAddress((const GLubyte*)"glShaderSource")) == NULL) || r; + r = ((glStencilFuncSeparate = (PFNGLSTENCILFUNCSEPARATEPROC)glewGetProcAddress((const GLubyte*)"glStencilFuncSeparate")) == NULL) || r; + r = ((glStencilMaskSeparate = (PFNGLSTENCILMASKSEPARATEPROC)glewGetProcAddress((const GLubyte*)"glStencilMaskSeparate")) == NULL) || r; + r = ((glStencilOpSeparate = (PFNGLSTENCILOPSEPARATEPROC)glewGetProcAddress((const GLubyte*)"glStencilOpSeparate")) == NULL) || r; + r = ((glUniform1f = (PFNGLUNIFORM1FPROC)glewGetProcAddress((const GLubyte*)"glUniform1f")) == NULL) || r; + r = ((glUniform1fv = (PFNGLUNIFORM1FVPROC)glewGetProcAddress((const GLubyte*)"glUniform1fv")) == NULL) || r; + r = ((glUniform1i = (PFNGLUNIFORM1IPROC)glewGetProcAddress((const GLubyte*)"glUniform1i")) == NULL) || r; + r = ((glUniform1iv = (PFNGLUNIFORM1IVPROC)glewGetProcAddress((const GLubyte*)"glUniform1iv")) == NULL) || r; + r = ((glUniform2f = (PFNGLUNIFORM2FPROC)glewGetProcAddress((const GLubyte*)"glUniform2f")) == NULL) || r; + r = ((glUniform2fv = (PFNGLUNIFORM2FVPROC)glewGetProcAddress((const GLubyte*)"glUniform2fv")) == NULL) || r; + r = ((glUniform2i = (PFNGLUNIFORM2IPROC)glewGetProcAddress((const GLubyte*)"glUniform2i")) == NULL) || r; + r = ((glUniform2iv = (PFNGLUNIFORM2IVPROC)glewGetProcAddress((const GLubyte*)"glUniform2iv")) == NULL) || r; + r = ((glUniform3f = (PFNGLUNIFORM3FPROC)glewGetProcAddress((const GLubyte*)"glUniform3f")) == NULL) || r; + r = ((glUniform3fv = (PFNGLUNIFORM3FVPROC)glewGetProcAddress((const GLubyte*)"glUniform3fv")) == NULL) || r; + r = ((glUniform3i = (PFNGLUNIFORM3IPROC)glewGetProcAddress((const GLubyte*)"glUniform3i")) == NULL) || r; + r = ((glUniform3iv = (PFNGLUNIFORM3IVPROC)glewGetProcAddress((const GLubyte*)"glUniform3iv")) == NULL) || r; + r = ((glUniform4f = (PFNGLUNIFORM4FPROC)glewGetProcAddress((const GLubyte*)"glUniform4f")) == NULL) || r; + r = ((glUniform4fv = (PFNGLUNIFORM4FVPROC)glewGetProcAddress((const GLubyte*)"glUniform4fv")) == NULL) || r; + r = ((glUniform4i = (PFNGLUNIFORM4IPROC)glewGetProcAddress((const GLubyte*)"glUniform4i")) == NULL) || r; + r = ((glUniform4iv = (PFNGLUNIFORM4IVPROC)glewGetProcAddress((const GLubyte*)"glUniform4iv")) == NULL) || r; + r = ((glUniformMatrix2fv = (PFNGLUNIFORMMATRIX2FVPROC)glewGetProcAddress((const GLubyte*)"glUniformMatrix2fv")) == NULL) || r; + r = ((glUniformMatrix3fv = (PFNGLUNIFORMMATRIX3FVPROC)glewGetProcAddress((const GLubyte*)"glUniformMatrix3fv")) == NULL) || r; + r = ((glUniformMatrix4fv = (PFNGLUNIFORMMATRIX4FVPROC)glewGetProcAddress((const GLubyte*)"glUniformMatrix4fv")) == NULL) || r; + r = ((glUseProgram = (PFNGLUSEPROGRAMPROC)glewGetProcAddress((const GLubyte*)"glUseProgram")) == NULL) || r; + r = ((glValidateProgram = (PFNGLVALIDATEPROGRAMPROC)glewGetProcAddress((const GLubyte*)"glValidateProgram")) == NULL) || r; + r = ((glVertexAttrib1d = (PFNGLVERTEXATTRIB1DPROC)glewGetProcAddress((const GLubyte*)"glVertexAttrib1d")) == NULL) || r; + r = ((glVertexAttrib1dv = (PFNGLVERTEXATTRIB1DVPROC)glewGetProcAddress((const GLubyte*)"glVertexAttrib1dv")) == NULL) || r; + r = ((glVertexAttrib1f = (PFNGLVERTEXATTRIB1FPROC)glewGetProcAddress((const GLubyte*)"glVertexAttrib1f")) == NULL) || r; + r = ((glVertexAttrib1fv = (PFNGLVERTEXATTRIB1FVPROC)glewGetProcAddress((const GLubyte*)"glVertexAttrib1fv")) == NULL) || r; + r = ((glVertexAttrib1s = (PFNGLVERTEXATTRIB1SPROC)glewGetProcAddress((const GLubyte*)"glVertexAttrib1s")) == NULL) || r; + r = ((glVertexAttrib1sv = (PFNGLVERTEXATTRIB1SVPROC)glewGetProcAddress((const GLubyte*)"glVertexAttrib1sv")) == NULL) || r; + r = ((glVertexAttrib2d = (PFNGLVERTEXATTRIB2DPROC)glewGetProcAddress((const GLubyte*)"glVertexAttrib2d")) == NULL) || r; + r = ((glVertexAttrib2dv = (PFNGLVERTEXATTRIB2DVPROC)glewGetProcAddress((const GLubyte*)"glVertexAttrib2dv")) == NULL) || r; + r = ((glVertexAttrib2f = (PFNGLVERTEXATTRIB2FPROC)glewGetProcAddress((const GLubyte*)"glVertexAttrib2f")) == NULL) || r; + r = ((glVertexAttrib2fv = (PFNGLVERTEXATTRIB2FVPROC)glewGetProcAddress((const GLubyte*)"glVertexAttrib2fv")) == NULL) || r; + r = ((glVertexAttrib2s = (PFNGLVERTEXATTRIB2SPROC)glewGetProcAddress((const GLubyte*)"glVertexAttrib2s")) == NULL) || r; + r = ((glVertexAttrib2sv = (PFNGLVERTEXATTRIB2SVPROC)glewGetProcAddress((const GLubyte*)"glVertexAttrib2sv")) == NULL) || r; + r = ((glVertexAttrib3d = (PFNGLVERTEXATTRIB3DPROC)glewGetProcAddress((const GLubyte*)"glVertexAttrib3d")) == NULL) || r; + r = ((glVertexAttrib3dv = (PFNGLVERTEXATTRIB3DVPROC)glewGetProcAddress((const GLubyte*)"glVertexAttrib3dv")) == NULL) || r; + r = ((glVertexAttrib3f = (PFNGLVERTEXATTRIB3FPROC)glewGetProcAddress((const GLubyte*)"glVertexAttrib3f")) == NULL) || r; + r = ((glVertexAttrib3fv = (PFNGLVERTEXATTRIB3FVPROC)glewGetProcAddress((const GLubyte*)"glVertexAttrib3fv")) == NULL) || r; + r = ((glVertexAttrib3s = (PFNGLVERTEXATTRIB3SPROC)glewGetProcAddress((const GLubyte*)"glVertexAttrib3s")) == NULL) || r; + r = ((glVertexAttrib3sv = (PFNGLVERTEXATTRIB3SVPROC)glewGetProcAddress((const GLubyte*)"glVertexAttrib3sv")) == NULL) || r; + r = ((glVertexAttrib4Nbv = (PFNGLVERTEXATTRIB4NBVPROC)glewGetProcAddress((const GLubyte*)"glVertexAttrib4Nbv")) == NULL) || r; + r = ((glVertexAttrib4Niv = (PFNGLVERTEXATTRIB4NIVPROC)glewGetProcAddress((const GLubyte*)"glVertexAttrib4Niv")) == NULL) || r; + r = ((glVertexAttrib4Nsv = (PFNGLVERTEXATTRIB4NSVPROC)glewGetProcAddress((const GLubyte*)"glVertexAttrib4Nsv")) == NULL) || r; + r = ((glVertexAttrib4Nub = (PFNGLVERTEXATTRIB4NUBPROC)glewGetProcAddress((const GLubyte*)"glVertexAttrib4Nub")) == NULL) || r; + r = ((glVertexAttrib4Nubv = (PFNGLVERTEXATTRIB4NUBVPROC)glewGetProcAddress((const GLubyte*)"glVertexAttrib4Nubv")) == NULL) || r; + r = ((glVertexAttrib4Nuiv = (PFNGLVERTEXATTRIB4NUIVPROC)glewGetProcAddress((const GLubyte*)"glVertexAttrib4Nuiv")) == NULL) || r; + r = ((glVertexAttrib4Nusv = (PFNGLVERTEXATTRIB4NUSVPROC)glewGetProcAddress((const GLubyte*)"glVertexAttrib4Nusv")) == NULL) || r; + r = ((glVertexAttrib4bv = (PFNGLVERTEXATTRIB4BVPROC)glewGetProcAddress((const GLubyte*)"glVertexAttrib4bv")) == NULL) || r; + r = ((glVertexAttrib4d = (PFNGLVERTEXATTRIB4DPROC)glewGetProcAddress((const GLubyte*)"glVertexAttrib4d")) == NULL) || r; + r = ((glVertexAttrib4dv = (PFNGLVERTEXATTRIB4DVPROC)glewGetProcAddress((const GLubyte*)"glVertexAttrib4dv")) == NULL) || r; + r = ((glVertexAttrib4f = (PFNGLVERTEXATTRIB4FPROC)glewGetProcAddress((const GLubyte*)"glVertexAttrib4f")) == NULL) || r; + r = ((glVertexAttrib4fv = (PFNGLVERTEXATTRIB4FVPROC)glewGetProcAddress((const GLubyte*)"glVertexAttrib4fv")) == NULL) || r; + r = ((glVertexAttrib4iv = (PFNGLVERTEXATTRIB4IVPROC)glewGetProcAddress((const GLubyte*)"glVertexAttrib4iv")) == NULL) || r; + r = ((glVertexAttrib4s = (PFNGLVERTEXATTRIB4SPROC)glewGetProcAddress((const GLubyte*)"glVertexAttrib4s")) == NULL) || r; + r = ((glVertexAttrib4sv = (PFNGLVERTEXATTRIB4SVPROC)glewGetProcAddress((const GLubyte*)"glVertexAttrib4sv")) == NULL) || r; + r = ((glVertexAttrib4ubv = (PFNGLVERTEXATTRIB4UBVPROC)glewGetProcAddress((const GLubyte*)"glVertexAttrib4ubv")) == NULL) || r; + r = ((glVertexAttrib4uiv = (PFNGLVERTEXATTRIB4UIVPROC)glewGetProcAddress((const GLubyte*)"glVertexAttrib4uiv")) == NULL) || r; + r = ((glVertexAttrib4usv = (PFNGLVERTEXATTRIB4USVPROC)glewGetProcAddress((const GLubyte*)"glVertexAttrib4usv")) == NULL) || r; + r = ((glVertexAttribPointer = (PFNGLVERTEXATTRIBPOINTERPROC)glewGetProcAddress((const GLubyte*)"glVertexAttribPointer")) == NULL) || r; + + return r; +} + +#endif /* GL_VERSION_2_0 */ + +#ifdef GL_VERSION_2_1 + +static GLboolean _glewInit_GL_VERSION_2_1 (GLEW_CONTEXT_ARG_DEF_INIT) +{ + GLboolean r = GL_FALSE; + + r = ((glUniformMatrix2x3fv = (PFNGLUNIFORMMATRIX2X3FVPROC)glewGetProcAddress((const GLubyte*)"glUniformMatrix2x3fv")) == NULL) || r; + r = ((glUniformMatrix2x4fv = (PFNGLUNIFORMMATRIX2X4FVPROC)glewGetProcAddress((const GLubyte*)"glUniformMatrix2x4fv")) == NULL) || r; + r = ((glUniformMatrix3x2fv = (PFNGLUNIFORMMATRIX3X2FVPROC)glewGetProcAddress((const GLubyte*)"glUniformMatrix3x2fv")) == NULL) || r; + r = ((glUniformMatrix3x4fv = (PFNGLUNIFORMMATRIX3X4FVPROC)glewGetProcAddress((const GLubyte*)"glUniformMatrix3x4fv")) == NULL) || r; + r = ((glUniformMatrix4x2fv = (PFNGLUNIFORMMATRIX4X2FVPROC)glewGetProcAddress((const GLubyte*)"glUniformMatrix4x2fv")) == NULL) || r; + r = ((glUniformMatrix4x3fv = (PFNGLUNIFORMMATRIX4X3FVPROC)glewGetProcAddress((const GLubyte*)"glUniformMatrix4x3fv")) == NULL) || r; + + return r; +} + +#endif /* GL_VERSION_2_1 */ + +#ifdef GL_VERSION_3_0 + +static GLboolean _glewInit_GL_VERSION_3_0 (GLEW_CONTEXT_ARG_DEF_INIT) +{ + GLboolean r = GL_FALSE; + + r = ((glBeginConditionalRender = (PFNGLBEGINCONDITIONALRENDERPROC)glewGetProcAddress((const GLubyte*)"glBeginConditionalRender")) == NULL) || r; + r = ((glBeginTransformFeedback = (PFNGLBEGINTRANSFORMFEEDBACKPROC)glewGetProcAddress((const GLubyte*)"glBeginTransformFeedback")) == NULL) || r; + r = ((glBindBufferBase = (PFNGLBINDBUFFERBASEPROC)glewGetProcAddress((const GLubyte*)"glBindBufferBase")) == NULL) || r; + r = ((glBindBufferRange = (PFNGLBINDBUFFERRANGEPROC)glewGetProcAddress((const GLubyte*)"glBindBufferRange")) == NULL) || r; + r = ((glBindFragDataLocation = (PFNGLBINDFRAGDATALOCATIONPROC)glewGetProcAddress((const GLubyte*)"glBindFragDataLocation")) == NULL) || r; + r = ((glClampColor = (PFNGLCLAMPCOLORPROC)glewGetProcAddress((const GLubyte*)"glClampColor")) == NULL) || r; + r = ((glClearBufferfi = (PFNGLCLEARBUFFERFIPROC)glewGetProcAddress((const GLubyte*)"glClearBufferfi")) == NULL) || r; + r = ((glClearBufferfv = (PFNGLCLEARBUFFERFVPROC)glewGetProcAddress((const GLubyte*)"glClearBufferfv")) == NULL) || r; + r = ((glClearBufferiv = (PFNGLCLEARBUFFERIVPROC)glewGetProcAddress((const GLubyte*)"glClearBufferiv")) == NULL) || r; + r = ((glClearBufferuiv = (PFNGLCLEARBUFFERUIVPROC)glewGetProcAddress((const GLubyte*)"glClearBufferuiv")) == NULL) || r; + r = ((glColorMaski = (PFNGLCOLORMASKIPROC)glewGetProcAddress((const GLubyte*)"glColorMaski")) == NULL) || r; + r = ((glDisablei = (PFNGLDISABLEIPROC)glewGetProcAddress((const GLubyte*)"glDisablei")) == NULL) || r; + r = ((glEnablei = (PFNGLENABLEIPROC)glewGetProcAddress((const GLubyte*)"glEnablei")) == NULL) || r; + r = ((glEndConditionalRender = (PFNGLENDCONDITIONALRENDERPROC)glewGetProcAddress((const GLubyte*)"glEndConditionalRender")) == NULL) || r; + r = ((glEndTransformFeedback = (PFNGLENDTRANSFORMFEEDBACKPROC)glewGetProcAddress((const GLubyte*)"glEndTransformFeedback")) == NULL) || r; + r = ((glGetBooleani_v = (PFNGLGETBOOLEANI_VPROC)glewGetProcAddress((const GLubyte*)"glGetBooleani_v")) == NULL) || r; + r = ((glGetFragDataLocation = (PFNGLGETFRAGDATALOCATIONPROC)glewGetProcAddress((const GLubyte*)"glGetFragDataLocation")) == NULL) || r; + r = ((glGetIntegeri_v = (PFNGLGETINTEGERI_VPROC)glewGetProcAddress((const GLubyte*)"glGetIntegeri_v")) == NULL) || r; + r = ((glGetStringi = (PFNGLGETSTRINGIPROC)glewGetProcAddress((const GLubyte*)"glGetStringi")) == NULL) || r; + r = ((glGetTexParameterIiv = (PFNGLGETTEXPARAMETERIIVPROC)glewGetProcAddress((const GLubyte*)"glGetTexParameterIiv")) == NULL) || r; + r = ((glGetTexParameterIuiv = (PFNGLGETTEXPARAMETERIUIVPROC)glewGetProcAddress((const GLubyte*)"glGetTexParameterIuiv")) == NULL) || r; + r = ((glGetTransformFeedbackVarying = (PFNGLGETTRANSFORMFEEDBACKVARYINGPROC)glewGetProcAddress((const GLubyte*)"glGetTransformFeedbackVarying")) == NULL) || r; + r = ((glGetUniformuiv = (PFNGLGETUNIFORMUIVPROC)glewGetProcAddress((const GLubyte*)"glGetUniformuiv")) == NULL) || r; + r = ((glGetVertexAttribIiv = (PFNGLGETVERTEXATTRIBIIVPROC)glewGetProcAddress((const GLubyte*)"glGetVertexAttribIiv")) == NULL) || r; + r = ((glGetVertexAttribIuiv = (PFNGLGETVERTEXATTRIBIUIVPROC)glewGetProcAddress((const GLubyte*)"glGetVertexAttribIuiv")) == NULL) || r; + r = ((glIsEnabledi = (PFNGLISENABLEDIPROC)glewGetProcAddress((const GLubyte*)"glIsEnabledi")) == NULL) || r; + r = ((glTexParameterIiv = (PFNGLTEXPARAMETERIIVPROC)glewGetProcAddress((const GLubyte*)"glTexParameterIiv")) == NULL) || r; + r = ((glTexParameterIuiv = (PFNGLTEXPARAMETERIUIVPROC)glewGetProcAddress((const GLubyte*)"glTexParameterIuiv")) == NULL) || r; + r = ((glTransformFeedbackVaryings = (PFNGLTRANSFORMFEEDBACKVARYINGSPROC)glewGetProcAddress((const GLubyte*)"glTransformFeedbackVaryings")) == NULL) || r; + r = ((glUniform1ui = (PFNGLUNIFORM1UIPROC)glewGetProcAddress((const GLubyte*)"glUniform1ui")) == NULL) || r; + r = ((glUniform1uiv = (PFNGLUNIFORM1UIVPROC)glewGetProcAddress((const GLubyte*)"glUniform1uiv")) == NULL) || r; + r = ((glUniform2ui = (PFNGLUNIFORM2UIPROC)glewGetProcAddress((const GLubyte*)"glUniform2ui")) == NULL) || r; + r = ((glUniform2uiv = (PFNGLUNIFORM2UIVPROC)glewGetProcAddress((const GLubyte*)"glUniform2uiv")) == NULL) || r; + r = ((glUniform3ui = (PFNGLUNIFORM3UIPROC)glewGetProcAddress((const GLubyte*)"glUniform3ui")) == NULL) || r; + r = ((glUniform3uiv = (PFNGLUNIFORM3UIVPROC)glewGetProcAddress((const GLubyte*)"glUniform3uiv")) == NULL) || r; + r = ((glUniform4ui = (PFNGLUNIFORM4UIPROC)glewGetProcAddress((const GLubyte*)"glUniform4ui")) == NULL) || r; + r = ((glUniform4uiv = (PFNGLUNIFORM4UIVPROC)glewGetProcAddress((const GLubyte*)"glUniform4uiv")) == NULL) || r; + r = ((glVertexAttribI1i = (PFNGLVERTEXATTRIBI1IPROC)glewGetProcAddress((const GLubyte*)"glVertexAttribI1i")) == NULL) || r; + r = ((glVertexAttribI1iv = (PFNGLVERTEXATTRIBI1IVPROC)glewGetProcAddress((const GLubyte*)"glVertexAttribI1iv")) == NULL) || r; + r = ((glVertexAttribI1ui = (PFNGLVERTEXATTRIBI1UIPROC)glewGetProcAddress((const GLubyte*)"glVertexAttribI1ui")) == NULL) || r; + r = ((glVertexAttribI1uiv = (PFNGLVERTEXATTRIBI1UIVPROC)glewGetProcAddress((const GLubyte*)"glVertexAttribI1uiv")) == NULL) || r; + r = ((glVertexAttribI2i = (PFNGLVERTEXATTRIBI2IPROC)glewGetProcAddress((const GLubyte*)"glVertexAttribI2i")) == NULL) || r; + r = ((glVertexAttribI2iv = (PFNGLVERTEXATTRIBI2IVPROC)glewGetProcAddress((const GLubyte*)"glVertexAttribI2iv")) == NULL) || r; + r = ((glVertexAttribI2ui = (PFNGLVERTEXATTRIBI2UIPROC)glewGetProcAddress((const GLubyte*)"glVertexAttribI2ui")) == NULL) || r; + r = ((glVertexAttribI2uiv = (PFNGLVERTEXATTRIBI2UIVPROC)glewGetProcAddress((const GLubyte*)"glVertexAttribI2uiv")) == NULL) || r; + r = ((glVertexAttribI3i = (PFNGLVERTEXATTRIBI3IPROC)glewGetProcAddress((const GLubyte*)"glVertexAttribI3i")) == NULL) || r; + r = ((glVertexAttribI3iv = (PFNGLVERTEXATTRIBI3IVPROC)glewGetProcAddress((const GLubyte*)"glVertexAttribI3iv")) == NULL) || r; + r = ((glVertexAttribI3ui = (PFNGLVERTEXATTRIBI3UIPROC)glewGetProcAddress((const GLubyte*)"glVertexAttribI3ui")) == NULL) || r; + r = ((glVertexAttribI3uiv = (PFNGLVERTEXATTRIBI3UIVPROC)glewGetProcAddress((const GLubyte*)"glVertexAttribI3uiv")) == NULL) || r; + r = ((glVertexAttribI4bv = (PFNGLVERTEXATTRIBI4BVPROC)glewGetProcAddress((const GLubyte*)"glVertexAttribI4bv")) == NULL) || r; + r = ((glVertexAttribI4i = (PFNGLVERTEXATTRIBI4IPROC)glewGetProcAddress((const GLubyte*)"glVertexAttribI4i")) == NULL) || r; + r = ((glVertexAttribI4iv = (PFNGLVERTEXATTRIBI4IVPROC)glewGetProcAddress((const GLubyte*)"glVertexAttribI4iv")) == NULL) || r; + r = ((glVertexAttribI4sv = (PFNGLVERTEXATTRIBI4SVPROC)glewGetProcAddress((const GLubyte*)"glVertexAttribI4sv")) == NULL) || r; + r = ((glVertexAttribI4ubv = (PFNGLVERTEXATTRIBI4UBVPROC)glewGetProcAddress((const GLubyte*)"glVertexAttribI4ubv")) == NULL) || r; + r = ((glVertexAttribI4ui = (PFNGLVERTEXATTRIBI4UIPROC)glewGetProcAddress((const GLubyte*)"glVertexAttribI4ui")) == NULL) || r; + r = ((glVertexAttribI4uiv = (PFNGLVERTEXATTRIBI4UIVPROC)glewGetProcAddress((const GLubyte*)"glVertexAttribI4uiv")) == NULL) || r; + r = ((glVertexAttribI4usv = (PFNGLVERTEXATTRIBI4USVPROC)glewGetProcAddress((const GLubyte*)"glVertexAttribI4usv")) == NULL) || r; + r = ((glVertexAttribIPointer = (PFNGLVERTEXATTRIBIPOINTERPROC)glewGetProcAddress((const GLubyte*)"glVertexAttribIPointer")) == NULL) || r; + + return r; +} + +#endif /* GL_VERSION_3_0 */ + +#ifdef GL_3DFX_multisample + +#endif /* GL_3DFX_multisample */ + +#ifdef GL_3DFX_tbuffer + +static GLboolean _glewInit_GL_3DFX_tbuffer (GLEW_CONTEXT_ARG_DEF_INIT) +{ + GLboolean r = GL_FALSE; + + r = ((glTbufferMask3DFX = (PFNGLTBUFFERMASK3DFXPROC)glewGetProcAddress((const GLubyte*)"glTbufferMask3DFX")) == NULL) || r; + + return r; +} + +#endif /* GL_3DFX_tbuffer */ + +#ifdef GL_3DFX_texture_compression_FXT1 + +#endif /* GL_3DFX_texture_compression_FXT1 */ + +#ifdef GL_APPLE_client_storage + +#endif /* GL_APPLE_client_storage */ + +#ifdef GL_APPLE_element_array + +static GLboolean _glewInit_GL_APPLE_element_array (GLEW_CONTEXT_ARG_DEF_INIT) +{ + GLboolean r = GL_FALSE; + + r = ((glDrawElementArrayAPPLE = (PFNGLDRAWELEMENTARRAYAPPLEPROC)glewGetProcAddress((const GLubyte*)"glDrawElementArrayAPPLE")) == NULL) || r; + r = ((glDrawRangeElementArrayAPPLE = (PFNGLDRAWRANGEELEMENTARRAYAPPLEPROC)glewGetProcAddress((const GLubyte*)"glDrawRangeElementArrayAPPLE")) == NULL) || r; + r = ((glElementPointerAPPLE = (PFNGLELEMENTPOINTERAPPLEPROC)glewGetProcAddress((const GLubyte*)"glElementPointerAPPLE")) == NULL) || r; + r = ((glMultiDrawElementArrayAPPLE = (PFNGLMULTIDRAWELEMENTARRAYAPPLEPROC)glewGetProcAddress((const GLubyte*)"glMultiDrawElementArrayAPPLE")) == NULL) || r; + r = ((glMultiDrawRangeElementArrayAPPLE = (PFNGLMULTIDRAWRANGEELEMENTARRAYAPPLEPROC)glewGetProcAddress((const GLubyte*)"glMultiDrawRangeElementArrayAPPLE")) == NULL) || r; + + return r; +} + +#endif /* GL_APPLE_element_array */ + +#ifdef GL_APPLE_fence + +static GLboolean _glewInit_GL_APPLE_fence (GLEW_CONTEXT_ARG_DEF_INIT) +{ + GLboolean r = GL_FALSE; + + r = ((glDeleteFencesAPPLE = (PFNGLDELETEFENCESAPPLEPROC)glewGetProcAddress((const GLubyte*)"glDeleteFencesAPPLE")) == NULL) || r; + r = ((glFinishFenceAPPLE = (PFNGLFINISHFENCEAPPLEPROC)glewGetProcAddress((const GLubyte*)"glFinishFenceAPPLE")) == NULL) || r; + r = ((glFinishObjectAPPLE = (PFNGLFINISHOBJECTAPPLEPROC)glewGetProcAddress((const GLubyte*)"glFinishObjectAPPLE")) == NULL) || r; + r = ((glGenFencesAPPLE = (PFNGLGENFENCESAPPLEPROC)glewGetProcAddress((const GLubyte*)"glGenFencesAPPLE")) == NULL) || r; + r = ((glIsFenceAPPLE = (PFNGLISFENCEAPPLEPROC)glewGetProcAddress((const GLubyte*)"glIsFenceAPPLE")) == NULL) || r; + r = ((glSetFenceAPPLE = (PFNGLSETFENCEAPPLEPROC)glewGetProcAddress((const GLubyte*)"glSetFenceAPPLE")) == NULL) || r; + r = ((glTestFenceAPPLE = (PFNGLTESTFENCEAPPLEPROC)glewGetProcAddress((const GLubyte*)"glTestFenceAPPLE")) == NULL) || r; + r = ((glTestObjectAPPLE = (PFNGLTESTOBJECTAPPLEPROC)glewGetProcAddress((const GLubyte*)"glTestObjectAPPLE")) == NULL) || r; + + return r; +} + +#endif /* GL_APPLE_fence */ + +#ifdef GL_APPLE_float_pixels + +#endif /* GL_APPLE_float_pixels */ + +#ifdef GL_APPLE_flush_buffer_range + +static GLboolean _glewInit_GL_APPLE_flush_buffer_range (GLEW_CONTEXT_ARG_DEF_INIT) +{ + GLboolean r = GL_FALSE; + + r = ((glBufferParameteriAPPLE = (PFNGLBUFFERPARAMETERIAPPLEPROC)glewGetProcAddress((const GLubyte*)"glBufferParameteriAPPLE")) == NULL) || r; + r = ((glFlushMappedBufferRangeAPPLE = (PFNGLFLUSHMAPPEDBUFFERRANGEAPPLEPROC)glewGetProcAddress((const GLubyte*)"glFlushMappedBufferRangeAPPLE")) == NULL) || r; + + return r; +} + +#endif /* GL_APPLE_flush_buffer_range */ + +#ifdef GL_APPLE_pixel_buffer + +#endif /* GL_APPLE_pixel_buffer */ + +#ifdef GL_APPLE_specular_vector + +#endif /* GL_APPLE_specular_vector */ + +#ifdef GL_APPLE_texture_range + +static GLboolean _glewInit_GL_APPLE_texture_range (GLEW_CONTEXT_ARG_DEF_INIT) +{ + GLboolean r = GL_FALSE; + + r = ((glGetTexParameterPointervAPPLE = (PFNGLGETTEXPARAMETERPOINTERVAPPLEPROC)glewGetProcAddress((const GLubyte*)"glGetTexParameterPointervAPPLE")) == NULL) || r; + r = ((glTextureRangeAPPLE = (PFNGLTEXTURERANGEAPPLEPROC)glewGetProcAddress((const GLubyte*)"glTextureRangeAPPLE")) == NULL) || r; + + return r; +} + +#endif /* GL_APPLE_texture_range */ + +#ifdef GL_APPLE_transform_hint + +#endif /* GL_APPLE_transform_hint */ + +#ifdef GL_APPLE_vertex_array_object + +static GLboolean _glewInit_GL_APPLE_vertex_array_object (GLEW_CONTEXT_ARG_DEF_INIT) +{ + GLboolean r = GL_FALSE; + + r = ((glBindVertexArrayAPPLE = (PFNGLBINDVERTEXARRAYAPPLEPROC)glewGetProcAddress((const GLubyte*)"glBindVertexArrayAPPLE")) == NULL) || r; + r = ((glDeleteVertexArraysAPPLE = (PFNGLDELETEVERTEXARRAYSAPPLEPROC)glewGetProcAddress((const GLubyte*)"glDeleteVertexArraysAPPLE")) == NULL) || r; + r = ((glGenVertexArraysAPPLE = (PFNGLGENVERTEXARRAYSAPPLEPROC)glewGetProcAddress((const GLubyte*)"glGenVertexArraysAPPLE")) == NULL) || r; + r = ((glIsVertexArrayAPPLE = (PFNGLISVERTEXARRAYAPPLEPROC)glewGetProcAddress((const GLubyte*)"glIsVertexArrayAPPLE")) == NULL) || r; + + return r; +} + +#endif /* GL_APPLE_vertex_array_object */ + +#ifdef GL_APPLE_vertex_array_range + +static GLboolean _glewInit_GL_APPLE_vertex_array_range (GLEW_CONTEXT_ARG_DEF_INIT) +{ + GLboolean r = GL_FALSE; + + r = ((glFlushVertexArrayRangeAPPLE = (PFNGLFLUSHVERTEXARRAYRANGEAPPLEPROC)glewGetProcAddress((const GLubyte*)"glFlushVertexArrayRangeAPPLE")) == NULL) || r; + r = ((glVertexArrayParameteriAPPLE = (PFNGLVERTEXARRAYPARAMETERIAPPLEPROC)glewGetProcAddress((const GLubyte*)"glVertexArrayParameteriAPPLE")) == NULL) || r; + r = ((glVertexArrayRangeAPPLE = (PFNGLVERTEXARRAYRANGEAPPLEPROC)glewGetProcAddress((const GLubyte*)"glVertexArrayRangeAPPLE")) == NULL) || r; + + return r; +} + +#endif /* GL_APPLE_vertex_array_range */ + +#ifdef GL_APPLE_ycbcr_422 + +#endif /* GL_APPLE_ycbcr_422 */ + +#ifdef GL_ARB_color_buffer_float + +static GLboolean _glewInit_GL_ARB_color_buffer_float (GLEW_CONTEXT_ARG_DEF_INIT) +{ + GLboolean r = GL_FALSE; + + r = ((glClampColorARB = (PFNGLCLAMPCOLORARBPROC)glewGetProcAddress((const GLubyte*)"glClampColorARB")) == NULL) || r; + + return r; +} + +#endif /* GL_ARB_color_buffer_float */ + +#ifdef GL_ARB_depth_buffer_float + +#endif /* GL_ARB_depth_buffer_float */ + +#ifdef GL_ARB_depth_texture + +#endif /* GL_ARB_depth_texture */ + +#ifdef GL_ARB_draw_buffers + +static GLboolean _glewInit_GL_ARB_draw_buffers (GLEW_CONTEXT_ARG_DEF_INIT) +{ + GLboolean r = GL_FALSE; + + r = ((glDrawBuffersARB = (PFNGLDRAWBUFFERSARBPROC)glewGetProcAddress((const GLubyte*)"glDrawBuffersARB")) == NULL) || r; + + return r; +} + +#endif /* GL_ARB_draw_buffers */ + +#ifdef GL_ARB_draw_instanced + +static GLboolean _glewInit_GL_ARB_draw_instanced (GLEW_CONTEXT_ARG_DEF_INIT) +{ + GLboolean r = GL_FALSE; + + r = ((glDrawArraysInstancedARB = (PFNGLDRAWARRAYSINSTANCEDARBPROC)glewGetProcAddress((const GLubyte*)"glDrawArraysInstancedARB")) == NULL) || r; + r = ((glDrawElementsInstancedARB = (PFNGLDRAWELEMENTSINSTANCEDARBPROC)glewGetProcAddress((const GLubyte*)"glDrawElementsInstancedARB")) == NULL) || r; + + return r; +} + +#endif /* GL_ARB_draw_instanced */ + +#ifdef GL_ARB_fragment_program + +#endif /* GL_ARB_fragment_program */ + +#ifdef GL_ARB_fragment_program_shadow + +#endif /* GL_ARB_fragment_program_shadow */ + +#ifdef GL_ARB_fragment_shader + +#endif /* GL_ARB_fragment_shader */ + +#ifdef GL_ARB_framebuffer_object + +static GLboolean _glewInit_GL_ARB_framebuffer_object (GLEW_CONTEXT_ARG_DEF_INIT) +{ + GLboolean r = GL_FALSE; + + r = ((glBindFramebuffer = (PFNGLBINDFRAMEBUFFERPROC)glewGetProcAddress((const GLubyte*)"glBindFramebuffer")) == NULL) || r; + r = ((glBindRenderbuffer = (PFNGLBINDRENDERBUFFERPROC)glewGetProcAddress((const GLubyte*)"glBindRenderbuffer")) == NULL) || r; + r = ((glBlitFramebuffer = (PFNGLBLITFRAMEBUFFERPROC)glewGetProcAddress((const GLubyte*)"glBlitFramebuffer")) == NULL) || r; + r = ((glCheckFramebufferStatus = (PFNGLCHECKFRAMEBUFFERSTATUSPROC)glewGetProcAddress((const GLubyte*)"glCheckFramebufferStatus")) == NULL) || r; + r = ((glDeleteFramebuffers = (PFNGLDELETEFRAMEBUFFERSPROC)glewGetProcAddress((const GLubyte*)"glDeleteFramebuffers")) == NULL) || r; + r = ((glDeleteRenderbuffers = (PFNGLDELETERENDERBUFFERSPROC)glewGetProcAddress((const GLubyte*)"glDeleteRenderbuffers")) == NULL) || r; + r = ((glFramebufferRenderbuffer = (PFNGLFRAMEBUFFERRENDERBUFFERPROC)glewGetProcAddress((const GLubyte*)"glFramebufferRenderbuffer")) == NULL) || r; + r = ((glFramebufferTexturLayer = (PFNGLFRAMEBUFFERTEXTURLAYERPROC)glewGetProcAddress((const GLubyte*)"glFramebufferTexturLayer")) == NULL) || r; + r = ((glFramebufferTexture1D = (PFNGLFRAMEBUFFERTEXTURE1DPROC)glewGetProcAddress((const GLubyte*)"glFramebufferTexture1D")) == NULL) || r; + r = ((glFramebufferTexture2D = (PFNGLFRAMEBUFFERTEXTURE2DPROC)glewGetProcAddress((const GLubyte*)"glFramebufferTexture2D")) == NULL) || r; + r = ((glFramebufferTexture3D = (PFNGLFRAMEBUFFERTEXTURE3DPROC)glewGetProcAddress((const GLubyte*)"glFramebufferTexture3D")) == NULL) || r; + r = ((glGenFramebuffers = (PFNGLGENFRAMEBUFFERSPROC)glewGetProcAddress((const GLubyte*)"glGenFramebuffers")) == NULL) || r; + r = ((glGenRenderbuffers = (PFNGLGENRENDERBUFFERSPROC)glewGetProcAddress((const GLubyte*)"glGenRenderbuffers")) == NULL) || r; + r = ((glGenerateMipmap = (PFNGLGENERATEMIPMAPPROC)glewGetProcAddress((const GLubyte*)"glGenerateMipmap")) == NULL) || r; + r = ((glGetFramebufferAttachmentParameteriv = (PFNGLGETFRAMEBUFFERATTACHMENTPARAMETERIVPROC)glewGetProcAddress((const GLubyte*)"glGetFramebufferAttachmentParameteriv")) == NULL) || r; + r = ((glGetRenderbufferParameteriv = (PFNGLGETRENDERBUFFERPARAMETERIVPROC)glewGetProcAddress((const GLubyte*)"glGetRenderbufferParameteriv")) == NULL) || r; + r = ((glIsFramebuffer = (PFNGLISFRAMEBUFFERPROC)glewGetProcAddress((const GLubyte*)"glIsFramebuffer")) == NULL) || r; + r = ((glIsRenderbuffer = (PFNGLISRENDERBUFFERPROC)glewGetProcAddress((const GLubyte*)"glIsRenderbuffer")) == NULL) || r; + r = ((glRenderbufferStorage = (PFNGLRENDERBUFFERSTORAGEPROC)glewGetProcAddress((const GLubyte*)"glRenderbufferStorage")) == NULL) || r; + r = ((glRenderbufferStorageMultisample = (PFNGLRENDERBUFFERSTORAGEMULTISAMPLEPROC)glewGetProcAddress((const GLubyte*)"glRenderbufferStorageMultisample")) == NULL) || r; + + return r; +} + +#endif /* GL_ARB_framebuffer_object */ + +#ifdef GL_ARB_framebuffer_sRGB + +#endif /* GL_ARB_framebuffer_sRGB */ + +#ifdef GL_ARB_geometry_shader4 + +static GLboolean _glewInit_GL_ARB_geometry_shader4 (GLEW_CONTEXT_ARG_DEF_INIT) +{ + GLboolean r = GL_FALSE; + + r = ((glFramebufferTextureARB = (PFNGLFRAMEBUFFERTEXTUREARBPROC)glewGetProcAddress((const GLubyte*)"glFramebufferTextureARB")) == NULL) || r; + r = ((glFramebufferTextureFaceARB = (PFNGLFRAMEBUFFERTEXTUREFACEARBPROC)glewGetProcAddress((const GLubyte*)"glFramebufferTextureFaceARB")) == NULL) || r; + r = ((glFramebufferTextureLayerARB = (PFNGLFRAMEBUFFERTEXTURELAYERARBPROC)glewGetProcAddress((const GLubyte*)"glFramebufferTextureLayerARB")) == NULL) || r; + r = ((glProgramParameteriARB = (PFNGLPROGRAMPARAMETERIARBPROC)glewGetProcAddress((const GLubyte*)"glProgramParameteriARB")) == NULL) || r; + + return r; +} + +#endif /* GL_ARB_geometry_shader4 */ + +#ifdef GL_ARB_half_float_pixel + +#endif /* GL_ARB_half_float_pixel */ + +#ifdef GL_ARB_half_float_vertex + +#endif /* GL_ARB_half_float_vertex */ + +#ifdef GL_ARB_imaging + +static GLboolean _glewInit_GL_ARB_imaging (GLEW_CONTEXT_ARG_DEF_INIT) +{ + GLboolean r = GL_FALSE; + + r = ((glBlendEquation = (PFNGLBLENDEQUATIONPROC)glewGetProcAddress((const GLubyte*)"glBlendEquation")) == NULL) || r; + r = ((glColorSubTable = (PFNGLCOLORSUBTABLEPROC)glewGetProcAddress((const GLubyte*)"glColorSubTable")) == NULL) || r; + r = ((glColorTable = (PFNGLCOLORTABLEPROC)glewGetProcAddress((const GLubyte*)"glColorTable")) == NULL) || r; + r = ((glColorTableParameterfv = (PFNGLCOLORTABLEPARAMETERFVPROC)glewGetProcAddress((const GLubyte*)"glColorTableParameterfv")) == NULL) || r; + r = ((glColorTableParameteriv = (PFNGLCOLORTABLEPARAMETERIVPROC)glewGetProcAddress((const GLubyte*)"glColorTableParameteriv")) == NULL) || r; + r = ((glConvolutionFilter1D = (PFNGLCONVOLUTIONFILTER1DPROC)glewGetProcAddress((const GLubyte*)"glConvolutionFilter1D")) == NULL) || r; + r = ((glConvolutionFilter2D = (PFNGLCONVOLUTIONFILTER2DPROC)glewGetProcAddress((const GLubyte*)"glConvolutionFilter2D")) == NULL) || r; + r = ((glConvolutionParameterf = (PFNGLCONVOLUTIONPARAMETERFPROC)glewGetProcAddress((const GLubyte*)"glConvolutionParameterf")) == NULL) || r; + r = ((glConvolutionParameterfv = (PFNGLCONVOLUTIONPARAMETERFVPROC)glewGetProcAddress((const GLubyte*)"glConvolutionParameterfv")) == NULL) || r; + r = ((glConvolutionParameteri = (PFNGLCONVOLUTIONPARAMETERIPROC)glewGetProcAddress((const GLubyte*)"glConvolutionParameteri")) == NULL) || r; + r = ((glConvolutionParameteriv = (PFNGLCONVOLUTIONPARAMETERIVPROC)glewGetProcAddress((const GLubyte*)"glConvolutionParameteriv")) == NULL) || r; + r = ((glCopyColorSubTable = (PFNGLCOPYCOLORSUBTABLEPROC)glewGetProcAddress((const GLubyte*)"glCopyColorSubTable")) == NULL) || r; + r = ((glCopyColorTable = (PFNGLCOPYCOLORTABLEPROC)glewGetProcAddress((const GLubyte*)"glCopyColorTable")) == NULL) || r; + r = ((glCopyConvolutionFilter1D = (PFNGLCOPYCONVOLUTIONFILTER1DPROC)glewGetProcAddress((const GLubyte*)"glCopyConvolutionFilter1D")) == NULL) || r; + r = ((glCopyConvolutionFilter2D = (PFNGLCOPYCONVOLUTIONFILTER2DPROC)glewGetProcAddress((const GLubyte*)"glCopyConvolutionFilter2D")) == NULL) || r; + r = ((glGetColorTable = (PFNGLGETCOLORTABLEPROC)glewGetProcAddress((const GLubyte*)"glGetColorTable")) == NULL) || r; + r = ((glGetColorTableParameterfv = (PFNGLGETCOLORTABLEPARAMETERFVPROC)glewGetProcAddress((const GLubyte*)"glGetColorTableParameterfv")) == NULL) || r; + r = ((glGetColorTableParameteriv = (PFNGLGETCOLORTABLEPARAMETERIVPROC)glewGetProcAddress((const GLubyte*)"glGetColorTableParameteriv")) == NULL) || r; + r = ((glGetConvolutionFilter = (PFNGLGETCONVOLUTIONFILTERPROC)glewGetProcAddress((const GLubyte*)"glGetConvolutionFilter")) == NULL) || r; + r = ((glGetConvolutionParameterfv = (PFNGLGETCONVOLUTIONPARAMETERFVPROC)glewGetProcAddress((const GLubyte*)"glGetConvolutionParameterfv")) == NULL) || r; + r = ((glGetConvolutionParameteriv = (PFNGLGETCONVOLUTIONPARAMETERIVPROC)glewGetProcAddress((const GLubyte*)"glGetConvolutionParameteriv")) == NULL) || r; + r = ((glGetHistogram = (PFNGLGETHISTOGRAMPROC)glewGetProcAddress((const GLubyte*)"glGetHistogram")) == NULL) || r; + r = ((glGetHistogramParameterfv = (PFNGLGETHISTOGRAMPARAMETERFVPROC)glewGetProcAddress((const GLubyte*)"glGetHistogramParameterfv")) == NULL) || r; + r = ((glGetHistogramParameteriv = (PFNGLGETHISTOGRAMPARAMETERIVPROC)glewGetProcAddress((const GLubyte*)"glGetHistogramParameteriv")) == NULL) || r; + r = ((glGetMinmax = (PFNGLGETMINMAXPROC)glewGetProcAddress((const GLubyte*)"glGetMinmax")) == NULL) || r; + r = ((glGetMinmaxParameterfv = (PFNGLGETMINMAXPARAMETERFVPROC)glewGetProcAddress((const GLubyte*)"glGetMinmaxParameterfv")) == NULL) || r; + r = ((glGetMinmaxParameteriv = (PFNGLGETMINMAXPARAMETERIVPROC)glewGetProcAddress((const GLubyte*)"glGetMinmaxParameteriv")) == NULL) || r; + r = ((glGetSeparableFilter = (PFNGLGETSEPARABLEFILTERPROC)glewGetProcAddress((const GLubyte*)"glGetSeparableFilter")) == NULL) || r; + r = ((glHistogram = (PFNGLHISTOGRAMPROC)glewGetProcAddress((const GLubyte*)"glHistogram")) == NULL) || r; + r = ((glMinmax = (PFNGLMINMAXPROC)glewGetProcAddress((const GLubyte*)"glMinmax")) == NULL) || r; + r = ((glResetHistogram = (PFNGLRESETHISTOGRAMPROC)glewGetProcAddress((const GLubyte*)"glResetHistogram")) == NULL) || r; + r = ((glResetMinmax = (PFNGLRESETMINMAXPROC)glewGetProcAddress((const GLubyte*)"glResetMinmax")) == NULL) || r; + r = ((glSeparableFilter2D = (PFNGLSEPARABLEFILTER2DPROC)glewGetProcAddress((const GLubyte*)"glSeparableFilter2D")) == NULL) || r; + + return r; +} + +#endif /* GL_ARB_imaging */ + +#ifdef GL_ARB_instanced_arrays + +static GLboolean _glewInit_GL_ARB_instanced_arrays (GLEW_CONTEXT_ARG_DEF_INIT) +{ + GLboolean r = GL_FALSE; + + r = ((glVertexAttribDivisorARB = (PFNGLVERTEXATTRIBDIVISORARBPROC)glewGetProcAddress((const GLubyte*)"glVertexAttribDivisorARB")) == NULL) || r; + + return r; +} + +#endif /* GL_ARB_instanced_arrays */ + +#ifdef GL_ARB_map_buffer_range + +static GLboolean _glewInit_GL_ARB_map_buffer_range (GLEW_CONTEXT_ARG_DEF_INIT) +{ + GLboolean r = GL_FALSE; + + r = ((glFlushMappedBufferRange = (PFNGLFLUSHMAPPEDBUFFERRANGEPROC)glewGetProcAddress((const GLubyte*)"glFlushMappedBufferRange")) == NULL) || r; + r = ((glMapBufferRange = (PFNGLMAPBUFFERRANGEPROC)glewGetProcAddress((const GLubyte*)"glMapBufferRange")) == NULL) || r; + + return r; +} + +#endif /* GL_ARB_map_buffer_range */ + +#ifdef GL_ARB_matrix_palette + +static GLboolean _glewInit_GL_ARB_matrix_palette (GLEW_CONTEXT_ARG_DEF_INIT) +{ + GLboolean r = GL_FALSE; + + r = ((glCurrentPaletteMatrixARB = (PFNGLCURRENTPALETTEMATRIXARBPROC)glewGetProcAddress((const GLubyte*)"glCurrentPaletteMatrixARB")) == NULL) || r; + r = ((glMatrixIndexPointerARB = (PFNGLMATRIXINDEXPOINTERARBPROC)glewGetProcAddress((const GLubyte*)"glMatrixIndexPointerARB")) == NULL) || r; + r = ((glMatrixIndexubvARB = (PFNGLMATRIXINDEXUBVARBPROC)glewGetProcAddress((const GLubyte*)"glMatrixIndexubvARB")) == NULL) || r; + r = ((glMatrixIndexuivARB = (PFNGLMATRIXINDEXUIVARBPROC)glewGetProcAddress((const GLubyte*)"glMatrixIndexuivARB")) == NULL) || r; + r = ((glMatrixIndexusvARB = (PFNGLMATRIXINDEXUSVARBPROC)glewGetProcAddress((const GLubyte*)"glMatrixIndexusvARB")) == NULL) || r; + + return r; +} + +#endif /* GL_ARB_matrix_palette */ + +#ifdef GL_ARB_multisample + +static GLboolean _glewInit_GL_ARB_multisample (GLEW_CONTEXT_ARG_DEF_INIT) +{ + GLboolean r = GL_FALSE; + + r = ((glSampleCoverageARB = (PFNGLSAMPLECOVERAGEARBPROC)glewGetProcAddress((const GLubyte*)"glSampleCoverageARB")) == NULL) || r; + + return r; +} + +#endif /* GL_ARB_multisample */ + +#ifdef GL_ARB_multitexture + +static GLboolean _glewInit_GL_ARB_multitexture (GLEW_CONTEXT_ARG_DEF_INIT) +{ + GLboolean r = GL_FALSE; + + r = ((glActiveTextureARB = (PFNGLACTIVETEXTUREARBPROC)glewGetProcAddress((const GLubyte*)"glActiveTextureARB")) == NULL) || r; + r = ((glClientActiveTextureARB = (PFNGLCLIENTACTIVETEXTUREARBPROC)glewGetProcAddress((const GLubyte*)"glClientActiveTextureARB")) == NULL) || r; + r = ((glMultiTexCoord1dARB = (PFNGLMULTITEXCOORD1DARBPROC)glewGetProcAddress((const GLubyte*)"glMultiTexCoord1dARB")) == NULL) || r; + r = ((glMultiTexCoord1dvARB = (PFNGLMULTITEXCOORD1DVARBPROC)glewGetProcAddress((const GLubyte*)"glMultiTexCoord1dvARB")) == NULL) || r; + r = ((glMultiTexCoord1fARB = (PFNGLMULTITEXCOORD1FARBPROC)glewGetProcAddress((const GLubyte*)"glMultiTexCoord1fARB")) == NULL) || r; + r = ((glMultiTexCoord1fvARB = (PFNGLMULTITEXCOORD1FVARBPROC)glewGetProcAddress((const GLubyte*)"glMultiTexCoord1fvARB")) == NULL) || r; + r = ((glMultiTexCoord1iARB = (PFNGLMULTITEXCOORD1IARBPROC)glewGetProcAddress((const GLubyte*)"glMultiTexCoord1iARB")) == NULL) || r; + r = ((glMultiTexCoord1ivARB = (PFNGLMULTITEXCOORD1IVARBPROC)glewGetProcAddress((const GLubyte*)"glMultiTexCoord1ivARB")) == NULL) || r; + r = ((glMultiTexCoord1sARB = (PFNGLMULTITEXCOORD1SARBPROC)glewGetProcAddress((const GLubyte*)"glMultiTexCoord1sARB")) == NULL) || r; + r = ((glMultiTexCoord1svARB = (PFNGLMULTITEXCOORD1SVARBPROC)glewGetProcAddress((const GLubyte*)"glMultiTexCoord1svARB")) == NULL) || r; + r = ((glMultiTexCoord2dARB = (PFNGLMULTITEXCOORD2DARBPROC)glewGetProcAddress((const GLubyte*)"glMultiTexCoord2dARB")) == NULL) || r; + r = ((glMultiTexCoord2dvARB = (PFNGLMULTITEXCOORD2DVARBPROC)glewGetProcAddress((const GLubyte*)"glMultiTexCoord2dvARB")) == NULL) || r; + r = ((glMultiTexCoord2fARB = (PFNGLMULTITEXCOORD2FARBPROC)glewGetProcAddress((const GLubyte*)"glMultiTexCoord2fARB")) == NULL) || r; + r = ((glMultiTexCoord2fvARB = (PFNGLMULTITEXCOORD2FVARBPROC)glewGetProcAddress((const GLubyte*)"glMultiTexCoord2fvARB")) == NULL) || r; + r = ((glMultiTexCoord2iARB = (PFNGLMULTITEXCOORD2IARBPROC)glewGetProcAddress((const GLubyte*)"glMultiTexCoord2iARB")) == NULL) || r; + r = ((glMultiTexCoord2ivARB = (PFNGLMULTITEXCOORD2IVARBPROC)glewGetProcAddress((const GLubyte*)"glMultiTexCoord2ivARB")) == NULL) || r; + r = ((glMultiTexCoord2sARB = (PFNGLMULTITEXCOORD2SARBPROC)glewGetProcAddress((const GLubyte*)"glMultiTexCoord2sARB")) == NULL) || r; + r = ((glMultiTexCoord2svARB = (PFNGLMULTITEXCOORD2SVARBPROC)glewGetProcAddress((const GLubyte*)"glMultiTexCoord2svARB")) == NULL) || r; + r = ((glMultiTexCoord3dARB = (PFNGLMULTITEXCOORD3DARBPROC)glewGetProcAddress((const GLubyte*)"glMultiTexCoord3dARB")) == NULL) || r; + r = ((glMultiTexCoord3dvARB = (PFNGLMULTITEXCOORD3DVARBPROC)glewGetProcAddress((const GLubyte*)"glMultiTexCoord3dvARB")) == NULL) || r; + r = ((glMultiTexCoord3fARB = (PFNGLMULTITEXCOORD3FARBPROC)glewGetProcAddress((const GLubyte*)"glMultiTexCoord3fARB")) == NULL) || r; + r = ((glMultiTexCoord3fvARB = (PFNGLMULTITEXCOORD3FVARBPROC)glewGetProcAddress((const GLubyte*)"glMultiTexCoord3fvARB")) == NULL) || r; + r = ((glMultiTexCoord3iARB = (PFNGLMULTITEXCOORD3IARBPROC)glewGetProcAddress((const GLubyte*)"glMultiTexCoord3iARB")) == NULL) || r; + r = ((glMultiTexCoord3ivARB = (PFNGLMULTITEXCOORD3IVARBPROC)glewGetProcAddress((const GLubyte*)"glMultiTexCoord3ivARB")) == NULL) || r; + r = ((glMultiTexCoord3sARB = (PFNGLMULTITEXCOORD3SARBPROC)glewGetProcAddress((const GLubyte*)"glMultiTexCoord3sARB")) == NULL) || r; + r = ((glMultiTexCoord3svARB = (PFNGLMULTITEXCOORD3SVARBPROC)glewGetProcAddress((const GLubyte*)"glMultiTexCoord3svARB")) == NULL) || r; + r = ((glMultiTexCoord4dARB = (PFNGLMULTITEXCOORD4DARBPROC)glewGetProcAddress((const GLubyte*)"glMultiTexCoord4dARB")) == NULL) || r; + r = ((glMultiTexCoord4dvARB = (PFNGLMULTITEXCOORD4DVARBPROC)glewGetProcAddress((const GLubyte*)"glMultiTexCoord4dvARB")) == NULL) || r; + r = ((glMultiTexCoord4fARB = (PFNGLMULTITEXCOORD4FARBPROC)glewGetProcAddress((const GLubyte*)"glMultiTexCoord4fARB")) == NULL) || r; + r = ((glMultiTexCoord4fvARB = (PFNGLMULTITEXCOORD4FVARBPROC)glewGetProcAddress((const GLubyte*)"glMultiTexCoord4fvARB")) == NULL) || r; + r = ((glMultiTexCoord4iARB = (PFNGLMULTITEXCOORD4IARBPROC)glewGetProcAddress((const GLubyte*)"glMultiTexCoord4iARB")) == NULL) || r; + r = ((glMultiTexCoord4ivARB = (PFNGLMULTITEXCOORD4IVARBPROC)glewGetProcAddress((const GLubyte*)"glMultiTexCoord4ivARB")) == NULL) || r; + r = ((glMultiTexCoord4sARB = (PFNGLMULTITEXCOORD4SARBPROC)glewGetProcAddress((const GLubyte*)"glMultiTexCoord4sARB")) == NULL) || r; + r = ((glMultiTexCoord4svARB = (PFNGLMULTITEXCOORD4SVARBPROC)glewGetProcAddress((const GLubyte*)"glMultiTexCoord4svARB")) == NULL) || r; + + return r; +} + +#endif /* GL_ARB_multitexture */ + +#ifdef GL_ARB_occlusion_query + +static GLboolean _glewInit_GL_ARB_occlusion_query (GLEW_CONTEXT_ARG_DEF_INIT) +{ + GLboolean r = GL_FALSE; + + r = ((glBeginQueryARB = (PFNGLBEGINQUERYARBPROC)glewGetProcAddress((const GLubyte*)"glBeginQueryARB")) == NULL) || r; + r = ((glDeleteQueriesARB = (PFNGLDELETEQUERIESARBPROC)glewGetProcAddress((const GLubyte*)"glDeleteQueriesARB")) == NULL) || r; + r = ((glEndQueryARB = (PFNGLENDQUERYARBPROC)glewGetProcAddress((const GLubyte*)"glEndQueryARB")) == NULL) || r; + r = ((glGenQueriesARB = (PFNGLGENQUERIESARBPROC)glewGetProcAddress((const GLubyte*)"glGenQueriesARB")) == NULL) || r; + r = ((glGetQueryObjectivARB = (PFNGLGETQUERYOBJECTIVARBPROC)glewGetProcAddress((const GLubyte*)"glGetQueryObjectivARB")) == NULL) || r; + r = ((glGetQueryObjectuivARB = (PFNGLGETQUERYOBJECTUIVARBPROC)glewGetProcAddress((const GLubyte*)"glGetQueryObjectuivARB")) == NULL) || r; + r = ((glGetQueryivARB = (PFNGLGETQUERYIVARBPROC)glewGetProcAddress((const GLubyte*)"glGetQueryivARB")) == NULL) || r; + r = ((glIsQueryARB = (PFNGLISQUERYARBPROC)glewGetProcAddress((const GLubyte*)"glIsQueryARB")) == NULL) || r; + + return r; +} + +#endif /* GL_ARB_occlusion_query */ + +#ifdef GL_ARB_pixel_buffer_object + +#endif /* GL_ARB_pixel_buffer_object */ + +#ifdef GL_ARB_point_parameters + +static GLboolean _glewInit_GL_ARB_point_parameters (GLEW_CONTEXT_ARG_DEF_INIT) +{ + GLboolean r = GL_FALSE; + + r = ((glPointParameterfARB = (PFNGLPOINTPARAMETERFARBPROC)glewGetProcAddress((const GLubyte*)"glPointParameterfARB")) == NULL) || r; + r = ((glPointParameterfvARB = (PFNGLPOINTPARAMETERFVARBPROC)glewGetProcAddress((const GLubyte*)"glPointParameterfvARB")) == NULL) || r; + + return r; +} + +#endif /* GL_ARB_point_parameters */ + +#ifdef GL_ARB_point_sprite + +#endif /* GL_ARB_point_sprite */ + +#ifdef GL_ARB_shader_objects + +static GLboolean _glewInit_GL_ARB_shader_objects (GLEW_CONTEXT_ARG_DEF_INIT) +{ + GLboolean r = GL_FALSE; + + r = ((glAttachObjectARB = (PFNGLATTACHOBJECTARBPROC)glewGetProcAddress((const GLubyte*)"glAttachObjectARB")) == NULL) || r; + r = ((glCompileShaderARB = (PFNGLCOMPILESHADERARBPROC)glewGetProcAddress((const GLubyte*)"glCompileShaderARB")) == NULL) || r; + r = ((glCreateProgramObjectARB = (PFNGLCREATEPROGRAMOBJECTARBPROC)glewGetProcAddress((const GLubyte*)"glCreateProgramObjectARB")) == NULL) || r; + r = ((glCreateShaderObjectARB = (PFNGLCREATESHADEROBJECTARBPROC)glewGetProcAddress((const GLubyte*)"glCreateShaderObjectARB")) == NULL) || r; + r = ((glDeleteObjectARB = (PFNGLDELETEOBJECTARBPROC)glewGetProcAddress((const GLubyte*)"glDeleteObjectARB")) == NULL) || r; + r = ((glDetachObjectARB = (PFNGLDETACHOBJECTARBPROC)glewGetProcAddress((const GLubyte*)"glDetachObjectARB")) == NULL) || r; + r = ((glGetActiveUniformARB = (PFNGLGETACTIVEUNIFORMARBPROC)glewGetProcAddress((const GLubyte*)"glGetActiveUniformARB")) == NULL) || r; + r = ((glGetAttachedObjectsARB = (PFNGLGETATTACHEDOBJECTSARBPROC)glewGetProcAddress((const GLubyte*)"glGetAttachedObjectsARB")) == NULL) || r; + r = ((glGetHandleARB = (PFNGLGETHANDLEARBPROC)glewGetProcAddress((const GLubyte*)"glGetHandleARB")) == NULL) || r; + r = ((glGetInfoLogARB = (PFNGLGETINFOLOGARBPROC)glewGetProcAddress((const GLubyte*)"glGetInfoLogARB")) == NULL) || r; + r = ((glGetObjectParameterfvARB = (PFNGLGETOBJECTPARAMETERFVARBPROC)glewGetProcAddress((const GLubyte*)"glGetObjectParameterfvARB")) == NULL) || r; + r = ((glGetObjectParameterivARB = (PFNGLGETOBJECTPARAMETERIVARBPROC)glewGetProcAddress((const GLubyte*)"glGetObjectParameterivARB")) == NULL) || r; + r = ((glGetShaderSourceARB = (PFNGLGETSHADERSOURCEARBPROC)glewGetProcAddress((const GLubyte*)"glGetShaderSourceARB")) == NULL) || r; + r = ((glGetUniformLocationARB = (PFNGLGETUNIFORMLOCATIONARBPROC)glewGetProcAddress((const GLubyte*)"glGetUniformLocationARB")) == NULL) || r; + r = ((glGetUniformfvARB = (PFNGLGETUNIFORMFVARBPROC)glewGetProcAddress((const GLubyte*)"glGetUniformfvARB")) == NULL) || r; + r = ((glGetUniformivARB = (PFNGLGETUNIFORMIVARBPROC)glewGetProcAddress((const GLubyte*)"glGetUniformivARB")) == NULL) || r; + r = ((glLinkProgramARB = (PFNGLLINKPROGRAMARBPROC)glewGetProcAddress((const GLubyte*)"glLinkProgramARB")) == NULL) || r; + r = ((glShaderSourceARB = (PFNGLSHADERSOURCEARBPROC)glewGetProcAddress((const GLubyte*)"glShaderSourceARB")) == NULL) || r; + r = ((glUniform1fARB = (PFNGLUNIFORM1FARBPROC)glewGetProcAddress((const GLubyte*)"glUniform1fARB")) == NULL) || r; + r = ((glUniform1fvARB = (PFNGLUNIFORM1FVARBPROC)glewGetProcAddress((const GLubyte*)"glUniform1fvARB")) == NULL) || r; + r = ((glUniform1iARB = (PFNGLUNIFORM1IARBPROC)glewGetProcAddress((const GLubyte*)"glUniform1iARB")) == NULL) || r; + r = ((glUniform1ivARB = (PFNGLUNIFORM1IVARBPROC)glewGetProcAddress((const GLubyte*)"glUniform1ivARB")) == NULL) || r; + r = ((glUniform2fARB = (PFNGLUNIFORM2FARBPROC)glewGetProcAddress((const GLubyte*)"glUniform2fARB")) == NULL) || r; + r = ((glUniform2fvARB = (PFNGLUNIFORM2FVARBPROC)glewGetProcAddress((const GLubyte*)"glUniform2fvARB")) == NULL) || r; + r = ((glUniform2iARB = (PFNGLUNIFORM2IARBPROC)glewGetProcAddress((const GLubyte*)"glUniform2iARB")) == NULL) || r; + r = ((glUniform2ivARB = (PFNGLUNIFORM2IVARBPROC)glewGetProcAddress((const GLubyte*)"glUniform2ivARB")) == NULL) || r; + r = ((glUniform3fARB = (PFNGLUNIFORM3FARBPROC)glewGetProcAddress((const GLubyte*)"glUniform3fARB")) == NULL) || r; + r = ((glUniform3fvARB = (PFNGLUNIFORM3FVARBPROC)glewGetProcAddress((const GLubyte*)"glUniform3fvARB")) == NULL) || r; + r = ((glUniform3iARB = (PFNGLUNIFORM3IARBPROC)glewGetProcAddress((const GLubyte*)"glUniform3iARB")) == NULL) || r; + r = ((glUniform3ivARB = (PFNGLUNIFORM3IVARBPROC)glewGetProcAddress((const GLubyte*)"glUniform3ivARB")) == NULL) || r; + r = ((glUniform4fARB = (PFNGLUNIFORM4FARBPROC)glewGetProcAddress((const GLubyte*)"glUniform4fARB")) == NULL) || r; + r = ((glUniform4fvARB = (PFNGLUNIFORM4FVARBPROC)glewGetProcAddress((const GLubyte*)"glUniform4fvARB")) == NULL) || r; + r = ((glUniform4iARB = (PFNGLUNIFORM4IARBPROC)glewGetProcAddress((const GLubyte*)"glUniform4iARB")) == NULL) || r; + r = ((glUniform4ivARB = (PFNGLUNIFORM4IVARBPROC)glewGetProcAddress((const GLubyte*)"glUniform4ivARB")) == NULL) || r; + r = ((glUniformMatrix2fvARB = (PFNGLUNIFORMMATRIX2FVARBPROC)glewGetProcAddress((const GLubyte*)"glUniformMatrix2fvARB")) == NULL) || r; + r = ((glUniformMatrix3fvARB = (PFNGLUNIFORMMATRIX3FVARBPROC)glewGetProcAddress((const GLubyte*)"glUniformMatrix3fvARB")) == NULL) || r; + r = ((glUniformMatrix4fvARB = (PFNGLUNIFORMMATRIX4FVARBPROC)glewGetProcAddress((const GLubyte*)"glUniformMatrix4fvARB")) == NULL) || r; + r = ((glUseProgramObjectARB = (PFNGLUSEPROGRAMOBJECTARBPROC)glewGetProcAddress((const GLubyte*)"glUseProgramObjectARB")) == NULL) || r; + r = ((glValidateProgramARB = (PFNGLVALIDATEPROGRAMARBPROC)glewGetProcAddress((const GLubyte*)"glValidateProgramARB")) == NULL) || r; + + return r; +} + +#endif /* GL_ARB_shader_objects */ + +#ifdef GL_ARB_shading_language_100 + +#endif /* GL_ARB_shading_language_100 */ + +#ifdef GL_ARB_shadow + +#endif /* GL_ARB_shadow */ + +#ifdef GL_ARB_shadow_ambient + +#endif /* GL_ARB_shadow_ambient */ + +#ifdef GL_ARB_texture_border_clamp + +#endif /* GL_ARB_texture_border_clamp */ + +#ifdef GL_ARB_texture_buffer_object + +static GLboolean _glewInit_GL_ARB_texture_buffer_object (GLEW_CONTEXT_ARG_DEF_INIT) +{ + GLboolean r = GL_FALSE; + + r = ((glTexBufferARB = (PFNGLTEXBUFFERARBPROC)glewGetProcAddress((const GLubyte*)"glTexBufferARB")) == NULL) || r; + + return r; +} + +#endif /* GL_ARB_texture_buffer_object */ + +#ifdef GL_ARB_texture_compression + +static GLboolean _glewInit_GL_ARB_texture_compression (GLEW_CONTEXT_ARG_DEF_INIT) +{ + GLboolean r = GL_FALSE; + + r = ((glCompressedTexImage1DARB = (PFNGLCOMPRESSEDTEXIMAGE1DARBPROC)glewGetProcAddress((const GLubyte*)"glCompressedTexImage1DARB")) == NULL) || r; + r = ((glCompressedTexImage2DARB = (PFNGLCOMPRESSEDTEXIMAGE2DARBPROC)glewGetProcAddress((const GLubyte*)"glCompressedTexImage2DARB")) == NULL) || r; + r = ((glCompressedTexImage3DARB = (PFNGLCOMPRESSEDTEXIMAGE3DARBPROC)glewGetProcAddress((const GLubyte*)"glCompressedTexImage3DARB")) == NULL) || r; + r = ((glCompressedTexSubImage1DARB = (PFNGLCOMPRESSEDTEXSUBIMAGE1DARBPROC)glewGetProcAddress((const GLubyte*)"glCompressedTexSubImage1DARB")) == NULL) || r; + r = ((glCompressedTexSubImage2DARB = (PFNGLCOMPRESSEDTEXSUBIMAGE2DARBPROC)glewGetProcAddress((const GLubyte*)"glCompressedTexSubImage2DARB")) == NULL) || r; + r = ((glCompressedTexSubImage3DARB = (PFNGLCOMPRESSEDTEXSUBIMAGE3DARBPROC)glewGetProcAddress((const GLubyte*)"glCompressedTexSubImage3DARB")) == NULL) || r; + r = ((glGetCompressedTexImageARB = (PFNGLGETCOMPRESSEDTEXIMAGEARBPROC)glewGetProcAddress((const GLubyte*)"glGetCompressedTexImageARB")) == NULL) || r; + + return r; +} + +#endif /* GL_ARB_texture_compression */ + +#ifdef GL_ARB_texture_compression_rgtc + +#endif /* GL_ARB_texture_compression_rgtc */ + +#ifdef GL_ARB_texture_cube_map + +#endif /* GL_ARB_texture_cube_map */ + +#ifdef GL_ARB_texture_env_add + +#endif /* GL_ARB_texture_env_add */ + +#ifdef GL_ARB_texture_env_combine + +#endif /* GL_ARB_texture_env_combine */ + +#ifdef GL_ARB_texture_env_crossbar + +#endif /* GL_ARB_texture_env_crossbar */ + +#ifdef GL_ARB_texture_env_dot3 + +#endif /* GL_ARB_texture_env_dot3 */ + +#ifdef GL_ARB_texture_float + +#endif /* GL_ARB_texture_float */ + +#ifdef GL_ARB_texture_mirrored_repeat + +#endif /* GL_ARB_texture_mirrored_repeat */ + +#ifdef GL_ARB_texture_non_power_of_two + +#endif /* GL_ARB_texture_non_power_of_two */ + +#ifdef GL_ARB_texture_rectangle + +#endif /* GL_ARB_texture_rectangle */ + +#ifdef GL_ARB_texture_rg + +#endif /* GL_ARB_texture_rg */ + +#ifdef GL_ARB_transpose_matrix + +static GLboolean _glewInit_GL_ARB_transpose_matrix (GLEW_CONTEXT_ARG_DEF_INIT) +{ + GLboolean r = GL_FALSE; + + r = ((glLoadTransposeMatrixdARB = (PFNGLLOADTRANSPOSEMATRIXDARBPROC)glewGetProcAddress((const GLubyte*)"glLoadTransposeMatrixdARB")) == NULL) || r; + r = ((glLoadTransposeMatrixfARB = (PFNGLLOADTRANSPOSEMATRIXFARBPROC)glewGetProcAddress((const GLubyte*)"glLoadTransposeMatrixfARB")) == NULL) || r; + r = ((glMultTransposeMatrixdARB = (PFNGLMULTTRANSPOSEMATRIXDARBPROC)glewGetProcAddress((const GLubyte*)"glMultTransposeMatrixdARB")) == NULL) || r; + r = ((glMultTransposeMatrixfARB = (PFNGLMULTTRANSPOSEMATRIXFARBPROC)glewGetProcAddress((const GLubyte*)"glMultTransposeMatrixfARB")) == NULL) || r; + + return r; +} + +#endif /* GL_ARB_transpose_matrix */ + +#ifdef GL_ARB_vertex_array_object + +static GLboolean _glewInit_GL_ARB_vertex_array_object (GLEW_CONTEXT_ARG_DEF_INIT) +{ + GLboolean r = GL_FALSE; + + r = ((glBindVertexArray = (PFNGLBINDVERTEXARRAYPROC)glewGetProcAddress((const GLubyte*)"glBindVertexArray")) == NULL) || r; + r = ((glDeleteVertexArrays = (PFNGLDELETEVERTEXARRAYSPROC)glewGetProcAddress((const GLubyte*)"glDeleteVertexArrays")) == NULL) || r; + r = ((glGenVertexArrays = (PFNGLGENVERTEXARRAYSPROC)glewGetProcAddress((const GLubyte*)"glGenVertexArrays")) == NULL) || r; + r = ((glIsVertexArray = (PFNGLISVERTEXARRAYPROC)glewGetProcAddress((const GLubyte*)"glIsVertexArray")) == NULL) || r; + + return r; +} + +#endif /* GL_ARB_vertex_array_object */ + +#ifdef GL_ARB_vertex_blend + +static GLboolean _glewInit_GL_ARB_vertex_blend (GLEW_CONTEXT_ARG_DEF_INIT) +{ + GLboolean r = GL_FALSE; + + r = ((glVertexBlendARB = (PFNGLVERTEXBLENDARBPROC)glewGetProcAddress((const GLubyte*)"glVertexBlendARB")) == NULL) || r; + r = ((glWeightPointerARB = (PFNGLWEIGHTPOINTERARBPROC)glewGetProcAddress((const GLubyte*)"glWeightPointerARB")) == NULL) || r; + r = ((glWeightbvARB = (PFNGLWEIGHTBVARBPROC)glewGetProcAddress((const GLubyte*)"glWeightbvARB")) == NULL) || r; + r = ((glWeightdvARB = (PFNGLWEIGHTDVARBPROC)glewGetProcAddress((const GLubyte*)"glWeightdvARB")) == NULL) || r; + r = ((glWeightfvARB = (PFNGLWEIGHTFVARBPROC)glewGetProcAddress((const GLubyte*)"glWeightfvARB")) == NULL) || r; + r = ((glWeightivARB = (PFNGLWEIGHTIVARBPROC)glewGetProcAddress((const GLubyte*)"glWeightivARB")) == NULL) || r; + r = ((glWeightsvARB = (PFNGLWEIGHTSVARBPROC)glewGetProcAddress((const GLubyte*)"glWeightsvARB")) == NULL) || r; + r = ((glWeightubvARB = (PFNGLWEIGHTUBVARBPROC)glewGetProcAddress((const GLubyte*)"glWeightubvARB")) == NULL) || r; + r = ((glWeightuivARB = (PFNGLWEIGHTUIVARBPROC)glewGetProcAddress((const GLubyte*)"glWeightuivARB")) == NULL) || r; + r = ((glWeightusvARB = (PFNGLWEIGHTUSVARBPROC)glewGetProcAddress((const GLubyte*)"glWeightusvARB")) == NULL) || r; + + return r; +} + +#endif /* GL_ARB_vertex_blend */ + +#ifdef GL_ARB_vertex_buffer_object + +static GLboolean _glewInit_GL_ARB_vertex_buffer_object (GLEW_CONTEXT_ARG_DEF_INIT) +{ + GLboolean r = GL_FALSE; + + r = ((glBindBufferARB = (PFNGLBINDBUFFERARBPROC)glewGetProcAddress((const GLubyte*)"glBindBufferARB")) == NULL) || r; + r = ((glBufferDataARB = (PFNGLBUFFERDATAARBPROC)glewGetProcAddress((const GLubyte*)"glBufferDataARB")) == NULL) || r; + r = ((glBufferSubDataARB = (PFNGLBUFFERSUBDATAARBPROC)glewGetProcAddress((const GLubyte*)"glBufferSubDataARB")) == NULL) || r; + r = ((glDeleteBuffersARB = (PFNGLDELETEBUFFERSARBPROC)glewGetProcAddress((const GLubyte*)"glDeleteBuffersARB")) == NULL) || r; + r = ((glGenBuffersARB = (PFNGLGENBUFFERSARBPROC)glewGetProcAddress((const GLubyte*)"glGenBuffersARB")) == NULL) || r; + r = ((glGetBufferParameterivARB = (PFNGLGETBUFFERPARAMETERIVARBPROC)glewGetProcAddress((const GLubyte*)"glGetBufferParameterivARB")) == NULL) || r; + r = ((glGetBufferPointervARB = (PFNGLGETBUFFERPOINTERVARBPROC)glewGetProcAddress((const GLubyte*)"glGetBufferPointervARB")) == NULL) || r; + r = ((glGetBufferSubDataARB = (PFNGLGETBUFFERSUBDATAARBPROC)glewGetProcAddress((const GLubyte*)"glGetBufferSubDataARB")) == NULL) || r; + r = ((glIsBufferARB = (PFNGLISBUFFERARBPROC)glewGetProcAddress((const GLubyte*)"glIsBufferARB")) == NULL) || r; + r = ((glMapBufferARB = (PFNGLMAPBUFFERARBPROC)glewGetProcAddress((const GLubyte*)"glMapBufferARB")) == NULL) || r; + r = ((glUnmapBufferARB = (PFNGLUNMAPBUFFERARBPROC)glewGetProcAddress((const GLubyte*)"glUnmapBufferARB")) == NULL) || r; + + return r; +} + +#endif /* GL_ARB_vertex_buffer_object */ + +#ifdef GL_ARB_vertex_program + +static GLboolean _glewInit_GL_ARB_vertex_program (GLEW_CONTEXT_ARG_DEF_INIT) +{ + GLboolean r = GL_FALSE; + + r = ((glBindProgramARB = (PFNGLBINDPROGRAMARBPROC)glewGetProcAddress((const GLubyte*)"glBindProgramARB")) == NULL) || r; + r = ((glDeleteProgramsARB = (PFNGLDELETEPROGRAMSARBPROC)glewGetProcAddress((const GLubyte*)"glDeleteProgramsARB")) == NULL) || r; + r = ((glDisableVertexAttribArrayARB = (PFNGLDISABLEVERTEXATTRIBARRAYARBPROC)glewGetProcAddress((const GLubyte*)"glDisableVertexAttribArrayARB")) == NULL) || r; + r = ((glEnableVertexAttribArrayARB = (PFNGLENABLEVERTEXATTRIBARRAYARBPROC)glewGetProcAddress((const GLubyte*)"glEnableVertexAttribArrayARB")) == NULL) || r; + r = ((glGenProgramsARB = (PFNGLGENPROGRAMSARBPROC)glewGetProcAddress((const GLubyte*)"glGenProgramsARB")) == NULL) || r; + r = ((glGetProgramEnvParameterdvARB = (PFNGLGETPROGRAMENVPARAMETERDVARBPROC)glewGetProcAddress((const GLubyte*)"glGetProgramEnvParameterdvARB")) == NULL) || r; + r = ((glGetProgramEnvParameterfvARB = (PFNGLGETPROGRAMENVPARAMETERFVARBPROC)glewGetProcAddress((const GLubyte*)"glGetProgramEnvParameterfvARB")) == NULL) || r; + r = ((glGetProgramLocalParameterdvARB = (PFNGLGETPROGRAMLOCALPARAMETERDVARBPROC)glewGetProcAddress((const GLubyte*)"glGetProgramLocalParameterdvARB")) == NULL) || r; + r = ((glGetProgramLocalParameterfvARB = (PFNGLGETPROGRAMLOCALPARAMETERFVARBPROC)glewGetProcAddress((const GLubyte*)"glGetProgramLocalParameterfvARB")) == NULL) || r; + r = ((glGetProgramStringARB = (PFNGLGETPROGRAMSTRINGARBPROC)glewGetProcAddress((const GLubyte*)"glGetProgramStringARB")) == NULL) || r; + r = ((glGetProgramivARB = (PFNGLGETPROGRAMIVARBPROC)glewGetProcAddress((const GLubyte*)"glGetProgramivARB")) == NULL) || r; + r = ((glGetVertexAttribPointervARB = (PFNGLGETVERTEXATTRIBPOINTERVARBPROC)glewGetProcAddress((const GLubyte*)"glGetVertexAttribPointervARB")) == NULL) || r; + r = ((glGetVertexAttribdvARB = (PFNGLGETVERTEXATTRIBDVARBPROC)glewGetProcAddress((const GLubyte*)"glGetVertexAttribdvARB")) == NULL) || r; + r = ((glGetVertexAttribfvARB = (PFNGLGETVERTEXATTRIBFVARBPROC)glewGetProcAddress((const GLubyte*)"glGetVertexAttribfvARB")) == NULL) || r; + r = ((glGetVertexAttribivARB = (PFNGLGETVERTEXATTRIBIVARBPROC)glewGetProcAddress((const GLubyte*)"glGetVertexAttribivARB")) == NULL) || r; + r = ((glIsProgramARB = (PFNGLISPROGRAMARBPROC)glewGetProcAddress((const GLubyte*)"glIsProgramARB")) == NULL) || r; + r = ((glProgramEnvParameter4dARB = (PFNGLPROGRAMENVPARAMETER4DARBPROC)glewGetProcAddress((const GLubyte*)"glProgramEnvParameter4dARB")) == NULL) || r; + r = ((glProgramEnvParameter4dvARB = (PFNGLPROGRAMENVPARAMETER4DVARBPROC)glewGetProcAddress((const GLubyte*)"glProgramEnvParameter4dvARB")) == NULL) || r; + r = ((glProgramEnvParameter4fARB = (PFNGLPROGRAMENVPARAMETER4FARBPROC)glewGetProcAddress((const GLubyte*)"glProgramEnvParameter4fARB")) == NULL) || r; + r = ((glProgramEnvParameter4fvARB = (PFNGLPROGRAMENVPARAMETER4FVARBPROC)glewGetProcAddress((const GLubyte*)"glProgramEnvParameter4fvARB")) == NULL) || r; + r = ((glProgramLocalParameter4dARB = (PFNGLPROGRAMLOCALPARAMETER4DARBPROC)glewGetProcAddress((const GLubyte*)"glProgramLocalParameter4dARB")) == NULL) || r; + r = ((glProgramLocalParameter4dvARB = (PFNGLPROGRAMLOCALPARAMETER4DVARBPROC)glewGetProcAddress((const GLubyte*)"glProgramLocalParameter4dvARB")) == NULL) || r; + r = ((glProgramLocalParameter4fARB = (PFNGLPROGRAMLOCALPARAMETER4FARBPROC)glewGetProcAddress((const GLubyte*)"glProgramLocalParameter4fARB")) == NULL) || r; + r = ((glProgramLocalParameter4fvARB = (PFNGLPROGRAMLOCALPARAMETER4FVARBPROC)glewGetProcAddress((const GLubyte*)"glProgramLocalParameter4fvARB")) == NULL) || r; + r = ((glProgramStringARB = (PFNGLPROGRAMSTRINGARBPROC)glewGetProcAddress((const GLubyte*)"glProgramStringARB")) == NULL) || r; + r = ((glVertexAttrib1dARB = (PFNGLVERTEXATTRIB1DARBPROC)glewGetProcAddress((const GLubyte*)"glVertexAttrib1dARB")) == NULL) || r; + r = ((glVertexAttrib1dvARB = (PFNGLVERTEXATTRIB1DVARBPROC)glewGetProcAddress((const GLubyte*)"glVertexAttrib1dvARB")) == NULL) || r; + r = ((glVertexAttrib1fARB = (PFNGLVERTEXATTRIB1FARBPROC)glewGetProcAddress((const GLubyte*)"glVertexAttrib1fARB")) == NULL) || r; + r = ((glVertexAttrib1fvARB = (PFNGLVERTEXATTRIB1FVARBPROC)glewGetProcAddress((const GLubyte*)"glVertexAttrib1fvARB")) == NULL) || r; + r = ((glVertexAttrib1sARB = (PFNGLVERTEXATTRIB1SARBPROC)glewGetProcAddress((const GLubyte*)"glVertexAttrib1sARB")) == NULL) || r; + r = ((glVertexAttrib1svARB = (PFNGLVERTEXATTRIB1SVARBPROC)glewGetProcAddress((const GLubyte*)"glVertexAttrib1svARB")) == NULL) || r; + r = ((glVertexAttrib2dARB = (PFNGLVERTEXATTRIB2DARBPROC)glewGetProcAddress((const GLubyte*)"glVertexAttrib2dARB")) == NULL) || r; + r = ((glVertexAttrib2dvARB = (PFNGLVERTEXATTRIB2DVARBPROC)glewGetProcAddress((const GLubyte*)"glVertexAttrib2dvARB")) == NULL) || r; + r = ((glVertexAttrib2fARB = (PFNGLVERTEXATTRIB2FARBPROC)glewGetProcAddress((const GLubyte*)"glVertexAttrib2fARB")) == NULL) || r; + r = ((glVertexAttrib2fvARB = (PFNGLVERTEXATTRIB2FVARBPROC)glewGetProcAddress((const GLubyte*)"glVertexAttrib2fvARB")) == NULL) || r; + r = ((glVertexAttrib2sARB = (PFNGLVERTEXATTRIB2SARBPROC)glewGetProcAddress((const GLubyte*)"glVertexAttrib2sARB")) == NULL) || r; + r = ((glVertexAttrib2svARB = (PFNGLVERTEXATTRIB2SVARBPROC)glewGetProcAddress((const GLubyte*)"glVertexAttrib2svARB")) == NULL) || r; + r = ((glVertexAttrib3dARB = (PFNGLVERTEXATTRIB3DARBPROC)glewGetProcAddress((const GLubyte*)"glVertexAttrib3dARB")) == NULL) || r; + r = ((glVertexAttrib3dvARB = (PFNGLVERTEXATTRIB3DVARBPROC)glewGetProcAddress((const GLubyte*)"glVertexAttrib3dvARB")) == NULL) || r; + r = ((glVertexAttrib3fARB = (PFNGLVERTEXATTRIB3FARBPROC)glewGetProcAddress((const GLubyte*)"glVertexAttrib3fARB")) == NULL) || r; + r = ((glVertexAttrib3fvARB = (PFNGLVERTEXATTRIB3FVARBPROC)glewGetProcAddress((const GLubyte*)"glVertexAttrib3fvARB")) == NULL) || r; + r = ((glVertexAttrib3sARB = (PFNGLVERTEXATTRIB3SARBPROC)glewGetProcAddress((const GLubyte*)"glVertexAttrib3sARB")) == NULL) || r; + r = ((glVertexAttrib3svARB = (PFNGLVERTEXATTRIB3SVARBPROC)glewGetProcAddress((const GLubyte*)"glVertexAttrib3svARB")) == NULL) || r; + r = ((glVertexAttrib4NbvARB = (PFNGLVERTEXATTRIB4NBVARBPROC)glewGetProcAddress((const GLubyte*)"glVertexAttrib4NbvARB")) == NULL) || r; + r = ((glVertexAttrib4NivARB = (PFNGLVERTEXATTRIB4NIVARBPROC)glewGetProcAddress((const GLubyte*)"glVertexAttrib4NivARB")) == NULL) || r; + r = ((glVertexAttrib4NsvARB = (PFNGLVERTEXATTRIB4NSVARBPROC)glewGetProcAddress((const GLubyte*)"glVertexAttrib4NsvARB")) == NULL) || r; + r = ((glVertexAttrib4NubARB = (PFNGLVERTEXATTRIB4NUBARBPROC)glewGetProcAddress((const GLubyte*)"glVertexAttrib4NubARB")) == NULL) || r; + r = ((glVertexAttrib4NubvARB = (PFNGLVERTEXATTRIB4NUBVARBPROC)glewGetProcAddress((const GLubyte*)"glVertexAttrib4NubvARB")) == NULL) || r; + r = ((glVertexAttrib4NuivARB = (PFNGLVERTEXATTRIB4NUIVARBPROC)glewGetProcAddress((const GLubyte*)"glVertexAttrib4NuivARB")) == NULL) || r; + r = ((glVertexAttrib4NusvARB = (PFNGLVERTEXATTRIB4NUSVARBPROC)glewGetProcAddress((const GLubyte*)"glVertexAttrib4NusvARB")) == NULL) || r; + r = ((glVertexAttrib4bvARB = (PFNGLVERTEXATTRIB4BVARBPROC)glewGetProcAddress((const GLubyte*)"glVertexAttrib4bvARB")) == NULL) || r; + r = ((glVertexAttrib4dARB = (PFNGLVERTEXATTRIB4DARBPROC)glewGetProcAddress((const GLubyte*)"glVertexAttrib4dARB")) == NULL) || r; + r = ((glVertexAttrib4dvARB = (PFNGLVERTEXATTRIB4DVARBPROC)glewGetProcAddress((const GLubyte*)"glVertexAttrib4dvARB")) == NULL) || r; + r = ((glVertexAttrib4fARB = (PFNGLVERTEXATTRIB4FARBPROC)glewGetProcAddress((const GLubyte*)"glVertexAttrib4fARB")) == NULL) || r; + r = ((glVertexAttrib4fvARB = (PFNGLVERTEXATTRIB4FVARBPROC)glewGetProcAddress((const GLubyte*)"glVertexAttrib4fvARB")) == NULL) || r; + r = ((glVertexAttrib4ivARB = (PFNGLVERTEXATTRIB4IVARBPROC)glewGetProcAddress((const GLubyte*)"glVertexAttrib4ivARB")) == NULL) || r; + r = ((glVertexAttrib4sARB = (PFNGLVERTEXATTRIB4SARBPROC)glewGetProcAddress((const GLubyte*)"glVertexAttrib4sARB")) == NULL) || r; + r = ((glVertexAttrib4svARB = (PFNGLVERTEXATTRIB4SVARBPROC)glewGetProcAddress((const GLubyte*)"glVertexAttrib4svARB")) == NULL) || r; + r = ((glVertexAttrib4ubvARB = (PFNGLVERTEXATTRIB4UBVARBPROC)glewGetProcAddress((const GLubyte*)"glVertexAttrib4ubvARB")) == NULL) || r; + r = ((glVertexAttrib4uivARB = (PFNGLVERTEXATTRIB4UIVARBPROC)glewGetProcAddress((const GLubyte*)"glVertexAttrib4uivARB")) == NULL) || r; + r = ((glVertexAttrib4usvARB = (PFNGLVERTEXATTRIB4USVARBPROC)glewGetProcAddress((const GLubyte*)"glVertexAttrib4usvARB")) == NULL) || r; + r = ((glVertexAttribPointerARB = (PFNGLVERTEXATTRIBPOINTERARBPROC)glewGetProcAddress((const GLubyte*)"glVertexAttribPointerARB")) == NULL) || r; + + return r; +} + +#endif /* GL_ARB_vertex_program */ + +#ifdef GL_ARB_vertex_shader + +static GLboolean _glewInit_GL_ARB_vertex_shader (GLEW_CONTEXT_ARG_DEF_INIT) +{ + GLboolean r = GL_FALSE; + + r = ((glBindAttribLocationARB = (PFNGLBINDATTRIBLOCATIONARBPROC)glewGetProcAddress((const GLubyte*)"glBindAttribLocationARB")) == NULL) || r; + r = ((glGetActiveAttribARB = (PFNGLGETACTIVEATTRIBARBPROC)glewGetProcAddress((const GLubyte*)"glGetActiveAttribARB")) == NULL) || r; + r = ((glGetAttribLocationARB = (PFNGLGETATTRIBLOCATIONARBPROC)glewGetProcAddress((const GLubyte*)"glGetAttribLocationARB")) == NULL) || r; + + return r; +} + +#endif /* GL_ARB_vertex_shader */ + +#ifdef GL_ARB_window_pos + +static GLboolean _glewInit_GL_ARB_window_pos (GLEW_CONTEXT_ARG_DEF_INIT) +{ + GLboolean r = GL_FALSE; + + r = ((glWindowPos2dARB = (PFNGLWINDOWPOS2DARBPROC)glewGetProcAddress((const GLubyte*)"glWindowPos2dARB")) == NULL) || r; + r = ((glWindowPos2dvARB = (PFNGLWINDOWPOS2DVARBPROC)glewGetProcAddress((const GLubyte*)"glWindowPos2dvARB")) == NULL) || r; + r = ((glWindowPos2fARB = (PFNGLWINDOWPOS2FARBPROC)glewGetProcAddress((const GLubyte*)"glWindowPos2fARB")) == NULL) || r; + r = ((glWindowPos2fvARB = (PFNGLWINDOWPOS2FVARBPROC)glewGetProcAddress((const GLubyte*)"glWindowPos2fvARB")) == NULL) || r; + r = ((glWindowPos2iARB = (PFNGLWINDOWPOS2IARBPROC)glewGetProcAddress((const GLubyte*)"glWindowPos2iARB")) == NULL) || r; + r = ((glWindowPos2ivARB = (PFNGLWINDOWPOS2IVARBPROC)glewGetProcAddress((const GLubyte*)"glWindowPos2ivARB")) == NULL) || r; + r = ((glWindowPos2sARB = (PFNGLWINDOWPOS2SARBPROC)glewGetProcAddress((const GLubyte*)"glWindowPos2sARB")) == NULL) || r; + r = ((glWindowPos2svARB = (PFNGLWINDOWPOS2SVARBPROC)glewGetProcAddress((const GLubyte*)"glWindowPos2svARB")) == NULL) || r; + r = ((glWindowPos3dARB = (PFNGLWINDOWPOS3DARBPROC)glewGetProcAddress((const GLubyte*)"glWindowPos3dARB")) == NULL) || r; + r = ((glWindowPos3dvARB = (PFNGLWINDOWPOS3DVARBPROC)glewGetProcAddress((const GLubyte*)"glWindowPos3dvARB")) == NULL) || r; + r = ((glWindowPos3fARB = (PFNGLWINDOWPOS3FARBPROC)glewGetProcAddress((const GLubyte*)"glWindowPos3fARB")) == NULL) || r; + r = ((glWindowPos3fvARB = (PFNGLWINDOWPOS3FVARBPROC)glewGetProcAddress((const GLubyte*)"glWindowPos3fvARB")) == NULL) || r; + r = ((glWindowPos3iARB = (PFNGLWINDOWPOS3IARBPROC)glewGetProcAddress((const GLubyte*)"glWindowPos3iARB")) == NULL) || r; + r = ((glWindowPos3ivARB = (PFNGLWINDOWPOS3IVARBPROC)glewGetProcAddress((const GLubyte*)"glWindowPos3ivARB")) == NULL) || r; + r = ((glWindowPos3sARB = (PFNGLWINDOWPOS3SARBPROC)glewGetProcAddress((const GLubyte*)"glWindowPos3sARB")) == NULL) || r; + r = ((glWindowPos3svARB = (PFNGLWINDOWPOS3SVARBPROC)glewGetProcAddress((const GLubyte*)"glWindowPos3svARB")) == NULL) || r; + + return r; +} + +#endif /* GL_ARB_window_pos */ + +#ifdef GL_ATIX_point_sprites + +#endif /* GL_ATIX_point_sprites */ + +#ifdef GL_ATIX_texture_env_combine3 + +#endif /* GL_ATIX_texture_env_combine3 */ + +#ifdef GL_ATIX_texture_env_route + +#endif /* GL_ATIX_texture_env_route */ + +#ifdef GL_ATIX_vertex_shader_output_point_size + +#endif /* GL_ATIX_vertex_shader_output_point_size */ + +#ifdef GL_ATI_draw_buffers + +static GLboolean _glewInit_GL_ATI_draw_buffers (GLEW_CONTEXT_ARG_DEF_INIT) +{ + GLboolean r = GL_FALSE; + + r = ((glDrawBuffersATI = (PFNGLDRAWBUFFERSATIPROC)glewGetProcAddress((const GLubyte*)"glDrawBuffersATI")) == NULL) || r; + + return r; +} + +#endif /* GL_ATI_draw_buffers */ + +#ifdef GL_ATI_element_array + +static GLboolean _glewInit_GL_ATI_element_array (GLEW_CONTEXT_ARG_DEF_INIT) +{ + GLboolean r = GL_FALSE; + + r = ((glDrawElementArrayATI = (PFNGLDRAWELEMENTARRAYATIPROC)glewGetProcAddress((const GLubyte*)"glDrawElementArrayATI")) == NULL) || r; + r = ((glDrawRangeElementArrayATI = (PFNGLDRAWRANGEELEMENTARRAYATIPROC)glewGetProcAddress((const GLubyte*)"glDrawRangeElementArrayATI")) == NULL) || r; + r = ((glElementPointerATI = (PFNGLELEMENTPOINTERATIPROC)glewGetProcAddress((const GLubyte*)"glElementPointerATI")) == NULL) || r; + + return r; +} + +#endif /* GL_ATI_element_array */ + +#ifdef GL_ATI_envmap_bumpmap + +static GLboolean _glewInit_GL_ATI_envmap_bumpmap (GLEW_CONTEXT_ARG_DEF_INIT) +{ + GLboolean r = GL_FALSE; + + r = ((glGetTexBumpParameterfvATI = (PFNGLGETTEXBUMPPARAMETERFVATIPROC)glewGetProcAddress((const GLubyte*)"glGetTexBumpParameterfvATI")) == NULL) || r; + r = ((glGetTexBumpParameterivATI = (PFNGLGETTEXBUMPPARAMETERIVATIPROC)glewGetProcAddress((const GLubyte*)"glGetTexBumpParameterivATI")) == NULL) || r; + r = ((glTexBumpParameterfvATI = (PFNGLTEXBUMPPARAMETERFVATIPROC)glewGetProcAddress((const GLubyte*)"glTexBumpParameterfvATI")) == NULL) || r; + r = ((glTexBumpParameterivATI = (PFNGLTEXBUMPPARAMETERIVATIPROC)glewGetProcAddress((const GLubyte*)"glTexBumpParameterivATI")) == NULL) || r; + + return r; +} + +#endif /* GL_ATI_envmap_bumpmap */ + +#ifdef GL_ATI_fragment_shader + +static GLboolean _glewInit_GL_ATI_fragment_shader (GLEW_CONTEXT_ARG_DEF_INIT) +{ + GLboolean r = GL_FALSE; + + r = ((glAlphaFragmentOp1ATI = (PFNGLALPHAFRAGMENTOP1ATIPROC)glewGetProcAddress((const GLubyte*)"glAlphaFragmentOp1ATI")) == NULL) || r; + r = ((glAlphaFragmentOp2ATI = (PFNGLALPHAFRAGMENTOP2ATIPROC)glewGetProcAddress((const GLubyte*)"glAlphaFragmentOp2ATI")) == NULL) || r; + r = ((glAlphaFragmentOp3ATI = (PFNGLALPHAFRAGMENTOP3ATIPROC)glewGetProcAddress((const GLubyte*)"glAlphaFragmentOp3ATI")) == NULL) || r; + r = ((glBeginFragmentShaderATI = (PFNGLBEGINFRAGMENTSHADERATIPROC)glewGetProcAddress((const GLubyte*)"glBeginFragmentShaderATI")) == NULL) || r; + r = ((glBindFragmentShaderATI = (PFNGLBINDFRAGMENTSHADERATIPROC)glewGetProcAddress((const GLubyte*)"glBindFragmentShaderATI")) == NULL) || r; + r = ((glColorFragmentOp1ATI = (PFNGLCOLORFRAGMENTOP1ATIPROC)glewGetProcAddress((const GLubyte*)"glColorFragmentOp1ATI")) == NULL) || r; + r = ((glColorFragmentOp2ATI = (PFNGLCOLORFRAGMENTOP2ATIPROC)glewGetProcAddress((const GLubyte*)"glColorFragmentOp2ATI")) == NULL) || r; + r = ((glColorFragmentOp3ATI = (PFNGLCOLORFRAGMENTOP3ATIPROC)glewGetProcAddress((const GLubyte*)"glColorFragmentOp3ATI")) == NULL) || r; + r = ((glDeleteFragmentShaderATI = (PFNGLDELETEFRAGMENTSHADERATIPROC)glewGetProcAddress((const GLubyte*)"glDeleteFragmentShaderATI")) == NULL) || r; + r = ((glEndFragmentShaderATI = (PFNGLENDFRAGMENTSHADERATIPROC)glewGetProcAddress((const GLubyte*)"glEndFragmentShaderATI")) == NULL) || r; + r = ((glGenFragmentShadersATI = (PFNGLGENFRAGMENTSHADERSATIPROC)glewGetProcAddress((const GLubyte*)"glGenFragmentShadersATI")) == NULL) || r; + r = ((glPassTexCoordATI = (PFNGLPASSTEXCOORDATIPROC)glewGetProcAddress((const GLubyte*)"glPassTexCoordATI")) == NULL) || r; + r = ((glSampleMapATI = (PFNGLSAMPLEMAPATIPROC)glewGetProcAddress((const GLubyte*)"glSampleMapATI")) == NULL) || r; + r = ((glSetFragmentShaderConstantATI = (PFNGLSETFRAGMENTSHADERCONSTANTATIPROC)glewGetProcAddress((const GLubyte*)"glSetFragmentShaderConstantATI")) == NULL) || r; + + return r; +} + +#endif /* GL_ATI_fragment_shader */ + +#ifdef GL_ATI_map_object_buffer + +static GLboolean _glewInit_GL_ATI_map_object_buffer (GLEW_CONTEXT_ARG_DEF_INIT) +{ + GLboolean r = GL_FALSE; + + r = ((glMapObjectBufferATI = (PFNGLMAPOBJECTBUFFERATIPROC)glewGetProcAddress((const GLubyte*)"glMapObjectBufferATI")) == NULL) || r; + r = ((glUnmapObjectBufferATI = (PFNGLUNMAPOBJECTBUFFERATIPROC)glewGetProcAddress((const GLubyte*)"glUnmapObjectBufferATI")) == NULL) || r; + + return r; +} + +#endif /* GL_ATI_map_object_buffer */ + +#ifdef GL_ATI_pn_triangles + +static GLboolean _glewInit_GL_ATI_pn_triangles (GLEW_CONTEXT_ARG_DEF_INIT) +{ + GLboolean r = GL_FALSE; + + r = ((glPNTrianglesfATI = (PFNGLPNTRIANGLESFATIPROC)glewGetProcAddress((const GLubyte*)"glPNTrianglesfATI")) == NULL) || r; + r = ((glPNTrianglesiATI = (PFNGLPNTRIANGLESIATIPROC)glewGetProcAddress((const GLubyte*)"glPNTrianglesiATI")) == NULL) || r; + + return r; +} + +#endif /* GL_ATI_pn_triangles */ + +#ifdef GL_ATI_separate_stencil + +static GLboolean _glewInit_GL_ATI_separate_stencil (GLEW_CONTEXT_ARG_DEF_INIT) +{ + GLboolean r = GL_FALSE; + + r = ((glStencilFuncSeparateATI = (PFNGLSTENCILFUNCSEPARATEATIPROC)glewGetProcAddress((const GLubyte*)"glStencilFuncSeparateATI")) == NULL) || r; + r = ((glStencilOpSeparateATI = (PFNGLSTENCILOPSEPARATEATIPROC)glewGetProcAddress((const GLubyte*)"glStencilOpSeparateATI")) == NULL) || r; + + return r; +} + +#endif /* GL_ATI_separate_stencil */ + +#ifdef GL_ATI_shader_texture_lod + +#endif /* GL_ATI_shader_texture_lod */ + +#ifdef GL_ATI_text_fragment_shader + +#endif /* GL_ATI_text_fragment_shader */ + +#ifdef GL_ATI_texture_compression_3dc + +#endif /* GL_ATI_texture_compression_3dc */ + +#ifdef GL_ATI_texture_env_combine3 + +#endif /* GL_ATI_texture_env_combine3 */ + +#ifdef GL_ATI_texture_float + +#endif /* GL_ATI_texture_float */ + +#ifdef GL_ATI_texture_mirror_once + +#endif /* GL_ATI_texture_mirror_once */ + +#ifdef GL_ATI_vertex_array_object + +static GLboolean _glewInit_GL_ATI_vertex_array_object (GLEW_CONTEXT_ARG_DEF_INIT) +{ + GLboolean r = GL_FALSE; + + r = ((glArrayObjectATI = (PFNGLARRAYOBJECTATIPROC)glewGetProcAddress((const GLubyte*)"glArrayObjectATI")) == NULL) || r; + r = ((glFreeObjectBufferATI = (PFNGLFREEOBJECTBUFFERATIPROC)glewGetProcAddress((const GLubyte*)"glFreeObjectBufferATI")) == NULL) || r; + r = ((glGetArrayObjectfvATI = (PFNGLGETARRAYOBJECTFVATIPROC)glewGetProcAddress((const GLubyte*)"glGetArrayObjectfvATI")) == NULL) || r; + r = ((glGetArrayObjectivATI = (PFNGLGETARRAYOBJECTIVATIPROC)glewGetProcAddress((const GLubyte*)"glGetArrayObjectivATI")) == NULL) || r; + r = ((glGetObjectBufferfvATI = (PFNGLGETOBJECTBUFFERFVATIPROC)glewGetProcAddress((const GLubyte*)"glGetObjectBufferfvATI")) == NULL) || r; + r = ((glGetObjectBufferivATI = (PFNGLGETOBJECTBUFFERIVATIPROC)glewGetProcAddress((const GLubyte*)"glGetObjectBufferivATI")) == NULL) || r; + r = ((glGetVariantArrayObjectfvATI = (PFNGLGETVARIANTARRAYOBJECTFVATIPROC)glewGetProcAddress((const GLubyte*)"glGetVariantArrayObjectfvATI")) == NULL) || r; + r = ((glGetVariantArrayObjectivATI = (PFNGLGETVARIANTARRAYOBJECTIVATIPROC)glewGetProcAddress((const GLubyte*)"glGetVariantArrayObjectivATI")) == NULL) || r; + r = ((glIsObjectBufferATI = (PFNGLISOBJECTBUFFERATIPROC)glewGetProcAddress((const GLubyte*)"glIsObjectBufferATI")) == NULL) || r; + r = ((glNewObjectBufferATI = (PFNGLNEWOBJECTBUFFERATIPROC)glewGetProcAddress((const GLubyte*)"glNewObjectBufferATI")) == NULL) || r; + r = ((glUpdateObjectBufferATI = (PFNGLUPDATEOBJECTBUFFERATIPROC)glewGetProcAddress((const GLubyte*)"glUpdateObjectBufferATI")) == NULL) || r; + r = ((glVariantArrayObjectATI = (PFNGLVARIANTARRAYOBJECTATIPROC)glewGetProcAddress((const GLubyte*)"glVariantArrayObjectATI")) == NULL) || r; + + return r; +} + +#endif /* GL_ATI_vertex_array_object */ + +#ifdef GL_ATI_vertex_attrib_array_object + +static GLboolean _glewInit_GL_ATI_vertex_attrib_array_object (GLEW_CONTEXT_ARG_DEF_INIT) +{ + GLboolean r = GL_FALSE; + + r = ((glGetVertexAttribArrayObjectfvATI = (PFNGLGETVERTEXATTRIBARRAYOBJECTFVATIPROC)glewGetProcAddress((const GLubyte*)"glGetVertexAttribArrayObjectfvATI")) == NULL) || r; + r = ((glGetVertexAttribArrayObjectivATI = (PFNGLGETVERTEXATTRIBARRAYOBJECTIVATIPROC)glewGetProcAddress((const GLubyte*)"glGetVertexAttribArrayObjectivATI")) == NULL) || r; + r = ((glVertexAttribArrayObjectATI = (PFNGLVERTEXATTRIBARRAYOBJECTATIPROC)glewGetProcAddress((const GLubyte*)"glVertexAttribArrayObjectATI")) == NULL) || r; + + return r; +} + +#endif /* GL_ATI_vertex_attrib_array_object */ + +#ifdef GL_ATI_vertex_streams + +static GLboolean _glewInit_GL_ATI_vertex_streams (GLEW_CONTEXT_ARG_DEF_INIT) +{ + GLboolean r = GL_FALSE; + + r = ((glClientActiveVertexStreamATI = (PFNGLCLIENTACTIVEVERTEXSTREAMATIPROC)glewGetProcAddress((const GLubyte*)"glClientActiveVertexStreamATI")) == NULL) || r; + r = ((glNormalStream3bATI = (PFNGLNORMALSTREAM3BATIPROC)glewGetProcAddress((const GLubyte*)"glNormalStream3bATI")) == NULL) || r; + r = ((glNormalStream3bvATI = (PFNGLNORMALSTREAM3BVATIPROC)glewGetProcAddress((const GLubyte*)"glNormalStream3bvATI")) == NULL) || r; + r = ((glNormalStream3dATI = (PFNGLNORMALSTREAM3DATIPROC)glewGetProcAddress((const GLubyte*)"glNormalStream3dATI")) == NULL) || r; + r = ((glNormalStream3dvATI = (PFNGLNORMALSTREAM3DVATIPROC)glewGetProcAddress((const GLubyte*)"glNormalStream3dvATI")) == NULL) || r; + r = ((glNormalStream3fATI = (PFNGLNORMALSTREAM3FATIPROC)glewGetProcAddress((const GLubyte*)"glNormalStream3fATI")) == NULL) || r; + r = ((glNormalStream3fvATI = (PFNGLNORMALSTREAM3FVATIPROC)glewGetProcAddress((const GLubyte*)"glNormalStream3fvATI")) == NULL) || r; + r = ((glNormalStream3iATI = (PFNGLNORMALSTREAM3IATIPROC)glewGetProcAddress((const GLubyte*)"glNormalStream3iATI")) == NULL) || r; + r = ((glNormalStream3ivATI = (PFNGLNORMALSTREAM3IVATIPROC)glewGetProcAddress((const GLubyte*)"glNormalStream3ivATI")) == NULL) || r; + r = ((glNormalStream3sATI = (PFNGLNORMALSTREAM3SATIPROC)glewGetProcAddress((const GLubyte*)"glNormalStream3sATI")) == NULL) || r; + r = ((glNormalStream3svATI = (PFNGLNORMALSTREAM3SVATIPROC)glewGetProcAddress((const GLubyte*)"glNormalStream3svATI")) == NULL) || r; + r = ((glVertexBlendEnvfATI = (PFNGLVERTEXBLENDENVFATIPROC)glewGetProcAddress((const GLubyte*)"glVertexBlendEnvfATI")) == NULL) || r; + r = ((glVertexBlendEnviATI = (PFNGLVERTEXBLENDENVIATIPROC)glewGetProcAddress((const GLubyte*)"glVertexBlendEnviATI")) == NULL) || r; + r = ((glVertexStream2dATI = (PFNGLVERTEXSTREAM2DATIPROC)glewGetProcAddress((const GLubyte*)"glVertexStream2dATI")) == NULL) || r; + r = ((glVertexStream2dvATI = (PFNGLVERTEXSTREAM2DVATIPROC)glewGetProcAddress((const GLubyte*)"glVertexStream2dvATI")) == NULL) || r; + r = ((glVertexStream2fATI = (PFNGLVERTEXSTREAM2FATIPROC)glewGetProcAddress((const GLubyte*)"glVertexStream2fATI")) == NULL) || r; + r = ((glVertexStream2fvATI = (PFNGLVERTEXSTREAM2FVATIPROC)glewGetProcAddress((const GLubyte*)"glVertexStream2fvATI")) == NULL) || r; + r = ((glVertexStream2iATI = (PFNGLVERTEXSTREAM2IATIPROC)glewGetProcAddress((const GLubyte*)"glVertexStream2iATI")) == NULL) || r; + r = ((glVertexStream2ivATI = (PFNGLVERTEXSTREAM2IVATIPROC)glewGetProcAddress((const GLubyte*)"glVertexStream2ivATI")) == NULL) || r; + r = ((glVertexStream2sATI = (PFNGLVERTEXSTREAM2SATIPROC)glewGetProcAddress((const GLubyte*)"glVertexStream2sATI")) == NULL) || r; + r = ((glVertexStream2svATI = (PFNGLVERTEXSTREAM2SVATIPROC)glewGetProcAddress((const GLubyte*)"glVertexStream2svATI")) == NULL) || r; + r = ((glVertexStream3dATI = (PFNGLVERTEXSTREAM3DATIPROC)glewGetProcAddress((const GLubyte*)"glVertexStream3dATI")) == NULL) || r; + r = ((glVertexStream3dvATI = (PFNGLVERTEXSTREAM3DVATIPROC)glewGetProcAddress((const GLubyte*)"glVertexStream3dvATI")) == NULL) || r; + r = ((glVertexStream3fATI = (PFNGLVERTEXSTREAM3FATIPROC)glewGetProcAddress((const GLubyte*)"glVertexStream3fATI")) == NULL) || r; + r = ((glVertexStream3fvATI = (PFNGLVERTEXSTREAM3FVATIPROC)glewGetProcAddress((const GLubyte*)"glVertexStream3fvATI")) == NULL) || r; + r = ((glVertexStream3iATI = (PFNGLVERTEXSTREAM3IATIPROC)glewGetProcAddress((const GLubyte*)"glVertexStream3iATI")) == NULL) || r; + r = ((glVertexStream3ivATI = (PFNGLVERTEXSTREAM3IVATIPROC)glewGetProcAddress((const GLubyte*)"glVertexStream3ivATI")) == NULL) || r; + r = ((glVertexStream3sATI = (PFNGLVERTEXSTREAM3SATIPROC)glewGetProcAddress((const GLubyte*)"glVertexStream3sATI")) == NULL) || r; + r = ((glVertexStream3svATI = (PFNGLVERTEXSTREAM3SVATIPROC)glewGetProcAddress((const GLubyte*)"glVertexStream3svATI")) == NULL) || r; + r = ((glVertexStream4dATI = (PFNGLVERTEXSTREAM4DATIPROC)glewGetProcAddress((const GLubyte*)"glVertexStream4dATI")) == NULL) || r; + r = ((glVertexStream4dvATI = (PFNGLVERTEXSTREAM4DVATIPROC)glewGetProcAddress((const GLubyte*)"glVertexStream4dvATI")) == NULL) || r; + r = ((glVertexStream4fATI = (PFNGLVERTEXSTREAM4FATIPROC)glewGetProcAddress((const GLubyte*)"glVertexStream4fATI")) == NULL) || r; + r = ((glVertexStream4fvATI = (PFNGLVERTEXSTREAM4FVATIPROC)glewGetProcAddress((const GLubyte*)"glVertexStream4fvATI")) == NULL) || r; + r = ((glVertexStream4iATI = (PFNGLVERTEXSTREAM4IATIPROC)glewGetProcAddress((const GLubyte*)"glVertexStream4iATI")) == NULL) || r; + r = ((glVertexStream4ivATI = (PFNGLVERTEXSTREAM4IVATIPROC)glewGetProcAddress((const GLubyte*)"glVertexStream4ivATI")) == NULL) || r; + r = ((glVertexStream4sATI = (PFNGLVERTEXSTREAM4SATIPROC)glewGetProcAddress((const GLubyte*)"glVertexStream4sATI")) == NULL) || r; + r = ((glVertexStream4svATI = (PFNGLVERTEXSTREAM4SVATIPROC)glewGetProcAddress((const GLubyte*)"glVertexStream4svATI")) == NULL) || r; + + return r; +} + +#endif /* GL_ATI_vertex_streams */ + +#ifdef GL_EXT_422_pixels + +#endif /* GL_EXT_422_pixels */ + +#ifdef GL_EXT_Cg_shader + +#endif /* GL_EXT_Cg_shader */ + +#ifdef GL_EXT_abgr + +#endif /* GL_EXT_abgr */ + +#ifdef GL_EXT_bgra + +#endif /* GL_EXT_bgra */ + +#ifdef GL_EXT_bindable_uniform + +static GLboolean _glewInit_GL_EXT_bindable_uniform (GLEW_CONTEXT_ARG_DEF_INIT) +{ + GLboolean r = GL_FALSE; + + r = ((glGetUniformBufferSizeEXT = (PFNGLGETUNIFORMBUFFERSIZEEXTPROC)glewGetProcAddress((const GLubyte*)"glGetUniformBufferSizeEXT")) == NULL) || r; + r = ((glGetUniformOffsetEXT = (PFNGLGETUNIFORMOFFSETEXTPROC)glewGetProcAddress((const GLubyte*)"glGetUniformOffsetEXT")) == NULL) || r; + r = ((glUniformBufferEXT = (PFNGLUNIFORMBUFFEREXTPROC)glewGetProcAddress((const GLubyte*)"glUniformBufferEXT")) == NULL) || r; + + return r; +} + +#endif /* GL_EXT_bindable_uniform */ + +#ifdef GL_EXT_blend_color + +static GLboolean _glewInit_GL_EXT_blend_color (GLEW_CONTEXT_ARG_DEF_INIT) +{ + GLboolean r = GL_FALSE; + + r = ((glBlendColorEXT = (PFNGLBLENDCOLOREXTPROC)glewGetProcAddress((const GLubyte*)"glBlendColorEXT")) == NULL) || r; + + return r; +} + +#endif /* GL_EXT_blend_color */ + +#ifdef GL_EXT_blend_equation_separate + +static GLboolean _glewInit_GL_EXT_blend_equation_separate (GLEW_CONTEXT_ARG_DEF_INIT) +{ + GLboolean r = GL_FALSE; + + r = ((glBlendEquationSeparateEXT = (PFNGLBLENDEQUATIONSEPARATEEXTPROC)glewGetProcAddress((const GLubyte*)"glBlendEquationSeparateEXT")) == NULL) || r; + + return r; +} + +#endif /* GL_EXT_blend_equation_separate */ + +#ifdef GL_EXT_blend_func_separate + +static GLboolean _glewInit_GL_EXT_blend_func_separate (GLEW_CONTEXT_ARG_DEF_INIT) +{ + GLboolean r = GL_FALSE; + + r = ((glBlendFuncSeparateEXT = (PFNGLBLENDFUNCSEPARATEEXTPROC)glewGetProcAddress((const GLubyte*)"glBlendFuncSeparateEXT")) == NULL) || r; + + return r; +} + +#endif /* GL_EXT_blend_func_separate */ + +#ifdef GL_EXT_blend_logic_op + +#endif /* GL_EXT_blend_logic_op */ + +#ifdef GL_EXT_blend_minmax + +static GLboolean _glewInit_GL_EXT_blend_minmax (GLEW_CONTEXT_ARG_DEF_INIT) +{ + GLboolean r = GL_FALSE; + + r = ((glBlendEquationEXT = (PFNGLBLENDEQUATIONEXTPROC)glewGetProcAddress((const GLubyte*)"glBlendEquationEXT")) == NULL) || r; + + return r; +} + +#endif /* GL_EXT_blend_minmax */ + +#ifdef GL_EXT_blend_subtract + +#endif /* GL_EXT_blend_subtract */ + +#ifdef GL_EXT_clip_volume_hint + +#endif /* GL_EXT_clip_volume_hint */ + +#ifdef GL_EXT_cmyka + +#endif /* GL_EXT_cmyka */ + +#ifdef GL_EXT_color_subtable + +static GLboolean _glewInit_GL_EXT_color_subtable (GLEW_CONTEXT_ARG_DEF_INIT) +{ + GLboolean r = GL_FALSE; + + r = ((glColorSubTableEXT = (PFNGLCOLORSUBTABLEEXTPROC)glewGetProcAddress((const GLubyte*)"glColorSubTableEXT")) == NULL) || r; + r = ((glCopyColorSubTableEXT = (PFNGLCOPYCOLORSUBTABLEEXTPROC)glewGetProcAddress((const GLubyte*)"glCopyColorSubTableEXT")) == NULL) || r; + + return r; +} + +#endif /* GL_EXT_color_subtable */ + +#ifdef GL_EXT_compiled_vertex_array + +static GLboolean _glewInit_GL_EXT_compiled_vertex_array (GLEW_CONTEXT_ARG_DEF_INIT) +{ + GLboolean r = GL_FALSE; + + r = ((glLockArraysEXT = (PFNGLLOCKARRAYSEXTPROC)glewGetProcAddress((const GLubyte*)"glLockArraysEXT")) == NULL) || r; + r = ((glUnlockArraysEXT = (PFNGLUNLOCKARRAYSEXTPROC)glewGetProcAddress((const GLubyte*)"glUnlockArraysEXT")) == NULL) || r; + + return r; +} + +#endif /* GL_EXT_compiled_vertex_array */ + +#ifdef GL_EXT_convolution + +static GLboolean _glewInit_GL_EXT_convolution (GLEW_CONTEXT_ARG_DEF_INIT) +{ + GLboolean r = GL_FALSE; + + r = ((glConvolutionFilter1DEXT = (PFNGLCONVOLUTIONFILTER1DEXTPROC)glewGetProcAddress((const GLubyte*)"glConvolutionFilter1DEXT")) == NULL) || r; + r = ((glConvolutionFilter2DEXT = (PFNGLCONVOLUTIONFILTER2DEXTPROC)glewGetProcAddress((const GLubyte*)"glConvolutionFilter2DEXT")) == NULL) || r; + r = ((glConvolutionParameterfEXT = (PFNGLCONVOLUTIONPARAMETERFEXTPROC)glewGetProcAddress((const GLubyte*)"glConvolutionParameterfEXT")) == NULL) || r; + r = ((glConvolutionParameterfvEXT = (PFNGLCONVOLUTIONPARAMETERFVEXTPROC)glewGetProcAddress((const GLubyte*)"glConvolutionParameterfvEXT")) == NULL) || r; + r = ((glConvolutionParameteriEXT = (PFNGLCONVOLUTIONPARAMETERIEXTPROC)glewGetProcAddress((const GLubyte*)"glConvolutionParameteriEXT")) == NULL) || r; + r = ((glConvolutionParameterivEXT = (PFNGLCONVOLUTIONPARAMETERIVEXTPROC)glewGetProcAddress((const GLubyte*)"glConvolutionParameterivEXT")) == NULL) || r; + r = ((glCopyConvolutionFilter1DEXT = (PFNGLCOPYCONVOLUTIONFILTER1DEXTPROC)glewGetProcAddress((const GLubyte*)"glCopyConvolutionFilter1DEXT")) == NULL) || r; + r = ((glCopyConvolutionFilter2DEXT = (PFNGLCOPYCONVOLUTIONFILTER2DEXTPROC)glewGetProcAddress((const GLubyte*)"glCopyConvolutionFilter2DEXT")) == NULL) || r; + r = ((glGetConvolutionFilterEXT = (PFNGLGETCONVOLUTIONFILTEREXTPROC)glewGetProcAddress((const GLubyte*)"glGetConvolutionFilterEXT")) == NULL) || r; + r = ((glGetConvolutionParameterfvEXT = (PFNGLGETCONVOLUTIONPARAMETERFVEXTPROC)glewGetProcAddress((const GLubyte*)"glGetConvolutionParameterfvEXT")) == NULL) || r; + r = ((glGetConvolutionParameterivEXT = (PFNGLGETCONVOLUTIONPARAMETERIVEXTPROC)glewGetProcAddress((const GLubyte*)"glGetConvolutionParameterivEXT")) == NULL) || r; + r = ((glGetSeparableFilterEXT = (PFNGLGETSEPARABLEFILTEREXTPROC)glewGetProcAddress((const GLubyte*)"glGetSeparableFilterEXT")) == NULL) || r; + r = ((glSeparableFilter2DEXT = (PFNGLSEPARABLEFILTER2DEXTPROC)glewGetProcAddress((const GLubyte*)"glSeparableFilter2DEXT")) == NULL) || r; + + return r; +} + +#endif /* GL_EXT_convolution */ + +#ifdef GL_EXT_coordinate_frame + +static GLboolean _glewInit_GL_EXT_coordinate_frame (GLEW_CONTEXT_ARG_DEF_INIT) +{ + GLboolean r = GL_FALSE; + + r = ((glBinormalPointerEXT = (PFNGLBINORMALPOINTEREXTPROC)glewGetProcAddress((const GLubyte*)"glBinormalPointerEXT")) == NULL) || r; + r = ((glTangentPointerEXT = (PFNGLTANGENTPOINTEREXTPROC)glewGetProcAddress((const GLubyte*)"glTangentPointerEXT")) == NULL) || r; + + return r; +} + +#endif /* GL_EXT_coordinate_frame */ + +#ifdef GL_EXT_copy_texture + +static GLboolean _glewInit_GL_EXT_copy_texture (GLEW_CONTEXT_ARG_DEF_INIT) +{ + GLboolean r = GL_FALSE; + + r = ((glCopyTexImage1DEXT = (PFNGLCOPYTEXIMAGE1DEXTPROC)glewGetProcAddress((const GLubyte*)"glCopyTexImage1DEXT")) == NULL) || r; + r = ((glCopyTexImage2DEXT = (PFNGLCOPYTEXIMAGE2DEXTPROC)glewGetProcAddress((const GLubyte*)"glCopyTexImage2DEXT")) == NULL) || r; + r = ((glCopyTexSubImage1DEXT = (PFNGLCOPYTEXSUBIMAGE1DEXTPROC)glewGetProcAddress((const GLubyte*)"glCopyTexSubImage1DEXT")) == NULL) || r; + r = ((glCopyTexSubImage2DEXT = (PFNGLCOPYTEXSUBIMAGE2DEXTPROC)glewGetProcAddress((const GLubyte*)"glCopyTexSubImage2DEXT")) == NULL) || r; + r = ((glCopyTexSubImage3DEXT = (PFNGLCOPYTEXSUBIMAGE3DEXTPROC)glewGetProcAddress((const GLubyte*)"glCopyTexSubImage3DEXT")) == NULL) || r; + + return r; +} + +#endif /* GL_EXT_copy_texture */ + +#ifdef GL_EXT_cull_vertex + +static GLboolean _glewInit_GL_EXT_cull_vertex (GLEW_CONTEXT_ARG_DEF_INIT) +{ + GLboolean r = GL_FALSE; + + r = ((glCullParameterdvEXT = (PFNGLCULLPARAMETERDVEXTPROC)glewGetProcAddress((const GLubyte*)"glCullParameterdvEXT")) == NULL) || r; + r = ((glCullParameterfvEXT = (PFNGLCULLPARAMETERFVEXTPROC)glewGetProcAddress((const GLubyte*)"glCullParameterfvEXT")) == NULL) || r; + + return r; +} + +#endif /* GL_EXT_cull_vertex */ + +#ifdef GL_EXT_depth_bounds_test + +static GLboolean _glewInit_GL_EXT_depth_bounds_test (GLEW_CONTEXT_ARG_DEF_INIT) +{ + GLboolean r = GL_FALSE; + + r = ((glDepthBoundsEXT = (PFNGLDEPTHBOUNDSEXTPROC)glewGetProcAddress((const GLubyte*)"glDepthBoundsEXT")) == NULL) || r; + + return r; +} + +#endif /* GL_EXT_depth_bounds_test */ + +#ifdef GL_EXT_direct_state_access + +static GLboolean _glewInit_GL_EXT_direct_state_access (GLEW_CONTEXT_ARG_DEF_INIT) +{ + GLboolean r = GL_FALSE; + + r = ((glBindMultiTextureEXT = (PFNGLBINDMULTITEXTUREEXTPROC)glewGetProcAddress((const GLubyte*)"glBindMultiTextureEXT")) == NULL) || r; + r = ((glCheckNamedFramebufferStatusEXT = (PFNGLCHECKNAMEDFRAMEBUFFERSTATUSEXTPROC)glewGetProcAddress((const GLubyte*)"glCheckNamedFramebufferStatusEXT")) == NULL) || r; + r = ((glClientAttribDefaultEXT = (PFNGLCLIENTATTRIBDEFAULTEXTPROC)glewGetProcAddress((const GLubyte*)"glClientAttribDefaultEXT")) == NULL) || r; + r = ((glCompressedMultiTexImage1DEXT = (PFNGLCOMPRESSEDMULTITEXIMAGE1DEXTPROC)glewGetProcAddress((const GLubyte*)"glCompressedMultiTexImage1DEXT")) == NULL) || r; + r = ((glCompressedMultiTexImage2DEXT = (PFNGLCOMPRESSEDMULTITEXIMAGE2DEXTPROC)glewGetProcAddress((const GLubyte*)"glCompressedMultiTexImage2DEXT")) == NULL) || r; + r = ((glCompressedMultiTexImage3DEXT = (PFNGLCOMPRESSEDMULTITEXIMAGE3DEXTPROC)glewGetProcAddress((const GLubyte*)"glCompressedMultiTexImage3DEXT")) == NULL) || r; + r = ((glCompressedMultiTexSubImage1DEXT = (PFNGLCOMPRESSEDMULTITEXSUBIMAGE1DEXTPROC)glewGetProcAddress((const GLubyte*)"glCompressedMultiTexSubImage1DEXT")) == NULL) || r; + r = ((glCompressedMultiTexSubImage2DEXT = (PFNGLCOMPRESSEDMULTITEXSUBIMAGE2DEXTPROC)glewGetProcAddress((const GLubyte*)"glCompressedMultiTexSubImage2DEXT")) == NULL) || r; + r = ((glCompressedMultiTexSubImage3DEXT = (PFNGLCOMPRESSEDMULTITEXSUBIMAGE3DEXTPROC)glewGetProcAddress((const GLubyte*)"glCompressedMultiTexSubImage3DEXT")) == NULL) || r; + r = ((glCompressedTextureImage1DEXT = (PFNGLCOMPRESSEDTEXTUREIMAGE1DEXTPROC)glewGetProcAddress((const GLubyte*)"glCompressedTextureImage1DEXT")) == NULL) || r; + r = ((glCompressedTextureImage2DEXT = (PFNGLCOMPRESSEDTEXTUREIMAGE2DEXTPROC)glewGetProcAddress((const GLubyte*)"glCompressedTextureImage2DEXT")) == NULL) || r; + r = ((glCompressedTextureImage3DEXT = (PFNGLCOMPRESSEDTEXTUREIMAGE3DEXTPROC)glewGetProcAddress((const GLubyte*)"glCompressedTextureImage3DEXT")) == NULL) || r; + r = ((glCompressedTextureSubImage1DEXT = (PFNGLCOMPRESSEDTEXTURESUBIMAGE1DEXTPROC)glewGetProcAddress((const GLubyte*)"glCompressedTextureSubImage1DEXT")) == NULL) || r; + r = ((glCompressedTextureSubImage2DEXT = (PFNGLCOMPRESSEDTEXTURESUBIMAGE2DEXTPROC)glewGetProcAddress((const GLubyte*)"glCompressedTextureSubImage2DEXT")) == NULL) || r; + r = ((glCompressedTextureSubImage3DEXT = (PFNGLCOMPRESSEDTEXTURESUBIMAGE3DEXTPROC)glewGetProcAddress((const GLubyte*)"glCompressedTextureSubImage3DEXT")) == NULL) || r; + r = ((glCopyMultiTexImage1DEXT = (PFNGLCOPYMULTITEXIMAGE1DEXTPROC)glewGetProcAddress((const GLubyte*)"glCopyMultiTexImage1DEXT")) == NULL) || r; + r = ((glCopyMultiTexImage2DEXT = (PFNGLCOPYMULTITEXIMAGE2DEXTPROC)glewGetProcAddress((const GLubyte*)"glCopyMultiTexImage2DEXT")) == NULL) || r; + r = ((glCopyMultiTexSubImage1DEXT = (PFNGLCOPYMULTITEXSUBIMAGE1DEXTPROC)glewGetProcAddress((const GLubyte*)"glCopyMultiTexSubImage1DEXT")) == NULL) || r; + r = ((glCopyMultiTexSubImage2DEXT = (PFNGLCOPYMULTITEXSUBIMAGE2DEXTPROC)glewGetProcAddress((const GLubyte*)"glCopyMultiTexSubImage2DEXT")) == NULL) || r; + r = ((glCopyMultiTexSubImage3DEXT = (PFNGLCOPYMULTITEXSUBIMAGE3DEXTPROC)glewGetProcAddress((const GLubyte*)"glCopyMultiTexSubImage3DEXT")) == NULL) || r; + r = ((glCopyTextureImage1DEXT = (PFNGLCOPYTEXTUREIMAGE1DEXTPROC)glewGetProcAddress((const GLubyte*)"glCopyTextureImage1DEXT")) == NULL) || r; + r = ((glCopyTextureImage2DEXT = (PFNGLCOPYTEXTUREIMAGE2DEXTPROC)glewGetProcAddress((const GLubyte*)"glCopyTextureImage2DEXT")) == NULL) || r; + r = ((glCopyTextureSubImage1DEXT = (PFNGLCOPYTEXTURESUBIMAGE1DEXTPROC)glewGetProcAddress((const GLubyte*)"glCopyTextureSubImage1DEXT")) == NULL) || r; + r = ((glCopyTextureSubImage2DEXT = (PFNGLCOPYTEXTURESUBIMAGE2DEXTPROC)glewGetProcAddress((const GLubyte*)"glCopyTextureSubImage2DEXT")) == NULL) || r; + r = ((glCopyTextureSubImage3DEXT = (PFNGLCOPYTEXTURESUBIMAGE3DEXTPROC)glewGetProcAddress((const GLubyte*)"glCopyTextureSubImage3DEXT")) == NULL) || r; + r = ((glDisableClientStateIndexedEXT = (PFNGLDISABLECLIENTSTATEINDEXEDEXTPROC)glewGetProcAddress((const GLubyte*)"glDisableClientStateIndexedEXT")) == NULL) || r; + r = ((glEnableClientStateIndexedEXT = (PFNGLENABLECLIENTSTATEINDEXEDEXTPROC)glewGetProcAddress((const GLubyte*)"glEnableClientStateIndexedEXT")) == NULL) || r; + r = ((glFramebufferDrawBufferEXT = (PFNGLFRAMEBUFFERDRAWBUFFEREXTPROC)glewGetProcAddress((const GLubyte*)"glFramebufferDrawBufferEXT")) == NULL) || r; + r = ((glFramebufferDrawBuffersEXT = (PFNGLFRAMEBUFFERDRAWBUFFERSEXTPROC)glewGetProcAddress((const GLubyte*)"glFramebufferDrawBuffersEXT")) == NULL) || r; + r = ((glFramebufferReadBufferEXT = (PFNGLFRAMEBUFFERREADBUFFEREXTPROC)glewGetProcAddress((const GLubyte*)"glFramebufferReadBufferEXT")) == NULL) || r; + r = ((glGenerateMultiTexMipmapEXT = (PFNGLGENERATEMULTITEXMIPMAPEXTPROC)glewGetProcAddress((const GLubyte*)"glGenerateMultiTexMipmapEXT")) == NULL) || r; + r = ((glGenerateTextureMipmapEXT = (PFNGLGENERATETEXTUREMIPMAPEXTPROC)glewGetProcAddress((const GLubyte*)"glGenerateTextureMipmapEXT")) == NULL) || r; + r = ((glGetCompressedMultiTexImageEXT = (PFNGLGETCOMPRESSEDMULTITEXIMAGEEXTPROC)glewGetProcAddress((const GLubyte*)"glGetCompressedMultiTexImageEXT")) == NULL) || r; + r = ((glGetCompressedTextureImageEXT = (PFNGLGETCOMPRESSEDTEXTUREIMAGEEXTPROC)glewGetProcAddress((const GLubyte*)"glGetCompressedTextureImageEXT")) == NULL) || r; + r = ((glGetDoubleIndexedvEXT = (PFNGLGETDOUBLEINDEXEDVEXTPROC)glewGetProcAddress((const GLubyte*)"glGetDoubleIndexedvEXT")) == NULL) || r; + r = ((glGetFloatIndexedvEXT = (PFNGLGETFLOATINDEXEDVEXTPROC)glewGetProcAddress((const GLubyte*)"glGetFloatIndexedvEXT")) == NULL) || r; + r = ((glGetFramebufferParameterivEXT = (PFNGLGETFRAMEBUFFERPARAMETERIVEXTPROC)glewGetProcAddress((const GLubyte*)"glGetFramebufferParameterivEXT")) == NULL) || r; + r = ((glGetMultiTexEnvfvEXT = (PFNGLGETMULTITEXENVFVEXTPROC)glewGetProcAddress((const GLubyte*)"glGetMultiTexEnvfvEXT")) == NULL) || r; + r = ((glGetMultiTexEnvivEXT = (PFNGLGETMULTITEXENVIVEXTPROC)glewGetProcAddress((const GLubyte*)"glGetMultiTexEnvivEXT")) == NULL) || r; + r = ((glGetMultiTexGendvEXT = (PFNGLGETMULTITEXGENDVEXTPROC)glewGetProcAddress((const GLubyte*)"glGetMultiTexGendvEXT")) == NULL) || r; + r = ((glGetMultiTexGenfvEXT = (PFNGLGETMULTITEXGENFVEXTPROC)glewGetProcAddress((const GLubyte*)"glGetMultiTexGenfvEXT")) == NULL) || r; + r = ((glGetMultiTexGenivEXT = (PFNGLGETMULTITEXGENIVEXTPROC)glewGetProcAddress((const GLubyte*)"glGetMultiTexGenivEXT")) == NULL) || r; + r = ((glGetMultiTexImageEXT = (PFNGLGETMULTITEXIMAGEEXTPROC)glewGetProcAddress((const GLubyte*)"glGetMultiTexImageEXT")) == NULL) || r; + r = ((glGetMultiTexLevelParameterfvEXT = (PFNGLGETMULTITEXLEVELPARAMETERFVEXTPROC)glewGetProcAddress((const GLubyte*)"glGetMultiTexLevelParameterfvEXT")) == NULL) || r; + r = ((glGetMultiTexLevelParameterivEXT = (PFNGLGETMULTITEXLEVELPARAMETERIVEXTPROC)glewGetProcAddress((const GLubyte*)"glGetMultiTexLevelParameterivEXT")) == NULL) || r; + r = ((glGetMultiTexParameterIivEXT = (PFNGLGETMULTITEXPARAMETERIIVEXTPROC)glewGetProcAddress((const GLubyte*)"glGetMultiTexParameterIivEXT")) == NULL) || r; + r = ((glGetMultiTexParameterIuivEXT = (PFNGLGETMULTITEXPARAMETERIUIVEXTPROC)glewGetProcAddress((const GLubyte*)"glGetMultiTexParameterIuivEXT")) == NULL) || r; + r = ((glGetMultiTexParameterfvEXT = (PFNGLGETMULTITEXPARAMETERFVEXTPROC)glewGetProcAddress((const GLubyte*)"glGetMultiTexParameterfvEXT")) == NULL) || r; + r = ((glGetMultiTexParameterivEXT = (PFNGLGETMULTITEXPARAMETERIVEXTPROC)glewGetProcAddress((const GLubyte*)"glGetMultiTexParameterivEXT")) == NULL) || r; + r = ((glGetNamedBufferParameterivEXT = (PFNGLGETNAMEDBUFFERPARAMETERIVEXTPROC)glewGetProcAddress((const GLubyte*)"glGetNamedBufferParameterivEXT")) == NULL) || r; + r = ((glGetNamedBufferPointervEXT = (PFNGLGETNAMEDBUFFERPOINTERVEXTPROC)glewGetProcAddress((const GLubyte*)"glGetNamedBufferPointervEXT")) == NULL) || r; + r = ((glGetNamedBufferSubDataEXT = (PFNGLGETNAMEDBUFFERSUBDATAEXTPROC)glewGetProcAddress((const GLubyte*)"glGetNamedBufferSubDataEXT")) == NULL) || r; + r = ((glGetNamedFramebufferAttachmentParameterivEXT = (PFNGLGETNAMEDFRAMEBUFFERATTACHMENTPARAMETERIVEXTPROC)glewGetProcAddress((const GLubyte*)"glGetNamedFramebufferAttachmentParameterivEXT")) == NULL) || r; + r = ((glGetNamedProgramLocalParameterIivEXT = (PFNGLGETNAMEDPROGRAMLOCALPARAMETERIIVEXTPROC)glewGetProcAddress((const GLubyte*)"glGetNamedProgramLocalParameterIivEXT")) == NULL) || r; + r = ((glGetNamedProgramLocalParameterIuivEXT = (PFNGLGETNAMEDPROGRAMLOCALPARAMETERIUIVEXTPROC)glewGetProcAddress((const GLubyte*)"glGetNamedProgramLocalParameterIuivEXT")) == NULL) || r; + r = ((glGetNamedProgramLocalParameterdvEXT = (PFNGLGETNAMEDPROGRAMLOCALPARAMETERDVEXTPROC)glewGetProcAddress((const GLubyte*)"glGetNamedProgramLocalParameterdvEXT")) == NULL) || r; + r = ((glGetNamedProgramLocalParameterfvEXT = (PFNGLGETNAMEDPROGRAMLOCALPARAMETERFVEXTPROC)glewGetProcAddress((const GLubyte*)"glGetNamedProgramLocalParameterfvEXT")) == NULL) || r; + r = ((glGetNamedProgramStringEXT = (PFNGLGETNAMEDPROGRAMSTRINGEXTPROC)glewGetProcAddress((const GLubyte*)"glGetNamedProgramStringEXT")) == NULL) || r; + r = ((glGetNamedProgramivEXT = (PFNGLGETNAMEDPROGRAMIVEXTPROC)glewGetProcAddress((const GLubyte*)"glGetNamedProgramivEXT")) == NULL) || r; + r = ((glGetNamedRenderbufferParameterivEXT = (PFNGLGETNAMEDRENDERBUFFERPARAMETERIVEXTPROC)glewGetProcAddress((const GLubyte*)"glGetNamedRenderbufferParameterivEXT")) == NULL) || r; + r = ((glGetPointerIndexedvEXT = (PFNGLGETPOINTERINDEXEDVEXTPROC)glewGetProcAddress((const GLubyte*)"glGetPointerIndexedvEXT")) == NULL) || r; + r = ((glGetTextureImageEXT = (PFNGLGETTEXTUREIMAGEEXTPROC)glewGetProcAddress((const GLubyte*)"glGetTextureImageEXT")) == NULL) || r; + r = ((glGetTextureLevelParameterfvEXT = (PFNGLGETTEXTURELEVELPARAMETERFVEXTPROC)glewGetProcAddress((const GLubyte*)"glGetTextureLevelParameterfvEXT")) == NULL) || r; + r = ((glGetTextureLevelParameterivEXT = (PFNGLGETTEXTURELEVELPARAMETERIVEXTPROC)glewGetProcAddress((const GLubyte*)"glGetTextureLevelParameterivEXT")) == NULL) || r; + r = ((glGetTextureParameterIivEXT = (PFNGLGETTEXTUREPARAMETERIIVEXTPROC)glewGetProcAddress((const GLubyte*)"glGetTextureParameterIivEXT")) == NULL) || r; + r = ((glGetTextureParameterIuivEXT = (PFNGLGETTEXTUREPARAMETERIUIVEXTPROC)glewGetProcAddress((const GLubyte*)"glGetTextureParameterIuivEXT")) == NULL) || r; + r = ((glGetTextureParameterfvEXT = (PFNGLGETTEXTUREPARAMETERFVEXTPROC)glewGetProcAddress((const GLubyte*)"glGetTextureParameterfvEXT")) == NULL) || r; + r = ((glGetTextureParameterivEXT = (PFNGLGETTEXTUREPARAMETERIVEXTPROC)glewGetProcAddress((const GLubyte*)"glGetTextureParameterivEXT")) == NULL) || r; + r = ((glMapNamedBufferEXT = (PFNGLMAPNAMEDBUFFEREXTPROC)glewGetProcAddress((const GLubyte*)"glMapNamedBufferEXT")) == NULL) || r; + r = ((glMatrixFrustumEXT = (PFNGLMATRIXFRUSTUMEXTPROC)glewGetProcAddress((const GLubyte*)"glMatrixFrustumEXT")) == NULL) || r; + r = ((glMatrixLoadIdentityEXT = (PFNGLMATRIXLOADIDENTITYEXTPROC)glewGetProcAddress((const GLubyte*)"glMatrixLoadIdentityEXT")) == NULL) || r; + r = ((glMatrixLoadTransposedEXT = (PFNGLMATRIXLOADTRANSPOSEDEXTPROC)glewGetProcAddress((const GLubyte*)"glMatrixLoadTransposedEXT")) == NULL) || r; + r = ((glMatrixLoadTransposefEXT = (PFNGLMATRIXLOADTRANSPOSEFEXTPROC)glewGetProcAddress((const GLubyte*)"glMatrixLoadTransposefEXT")) == NULL) || r; + r = ((glMatrixLoaddEXT = (PFNGLMATRIXLOADDEXTPROC)glewGetProcAddress((const GLubyte*)"glMatrixLoaddEXT")) == NULL) || r; + r = ((glMatrixLoadfEXT = (PFNGLMATRIXLOADFEXTPROC)glewGetProcAddress((const GLubyte*)"glMatrixLoadfEXT")) == NULL) || r; + r = ((glMatrixMultTransposedEXT = (PFNGLMATRIXMULTTRANSPOSEDEXTPROC)glewGetProcAddress((const GLubyte*)"glMatrixMultTransposedEXT")) == NULL) || r; + r = ((glMatrixMultTransposefEXT = (PFNGLMATRIXMULTTRANSPOSEFEXTPROC)glewGetProcAddress((const GLubyte*)"glMatrixMultTransposefEXT")) == NULL) || r; + r = ((glMatrixMultdEXT = (PFNGLMATRIXMULTDEXTPROC)glewGetProcAddress((const GLubyte*)"glMatrixMultdEXT")) == NULL) || r; + r = ((glMatrixMultfEXT = (PFNGLMATRIXMULTFEXTPROC)glewGetProcAddress((const GLubyte*)"glMatrixMultfEXT")) == NULL) || r; + r = ((glMatrixOrthoEXT = (PFNGLMATRIXORTHOEXTPROC)glewGetProcAddress((const GLubyte*)"glMatrixOrthoEXT")) == NULL) || r; + r = ((glMatrixPopEXT = (PFNGLMATRIXPOPEXTPROC)glewGetProcAddress((const GLubyte*)"glMatrixPopEXT")) == NULL) || r; + r = ((glMatrixPushEXT = (PFNGLMATRIXPUSHEXTPROC)glewGetProcAddress((const GLubyte*)"glMatrixPushEXT")) == NULL) || r; + r = ((glMatrixRotatedEXT = (PFNGLMATRIXROTATEDEXTPROC)glewGetProcAddress((const GLubyte*)"glMatrixRotatedEXT")) == NULL) || r; + r = ((glMatrixRotatefEXT = (PFNGLMATRIXROTATEFEXTPROC)glewGetProcAddress((const GLubyte*)"glMatrixRotatefEXT")) == NULL) || r; + r = ((glMatrixScaledEXT = (PFNGLMATRIXSCALEDEXTPROC)glewGetProcAddress((const GLubyte*)"glMatrixScaledEXT")) == NULL) || r; + r = ((glMatrixScalefEXT = (PFNGLMATRIXSCALEFEXTPROC)glewGetProcAddress((const GLubyte*)"glMatrixScalefEXT")) == NULL) || r; + r = ((glMatrixTranslatedEXT = (PFNGLMATRIXTRANSLATEDEXTPROC)glewGetProcAddress((const GLubyte*)"glMatrixTranslatedEXT")) == NULL) || r; + r = ((glMatrixTranslatefEXT = (PFNGLMATRIXTRANSLATEFEXTPROC)glewGetProcAddress((const GLubyte*)"glMatrixTranslatefEXT")) == NULL) || r; + r = ((glMultiTexBufferEXT = (PFNGLMULTITEXBUFFEREXTPROC)glewGetProcAddress((const GLubyte*)"glMultiTexBufferEXT")) == NULL) || r; + r = ((glMultiTexCoordPointerEXT = (PFNGLMULTITEXCOORDPOINTEREXTPROC)glewGetProcAddress((const GLubyte*)"glMultiTexCoordPointerEXT")) == NULL) || r; + r = ((glMultiTexEnvfEXT = (PFNGLMULTITEXENVFEXTPROC)glewGetProcAddress((const GLubyte*)"glMultiTexEnvfEXT")) == NULL) || r; + r = ((glMultiTexEnvfvEXT = (PFNGLMULTITEXENVFVEXTPROC)glewGetProcAddress((const GLubyte*)"glMultiTexEnvfvEXT")) == NULL) || r; + r = ((glMultiTexEnviEXT = (PFNGLMULTITEXENVIEXTPROC)glewGetProcAddress((const GLubyte*)"glMultiTexEnviEXT")) == NULL) || r; + r = ((glMultiTexEnvivEXT = (PFNGLMULTITEXENVIVEXTPROC)glewGetProcAddress((const GLubyte*)"glMultiTexEnvivEXT")) == NULL) || r; + r = ((glMultiTexGendEXT = (PFNGLMULTITEXGENDEXTPROC)glewGetProcAddress((const GLubyte*)"glMultiTexGendEXT")) == NULL) || r; + r = ((glMultiTexGendvEXT = (PFNGLMULTITEXGENDVEXTPROC)glewGetProcAddress((const GLubyte*)"glMultiTexGendvEXT")) == NULL) || r; + r = ((glMultiTexGenfEXT = (PFNGLMULTITEXGENFEXTPROC)glewGetProcAddress((const GLubyte*)"glMultiTexGenfEXT")) == NULL) || r; + r = ((glMultiTexGenfvEXT = (PFNGLMULTITEXGENFVEXTPROC)glewGetProcAddress((const GLubyte*)"glMultiTexGenfvEXT")) == NULL) || r; + r = ((glMultiTexGeniEXT = (PFNGLMULTITEXGENIEXTPROC)glewGetProcAddress((const GLubyte*)"glMultiTexGeniEXT")) == NULL) || r; + r = ((glMultiTexGenivEXT = (PFNGLMULTITEXGENIVEXTPROC)glewGetProcAddress((const GLubyte*)"glMultiTexGenivEXT")) == NULL) || r; + r = ((glMultiTexImage1DEXT = (PFNGLMULTITEXIMAGE1DEXTPROC)glewGetProcAddress((const GLubyte*)"glMultiTexImage1DEXT")) == NULL) || r; + r = ((glMultiTexImage2DEXT = (PFNGLMULTITEXIMAGE2DEXTPROC)glewGetProcAddress((const GLubyte*)"glMultiTexImage2DEXT")) == NULL) || r; + r = ((glMultiTexImage3DEXT = (PFNGLMULTITEXIMAGE3DEXTPROC)glewGetProcAddress((const GLubyte*)"glMultiTexImage3DEXT")) == NULL) || r; + r = ((glMultiTexParameterIivEXT = (PFNGLMULTITEXPARAMETERIIVEXTPROC)glewGetProcAddress((const GLubyte*)"glMultiTexParameterIivEXT")) == NULL) || r; + r = ((glMultiTexParameterIuivEXT = (PFNGLMULTITEXPARAMETERIUIVEXTPROC)glewGetProcAddress((const GLubyte*)"glMultiTexParameterIuivEXT")) == NULL) || r; + r = ((glMultiTexParameterfEXT = (PFNGLMULTITEXPARAMETERFEXTPROC)glewGetProcAddress((const GLubyte*)"glMultiTexParameterfEXT")) == NULL) || r; + r = ((glMultiTexParameterfvEXT = (PFNGLMULTITEXPARAMETERFVEXTPROC)glewGetProcAddress((const GLubyte*)"glMultiTexParameterfvEXT")) == NULL) || r; + r = ((glMultiTexParameteriEXT = (PFNGLMULTITEXPARAMETERIEXTPROC)glewGetProcAddress((const GLubyte*)"glMultiTexParameteriEXT")) == NULL) || r; + r = ((glMultiTexParameterivEXT = (PFNGLMULTITEXPARAMETERIVEXTPROC)glewGetProcAddress((const GLubyte*)"glMultiTexParameterivEXT")) == NULL) || r; + r = ((glMultiTexRenderbufferEXT = (PFNGLMULTITEXRENDERBUFFEREXTPROC)glewGetProcAddress((const GLubyte*)"glMultiTexRenderbufferEXT")) == NULL) || r; + r = ((glMultiTexSubImage1DEXT = (PFNGLMULTITEXSUBIMAGE1DEXTPROC)glewGetProcAddress((const GLubyte*)"glMultiTexSubImage1DEXT")) == NULL) || r; + r = ((glMultiTexSubImage2DEXT = (PFNGLMULTITEXSUBIMAGE2DEXTPROC)glewGetProcAddress((const GLubyte*)"glMultiTexSubImage2DEXT")) == NULL) || r; + r = ((glMultiTexSubImage3DEXT = (PFNGLMULTITEXSUBIMAGE3DEXTPROC)glewGetProcAddress((const GLubyte*)"glMultiTexSubImage3DEXT")) == NULL) || r; + r = ((glNamedBufferDataEXT = (PFNGLNAMEDBUFFERDATAEXTPROC)glewGetProcAddress((const GLubyte*)"glNamedBufferDataEXT")) == NULL) || r; + r = ((glNamedBufferSubDataEXT = (PFNGLNAMEDBUFFERSUBDATAEXTPROC)glewGetProcAddress((const GLubyte*)"glNamedBufferSubDataEXT")) == NULL) || r; + r = ((glNamedFramebufferRenderbufferEXT = (PFNGLNAMEDFRAMEBUFFERRENDERBUFFEREXTPROC)glewGetProcAddress((const GLubyte*)"glNamedFramebufferRenderbufferEXT")) == NULL) || r; + r = ((glNamedFramebufferTexture1DEXT = (PFNGLNAMEDFRAMEBUFFERTEXTURE1DEXTPROC)glewGetProcAddress((const GLubyte*)"glNamedFramebufferTexture1DEXT")) == NULL) || r; + r = ((glNamedFramebufferTexture2DEXT = (PFNGLNAMEDFRAMEBUFFERTEXTURE2DEXTPROC)glewGetProcAddress((const GLubyte*)"glNamedFramebufferTexture2DEXT")) == NULL) || r; + r = ((glNamedFramebufferTexture3DEXT = (PFNGLNAMEDFRAMEBUFFERTEXTURE3DEXTPROC)glewGetProcAddress((const GLubyte*)"glNamedFramebufferTexture3DEXT")) == NULL) || r; + r = ((glNamedFramebufferTextureEXT = (PFNGLNAMEDFRAMEBUFFERTEXTUREEXTPROC)glewGetProcAddress((const GLubyte*)"glNamedFramebufferTextureEXT")) == NULL) || r; + r = ((glNamedFramebufferTextureFaceEXT = (PFNGLNAMEDFRAMEBUFFERTEXTUREFACEEXTPROC)glewGetProcAddress((const GLubyte*)"glNamedFramebufferTextureFaceEXT")) == NULL) || r; + r = ((glNamedFramebufferTextureLayerEXT = (PFNGLNAMEDFRAMEBUFFERTEXTURELAYEREXTPROC)glewGetProcAddress((const GLubyte*)"glNamedFramebufferTextureLayerEXT")) == NULL) || r; + r = ((glNamedProgramLocalParameter4dEXT = (PFNGLNAMEDPROGRAMLOCALPARAMETER4DEXTPROC)glewGetProcAddress((const GLubyte*)"glNamedProgramLocalParameter4dEXT")) == NULL) || r; + r = ((glNamedProgramLocalParameter4dvEXT = (PFNGLNAMEDPROGRAMLOCALPARAMETER4DVEXTPROC)glewGetProcAddress((const GLubyte*)"glNamedProgramLocalParameter4dvEXT")) == NULL) || r; + r = ((glNamedProgramLocalParameter4fEXT = (PFNGLNAMEDPROGRAMLOCALPARAMETER4FEXTPROC)glewGetProcAddress((const GLubyte*)"glNamedProgramLocalParameter4fEXT")) == NULL) || r; + r = ((glNamedProgramLocalParameter4fvEXT = (PFNGLNAMEDPROGRAMLOCALPARAMETER4FVEXTPROC)glewGetProcAddress((const GLubyte*)"glNamedProgramLocalParameter4fvEXT")) == NULL) || r; + r = ((glNamedProgramLocalParameterI4iEXT = (PFNGLNAMEDPROGRAMLOCALPARAMETERI4IEXTPROC)glewGetProcAddress((const GLubyte*)"glNamedProgramLocalParameterI4iEXT")) == NULL) || r; + r = ((glNamedProgramLocalParameterI4ivEXT = (PFNGLNAMEDPROGRAMLOCALPARAMETERI4IVEXTPROC)glewGetProcAddress((const GLubyte*)"glNamedProgramLocalParameterI4ivEXT")) == NULL) || r; + r = ((glNamedProgramLocalParameterI4uiEXT = (PFNGLNAMEDPROGRAMLOCALPARAMETERI4UIEXTPROC)glewGetProcAddress((const GLubyte*)"glNamedProgramLocalParameterI4uiEXT")) == NULL) || r; + r = ((glNamedProgramLocalParameterI4uivEXT = (PFNGLNAMEDPROGRAMLOCALPARAMETERI4UIVEXTPROC)glewGetProcAddress((const GLubyte*)"glNamedProgramLocalParameterI4uivEXT")) == NULL) || r; + r = ((glNamedProgramLocalParameters4fvEXT = (PFNGLNAMEDPROGRAMLOCALPARAMETERS4FVEXTPROC)glewGetProcAddress((const GLubyte*)"glNamedProgramLocalParameters4fvEXT")) == NULL) || r; + r = ((glNamedProgramLocalParametersI4ivEXT = (PFNGLNAMEDPROGRAMLOCALPARAMETERSI4IVEXTPROC)glewGetProcAddress((const GLubyte*)"glNamedProgramLocalParametersI4ivEXT")) == NULL) || r; + r = ((glNamedProgramLocalParametersI4uivEXT = (PFNGLNAMEDPROGRAMLOCALPARAMETERSI4UIVEXTPROC)glewGetProcAddress((const GLubyte*)"glNamedProgramLocalParametersI4uivEXT")) == NULL) || r; + r = ((glNamedProgramStringEXT = (PFNGLNAMEDPROGRAMSTRINGEXTPROC)glewGetProcAddress((const GLubyte*)"glNamedProgramStringEXT")) == NULL) || r; + r = ((glNamedRenderbufferStorageEXT = (PFNGLNAMEDRENDERBUFFERSTORAGEEXTPROC)glewGetProcAddress((const GLubyte*)"glNamedRenderbufferStorageEXT")) == NULL) || r; + r = ((glNamedRenderbufferStorageMultisampleCoverageEXT = (PFNGLNAMEDRENDERBUFFERSTORAGEMULTISAMPLECOVERAGEEXTPROC)glewGetProcAddress((const GLubyte*)"glNamedRenderbufferStorageMultisampleCoverageEXT")) == NULL) || r; + r = ((glNamedRenderbufferStorageMultisampleEXT = (PFNGLNAMEDRENDERBUFFERSTORAGEMULTISAMPLEEXTPROC)glewGetProcAddress((const GLubyte*)"glNamedRenderbufferStorageMultisampleEXT")) == NULL) || r; + r = ((glProgramUniform1fEXT = (PFNGLPROGRAMUNIFORM1FEXTPROC)glewGetProcAddress((const GLubyte*)"glProgramUniform1fEXT")) == NULL) || r; + r = ((glProgramUniform1fvEXT = (PFNGLPROGRAMUNIFORM1FVEXTPROC)glewGetProcAddress((const GLubyte*)"glProgramUniform1fvEXT")) == NULL) || r; + r = ((glProgramUniform1iEXT = (PFNGLPROGRAMUNIFORM1IEXTPROC)glewGetProcAddress((const GLubyte*)"glProgramUniform1iEXT")) == NULL) || r; + r = ((glProgramUniform1ivEXT = (PFNGLPROGRAMUNIFORM1IVEXTPROC)glewGetProcAddress((const GLubyte*)"glProgramUniform1ivEXT")) == NULL) || r; + r = ((glProgramUniform1uiEXT = (PFNGLPROGRAMUNIFORM1UIEXTPROC)glewGetProcAddress((const GLubyte*)"glProgramUniform1uiEXT")) == NULL) || r; + r = ((glProgramUniform1uivEXT = (PFNGLPROGRAMUNIFORM1UIVEXTPROC)glewGetProcAddress((const GLubyte*)"glProgramUniform1uivEXT")) == NULL) || r; + r = ((glProgramUniform2fEXT = (PFNGLPROGRAMUNIFORM2FEXTPROC)glewGetProcAddress((const GLubyte*)"glProgramUniform2fEXT")) == NULL) || r; + r = ((glProgramUniform2fvEXT = (PFNGLPROGRAMUNIFORM2FVEXTPROC)glewGetProcAddress((const GLubyte*)"glProgramUniform2fvEXT")) == NULL) || r; + r = ((glProgramUniform2iEXT = (PFNGLPROGRAMUNIFORM2IEXTPROC)glewGetProcAddress((const GLubyte*)"glProgramUniform2iEXT")) == NULL) || r; + r = ((glProgramUniform2ivEXT = (PFNGLPROGRAMUNIFORM2IVEXTPROC)glewGetProcAddress((const GLubyte*)"glProgramUniform2ivEXT")) == NULL) || r; + r = ((glProgramUniform2uiEXT = (PFNGLPROGRAMUNIFORM2UIEXTPROC)glewGetProcAddress((const GLubyte*)"glProgramUniform2uiEXT")) == NULL) || r; + r = ((glProgramUniform2uivEXT = (PFNGLPROGRAMUNIFORM2UIVEXTPROC)glewGetProcAddress((const GLubyte*)"glProgramUniform2uivEXT")) == NULL) || r; + r = ((glProgramUniform3fEXT = (PFNGLPROGRAMUNIFORM3FEXTPROC)glewGetProcAddress((const GLubyte*)"glProgramUniform3fEXT")) == NULL) || r; + r = ((glProgramUniform3fvEXT = (PFNGLPROGRAMUNIFORM3FVEXTPROC)glewGetProcAddress((const GLubyte*)"glProgramUniform3fvEXT")) == NULL) || r; + r = ((glProgramUniform3iEXT = (PFNGLPROGRAMUNIFORM3IEXTPROC)glewGetProcAddress((const GLubyte*)"glProgramUniform3iEXT")) == NULL) || r; + r = ((glProgramUniform3ivEXT = (PFNGLPROGRAMUNIFORM3IVEXTPROC)glewGetProcAddress((const GLubyte*)"glProgramUniform3ivEXT")) == NULL) || r; + r = ((glProgramUniform3uiEXT = (PFNGLPROGRAMUNIFORM3UIEXTPROC)glewGetProcAddress((const GLubyte*)"glProgramUniform3uiEXT")) == NULL) || r; + r = ((glProgramUniform3uivEXT = (PFNGLPROGRAMUNIFORM3UIVEXTPROC)glewGetProcAddress((const GLubyte*)"glProgramUniform3uivEXT")) == NULL) || r; + r = ((glProgramUniform4fEXT = (PFNGLPROGRAMUNIFORM4FEXTPROC)glewGetProcAddress((const GLubyte*)"glProgramUniform4fEXT")) == NULL) || r; + r = ((glProgramUniform4fvEXT = (PFNGLPROGRAMUNIFORM4FVEXTPROC)glewGetProcAddress((const GLubyte*)"glProgramUniform4fvEXT")) == NULL) || r; + r = ((glProgramUniform4iEXT = (PFNGLPROGRAMUNIFORM4IEXTPROC)glewGetProcAddress((const GLubyte*)"glProgramUniform4iEXT")) == NULL) || r; + r = ((glProgramUniform4ivEXT = (PFNGLPROGRAMUNIFORM4IVEXTPROC)glewGetProcAddress((const GLubyte*)"glProgramUniform4ivEXT")) == NULL) || r; + r = ((glProgramUniform4uiEXT = (PFNGLPROGRAMUNIFORM4UIEXTPROC)glewGetProcAddress((const GLubyte*)"glProgramUniform4uiEXT")) == NULL) || r; + r = ((glProgramUniform4uivEXT = (PFNGLPROGRAMUNIFORM4UIVEXTPROC)glewGetProcAddress((const GLubyte*)"glProgramUniform4uivEXT")) == NULL) || r; + r = ((glProgramUniformMatrix2fvEXT = (PFNGLPROGRAMUNIFORMMATRIX2FVEXTPROC)glewGetProcAddress((const GLubyte*)"glProgramUniformMatrix2fvEXT")) == NULL) || r; + r = ((glProgramUniformMatrix2x3fvEXT = (PFNGLPROGRAMUNIFORMMATRIX2X3FVEXTPROC)glewGetProcAddress((const GLubyte*)"glProgramUniformMatrix2x3fvEXT")) == NULL) || r; + r = ((glProgramUniformMatrix2x4fvEXT = (PFNGLPROGRAMUNIFORMMATRIX2X4FVEXTPROC)glewGetProcAddress((const GLubyte*)"glProgramUniformMatrix2x4fvEXT")) == NULL) || r; + r = ((glProgramUniformMatrix3fvEXT = (PFNGLPROGRAMUNIFORMMATRIX3FVEXTPROC)glewGetProcAddress((const GLubyte*)"glProgramUniformMatrix3fvEXT")) == NULL) || r; + r = ((glProgramUniformMatrix3x2fvEXT = (PFNGLPROGRAMUNIFORMMATRIX3X2FVEXTPROC)glewGetProcAddress((const GLubyte*)"glProgramUniformMatrix3x2fvEXT")) == NULL) || r; + r = ((glProgramUniformMatrix3x4fvEXT = (PFNGLPROGRAMUNIFORMMATRIX3X4FVEXTPROC)glewGetProcAddress((const GLubyte*)"glProgramUniformMatrix3x4fvEXT")) == NULL) || r; + r = ((glProgramUniformMatrix4fvEXT = (PFNGLPROGRAMUNIFORMMATRIX4FVEXTPROC)glewGetProcAddress((const GLubyte*)"glProgramUniformMatrix4fvEXT")) == NULL) || r; + r = ((glProgramUniformMatrix4x2fvEXT = (PFNGLPROGRAMUNIFORMMATRIX4X2FVEXTPROC)glewGetProcAddress((const GLubyte*)"glProgramUniformMatrix4x2fvEXT")) == NULL) || r; + r = ((glProgramUniformMatrix4x3fvEXT = (PFNGLPROGRAMUNIFORMMATRIX4X3FVEXTPROC)glewGetProcAddress((const GLubyte*)"glProgramUniformMatrix4x3fvEXT")) == NULL) || r; + r = ((glPushClientAttribDefaultEXT = (PFNGLPUSHCLIENTATTRIBDEFAULTEXTPROC)glewGetProcAddress((const GLubyte*)"glPushClientAttribDefaultEXT")) == NULL) || r; + r = ((glTextureBufferEXT = (PFNGLTEXTUREBUFFEREXTPROC)glewGetProcAddress((const GLubyte*)"glTextureBufferEXT")) == NULL) || r; + r = ((glTextureImage1DEXT = (PFNGLTEXTUREIMAGE1DEXTPROC)glewGetProcAddress((const GLubyte*)"glTextureImage1DEXT")) == NULL) || r; + r = ((glTextureImage2DEXT = (PFNGLTEXTUREIMAGE2DEXTPROC)glewGetProcAddress((const GLubyte*)"glTextureImage2DEXT")) == NULL) || r; + r = ((glTextureImage3DEXT = (PFNGLTEXTUREIMAGE3DEXTPROC)glewGetProcAddress((const GLubyte*)"glTextureImage3DEXT")) == NULL) || r; + r = ((glTextureParameterIivEXT = (PFNGLTEXTUREPARAMETERIIVEXTPROC)glewGetProcAddress((const GLubyte*)"glTextureParameterIivEXT")) == NULL) || r; + r = ((glTextureParameterIuivEXT = (PFNGLTEXTUREPARAMETERIUIVEXTPROC)glewGetProcAddress((const GLubyte*)"glTextureParameterIuivEXT")) == NULL) || r; + r = ((glTextureParameterfEXT = (PFNGLTEXTUREPARAMETERFEXTPROC)glewGetProcAddress((const GLubyte*)"glTextureParameterfEXT")) == NULL) || r; + r = ((glTextureParameterfvEXT = (PFNGLTEXTUREPARAMETERFVEXTPROC)glewGetProcAddress((const GLubyte*)"glTextureParameterfvEXT")) == NULL) || r; + r = ((glTextureParameteriEXT = (PFNGLTEXTUREPARAMETERIEXTPROC)glewGetProcAddress((const GLubyte*)"glTextureParameteriEXT")) == NULL) || r; + r = ((glTextureParameterivEXT = (PFNGLTEXTUREPARAMETERIVEXTPROC)glewGetProcAddress((const GLubyte*)"glTextureParameterivEXT")) == NULL) || r; + r = ((glTextureRenderbufferEXT = (PFNGLTEXTURERENDERBUFFEREXTPROC)glewGetProcAddress((const GLubyte*)"glTextureRenderbufferEXT")) == NULL) || r; + r = ((glTextureSubImage1DEXT = (PFNGLTEXTURESUBIMAGE1DEXTPROC)glewGetProcAddress((const GLubyte*)"glTextureSubImage1DEXT")) == NULL) || r; + r = ((glTextureSubImage2DEXT = (PFNGLTEXTURESUBIMAGE2DEXTPROC)glewGetProcAddress((const GLubyte*)"glTextureSubImage2DEXT")) == NULL) || r; + r = ((glTextureSubImage3DEXT = (PFNGLTEXTURESUBIMAGE3DEXTPROC)glewGetProcAddress((const GLubyte*)"glTextureSubImage3DEXT")) == NULL) || r; + r = ((glUnmapNamedBufferEXT = (PFNGLUNMAPNAMEDBUFFEREXTPROC)glewGetProcAddress((const GLubyte*)"glUnmapNamedBufferEXT")) == NULL) || r; + + return r; +} + +#endif /* GL_EXT_direct_state_access */ + +#ifdef GL_EXT_draw_buffers2 + +static GLboolean _glewInit_GL_EXT_draw_buffers2 (GLEW_CONTEXT_ARG_DEF_INIT) +{ + GLboolean r = GL_FALSE; + + r = ((glColorMaskIndexedEXT = (PFNGLCOLORMASKINDEXEDEXTPROC)glewGetProcAddress((const GLubyte*)"glColorMaskIndexedEXT")) == NULL) || r; + r = ((glDisableIndexedEXT = (PFNGLDISABLEINDEXEDEXTPROC)glewGetProcAddress((const GLubyte*)"glDisableIndexedEXT")) == NULL) || r; + r = ((glEnableIndexedEXT = (PFNGLENABLEINDEXEDEXTPROC)glewGetProcAddress((const GLubyte*)"glEnableIndexedEXT")) == NULL) || r; + r = ((glGetBooleanIndexedvEXT = (PFNGLGETBOOLEANINDEXEDVEXTPROC)glewGetProcAddress((const GLubyte*)"glGetBooleanIndexedvEXT")) == NULL) || r; + r = ((glGetIntegerIndexedvEXT = (PFNGLGETINTEGERINDEXEDVEXTPROC)glewGetProcAddress((const GLubyte*)"glGetIntegerIndexedvEXT")) == NULL) || r; + r = ((glIsEnabledIndexedEXT = (PFNGLISENABLEDINDEXEDEXTPROC)glewGetProcAddress((const GLubyte*)"glIsEnabledIndexedEXT")) == NULL) || r; + + return r; +} + +#endif /* GL_EXT_draw_buffers2 */ + +#ifdef GL_EXT_draw_instanced + +static GLboolean _glewInit_GL_EXT_draw_instanced (GLEW_CONTEXT_ARG_DEF_INIT) +{ + GLboolean r = GL_FALSE; + + r = ((glDrawArraysInstancedEXT = (PFNGLDRAWARRAYSINSTANCEDEXTPROC)glewGetProcAddress((const GLubyte*)"glDrawArraysInstancedEXT")) == NULL) || r; + r = ((glDrawElementsInstancedEXT = (PFNGLDRAWELEMENTSINSTANCEDEXTPROC)glewGetProcAddress((const GLubyte*)"glDrawElementsInstancedEXT")) == NULL) || r; + + return r; +} + +#endif /* GL_EXT_draw_instanced */ + +#ifdef GL_EXT_draw_range_elements + +static GLboolean _glewInit_GL_EXT_draw_range_elements (GLEW_CONTEXT_ARG_DEF_INIT) +{ + GLboolean r = GL_FALSE; + + r = ((glDrawRangeElementsEXT = (PFNGLDRAWRANGEELEMENTSEXTPROC)glewGetProcAddress((const GLubyte*)"glDrawRangeElementsEXT")) == NULL) || r; + + return r; +} + +#endif /* GL_EXT_draw_range_elements */ + +#ifdef GL_EXT_fog_coord + +static GLboolean _glewInit_GL_EXT_fog_coord (GLEW_CONTEXT_ARG_DEF_INIT) +{ + GLboolean r = GL_FALSE; + + r = ((glFogCoordPointerEXT = (PFNGLFOGCOORDPOINTEREXTPROC)glewGetProcAddress((const GLubyte*)"glFogCoordPointerEXT")) == NULL) || r; + r = ((glFogCoorddEXT = (PFNGLFOGCOORDDEXTPROC)glewGetProcAddress((const GLubyte*)"glFogCoorddEXT")) == NULL) || r; + r = ((glFogCoorddvEXT = (PFNGLFOGCOORDDVEXTPROC)glewGetProcAddress((const GLubyte*)"glFogCoorddvEXT")) == NULL) || r; + r = ((glFogCoordfEXT = (PFNGLFOGCOORDFEXTPROC)glewGetProcAddress((const GLubyte*)"glFogCoordfEXT")) == NULL) || r; + r = ((glFogCoordfvEXT = (PFNGLFOGCOORDFVEXTPROC)glewGetProcAddress((const GLubyte*)"glFogCoordfvEXT")) == NULL) || r; + + return r; +} + +#endif /* GL_EXT_fog_coord */ + +#ifdef GL_EXT_fragment_lighting + +static GLboolean _glewInit_GL_EXT_fragment_lighting (GLEW_CONTEXT_ARG_DEF_INIT) +{ + GLboolean r = GL_FALSE; + + r = ((glFragmentColorMaterialEXT = (PFNGLFRAGMENTCOLORMATERIALEXTPROC)glewGetProcAddress((const GLubyte*)"glFragmentColorMaterialEXT")) == NULL) || r; + r = ((glFragmentLightModelfEXT = (PFNGLFRAGMENTLIGHTMODELFEXTPROC)glewGetProcAddress((const GLubyte*)"glFragmentLightModelfEXT")) == NULL) || r; + r = ((glFragmentLightModelfvEXT = (PFNGLFRAGMENTLIGHTMODELFVEXTPROC)glewGetProcAddress((const GLubyte*)"glFragmentLightModelfvEXT")) == NULL) || r; + r = ((glFragmentLightModeliEXT = (PFNGLFRAGMENTLIGHTMODELIEXTPROC)glewGetProcAddress((const GLubyte*)"glFragmentLightModeliEXT")) == NULL) || r; + r = ((glFragmentLightModelivEXT = (PFNGLFRAGMENTLIGHTMODELIVEXTPROC)glewGetProcAddress((const GLubyte*)"glFragmentLightModelivEXT")) == NULL) || r; + r = ((glFragmentLightfEXT = (PFNGLFRAGMENTLIGHTFEXTPROC)glewGetProcAddress((const GLubyte*)"glFragmentLightfEXT")) == NULL) || r; + r = ((glFragmentLightfvEXT = (PFNGLFRAGMENTLIGHTFVEXTPROC)glewGetProcAddress((const GLubyte*)"glFragmentLightfvEXT")) == NULL) || r; + r = ((glFragmentLightiEXT = (PFNGLFRAGMENTLIGHTIEXTPROC)glewGetProcAddress((const GLubyte*)"glFragmentLightiEXT")) == NULL) || r; + r = ((glFragmentLightivEXT = (PFNGLFRAGMENTLIGHTIVEXTPROC)glewGetProcAddress((const GLubyte*)"glFragmentLightivEXT")) == NULL) || r; + r = ((glFragmentMaterialfEXT = (PFNGLFRAGMENTMATERIALFEXTPROC)glewGetProcAddress((const GLubyte*)"glFragmentMaterialfEXT")) == NULL) || r; + r = ((glFragmentMaterialfvEXT = (PFNGLFRAGMENTMATERIALFVEXTPROC)glewGetProcAddress((const GLubyte*)"glFragmentMaterialfvEXT")) == NULL) || r; + r = ((glFragmentMaterialiEXT = (PFNGLFRAGMENTMATERIALIEXTPROC)glewGetProcAddress((const GLubyte*)"glFragmentMaterialiEXT")) == NULL) || r; + r = ((glFragmentMaterialivEXT = (PFNGLFRAGMENTMATERIALIVEXTPROC)glewGetProcAddress((const GLubyte*)"glFragmentMaterialivEXT")) == NULL) || r; + r = ((glGetFragmentLightfvEXT = (PFNGLGETFRAGMENTLIGHTFVEXTPROC)glewGetProcAddress((const GLubyte*)"glGetFragmentLightfvEXT")) == NULL) || r; + r = ((glGetFragmentLightivEXT = (PFNGLGETFRAGMENTLIGHTIVEXTPROC)glewGetProcAddress((const GLubyte*)"glGetFragmentLightivEXT")) == NULL) || r; + r = ((glGetFragmentMaterialfvEXT = (PFNGLGETFRAGMENTMATERIALFVEXTPROC)glewGetProcAddress((const GLubyte*)"glGetFragmentMaterialfvEXT")) == NULL) || r; + r = ((glGetFragmentMaterialivEXT = (PFNGLGETFRAGMENTMATERIALIVEXTPROC)glewGetProcAddress((const GLubyte*)"glGetFragmentMaterialivEXT")) == NULL) || r; + r = ((glLightEnviEXT = (PFNGLLIGHTENVIEXTPROC)glewGetProcAddress((const GLubyte*)"glLightEnviEXT")) == NULL) || r; + + return r; +} + +#endif /* GL_EXT_fragment_lighting */ + +#ifdef GL_EXT_framebuffer_blit + +static GLboolean _glewInit_GL_EXT_framebuffer_blit (GLEW_CONTEXT_ARG_DEF_INIT) +{ + GLboolean r = GL_FALSE; + + r = ((glBlitFramebufferEXT = (PFNGLBLITFRAMEBUFFEREXTPROC)glewGetProcAddress((const GLubyte*)"glBlitFramebufferEXT")) == NULL) || r; + + return r; +} + +#endif /* GL_EXT_framebuffer_blit */ + +#ifdef GL_EXT_framebuffer_multisample + +static GLboolean _glewInit_GL_EXT_framebuffer_multisample (GLEW_CONTEXT_ARG_DEF_INIT) +{ + GLboolean r = GL_FALSE; + + r = ((glRenderbufferStorageMultisampleEXT = (PFNGLRENDERBUFFERSTORAGEMULTISAMPLEEXTPROC)glewGetProcAddress((const GLubyte*)"glRenderbufferStorageMultisampleEXT")) == NULL) || r; + + return r; +} + +#endif /* GL_EXT_framebuffer_multisample */ + +#ifdef GL_EXT_framebuffer_object + +static GLboolean _glewInit_GL_EXT_framebuffer_object (GLEW_CONTEXT_ARG_DEF_INIT) +{ + GLboolean r = GL_FALSE; + + r = ((glBindFramebufferEXT = (PFNGLBINDFRAMEBUFFEREXTPROC)glewGetProcAddress((const GLubyte*)"glBindFramebufferEXT")) == NULL) || r; + r = ((glBindRenderbufferEXT = (PFNGLBINDRENDERBUFFEREXTPROC)glewGetProcAddress((const GLubyte*)"glBindRenderbufferEXT")) == NULL) || r; + r = ((glCheckFramebufferStatusEXT = (PFNGLCHECKFRAMEBUFFERSTATUSEXTPROC)glewGetProcAddress((const GLubyte*)"glCheckFramebufferStatusEXT")) == NULL) || r; + r = ((glDeleteFramebuffersEXT = (PFNGLDELETEFRAMEBUFFERSEXTPROC)glewGetProcAddress((const GLubyte*)"glDeleteFramebuffersEXT")) == NULL) || r; + r = ((glDeleteRenderbuffersEXT = (PFNGLDELETERENDERBUFFERSEXTPROC)glewGetProcAddress((const GLubyte*)"glDeleteRenderbuffersEXT")) == NULL) || r; + r = ((glFramebufferRenderbufferEXT = (PFNGLFRAMEBUFFERRENDERBUFFEREXTPROC)glewGetProcAddress((const GLubyte*)"glFramebufferRenderbufferEXT")) == NULL) || r; + r = ((glFramebufferTexture1DEXT = (PFNGLFRAMEBUFFERTEXTURE1DEXTPROC)glewGetProcAddress((const GLubyte*)"glFramebufferTexture1DEXT")) == NULL) || r; + r = ((glFramebufferTexture2DEXT = (PFNGLFRAMEBUFFERTEXTURE2DEXTPROC)glewGetProcAddress((const GLubyte*)"glFramebufferTexture2DEXT")) == NULL) || r; + r = ((glFramebufferTexture3DEXT = (PFNGLFRAMEBUFFERTEXTURE3DEXTPROC)glewGetProcAddress((const GLubyte*)"glFramebufferTexture3DEXT")) == NULL) || r; + r = ((glGenFramebuffersEXT = (PFNGLGENFRAMEBUFFERSEXTPROC)glewGetProcAddress((const GLubyte*)"glGenFramebuffersEXT")) == NULL) || r; + r = ((glGenRenderbuffersEXT = (PFNGLGENRENDERBUFFERSEXTPROC)glewGetProcAddress((const GLubyte*)"glGenRenderbuffersEXT")) == NULL) || r; + r = ((glGenerateMipmapEXT = (PFNGLGENERATEMIPMAPEXTPROC)glewGetProcAddress((const GLubyte*)"glGenerateMipmapEXT")) == NULL) || r; + r = ((glGetFramebufferAttachmentParameterivEXT = (PFNGLGETFRAMEBUFFERATTACHMENTPARAMETERIVEXTPROC)glewGetProcAddress((const GLubyte*)"glGetFramebufferAttachmentParameterivEXT")) == NULL) || r; + r = ((glGetRenderbufferParameterivEXT = (PFNGLGETRENDERBUFFERPARAMETERIVEXTPROC)glewGetProcAddress((const GLubyte*)"glGetRenderbufferParameterivEXT")) == NULL) || r; + r = ((glIsFramebufferEXT = (PFNGLISFRAMEBUFFEREXTPROC)glewGetProcAddress((const GLubyte*)"glIsFramebufferEXT")) == NULL) || r; + r = ((glIsRenderbufferEXT = (PFNGLISRENDERBUFFEREXTPROC)glewGetProcAddress((const GLubyte*)"glIsRenderbufferEXT")) == NULL) || r; + r = ((glRenderbufferStorageEXT = (PFNGLRENDERBUFFERSTORAGEEXTPROC)glewGetProcAddress((const GLubyte*)"glRenderbufferStorageEXT")) == NULL) || r; + + return r; +} + +#endif /* GL_EXT_framebuffer_object */ + +#ifdef GL_EXT_framebuffer_sRGB + +#endif /* GL_EXT_framebuffer_sRGB */ + +#ifdef GL_EXT_geometry_shader4 + +static GLboolean _glewInit_GL_EXT_geometry_shader4 (GLEW_CONTEXT_ARG_DEF_INIT) +{ + GLboolean r = GL_FALSE; + + r = ((glFramebufferTextureEXT = (PFNGLFRAMEBUFFERTEXTUREEXTPROC)glewGetProcAddress((const GLubyte*)"glFramebufferTextureEXT")) == NULL) || r; + r = ((glFramebufferTextureFaceEXT = (PFNGLFRAMEBUFFERTEXTUREFACEEXTPROC)glewGetProcAddress((const GLubyte*)"glFramebufferTextureFaceEXT")) == NULL) || r; + r = ((glFramebufferTextureLayerEXT = (PFNGLFRAMEBUFFERTEXTURELAYEREXTPROC)glewGetProcAddress((const GLubyte*)"glFramebufferTextureLayerEXT")) == NULL) || r; + r = ((glProgramParameteriEXT = (PFNGLPROGRAMPARAMETERIEXTPROC)glewGetProcAddress((const GLubyte*)"glProgramParameteriEXT")) == NULL) || r; + + return r; +} + +#endif /* GL_EXT_geometry_shader4 */ + +#ifdef GL_EXT_gpu_program_parameters + +static GLboolean _glewInit_GL_EXT_gpu_program_parameters (GLEW_CONTEXT_ARG_DEF_INIT) +{ + GLboolean r = GL_FALSE; + + r = ((glProgramEnvParameters4fvEXT = (PFNGLPROGRAMENVPARAMETERS4FVEXTPROC)glewGetProcAddress((const GLubyte*)"glProgramEnvParameters4fvEXT")) == NULL) || r; + r = ((glProgramLocalParameters4fvEXT = (PFNGLPROGRAMLOCALPARAMETERS4FVEXTPROC)glewGetProcAddress((const GLubyte*)"glProgramLocalParameters4fvEXT")) == NULL) || r; + + return r; +} + +#endif /* GL_EXT_gpu_program_parameters */ + +#ifdef GL_EXT_gpu_shader4 + +static GLboolean _glewInit_GL_EXT_gpu_shader4 (GLEW_CONTEXT_ARG_DEF_INIT) +{ + GLboolean r = GL_FALSE; + + r = ((glBindFragDataLocationEXT = (PFNGLBINDFRAGDATALOCATIONEXTPROC)glewGetProcAddress((const GLubyte*)"glBindFragDataLocationEXT")) == NULL) || r; + r = ((glGetFragDataLocationEXT = (PFNGLGETFRAGDATALOCATIONEXTPROC)glewGetProcAddress((const GLubyte*)"glGetFragDataLocationEXT")) == NULL) || r; + r = ((glGetUniformuivEXT = (PFNGLGETUNIFORMUIVEXTPROC)glewGetProcAddress((const GLubyte*)"glGetUniformuivEXT")) == NULL) || r; + r = ((glGetVertexAttribIivEXT = (PFNGLGETVERTEXATTRIBIIVEXTPROC)glewGetProcAddress((const GLubyte*)"glGetVertexAttribIivEXT")) == NULL) || r; + r = ((glGetVertexAttribIuivEXT = (PFNGLGETVERTEXATTRIBIUIVEXTPROC)glewGetProcAddress((const GLubyte*)"glGetVertexAttribIuivEXT")) == NULL) || r; + r = ((glUniform1uiEXT = (PFNGLUNIFORM1UIEXTPROC)glewGetProcAddress((const GLubyte*)"glUniform1uiEXT")) == NULL) || r; + r = ((glUniform1uivEXT = (PFNGLUNIFORM1UIVEXTPROC)glewGetProcAddress((const GLubyte*)"glUniform1uivEXT")) == NULL) || r; + r = ((glUniform2uiEXT = (PFNGLUNIFORM2UIEXTPROC)glewGetProcAddress((const GLubyte*)"glUniform2uiEXT")) == NULL) || r; + r = ((glUniform2uivEXT = (PFNGLUNIFORM2UIVEXTPROC)glewGetProcAddress((const GLubyte*)"glUniform2uivEXT")) == NULL) || r; + r = ((glUniform3uiEXT = (PFNGLUNIFORM3UIEXTPROC)glewGetProcAddress((const GLubyte*)"glUniform3uiEXT")) == NULL) || r; + r = ((glUniform3uivEXT = (PFNGLUNIFORM3UIVEXTPROC)glewGetProcAddress((const GLubyte*)"glUniform3uivEXT")) == NULL) || r; + r = ((glUniform4uiEXT = (PFNGLUNIFORM4UIEXTPROC)glewGetProcAddress((const GLubyte*)"glUniform4uiEXT")) == NULL) || r; + r = ((glUniform4uivEXT = (PFNGLUNIFORM4UIVEXTPROC)glewGetProcAddress((const GLubyte*)"glUniform4uivEXT")) == NULL) || r; + r = ((glVertexAttribI1iEXT = (PFNGLVERTEXATTRIBI1IEXTPROC)glewGetProcAddress((const GLubyte*)"glVertexAttribI1iEXT")) == NULL) || r; + r = ((glVertexAttribI1ivEXT = (PFNGLVERTEXATTRIBI1IVEXTPROC)glewGetProcAddress((const GLubyte*)"glVertexAttribI1ivEXT")) == NULL) || r; + r = ((glVertexAttribI1uiEXT = (PFNGLVERTEXATTRIBI1UIEXTPROC)glewGetProcAddress((const GLubyte*)"glVertexAttribI1uiEXT")) == NULL) || r; + r = ((glVertexAttribI1uivEXT = (PFNGLVERTEXATTRIBI1UIVEXTPROC)glewGetProcAddress((const GLubyte*)"glVertexAttribI1uivEXT")) == NULL) || r; + r = ((glVertexAttribI2iEXT = (PFNGLVERTEXATTRIBI2IEXTPROC)glewGetProcAddress((const GLubyte*)"glVertexAttribI2iEXT")) == NULL) || r; + r = ((glVertexAttribI2ivEXT = (PFNGLVERTEXATTRIBI2IVEXTPROC)glewGetProcAddress((const GLubyte*)"glVertexAttribI2ivEXT")) == NULL) || r; + r = ((glVertexAttribI2uiEXT = (PFNGLVERTEXATTRIBI2UIEXTPROC)glewGetProcAddress((const GLubyte*)"glVertexAttribI2uiEXT")) == NULL) || r; + r = ((glVertexAttribI2uivEXT = (PFNGLVERTEXATTRIBI2UIVEXTPROC)glewGetProcAddress((const GLubyte*)"glVertexAttribI2uivEXT")) == NULL) || r; + r = ((glVertexAttribI3iEXT = (PFNGLVERTEXATTRIBI3IEXTPROC)glewGetProcAddress((const GLubyte*)"glVertexAttribI3iEXT")) == NULL) || r; + r = ((glVertexAttribI3ivEXT = (PFNGLVERTEXATTRIBI3IVEXTPROC)glewGetProcAddress((const GLubyte*)"glVertexAttribI3ivEXT")) == NULL) || r; + r = ((glVertexAttribI3uiEXT = (PFNGLVERTEXATTRIBI3UIEXTPROC)glewGetProcAddress((const GLubyte*)"glVertexAttribI3uiEXT")) == NULL) || r; + r = ((glVertexAttribI3uivEXT = (PFNGLVERTEXATTRIBI3UIVEXTPROC)glewGetProcAddress((const GLubyte*)"glVertexAttribI3uivEXT")) == NULL) || r; + r = ((glVertexAttribI4bvEXT = (PFNGLVERTEXATTRIBI4BVEXTPROC)glewGetProcAddress((const GLubyte*)"glVertexAttribI4bvEXT")) == NULL) || r; + r = ((glVertexAttribI4iEXT = (PFNGLVERTEXATTRIBI4IEXTPROC)glewGetProcAddress((const GLubyte*)"glVertexAttribI4iEXT")) == NULL) || r; + r = ((glVertexAttribI4ivEXT = (PFNGLVERTEXATTRIBI4IVEXTPROC)glewGetProcAddress((const GLubyte*)"glVertexAttribI4ivEXT")) == NULL) || r; + r = ((glVertexAttribI4svEXT = (PFNGLVERTEXATTRIBI4SVEXTPROC)glewGetProcAddress((const GLubyte*)"glVertexAttribI4svEXT")) == NULL) || r; + r = ((glVertexAttribI4ubvEXT = (PFNGLVERTEXATTRIBI4UBVEXTPROC)glewGetProcAddress((const GLubyte*)"glVertexAttribI4ubvEXT")) == NULL) || r; + r = ((glVertexAttribI4uiEXT = (PFNGLVERTEXATTRIBI4UIEXTPROC)glewGetProcAddress((const GLubyte*)"glVertexAttribI4uiEXT")) == NULL) || r; + r = ((glVertexAttribI4uivEXT = (PFNGLVERTEXATTRIBI4UIVEXTPROC)glewGetProcAddress((const GLubyte*)"glVertexAttribI4uivEXT")) == NULL) || r; + r = ((glVertexAttribI4usvEXT = (PFNGLVERTEXATTRIBI4USVEXTPROC)glewGetProcAddress((const GLubyte*)"glVertexAttribI4usvEXT")) == NULL) || r; + r = ((glVertexAttribIPointerEXT = (PFNGLVERTEXATTRIBIPOINTEREXTPROC)glewGetProcAddress((const GLubyte*)"glVertexAttribIPointerEXT")) == NULL) || r; + + return r; +} + +#endif /* GL_EXT_gpu_shader4 */ + +#ifdef GL_EXT_histogram + +static GLboolean _glewInit_GL_EXT_histogram (GLEW_CONTEXT_ARG_DEF_INIT) +{ + GLboolean r = GL_FALSE; + + r = ((glGetHistogramEXT = (PFNGLGETHISTOGRAMEXTPROC)glewGetProcAddress((const GLubyte*)"glGetHistogramEXT")) == NULL) || r; + r = ((glGetHistogramParameterfvEXT = (PFNGLGETHISTOGRAMPARAMETERFVEXTPROC)glewGetProcAddress((const GLubyte*)"glGetHistogramParameterfvEXT")) == NULL) || r; + r = ((glGetHistogramParameterivEXT = (PFNGLGETHISTOGRAMPARAMETERIVEXTPROC)glewGetProcAddress((const GLubyte*)"glGetHistogramParameterivEXT")) == NULL) || r; + r = ((glGetMinmaxEXT = (PFNGLGETMINMAXEXTPROC)glewGetProcAddress((const GLubyte*)"glGetMinmaxEXT")) == NULL) || r; + r = ((glGetMinmaxParameterfvEXT = (PFNGLGETMINMAXPARAMETERFVEXTPROC)glewGetProcAddress((const GLubyte*)"glGetMinmaxParameterfvEXT")) == NULL) || r; + r = ((glGetMinmaxParameterivEXT = (PFNGLGETMINMAXPARAMETERIVEXTPROC)glewGetProcAddress((const GLubyte*)"glGetMinmaxParameterivEXT")) == NULL) || r; + r = ((glHistogramEXT = (PFNGLHISTOGRAMEXTPROC)glewGetProcAddress((const GLubyte*)"glHistogramEXT")) == NULL) || r; + r = ((glMinmaxEXT = (PFNGLMINMAXEXTPROC)glewGetProcAddress((const GLubyte*)"glMinmaxEXT")) == NULL) || r; + r = ((glResetHistogramEXT = (PFNGLRESETHISTOGRAMEXTPROC)glewGetProcAddress((const GLubyte*)"glResetHistogramEXT")) == NULL) || r; + r = ((glResetMinmaxEXT = (PFNGLRESETMINMAXEXTPROC)glewGetProcAddress((const GLubyte*)"glResetMinmaxEXT")) == NULL) || r; + + return r; +} + +#endif /* GL_EXT_histogram */ + +#ifdef GL_EXT_index_array_formats + +#endif /* GL_EXT_index_array_formats */ + +#ifdef GL_EXT_index_func + +static GLboolean _glewInit_GL_EXT_index_func (GLEW_CONTEXT_ARG_DEF_INIT) +{ + GLboolean r = GL_FALSE; + + r = ((glIndexFuncEXT = (PFNGLINDEXFUNCEXTPROC)glewGetProcAddress((const GLubyte*)"glIndexFuncEXT")) == NULL) || r; + + return r; +} + +#endif /* GL_EXT_index_func */ + +#ifdef GL_EXT_index_material + +static GLboolean _glewInit_GL_EXT_index_material (GLEW_CONTEXT_ARG_DEF_INIT) +{ + GLboolean r = GL_FALSE; + + r = ((glIndexMaterialEXT = (PFNGLINDEXMATERIALEXTPROC)glewGetProcAddress((const GLubyte*)"glIndexMaterialEXT")) == NULL) || r; + + return r; +} + +#endif /* GL_EXT_index_material */ + +#ifdef GL_EXT_index_texture + +#endif /* GL_EXT_index_texture */ + +#ifdef GL_EXT_light_texture + +static GLboolean _glewInit_GL_EXT_light_texture (GLEW_CONTEXT_ARG_DEF_INIT) +{ + GLboolean r = GL_FALSE; + + r = ((glApplyTextureEXT = (PFNGLAPPLYTEXTUREEXTPROC)glewGetProcAddress((const GLubyte*)"glApplyTextureEXT")) == NULL) || r; + r = ((glTextureLightEXT = (PFNGLTEXTURELIGHTEXTPROC)glewGetProcAddress((const GLubyte*)"glTextureLightEXT")) == NULL) || r; + r = ((glTextureMaterialEXT = (PFNGLTEXTUREMATERIALEXTPROC)glewGetProcAddress((const GLubyte*)"glTextureMaterialEXT")) == NULL) || r; + + return r; +} + +#endif /* GL_EXT_light_texture */ + +#ifdef GL_EXT_misc_attribute + +#endif /* GL_EXT_misc_attribute */ + +#ifdef GL_EXT_multi_draw_arrays + +static GLboolean _glewInit_GL_EXT_multi_draw_arrays (GLEW_CONTEXT_ARG_DEF_INIT) +{ + GLboolean r = GL_FALSE; + + r = ((glMultiDrawArraysEXT = (PFNGLMULTIDRAWARRAYSEXTPROC)glewGetProcAddress((const GLubyte*)"glMultiDrawArraysEXT")) == NULL) || r; + r = ((glMultiDrawElementsEXT = (PFNGLMULTIDRAWELEMENTSEXTPROC)glewGetProcAddress((const GLubyte*)"glMultiDrawElementsEXT")) == NULL) || r; + + return r; +} + +#endif /* GL_EXT_multi_draw_arrays */ + +#ifdef GL_EXT_multisample + +static GLboolean _glewInit_GL_EXT_multisample (GLEW_CONTEXT_ARG_DEF_INIT) +{ + GLboolean r = GL_FALSE; + + r = ((glSampleMaskEXT = (PFNGLSAMPLEMASKEXTPROC)glewGetProcAddress((const GLubyte*)"glSampleMaskEXT")) == NULL) || r; + r = ((glSamplePatternEXT = (PFNGLSAMPLEPATTERNEXTPROC)glewGetProcAddress((const GLubyte*)"glSamplePatternEXT")) == NULL) || r; + + return r; +} + +#endif /* GL_EXT_multisample */ + +#ifdef GL_EXT_packed_depth_stencil + +#endif /* GL_EXT_packed_depth_stencil */ + +#ifdef GL_EXT_packed_float + +#endif /* GL_EXT_packed_float */ + +#ifdef GL_EXT_packed_pixels + +#endif /* GL_EXT_packed_pixels */ + +#ifdef GL_EXT_paletted_texture + +static GLboolean _glewInit_GL_EXT_paletted_texture (GLEW_CONTEXT_ARG_DEF_INIT) +{ + GLboolean r = GL_FALSE; + + r = ((glColorTableEXT = (PFNGLCOLORTABLEEXTPROC)glewGetProcAddress((const GLubyte*)"glColorTableEXT")) == NULL) || r; + r = ((glGetColorTableEXT = (PFNGLGETCOLORTABLEEXTPROC)glewGetProcAddress((const GLubyte*)"glGetColorTableEXT")) == NULL) || r; + r = ((glGetColorTableParameterfvEXT = (PFNGLGETCOLORTABLEPARAMETERFVEXTPROC)glewGetProcAddress((const GLubyte*)"glGetColorTableParameterfvEXT")) == NULL) || r; + r = ((glGetColorTableParameterivEXT = (PFNGLGETCOLORTABLEPARAMETERIVEXTPROC)glewGetProcAddress((const GLubyte*)"glGetColorTableParameterivEXT")) == NULL) || r; + + return r; +} + +#endif /* GL_EXT_paletted_texture */ + +#ifdef GL_EXT_pixel_buffer_object + +#endif /* GL_EXT_pixel_buffer_object */ + +#ifdef GL_EXT_pixel_transform + +static GLboolean _glewInit_GL_EXT_pixel_transform (GLEW_CONTEXT_ARG_DEF_INIT) +{ + GLboolean r = GL_FALSE; + + r = ((glGetPixelTransformParameterfvEXT = (PFNGLGETPIXELTRANSFORMPARAMETERFVEXTPROC)glewGetProcAddress((const GLubyte*)"glGetPixelTransformParameterfvEXT")) == NULL) || r; + r = ((glGetPixelTransformParameterivEXT = (PFNGLGETPIXELTRANSFORMPARAMETERIVEXTPROC)glewGetProcAddress((const GLubyte*)"glGetPixelTransformParameterivEXT")) == NULL) || r; + r = ((glPixelTransformParameterfEXT = (PFNGLPIXELTRANSFORMPARAMETERFEXTPROC)glewGetProcAddress((const GLubyte*)"glPixelTransformParameterfEXT")) == NULL) || r; + r = ((glPixelTransformParameterfvEXT = (PFNGLPIXELTRANSFORMPARAMETERFVEXTPROC)glewGetProcAddress((const GLubyte*)"glPixelTransformParameterfvEXT")) == NULL) || r; + r = ((glPixelTransformParameteriEXT = (PFNGLPIXELTRANSFORMPARAMETERIEXTPROC)glewGetProcAddress((const GLubyte*)"glPixelTransformParameteriEXT")) == NULL) || r; + r = ((glPixelTransformParameterivEXT = (PFNGLPIXELTRANSFORMPARAMETERIVEXTPROC)glewGetProcAddress((const GLubyte*)"glPixelTransformParameterivEXT")) == NULL) || r; + + return r; +} + +#endif /* GL_EXT_pixel_transform */ + +#ifdef GL_EXT_pixel_transform_color_table + +#endif /* GL_EXT_pixel_transform_color_table */ + +#ifdef GL_EXT_point_parameters + +static GLboolean _glewInit_GL_EXT_point_parameters (GLEW_CONTEXT_ARG_DEF_INIT) +{ + GLboolean r = GL_FALSE; + + r = ((glPointParameterfEXT = (PFNGLPOINTPARAMETERFEXTPROC)glewGetProcAddress((const GLubyte*)"glPointParameterfEXT")) == NULL) || r; + r = ((glPointParameterfvEXT = (PFNGLPOINTPARAMETERFVEXTPROC)glewGetProcAddress((const GLubyte*)"glPointParameterfvEXT")) == NULL) || r; + + return r; +} + +#endif /* GL_EXT_point_parameters */ + +#ifdef GL_EXT_polygon_offset + +static GLboolean _glewInit_GL_EXT_polygon_offset (GLEW_CONTEXT_ARG_DEF_INIT) +{ + GLboolean r = GL_FALSE; + + r = ((glPolygonOffsetEXT = (PFNGLPOLYGONOFFSETEXTPROC)glewGetProcAddress((const GLubyte*)"glPolygonOffsetEXT")) == NULL) || r; + + return r; +} + +#endif /* GL_EXT_polygon_offset */ + +#ifdef GL_EXT_rescale_normal + +#endif /* GL_EXT_rescale_normal */ + +#ifdef GL_EXT_scene_marker + +static GLboolean _glewInit_GL_EXT_scene_marker (GLEW_CONTEXT_ARG_DEF_INIT) +{ + GLboolean r = GL_FALSE; + + r = ((glBeginSceneEXT = (PFNGLBEGINSCENEEXTPROC)glewGetProcAddress((const GLubyte*)"glBeginSceneEXT")) == NULL) || r; + r = ((glEndSceneEXT = (PFNGLENDSCENEEXTPROC)glewGetProcAddress((const GLubyte*)"glEndSceneEXT")) == NULL) || r; + + return r; +} + +#endif /* GL_EXT_scene_marker */ + +#ifdef GL_EXT_secondary_color + +static GLboolean _glewInit_GL_EXT_secondary_color (GLEW_CONTEXT_ARG_DEF_INIT) +{ + GLboolean r = GL_FALSE; + + r = ((glSecondaryColor3bEXT = (PFNGLSECONDARYCOLOR3BEXTPROC)glewGetProcAddress((const GLubyte*)"glSecondaryColor3bEXT")) == NULL) || r; + r = ((glSecondaryColor3bvEXT = (PFNGLSECONDARYCOLOR3BVEXTPROC)glewGetProcAddress((const GLubyte*)"glSecondaryColor3bvEXT")) == NULL) || r; + r = ((glSecondaryColor3dEXT = (PFNGLSECONDARYCOLOR3DEXTPROC)glewGetProcAddress((const GLubyte*)"glSecondaryColor3dEXT")) == NULL) || r; + r = ((glSecondaryColor3dvEXT = (PFNGLSECONDARYCOLOR3DVEXTPROC)glewGetProcAddress((const GLubyte*)"glSecondaryColor3dvEXT")) == NULL) || r; + r = ((glSecondaryColor3fEXT = (PFNGLSECONDARYCOLOR3FEXTPROC)glewGetProcAddress((const GLubyte*)"glSecondaryColor3fEXT")) == NULL) || r; + r = ((glSecondaryColor3fvEXT = (PFNGLSECONDARYCOLOR3FVEXTPROC)glewGetProcAddress((const GLubyte*)"glSecondaryColor3fvEXT")) == NULL) || r; + r = ((glSecondaryColor3iEXT = (PFNGLSECONDARYCOLOR3IEXTPROC)glewGetProcAddress((const GLubyte*)"glSecondaryColor3iEXT")) == NULL) || r; + r = ((glSecondaryColor3ivEXT = (PFNGLSECONDARYCOLOR3IVEXTPROC)glewGetProcAddress((const GLubyte*)"glSecondaryColor3ivEXT")) == NULL) || r; + r = ((glSecondaryColor3sEXT = (PFNGLSECONDARYCOLOR3SEXTPROC)glewGetProcAddress((const GLubyte*)"glSecondaryColor3sEXT")) == NULL) || r; + r = ((glSecondaryColor3svEXT = (PFNGLSECONDARYCOLOR3SVEXTPROC)glewGetProcAddress((const GLubyte*)"glSecondaryColor3svEXT")) == NULL) || r; + r = ((glSecondaryColor3ubEXT = (PFNGLSECONDARYCOLOR3UBEXTPROC)glewGetProcAddress((const GLubyte*)"glSecondaryColor3ubEXT")) == NULL) || r; + r = ((glSecondaryColor3ubvEXT = (PFNGLSECONDARYCOLOR3UBVEXTPROC)glewGetProcAddress((const GLubyte*)"glSecondaryColor3ubvEXT")) == NULL) || r; + r = ((glSecondaryColor3uiEXT = (PFNGLSECONDARYCOLOR3UIEXTPROC)glewGetProcAddress((const GLubyte*)"glSecondaryColor3uiEXT")) == NULL) || r; + r = ((glSecondaryColor3uivEXT = (PFNGLSECONDARYCOLOR3UIVEXTPROC)glewGetProcAddress((const GLubyte*)"glSecondaryColor3uivEXT")) == NULL) || r; + r = ((glSecondaryColor3usEXT = (PFNGLSECONDARYCOLOR3USEXTPROC)glewGetProcAddress((const GLubyte*)"glSecondaryColor3usEXT")) == NULL) || r; + r = ((glSecondaryColor3usvEXT = (PFNGLSECONDARYCOLOR3USVEXTPROC)glewGetProcAddress((const GLubyte*)"glSecondaryColor3usvEXT")) == NULL) || r; + r = ((glSecondaryColorPointerEXT = (PFNGLSECONDARYCOLORPOINTEREXTPROC)glewGetProcAddress((const GLubyte*)"glSecondaryColorPointerEXT")) == NULL) || r; + + return r; +} + +#endif /* GL_EXT_secondary_color */ + +#ifdef GL_EXT_separate_specular_color + +#endif /* GL_EXT_separate_specular_color */ + +#ifdef GL_EXT_shadow_funcs + +#endif /* GL_EXT_shadow_funcs */ + +#ifdef GL_EXT_shared_texture_palette + +#endif /* GL_EXT_shared_texture_palette */ + +#ifdef GL_EXT_stencil_clear_tag + +#endif /* GL_EXT_stencil_clear_tag */ + +#ifdef GL_EXT_stencil_two_side + +static GLboolean _glewInit_GL_EXT_stencil_two_side (GLEW_CONTEXT_ARG_DEF_INIT) +{ + GLboolean r = GL_FALSE; + + r = ((glActiveStencilFaceEXT = (PFNGLACTIVESTENCILFACEEXTPROC)glewGetProcAddress((const GLubyte*)"glActiveStencilFaceEXT")) == NULL) || r; + + return r; +} + +#endif /* GL_EXT_stencil_two_side */ + +#ifdef GL_EXT_stencil_wrap + +#endif /* GL_EXT_stencil_wrap */ + +#ifdef GL_EXT_subtexture + +static GLboolean _glewInit_GL_EXT_subtexture (GLEW_CONTEXT_ARG_DEF_INIT) +{ + GLboolean r = GL_FALSE; + + r = ((glTexSubImage1DEXT = (PFNGLTEXSUBIMAGE1DEXTPROC)glewGetProcAddress((const GLubyte*)"glTexSubImage1DEXT")) == NULL) || r; + r = ((glTexSubImage2DEXT = (PFNGLTEXSUBIMAGE2DEXTPROC)glewGetProcAddress((const GLubyte*)"glTexSubImage2DEXT")) == NULL) || r; + r = ((glTexSubImage3DEXT = (PFNGLTEXSUBIMAGE3DEXTPROC)glewGetProcAddress((const GLubyte*)"glTexSubImage3DEXT")) == NULL) || r; + + return r; +} + +#endif /* GL_EXT_subtexture */ + +#ifdef GL_EXT_texture + +#endif /* GL_EXT_texture */ + +#ifdef GL_EXT_texture3D + +static GLboolean _glewInit_GL_EXT_texture3D (GLEW_CONTEXT_ARG_DEF_INIT) +{ + GLboolean r = GL_FALSE; + + r = ((glTexImage3DEXT = (PFNGLTEXIMAGE3DEXTPROC)glewGetProcAddress((const GLubyte*)"glTexImage3DEXT")) == NULL) || r; + + return r; +} + +#endif /* GL_EXT_texture3D */ + +#ifdef GL_EXT_texture_array + +#endif /* GL_EXT_texture_array */ + +#ifdef GL_EXT_texture_buffer_object + +static GLboolean _glewInit_GL_EXT_texture_buffer_object (GLEW_CONTEXT_ARG_DEF_INIT) +{ + GLboolean r = GL_FALSE; + + r = ((glTexBufferEXT = (PFNGLTEXBUFFEREXTPROC)glewGetProcAddress((const GLubyte*)"glTexBufferEXT")) == NULL) || r; + + return r; +} + +#endif /* GL_EXT_texture_buffer_object */ + +#ifdef GL_EXT_texture_compression_dxt1 + +#endif /* GL_EXT_texture_compression_dxt1 */ + +#ifdef GL_EXT_texture_compression_latc + +#endif /* GL_EXT_texture_compression_latc */ + +#ifdef GL_EXT_texture_compression_rgtc + +#endif /* GL_EXT_texture_compression_rgtc */ + +#ifdef GL_EXT_texture_compression_s3tc + +#endif /* GL_EXT_texture_compression_s3tc */ + +#ifdef GL_EXT_texture_cube_map + +#endif /* GL_EXT_texture_cube_map */ + +#ifdef GL_EXT_texture_edge_clamp + +#endif /* GL_EXT_texture_edge_clamp */ + +#ifdef GL_EXT_texture_env + +#endif /* GL_EXT_texture_env */ + +#ifdef GL_EXT_texture_env_add + +#endif /* GL_EXT_texture_env_add */ + +#ifdef GL_EXT_texture_env_combine + +#endif /* GL_EXT_texture_env_combine */ + +#ifdef GL_EXT_texture_env_dot3 + +#endif /* GL_EXT_texture_env_dot3 */ + +#ifdef GL_EXT_texture_filter_anisotropic + +#endif /* GL_EXT_texture_filter_anisotropic */ + +#ifdef GL_EXT_texture_integer + +static GLboolean _glewInit_GL_EXT_texture_integer (GLEW_CONTEXT_ARG_DEF_INIT) +{ + GLboolean r = GL_FALSE; + + r = ((glClearColorIiEXT = (PFNGLCLEARCOLORIIEXTPROC)glewGetProcAddress((const GLubyte*)"glClearColorIiEXT")) == NULL) || r; + r = ((glClearColorIuiEXT = (PFNGLCLEARCOLORIUIEXTPROC)glewGetProcAddress((const GLubyte*)"glClearColorIuiEXT")) == NULL) || r; + r = ((glGetTexParameterIivEXT = (PFNGLGETTEXPARAMETERIIVEXTPROC)glewGetProcAddress((const GLubyte*)"glGetTexParameterIivEXT")) == NULL) || r; + r = ((glGetTexParameterIuivEXT = (PFNGLGETTEXPARAMETERIUIVEXTPROC)glewGetProcAddress((const GLubyte*)"glGetTexParameterIuivEXT")) == NULL) || r; + r = ((glTexParameterIivEXT = (PFNGLTEXPARAMETERIIVEXTPROC)glewGetProcAddress((const GLubyte*)"glTexParameterIivEXT")) == NULL) || r; + r = ((glTexParameterIuivEXT = (PFNGLTEXPARAMETERIUIVEXTPROC)glewGetProcAddress((const GLubyte*)"glTexParameterIuivEXT")) == NULL) || r; + + return r; +} + +#endif /* GL_EXT_texture_integer */ + +#ifdef GL_EXT_texture_lod_bias + +#endif /* GL_EXT_texture_lod_bias */ + +#ifdef GL_EXT_texture_mirror_clamp + +#endif /* GL_EXT_texture_mirror_clamp */ + +#ifdef GL_EXT_texture_object + +static GLboolean _glewInit_GL_EXT_texture_object (GLEW_CONTEXT_ARG_DEF_INIT) +{ + GLboolean r = GL_FALSE; + + r = ((glAreTexturesResidentEXT = (PFNGLARETEXTURESRESIDENTEXTPROC)glewGetProcAddress((const GLubyte*)"glAreTexturesResidentEXT")) == NULL) || r; + r = ((glBindTextureEXT = (PFNGLBINDTEXTUREEXTPROC)glewGetProcAddress((const GLubyte*)"glBindTextureEXT")) == NULL) || r; + r = ((glDeleteTexturesEXT = (PFNGLDELETETEXTURESEXTPROC)glewGetProcAddress((const GLubyte*)"glDeleteTexturesEXT")) == NULL) || r; + r = ((glGenTexturesEXT = (PFNGLGENTEXTURESEXTPROC)glewGetProcAddress((const GLubyte*)"glGenTexturesEXT")) == NULL) || r; + r = ((glIsTextureEXT = (PFNGLISTEXTUREEXTPROC)glewGetProcAddress((const GLubyte*)"glIsTextureEXT")) == NULL) || r; + r = ((glPrioritizeTexturesEXT = (PFNGLPRIORITIZETEXTURESEXTPROC)glewGetProcAddress((const GLubyte*)"glPrioritizeTexturesEXT")) == NULL) || r; + + return r; +} + +#endif /* GL_EXT_texture_object */ + +#ifdef GL_EXT_texture_perturb_normal + +static GLboolean _glewInit_GL_EXT_texture_perturb_normal (GLEW_CONTEXT_ARG_DEF_INIT) +{ + GLboolean r = GL_FALSE; + + r = ((glTextureNormalEXT = (PFNGLTEXTURENORMALEXTPROC)glewGetProcAddress((const GLubyte*)"glTextureNormalEXT")) == NULL) || r; + + return r; +} + +#endif /* GL_EXT_texture_perturb_normal */ + +#ifdef GL_EXT_texture_rectangle + +#endif /* GL_EXT_texture_rectangle */ + +#ifdef GL_EXT_texture_sRGB + +#endif /* GL_EXT_texture_sRGB */ + +#ifdef GL_EXT_texture_shared_exponent + +#endif /* GL_EXT_texture_shared_exponent */ + +#ifdef GL_EXT_texture_swizzle + +#endif /* GL_EXT_texture_swizzle */ + +#ifdef GL_EXT_timer_query + +static GLboolean _glewInit_GL_EXT_timer_query (GLEW_CONTEXT_ARG_DEF_INIT) +{ + GLboolean r = GL_FALSE; + +// r = ((glGetQueryObjecti64vEXT = (PFNGLGETQUERYOBJECTI64VEXTPROC)glewGetProcAddress((const GLubyte*)"glGetQueryObjecti64vEXT")) == NULL) || r; +// r = ((glGetQueryObjectui64vEXT = (PFNGLGETQUERYOBJECTUI64VEXTPROC)glewGetProcAddress((const GLubyte*)"glGetQueryObjectui64vEXT")) == NULL) || r; + + return r; +} + +#endif /* GL_EXT_timer_query */ + +#ifdef GL_EXT_transform_feedback + +static GLboolean _glewInit_GL_EXT_transform_feedback (GLEW_CONTEXT_ARG_DEF_INIT) +{ + GLboolean r = GL_FALSE; + + r = ((glBeginTransformFeedbackEXT = (PFNGLBEGINTRANSFORMFEEDBACKEXTPROC)glewGetProcAddress((const GLubyte*)"glBeginTransformFeedbackEXT")) == NULL) || r; + r = ((glBindBufferBaseEXT = (PFNGLBINDBUFFERBASEEXTPROC)glewGetProcAddress((const GLubyte*)"glBindBufferBaseEXT")) == NULL) || r; + r = ((glBindBufferOffsetEXT = (PFNGLBINDBUFFEROFFSETEXTPROC)glewGetProcAddress((const GLubyte*)"glBindBufferOffsetEXT")) == NULL) || r; + r = ((glBindBufferRangeEXT = (PFNGLBINDBUFFERRANGEEXTPROC)glewGetProcAddress((const GLubyte*)"glBindBufferRangeEXT")) == NULL) || r; + r = ((glEndTransformFeedbackEXT = (PFNGLENDTRANSFORMFEEDBACKEXTPROC)glewGetProcAddress((const GLubyte*)"glEndTransformFeedbackEXT")) == NULL) || r; + r = ((glGetTransformFeedbackVaryingEXT = (PFNGLGETTRANSFORMFEEDBACKVARYINGEXTPROC)glewGetProcAddress((const GLubyte*)"glGetTransformFeedbackVaryingEXT")) == NULL) || r; + r = ((glTransformFeedbackVaryingsEXT = (PFNGLTRANSFORMFEEDBACKVARYINGSEXTPROC)glewGetProcAddress((const GLubyte*)"glTransformFeedbackVaryingsEXT")) == NULL) || r; + + return r; +} + +#endif /* GL_EXT_transform_feedback */ + +#ifdef GL_EXT_vertex_array + +static GLboolean _glewInit_GL_EXT_vertex_array (GLEW_CONTEXT_ARG_DEF_INIT) +{ + GLboolean r = GL_FALSE; + + r = ((glArrayElementEXT = (PFNGLARRAYELEMENTEXTPROC)glewGetProcAddress((const GLubyte*)"glArrayElementEXT")) == NULL) || r; + r = ((glColorPointerEXT = (PFNGLCOLORPOINTEREXTPROC)glewGetProcAddress((const GLubyte*)"glColorPointerEXT")) == NULL) || r; + r = ((glDrawArraysEXT = (PFNGLDRAWARRAYSEXTPROC)glewGetProcAddress((const GLubyte*)"glDrawArraysEXT")) == NULL) || r; + r = ((glEdgeFlagPointerEXT = (PFNGLEDGEFLAGPOINTEREXTPROC)glewGetProcAddress((const GLubyte*)"glEdgeFlagPointerEXT")) == NULL) || r; + r = ((glGetPointervEXT = (PFNGLGETPOINTERVEXTPROC)glewGetProcAddress((const GLubyte*)"glGetPointervEXT")) == NULL) || r; + r = ((glIndexPointerEXT = (PFNGLINDEXPOINTEREXTPROC)glewGetProcAddress((const GLubyte*)"glIndexPointerEXT")) == NULL) || r; + r = ((glNormalPointerEXT = (PFNGLNORMALPOINTEREXTPROC)glewGetProcAddress((const GLubyte*)"glNormalPointerEXT")) == NULL) || r; + r = ((glTexCoordPointerEXT = (PFNGLTEXCOORDPOINTEREXTPROC)glewGetProcAddress((const GLubyte*)"glTexCoordPointerEXT")) == NULL) || r; + r = ((glVertexPointerEXT = (PFNGLVERTEXPOINTEREXTPROC)glewGetProcAddress((const GLubyte*)"glVertexPointerEXT")) == NULL) || r; + + return r; +} + +#endif /* GL_EXT_vertex_array */ + +#ifdef GL_EXT_vertex_array_bgra + +#endif /* GL_EXT_vertex_array_bgra */ + +#ifdef GL_EXT_vertex_shader + +static GLboolean _glewInit_GL_EXT_vertex_shader (GLEW_CONTEXT_ARG_DEF_INIT) +{ + GLboolean r = GL_FALSE; + + r = ((glBeginVertexShaderEXT = (PFNGLBEGINVERTEXSHADEREXTPROC)glewGetProcAddress((const GLubyte*)"glBeginVertexShaderEXT")) == NULL) || r; + r = ((glBindLightParameterEXT = (PFNGLBINDLIGHTPARAMETEREXTPROC)glewGetProcAddress((const GLubyte*)"glBindLightParameterEXT")) == NULL) || r; + r = ((glBindMaterialParameterEXT = (PFNGLBINDMATERIALPARAMETEREXTPROC)glewGetProcAddress((const GLubyte*)"glBindMaterialParameterEXT")) == NULL) || r; + r = ((glBindParameterEXT = (PFNGLBINDPARAMETEREXTPROC)glewGetProcAddress((const GLubyte*)"glBindParameterEXT")) == NULL) || r; + r = ((glBindTexGenParameterEXT = (PFNGLBINDTEXGENPARAMETEREXTPROC)glewGetProcAddress((const GLubyte*)"glBindTexGenParameterEXT")) == NULL) || r; + r = ((glBindTextureUnitParameterEXT = (PFNGLBINDTEXTUREUNITPARAMETEREXTPROC)glewGetProcAddress((const GLubyte*)"glBindTextureUnitParameterEXT")) == NULL) || r; + r = ((glBindVertexShaderEXT = (PFNGLBINDVERTEXSHADEREXTPROC)glewGetProcAddress((const GLubyte*)"glBindVertexShaderEXT")) == NULL) || r; + r = ((glDeleteVertexShaderEXT = (PFNGLDELETEVERTEXSHADEREXTPROC)glewGetProcAddress((const GLubyte*)"glDeleteVertexShaderEXT")) == NULL) || r; + r = ((glDisableVariantClientStateEXT = (PFNGLDISABLEVARIANTCLIENTSTATEEXTPROC)glewGetProcAddress((const GLubyte*)"glDisableVariantClientStateEXT")) == NULL) || r; + r = ((glEnableVariantClientStateEXT = (PFNGLENABLEVARIANTCLIENTSTATEEXTPROC)glewGetProcAddress((const GLubyte*)"glEnableVariantClientStateEXT")) == NULL) || r; + r = ((glEndVertexShaderEXT = (PFNGLENDVERTEXSHADEREXTPROC)glewGetProcAddress((const GLubyte*)"glEndVertexShaderEXT")) == NULL) || r; + r = ((glExtractComponentEXT = (PFNGLEXTRACTCOMPONENTEXTPROC)glewGetProcAddress((const GLubyte*)"glExtractComponentEXT")) == NULL) || r; + r = ((glGenSymbolsEXT = (PFNGLGENSYMBOLSEXTPROC)glewGetProcAddress((const GLubyte*)"glGenSymbolsEXT")) == NULL) || r; + r = ((glGenVertexShadersEXT = (PFNGLGENVERTEXSHADERSEXTPROC)glewGetProcAddress((const GLubyte*)"glGenVertexShadersEXT")) == NULL) || r; + r = ((glGetInvariantBooleanvEXT = (PFNGLGETINVARIANTBOOLEANVEXTPROC)glewGetProcAddress((const GLubyte*)"glGetInvariantBooleanvEXT")) == NULL) || r; + r = ((glGetInvariantFloatvEXT = (PFNGLGETINVARIANTFLOATVEXTPROC)glewGetProcAddress((const GLubyte*)"glGetInvariantFloatvEXT")) == NULL) || r; + r = ((glGetInvariantIntegervEXT = (PFNGLGETINVARIANTINTEGERVEXTPROC)glewGetProcAddress((const GLubyte*)"glGetInvariantIntegervEXT")) == NULL) || r; + r = ((glGetLocalConstantBooleanvEXT = (PFNGLGETLOCALCONSTANTBOOLEANVEXTPROC)glewGetProcAddress((const GLubyte*)"glGetLocalConstantBooleanvEXT")) == NULL) || r; + r = ((glGetLocalConstantFloatvEXT = (PFNGLGETLOCALCONSTANTFLOATVEXTPROC)glewGetProcAddress((const GLubyte*)"glGetLocalConstantFloatvEXT")) == NULL) || r; + r = ((glGetLocalConstantIntegervEXT = (PFNGLGETLOCALCONSTANTINTEGERVEXTPROC)glewGetProcAddress((const GLubyte*)"glGetLocalConstantIntegervEXT")) == NULL) || r; + r = ((glGetVariantBooleanvEXT = (PFNGLGETVARIANTBOOLEANVEXTPROC)glewGetProcAddress((const GLubyte*)"glGetVariantBooleanvEXT")) == NULL) || r; + r = ((glGetVariantFloatvEXT = (PFNGLGETVARIANTFLOATVEXTPROC)glewGetProcAddress((const GLubyte*)"glGetVariantFloatvEXT")) == NULL) || r; + r = ((glGetVariantIntegervEXT = (PFNGLGETVARIANTINTEGERVEXTPROC)glewGetProcAddress((const GLubyte*)"glGetVariantIntegervEXT")) == NULL) || r; + r = ((glGetVariantPointervEXT = (PFNGLGETVARIANTPOINTERVEXTPROC)glewGetProcAddress((const GLubyte*)"glGetVariantPointervEXT")) == NULL) || r; + r = ((glInsertComponentEXT = (PFNGLINSERTCOMPONENTEXTPROC)glewGetProcAddress((const GLubyte*)"glInsertComponentEXT")) == NULL) || r; + r = ((glIsVariantEnabledEXT = (PFNGLISVARIANTENABLEDEXTPROC)glewGetProcAddress((const GLubyte*)"glIsVariantEnabledEXT")) == NULL) || r; + r = ((glSetInvariantEXT = (PFNGLSETINVARIANTEXTPROC)glewGetProcAddress((const GLubyte*)"glSetInvariantEXT")) == NULL) || r; + r = ((glSetLocalConstantEXT = (PFNGLSETLOCALCONSTANTEXTPROC)glewGetProcAddress((const GLubyte*)"glSetLocalConstantEXT")) == NULL) || r; + r = ((glShaderOp1EXT = (PFNGLSHADEROP1EXTPROC)glewGetProcAddress((const GLubyte*)"glShaderOp1EXT")) == NULL) || r; + r = ((glShaderOp2EXT = (PFNGLSHADEROP2EXTPROC)glewGetProcAddress((const GLubyte*)"glShaderOp2EXT")) == NULL) || r; + r = ((glShaderOp3EXT = (PFNGLSHADEROP3EXTPROC)glewGetProcAddress((const GLubyte*)"glShaderOp3EXT")) == NULL) || r; + r = ((glSwizzleEXT = (PFNGLSWIZZLEEXTPROC)glewGetProcAddress((const GLubyte*)"glSwizzleEXT")) == NULL) || r; + r = ((glVariantPointerEXT = (PFNGLVARIANTPOINTEREXTPROC)glewGetProcAddress((const GLubyte*)"glVariantPointerEXT")) == NULL) || r; + r = ((glVariantbvEXT = (PFNGLVARIANTBVEXTPROC)glewGetProcAddress((const GLubyte*)"glVariantbvEXT")) == NULL) || r; + r = ((glVariantdvEXT = (PFNGLVARIANTDVEXTPROC)glewGetProcAddress((const GLubyte*)"glVariantdvEXT")) == NULL) || r; + r = ((glVariantfvEXT = (PFNGLVARIANTFVEXTPROC)glewGetProcAddress((const GLubyte*)"glVariantfvEXT")) == NULL) || r; + r = ((glVariantivEXT = (PFNGLVARIANTIVEXTPROC)glewGetProcAddress((const GLubyte*)"glVariantivEXT")) == NULL) || r; + r = ((glVariantsvEXT = (PFNGLVARIANTSVEXTPROC)glewGetProcAddress((const GLubyte*)"glVariantsvEXT")) == NULL) || r; + r = ((glVariantubvEXT = (PFNGLVARIANTUBVEXTPROC)glewGetProcAddress((const GLubyte*)"glVariantubvEXT")) == NULL) || r; + r = ((glVariantuivEXT = (PFNGLVARIANTUIVEXTPROC)glewGetProcAddress((const GLubyte*)"glVariantuivEXT")) == NULL) || r; + r = ((glVariantusvEXT = (PFNGLVARIANTUSVEXTPROC)glewGetProcAddress((const GLubyte*)"glVariantusvEXT")) == NULL) || r; + r = ((glWriteMaskEXT = (PFNGLWRITEMASKEXTPROC)glewGetProcAddress((const GLubyte*)"glWriteMaskEXT")) == NULL) || r; + + return r; +} + +#endif /* GL_EXT_vertex_shader */ + +#ifdef GL_EXT_vertex_weighting + +static GLboolean _glewInit_GL_EXT_vertex_weighting (GLEW_CONTEXT_ARG_DEF_INIT) +{ + GLboolean r = GL_FALSE; + + r = ((glVertexWeightPointerEXT = (PFNGLVERTEXWEIGHTPOINTEREXTPROC)glewGetProcAddress((const GLubyte*)"glVertexWeightPointerEXT")) == NULL) || r; + r = ((glVertexWeightfEXT = (PFNGLVERTEXWEIGHTFEXTPROC)glewGetProcAddress((const GLubyte*)"glVertexWeightfEXT")) == NULL) || r; + r = ((glVertexWeightfvEXT = (PFNGLVERTEXWEIGHTFVEXTPROC)glewGetProcAddress((const GLubyte*)"glVertexWeightfvEXT")) == NULL) || r; + + return r; +} + +#endif /* GL_EXT_vertex_weighting */ + +#ifdef GL_GREMEDY_frame_terminator + +static GLboolean _glewInit_GL_GREMEDY_frame_terminator (GLEW_CONTEXT_ARG_DEF_INIT) +{ + GLboolean r = GL_FALSE; + + r = ((glFrameTerminatorGREMEDY = (PFNGLFRAMETERMINATORGREMEDYPROC)glewGetProcAddress((const GLubyte*)"glFrameTerminatorGREMEDY")) == NULL) || r; + + return r; +} + +#endif /* GL_GREMEDY_frame_terminator */ + +#ifdef GL_GREMEDY_string_marker + +static GLboolean _glewInit_GL_GREMEDY_string_marker (GLEW_CONTEXT_ARG_DEF_INIT) +{ + GLboolean r = GL_FALSE; + + r = ((glStringMarkerGREMEDY = (PFNGLSTRINGMARKERGREMEDYPROC)glewGetProcAddress((const GLubyte*)"glStringMarkerGREMEDY")) == NULL) || r; + + return r; +} + +#endif /* GL_GREMEDY_string_marker */ + +#ifdef GL_HP_convolution_border_modes + +#endif /* GL_HP_convolution_border_modes */ + +#ifdef GL_HP_image_transform + +static GLboolean _glewInit_GL_HP_image_transform (GLEW_CONTEXT_ARG_DEF_INIT) +{ + GLboolean r = GL_FALSE; + + r = ((glGetImageTransformParameterfvHP = (PFNGLGETIMAGETRANSFORMPARAMETERFVHPPROC)glewGetProcAddress((const GLubyte*)"glGetImageTransformParameterfvHP")) == NULL) || r; + r = ((glGetImageTransformParameterivHP = (PFNGLGETIMAGETRANSFORMPARAMETERIVHPPROC)glewGetProcAddress((const GLubyte*)"glGetImageTransformParameterivHP")) == NULL) || r; + r = ((glImageTransformParameterfHP = (PFNGLIMAGETRANSFORMPARAMETERFHPPROC)glewGetProcAddress((const GLubyte*)"glImageTransformParameterfHP")) == NULL) || r; + r = ((glImageTransformParameterfvHP = (PFNGLIMAGETRANSFORMPARAMETERFVHPPROC)glewGetProcAddress((const GLubyte*)"glImageTransformParameterfvHP")) == NULL) || r; + r = ((glImageTransformParameteriHP = (PFNGLIMAGETRANSFORMPARAMETERIHPPROC)glewGetProcAddress((const GLubyte*)"glImageTransformParameteriHP")) == NULL) || r; + r = ((glImageTransformParameterivHP = (PFNGLIMAGETRANSFORMPARAMETERIVHPPROC)glewGetProcAddress((const GLubyte*)"glImageTransformParameterivHP")) == NULL) || r; + + return r; +} + +#endif /* GL_HP_image_transform */ + +#ifdef GL_HP_occlusion_test + +#endif /* GL_HP_occlusion_test */ + +#ifdef GL_HP_texture_lighting + +#endif /* GL_HP_texture_lighting */ + +#ifdef GL_IBM_cull_vertex + +#endif /* GL_IBM_cull_vertex */ + +#ifdef GL_IBM_multimode_draw_arrays + +static GLboolean _glewInit_GL_IBM_multimode_draw_arrays (GLEW_CONTEXT_ARG_DEF_INIT) +{ + GLboolean r = GL_FALSE; + + r = ((glMultiModeDrawArraysIBM = (PFNGLMULTIMODEDRAWARRAYSIBMPROC)glewGetProcAddress((const GLubyte*)"glMultiModeDrawArraysIBM")) == NULL) || r; + r = ((glMultiModeDrawElementsIBM = (PFNGLMULTIMODEDRAWELEMENTSIBMPROC)glewGetProcAddress((const GLubyte*)"glMultiModeDrawElementsIBM")) == NULL) || r; + + return r; +} + +#endif /* GL_IBM_multimode_draw_arrays */ + +#ifdef GL_IBM_rasterpos_clip + +#endif /* GL_IBM_rasterpos_clip */ + +#ifdef GL_IBM_static_data + +#endif /* GL_IBM_static_data */ + +#ifdef GL_IBM_texture_mirrored_repeat + +#endif /* GL_IBM_texture_mirrored_repeat */ + +#ifdef GL_IBM_vertex_array_lists + +static GLboolean _glewInit_GL_IBM_vertex_array_lists (GLEW_CONTEXT_ARG_DEF_INIT) +{ + GLboolean r = GL_FALSE; + + r = ((glColorPointerListIBM = (PFNGLCOLORPOINTERLISTIBMPROC)glewGetProcAddress((const GLubyte*)"glColorPointerListIBM")) == NULL) || r; + r = ((glEdgeFlagPointerListIBM = (PFNGLEDGEFLAGPOINTERLISTIBMPROC)glewGetProcAddress((const GLubyte*)"glEdgeFlagPointerListIBM")) == NULL) || r; + r = ((glFogCoordPointerListIBM = (PFNGLFOGCOORDPOINTERLISTIBMPROC)glewGetProcAddress((const GLubyte*)"glFogCoordPointerListIBM")) == NULL) || r; + r = ((glIndexPointerListIBM = (PFNGLINDEXPOINTERLISTIBMPROC)glewGetProcAddress((const GLubyte*)"glIndexPointerListIBM")) == NULL) || r; + r = ((glNormalPointerListIBM = (PFNGLNORMALPOINTERLISTIBMPROC)glewGetProcAddress((const GLubyte*)"glNormalPointerListIBM")) == NULL) || r; + r = ((glSecondaryColorPointerListIBM = (PFNGLSECONDARYCOLORPOINTERLISTIBMPROC)glewGetProcAddress((const GLubyte*)"glSecondaryColorPointerListIBM")) == NULL) || r; + r = ((glTexCoordPointerListIBM = (PFNGLTEXCOORDPOINTERLISTIBMPROC)glewGetProcAddress((const GLubyte*)"glTexCoordPointerListIBM")) == NULL) || r; + r = ((glVertexPointerListIBM = (PFNGLVERTEXPOINTERLISTIBMPROC)glewGetProcAddress((const GLubyte*)"glVertexPointerListIBM")) == NULL) || r; + + return r; +} + +#endif /* GL_IBM_vertex_array_lists */ + +#ifdef GL_INGR_color_clamp + +#endif /* GL_INGR_color_clamp */ + +#ifdef GL_INGR_interlace_read + +#endif /* GL_INGR_interlace_read */ + +#ifdef GL_INTEL_parallel_arrays + +static GLboolean _glewInit_GL_INTEL_parallel_arrays (GLEW_CONTEXT_ARG_DEF_INIT) +{ + GLboolean r = GL_FALSE; + + r = ((glColorPointervINTEL = (PFNGLCOLORPOINTERVINTELPROC)glewGetProcAddress((const GLubyte*)"glColorPointervINTEL")) == NULL) || r; + r = ((glNormalPointervINTEL = (PFNGLNORMALPOINTERVINTELPROC)glewGetProcAddress((const GLubyte*)"glNormalPointervINTEL")) == NULL) || r; + r = ((glTexCoordPointervINTEL = (PFNGLTEXCOORDPOINTERVINTELPROC)glewGetProcAddress((const GLubyte*)"glTexCoordPointervINTEL")) == NULL) || r; + r = ((glVertexPointervINTEL = (PFNGLVERTEXPOINTERVINTELPROC)glewGetProcAddress((const GLubyte*)"glVertexPointervINTEL")) == NULL) || r; + + return r; +} + +#endif /* GL_INTEL_parallel_arrays */ + +#ifdef GL_INTEL_texture_scissor + +static GLboolean _glewInit_GL_INTEL_texture_scissor (GLEW_CONTEXT_ARG_DEF_INIT) +{ + GLboolean r = GL_FALSE; + + r = ((glTexScissorFuncINTEL = (PFNGLTEXSCISSORFUNCINTELPROC)glewGetProcAddress((const GLubyte*)"glTexScissorFuncINTEL")) == NULL) || r; + r = ((glTexScissorINTEL = (PFNGLTEXSCISSORINTELPROC)glewGetProcAddress((const GLubyte*)"glTexScissorINTEL")) == NULL) || r; + + return r; +} + +#endif /* GL_INTEL_texture_scissor */ + +#ifdef GL_KTX_buffer_region + +static GLboolean _glewInit_GL_KTX_buffer_region (GLEW_CONTEXT_ARG_DEF_INIT) +{ + GLboolean r = GL_FALSE; + + r = ((glBufferRegionEnabledEXT = (PFNGLBUFFERREGIONENABLEDEXTPROC)glewGetProcAddress((const GLubyte*)"glBufferRegionEnabledEXT")) == NULL) || r; + r = ((glDeleteBufferRegionEXT = (PFNGLDELETEBUFFERREGIONEXTPROC)glewGetProcAddress((const GLubyte*)"glDeleteBufferRegionEXT")) == NULL) || r; + r = ((glDrawBufferRegionEXT = (PFNGLDRAWBUFFERREGIONEXTPROC)glewGetProcAddress((const GLubyte*)"glDrawBufferRegionEXT")) == NULL) || r; + r = ((glNewBufferRegionEXT = (PFNGLNEWBUFFERREGIONEXTPROC)glewGetProcAddress((const GLubyte*)"glNewBufferRegionEXT")) == NULL) || r; + r = ((glReadBufferRegionEXT = (PFNGLREADBUFFERREGIONEXTPROC)glewGetProcAddress((const GLubyte*)"glReadBufferRegionEXT")) == NULL) || r; + + return r; +} + +#endif /* GL_KTX_buffer_region */ + +#ifdef GL_MESAX_texture_stack + +#endif /* GL_MESAX_texture_stack */ + +#ifdef GL_MESA_pack_invert + +#endif /* GL_MESA_pack_invert */ + +#ifdef GL_MESA_resize_buffers + +static GLboolean _glewInit_GL_MESA_resize_buffers (GLEW_CONTEXT_ARG_DEF_INIT) +{ + GLboolean r = GL_FALSE; + + r = ((glResizeBuffersMESA = (PFNGLRESIZEBUFFERSMESAPROC)glewGetProcAddress((const GLubyte*)"glResizeBuffersMESA")) == NULL) || r; + + return r; +} + +#endif /* GL_MESA_resize_buffers */ + +#ifdef GL_MESA_window_pos + +static GLboolean _glewInit_GL_MESA_window_pos (GLEW_CONTEXT_ARG_DEF_INIT) +{ + GLboolean r = GL_FALSE; + + r = ((glWindowPos2dMESA = (PFNGLWINDOWPOS2DMESAPROC)glewGetProcAddress((const GLubyte*)"glWindowPos2dMESA")) == NULL) || r; + r = ((glWindowPos2dvMESA = (PFNGLWINDOWPOS2DVMESAPROC)glewGetProcAddress((const GLubyte*)"glWindowPos2dvMESA")) == NULL) || r; + r = ((glWindowPos2fMESA = (PFNGLWINDOWPOS2FMESAPROC)glewGetProcAddress((const GLubyte*)"glWindowPos2fMESA")) == NULL) || r; + r = ((glWindowPos2fvMESA = (PFNGLWINDOWPOS2FVMESAPROC)glewGetProcAddress((const GLubyte*)"glWindowPos2fvMESA")) == NULL) || r; + r = ((glWindowPos2iMESA = (PFNGLWINDOWPOS2IMESAPROC)glewGetProcAddress((const GLubyte*)"glWindowPos2iMESA")) == NULL) || r; + r = ((glWindowPos2ivMESA = (PFNGLWINDOWPOS2IVMESAPROC)glewGetProcAddress((const GLubyte*)"glWindowPos2ivMESA")) == NULL) || r; + r = ((glWindowPos2sMESA = (PFNGLWINDOWPOS2SMESAPROC)glewGetProcAddress((const GLubyte*)"glWindowPos2sMESA")) == NULL) || r; + r = ((glWindowPos2svMESA = (PFNGLWINDOWPOS2SVMESAPROC)glewGetProcAddress((const GLubyte*)"glWindowPos2svMESA")) == NULL) || r; + r = ((glWindowPos3dMESA = (PFNGLWINDOWPOS3DMESAPROC)glewGetProcAddress((const GLubyte*)"glWindowPos3dMESA")) == NULL) || r; + r = ((glWindowPos3dvMESA = (PFNGLWINDOWPOS3DVMESAPROC)glewGetProcAddress((const GLubyte*)"glWindowPos3dvMESA")) == NULL) || r; + r = ((glWindowPos3fMESA = (PFNGLWINDOWPOS3FMESAPROC)glewGetProcAddress((const GLubyte*)"glWindowPos3fMESA")) == NULL) || r; + r = ((glWindowPos3fvMESA = (PFNGLWINDOWPOS3FVMESAPROC)glewGetProcAddress((const GLubyte*)"glWindowPos3fvMESA")) == NULL) || r; + r = ((glWindowPos3iMESA = (PFNGLWINDOWPOS3IMESAPROC)glewGetProcAddress((const GLubyte*)"glWindowPos3iMESA")) == NULL) || r; + r = ((glWindowPos3ivMESA = (PFNGLWINDOWPOS3IVMESAPROC)glewGetProcAddress((const GLubyte*)"glWindowPos3ivMESA")) == NULL) || r; + r = ((glWindowPos3sMESA = (PFNGLWINDOWPOS3SMESAPROC)glewGetProcAddress((const GLubyte*)"glWindowPos3sMESA")) == NULL) || r; + r = ((glWindowPos3svMESA = (PFNGLWINDOWPOS3SVMESAPROC)glewGetProcAddress((const GLubyte*)"glWindowPos3svMESA")) == NULL) || r; + r = ((glWindowPos4dMESA = (PFNGLWINDOWPOS4DMESAPROC)glewGetProcAddress((const GLubyte*)"glWindowPos4dMESA")) == NULL) || r; + r = ((glWindowPos4dvMESA = (PFNGLWINDOWPOS4DVMESAPROC)glewGetProcAddress((const GLubyte*)"glWindowPos4dvMESA")) == NULL) || r; + r = ((glWindowPos4fMESA = (PFNGLWINDOWPOS4FMESAPROC)glewGetProcAddress((const GLubyte*)"glWindowPos4fMESA")) == NULL) || r; + r = ((glWindowPos4fvMESA = (PFNGLWINDOWPOS4FVMESAPROC)glewGetProcAddress((const GLubyte*)"glWindowPos4fvMESA")) == NULL) || r; + r = ((glWindowPos4iMESA = (PFNGLWINDOWPOS4IMESAPROC)glewGetProcAddress((const GLubyte*)"glWindowPos4iMESA")) == NULL) || r; + r = ((glWindowPos4ivMESA = (PFNGLWINDOWPOS4IVMESAPROC)glewGetProcAddress((const GLubyte*)"glWindowPos4ivMESA")) == NULL) || r; + r = ((glWindowPos4sMESA = (PFNGLWINDOWPOS4SMESAPROC)glewGetProcAddress((const GLubyte*)"glWindowPos4sMESA")) == NULL) || r; + r = ((glWindowPos4svMESA = (PFNGLWINDOWPOS4SVMESAPROC)glewGetProcAddress((const GLubyte*)"glWindowPos4svMESA")) == NULL) || r; + + return r; +} + +#endif /* GL_MESA_window_pos */ + +#ifdef GL_MESA_ycbcr_texture + +#endif /* GL_MESA_ycbcr_texture */ + +#ifdef GL_NV_blend_square + +#endif /* GL_NV_blend_square */ + +#ifdef GL_NV_conditional_render + +static GLboolean _glewInit_GL_NV_conditional_render (GLEW_CONTEXT_ARG_DEF_INIT) +{ + GLboolean r = GL_FALSE; + + r = ((glBeginConditionalRenderNV = (PFNGLBEGINCONDITIONALRENDERNVPROC)glewGetProcAddress((const GLubyte*)"glBeginConditionalRenderNV")) == NULL) || r; + r = ((glEndConditionalRenderNV = (PFNGLENDCONDITIONALRENDERNVPROC)glewGetProcAddress((const GLubyte*)"glEndConditionalRenderNV")) == NULL) || r; + + return r; +} + +#endif /* GL_NV_conditional_render */ + +#ifdef GL_NV_copy_depth_to_color + +#endif /* GL_NV_copy_depth_to_color */ + +#ifdef GL_NV_depth_buffer_float + +static GLboolean _glewInit_GL_NV_depth_buffer_float (GLEW_CONTEXT_ARG_DEF_INIT) +{ + GLboolean r = GL_FALSE; + + r = ((glClearDepthdNV = (PFNGLCLEARDEPTHDNVPROC)glewGetProcAddress((const GLubyte*)"glClearDepthdNV")) == NULL) || r; + r = ((glDepthBoundsdNV = (PFNGLDEPTHBOUNDSDNVPROC)glewGetProcAddress((const GLubyte*)"glDepthBoundsdNV")) == NULL) || r; + r = ((glDepthRangedNV = (PFNGLDEPTHRANGEDNVPROC)glewGetProcAddress((const GLubyte*)"glDepthRangedNV")) == NULL) || r; + + return r; +} + +#endif /* GL_NV_depth_buffer_float */ + +#ifdef GL_NV_depth_clamp + +#endif /* GL_NV_depth_clamp */ + +#ifdef GL_NV_depth_range_unclamped + +#endif /* GL_NV_depth_range_unclamped */ + +#ifdef GL_NV_evaluators + +static GLboolean _glewInit_GL_NV_evaluators (GLEW_CONTEXT_ARG_DEF_INIT) +{ + GLboolean r = GL_FALSE; + + r = ((glEvalMapsNV = (PFNGLEVALMAPSNVPROC)glewGetProcAddress((const GLubyte*)"glEvalMapsNV")) == NULL) || r; + r = ((glGetMapAttribParameterfvNV = (PFNGLGETMAPATTRIBPARAMETERFVNVPROC)glewGetProcAddress((const GLubyte*)"glGetMapAttribParameterfvNV")) == NULL) || r; + r = ((glGetMapAttribParameterivNV = (PFNGLGETMAPATTRIBPARAMETERIVNVPROC)glewGetProcAddress((const GLubyte*)"glGetMapAttribParameterivNV")) == NULL) || r; + r = ((glGetMapControlPointsNV = (PFNGLGETMAPCONTROLPOINTSNVPROC)glewGetProcAddress((const GLubyte*)"glGetMapControlPointsNV")) == NULL) || r; + r = ((glGetMapParameterfvNV = (PFNGLGETMAPPARAMETERFVNVPROC)glewGetProcAddress((const GLubyte*)"glGetMapParameterfvNV")) == NULL) || r; + r = ((glGetMapParameterivNV = (PFNGLGETMAPPARAMETERIVNVPROC)glewGetProcAddress((const GLubyte*)"glGetMapParameterivNV")) == NULL) || r; + r = ((glMapControlPointsNV = (PFNGLMAPCONTROLPOINTSNVPROC)glewGetProcAddress((const GLubyte*)"glMapControlPointsNV")) == NULL) || r; + r = ((glMapParameterfvNV = (PFNGLMAPPARAMETERFVNVPROC)glewGetProcAddress((const GLubyte*)"glMapParameterfvNV")) == NULL) || r; + r = ((glMapParameterivNV = (PFNGLMAPPARAMETERIVNVPROC)glewGetProcAddress((const GLubyte*)"glMapParameterivNV")) == NULL) || r; + + return r; +} + +#endif /* GL_NV_evaluators */ + +#ifdef GL_NV_explicit_multisample + +static GLboolean _glewInit_GL_NV_explicit_multisample (GLEW_CONTEXT_ARG_DEF_INIT) +{ + GLboolean r = GL_FALSE; + + r = ((glGetMultisamplefvNV = (PFNGLGETMULTISAMPLEFVNVPROC)glewGetProcAddress((const GLubyte*)"glGetMultisamplefvNV")) == NULL) || r; + r = ((glSampleMaskIndexedNV = (PFNGLSAMPLEMASKINDEXEDNVPROC)glewGetProcAddress((const GLubyte*)"glSampleMaskIndexedNV")) == NULL) || r; + r = ((glTexRenderbufferNV = (PFNGLTEXRENDERBUFFERNVPROC)glewGetProcAddress((const GLubyte*)"glTexRenderbufferNV")) == NULL) || r; + + return r; +} + +#endif /* GL_NV_explicit_multisample */ + +#ifdef GL_NV_fence + +static GLboolean _glewInit_GL_NV_fence (GLEW_CONTEXT_ARG_DEF_INIT) +{ + GLboolean r = GL_FALSE; + + r = ((glDeleteFencesNV = (PFNGLDELETEFENCESNVPROC)glewGetProcAddress((const GLubyte*)"glDeleteFencesNV")) == NULL) || r; + r = ((glFinishFenceNV = (PFNGLFINISHFENCENVPROC)glewGetProcAddress((const GLubyte*)"glFinishFenceNV")) == NULL) || r; + r = ((glGenFencesNV = (PFNGLGENFENCESNVPROC)glewGetProcAddress((const GLubyte*)"glGenFencesNV")) == NULL) || r; + r = ((glGetFenceivNV = (PFNGLGETFENCEIVNVPROC)glewGetProcAddress((const GLubyte*)"glGetFenceivNV")) == NULL) || r; + r = ((glIsFenceNV = (PFNGLISFENCENVPROC)glewGetProcAddress((const GLubyte*)"glIsFenceNV")) == NULL) || r; + r = ((glSetFenceNV = (PFNGLSETFENCENVPROC)glewGetProcAddress((const GLubyte*)"glSetFenceNV")) == NULL) || r; + r = ((glTestFenceNV = (PFNGLTESTFENCENVPROC)glewGetProcAddress((const GLubyte*)"glTestFenceNV")) == NULL) || r; + + return r; +} + +#endif /* GL_NV_fence */ + +#ifdef GL_NV_float_buffer + +#endif /* GL_NV_float_buffer */ + +#ifdef GL_NV_fog_distance + +#endif /* GL_NV_fog_distance */ + +#ifdef GL_NV_fragment_program + +static GLboolean _glewInit_GL_NV_fragment_program (GLEW_CONTEXT_ARG_DEF_INIT) +{ + GLboolean r = GL_FALSE; + + r = ((glGetProgramNamedParameterdvNV = (PFNGLGETPROGRAMNAMEDPARAMETERDVNVPROC)glewGetProcAddress((const GLubyte*)"glGetProgramNamedParameterdvNV")) == NULL) || r; + r = ((glGetProgramNamedParameterfvNV = (PFNGLGETPROGRAMNAMEDPARAMETERFVNVPROC)glewGetProcAddress((const GLubyte*)"glGetProgramNamedParameterfvNV")) == NULL) || r; + r = ((glProgramNamedParameter4dNV = (PFNGLPROGRAMNAMEDPARAMETER4DNVPROC)glewGetProcAddress((const GLubyte*)"glProgramNamedParameter4dNV")) == NULL) || r; + r = ((glProgramNamedParameter4dvNV = (PFNGLPROGRAMNAMEDPARAMETER4DVNVPROC)glewGetProcAddress((const GLubyte*)"glProgramNamedParameter4dvNV")) == NULL) || r; + r = ((glProgramNamedParameter4fNV = (PFNGLPROGRAMNAMEDPARAMETER4FNVPROC)glewGetProcAddress((const GLubyte*)"glProgramNamedParameter4fNV")) == NULL) || r; + r = ((glProgramNamedParameter4fvNV = (PFNGLPROGRAMNAMEDPARAMETER4FVNVPROC)glewGetProcAddress((const GLubyte*)"glProgramNamedParameter4fvNV")) == NULL) || r; + + return r; +} + +#endif /* GL_NV_fragment_program */ + +#ifdef GL_NV_fragment_program2 + +#endif /* GL_NV_fragment_program2 */ + +#ifdef GL_NV_fragment_program4 + +#endif /* GL_NV_fragment_program4 */ + +#ifdef GL_NV_fragment_program_option + +#endif /* GL_NV_fragment_program_option */ + +#ifdef GL_NV_framebuffer_multisample_coverage + +static GLboolean _glewInit_GL_NV_framebuffer_multisample_coverage (GLEW_CONTEXT_ARG_DEF_INIT) +{ + GLboolean r = GL_FALSE; + + r = ((glRenderbufferStorageMultisampleCoverageNV = (PFNGLRENDERBUFFERSTORAGEMULTISAMPLECOVERAGENVPROC)glewGetProcAddress((const GLubyte*)"glRenderbufferStorageMultisampleCoverageNV")) == NULL) || r; + + return r; +} + +#endif /* GL_NV_framebuffer_multisample_coverage */ + +#ifdef GL_NV_geometry_program4 + +static GLboolean _glewInit_GL_NV_geometry_program4 (GLEW_CONTEXT_ARG_DEF_INIT) +{ + GLboolean r = GL_FALSE; + + r = ((glProgramVertexLimitNV = (PFNGLPROGRAMVERTEXLIMITNVPROC)glewGetProcAddress((const GLubyte*)"glProgramVertexLimitNV")) == NULL) || r; + + return r; +} + +#endif /* GL_NV_geometry_program4 */ + +#ifdef GL_NV_geometry_shader4 + +#endif /* GL_NV_geometry_shader4 */ + +#ifdef GL_NV_gpu_program4 + +static GLboolean _glewInit_GL_NV_gpu_program4 (GLEW_CONTEXT_ARG_DEF_INIT) +{ + GLboolean r = GL_FALSE; + + r = ((glProgramEnvParameterI4iNV = (PFNGLPROGRAMENVPARAMETERI4INVPROC)glewGetProcAddress((const GLubyte*)"glProgramEnvParameterI4iNV")) == NULL) || r; + r = ((glProgramEnvParameterI4ivNV = (PFNGLPROGRAMENVPARAMETERI4IVNVPROC)glewGetProcAddress((const GLubyte*)"glProgramEnvParameterI4ivNV")) == NULL) || r; + r = ((glProgramEnvParameterI4uiNV = (PFNGLPROGRAMENVPARAMETERI4UINVPROC)glewGetProcAddress((const GLubyte*)"glProgramEnvParameterI4uiNV")) == NULL) || r; + r = ((glProgramEnvParameterI4uivNV = (PFNGLPROGRAMENVPARAMETERI4UIVNVPROC)glewGetProcAddress((const GLubyte*)"glProgramEnvParameterI4uivNV")) == NULL) || r; + r = ((glProgramEnvParametersI4ivNV = (PFNGLPROGRAMENVPARAMETERSI4IVNVPROC)glewGetProcAddress((const GLubyte*)"glProgramEnvParametersI4ivNV")) == NULL) || r; + r = ((glProgramEnvParametersI4uivNV = (PFNGLPROGRAMENVPARAMETERSI4UIVNVPROC)glewGetProcAddress((const GLubyte*)"glProgramEnvParametersI4uivNV")) == NULL) || r; + r = ((glProgramLocalParameterI4iNV = (PFNGLPROGRAMLOCALPARAMETERI4INVPROC)glewGetProcAddress((const GLubyte*)"glProgramLocalParameterI4iNV")) == NULL) || r; + r = ((glProgramLocalParameterI4ivNV = (PFNGLPROGRAMLOCALPARAMETERI4IVNVPROC)glewGetProcAddress((const GLubyte*)"glProgramLocalParameterI4ivNV")) == NULL) || r; + r = ((glProgramLocalParameterI4uiNV = (PFNGLPROGRAMLOCALPARAMETERI4UINVPROC)glewGetProcAddress((const GLubyte*)"glProgramLocalParameterI4uiNV")) == NULL) || r; + r = ((glProgramLocalParameterI4uivNV = (PFNGLPROGRAMLOCALPARAMETERI4UIVNVPROC)glewGetProcAddress((const GLubyte*)"glProgramLocalParameterI4uivNV")) == NULL) || r; + r = ((glProgramLocalParametersI4ivNV = (PFNGLPROGRAMLOCALPARAMETERSI4IVNVPROC)glewGetProcAddress((const GLubyte*)"glProgramLocalParametersI4ivNV")) == NULL) || r; + r = ((glProgramLocalParametersI4uivNV = (PFNGLPROGRAMLOCALPARAMETERSI4UIVNVPROC)glewGetProcAddress((const GLubyte*)"glProgramLocalParametersI4uivNV")) == NULL) || r; + + return r; +} + +#endif /* GL_NV_gpu_program4 */ + +#ifdef GL_NV_half_float + +static GLboolean _glewInit_GL_NV_half_float (GLEW_CONTEXT_ARG_DEF_INIT) +{ + GLboolean r = GL_FALSE; + + r = ((glColor3hNV = (PFNGLCOLOR3HNVPROC)glewGetProcAddress((const GLubyte*)"glColor3hNV")) == NULL) || r; + r = ((glColor3hvNV = (PFNGLCOLOR3HVNVPROC)glewGetProcAddress((const GLubyte*)"glColor3hvNV")) == NULL) || r; + r = ((glColor4hNV = (PFNGLCOLOR4HNVPROC)glewGetProcAddress((const GLubyte*)"glColor4hNV")) == NULL) || r; + r = ((glColor4hvNV = (PFNGLCOLOR4HVNVPROC)glewGetProcAddress((const GLubyte*)"glColor4hvNV")) == NULL) || r; + r = ((glFogCoordhNV = (PFNGLFOGCOORDHNVPROC)glewGetProcAddress((const GLubyte*)"glFogCoordhNV")) == NULL) || r; + r = ((glFogCoordhvNV = (PFNGLFOGCOORDHVNVPROC)glewGetProcAddress((const GLubyte*)"glFogCoordhvNV")) == NULL) || r; + r = ((glMultiTexCoord1hNV = (PFNGLMULTITEXCOORD1HNVPROC)glewGetProcAddress((const GLubyte*)"glMultiTexCoord1hNV")) == NULL) || r; + r = ((glMultiTexCoord1hvNV = (PFNGLMULTITEXCOORD1HVNVPROC)glewGetProcAddress((const GLubyte*)"glMultiTexCoord1hvNV")) == NULL) || r; + r = ((glMultiTexCoord2hNV = (PFNGLMULTITEXCOORD2HNVPROC)glewGetProcAddress((const GLubyte*)"glMultiTexCoord2hNV")) == NULL) || r; + r = ((glMultiTexCoord2hvNV = (PFNGLMULTITEXCOORD2HVNVPROC)glewGetProcAddress((const GLubyte*)"glMultiTexCoord2hvNV")) == NULL) || r; + r = ((glMultiTexCoord3hNV = (PFNGLMULTITEXCOORD3HNVPROC)glewGetProcAddress((const GLubyte*)"glMultiTexCoord3hNV")) == NULL) || r; + r = ((glMultiTexCoord3hvNV = (PFNGLMULTITEXCOORD3HVNVPROC)glewGetProcAddress((const GLubyte*)"glMultiTexCoord3hvNV")) == NULL) || r; + r = ((glMultiTexCoord4hNV = (PFNGLMULTITEXCOORD4HNVPROC)glewGetProcAddress((const GLubyte*)"glMultiTexCoord4hNV")) == NULL) || r; + r = ((glMultiTexCoord4hvNV = (PFNGLMULTITEXCOORD4HVNVPROC)glewGetProcAddress((const GLubyte*)"glMultiTexCoord4hvNV")) == NULL) || r; + r = ((glNormal3hNV = (PFNGLNORMAL3HNVPROC)glewGetProcAddress((const GLubyte*)"glNormal3hNV")) == NULL) || r; + r = ((glNormal3hvNV = (PFNGLNORMAL3HVNVPROC)glewGetProcAddress((const GLubyte*)"glNormal3hvNV")) == NULL) || r; + r = ((glSecondaryColor3hNV = (PFNGLSECONDARYCOLOR3HNVPROC)glewGetProcAddress((const GLubyte*)"glSecondaryColor3hNV")) == NULL) || r; + r = ((glSecondaryColor3hvNV = (PFNGLSECONDARYCOLOR3HVNVPROC)glewGetProcAddress((const GLubyte*)"glSecondaryColor3hvNV")) == NULL) || r; + r = ((glTexCoord1hNV = (PFNGLTEXCOORD1HNVPROC)glewGetProcAddress((const GLubyte*)"glTexCoord1hNV")) == NULL) || r; + r = ((glTexCoord1hvNV = (PFNGLTEXCOORD1HVNVPROC)glewGetProcAddress((const GLubyte*)"glTexCoord1hvNV")) == NULL) || r; + r = ((glTexCoord2hNV = (PFNGLTEXCOORD2HNVPROC)glewGetProcAddress((const GLubyte*)"glTexCoord2hNV")) == NULL) || r; + r = ((glTexCoord2hvNV = (PFNGLTEXCOORD2HVNVPROC)glewGetProcAddress((const GLubyte*)"glTexCoord2hvNV")) == NULL) || r; + r = ((glTexCoord3hNV = (PFNGLTEXCOORD3HNVPROC)glewGetProcAddress((const GLubyte*)"glTexCoord3hNV")) == NULL) || r; + r = ((glTexCoord3hvNV = (PFNGLTEXCOORD3HVNVPROC)glewGetProcAddress((const GLubyte*)"glTexCoord3hvNV")) == NULL) || r; + r = ((glTexCoord4hNV = (PFNGLTEXCOORD4HNVPROC)glewGetProcAddress((const GLubyte*)"glTexCoord4hNV")) == NULL) || r; + r = ((glTexCoord4hvNV = (PFNGLTEXCOORD4HVNVPROC)glewGetProcAddress((const GLubyte*)"glTexCoord4hvNV")) == NULL) || r; + r = ((glVertex2hNV = (PFNGLVERTEX2HNVPROC)glewGetProcAddress((const GLubyte*)"glVertex2hNV")) == NULL) || r; + r = ((glVertex2hvNV = (PFNGLVERTEX2HVNVPROC)glewGetProcAddress((const GLubyte*)"glVertex2hvNV")) == NULL) || r; + r = ((glVertex3hNV = (PFNGLVERTEX3HNVPROC)glewGetProcAddress((const GLubyte*)"glVertex3hNV")) == NULL) || r; + r = ((glVertex3hvNV = (PFNGLVERTEX3HVNVPROC)glewGetProcAddress((const GLubyte*)"glVertex3hvNV")) == NULL) || r; + r = ((glVertex4hNV = (PFNGLVERTEX4HNVPROC)glewGetProcAddress((const GLubyte*)"glVertex4hNV")) == NULL) || r; + r = ((glVertex4hvNV = (PFNGLVERTEX4HVNVPROC)glewGetProcAddress((const GLubyte*)"glVertex4hvNV")) == NULL) || r; + r = ((glVertexAttrib1hNV = (PFNGLVERTEXATTRIB1HNVPROC)glewGetProcAddress((const GLubyte*)"glVertexAttrib1hNV")) == NULL) || r; + r = ((glVertexAttrib1hvNV = (PFNGLVERTEXATTRIB1HVNVPROC)glewGetProcAddress((const GLubyte*)"glVertexAttrib1hvNV")) == NULL) || r; + r = ((glVertexAttrib2hNV = (PFNGLVERTEXATTRIB2HNVPROC)glewGetProcAddress((const GLubyte*)"glVertexAttrib2hNV")) == NULL) || r; + r = ((glVertexAttrib2hvNV = (PFNGLVERTEXATTRIB2HVNVPROC)glewGetProcAddress((const GLubyte*)"glVertexAttrib2hvNV")) == NULL) || r; + r = ((glVertexAttrib3hNV = (PFNGLVERTEXATTRIB3HNVPROC)glewGetProcAddress((const GLubyte*)"glVertexAttrib3hNV")) == NULL) || r; + r = ((glVertexAttrib3hvNV = (PFNGLVERTEXATTRIB3HVNVPROC)glewGetProcAddress((const GLubyte*)"glVertexAttrib3hvNV")) == NULL) || r; + r = ((glVertexAttrib4hNV = (PFNGLVERTEXATTRIB4HNVPROC)glewGetProcAddress((const GLubyte*)"glVertexAttrib4hNV")) == NULL) || r; + r = ((glVertexAttrib4hvNV = (PFNGLVERTEXATTRIB4HVNVPROC)glewGetProcAddress((const GLubyte*)"glVertexAttrib4hvNV")) == NULL) || r; + r = ((glVertexAttribs1hvNV = (PFNGLVERTEXATTRIBS1HVNVPROC)glewGetProcAddress((const GLubyte*)"glVertexAttribs1hvNV")) == NULL) || r; + r = ((glVertexAttribs2hvNV = (PFNGLVERTEXATTRIBS2HVNVPROC)glewGetProcAddress((const GLubyte*)"glVertexAttribs2hvNV")) == NULL) || r; + r = ((glVertexAttribs3hvNV = (PFNGLVERTEXATTRIBS3HVNVPROC)glewGetProcAddress((const GLubyte*)"glVertexAttribs3hvNV")) == NULL) || r; + r = ((glVertexAttribs4hvNV = (PFNGLVERTEXATTRIBS4HVNVPROC)glewGetProcAddress((const GLubyte*)"glVertexAttribs4hvNV")) == NULL) || r; + r = ((glVertexWeighthNV = (PFNGLVERTEXWEIGHTHNVPROC)glewGetProcAddress((const GLubyte*)"glVertexWeighthNV")) == NULL) || r; + r = ((glVertexWeighthvNV = (PFNGLVERTEXWEIGHTHVNVPROC)glewGetProcAddress((const GLubyte*)"glVertexWeighthvNV")) == NULL) || r; + + return r; +} + +#endif /* GL_NV_half_float */ + +#ifdef GL_NV_light_max_exponent + +#endif /* GL_NV_light_max_exponent */ + +#ifdef GL_NV_multisample_filter_hint + +#endif /* GL_NV_multisample_filter_hint */ + +#ifdef GL_NV_occlusion_query + +static GLboolean _glewInit_GL_NV_occlusion_query (GLEW_CONTEXT_ARG_DEF_INIT) +{ + GLboolean r = GL_FALSE; + + r = ((glBeginOcclusionQueryNV = (PFNGLBEGINOCCLUSIONQUERYNVPROC)glewGetProcAddress((const GLubyte*)"glBeginOcclusionQueryNV")) == NULL) || r; + r = ((glDeleteOcclusionQueriesNV = (PFNGLDELETEOCCLUSIONQUERIESNVPROC)glewGetProcAddress((const GLubyte*)"glDeleteOcclusionQueriesNV")) == NULL) || r; + r = ((glEndOcclusionQueryNV = (PFNGLENDOCCLUSIONQUERYNVPROC)glewGetProcAddress((const GLubyte*)"glEndOcclusionQueryNV")) == NULL) || r; + r = ((glGenOcclusionQueriesNV = (PFNGLGENOCCLUSIONQUERIESNVPROC)glewGetProcAddress((const GLubyte*)"glGenOcclusionQueriesNV")) == NULL) || r; + r = ((glGetOcclusionQueryivNV = (PFNGLGETOCCLUSIONQUERYIVNVPROC)glewGetProcAddress((const GLubyte*)"glGetOcclusionQueryivNV")) == NULL) || r; + r = ((glGetOcclusionQueryuivNV = (PFNGLGETOCCLUSIONQUERYUIVNVPROC)glewGetProcAddress((const GLubyte*)"glGetOcclusionQueryuivNV")) == NULL) || r; + r = ((glIsOcclusionQueryNV = (PFNGLISOCCLUSIONQUERYNVPROC)glewGetProcAddress((const GLubyte*)"glIsOcclusionQueryNV")) == NULL) || r; + + return r; +} + +#endif /* GL_NV_occlusion_query */ + +#ifdef GL_NV_packed_depth_stencil + +#endif /* GL_NV_packed_depth_stencil */ + +#ifdef GL_NV_parameter_buffer_object + +static GLboolean _glewInit_GL_NV_parameter_buffer_object (GLEW_CONTEXT_ARG_DEF_INIT) +{ + GLboolean r = GL_FALSE; + + r = ((glProgramBufferParametersIivNV = (PFNGLPROGRAMBUFFERPARAMETERSIIVNVPROC)glewGetProcAddress((const GLubyte*)"glProgramBufferParametersIivNV")) == NULL) || r; + r = ((glProgramBufferParametersIuivNV = (PFNGLPROGRAMBUFFERPARAMETERSIUIVNVPROC)glewGetProcAddress((const GLubyte*)"glProgramBufferParametersIuivNV")) == NULL) || r; + r = ((glProgramBufferParametersfvNV = (PFNGLPROGRAMBUFFERPARAMETERSFVNVPROC)glewGetProcAddress((const GLubyte*)"glProgramBufferParametersfvNV")) == NULL) || r; + + return r; +} + +#endif /* GL_NV_parameter_buffer_object */ + +#ifdef GL_NV_pixel_data_range + +static GLboolean _glewInit_GL_NV_pixel_data_range (GLEW_CONTEXT_ARG_DEF_INIT) +{ + GLboolean r = GL_FALSE; + + r = ((glFlushPixelDataRangeNV = (PFNGLFLUSHPIXELDATARANGENVPROC)glewGetProcAddress((const GLubyte*)"glFlushPixelDataRangeNV")) == NULL) || r; + r = ((glPixelDataRangeNV = (PFNGLPIXELDATARANGENVPROC)glewGetProcAddress((const GLubyte*)"glPixelDataRangeNV")) == NULL) || r; + + return r; +} + +#endif /* GL_NV_pixel_data_range */ + +#ifdef GL_NV_point_sprite + +static GLboolean _glewInit_GL_NV_point_sprite (GLEW_CONTEXT_ARG_DEF_INIT) +{ + GLboolean r = GL_FALSE; + + r = ((glPointParameteriNV = (PFNGLPOINTPARAMETERINVPROC)glewGetProcAddress((const GLubyte*)"glPointParameteriNV")) == NULL) || r; + r = ((glPointParameterivNV = (PFNGLPOINTPARAMETERIVNVPROC)glewGetProcAddress((const GLubyte*)"glPointParameterivNV")) == NULL) || r; + + return r; +} + +#endif /* GL_NV_point_sprite */ + +#ifdef GL_NV_present_video + +static GLboolean _glewInit_GL_NV_present_video (GLEW_CONTEXT_ARG_DEF_INIT) +{ + GLboolean r = GL_FALSE; + +// r = ((glGetVideoi64vNV = (PFNGLGETVIDEOI64VNVPROC)glewGetProcAddress((const GLubyte*)"glGetVideoi64vNV")) == NULL) || r; + r = ((glGetVideoivNV = (PFNGLGETVIDEOIVNVPROC)glewGetProcAddress((const GLubyte*)"glGetVideoivNV")) == NULL) || r; +// r = ((glGetVideoui64vNV = (PFNGLGETVIDEOUI64VNVPROC)glewGetProcAddress((const GLubyte*)"glGetVideoui64vNV")) == NULL) || r; + r = ((glGetVideouivNV = (PFNGLGETVIDEOUIVNVPROC)glewGetProcAddress((const GLubyte*)"glGetVideouivNV")) == NULL) || r; +// r = ((glPresentFrameDualFillNV = (PFNGLPRESENTFRAMEDUALFILLNVPROC)glewGetProcAddress((const GLubyte*)"glPresentFrameDualFillNV")) == NULL) || r; +// r = ((glPresentFrameKeyedNV = (PFNGLPRESENTFRAMEKEYEDNVPROC)glewGetProcAddress((const GLubyte*)"glPresentFrameKeyedNV")) == NULL) || r; + r = ((glVideoParameterivNV = (PFNGLVIDEOPARAMETERIVNVPROC)glewGetProcAddress((const GLubyte*)"glVideoParameterivNV")) == NULL) || r; + + return r; +} + +#endif /* GL_NV_present_video */ + +#ifdef GL_NV_primitive_restart + +static GLboolean _glewInit_GL_NV_primitive_restart (GLEW_CONTEXT_ARG_DEF_INIT) +{ + GLboolean r = GL_FALSE; + + r = ((glPrimitiveRestartIndexNV = (PFNGLPRIMITIVERESTARTINDEXNVPROC)glewGetProcAddress((const GLubyte*)"glPrimitiveRestartIndexNV")) == NULL) || r; + r = ((glPrimitiveRestartNV = (PFNGLPRIMITIVERESTARTNVPROC)glewGetProcAddress((const GLubyte*)"glPrimitiveRestartNV")) == NULL) || r; + + return r; +} + +#endif /* GL_NV_primitive_restart */ + +#ifdef GL_NV_register_combiners + +static GLboolean _glewInit_GL_NV_register_combiners (GLEW_CONTEXT_ARG_DEF_INIT) +{ + GLboolean r = GL_FALSE; + + r = ((glCombinerInputNV = (PFNGLCOMBINERINPUTNVPROC)glewGetProcAddress((const GLubyte*)"glCombinerInputNV")) == NULL) || r; + r = ((glCombinerOutputNV = (PFNGLCOMBINEROUTPUTNVPROC)glewGetProcAddress((const GLubyte*)"glCombinerOutputNV")) == NULL) || r; + r = ((glCombinerParameterfNV = (PFNGLCOMBINERPARAMETERFNVPROC)glewGetProcAddress((const GLubyte*)"glCombinerParameterfNV")) == NULL) || r; + r = ((glCombinerParameterfvNV = (PFNGLCOMBINERPARAMETERFVNVPROC)glewGetProcAddress((const GLubyte*)"glCombinerParameterfvNV")) == NULL) || r; + r = ((glCombinerParameteriNV = (PFNGLCOMBINERPARAMETERINVPROC)glewGetProcAddress((const GLubyte*)"glCombinerParameteriNV")) == NULL) || r; + r = ((glCombinerParameterivNV = (PFNGLCOMBINERPARAMETERIVNVPROC)glewGetProcAddress((const GLubyte*)"glCombinerParameterivNV")) == NULL) || r; + r = ((glFinalCombinerInputNV = (PFNGLFINALCOMBINERINPUTNVPROC)glewGetProcAddress((const GLubyte*)"glFinalCombinerInputNV")) == NULL) || r; + r = ((glGetCombinerInputParameterfvNV = (PFNGLGETCOMBINERINPUTPARAMETERFVNVPROC)glewGetProcAddress((const GLubyte*)"glGetCombinerInputParameterfvNV")) == NULL) || r; + r = ((glGetCombinerInputParameterivNV = (PFNGLGETCOMBINERINPUTPARAMETERIVNVPROC)glewGetProcAddress((const GLubyte*)"glGetCombinerInputParameterivNV")) == NULL) || r; + r = ((glGetCombinerOutputParameterfvNV = (PFNGLGETCOMBINEROUTPUTPARAMETERFVNVPROC)glewGetProcAddress((const GLubyte*)"glGetCombinerOutputParameterfvNV")) == NULL) || r; + r = ((glGetCombinerOutputParameterivNV = (PFNGLGETCOMBINEROUTPUTPARAMETERIVNVPROC)glewGetProcAddress((const GLubyte*)"glGetCombinerOutputParameterivNV")) == NULL) || r; + r = ((glGetFinalCombinerInputParameterfvNV = (PFNGLGETFINALCOMBINERINPUTPARAMETERFVNVPROC)glewGetProcAddress((const GLubyte*)"glGetFinalCombinerInputParameterfvNV")) == NULL) || r; + r = ((glGetFinalCombinerInputParameterivNV = (PFNGLGETFINALCOMBINERINPUTPARAMETERIVNVPROC)glewGetProcAddress((const GLubyte*)"glGetFinalCombinerInputParameterivNV")) == NULL) || r; + + return r; +} + +#endif /* GL_NV_register_combiners */ + +#ifdef GL_NV_register_combiners2 + +static GLboolean _glewInit_GL_NV_register_combiners2 (GLEW_CONTEXT_ARG_DEF_INIT) +{ + GLboolean r = GL_FALSE; + + r = ((glCombinerStageParameterfvNV = (PFNGLCOMBINERSTAGEPARAMETERFVNVPROC)glewGetProcAddress((const GLubyte*)"glCombinerStageParameterfvNV")) == NULL) || r; + r = ((glGetCombinerStageParameterfvNV = (PFNGLGETCOMBINERSTAGEPARAMETERFVNVPROC)glewGetProcAddress((const GLubyte*)"glGetCombinerStageParameterfvNV")) == NULL) || r; + + return r; +} + +#endif /* GL_NV_register_combiners2 */ + +#ifdef GL_NV_texgen_emboss + +#endif /* GL_NV_texgen_emboss */ + +#ifdef GL_NV_texgen_reflection + +#endif /* GL_NV_texgen_reflection */ + +#ifdef GL_NV_texture_compression_vtc + +#endif /* GL_NV_texture_compression_vtc */ + +#ifdef GL_NV_texture_env_combine4 + +#endif /* GL_NV_texture_env_combine4 */ + +#ifdef GL_NV_texture_expand_normal + +#endif /* GL_NV_texture_expand_normal */ + +#ifdef GL_NV_texture_rectangle + +#endif /* GL_NV_texture_rectangle */ + +#ifdef GL_NV_texture_shader + +#endif /* GL_NV_texture_shader */ + +#ifdef GL_NV_texture_shader2 + +#endif /* GL_NV_texture_shader2 */ + +#ifdef GL_NV_texture_shader3 + +#endif /* GL_NV_texture_shader3 */ + +#ifdef GL_NV_transform_feedback + +static GLboolean _glewInit_GL_NV_transform_feedback (GLEW_CONTEXT_ARG_DEF_INIT) +{ + GLboolean r = GL_FALSE; + + r = ((glActiveVaryingNV = (PFNGLACTIVEVARYINGNVPROC)glewGetProcAddress((const GLubyte*)"glActiveVaryingNV")) == NULL) || r; + r = ((glBeginTransformFeedbackNV = (PFNGLBEGINTRANSFORMFEEDBACKNVPROC)glewGetProcAddress((const GLubyte*)"glBeginTransformFeedbackNV")) == NULL) || r; + r = ((glBindBufferBaseNV = (PFNGLBINDBUFFERBASENVPROC)glewGetProcAddress((const GLubyte*)"glBindBufferBaseNV")) == NULL) || r; + r = ((glBindBufferOffsetNV = (PFNGLBINDBUFFEROFFSETNVPROC)glewGetProcAddress((const GLubyte*)"glBindBufferOffsetNV")) == NULL) || r; + r = ((glBindBufferRangeNV = (PFNGLBINDBUFFERRANGENVPROC)glewGetProcAddress((const GLubyte*)"glBindBufferRangeNV")) == NULL) || r; + r = ((glEndTransformFeedbackNV = (PFNGLENDTRANSFORMFEEDBACKNVPROC)glewGetProcAddress((const GLubyte*)"glEndTransformFeedbackNV")) == NULL) || r; + r = ((glGetActiveVaryingNV = (PFNGLGETACTIVEVARYINGNVPROC)glewGetProcAddress((const GLubyte*)"glGetActiveVaryingNV")) == NULL) || r; + r = ((glGetTransformFeedbackVaryingNV = (PFNGLGETTRANSFORMFEEDBACKVARYINGNVPROC)glewGetProcAddress((const GLubyte*)"glGetTransformFeedbackVaryingNV")) == NULL) || r; + r = ((glGetVaryingLocationNV = (PFNGLGETVARYINGLOCATIONNVPROC)glewGetProcAddress((const GLubyte*)"glGetVaryingLocationNV")) == NULL) || r; + r = ((glTransformFeedbackAttribsNV = (PFNGLTRANSFORMFEEDBACKATTRIBSNVPROC)glewGetProcAddress((const GLubyte*)"glTransformFeedbackAttribsNV")) == NULL) || r; + r = ((glTransformFeedbackVaryingsNV = (PFNGLTRANSFORMFEEDBACKVARYINGSNVPROC)glewGetProcAddress((const GLubyte*)"glTransformFeedbackVaryingsNV")) == NULL) || r; + + return r; +} + +#endif /* GL_NV_transform_feedback */ + +#ifdef GL_NV_vertex_array_range + +static GLboolean _glewInit_GL_NV_vertex_array_range (GLEW_CONTEXT_ARG_DEF_INIT) +{ + GLboolean r = GL_FALSE; + + r = ((glFlushVertexArrayRangeNV = (PFNGLFLUSHVERTEXARRAYRANGENVPROC)glewGetProcAddress((const GLubyte*)"glFlushVertexArrayRangeNV")) == NULL) || r; + r = ((glVertexArrayRangeNV = (PFNGLVERTEXARRAYRANGENVPROC)glewGetProcAddress((const GLubyte*)"glVertexArrayRangeNV")) == NULL) || r; + + return r; +} + +#endif /* GL_NV_vertex_array_range */ + +#ifdef GL_NV_vertex_array_range2 + +#endif /* GL_NV_vertex_array_range2 */ + +#ifdef GL_NV_vertex_program + +static GLboolean _glewInit_GL_NV_vertex_program (GLEW_CONTEXT_ARG_DEF_INIT) +{ + GLboolean r = GL_FALSE; + + r = ((glAreProgramsResidentNV = (PFNGLAREPROGRAMSRESIDENTNVPROC)glewGetProcAddress((const GLubyte*)"glAreProgramsResidentNV")) == NULL) || r; + r = ((glBindProgramNV = (PFNGLBINDPROGRAMNVPROC)glewGetProcAddress((const GLubyte*)"glBindProgramNV")) == NULL) || r; + r = ((glDeleteProgramsNV = (PFNGLDELETEPROGRAMSNVPROC)glewGetProcAddress((const GLubyte*)"glDeleteProgramsNV")) == NULL) || r; + r = ((glExecuteProgramNV = (PFNGLEXECUTEPROGRAMNVPROC)glewGetProcAddress((const GLubyte*)"glExecuteProgramNV")) == NULL) || r; + r = ((glGenProgramsNV = (PFNGLGENPROGRAMSNVPROC)glewGetProcAddress((const GLubyte*)"glGenProgramsNV")) == NULL) || r; + r = ((glGetProgramParameterdvNV = (PFNGLGETPROGRAMPARAMETERDVNVPROC)glewGetProcAddress((const GLubyte*)"glGetProgramParameterdvNV")) == NULL) || r; + r = ((glGetProgramParameterfvNV = (PFNGLGETPROGRAMPARAMETERFVNVPROC)glewGetProcAddress((const GLubyte*)"glGetProgramParameterfvNV")) == NULL) || r; + r = ((glGetProgramStringNV = (PFNGLGETPROGRAMSTRINGNVPROC)glewGetProcAddress((const GLubyte*)"glGetProgramStringNV")) == NULL) || r; + r = ((glGetProgramivNV = (PFNGLGETPROGRAMIVNVPROC)glewGetProcAddress((const GLubyte*)"glGetProgramivNV")) == NULL) || r; + r = ((glGetTrackMatrixivNV = (PFNGLGETTRACKMATRIXIVNVPROC)glewGetProcAddress((const GLubyte*)"glGetTrackMatrixivNV")) == NULL) || r; + r = ((glGetVertexAttribPointervNV = (PFNGLGETVERTEXATTRIBPOINTERVNVPROC)glewGetProcAddress((const GLubyte*)"glGetVertexAttribPointervNV")) == NULL) || r; + r = ((glGetVertexAttribdvNV = (PFNGLGETVERTEXATTRIBDVNVPROC)glewGetProcAddress((const GLubyte*)"glGetVertexAttribdvNV")) == NULL) || r; + r = ((glGetVertexAttribfvNV = (PFNGLGETVERTEXATTRIBFVNVPROC)glewGetProcAddress((const GLubyte*)"glGetVertexAttribfvNV")) == NULL) || r; + r = ((glGetVertexAttribivNV = (PFNGLGETVERTEXATTRIBIVNVPROC)glewGetProcAddress((const GLubyte*)"glGetVertexAttribivNV")) == NULL) || r; + r = ((glIsProgramNV = (PFNGLISPROGRAMNVPROC)glewGetProcAddress((const GLubyte*)"glIsProgramNV")) == NULL) || r; + r = ((glLoadProgramNV = (PFNGLLOADPROGRAMNVPROC)glewGetProcAddress((const GLubyte*)"glLoadProgramNV")) == NULL) || r; + r = ((glProgramParameter4dNV = (PFNGLPROGRAMPARAMETER4DNVPROC)glewGetProcAddress((const GLubyte*)"glProgramParameter4dNV")) == NULL) || r; + r = ((glProgramParameter4dvNV = (PFNGLPROGRAMPARAMETER4DVNVPROC)glewGetProcAddress((const GLubyte*)"glProgramParameter4dvNV")) == NULL) || r; + r = ((glProgramParameter4fNV = (PFNGLPROGRAMPARAMETER4FNVPROC)glewGetProcAddress((const GLubyte*)"glProgramParameter4fNV")) == NULL) || r; + r = ((glProgramParameter4fvNV = (PFNGLPROGRAMPARAMETER4FVNVPROC)glewGetProcAddress((const GLubyte*)"glProgramParameter4fvNV")) == NULL) || r; + r = ((glProgramParameters4dvNV = (PFNGLPROGRAMPARAMETERS4DVNVPROC)glewGetProcAddress((const GLubyte*)"glProgramParameters4dvNV")) == NULL) || r; + r = ((glProgramParameters4fvNV = (PFNGLPROGRAMPARAMETERS4FVNVPROC)glewGetProcAddress((const GLubyte*)"glProgramParameters4fvNV")) == NULL) || r; + r = ((glRequestResidentProgramsNV = (PFNGLREQUESTRESIDENTPROGRAMSNVPROC)glewGetProcAddress((const GLubyte*)"glRequestResidentProgramsNV")) == NULL) || r; + r = ((glTrackMatrixNV = (PFNGLTRACKMATRIXNVPROC)glewGetProcAddress((const GLubyte*)"glTrackMatrixNV")) == NULL) || r; + r = ((glVertexAttrib1dNV = (PFNGLVERTEXATTRIB1DNVPROC)glewGetProcAddress((const GLubyte*)"glVertexAttrib1dNV")) == NULL) || r; + r = ((glVertexAttrib1dvNV = (PFNGLVERTEXATTRIB1DVNVPROC)glewGetProcAddress((const GLubyte*)"glVertexAttrib1dvNV")) == NULL) || r; + r = ((glVertexAttrib1fNV = (PFNGLVERTEXATTRIB1FNVPROC)glewGetProcAddress((const GLubyte*)"glVertexAttrib1fNV")) == NULL) || r; + r = ((glVertexAttrib1fvNV = (PFNGLVERTEXATTRIB1FVNVPROC)glewGetProcAddress((const GLubyte*)"glVertexAttrib1fvNV")) == NULL) || r; + r = ((glVertexAttrib1sNV = (PFNGLVERTEXATTRIB1SNVPROC)glewGetProcAddress((const GLubyte*)"glVertexAttrib1sNV")) == NULL) || r; + r = ((glVertexAttrib1svNV = (PFNGLVERTEXATTRIB1SVNVPROC)glewGetProcAddress((const GLubyte*)"glVertexAttrib1svNV")) == NULL) || r; + r = ((glVertexAttrib2dNV = (PFNGLVERTEXATTRIB2DNVPROC)glewGetProcAddress((const GLubyte*)"glVertexAttrib2dNV")) == NULL) || r; + r = ((glVertexAttrib2dvNV = (PFNGLVERTEXATTRIB2DVNVPROC)glewGetProcAddress((const GLubyte*)"glVertexAttrib2dvNV")) == NULL) || r; + r = ((glVertexAttrib2fNV = (PFNGLVERTEXATTRIB2FNVPROC)glewGetProcAddress((const GLubyte*)"glVertexAttrib2fNV")) == NULL) || r; + r = ((glVertexAttrib2fvNV = (PFNGLVERTEXATTRIB2FVNVPROC)glewGetProcAddress((const GLubyte*)"glVertexAttrib2fvNV")) == NULL) || r; + r = ((glVertexAttrib2sNV = (PFNGLVERTEXATTRIB2SNVPROC)glewGetProcAddress((const GLubyte*)"glVertexAttrib2sNV")) == NULL) || r; + r = ((glVertexAttrib2svNV = (PFNGLVERTEXATTRIB2SVNVPROC)glewGetProcAddress((const GLubyte*)"glVertexAttrib2svNV")) == NULL) || r; + r = ((glVertexAttrib3dNV = (PFNGLVERTEXATTRIB3DNVPROC)glewGetProcAddress((const GLubyte*)"glVertexAttrib3dNV")) == NULL) || r; + r = ((glVertexAttrib3dvNV = (PFNGLVERTEXATTRIB3DVNVPROC)glewGetProcAddress((const GLubyte*)"glVertexAttrib3dvNV")) == NULL) || r; + r = ((glVertexAttrib3fNV = (PFNGLVERTEXATTRIB3FNVPROC)glewGetProcAddress((const GLubyte*)"glVertexAttrib3fNV")) == NULL) || r; + r = ((glVertexAttrib3fvNV = (PFNGLVERTEXATTRIB3FVNVPROC)glewGetProcAddress((const GLubyte*)"glVertexAttrib3fvNV")) == NULL) || r; + r = ((glVertexAttrib3sNV = (PFNGLVERTEXATTRIB3SNVPROC)glewGetProcAddress((const GLubyte*)"glVertexAttrib3sNV")) == NULL) || r; + r = ((glVertexAttrib3svNV = (PFNGLVERTEXATTRIB3SVNVPROC)glewGetProcAddress((const GLubyte*)"glVertexAttrib3svNV")) == NULL) || r; + r = ((glVertexAttrib4dNV = (PFNGLVERTEXATTRIB4DNVPROC)glewGetProcAddress((const GLubyte*)"glVertexAttrib4dNV")) == NULL) || r; + r = ((glVertexAttrib4dvNV = (PFNGLVERTEXATTRIB4DVNVPROC)glewGetProcAddress((const GLubyte*)"glVertexAttrib4dvNV")) == NULL) || r; + r = ((glVertexAttrib4fNV = (PFNGLVERTEXATTRIB4FNVPROC)glewGetProcAddress((const GLubyte*)"glVertexAttrib4fNV")) == NULL) || r; + r = ((glVertexAttrib4fvNV = (PFNGLVERTEXATTRIB4FVNVPROC)glewGetProcAddress((const GLubyte*)"glVertexAttrib4fvNV")) == NULL) || r; + r = ((glVertexAttrib4sNV = (PFNGLVERTEXATTRIB4SNVPROC)glewGetProcAddress((const GLubyte*)"glVertexAttrib4sNV")) == NULL) || r; + r = ((glVertexAttrib4svNV = (PFNGLVERTEXATTRIB4SVNVPROC)glewGetProcAddress((const GLubyte*)"glVertexAttrib4svNV")) == NULL) || r; + r = ((glVertexAttrib4ubNV = (PFNGLVERTEXATTRIB4UBNVPROC)glewGetProcAddress((const GLubyte*)"glVertexAttrib4ubNV")) == NULL) || r; + r = ((glVertexAttrib4ubvNV = (PFNGLVERTEXATTRIB4UBVNVPROC)glewGetProcAddress((const GLubyte*)"glVertexAttrib4ubvNV")) == NULL) || r; + r = ((glVertexAttribPointerNV = (PFNGLVERTEXATTRIBPOINTERNVPROC)glewGetProcAddress((const GLubyte*)"glVertexAttribPointerNV")) == NULL) || r; + r = ((glVertexAttribs1dvNV = (PFNGLVERTEXATTRIBS1DVNVPROC)glewGetProcAddress((const GLubyte*)"glVertexAttribs1dvNV")) == NULL) || r; + r = ((glVertexAttribs1fvNV = (PFNGLVERTEXATTRIBS1FVNVPROC)glewGetProcAddress((const GLubyte*)"glVertexAttribs1fvNV")) == NULL) || r; + r = ((glVertexAttribs1svNV = (PFNGLVERTEXATTRIBS1SVNVPROC)glewGetProcAddress((const GLubyte*)"glVertexAttribs1svNV")) == NULL) || r; + r = ((glVertexAttribs2dvNV = (PFNGLVERTEXATTRIBS2DVNVPROC)glewGetProcAddress((const GLubyte*)"glVertexAttribs2dvNV")) == NULL) || r; + r = ((glVertexAttribs2fvNV = (PFNGLVERTEXATTRIBS2FVNVPROC)glewGetProcAddress((const GLubyte*)"glVertexAttribs2fvNV")) == NULL) || r; + r = ((glVertexAttribs2svNV = (PFNGLVERTEXATTRIBS2SVNVPROC)glewGetProcAddress((const GLubyte*)"glVertexAttribs2svNV")) == NULL) || r; + r = ((glVertexAttribs3dvNV = (PFNGLVERTEXATTRIBS3DVNVPROC)glewGetProcAddress((const GLubyte*)"glVertexAttribs3dvNV")) == NULL) || r; + r = ((glVertexAttribs3fvNV = (PFNGLVERTEXATTRIBS3FVNVPROC)glewGetProcAddress((const GLubyte*)"glVertexAttribs3fvNV")) == NULL) || r; + r = ((glVertexAttribs3svNV = (PFNGLVERTEXATTRIBS3SVNVPROC)glewGetProcAddress((const GLubyte*)"glVertexAttribs3svNV")) == NULL) || r; + r = ((glVertexAttribs4dvNV = (PFNGLVERTEXATTRIBS4DVNVPROC)glewGetProcAddress((const GLubyte*)"glVertexAttribs4dvNV")) == NULL) || r; + r = ((glVertexAttribs4fvNV = (PFNGLVERTEXATTRIBS4FVNVPROC)glewGetProcAddress((const GLubyte*)"glVertexAttribs4fvNV")) == NULL) || r; + r = ((glVertexAttribs4svNV = (PFNGLVERTEXATTRIBS4SVNVPROC)glewGetProcAddress((const GLubyte*)"glVertexAttribs4svNV")) == NULL) || r; + r = ((glVertexAttribs4ubvNV = (PFNGLVERTEXATTRIBS4UBVNVPROC)glewGetProcAddress((const GLubyte*)"glVertexAttribs4ubvNV")) == NULL) || r; + + return r; +} + +#endif /* GL_NV_vertex_program */ + +#ifdef GL_NV_vertex_program1_1 + +#endif /* GL_NV_vertex_program1_1 */ + +#ifdef GL_NV_vertex_program2 + +#endif /* GL_NV_vertex_program2 */ + +#ifdef GL_NV_vertex_program2_option + +#endif /* GL_NV_vertex_program2_option */ + +#ifdef GL_NV_vertex_program3 + +#endif /* GL_NV_vertex_program3 */ + +#ifdef GL_NV_vertex_program4 + +#endif /* GL_NV_vertex_program4 */ + +#ifdef GL_OES_byte_coordinates + +#endif /* GL_OES_byte_coordinates */ + +#ifdef GL_OES_compressed_paletted_texture + +#endif /* GL_OES_compressed_paletted_texture */ + +#ifdef GL_OES_read_format + +#endif /* GL_OES_read_format */ + +#ifdef GL_OES_single_precision + +static GLboolean _glewInit_GL_OES_single_precision (GLEW_CONTEXT_ARG_DEF_INIT) +{ + GLboolean r = GL_FALSE; + + r = ((glClearDepthfOES = (PFNGLCLEARDEPTHFOESPROC)glewGetProcAddress((const GLubyte*)"glClearDepthfOES")) == NULL) || r; + r = ((glClipPlanefOES = (PFNGLCLIPPLANEFOESPROC)glewGetProcAddress((const GLubyte*)"glClipPlanefOES")) == NULL) || r; + r = ((glDepthRangefOES = (PFNGLDEPTHRANGEFOESPROC)glewGetProcAddress((const GLubyte*)"glDepthRangefOES")) == NULL) || r; + r = ((glFrustumfOES = (PFNGLFRUSTUMFOESPROC)glewGetProcAddress((const GLubyte*)"glFrustumfOES")) == NULL) || r; + r = ((glGetClipPlanefOES = (PFNGLGETCLIPPLANEFOESPROC)glewGetProcAddress((const GLubyte*)"glGetClipPlanefOES")) == NULL) || r; + r = ((glOrthofOES = (PFNGLORTHOFOESPROC)glewGetProcAddress((const GLubyte*)"glOrthofOES")) == NULL) || r; + + return r; +} + +#endif /* GL_OES_single_precision */ + +#ifdef GL_OML_interlace + +#endif /* GL_OML_interlace */ + +#ifdef GL_OML_resample + +#endif /* GL_OML_resample */ + +#ifdef GL_OML_subsample + +#endif /* GL_OML_subsample */ + +#ifdef GL_PGI_misc_hints + +#endif /* GL_PGI_misc_hints */ + +#ifdef GL_PGI_vertex_hints + +#endif /* GL_PGI_vertex_hints */ + +#ifdef GL_REND_screen_coordinates + +#endif /* GL_REND_screen_coordinates */ + +#ifdef GL_S3_s3tc + +#endif /* GL_S3_s3tc */ + +#ifdef GL_SGIS_color_range + +#endif /* GL_SGIS_color_range */ + +#ifdef GL_SGIS_detail_texture + +static GLboolean _glewInit_GL_SGIS_detail_texture (GLEW_CONTEXT_ARG_DEF_INIT) +{ + GLboolean r = GL_FALSE; + + r = ((glDetailTexFuncSGIS = (PFNGLDETAILTEXFUNCSGISPROC)glewGetProcAddress((const GLubyte*)"glDetailTexFuncSGIS")) == NULL) || r; + r = ((glGetDetailTexFuncSGIS = (PFNGLGETDETAILTEXFUNCSGISPROC)glewGetProcAddress((const GLubyte*)"glGetDetailTexFuncSGIS")) == NULL) || r; + + return r; +} + +#endif /* GL_SGIS_detail_texture */ + +#ifdef GL_SGIS_fog_function + +static GLboolean _glewInit_GL_SGIS_fog_function (GLEW_CONTEXT_ARG_DEF_INIT) +{ + GLboolean r = GL_FALSE; + + r = ((glFogFuncSGIS = (PFNGLFOGFUNCSGISPROC)glewGetProcAddress((const GLubyte*)"glFogFuncSGIS")) == NULL) || r; + r = ((glGetFogFuncSGIS = (PFNGLGETFOGFUNCSGISPROC)glewGetProcAddress((const GLubyte*)"glGetFogFuncSGIS")) == NULL) || r; + + return r; +} + +#endif /* GL_SGIS_fog_function */ + +#ifdef GL_SGIS_generate_mipmap + +#endif /* GL_SGIS_generate_mipmap */ + +#ifdef GL_SGIS_multisample + +static GLboolean _glewInit_GL_SGIS_multisample (GLEW_CONTEXT_ARG_DEF_INIT) +{ + GLboolean r = GL_FALSE; + + r = ((glSampleMaskSGIS = (PFNGLSAMPLEMASKSGISPROC)glewGetProcAddress((const GLubyte*)"glSampleMaskSGIS")) == NULL) || r; + r = ((glSamplePatternSGIS = (PFNGLSAMPLEPATTERNSGISPROC)glewGetProcAddress((const GLubyte*)"glSamplePatternSGIS")) == NULL) || r; + + return r; +} + +#endif /* GL_SGIS_multisample */ + +#ifdef GL_SGIS_pixel_texture + +#endif /* GL_SGIS_pixel_texture */ + +#ifdef GL_SGIS_point_line_texgen + +#endif /* GL_SGIS_point_line_texgen */ + +#ifdef GL_SGIS_sharpen_texture + +static GLboolean _glewInit_GL_SGIS_sharpen_texture (GLEW_CONTEXT_ARG_DEF_INIT) +{ + GLboolean r = GL_FALSE; + + r = ((glGetSharpenTexFuncSGIS = (PFNGLGETSHARPENTEXFUNCSGISPROC)glewGetProcAddress((const GLubyte*)"glGetSharpenTexFuncSGIS")) == NULL) || r; + r = ((glSharpenTexFuncSGIS = (PFNGLSHARPENTEXFUNCSGISPROC)glewGetProcAddress((const GLubyte*)"glSharpenTexFuncSGIS")) == NULL) || r; + + return r; +} + +#endif /* GL_SGIS_sharpen_texture */ + +#ifdef GL_SGIS_texture4D + +static GLboolean _glewInit_GL_SGIS_texture4D (GLEW_CONTEXT_ARG_DEF_INIT) +{ + GLboolean r = GL_FALSE; + + r = ((glTexImage4DSGIS = (PFNGLTEXIMAGE4DSGISPROC)glewGetProcAddress((const GLubyte*)"glTexImage4DSGIS")) == NULL) || r; + r = ((glTexSubImage4DSGIS = (PFNGLTEXSUBIMAGE4DSGISPROC)glewGetProcAddress((const GLubyte*)"glTexSubImage4DSGIS")) == NULL) || r; + + return r; +} + +#endif /* GL_SGIS_texture4D */ + +#ifdef GL_SGIS_texture_border_clamp + +#endif /* GL_SGIS_texture_border_clamp */ + +#ifdef GL_SGIS_texture_edge_clamp + +#endif /* GL_SGIS_texture_edge_clamp */ + +#ifdef GL_SGIS_texture_filter4 + +static GLboolean _glewInit_GL_SGIS_texture_filter4 (GLEW_CONTEXT_ARG_DEF_INIT) +{ + GLboolean r = GL_FALSE; + + r = ((glGetTexFilterFuncSGIS = (PFNGLGETTEXFILTERFUNCSGISPROC)glewGetProcAddress((const GLubyte*)"glGetTexFilterFuncSGIS")) == NULL) || r; + r = ((glTexFilterFuncSGIS = (PFNGLTEXFILTERFUNCSGISPROC)glewGetProcAddress((const GLubyte*)"glTexFilterFuncSGIS")) == NULL) || r; + + return r; +} + +#endif /* GL_SGIS_texture_filter4 */ + +#ifdef GL_SGIS_texture_lod + +#endif /* GL_SGIS_texture_lod */ + +#ifdef GL_SGIS_texture_select + +#endif /* GL_SGIS_texture_select */ + +#ifdef GL_SGIX_async + +static GLboolean _glewInit_GL_SGIX_async (GLEW_CONTEXT_ARG_DEF_INIT) +{ + GLboolean r = GL_FALSE; + + r = ((glAsyncMarkerSGIX = (PFNGLASYNCMARKERSGIXPROC)glewGetProcAddress((const GLubyte*)"glAsyncMarkerSGIX")) == NULL) || r; + r = ((glDeleteAsyncMarkersSGIX = (PFNGLDELETEASYNCMARKERSSGIXPROC)glewGetProcAddress((const GLubyte*)"glDeleteAsyncMarkersSGIX")) == NULL) || r; + r = ((glFinishAsyncSGIX = (PFNGLFINISHASYNCSGIXPROC)glewGetProcAddress((const GLubyte*)"glFinishAsyncSGIX")) == NULL) || r; + r = ((glGenAsyncMarkersSGIX = (PFNGLGENASYNCMARKERSSGIXPROC)glewGetProcAddress((const GLubyte*)"glGenAsyncMarkersSGIX")) == NULL) || r; + r = ((glIsAsyncMarkerSGIX = (PFNGLISASYNCMARKERSGIXPROC)glewGetProcAddress((const GLubyte*)"glIsAsyncMarkerSGIX")) == NULL) || r; + r = ((glPollAsyncSGIX = (PFNGLPOLLASYNCSGIXPROC)glewGetProcAddress((const GLubyte*)"glPollAsyncSGIX")) == NULL) || r; + + return r; +} + +#endif /* GL_SGIX_async */ + +#ifdef GL_SGIX_async_histogram + +#endif /* GL_SGIX_async_histogram */ + +#ifdef GL_SGIX_async_pixel + +#endif /* GL_SGIX_async_pixel */ + +#ifdef GL_SGIX_blend_alpha_minmax + +#endif /* GL_SGIX_blend_alpha_minmax */ + +#ifdef GL_SGIX_clipmap + +#endif /* GL_SGIX_clipmap */ + +#ifdef GL_SGIX_convolution_accuracy + +#endif /* GL_SGIX_convolution_accuracy */ + +#ifdef GL_SGIX_depth_texture + +#endif /* GL_SGIX_depth_texture */ + +#ifdef GL_SGIX_flush_raster + +static GLboolean _glewInit_GL_SGIX_flush_raster (GLEW_CONTEXT_ARG_DEF_INIT) +{ + GLboolean r = GL_FALSE; + + r = ((glFlushRasterSGIX = (PFNGLFLUSHRASTERSGIXPROC)glewGetProcAddress((const GLubyte*)"glFlushRasterSGIX")) == NULL) || r; + + return r; +} + +#endif /* GL_SGIX_flush_raster */ + +#ifdef GL_SGIX_fog_offset + +#endif /* GL_SGIX_fog_offset */ + +#ifdef GL_SGIX_fog_texture + +static GLboolean _glewInit_GL_SGIX_fog_texture (GLEW_CONTEXT_ARG_DEF_INIT) +{ + GLboolean r = GL_FALSE; + + r = ((glTextureFogSGIX = (PFNGLTEXTUREFOGSGIXPROC)glewGetProcAddress((const GLubyte*)"glTextureFogSGIX")) == NULL) || r; + + return r; +} + +#endif /* GL_SGIX_fog_texture */ + +#ifdef GL_SGIX_fragment_specular_lighting + +static GLboolean _glewInit_GL_SGIX_fragment_specular_lighting (GLEW_CONTEXT_ARG_DEF_INIT) +{ + GLboolean r = GL_FALSE; + + r = ((glFragmentColorMaterialSGIX = (PFNGLFRAGMENTCOLORMATERIALSGIXPROC)glewGetProcAddress((const GLubyte*)"glFragmentColorMaterialSGIX")) == NULL) || r; + r = ((glFragmentLightModelfSGIX = (PFNGLFRAGMENTLIGHTMODELFSGIXPROC)glewGetProcAddress((const GLubyte*)"glFragmentLightModelfSGIX")) == NULL) || r; + r = ((glFragmentLightModelfvSGIX = (PFNGLFRAGMENTLIGHTMODELFVSGIXPROC)glewGetProcAddress((const GLubyte*)"glFragmentLightModelfvSGIX")) == NULL) || r; + r = ((glFragmentLightModeliSGIX = (PFNGLFRAGMENTLIGHTMODELISGIXPROC)glewGetProcAddress((const GLubyte*)"glFragmentLightModeliSGIX")) == NULL) || r; + r = ((glFragmentLightModelivSGIX = (PFNGLFRAGMENTLIGHTMODELIVSGIXPROC)glewGetProcAddress((const GLubyte*)"glFragmentLightModelivSGIX")) == NULL) || r; + r = ((glFragmentLightfSGIX = (PFNGLFRAGMENTLIGHTFSGIXPROC)glewGetProcAddress((const GLubyte*)"glFragmentLightfSGIX")) == NULL) || r; + r = ((glFragmentLightfvSGIX = (PFNGLFRAGMENTLIGHTFVSGIXPROC)glewGetProcAddress((const GLubyte*)"glFragmentLightfvSGIX")) == NULL) || r; + r = ((glFragmentLightiSGIX = (PFNGLFRAGMENTLIGHTISGIXPROC)glewGetProcAddress((const GLubyte*)"glFragmentLightiSGIX")) == NULL) || r; + r = ((glFragmentLightivSGIX = (PFNGLFRAGMENTLIGHTIVSGIXPROC)glewGetProcAddress((const GLubyte*)"glFragmentLightivSGIX")) == NULL) || r; + r = ((glFragmentMaterialfSGIX = (PFNGLFRAGMENTMATERIALFSGIXPROC)glewGetProcAddress((const GLubyte*)"glFragmentMaterialfSGIX")) == NULL) || r; + r = ((glFragmentMaterialfvSGIX = (PFNGLFRAGMENTMATERIALFVSGIXPROC)glewGetProcAddress((const GLubyte*)"glFragmentMaterialfvSGIX")) == NULL) || r; + r = ((glFragmentMaterialiSGIX = (PFNGLFRAGMENTMATERIALISGIXPROC)glewGetProcAddress((const GLubyte*)"glFragmentMaterialiSGIX")) == NULL) || r; + r = ((glFragmentMaterialivSGIX = (PFNGLFRAGMENTMATERIALIVSGIXPROC)glewGetProcAddress((const GLubyte*)"glFragmentMaterialivSGIX")) == NULL) || r; + r = ((glGetFragmentLightfvSGIX = (PFNGLGETFRAGMENTLIGHTFVSGIXPROC)glewGetProcAddress((const GLubyte*)"glGetFragmentLightfvSGIX")) == NULL) || r; + r = ((glGetFragmentLightivSGIX = (PFNGLGETFRAGMENTLIGHTIVSGIXPROC)glewGetProcAddress((const GLubyte*)"glGetFragmentLightivSGIX")) == NULL) || r; + r = ((glGetFragmentMaterialfvSGIX = (PFNGLGETFRAGMENTMATERIALFVSGIXPROC)glewGetProcAddress((const GLubyte*)"glGetFragmentMaterialfvSGIX")) == NULL) || r; + r = ((glGetFragmentMaterialivSGIX = (PFNGLGETFRAGMENTMATERIALIVSGIXPROC)glewGetProcAddress((const GLubyte*)"glGetFragmentMaterialivSGIX")) == NULL) || r; + + return r; +} + +#endif /* GL_SGIX_fragment_specular_lighting */ + +#ifdef GL_SGIX_framezoom + +static GLboolean _glewInit_GL_SGIX_framezoom (GLEW_CONTEXT_ARG_DEF_INIT) +{ + GLboolean r = GL_FALSE; + + r = ((glFrameZoomSGIX = (PFNGLFRAMEZOOMSGIXPROC)glewGetProcAddress((const GLubyte*)"glFrameZoomSGIX")) == NULL) || r; + + return r; +} + +#endif /* GL_SGIX_framezoom */ + +#ifdef GL_SGIX_interlace + +#endif /* GL_SGIX_interlace */ + +#ifdef GL_SGIX_ir_instrument1 + +#endif /* GL_SGIX_ir_instrument1 */ + +#ifdef GL_SGIX_list_priority + +#endif /* GL_SGIX_list_priority */ + +#ifdef GL_SGIX_pixel_texture + +static GLboolean _glewInit_GL_SGIX_pixel_texture (GLEW_CONTEXT_ARG_DEF_INIT) +{ + GLboolean r = GL_FALSE; + + r = ((glPixelTexGenSGIX = (PFNGLPIXELTEXGENSGIXPROC)glewGetProcAddress((const GLubyte*)"glPixelTexGenSGIX")) == NULL) || r; + + return r; +} + +#endif /* GL_SGIX_pixel_texture */ + +#ifdef GL_SGIX_pixel_texture_bits + +#endif /* GL_SGIX_pixel_texture_bits */ + +#ifdef GL_SGIX_reference_plane + +static GLboolean _glewInit_GL_SGIX_reference_plane (GLEW_CONTEXT_ARG_DEF_INIT) +{ + GLboolean r = GL_FALSE; + + r = ((glReferencePlaneSGIX = (PFNGLREFERENCEPLANESGIXPROC)glewGetProcAddress((const GLubyte*)"glReferencePlaneSGIX")) == NULL) || r; + + return r; +} + +#endif /* GL_SGIX_reference_plane */ + +#ifdef GL_SGIX_resample + +#endif /* GL_SGIX_resample */ + +#ifdef GL_SGIX_shadow + +#endif /* GL_SGIX_shadow */ + +#ifdef GL_SGIX_shadow_ambient + +#endif /* GL_SGIX_shadow_ambient */ + +#ifdef GL_SGIX_sprite + +static GLboolean _glewInit_GL_SGIX_sprite (GLEW_CONTEXT_ARG_DEF_INIT) +{ + GLboolean r = GL_FALSE; + + r = ((glSpriteParameterfSGIX = (PFNGLSPRITEPARAMETERFSGIXPROC)glewGetProcAddress((const GLubyte*)"glSpriteParameterfSGIX")) == NULL) || r; + r = ((glSpriteParameterfvSGIX = (PFNGLSPRITEPARAMETERFVSGIXPROC)glewGetProcAddress((const GLubyte*)"glSpriteParameterfvSGIX")) == NULL) || r; + r = ((glSpriteParameteriSGIX = (PFNGLSPRITEPARAMETERISGIXPROC)glewGetProcAddress((const GLubyte*)"glSpriteParameteriSGIX")) == NULL) || r; + r = ((glSpriteParameterivSGIX = (PFNGLSPRITEPARAMETERIVSGIXPROC)glewGetProcAddress((const GLubyte*)"glSpriteParameterivSGIX")) == NULL) || r; + + return r; +} + +#endif /* GL_SGIX_sprite */ + +#ifdef GL_SGIX_tag_sample_buffer + +static GLboolean _glewInit_GL_SGIX_tag_sample_buffer (GLEW_CONTEXT_ARG_DEF_INIT) +{ + GLboolean r = GL_FALSE; + + r = ((glTagSampleBufferSGIX = (PFNGLTAGSAMPLEBUFFERSGIXPROC)glewGetProcAddress((const GLubyte*)"glTagSampleBufferSGIX")) == NULL) || r; + + return r; +} + +#endif /* GL_SGIX_tag_sample_buffer */ + +#ifdef GL_SGIX_texture_add_env + +#endif /* GL_SGIX_texture_add_env */ + +#ifdef GL_SGIX_texture_coordinate_clamp + +#endif /* GL_SGIX_texture_coordinate_clamp */ + +#ifdef GL_SGIX_texture_lod_bias + +#endif /* GL_SGIX_texture_lod_bias */ + +#ifdef GL_SGIX_texture_multi_buffer + +#endif /* GL_SGIX_texture_multi_buffer */ + +#ifdef GL_SGIX_texture_range + +#endif /* GL_SGIX_texture_range */ + +#ifdef GL_SGIX_texture_scale_bias + +#endif /* GL_SGIX_texture_scale_bias */ + +#ifdef GL_SGIX_vertex_preclip + +#endif /* GL_SGIX_vertex_preclip */ + +#ifdef GL_SGIX_vertex_preclip_hint + +#endif /* GL_SGIX_vertex_preclip_hint */ + +#ifdef GL_SGIX_ycrcb + +#endif /* GL_SGIX_ycrcb */ + +#ifdef GL_SGI_color_matrix + +#endif /* GL_SGI_color_matrix */ + +#ifdef GL_SGI_color_table + +static GLboolean _glewInit_GL_SGI_color_table (GLEW_CONTEXT_ARG_DEF_INIT) +{ + GLboolean r = GL_FALSE; + + r = ((glColorTableParameterfvSGI = (PFNGLCOLORTABLEPARAMETERFVSGIPROC)glewGetProcAddress((const GLubyte*)"glColorTableParameterfvSGI")) == NULL) || r; + r = ((glColorTableParameterivSGI = (PFNGLCOLORTABLEPARAMETERIVSGIPROC)glewGetProcAddress((const GLubyte*)"glColorTableParameterivSGI")) == NULL) || r; + r = ((glColorTableSGI = (PFNGLCOLORTABLESGIPROC)glewGetProcAddress((const GLubyte*)"glColorTableSGI")) == NULL) || r; + r = ((glCopyColorTableSGI = (PFNGLCOPYCOLORTABLESGIPROC)glewGetProcAddress((const GLubyte*)"glCopyColorTableSGI")) == NULL) || r; + r = ((glGetColorTableParameterfvSGI = (PFNGLGETCOLORTABLEPARAMETERFVSGIPROC)glewGetProcAddress((const GLubyte*)"glGetColorTableParameterfvSGI")) == NULL) || r; + r = ((glGetColorTableParameterivSGI = (PFNGLGETCOLORTABLEPARAMETERIVSGIPROC)glewGetProcAddress((const GLubyte*)"glGetColorTableParameterivSGI")) == NULL) || r; + r = ((glGetColorTableSGI = (PFNGLGETCOLORTABLESGIPROC)glewGetProcAddress((const GLubyte*)"glGetColorTableSGI")) == NULL) || r; + + return r; +} + +#endif /* GL_SGI_color_table */ + +#ifdef GL_SGI_texture_color_table + +#endif /* GL_SGI_texture_color_table */ + +#ifdef GL_SUNX_constant_data + +static GLboolean _glewInit_GL_SUNX_constant_data (GLEW_CONTEXT_ARG_DEF_INIT) +{ + GLboolean r = GL_FALSE; + + r = ((glFinishTextureSUNX = (PFNGLFINISHTEXTURESUNXPROC)glewGetProcAddress((const GLubyte*)"glFinishTextureSUNX")) == NULL) || r; + + return r; +} + +#endif /* GL_SUNX_constant_data */ + +#ifdef GL_SUN_convolution_border_modes + +#endif /* GL_SUN_convolution_border_modes */ + +#ifdef GL_SUN_global_alpha + +static GLboolean _glewInit_GL_SUN_global_alpha (GLEW_CONTEXT_ARG_DEF_INIT) +{ + GLboolean r = GL_FALSE; + + r = ((glGlobalAlphaFactorbSUN = (PFNGLGLOBALALPHAFACTORBSUNPROC)glewGetProcAddress((const GLubyte*)"glGlobalAlphaFactorbSUN")) == NULL) || r; + r = ((glGlobalAlphaFactordSUN = (PFNGLGLOBALALPHAFACTORDSUNPROC)glewGetProcAddress((const GLubyte*)"glGlobalAlphaFactordSUN")) == NULL) || r; + r = ((glGlobalAlphaFactorfSUN = (PFNGLGLOBALALPHAFACTORFSUNPROC)glewGetProcAddress((const GLubyte*)"glGlobalAlphaFactorfSUN")) == NULL) || r; + r = ((glGlobalAlphaFactoriSUN = (PFNGLGLOBALALPHAFACTORISUNPROC)glewGetProcAddress((const GLubyte*)"glGlobalAlphaFactoriSUN")) == NULL) || r; + r = ((glGlobalAlphaFactorsSUN = (PFNGLGLOBALALPHAFACTORSSUNPROC)glewGetProcAddress((const GLubyte*)"glGlobalAlphaFactorsSUN")) == NULL) || r; + r = ((glGlobalAlphaFactorubSUN = (PFNGLGLOBALALPHAFACTORUBSUNPROC)glewGetProcAddress((const GLubyte*)"glGlobalAlphaFactorubSUN")) == NULL) || r; + r = ((glGlobalAlphaFactoruiSUN = (PFNGLGLOBALALPHAFACTORUISUNPROC)glewGetProcAddress((const GLubyte*)"glGlobalAlphaFactoruiSUN")) == NULL) || r; + r = ((glGlobalAlphaFactorusSUN = (PFNGLGLOBALALPHAFACTORUSSUNPROC)glewGetProcAddress((const GLubyte*)"glGlobalAlphaFactorusSUN")) == NULL) || r; + + return r; +} + +#endif /* GL_SUN_global_alpha */ + +#ifdef GL_SUN_mesh_array + +#endif /* GL_SUN_mesh_array */ + +#ifdef GL_SUN_read_video_pixels + +static GLboolean _glewInit_GL_SUN_read_video_pixels (GLEW_CONTEXT_ARG_DEF_INIT) +{ + GLboolean r = GL_FALSE; + + r = ((glReadVideoPixelsSUN = (PFNGLREADVIDEOPIXELSSUNPROC)glewGetProcAddress((const GLubyte*)"glReadVideoPixelsSUN")) == NULL) || r; + + return r; +} + +#endif /* GL_SUN_read_video_pixels */ + +#ifdef GL_SUN_slice_accum + +#endif /* GL_SUN_slice_accum */ + +#ifdef GL_SUN_triangle_list + +static GLboolean _glewInit_GL_SUN_triangle_list (GLEW_CONTEXT_ARG_DEF_INIT) +{ + GLboolean r = GL_FALSE; + + r = ((glReplacementCodePointerSUN = (PFNGLREPLACEMENTCODEPOINTERSUNPROC)glewGetProcAddress((const GLubyte*)"glReplacementCodePointerSUN")) == NULL) || r; + r = ((glReplacementCodeubSUN = (PFNGLREPLACEMENTCODEUBSUNPROC)glewGetProcAddress((const GLubyte*)"glReplacementCodeubSUN")) == NULL) || r; + r = ((glReplacementCodeubvSUN = (PFNGLREPLACEMENTCODEUBVSUNPROC)glewGetProcAddress((const GLubyte*)"glReplacementCodeubvSUN")) == NULL) || r; + r = ((glReplacementCodeuiSUN = (PFNGLREPLACEMENTCODEUISUNPROC)glewGetProcAddress((const GLubyte*)"glReplacementCodeuiSUN")) == NULL) || r; + r = ((glReplacementCodeuivSUN = (PFNGLREPLACEMENTCODEUIVSUNPROC)glewGetProcAddress((const GLubyte*)"glReplacementCodeuivSUN")) == NULL) || r; + r = ((glReplacementCodeusSUN = (PFNGLREPLACEMENTCODEUSSUNPROC)glewGetProcAddress((const GLubyte*)"glReplacementCodeusSUN")) == NULL) || r; + r = ((glReplacementCodeusvSUN = (PFNGLREPLACEMENTCODEUSVSUNPROC)glewGetProcAddress((const GLubyte*)"glReplacementCodeusvSUN")) == NULL) || r; + + return r; +} + +#endif /* GL_SUN_triangle_list */ + +#ifdef GL_SUN_vertex + +static GLboolean _glewInit_GL_SUN_vertex (GLEW_CONTEXT_ARG_DEF_INIT) +{ + GLboolean r = GL_FALSE; + + r = ((glColor3fVertex3fSUN = (PFNGLCOLOR3FVERTEX3FSUNPROC)glewGetProcAddress((const GLubyte*)"glColor3fVertex3fSUN")) == NULL) || r; + r = ((glColor3fVertex3fvSUN = (PFNGLCOLOR3FVERTEX3FVSUNPROC)glewGetProcAddress((const GLubyte*)"glColor3fVertex3fvSUN")) == NULL) || r; + r = ((glColor4fNormal3fVertex3fSUN = (PFNGLCOLOR4FNORMAL3FVERTEX3FSUNPROC)glewGetProcAddress((const GLubyte*)"glColor4fNormal3fVertex3fSUN")) == NULL) || r; + r = ((glColor4fNormal3fVertex3fvSUN = (PFNGLCOLOR4FNORMAL3FVERTEX3FVSUNPROC)glewGetProcAddress((const GLubyte*)"glColor4fNormal3fVertex3fvSUN")) == NULL) || r; + r = ((glColor4ubVertex2fSUN = (PFNGLCOLOR4UBVERTEX2FSUNPROC)glewGetProcAddress((const GLubyte*)"glColor4ubVertex2fSUN")) == NULL) || r; + r = ((glColor4ubVertex2fvSUN = (PFNGLCOLOR4UBVERTEX2FVSUNPROC)glewGetProcAddress((const GLubyte*)"glColor4ubVertex2fvSUN")) == NULL) || r; + r = ((glColor4ubVertex3fSUN = (PFNGLCOLOR4UBVERTEX3FSUNPROC)glewGetProcAddress((const GLubyte*)"glColor4ubVertex3fSUN")) == NULL) || r; + r = ((glColor4ubVertex3fvSUN = (PFNGLCOLOR4UBVERTEX3FVSUNPROC)glewGetProcAddress((const GLubyte*)"glColor4ubVertex3fvSUN")) == NULL) || r; + r = ((glNormal3fVertex3fSUN = (PFNGLNORMAL3FVERTEX3FSUNPROC)glewGetProcAddress((const GLubyte*)"glNormal3fVertex3fSUN")) == NULL) || r; + r = ((glNormal3fVertex3fvSUN = (PFNGLNORMAL3FVERTEX3FVSUNPROC)glewGetProcAddress((const GLubyte*)"glNormal3fVertex3fvSUN")) == NULL) || r; + r = ((glReplacementCodeuiColor3fVertex3fSUN = (PFNGLREPLACEMENTCODEUICOLOR3FVERTEX3FSUNPROC)glewGetProcAddress((const GLubyte*)"glReplacementCodeuiColor3fVertex3fSUN")) == NULL) || r; + r = ((glReplacementCodeuiColor3fVertex3fvSUN = (PFNGLREPLACEMENTCODEUICOLOR3FVERTEX3FVSUNPROC)glewGetProcAddress((const GLubyte*)"glReplacementCodeuiColor3fVertex3fvSUN")) == NULL) || r; + r = ((glReplacementCodeuiColor4fNormal3fVertex3fSUN = (PFNGLREPLACEMENTCODEUICOLOR4FNORMAL3FVERTEX3FSUNPROC)glewGetProcAddress((const GLubyte*)"glReplacementCodeuiColor4fNormal3fVertex3fSUN")) == NULL) || r; + r = ((glReplacementCodeuiColor4fNormal3fVertex3fvSUN = (PFNGLREPLACEMENTCODEUICOLOR4FNORMAL3FVERTEX3FVSUNPROC)glewGetProcAddress((const GLubyte*)"glReplacementCodeuiColor4fNormal3fVertex3fvSUN")) == NULL) || r; + r = ((glReplacementCodeuiColor4ubVertex3fSUN = (PFNGLREPLACEMENTCODEUICOLOR4UBVERTEX3FSUNPROC)glewGetProcAddress((const GLubyte*)"glReplacementCodeuiColor4ubVertex3fSUN")) == NULL) || r; + r = ((glReplacementCodeuiColor4ubVertex3fvSUN = (PFNGLREPLACEMENTCODEUICOLOR4UBVERTEX3FVSUNPROC)glewGetProcAddress((const GLubyte*)"glReplacementCodeuiColor4ubVertex3fvSUN")) == NULL) || r; + r = ((glReplacementCodeuiNormal3fVertex3fSUN = (PFNGLREPLACEMENTCODEUINORMAL3FVERTEX3FSUNPROC)glewGetProcAddress((const GLubyte*)"glReplacementCodeuiNormal3fVertex3fSUN")) == NULL) || r; + r = ((glReplacementCodeuiNormal3fVertex3fvSUN = (PFNGLREPLACEMENTCODEUINORMAL3FVERTEX3FVSUNPROC)glewGetProcAddress((const GLubyte*)"glReplacementCodeuiNormal3fVertex3fvSUN")) == NULL) || r; + r = ((glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fSUN = (PFNGLREPLACEMENTCODEUITEXCOORD2FCOLOR4FNORMAL3FVERTEX3FSUNPROC)glewGetProcAddress((const GLubyte*)"glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fSUN")) == NULL) || r; + r = ((glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN = (PFNGLREPLACEMENTCODEUITEXCOORD2FCOLOR4FNORMAL3FVERTEX3FVSUNPROC)glewGetProcAddress((const GLubyte*)"glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN")) == NULL) || r; + r = ((glReplacementCodeuiTexCoord2fNormal3fVertex3fSUN = (PFNGLREPLACEMENTCODEUITEXCOORD2FNORMAL3FVERTEX3FSUNPROC)glewGetProcAddress((const GLubyte*)"glReplacementCodeuiTexCoord2fNormal3fVertex3fSUN")) == NULL) || r; + r = ((glReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN = (PFNGLREPLACEMENTCODEUITEXCOORD2FNORMAL3FVERTEX3FVSUNPROC)glewGetProcAddress((const GLubyte*)"glReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN")) == NULL) || r; + r = ((glReplacementCodeuiTexCoord2fVertex3fSUN = (PFNGLREPLACEMENTCODEUITEXCOORD2FVERTEX3FSUNPROC)glewGetProcAddress((const GLubyte*)"glReplacementCodeuiTexCoord2fVertex3fSUN")) == NULL) || r; + r = ((glReplacementCodeuiTexCoord2fVertex3fvSUN = (PFNGLREPLACEMENTCODEUITEXCOORD2FVERTEX3FVSUNPROC)glewGetProcAddress((const GLubyte*)"glReplacementCodeuiTexCoord2fVertex3fvSUN")) == NULL) || r; + r = ((glReplacementCodeuiVertex3fSUN = (PFNGLREPLACEMENTCODEUIVERTEX3FSUNPROC)glewGetProcAddress((const GLubyte*)"glReplacementCodeuiVertex3fSUN")) == NULL) || r; + r = ((glReplacementCodeuiVertex3fvSUN = (PFNGLREPLACEMENTCODEUIVERTEX3FVSUNPROC)glewGetProcAddress((const GLubyte*)"glReplacementCodeuiVertex3fvSUN")) == NULL) || r; + r = ((glTexCoord2fColor3fVertex3fSUN = (PFNGLTEXCOORD2FCOLOR3FVERTEX3FSUNPROC)glewGetProcAddress((const GLubyte*)"glTexCoord2fColor3fVertex3fSUN")) == NULL) || r; + r = ((glTexCoord2fColor3fVertex3fvSUN = (PFNGLTEXCOORD2FCOLOR3FVERTEX3FVSUNPROC)glewGetProcAddress((const GLubyte*)"glTexCoord2fColor3fVertex3fvSUN")) == NULL) || r; + r = ((glTexCoord2fColor4fNormal3fVertex3fSUN = (PFNGLTEXCOORD2FCOLOR4FNORMAL3FVERTEX3FSUNPROC)glewGetProcAddress((const GLubyte*)"glTexCoord2fColor4fNormal3fVertex3fSUN")) == NULL) || r; + r = ((glTexCoord2fColor4fNormal3fVertex3fvSUN = (PFNGLTEXCOORD2FCOLOR4FNORMAL3FVERTEX3FVSUNPROC)glewGetProcAddress((const GLubyte*)"glTexCoord2fColor4fNormal3fVertex3fvSUN")) == NULL) || r; + r = ((glTexCoord2fColor4ubVertex3fSUN = (PFNGLTEXCOORD2FCOLOR4UBVERTEX3FSUNPROC)glewGetProcAddress((const GLubyte*)"glTexCoord2fColor4ubVertex3fSUN")) == NULL) || r; + r = ((glTexCoord2fColor4ubVertex3fvSUN = (PFNGLTEXCOORD2FCOLOR4UBVERTEX3FVSUNPROC)glewGetProcAddress((const GLubyte*)"glTexCoord2fColor4ubVertex3fvSUN")) == NULL) || r; + r = ((glTexCoord2fNormal3fVertex3fSUN = (PFNGLTEXCOORD2FNORMAL3FVERTEX3FSUNPROC)glewGetProcAddress((const GLubyte*)"glTexCoord2fNormal3fVertex3fSUN")) == NULL) || r; + r = ((glTexCoord2fNormal3fVertex3fvSUN = (PFNGLTEXCOORD2FNORMAL3FVERTEX3FVSUNPROC)glewGetProcAddress((const GLubyte*)"glTexCoord2fNormal3fVertex3fvSUN")) == NULL) || r; + r = ((glTexCoord2fVertex3fSUN = (PFNGLTEXCOORD2FVERTEX3FSUNPROC)glewGetProcAddress((const GLubyte*)"glTexCoord2fVertex3fSUN")) == NULL) || r; + r = ((glTexCoord2fVertex3fvSUN = (PFNGLTEXCOORD2FVERTEX3FVSUNPROC)glewGetProcAddress((const GLubyte*)"glTexCoord2fVertex3fvSUN")) == NULL) || r; + r = ((glTexCoord4fColor4fNormal3fVertex4fSUN = (PFNGLTEXCOORD4FCOLOR4FNORMAL3FVERTEX4FSUNPROC)glewGetProcAddress((const GLubyte*)"glTexCoord4fColor4fNormal3fVertex4fSUN")) == NULL) || r; + r = ((glTexCoord4fColor4fNormal3fVertex4fvSUN = (PFNGLTEXCOORD4FCOLOR4FNORMAL3FVERTEX4FVSUNPROC)glewGetProcAddress((const GLubyte*)"glTexCoord4fColor4fNormal3fVertex4fvSUN")) == NULL) || r; + r = ((glTexCoord4fVertex4fSUN = (PFNGLTEXCOORD4FVERTEX4FSUNPROC)glewGetProcAddress((const GLubyte*)"glTexCoord4fVertex4fSUN")) == NULL) || r; + r = ((glTexCoord4fVertex4fvSUN = (PFNGLTEXCOORD4FVERTEX4FVSUNPROC)glewGetProcAddress((const GLubyte*)"glTexCoord4fVertex4fvSUN")) == NULL) || r; + + return r; +} + +#endif /* GL_SUN_vertex */ + +#ifdef GL_WIN_phong_shading + +#endif /* GL_WIN_phong_shading */ + +#ifdef GL_WIN_specular_fog + +#endif /* GL_WIN_specular_fog */ + +#ifdef GL_WIN_swap_hint + +static GLboolean _glewInit_GL_WIN_swap_hint (GLEW_CONTEXT_ARG_DEF_INIT) +{ + GLboolean r = GL_FALSE; + + r = ((glAddSwapHintRectWIN = (PFNGLADDSWAPHINTRECTWINPROC)glewGetProcAddress((const GLubyte*)"glAddSwapHintRectWIN")) == NULL) || r; + + return r; +} + +#endif /* GL_WIN_swap_hint */ + +/* ------------------------------------------------------------------------- */ + +/* + * Search for name in the extensions string. Use of strstr() + * is not sufficient because extension names can be prefixes of + * other extension names. Could use strtok() but the constant + * string returned by glGetString might be in read-only memory. + */ +GLboolean glewGetExtension (const char* name) +{ + GLubyte* p; + GLubyte* end; + GLuint len = _glewStrLen((const GLubyte*)name); + p = (GLubyte*)glGetString(GL_EXTENSIONS); + if (0 == p) return GL_FALSE; + end = p + _glewStrLen(p); + while (p < end) + { + GLuint n = _glewStrCLen(p, ' '); + if (len == n && _glewStrSame((const GLubyte*)name, p, n)) return GL_TRUE; + p += n+1; + } + return GL_FALSE; +} + +/* ------------------------------------------------------------------------- */ + +#ifndef GLEW_MX +static +#endif +GLenum glewContextInit (GLEW_CONTEXT_ARG_DEF_LIST) +{ + const GLubyte* s; + GLuint dot, major, minor; + /* query opengl version */ + s = glGetString(GL_VERSION); + dot = _glewStrCLen(s, '.'); + major = dot-1; + minor = dot+1; + if (dot == 0 || s[minor] == '\0') + return GLEW_ERROR_NO_GL_VERSION; + if (s[major] == '1' && s[minor] == '0') + { + return GLEW_ERROR_GL_VERSION_10_ONLY; + } + else + { + CONST_CAST(GLEW_VERSION_1_1) = GL_TRUE; + if (s[major] >= '2') + { + CONST_CAST(GLEW_VERSION_1_2) = GL_TRUE; + CONST_CAST(GLEW_VERSION_1_3) = GL_TRUE; + CONST_CAST(GLEW_VERSION_1_4) = GL_TRUE; + CONST_CAST(GLEW_VERSION_1_5) = GL_TRUE; + CONST_CAST(GLEW_VERSION_2_0) = GL_TRUE; + if (s[minor] >= '1') + { + CONST_CAST(GLEW_VERSION_2_1) = GL_TRUE; + } + } + else + { + if (s[minor] >= '5') + { + CONST_CAST(GLEW_VERSION_1_2) = GL_TRUE; + CONST_CAST(GLEW_VERSION_1_3) = GL_TRUE; + CONST_CAST(GLEW_VERSION_1_4) = GL_TRUE; + CONST_CAST(GLEW_VERSION_1_5) = GL_TRUE; + CONST_CAST(GLEW_VERSION_2_0) = GL_FALSE; + CONST_CAST(GLEW_VERSION_2_1) = GL_FALSE; + } + if (s[minor] == '4') + { + CONST_CAST(GLEW_VERSION_1_2) = GL_TRUE; + CONST_CAST(GLEW_VERSION_1_3) = GL_TRUE; + CONST_CAST(GLEW_VERSION_1_4) = GL_TRUE; + CONST_CAST(GLEW_VERSION_1_5) = GL_FALSE; + CONST_CAST(GLEW_VERSION_2_0) = GL_FALSE; + CONST_CAST(GLEW_VERSION_2_1) = GL_FALSE; + } + if (s[minor] == '3') + { + CONST_CAST(GLEW_VERSION_1_2) = GL_TRUE; + CONST_CAST(GLEW_VERSION_1_3) = GL_TRUE; + CONST_CAST(GLEW_VERSION_1_4) = GL_FALSE; + CONST_CAST(GLEW_VERSION_1_5) = GL_FALSE; + CONST_CAST(GLEW_VERSION_2_0) = GL_FALSE; + CONST_CAST(GLEW_VERSION_2_1) = GL_FALSE; + } + if (s[minor] == '2') + { + CONST_CAST(GLEW_VERSION_1_2) = GL_TRUE; + CONST_CAST(GLEW_VERSION_1_3) = GL_FALSE; + CONST_CAST(GLEW_VERSION_1_4) = GL_FALSE; + CONST_CAST(GLEW_VERSION_1_5) = GL_FALSE; + CONST_CAST(GLEW_VERSION_2_0) = GL_FALSE; + CONST_CAST(GLEW_VERSION_2_1) = GL_FALSE; + } + if (s[minor] < '2') + { + CONST_CAST(GLEW_VERSION_1_2) = GL_FALSE; + CONST_CAST(GLEW_VERSION_1_3) = GL_FALSE; + CONST_CAST(GLEW_VERSION_1_4) = GL_FALSE; + CONST_CAST(GLEW_VERSION_1_5) = GL_FALSE; + CONST_CAST(GLEW_VERSION_2_0) = GL_FALSE; + CONST_CAST(GLEW_VERSION_2_1) = GL_FALSE; + } + } + } + /* initialize extensions */ +#ifdef GL_VERSION_1_2 + if (glewExperimental || GLEW_VERSION_1_2) CONST_CAST(GLEW_VERSION_1_2) = !_glewInit_GL_VERSION_1_2(GLEW_CONTEXT_ARG_VAR_INIT); +#endif /* GL_VERSION_1_2 */ +#ifdef GL_VERSION_1_3 + if (glewExperimental || GLEW_VERSION_1_3) CONST_CAST(GLEW_VERSION_1_3) = !_glewInit_GL_VERSION_1_3(GLEW_CONTEXT_ARG_VAR_INIT); +#endif /* GL_VERSION_1_3 */ +#ifdef GL_VERSION_1_4 + if (glewExperimental || GLEW_VERSION_1_4) CONST_CAST(GLEW_VERSION_1_4) = !_glewInit_GL_VERSION_1_4(GLEW_CONTEXT_ARG_VAR_INIT); +#endif /* GL_VERSION_1_4 */ +#ifdef GL_VERSION_1_5 + if (glewExperimental || GLEW_VERSION_1_5) CONST_CAST(GLEW_VERSION_1_5) = !_glewInit_GL_VERSION_1_5(GLEW_CONTEXT_ARG_VAR_INIT); +#endif /* GL_VERSION_1_5 */ +#ifdef GL_VERSION_2_0 + if (glewExperimental || GLEW_VERSION_2_0) CONST_CAST(GLEW_VERSION_2_0) = !_glewInit_GL_VERSION_2_0(GLEW_CONTEXT_ARG_VAR_INIT); +#endif /* GL_VERSION_2_0 */ +#ifdef GL_VERSION_2_1 + if (glewExperimental || GLEW_VERSION_2_1) CONST_CAST(GLEW_VERSION_2_1) = !_glewInit_GL_VERSION_2_1(GLEW_CONTEXT_ARG_VAR_INIT); +#endif /* GL_VERSION_2_1 */ +#ifdef GL_VERSION_3_0 + if (glewExperimental || GLEW_VERSION_3_0) CONST_CAST(GLEW_VERSION_3_0) = !_glewInit_GL_VERSION_3_0(GLEW_CONTEXT_ARG_VAR_INIT); +#endif /* GL_VERSION_3_0 */ +#ifdef GL_3DFX_multisample + CONST_CAST(GLEW_3DFX_multisample) = glewGetExtension("GL_3DFX_multisample"); +#endif /* GL_3DFX_multisample */ +#ifdef GL_3DFX_tbuffer + CONST_CAST(GLEW_3DFX_tbuffer) = glewGetExtension("GL_3DFX_tbuffer"); + if (glewExperimental || GLEW_3DFX_tbuffer) CONST_CAST(GLEW_3DFX_tbuffer) = !_glewInit_GL_3DFX_tbuffer(GLEW_CONTEXT_ARG_VAR_INIT); +#endif /* GL_3DFX_tbuffer */ +#ifdef GL_3DFX_texture_compression_FXT1 + CONST_CAST(GLEW_3DFX_texture_compression_FXT1) = glewGetExtension("GL_3DFX_texture_compression_FXT1"); +#endif /* GL_3DFX_texture_compression_FXT1 */ +#ifdef GL_APPLE_client_storage + CONST_CAST(GLEW_APPLE_client_storage) = glewGetExtension("GL_APPLE_client_storage"); +#endif /* GL_APPLE_client_storage */ +#ifdef GL_APPLE_element_array + CONST_CAST(GLEW_APPLE_element_array) = glewGetExtension("GL_APPLE_element_array"); + if (glewExperimental || GLEW_APPLE_element_array) CONST_CAST(GLEW_APPLE_element_array) = !_glewInit_GL_APPLE_element_array(GLEW_CONTEXT_ARG_VAR_INIT); +#endif /* GL_APPLE_element_array */ +#ifdef GL_APPLE_fence + CONST_CAST(GLEW_APPLE_fence) = glewGetExtension("GL_APPLE_fence"); + if (glewExperimental || GLEW_APPLE_fence) CONST_CAST(GLEW_APPLE_fence) = !_glewInit_GL_APPLE_fence(GLEW_CONTEXT_ARG_VAR_INIT); +#endif /* GL_APPLE_fence */ +#ifdef GL_APPLE_float_pixels + CONST_CAST(GLEW_APPLE_float_pixels) = glewGetExtension("GL_APPLE_float_pixels"); +#endif /* GL_APPLE_float_pixels */ +#ifdef GL_APPLE_flush_buffer_range + CONST_CAST(GLEW_APPLE_flush_buffer_range) = glewGetExtension("GL_APPLE_flush_buffer_range"); + if (glewExperimental || GLEW_APPLE_flush_buffer_range) CONST_CAST(GLEW_APPLE_flush_buffer_range) = !_glewInit_GL_APPLE_flush_buffer_range(GLEW_CONTEXT_ARG_VAR_INIT); +#endif /* GL_APPLE_flush_buffer_range */ +#ifdef GL_APPLE_pixel_buffer + CONST_CAST(GLEW_APPLE_pixel_buffer) = glewGetExtension("GL_APPLE_pixel_buffer"); +#endif /* GL_APPLE_pixel_buffer */ +#ifdef GL_APPLE_specular_vector + CONST_CAST(GLEW_APPLE_specular_vector) = glewGetExtension("GL_APPLE_specular_vector"); +#endif /* GL_APPLE_specular_vector */ +#ifdef GL_APPLE_texture_range + CONST_CAST(GLEW_APPLE_texture_range) = glewGetExtension("GL_APPLE_texture_range"); + if (glewExperimental || GLEW_APPLE_texture_range) CONST_CAST(GLEW_APPLE_texture_range) = !_glewInit_GL_APPLE_texture_range(GLEW_CONTEXT_ARG_VAR_INIT); +#endif /* GL_APPLE_texture_range */ +#ifdef GL_APPLE_transform_hint + CONST_CAST(GLEW_APPLE_transform_hint) = glewGetExtension("GL_APPLE_transform_hint"); +#endif /* GL_APPLE_transform_hint */ +#ifdef GL_APPLE_vertex_array_object + CONST_CAST(GLEW_APPLE_vertex_array_object) = glewGetExtension("GL_APPLE_vertex_array_object"); + if (glewExperimental || GLEW_APPLE_vertex_array_object) CONST_CAST(GLEW_APPLE_vertex_array_object) = !_glewInit_GL_APPLE_vertex_array_object(GLEW_CONTEXT_ARG_VAR_INIT); +#endif /* GL_APPLE_vertex_array_object */ +#ifdef GL_APPLE_vertex_array_range + CONST_CAST(GLEW_APPLE_vertex_array_range) = glewGetExtension("GL_APPLE_vertex_array_range"); + if (glewExperimental || GLEW_APPLE_vertex_array_range) CONST_CAST(GLEW_APPLE_vertex_array_range) = !_glewInit_GL_APPLE_vertex_array_range(GLEW_CONTEXT_ARG_VAR_INIT); +#endif /* GL_APPLE_vertex_array_range */ +#ifdef GL_APPLE_ycbcr_422 + CONST_CAST(GLEW_APPLE_ycbcr_422) = glewGetExtension("GL_APPLE_ycbcr_422"); +#endif /* GL_APPLE_ycbcr_422 */ +#ifdef GL_ARB_color_buffer_float + CONST_CAST(GLEW_ARB_color_buffer_float) = glewGetExtension("GL_ARB_color_buffer_float"); + if (glewExperimental || GLEW_ARB_color_buffer_float) CONST_CAST(GLEW_ARB_color_buffer_float) = !_glewInit_GL_ARB_color_buffer_float(GLEW_CONTEXT_ARG_VAR_INIT); +#endif /* GL_ARB_color_buffer_float */ +#ifdef GL_ARB_depth_buffer_float + CONST_CAST(GLEW_ARB_depth_buffer_float) = glewGetExtension("GL_ARB_depth_buffer_float"); +#endif /* GL_ARB_depth_buffer_float */ +#ifdef GL_ARB_depth_texture + CONST_CAST(GLEW_ARB_depth_texture) = glewGetExtension("GL_ARB_depth_texture"); +#endif /* GL_ARB_depth_texture */ +#ifdef GL_ARB_draw_buffers + CONST_CAST(GLEW_ARB_draw_buffers) = glewGetExtension("GL_ARB_draw_buffers"); + if (glewExperimental || GLEW_ARB_draw_buffers) CONST_CAST(GLEW_ARB_draw_buffers) = !_glewInit_GL_ARB_draw_buffers(GLEW_CONTEXT_ARG_VAR_INIT); +#endif /* GL_ARB_draw_buffers */ +#ifdef GL_ARB_draw_instanced + CONST_CAST(GLEW_ARB_draw_instanced) = glewGetExtension("GL_ARB_draw_instanced"); + if (glewExperimental || GLEW_ARB_draw_instanced) CONST_CAST(GLEW_ARB_draw_instanced) = !_glewInit_GL_ARB_draw_instanced(GLEW_CONTEXT_ARG_VAR_INIT); +#endif /* GL_ARB_draw_instanced */ +#ifdef GL_ARB_fragment_program + CONST_CAST(GLEW_ARB_fragment_program) = glewGetExtension("GL_ARB_fragment_program"); +#endif /* GL_ARB_fragment_program */ +#ifdef GL_ARB_fragment_program_shadow + CONST_CAST(GLEW_ARB_fragment_program_shadow) = glewGetExtension("GL_ARB_fragment_program_shadow"); +#endif /* GL_ARB_fragment_program_shadow */ +#ifdef GL_ARB_fragment_shader + CONST_CAST(GLEW_ARB_fragment_shader) = glewGetExtension("GL_ARB_fragment_shader"); +#endif /* GL_ARB_fragment_shader */ +#ifdef GL_ARB_framebuffer_object + CONST_CAST(GLEW_ARB_framebuffer_object) = glewGetExtension("GL_ARB_framebuffer_object"); + if (glewExperimental || GLEW_ARB_framebuffer_object) CONST_CAST(GLEW_ARB_framebuffer_object) = !_glewInit_GL_ARB_framebuffer_object(GLEW_CONTEXT_ARG_VAR_INIT); +#endif /* GL_ARB_framebuffer_object */ +#ifdef GL_ARB_framebuffer_sRGB + CONST_CAST(GLEW_ARB_framebuffer_sRGB) = glewGetExtension("GL_ARB_framebuffer_sRGB"); +#endif /* GL_ARB_framebuffer_sRGB */ +#ifdef GL_ARB_geometry_shader4 + CONST_CAST(GLEW_ARB_geometry_shader4) = glewGetExtension("GL_ARB_geometry_shader4"); + if (glewExperimental || GLEW_ARB_geometry_shader4) CONST_CAST(GLEW_ARB_geometry_shader4) = !_glewInit_GL_ARB_geometry_shader4(GLEW_CONTEXT_ARG_VAR_INIT); +#endif /* GL_ARB_geometry_shader4 */ +#ifdef GL_ARB_half_float_pixel + CONST_CAST(GLEW_ARB_half_float_pixel) = glewGetExtension("GL_ARB_half_float_pixel"); +#endif /* GL_ARB_half_float_pixel */ +#ifdef GL_ARB_half_float_vertex + CONST_CAST(GLEW_ARB_half_float_vertex) = glewGetExtension("GL_ARB_half_float_vertex"); +#endif /* GL_ARB_half_float_vertex */ +#ifdef GL_ARB_imaging + CONST_CAST(GLEW_ARB_imaging) = glewGetExtension("GL_ARB_imaging"); + if (glewExperimental || GLEW_ARB_imaging) CONST_CAST(GLEW_ARB_imaging) = !_glewInit_GL_ARB_imaging(GLEW_CONTEXT_ARG_VAR_INIT); +#endif /* GL_ARB_imaging */ +#ifdef GL_ARB_instanced_arrays + CONST_CAST(GLEW_ARB_instanced_arrays) = glewGetExtension("GL_ARB_instanced_arrays"); + if (glewExperimental || GLEW_ARB_instanced_arrays) CONST_CAST(GLEW_ARB_instanced_arrays) = !_glewInit_GL_ARB_instanced_arrays(GLEW_CONTEXT_ARG_VAR_INIT); +#endif /* GL_ARB_instanced_arrays */ +#ifdef GL_ARB_map_buffer_range + CONST_CAST(GLEW_ARB_map_buffer_range) = glewGetExtension("GL_ARB_map_buffer_range"); + if (glewExperimental || GLEW_ARB_map_buffer_range) CONST_CAST(GLEW_ARB_map_buffer_range) = !_glewInit_GL_ARB_map_buffer_range(GLEW_CONTEXT_ARG_VAR_INIT); +#endif /* GL_ARB_map_buffer_range */ +#ifdef GL_ARB_matrix_palette + CONST_CAST(GLEW_ARB_matrix_palette) = glewGetExtension("GL_ARB_matrix_palette"); + if (glewExperimental || GLEW_ARB_matrix_palette) CONST_CAST(GLEW_ARB_matrix_palette) = !_glewInit_GL_ARB_matrix_palette(GLEW_CONTEXT_ARG_VAR_INIT); +#endif /* GL_ARB_matrix_palette */ +#ifdef GL_ARB_multisample + CONST_CAST(GLEW_ARB_multisample) = glewGetExtension("GL_ARB_multisample"); + if (glewExperimental || GLEW_ARB_multisample) CONST_CAST(GLEW_ARB_multisample) = !_glewInit_GL_ARB_multisample(GLEW_CONTEXT_ARG_VAR_INIT); +#endif /* GL_ARB_multisample */ +#ifdef GL_ARB_multitexture + CONST_CAST(GLEW_ARB_multitexture) = glewGetExtension("GL_ARB_multitexture"); + if (glewExperimental || GLEW_ARB_multitexture) CONST_CAST(GLEW_ARB_multitexture) = !_glewInit_GL_ARB_multitexture(GLEW_CONTEXT_ARG_VAR_INIT); +#endif /* GL_ARB_multitexture */ +#ifdef GL_ARB_occlusion_query + CONST_CAST(GLEW_ARB_occlusion_query) = glewGetExtension("GL_ARB_occlusion_query"); + if (glewExperimental || GLEW_ARB_occlusion_query) CONST_CAST(GLEW_ARB_occlusion_query) = !_glewInit_GL_ARB_occlusion_query(GLEW_CONTEXT_ARG_VAR_INIT); +#endif /* GL_ARB_occlusion_query */ +#ifdef GL_ARB_pixel_buffer_object + CONST_CAST(GLEW_ARB_pixel_buffer_object) = glewGetExtension("GL_ARB_pixel_buffer_object"); +#endif /* GL_ARB_pixel_buffer_object */ +#ifdef GL_ARB_point_parameters + CONST_CAST(GLEW_ARB_point_parameters) = glewGetExtension("GL_ARB_point_parameters"); + if (glewExperimental || GLEW_ARB_point_parameters) CONST_CAST(GLEW_ARB_point_parameters) = !_glewInit_GL_ARB_point_parameters(GLEW_CONTEXT_ARG_VAR_INIT); +#endif /* GL_ARB_point_parameters */ +#ifdef GL_ARB_point_sprite + CONST_CAST(GLEW_ARB_point_sprite) = glewGetExtension("GL_ARB_point_sprite"); +#endif /* GL_ARB_point_sprite */ +#ifdef GL_ARB_shader_objects + CONST_CAST(GLEW_ARB_shader_objects) = glewGetExtension("GL_ARB_shader_objects"); + if (glewExperimental || GLEW_ARB_shader_objects) CONST_CAST(GLEW_ARB_shader_objects) = !_glewInit_GL_ARB_shader_objects(GLEW_CONTEXT_ARG_VAR_INIT); +#endif /* GL_ARB_shader_objects */ +#ifdef GL_ARB_shading_language_100 + CONST_CAST(GLEW_ARB_shading_language_100) = glewGetExtension("GL_ARB_shading_language_100"); +#endif /* GL_ARB_shading_language_100 */ +#ifdef GL_ARB_shadow + CONST_CAST(GLEW_ARB_shadow) = glewGetExtension("GL_ARB_shadow"); +#endif /* GL_ARB_shadow */ +#ifdef GL_ARB_shadow_ambient + CONST_CAST(GLEW_ARB_shadow_ambient) = glewGetExtension("GL_ARB_shadow_ambient"); +#endif /* GL_ARB_shadow_ambient */ +#ifdef GL_ARB_texture_border_clamp + CONST_CAST(GLEW_ARB_texture_border_clamp) = glewGetExtension("GL_ARB_texture_border_clamp"); +#endif /* GL_ARB_texture_border_clamp */ +#ifdef GL_ARB_texture_buffer_object + CONST_CAST(GLEW_ARB_texture_buffer_object) = glewGetExtension("GL_ARB_texture_buffer_object"); + if (glewExperimental || GLEW_ARB_texture_buffer_object) CONST_CAST(GLEW_ARB_texture_buffer_object) = !_glewInit_GL_ARB_texture_buffer_object(GLEW_CONTEXT_ARG_VAR_INIT); +#endif /* GL_ARB_texture_buffer_object */ +#ifdef GL_ARB_texture_compression + CONST_CAST(GLEW_ARB_texture_compression) = glewGetExtension("GL_ARB_texture_compression"); + if (glewExperimental || GLEW_ARB_texture_compression) CONST_CAST(GLEW_ARB_texture_compression) = !_glewInit_GL_ARB_texture_compression(GLEW_CONTEXT_ARG_VAR_INIT); +#endif /* GL_ARB_texture_compression */ +#ifdef GL_ARB_texture_compression_rgtc + CONST_CAST(GLEW_ARB_texture_compression_rgtc) = glewGetExtension("GL_ARB_texture_compression_rgtc"); +#endif /* GL_ARB_texture_compression_rgtc */ +#ifdef GL_ARB_texture_cube_map + CONST_CAST(GLEW_ARB_texture_cube_map) = glewGetExtension("GL_ARB_texture_cube_map"); +#endif /* GL_ARB_texture_cube_map */ +#ifdef GL_ARB_texture_env_add + CONST_CAST(GLEW_ARB_texture_env_add) = glewGetExtension("GL_ARB_texture_env_add"); +#endif /* GL_ARB_texture_env_add */ +#ifdef GL_ARB_texture_env_combine + CONST_CAST(GLEW_ARB_texture_env_combine) = glewGetExtension("GL_ARB_texture_env_combine"); +#endif /* GL_ARB_texture_env_combine */ +#ifdef GL_ARB_texture_env_crossbar + CONST_CAST(GLEW_ARB_texture_env_crossbar) = glewGetExtension("GL_ARB_texture_env_crossbar"); +#endif /* GL_ARB_texture_env_crossbar */ +#ifdef GL_ARB_texture_env_dot3 + CONST_CAST(GLEW_ARB_texture_env_dot3) = glewGetExtension("GL_ARB_texture_env_dot3"); +#endif /* GL_ARB_texture_env_dot3 */ +#ifdef GL_ARB_texture_float + CONST_CAST(GLEW_ARB_texture_float) = glewGetExtension("GL_ARB_texture_float"); +#endif /* GL_ARB_texture_float */ +#ifdef GL_ARB_texture_mirrored_repeat + CONST_CAST(GLEW_ARB_texture_mirrored_repeat) = glewGetExtension("GL_ARB_texture_mirrored_repeat"); +#endif /* GL_ARB_texture_mirrored_repeat */ +#ifdef GL_ARB_texture_non_power_of_two + CONST_CAST(GLEW_ARB_texture_non_power_of_two) = glewGetExtension("GL_ARB_texture_non_power_of_two"); +#endif /* GL_ARB_texture_non_power_of_two */ +#ifdef GL_ARB_texture_rectangle + CONST_CAST(GLEW_ARB_texture_rectangle) = glewGetExtension("GL_ARB_texture_rectangle"); +#endif /* GL_ARB_texture_rectangle */ +#ifdef GL_ARB_texture_rg + CONST_CAST(GLEW_ARB_texture_rg) = glewGetExtension("GL_ARB_texture_rg"); +#endif /* GL_ARB_texture_rg */ +#ifdef GL_ARB_transpose_matrix + CONST_CAST(GLEW_ARB_transpose_matrix) = glewGetExtension("GL_ARB_transpose_matrix"); + if (glewExperimental || GLEW_ARB_transpose_matrix) CONST_CAST(GLEW_ARB_transpose_matrix) = !_glewInit_GL_ARB_transpose_matrix(GLEW_CONTEXT_ARG_VAR_INIT); +#endif /* GL_ARB_transpose_matrix */ +#ifdef GL_ARB_vertex_array_object + CONST_CAST(GLEW_ARB_vertex_array_object) = glewGetExtension("GL_ARB_vertex_array_object"); + if (glewExperimental || GLEW_ARB_vertex_array_object) CONST_CAST(GLEW_ARB_vertex_array_object) = !_glewInit_GL_ARB_vertex_array_object(GLEW_CONTEXT_ARG_VAR_INIT); +#endif /* GL_ARB_vertex_array_object */ +#ifdef GL_ARB_vertex_blend + CONST_CAST(GLEW_ARB_vertex_blend) = glewGetExtension("GL_ARB_vertex_blend"); + if (glewExperimental || GLEW_ARB_vertex_blend) CONST_CAST(GLEW_ARB_vertex_blend) = !_glewInit_GL_ARB_vertex_blend(GLEW_CONTEXT_ARG_VAR_INIT); +#endif /* GL_ARB_vertex_blend */ +#ifdef GL_ARB_vertex_buffer_object + CONST_CAST(GLEW_ARB_vertex_buffer_object) = glewGetExtension("GL_ARB_vertex_buffer_object"); + if (glewExperimental || GLEW_ARB_vertex_buffer_object) CONST_CAST(GLEW_ARB_vertex_buffer_object) = !_glewInit_GL_ARB_vertex_buffer_object(GLEW_CONTEXT_ARG_VAR_INIT); +#endif /* GL_ARB_vertex_buffer_object */ +#ifdef GL_ARB_vertex_program + CONST_CAST(GLEW_ARB_vertex_program) = glewGetExtension("GL_ARB_vertex_program"); + if (glewExperimental || GLEW_ARB_vertex_program) CONST_CAST(GLEW_ARB_vertex_program) = !_glewInit_GL_ARB_vertex_program(GLEW_CONTEXT_ARG_VAR_INIT); +#endif /* GL_ARB_vertex_program */ +#ifdef GL_ARB_vertex_shader + CONST_CAST(GLEW_ARB_vertex_shader) = glewGetExtension("GL_ARB_vertex_shader"); + if (glewExperimental || GLEW_ARB_vertex_shader) CONST_CAST(GLEW_ARB_vertex_shader) = !_glewInit_GL_ARB_vertex_shader(GLEW_CONTEXT_ARG_VAR_INIT); +#endif /* GL_ARB_vertex_shader */ +#ifdef GL_ARB_window_pos + CONST_CAST(GLEW_ARB_window_pos) = glewGetExtension("GL_ARB_window_pos"); + if (glewExperimental || GLEW_ARB_window_pos) CONST_CAST(GLEW_ARB_window_pos) = !_glewInit_GL_ARB_window_pos(GLEW_CONTEXT_ARG_VAR_INIT); +#endif /* GL_ARB_window_pos */ +#ifdef GL_ATIX_point_sprites + CONST_CAST(GLEW_ATIX_point_sprites) = glewGetExtension("GL_ATIX_point_sprites"); +#endif /* GL_ATIX_point_sprites */ +#ifdef GL_ATIX_texture_env_combine3 + CONST_CAST(GLEW_ATIX_texture_env_combine3) = glewGetExtension("GL_ATIX_texture_env_combine3"); +#endif /* GL_ATIX_texture_env_combine3 */ +#ifdef GL_ATIX_texture_env_route + CONST_CAST(GLEW_ATIX_texture_env_route) = glewGetExtension("GL_ATIX_texture_env_route"); +#endif /* GL_ATIX_texture_env_route */ +#ifdef GL_ATIX_vertex_shader_output_point_size + CONST_CAST(GLEW_ATIX_vertex_shader_output_point_size) = glewGetExtension("GL_ATIX_vertex_shader_output_point_size"); +#endif /* GL_ATIX_vertex_shader_output_point_size */ +#ifdef GL_ATI_draw_buffers + CONST_CAST(GLEW_ATI_draw_buffers) = glewGetExtension("GL_ATI_draw_buffers"); + if (glewExperimental || GLEW_ATI_draw_buffers) CONST_CAST(GLEW_ATI_draw_buffers) = !_glewInit_GL_ATI_draw_buffers(GLEW_CONTEXT_ARG_VAR_INIT); +#endif /* GL_ATI_draw_buffers */ +#ifdef GL_ATI_element_array + CONST_CAST(GLEW_ATI_element_array) = glewGetExtension("GL_ATI_element_array"); + if (glewExperimental || GLEW_ATI_element_array) CONST_CAST(GLEW_ATI_element_array) = !_glewInit_GL_ATI_element_array(GLEW_CONTEXT_ARG_VAR_INIT); +#endif /* GL_ATI_element_array */ +#ifdef GL_ATI_envmap_bumpmap + CONST_CAST(GLEW_ATI_envmap_bumpmap) = glewGetExtension("GL_ATI_envmap_bumpmap"); + if (glewExperimental || GLEW_ATI_envmap_bumpmap) CONST_CAST(GLEW_ATI_envmap_bumpmap) = !_glewInit_GL_ATI_envmap_bumpmap(GLEW_CONTEXT_ARG_VAR_INIT); +#endif /* GL_ATI_envmap_bumpmap */ +#ifdef GL_ATI_fragment_shader + CONST_CAST(GLEW_ATI_fragment_shader) = glewGetExtension("GL_ATI_fragment_shader"); + if (glewExperimental || GLEW_ATI_fragment_shader) CONST_CAST(GLEW_ATI_fragment_shader) = !_glewInit_GL_ATI_fragment_shader(GLEW_CONTEXT_ARG_VAR_INIT); +#endif /* GL_ATI_fragment_shader */ +#ifdef GL_ATI_map_object_buffer + CONST_CAST(GLEW_ATI_map_object_buffer) = glewGetExtension("GL_ATI_map_object_buffer"); + if (glewExperimental || GLEW_ATI_map_object_buffer) CONST_CAST(GLEW_ATI_map_object_buffer) = !_glewInit_GL_ATI_map_object_buffer(GLEW_CONTEXT_ARG_VAR_INIT); +#endif /* GL_ATI_map_object_buffer */ +#ifdef GL_ATI_pn_triangles + CONST_CAST(GLEW_ATI_pn_triangles) = glewGetExtension("GL_ATI_pn_triangles"); + if (glewExperimental || GLEW_ATI_pn_triangles) CONST_CAST(GLEW_ATI_pn_triangles) = !_glewInit_GL_ATI_pn_triangles(GLEW_CONTEXT_ARG_VAR_INIT); +#endif /* GL_ATI_pn_triangles */ +#ifdef GL_ATI_separate_stencil + CONST_CAST(GLEW_ATI_separate_stencil) = glewGetExtension("GL_ATI_separate_stencil"); + if (glewExperimental || GLEW_ATI_separate_stencil) CONST_CAST(GLEW_ATI_separate_stencil) = !_glewInit_GL_ATI_separate_stencil(GLEW_CONTEXT_ARG_VAR_INIT); +#endif /* GL_ATI_separate_stencil */ +#ifdef GL_ATI_shader_texture_lod + CONST_CAST(GLEW_ATI_shader_texture_lod) = glewGetExtension("GL_ATI_shader_texture_lod"); +#endif /* GL_ATI_shader_texture_lod */ +#ifdef GL_ATI_text_fragment_shader + CONST_CAST(GLEW_ATI_text_fragment_shader) = glewGetExtension("GL_ATI_text_fragment_shader"); +#endif /* GL_ATI_text_fragment_shader */ +#ifdef GL_ATI_texture_compression_3dc + CONST_CAST(GLEW_ATI_texture_compression_3dc) = glewGetExtension("GL_ATI_texture_compression_3dc"); +#endif /* GL_ATI_texture_compression_3dc */ +#ifdef GL_ATI_texture_env_combine3 + CONST_CAST(GLEW_ATI_texture_env_combine3) = glewGetExtension("GL_ATI_texture_env_combine3"); +#endif /* GL_ATI_texture_env_combine3 */ +#ifdef GL_ATI_texture_float + CONST_CAST(GLEW_ATI_texture_float) = glewGetExtension("GL_ATI_texture_float"); +#endif /* GL_ATI_texture_float */ +#ifdef GL_ATI_texture_mirror_once + CONST_CAST(GLEW_ATI_texture_mirror_once) = glewGetExtension("GL_ATI_texture_mirror_once"); +#endif /* GL_ATI_texture_mirror_once */ +#ifdef GL_ATI_vertex_array_object + CONST_CAST(GLEW_ATI_vertex_array_object) = glewGetExtension("GL_ATI_vertex_array_object"); + if (glewExperimental || GLEW_ATI_vertex_array_object) CONST_CAST(GLEW_ATI_vertex_array_object) = !_glewInit_GL_ATI_vertex_array_object(GLEW_CONTEXT_ARG_VAR_INIT); +#endif /* GL_ATI_vertex_array_object */ +#ifdef GL_ATI_vertex_attrib_array_object + CONST_CAST(GLEW_ATI_vertex_attrib_array_object) = glewGetExtension("GL_ATI_vertex_attrib_array_object"); + if (glewExperimental || GLEW_ATI_vertex_attrib_array_object) CONST_CAST(GLEW_ATI_vertex_attrib_array_object) = !_glewInit_GL_ATI_vertex_attrib_array_object(GLEW_CONTEXT_ARG_VAR_INIT); +#endif /* GL_ATI_vertex_attrib_array_object */ +#ifdef GL_ATI_vertex_streams + CONST_CAST(GLEW_ATI_vertex_streams) = glewGetExtension("GL_ATI_vertex_streams"); + if (glewExperimental || GLEW_ATI_vertex_streams) CONST_CAST(GLEW_ATI_vertex_streams) = !_glewInit_GL_ATI_vertex_streams(GLEW_CONTEXT_ARG_VAR_INIT); +#endif /* GL_ATI_vertex_streams */ +#ifdef GL_EXT_422_pixels + CONST_CAST(GLEW_EXT_422_pixels) = glewGetExtension("GL_EXT_422_pixels"); +#endif /* GL_EXT_422_pixels */ +#ifdef GL_EXT_Cg_shader + CONST_CAST(GLEW_EXT_Cg_shader) = glewGetExtension("GL_EXT_Cg_shader"); +#endif /* GL_EXT_Cg_shader */ +#ifdef GL_EXT_abgr + CONST_CAST(GLEW_EXT_abgr) = glewGetExtension("GL_EXT_abgr"); +#endif /* GL_EXT_abgr */ +#ifdef GL_EXT_bgra + CONST_CAST(GLEW_EXT_bgra) = glewGetExtension("GL_EXT_bgra"); +#endif /* GL_EXT_bgra */ +#ifdef GL_EXT_bindable_uniform + CONST_CAST(GLEW_EXT_bindable_uniform) = glewGetExtension("GL_EXT_bindable_uniform"); + if (glewExperimental || GLEW_EXT_bindable_uniform) CONST_CAST(GLEW_EXT_bindable_uniform) = !_glewInit_GL_EXT_bindable_uniform(GLEW_CONTEXT_ARG_VAR_INIT); +#endif /* GL_EXT_bindable_uniform */ +#ifdef GL_EXT_blend_color + CONST_CAST(GLEW_EXT_blend_color) = glewGetExtension("GL_EXT_blend_color"); + if (glewExperimental || GLEW_EXT_blend_color) CONST_CAST(GLEW_EXT_blend_color) = !_glewInit_GL_EXT_blend_color(GLEW_CONTEXT_ARG_VAR_INIT); +#endif /* GL_EXT_blend_color */ +#ifdef GL_EXT_blend_equation_separate + CONST_CAST(GLEW_EXT_blend_equation_separate) = glewGetExtension("GL_EXT_blend_equation_separate"); + if (glewExperimental || GLEW_EXT_blend_equation_separate) CONST_CAST(GLEW_EXT_blend_equation_separate) = !_glewInit_GL_EXT_blend_equation_separate(GLEW_CONTEXT_ARG_VAR_INIT); +#endif /* GL_EXT_blend_equation_separate */ +#ifdef GL_EXT_blend_func_separate + CONST_CAST(GLEW_EXT_blend_func_separate) = glewGetExtension("GL_EXT_blend_func_separate"); + if (glewExperimental || GLEW_EXT_blend_func_separate) CONST_CAST(GLEW_EXT_blend_func_separate) = !_glewInit_GL_EXT_blend_func_separate(GLEW_CONTEXT_ARG_VAR_INIT); +#endif /* GL_EXT_blend_func_separate */ +#ifdef GL_EXT_blend_logic_op + CONST_CAST(GLEW_EXT_blend_logic_op) = glewGetExtension("GL_EXT_blend_logic_op"); +#endif /* GL_EXT_blend_logic_op */ +#ifdef GL_EXT_blend_minmax + CONST_CAST(GLEW_EXT_blend_minmax) = glewGetExtension("GL_EXT_blend_minmax"); + if (glewExperimental || GLEW_EXT_blend_minmax) CONST_CAST(GLEW_EXT_blend_minmax) = !_glewInit_GL_EXT_blend_minmax(GLEW_CONTEXT_ARG_VAR_INIT); +#endif /* GL_EXT_blend_minmax */ +#ifdef GL_EXT_blend_subtract + CONST_CAST(GLEW_EXT_blend_subtract) = glewGetExtension("GL_EXT_blend_subtract"); +#endif /* GL_EXT_blend_subtract */ +#ifdef GL_EXT_clip_volume_hint + CONST_CAST(GLEW_EXT_clip_volume_hint) = glewGetExtension("GL_EXT_clip_volume_hint"); +#endif /* GL_EXT_clip_volume_hint */ +#ifdef GL_EXT_cmyka + CONST_CAST(GLEW_EXT_cmyka) = glewGetExtension("GL_EXT_cmyka"); +#endif /* GL_EXT_cmyka */ +#ifdef GL_EXT_color_subtable + CONST_CAST(GLEW_EXT_color_subtable) = glewGetExtension("GL_EXT_color_subtable"); + if (glewExperimental || GLEW_EXT_color_subtable) CONST_CAST(GLEW_EXT_color_subtable) = !_glewInit_GL_EXT_color_subtable(GLEW_CONTEXT_ARG_VAR_INIT); +#endif /* GL_EXT_color_subtable */ +#ifdef GL_EXT_compiled_vertex_array + CONST_CAST(GLEW_EXT_compiled_vertex_array) = glewGetExtension("GL_EXT_compiled_vertex_array"); + if (glewExperimental || GLEW_EXT_compiled_vertex_array) CONST_CAST(GLEW_EXT_compiled_vertex_array) = !_glewInit_GL_EXT_compiled_vertex_array(GLEW_CONTEXT_ARG_VAR_INIT); +#endif /* GL_EXT_compiled_vertex_array */ +#ifdef GL_EXT_convolution + CONST_CAST(GLEW_EXT_convolution) = glewGetExtension("GL_EXT_convolution"); + if (glewExperimental || GLEW_EXT_convolution) CONST_CAST(GLEW_EXT_convolution) = !_glewInit_GL_EXT_convolution(GLEW_CONTEXT_ARG_VAR_INIT); +#endif /* GL_EXT_convolution */ +#ifdef GL_EXT_coordinate_frame + CONST_CAST(GLEW_EXT_coordinate_frame) = glewGetExtension("GL_EXT_coordinate_frame"); + if (glewExperimental || GLEW_EXT_coordinate_frame) CONST_CAST(GLEW_EXT_coordinate_frame) = !_glewInit_GL_EXT_coordinate_frame(GLEW_CONTEXT_ARG_VAR_INIT); +#endif /* GL_EXT_coordinate_frame */ +#ifdef GL_EXT_copy_texture + CONST_CAST(GLEW_EXT_copy_texture) = glewGetExtension("GL_EXT_copy_texture"); + if (glewExperimental || GLEW_EXT_copy_texture) CONST_CAST(GLEW_EXT_copy_texture) = !_glewInit_GL_EXT_copy_texture(GLEW_CONTEXT_ARG_VAR_INIT); +#endif /* GL_EXT_copy_texture */ +#ifdef GL_EXT_cull_vertex + CONST_CAST(GLEW_EXT_cull_vertex) = glewGetExtension("GL_EXT_cull_vertex"); + if (glewExperimental || GLEW_EXT_cull_vertex) CONST_CAST(GLEW_EXT_cull_vertex) = !_glewInit_GL_EXT_cull_vertex(GLEW_CONTEXT_ARG_VAR_INIT); +#endif /* GL_EXT_cull_vertex */ +#ifdef GL_EXT_depth_bounds_test + CONST_CAST(GLEW_EXT_depth_bounds_test) = glewGetExtension("GL_EXT_depth_bounds_test"); + if (glewExperimental || GLEW_EXT_depth_bounds_test) CONST_CAST(GLEW_EXT_depth_bounds_test) = !_glewInit_GL_EXT_depth_bounds_test(GLEW_CONTEXT_ARG_VAR_INIT); +#endif /* GL_EXT_depth_bounds_test */ +#ifdef GL_EXT_direct_state_access + CONST_CAST(GLEW_EXT_direct_state_access) = glewGetExtension("GL_EXT_direct_state_access"); + if (glewExperimental || GLEW_EXT_direct_state_access) CONST_CAST(GLEW_EXT_direct_state_access) = !_glewInit_GL_EXT_direct_state_access(GLEW_CONTEXT_ARG_VAR_INIT); +#endif /* GL_EXT_direct_state_access */ +#ifdef GL_EXT_draw_buffers2 + CONST_CAST(GLEW_EXT_draw_buffers2) = glewGetExtension("GL_EXT_draw_buffers2"); + if (glewExperimental || GLEW_EXT_draw_buffers2) CONST_CAST(GLEW_EXT_draw_buffers2) = !_glewInit_GL_EXT_draw_buffers2(GLEW_CONTEXT_ARG_VAR_INIT); +#endif /* GL_EXT_draw_buffers2 */ +#ifdef GL_EXT_draw_instanced + CONST_CAST(GLEW_EXT_draw_instanced) = glewGetExtension("GL_EXT_draw_instanced"); + if (glewExperimental || GLEW_EXT_draw_instanced) CONST_CAST(GLEW_EXT_draw_instanced) = !_glewInit_GL_EXT_draw_instanced(GLEW_CONTEXT_ARG_VAR_INIT); +#endif /* GL_EXT_draw_instanced */ +#ifdef GL_EXT_draw_range_elements + CONST_CAST(GLEW_EXT_draw_range_elements) = glewGetExtension("GL_EXT_draw_range_elements"); + if (glewExperimental || GLEW_EXT_draw_range_elements) CONST_CAST(GLEW_EXT_draw_range_elements) = !_glewInit_GL_EXT_draw_range_elements(GLEW_CONTEXT_ARG_VAR_INIT); +#endif /* GL_EXT_draw_range_elements */ +#ifdef GL_EXT_fog_coord + CONST_CAST(GLEW_EXT_fog_coord) = glewGetExtension("GL_EXT_fog_coord"); + if (glewExperimental || GLEW_EXT_fog_coord) CONST_CAST(GLEW_EXT_fog_coord) = !_glewInit_GL_EXT_fog_coord(GLEW_CONTEXT_ARG_VAR_INIT); +#endif /* GL_EXT_fog_coord */ +#ifdef GL_EXT_fragment_lighting + CONST_CAST(GLEW_EXT_fragment_lighting) = glewGetExtension("GL_EXT_fragment_lighting"); + if (glewExperimental || GLEW_EXT_fragment_lighting) CONST_CAST(GLEW_EXT_fragment_lighting) = !_glewInit_GL_EXT_fragment_lighting(GLEW_CONTEXT_ARG_VAR_INIT); +#endif /* GL_EXT_fragment_lighting */ +#ifdef GL_EXT_framebuffer_blit + CONST_CAST(GLEW_EXT_framebuffer_blit) = glewGetExtension("GL_EXT_framebuffer_blit"); + if (glewExperimental || GLEW_EXT_framebuffer_blit) CONST_CAST(GLEW_EXT_framebuffer_blit) = !_glewInit_GL_EXT_framebuffer_blit(GLEW_CONTEXT_ARG_VAR_INIT); +#endif /* GL_EXT_framebuffer_blit */ +#ifdef GL_EXT_framebuffer_multisample + CONST_CAST(GLEW_EXT_framebuffer_multisample) = glewGetExtension("GL_EXT_framebuffer_multisample"); + if (glewExperimental || GLEW_EXT_framebuffer_multisample) CONST_CAST(GLEW_EXT_framebuffer_multisample) = !_glewInit_GL_EXT_framebuffer_multisample(GLEW_CONTEXT_ARG_VAR_INIT); +#endif /* GL_EXT_framebuffer_multisample */ +#ifdef GL_EXT_framebuffer_object + CONST_CAST(GLEW_EXT_framebuffer_object) = glewGetExtension("GL_EXT_framebuffer_object"); + if (glewExperimental || GLEW_EXT_framebuffer_object) CONST_CAST(GLEW_EXT_framebuffer_object) = !_glewInit_GL_EXT_framebuffer_object(GLEW_CONTEXT_ARG_VAR_INIT); +#endif /* GL_EXT_framebuffer_object */ +#ifdef GL_EXT_framebuffer_sRGB + CONST_CAST(GLEW_EXT_framebuffer_sRGB) = glewGetExtension("GL_EXT_framebuffer_sRGB"); +#endif /* GL_EXT_framebuffer_sRGB */ +#ifdef GL_EXT_geometry_shader4 + CONST_CAST(GLEW_EXT_geometry_shader4) = glewGetExtension("GL_EXT_geometry_shader4"); + if (glewExperimental || GLEW_EXT_geometry_shader4) CONST_CAST(GLEW_EXT_geometry_shader4) = !_glewInit_GL_EXT_geometry_shader4(GLEW_CONTEXT_ARG_VAR_INIT); +#endif /* GL_EXT_geometry_shader4 */ +#ifdef GL_EXT_gpu_program_parameters + CONST_CAST(GLEW_EXT_gpu_program_parameters) = glewGetExtension("GL_EXT_gpu_program_parameters"); + if (glewExperimental || GLEW_EXT_gpu_program_parameters) CONST_CAST(GLEW_EXT_gpu_program_parameters) = !_glewInit_GL_EXT_gpu_program_parameters(GLEW_CONTEXT_ARG_VAR_INIT); +#endif /* GL_EXT_gpu_program_parameters */ +#ifdef GL_EXT_gpu_shader4 + CONST_CAST(GLEW_EXT_gpu_shader4) = glewGetExtension("GL_EXT_gpu_shader4"); + if (glewExperimental || GLEW_EXT_gpu_shader4) CONST_CAST(GLEW_EXT_gpu_shader4) = !_glewInit_GL_EXT_gpu_shader4(GLEW_CONTEXT_ARG_VAR_INIT); +#endif /* GL_EXT_gpu_shader4 */ +#ifdef GL_EXT_histogram + CONST_CAST(GLEW_EXT_histogram) = glewGetExtension("GL_EXT_histogram"); + if (glewExperimental || GLEW_EXT_histogram) CONST_CAST(GLEW_EXT_histogram) = !_glewInit_GL_EXT_histogram(GLEW_CONTEXT_ARG_VAR_INIT); +#endif /* GL_EXT_histogram */ +#ifdef GL_EXT_index_array_formats + CONST_CAST(GLEW_EXT_index_array_formats) = glewGetExtension("GL_EXT_index_array_formats"); +#endif /* GL_EXT_index_array_formats */ +#ifdef GL_EXT_index_func + CONST_CAST(GLEW_EXT_index_func) = glewGetExtension("GL_EXT_index_func"); + if (glewExperimental || GLEW_EXT_index_func) CONST_CAST(GLEW_EXT_index_func) = !_glewInit_GL_EXT_index_func(GLEW_CONTEXT_ARG_VAR_INIT); +#endif /* GL_EXT_index_func */ +#ifdef GL_EXT_index_material + CONST_CAST(GLEW_EXT_index_material) = glewGetExtension("GL_EXT_index_material"); + if (glewExperimental || GLEW_EXT_index_material) CONST_CAST(GLEW_EXT_index_material) = !_glewInit_GL_EXT_index_material(GLEW_CONTEXT_ARG_VAR_INIT); +#endif /* GL_EXT_index_material */ +#ifdef GL_EXT_index_texture + CONST_CAST(GLEW_EXT_index_texture) = glewGetExtension("GL_EXT_index_texture"); +#endif /* GL_EXT_index_texture */ +#ifdef GL_EXT_light_texture + CONST_CAST(GLEW_EXT_light_texture) = glewGetExtension("GL_EXT_light_texture"); + if (glewExperimental || GLEW_EXT_light_texture) CONST_CAST(GLEW_EXT_light_texture) = !_glewInit_GL_EXT_light_texture(GLEW_CONTEXT_ARG_VAR_INIT); +#endif /* GL_EXT_light_texture */ +#ifdef GL_EXT_misc_attribute + CONST_CAST(GLEW_EXT_misc_attribute) = glewGetExtension("GL_EXT_misc_attribute"); +#endif /* GL_EXT_misc_attribute */ +#ifdef GL_EXT_multi_draw_arrays + CONST_CAST(GLEW_EXT_multi_draw_arrays) = glewGetExtension("GL_EXT_multi_draw_arrays"); + if (glewExperimental || GLEW_EXT_multi_draw_arrays) CONST_CAST(GLEW_EXT_multi_draw_arrays) = !_glewInit_GL_EXT_multi_draw_arrays(GLEW_CONTEXT_ARG_VAR_INIT); +#endif /* GL_EXT_multi_draw_arrays */ +#ifdef GL_EXT_multisample + CONST_CAST(GLEW_EXT_multisample) = glewGetExtension("GL_EXT_multisample"); + if (glewExperimental || GLEW_EXT_multisample) CONST_CAST(GLEW_EXT_multisample) = !_glewInit_GL_EXT_multisample(GLEW_CONTEXT_ARG_VAR_INIT); +#endif /* GL_EXT_multisample */ +#ifdef GL_EXT_packed_depth_stencil + CONST_CAST(GLEW_EXT_packed_depth_stencil) = glewGetExtension("GL_EXT_packed_depth_stencil"); +#endif /* GL_EXT_packed_depth_stencil */ +#ifdef GL_EXT_packed_float + CONST_CAST(GLEW_EXT_packed_float) = glewGetExtension("GL_EXT_packed_float"); +#endif /* GL_EXT_packed_float */ +#ifdef GL_EXT_packed_pixels + CONST_CAST(GLEW_EXT_packed_pixels) = glewGetExtension("GL_EXT_packed_pixels"); +#endif /* GL_EXT_packed_pixels */ +#ifdef GL_EXT_paletted_texture + CONST_CAST(GLEW_EXT_paletted_texture) = glewGetExtension("GL_EXT_paletted_texture"); + if (glewExperimental || GLEW_EXT_paletted_texture) CONST_CAST(GLEW_EXT_paletted_texture) = !_glewInit_GL_EXT_paletted_texture(GLEW_CONTEXT_ARG_VAR_INIT); +#endif /* GL_EXT_paletted_texture */ +#ifdef GL_EXT_pixel_buffer_object + CONST_CAST(GLEW_EXT_pixel_buffer_object) = glewGetExtension("GL_EXT_pixel_buffer_object"); +#endif /* GL_EXT_pixel_buffer_object */ +#ifdef GL_EXT_pixel_transform + CONST_CAST(GLEW_EXT_pixel_transform) = glewGetExtension("GL_EXT_pixel_transform"); + if (glewExperimental || GLEW_EXT_pixel_transform) CONST_CAST(GLEW_EXT_pixel_transform) = !_glewInit_GL_EXT_pixel_transform(GLEW_CONTEXT_ARG_VAR_INIT); +#endif /* GL_EXT_pixel_transform */ +#ifdef GL_EXT_pixel_transform_color_table + CONST_CAST(GLEW_EXT_pixel_transform_color_table) = glewGetExtension("GL_EXT_pixel_transform_color_table"); +#endif /* GL_EXT_pixel_transform_color_table */ +#ifdef GL_EXT_point_parameters + CONST_CAST(GLEW_EXT_point_parameters) = glewGetExtension("GL_EXT_point_parameters"); + if (glewExperimental || GLEW_EXT_point_parameters) CONST_CAST(GLEW_EXT_point_parameters) = !_glewInit_GL_EXT_point_parameters(GLEW_CONTEXT_ARG_VAR_INIT); +#endif /* GL_EXT_point_parameters */ +#ifdef GL_EXT_polygon_offset + CONST_CAST(GLEW_EXT_polygon_offset) = glewGetExtension("GL_EXT_polygon_offset"); + if (glewExperimental || GLEW_EXT_polygon_offset) CONST_CAST(GLEW_EXT_polygon_offset) = !_glewInit_GL_EXT_polygon_offset(GLEW_CONTEXT_ARG_VAR_INIT); +#endif /* GL_EXT_polygon_offset */ +#ifdef GL_EXT_rescale_normal + CONST_CAST(GLEW_EXT_rescale_normal) = glewGetExtension("GL_EXT_rescale_normal"); +#endif /* GL_EXT_rescale_normal */ +#ifdef GL_EXT_scene_marker + CONST_CAST(GLEW_EXT_scene_marker) = glewGetExtension("GL_EXT_scene_marker"); + if (glewExperimental || GLEW_EXT_scene_marker) CONST_CAST(GLEW_EXT_scene_marker) = !_glewInit_GL_EXT_scene_marker(GLEW_CONTEXT_ARG_VAR_INIT); +#endif /* GL_EXT_scene_marker */ +#ifdef GL_EXT_secondary_color + CONST_CAST(GLEW_EXT_secondary_color) = glewGetExtension("GL_EXT_secondary_color"); + if (glewExperimental || GLEW_EXT_secondary_color) CONST_CAST(GLEW_EXT_secondary_color) = !_glewInit_GL_EXT_secondary_color(GLEW_CONTEXT_ARG_VAR_INIT); +#endif /* GL_EXT_secondary_color */ +#ifdef GL_EXT_separate_specular_color + CONST_CAST(GLEW_EXT_separate_specular_color) = glewGetExtension("GL_EXT_separate_specular_color"); +#endif /* GL_EXT_separate_specular_color */ +#ifdef GL_EXT_shadow_funcs + CONST_CAST(GLEW_EXT_shadow_funcs) = glewGetExtension("GL_EXT_shadow_funcs"); +#endif /* GL_EXT_shadow_funcs */ +#ifdef GL_EXT_shared_texture_palette + CONST_CAST(GLEW_EXT_shared_texture_palette) = glewGetExtension("GL_EXT_shared_texture_palette"); +#endif /* GL_EXT_shared_texture_palette */ +#ifdef GL_EXT_stencil_clear_tag + CONST_CAST(GLEW_EXT_stencil_clear_tag) = glewGetExtension("GL_EXT_stencil_clear_tag"); +#endif /* GL_EXT_stencil_clear_tag */ +#ifdef GL_EXT_stencil_two_side + CONST_CAST(GLEW_EXT_stencil_two_side) = glewGetExtension("GL_EXT_stencil_two_side"); + if (glewExperimental || GLEW_EXT_stencil_two_side) CONST_CAST(GLEW_EXT_stencil_two_side) = !_glewInit_GL_EXT_stencil_two_side(GLEW_CONTEXT_ARG_VAR_INIT); +#endif /* GL_EXT_stencil_two_side */ +#ifdef GL_EXT_stencil_wrap + CONST_CAST(GLEW_EXT_stencil_wrap) = glewGetExtension("GL_EXT_stencil_wrap"); +#endif /* GL_EXT_stencil_wrap */ +#ifdef GL_EXT_subtexture + CONST_CAST(GLEW_EXT_subtexture) = glewGetExtension("GL_EXT_subtexture"); + if (glewExperimental || GLEW_EXT_subtexture) CONST_CAST(GLEW_EXT_subtexture) = !_glewInit_GL_EXT_subtexture(GLEW_CONTEXT_ARG_VAR_INIT); +#endif /* GL_EXT_subtexture */ +#ifdef GL_EXT_texture + CONST_CAST(GLEW_EXT_texture) = glewGetExtension("GL_EXT_texture"); +#endif /* GL_EXT_texture */ +#ifdef GL_EXT_texture3D + CONST_CAST(GLEW_EXT_texture3D) = glewGetExtension("GL_EXT_texture3D"); + if (glewExperimental || GLEW_EXT_texture3D) CONST_CAST(GLEW_EXT_texture3D) = !_glewInit_GL_EXT_texture3D(GLEW_CONTEXT_ARG_VAR_INIT); +#endif /* GL_EXT_texture3D */ +#ifdef GL_EXT_texture_array + CONST_CAST(GLEW_EXT_texture_array) = glewGetExtension("GL_EXT_texture_array"); +#endif /* GL_EXT_texture_array */ +#ifdef GL_EXT_texture_buffer_object + CONST_CAST(GLEW_EXT_texture_buffer_object) = glewGetExtension("GL_EXT_texture_buffer_object"); + if (glewExperimental || GLEW_EXT_texture_buffer_object) CONST_CAST(GLEW_EXT_texture_buffer_object) = !_glewInit_GL_EXT_texture_buffer_object(GLEW_CONTEXT_ARG_VAR_INIT); +#endif /* GL_EXT_texture_buffer_object */ +#ifdef GL_EXT_texture_compression_dxt1 + CONST_CAST(GLEW_EXT_texture_compression_dxt1) = glewGetExtension("GL_EXT_texture_compression_dxt1"); +#endif /* GL_EXT_texture_compression_dxt1 */ +#ifdef GL_EXT_texture_compression_latc + CONST_CAST(GLEW_EXT_texture_compression_latc) = glewGetExtension("GL_EXT_texture_compression_latc"); +#endif /* GL_EXT_texture_compression_latc */ +#ifdef GL_EXT_texture_compression_rgtc + CONST_CAST(GLEW_EXT_texture_compression_rgtc) = glewGetExtension("GL_EXT_texture_compression_rgtc"); +#endif /* GL_EXT_texture_compression_rgtc */ +#ifdef GL_EXT_texture_compression_s3tc + CONST_CAST(GLEW_EXT_texture_compression_s3tc) = glewGetExtension("GL_EXT_texture_compression_s3tc"); +#endif /* GL_EXT_texture_compression_s3tc */ +#ifdef GL_EXT_texture_cube_map + CONST_CAST(GLEW_EXT_texture_cube_map) = glewGetExtension("GL_EXT_texture_cube_map"); +#endif /* GL_EXT_texture_cube_map */ +#ifdef GL_EXT_texture_edge_clamp + CONST_CAST(GLEW_EXT_texture_edge_clamp) = glewGetExtension("GL_EXT_texture_edge_clamp"); +#endif /* GL_EXT_texture_edge_clamp */ +#ifdef GL_EXT_texture_env + CONST_CAST(GLEW_EXT_texture_env) = glewGetExtension("GL_EXT_texture_env"); +#endif /* GL_EXT_texture_env */ +#ifdef GL_EXT_texture_env_add + CONST_CAST(GLEW_EXT_texture_env_add) = glewGetExtension("GL_EXT_texture_env_add"); +#endif /* GL_EXT_texture_env_add */ +#ifdef GL_EXT_texture_env_combine + CONST_CAST(GLEW_EXT_texture_env_combine) = glewGetExtension("GL_EXT_texture_env_combine"); +#endif /* GL_EXT_texture_env_combine */ +#ifdef GL_EXT_texture_env_dot3 + CONST_CAST(GLEW_EXT_texture_env_dot3) = glewGetExtension("GL_EXT_texture_env_dot3"); +#endif /* GL_EXT_texture_env_dot3 */ +#ifdef GL_EXT_texture_filter_anisotropic + CONST_CAST(GLEW_EXT_texture_filter_anisotropic) = glewGetExtension("GL_EXT_texture_filter_anisotropic"); +#endif /* GL_EXT_texture_filter_anisotropic */ +#ifdef GL_EXT_texture_integer + CONST_CAST(GLEW_EXT_texture_integer) = glewGetExtension("GL_EXT_texture_integer"); + if (glewExperimental || GLEW_EXT_texture_integer) CONST_CAST(GLEW_EXT_texture_integer) = !_glewInit_GL_EXT_texture_integer(GLEW_CONTEXT_ARG_VAR_INIT); +#endif /* GL_EXT_texture_integer */ +#ifdef GL_EXT_texture_lod_bias + CONST_CAST(GLEW_EXT_texture_lod_bias) = glewGetExtension("GL_EXT_texture_lod_bias"); +#endif /* GL_EXT_texture_lod_bias */ +#ifdef GL_EXT_texture_mirror_clamp + CONST_CAST(GLEW_EXT_texture_mirror_clamp) = glewGetExtension("GL_EXT_texture_mirror_clamp"); +#endif /* GL_EXT_texture_mirror_clamp */ +#ifdef GL_EXT_texture_object + CONST_CAST(GLEW_EXT_texture_object) = glewGetExtension("GL_EXT_texture_object"); + if (glewExperimental || GLEW_EXT_texture_object) CONST_CAST(GLEW_EXT_texture_object) = !_glewInit_GL_EXT_texture_object(GLEW_CONTEXT_ARG_VAR_INIT); +#endif /* GL_EXT_texture_object */ +#ifdef GL_EXT_texture_perturb_normal + CONST_CAST(GLEW_EXT_texture_perturb_normal) = glewGetExtension("GL_EXT_texture_perturb_normal"); + if (glewExperimental || GLEW_EXT_texture_perturb_normal) CONST_CAST(GLEW_EXT_texture_perturb_normal) = !_glewInit_GL_EXT_texture_perturb_normal(GLEW_CONTEXT_ARG_VAR_INIT); +#endif /* GL_EXT_texture_perturb_normal */ +#ifdef GL_EXT_texture_rectangle + CONST_CAST(GLEW_EXT_texture_rectangle) = glewGetExtension("GL_EXT_texture_rectangle"); +#endif /* GL_EXT_texture_rectangle */ +#ifdef GL_EXT_texture_sRGB + CONST_CAST(GLEW_EXT_texture_sRGB) = glewGetExtension("GL_EXT_texture_sRGB"); +#endif /* GL_EXT_texture_sRGB */ +#ifdef GL_EXT_texture_shared_exponent + CONST_CAST(GLEW_EXT_texture_shared_exponent) = glewGetExtension("GL_EXT_texture_shared_exponent"); +#endif /* GL_EXT_texture_shared_exponent */ +#ifdef GL_EXT_texture_swizzle + CONST_CAST(GLEW_EXT_texture_swizzle) = glewGetExtension("GL_EXT_texture_swizzle"); +#endif /* GL_EXT_texture_swizzle */ +#ifdef GL_EXT_timer_query + CONST_CAST(GLEW_EXT_timer_query) = glewGetExtension("GL_EXT_timer_query"); + if (glewExperimental || GLEW_EXT_timer_query) CONST_CAST(GLEW_EXT_timer_query) = !_glewInit_GL_EXT_timer_query(GLEW_CONTEXT_ARG_VAR_INIT); +#endif /* GL_EXT_timer_query */ +#ifdef GL_EXT_transform_feedback + CONST_CAST(GLEW_EXT_transform_feedback) = glewGetExtension("GL_EXT_transform_feedback"); + if (glewExperimental || GLEW_EXT_transform_feedback) CONST_CAST(GLEW_EXT_transform_feedback) = !_glewInit_GL_EXT_transform_feedback(GLEW_CONTEXT_ARG_VAR_INIT); +#endif /* GL_EXT_transform_feedback */ +#ifdef GL_EXT_vertex_array + CONST_CAST(GLEW_EXT_vertex_array) = glewGetExtension("GL_EXT_vertex_array"); + if (glewExperimental || GLEW_EXT_vertex_array) CONST_CAST(GLEW_EXT_vertex_array) = !_glewInit_GL_EXT_vertex_array(GLEW_CONTEXT_ARG_VAR_INIT); +#endif /* GL_EXT_vertex_array */ +#ifdef GL_EXT_vertex_array_bgra + CONST_CAST(GLEW_EXT_vertex_array_bgra) = glewGetExtension("GL_EXT_vertex_array_bgra"); +#endif /* GL_EXT_vertex_array_bgra */ +#ifdef GL_EXT_vertex_shader + CONST_CAST(GLEW_EXT_vertex_shader) = glewGetExtension("GL_EXT_vertex_shader"); + if (glewExperimental || GLEW_EXT_vertex_shader) CONST_CAST(GLEW_EXT_vertex_shader) = !_glewInit_GL_EXT_vertex_shader(GLEW_CONTEXT_ARG_VAR_INIT); +#endif /* GL_EXT_vertex_shader */ +#ifdef GL_EXT_vertex_weighting + CONST_CAST(GLEW_EXT_vertex_weighting) = glewGetExtension("GL_EXT_vertex_weighting"); + if (glewExperimental || GLEW_EXT_vertex_weighting) CONST_CAST(GLEW_EXT_vertex_weighting) = !_glewInit_GL_EXT_vertex_weighting(GLEW_CONTEXT_ARG_VAR_INIT); +#endif /* GL_EXT_vertex_weighting */ +#ifdef GL_GREMEDY_frame_terminator + CONST_CAST(GLEW_GREMEDY_frame_terminator) = glewGetExtension("GL_GREMEDY_frame_terminator"); + if (glewExperimental || GLEW_GREMEDY_frame_terminator) CONST_CAST(GLEW_GREMEDY_frame_terminator) = !_glewInit_GL_GREMEDY_frame_terminator(GLEW_CONTEXT_ARG_VAR_INIT); +#endif /* GL_GREMEDY_frame_terminator */ +#ifdef GL_GREMEDY_string_marker + CONST_CAST(GLEW_GREMEDY_string_marker) = glewGetExtension("GL_GREMEDY_string_marker"); + if (glewExperimental || GLEW_GREMEDY_string_marker) CONST_CAST(GLEW_GREMEDY_string_marker) = !_glewInit_GL_GREMEDY_string_marker(GLEW_CONTEXT_ARG_VAR_INIT); +#endif /* GL_GREMEDY_string_marker */ +#ifdef GL_HP_convolution_border_modes + CONST_CAST(GLEW_HP_convolution_border_modes) = glewGetExtension("GL_HP_convolution_border_modes"); +#endif /* GL_HP_convolution_border_modes */ +#ifdef GL_HP_image_transform + CONST_CAST(GLEW_HP_image_transform) = glewGetExtension("GL_HP_image_transform"); + if (glewExperimental || GLEW_HP_image_transform) CONST_CAST(GLEW_HP_image_transform) = !_glewInit_GL_HP_image_transform(GLEW_CONTEXT_ARG_VAR_INIT); +#endif /* GL_HP_image_transform */ +#ifdef GL_HP_occlusion_test + CONST_CAST(GLEW_HP_occlusion_test) = glewGetExtension("GL_HP_occlusion_test"); +#endif /* GL_HP_occlusion_test */ +#ifdef GL_HP_texture_lighting + CONST_CAST(GLEW_HP_texture_lighting) = glewGetExtension("GL_HP_texture_lighting"); +#endif /* GL_HP_texture_lighting */ +#ifdef GL_IBM_cull_vertex + CONST_CAST(GLEW_IBM_cull_vertex) = glewGetExtension("GL_IBM_cull_vertex"); +#endif /* GL_IBM_cull_vertex */ +#ifdef GL_IBM_multimode_draw_arrays + CONST_CAST(GLEW_IBM_multimode_draw_arrays) = glewGetExtension("GL_IBM_multimode_draw_arrays"); + if (glewExperimental || GLEW_IBM_multimode_draw_arrays) CONST_CAST(GLEW_IBM_multimode_draw_arrays) = !_glewInit_GL_IBM_multimode_draw_arrays(GLEW_CONTEXT_ARG_VAR_INIT); +#endif /* GL_IBM_multimode_draw_arrays */ +#ifdef GL_IBM_rasterpos_clip + CONST_CAST(GLEW_IBM_rasterpos_clip) = glewGetExtension("GL_IBM_rasterpos_clip"); +#endif /* GL_IBM_rasterpos_clip */ +#ifdef GL_IBM_static_data + CONST_CAST(GLEW_IBM_static_data) = glewGetExtension("GL_IBM_static_data"); +#endif /* GL_IBM_static_data */ +#ifdef GL_IBM_texture_mirrored_repeat + CONST_CAST(GLEW_IBM_texture_mirrored_repeat) = glewGetExtension("GL_IBM_texture_mirrored_repeat"); +#endif /* GL_IBM_texture_mirrored_repeat */ +#ifdef GL_IBM_vertex_array_lists + CONST_CAST(GLEW_IBM_vertex_array_lists) = glewGetExtension("GL_IBM_vertex_array_lists"); + if (glewExperimental || GLEW_IBM_vertex_array_lists) CONST_CAST(GLEW_IBM_vertex_array_lists) = !_glewInit_GL_IBM_vertex_array_lists(GLEW_CONTEXT_ARG_VAR_INIT); +#endif /* GL_IBM_vertex_array_lists */ +#ifdef GL_INGR_color_clamp + CONST_CAST(GLEW_INGR_color_clamp) = glewGetExtension("GL_INGR_color_clamp"); +#endif /* GL_INGR_color_clamp */ +#ifdef GL_INGR_interlace_read + CONST_CAST(GLEW_INGR_interlace_read) = glewGetExtension("GL_INGR_interlace_read"); +#endif /* GL_INGR_interlace_read */ +#ifdef GL_INTEL_parallel_arrays + CONST_CAST(GLEW_INTEL_parallel_arrays) = glewGetExtension("GL_INTEL_parallel_arrays"); + if (glewExperimental || GLEW_INTEL_parallel_arrays) CONST_CAST(GLEW_INTEL_parallel_arrays) = !_glewInit_GL_INTEL_parallel_arrays(GLEW_CONTEXT_ARG_VAR_INIT); +#endif /* GL_INTEL_parallel_arrays */ +#ifdef GL_INTEL_texture_scissor + CONST_CAST(GLEW_INTEL_texture_scissor) = glewGetExtension("GL_INTEL_texture_scissor"); + if (glewExperimental || GLEW_INTEL_texture_scissor) CONST_CAST(GLEW_INTEL_texture_scissor) = !_glewInit_GL_INTEL_texture_scissor(GLEW_CONTEXT_ARG_VAR_INIT); +#endif /* GL_INTEL_texture_scissor */ +#ifdef GL_KTX_buffer_region + CONST_CAST(GLEW_KTX_buffer_region) = glewGetExtension("GL_KTX_buffer_region"); + if (glewExperimental || GLEW_KTX_buffer_region) CONST_CAST(GLEW_KTX_buffer_region) = !_glewInit_GL_KTX_buffer_region(GLEW_CONTEXT_ARG_VAR_INIT); +#endif /* GL_KTX_buffer_region */ +#ifdef GL_MESAX_texture_stack + CONST_CAST(GLEW_MESAX_texture_stack) = glewGetExtension("GL_MESAX_texture_stack"); +#endif /* GL_MESAX_texture_stack */ +#ifdef GL_MESA_pack_invert + CONST_CAST(GLEW_MESA_pack_invert) = glewGetExtension("GL_MESA_pack_invert"); +#endif /* GL_MESA_pack_invert */ +#ifdef GL_MESA_resize_buffers + CONST_CAST(GLEW_MESA_resize_buffers) = glewGetExtension("GL_MESA_resize_buffers"); + if (glewExperimental || GLEW_MESA_resize_buffers) CONST_CAST(GLEW_MESA_resize_buffers) = !_glewInit_GL_MESA_resize_buffers(GLEW_CONTEXT_ARG_VAR_INIT); +#endif /* GL_MESA_resize_buffers */ +#ifdef GL_MESA_window_pos + CONST_CAST(GLEW_MESA_window_pos) = glewGetExtension("GL_MESA_window_pos"); + if (glewExperimental || GLEW_MESA_window_pos) CONST_CAST(GLEW_MESA_window_pos) = !_glewInit_GL_MESA_window_pos(GLEW_CONTEXT_ARG_VAR_INIT); +#endif /* GL_MESA_window_pos */ +#ifdef GL_MESA_ycbcr_texture + CONST_CAST(GLEW_MESA_ycbcr_texture) = glewGetExtension("GL_MESA_ycbcr_texture"); +#endif /* GL_MESA_ycbcr_texture */ +#ifdef GL_NV_blend_square + CONST_CAST(GLEW_NV_blend_square) = glewGetExtension("GL_NV_blend_square"); +#endif /* GL_NV_blend_square */ +#ifdef GL_NV_conditional_render + CONST_CAST(GLEW_NV_conditional_render) = glewGetExtension("GL_NV_conditional_render"); + if (glewExperimental || GLEW_NV_conditional_render) CONST_CAST(GLEW_NV_conditional_render) = !_glewInit_GL_NV_conditional_render(GLEW_CONTEXT_ARG_VAR_INIT); +#endif /* GL_NV_conditional_render */ +#ifdef GL_NV_copy_depth_to_color + CONST_CAST(GLEW_NV_copy_depth_to_color) = glewGetExtension("GL_NV_copy_depth_to_color"); +#endif /* GL_NV_copy_depth_to_color */ +#ifdef GL_NV_depth_buffer_float + CONST_CAST(GLEW_NV_depth_buffer_float) = glewGetExtension("GL_NV_depth_buffer_float"); + if (glewExperimental || GLEW_NV_depth_buffer_float) CONST_CAST(GLEW_NV_depth_buffer_float) = !_glewInit_GL_NV_depth_buffer_float(GLEW_CONTEXT_ARG_VAR_INIT); +#endif /* GL_NV_depth_buffer_float */ +#ifdef GL_NV_depth_clamp + CONST_CAST(GLEW_NV_depth_clamp) = glewGetExtension("GL_NV_depth_clamp"); +#endif /* GL_NV_depth_clamp */ +#ifdef GL_NV_depth_range_unclamped + CONST_CAST(GLEW_NV_depth_range_unclamped) = glewGetExtension("GL_NV_depth_range_unclamped"); +#endif /* GL_NV_depth_range_unclamped */ +#ifdef GL_NV_evaluators + CONST_CAST(GLEW_NV_evaluators) = glewGetExtension("GL_NV_evaluators"); + if (glewExperimental || GLEW_NV_evaluators) CONST_CAST(GLEW_NV_evaluators) = !_glewInit_GL_NV_evaluators(GLEW_CONTEXT_ARG_VAR_INIT); +#endif /* GL_NV_evaluators */ +#ifdef GL_NV_explicit_multisample + CONST_CAST(GLEW_NV_explicit_multisample) = glewGetExtension("GL_NV_explicit_multisample"); + if (glewExperimental || GLEW_NV_explicit_multisample) CONST_CAST(GLEW_NV_explicit_multisample) = !_glewInit_GL_NV_explicit_multisample(GLEW_CONTEXT_ARG_VAR_INIT); +#endif /* GL_NV_explicit_multisample */ +#ifdef GL_NV_fence + CONST_CAST(GLEW_NV_fence) = glewGetExtension("GL_NV_fence"); + if (glewExperimental || GLEW_NV_fence) CONST_CAST(GLEW_NV_fence) = !_glewInit_GL_NV_fence(GLEW_CONTEXT_ARG_VAR_INIT); +#endif /* GL_NV_fence */ +#ifdef GL_NV_float_buffer + CONST_CAST(GLEW_NV_float_buffer) = glewGetExtension("GL_NV_float_buffer"); +#endif /* GL_NV_float_buffer */ +#ifdef GL_NV_fog_distance + CONST_CAST(GLEW_NV_fog_distance) = glewGetExtension("GL_NV_fog_distance"); +#endif /* GL_NV_fog_distance */ +#ifdef GL_NV_fragment_program + CONST_CAST(GLEW_NV_fragment_program) = glewGetExtension("GL_NV_fragment_program"); + if (glewExperimental || GLEW_NV_fragment_program) CONST_CAST(GLEW_NV_fragment_program) = !_glewInit_GL_NV_fragment_program(GLEW_CONTEXT_ARG_VAR_INIT); +#endif /* GL_NV_fragment_program */ +#ifdef GL_NV_fragment_program2 + CONST_CAST(GLEW_NV_fragment_program2) = glewGetExtension("GL_NV_fragment_program2"); +#endif /* GL_NV_fragment_program2 */ +#ifdef GL_NV_fragment_program4 + CONST_CAST(GLEW_NV_fragment_program4) = glewGetExtension("GL_NV_fragment_program4"); +#endif /* GL_NV_fragment_program4 */ +#ifdef GL_NV_fragment_program_option + CONST_CAST(GLEW_NV_fragment_program_option) = glewGetExtension("GL_NV_fragment_program_option"); +#endif /* GL_NV_fragment_program_option */ +#ifdef GL_NV_framebuffer_multisample_coverage + CONST_CAST(GLEW_NV_framebuffer_multisample_coverage) = glewGetExtension("GL_NV_framebuffer_multisample_coverage"); + if (glewExperimental || GLEW_NV_framebuffer_multisample_coverage) CONST_CAST(GLEW_NV_framebuffer_multisample_coverage) = !_glewInit_GL_NV_framebuffer_multisample_coverage(GLEW_CONTEXT_ARG_VAR_INIT); +#endif /* GL_NV_framebuffer_multisample_coverage */ +#ifdef GL_NV_geometry_program4 + CONST_CAST(GLEW_NV_geometry_program4) = glewGetExtension("GL_NV_geometry_program4"); + if (glewExperimental || GLEW_NV_geometry_program4) CONST_CAST(GLEW_NV_geometry_program4) = !_glewInit_GL_NV_geometry_program4(GLEW_CONTEXT_ARG_VAR_INIT); +#endif /* GL_NV_geometry_program4 */ +#ifdef GL_NV_geometry_shader4 + CONST_CAST(GLEW_NV_geometry_shader4) = glewGetExtension("GL_NV_geometry_shader4"); +#endif /* GL_NV_geometry_shader4 */ +#ifdef GL_NV_gpu_program4 + CONST_CAST(GLEW_NV_gpu_program4) = glewGetExtension("GL_NV_gpu_program4"); + if (glewExperimental || GLEW_NV_gpu_program4) CONST_CAST(GLEW_NV_gpu_program4) = !_glewInit_GL_NV_gpu_program4(GLEW_CONTEXT_ARG_VAR_INIT); +#endif /* GL_NV_gpu_program4 */ +#ifdef GL_NV_half_float + CONST_CAST(GLEW_NV_half_float) = glewGetExtension("GL_NV_half_float"); + if (glewExperimental || GLEW_NV_half_float) CONST_CAST(GLEW_NV_half_float) = !_glewInit_GL_NV_half_float(GLEW_CONTEXT_ARG_VAR_INIT); +#endif /* GL_NV_half_float */ +#ifdef GL_NV_light_max_exponent + CONST_CAST(GLEW_NV_light_max_exponent) = glewGetExtension("GL_NV_light_max_exponent"); +#endif /* GL_NV_light_max_exponent */ +#ifdef GL_NV_multisample_filter_hint + CONST_CAST(GLEW_NV_multisample_filter_hint) = glewGetExtension("GL_NV_multisample_filter_hint"); +#endif /* GL_NV_multisample_filter_hint */ +#ifdef GL_NV_occlusion_query + CONST_CAST(GLEW_NV_occlusion_query) = glewGetExtension("GL_NV_occlusion_query"); + if (glewExperimental || GLEW_NV_occlusion_query) CONST_CAST(GLEW_NV_occlusion_query) = !_glewInit_GL_NV_occlusion_query(GLEW_CONTEXT_ARG_VAR_INIT); +#endif /* GL_NV_occlusion_query */ +#ifdef GL_NV_packed_depth_stencil + CONST_CAST(GLEW_NV_packed_depth_stencil) = glewGetExtension("GL_NV_packed_depth_stencil"); +#endif /* GL_NV_packed_depth_stencil */ +#ifdef GL_NV_parameter_buffer_object + CONST_CAST(GLEW_NV_parameter_buffer_object) = glewGetExtension("GL_NV_parameter_buffer_object"); + if (glewExperimental || GLEW_NV_parameter_buffer_object) CONST_CAST(GLEW_NV_parameter_buffer_object) = !_glewInit_GL_NV_parameter_buffer_object(GLEW_CONTEXT_ARG_VAR_INIT); +#endif /* GL_NV_parameter_buffer_object */ +#ifdef GL_NV_pixel_data_range + CONST_CAST(GLEW_NV_pixel_data_range) = glewGetExtension("GL_NV_pixel_data_range"); + if (glewExperimental || GLEW_NV_pixel_data_range) CONST_CAST(GLEW_NV_pixel_data_range) = !_glewInit_GL_NV_pixel_data_range(GLEW_CONTEXT_ARG_VAR_INIT); +#endif /* GL_NV_pixel_data_range */ +#ifdef GL_NV_point_sprite + CONST_CAST(GLEW_NV_point_sprite) = glewGetExtension("GL_NV_point_sprite"); + if (glewExperimental || GLEW_NV_point_sprite) CONST_CAST(GLEW_NV_point_sprite) = !_glewInit_GL_NV_point_sprite(GLEW_CONTEXT_ARG_VAR_INIT); +#endif /* GL_NV_point_sprite */ +#ifdef GL_NV_present_video + CONST_CAST(GLEW_NV_present_video) = glewGetExtension("GL_NV_present_video"); + if (glewExperimental || GLEW_NV_present_video) CONST_CAST(GLEW_NV_present_video) = !_glewInit_GL_NV_present_video(GLEW_CONTEXT_ARG_VAR_INIT); +#endif /* GL_NV_present_video */ +#ifdef GL_NV_primitive_restart + CONST_CAST(GLEW_NV_primitive_restart) = glewGetExtension("GL_NV_primitive_restart"); + if (glewExperimental || GLEW_NV_primitive_restart) CONST_CAST(GLEW_NV_primitive_restart) = !_glewInit_GL_NV_primitive_restart(GLEW_CONTEXT_ARG_VAR_INIT); +#endif /* GL_NV_primitive_restart */ +#ifdef GL_NV_register_combiners + CONST_CAST(GLEW_NV_register_combiners) = glewGetExtension("GL_NV_register_combiners"); + if (glewExperimental || GLEW_NV_register_combiners) CONST_CAST(GLEW_NV_register_combiners) = !_glewInit_GL_NV_register_combiners(GLEW_CONTEXT_ARG_VAR_INIT); +#endif /* GL_NV_register_combiners */ +#ifdef GL_NV_register_combiners2 + CONST_CAST(GLEW_NV_register_combiners2) = glewGetExtension("GL_NV_register_combiners2"); + if (glewExperimental || GLEW_NV_register_combiners2) CONST_CAST(GLEW_NV_register_combiners2) = !_glewInit_GL_NV_register_combiners2(GLEW_CONTEXT_ARG_VAR_INIT); +#endif /* GL_NV_register_combiners2 */ +#ifdef GL_NV_texgen_emboss + CONST_CAST(GLEW_NV_texgen_emboss) = glewGetExtension("GL_NV_texgen_emboss"); +#endif /* GL_NV_texgen_emboss */ +#ifdef GL_NV_texgen_reflection + CONST_CAST(GLEW_NV_texgen_reflection) = glewGetExtension("GL_NV_texgen_reflection"); +#endif /* GL_NV_texgen_reflection */ +#ifdef GL_NV_texture_compression_vtc + CONST_CAST(GLEW_NV_texture_compression_vtc) = glewGetExtension("GL_NV_texture_compression_vtc"); +#endif /* GL_NV_texture_compression_vtc */ +#ifdef GL_NV_texture_env_combine4 + CONST_CAST(GLEW_NV_texture_env_combine4) = glewGetExtension("GL_NV_texture_env_combine4"); +#endif /* GL_NV_texture_env_combine4 */ +#ifdef GL_NV_texture_expand_normal + CONST_CAST(GLEW_NV_texture_expand_normal) = glewGetExtension("GL_NV_texture_expand_normal"); +#endif /* GL_NV_texture_expand_normal */ +#ifdef GL_NV_texture_rectangle + CONST_CAST(GLEW_NV_texture_rectangle) = glewGetExtension("GL_NV_texture_rectangle"); +#endif /* GL_NV_texture_rectangle */ +#ifdef GL_NV_texture_shader + CONST_CAST(GLEW_NV_texture_shader) = glewGetExtension("GL_NV_texture_shader"); +#endif /* GL_NV_texture_shader */ +#ifdef GL_NV_texture_shader2 + CONST_CAST(GLEW_NV_texture_shader2) = glewGetExtension("GL_NV_texture_shader2"); +#endif /* GL_NV_texture_shader2 */ +#ifdef GL_NV_texture_shader3 + CONST_CAST(GLEW_NV_texture_shader3) = glewGetExtension("GL_NV_texture_shader3"); +#endif /* GL_NV_texture_shader3 */ +#ifdef GL_NV_transform_feedback + CONST_CAST(GLEW_NV_transform_feedback) = glewGetExtension("GL_NV_transform_feedback"); + if (glewExperimental || GLEW_NV_transform_feedback) CONST_CAST(GLEW_NV_transform_feedback) = !_glewInit_GL_NV_transform_feedback(GLEW_CONTEXT_ARG_VAR_INIT); +#endif /* GL_NV_transform_feedback */ +#ifdef GL_NV_vertex_array_range + CONST_CAST(GLEW_NV_vertex_array_range) = glewGetExtension("GL_NV_vertex_array_range"); + if (glewExperimental || GLEW_NV_vertex_array_range) CONST_CAST(GLEW_NV_vertex_array_range) = !_glewInit_GL_NV_vertex_array_range(GLEW_CONTEXT_ARG_VAR_INIT); +#endif /* GL_NV_vertex_array_range */ +#ifdef GL_NV_vertex_array_range2 + CONST_CAST(GLEW_NV_vertex_array_range2) = glewGetExtension("GL_NV_vertex_array_range2"); +#endif /* GL_NV_vertex_array_range2 */ +#ifdef GL_NV_vertex_program + CONST_CAST(GLEW_NV_vertex_program) = glewGetExtension("GL_NV_vertex_program"); + if (glewExperimental || GLEW_NV_vertex_program) CONST_CAST(GLEW_NV_vertex_program) = !_glewInit_GL_NV_vertex_program(GLEW_CONTEXT_ARG_VAR_INIT); +#endif /* GL_NV_vertex_program */ +#ifdef GL_NV_vertex_program1_1 + CONST_CAST(GLEW_NV_vertex_program1_1) = glewGetExtension("GL_NV_vertex_program1_1"); +#endif /* GL_NV_vertex_program1_1 */ +#ifdef GL_NV_vertex_program2 + CONST_CAST(GLEW_NV_vertex_program2) = glewGetExtension("GL_NV_vertex_program2"); +#endif /* GL_NV_vertex_program2 */ +#ifdef GL_NV_vertex_program2_option + CONST_CAST(GLEW_NV_vertex_program2_option) = glewGetExtension("GL_NV_vertex_program2_option"); +#endif /* GL_NV_vertex_program2_option */ +#ifdef GL_NV_vertex_program3 + CONST_CAST(GLEW_NV_vertex_program3) = glewGetExtension("GL_NV_vertex_program3"); +#endif /* GL_NV_vertex_program3 */ +#ifdef GL_NV_vertex_program4 + CONST_CAST(GLEW_NV_vertex_program4) = glewGetExtension("GL_NV_vertex_program4"); +#endif /* GL_NV_vertex_program4 */ +#ifdef GL_OES_byte_coordinates + CONST_CAST(GLEW_OES_byte_coordinates) = glewGetExtension("GL_OES_byte_coordinates"); +#endif /* GL_OES_byte_coordinates */ +#ifdef GL_OES_compressed_paletted_texture + CONST_CAST(GLEW_OES_compressed_paletted_texture) = glewGetExtension("GL_OES_compressed_paletted_texture"); +#endif /* GL_OES_compressed_paletted_texture */ +#ifdef GL_OES_read_format + CONST_CAST(GLEW_OES_read_format) = glewGetExtension("GL_OES_read_format"); +#endif /* GL_OES_read_format */ +#ifdef GL_OES_single_precision + CONST_CAST(GLEW_OES_single_precision) = glewGetExtension("GL_OES_single_precision"); + if (glewExperimental || GLEW_OES_single_precision) CONST_CAST(GLEW_OES_single_precision) = !_glewInit_GL_OES_single_precision(GLEW_CONTEXT_ARG_VAR_INIT); +#endif /* GL_OES_single_precision */ +#ifdef GL_OML_interlace + CONST_CAST(GLEW_OML_interlace) = glewGetExtension("GL_OML_interlace"); +#endif /* GL_OML_interlace */ +#ifdef GL_OML_resample + CONST_CAST(GLEW_OML_resample) = glewGetExtension("GL_OML_resample"); +#endif /* GL_OML_resample */ +#ifdef GL_OML_subsample + CONST_CAST(GLEW_OML_subsample) = glewGetExtension("GL_OML_subsample"); +#endif /* GL_OML_subsample */ +#ifdef GL_PGI_misc_hints + CONST_CAST(GLEW_PGI_misc_hints) = glewGetExtension("GL_PGI_misc_hints"); +#endif /* GL_PGI_misc_hints */ +#ifdef GL_PGI_vertex_hints + CONST_CAST(GLEW_PGI_vertex_hints) = glewGetExtension("GL_PGI_vertex_hints"); +#endif /* GL_PGI_vertex_hints */ +#ifdef GL_REND_screen_coordinates + CONST_CAST(GLEW_REND_screen_coordinates) = glewGetExtension("GL_REND_screen_coordinates"); +#endif /* GL_REND_screen_coordinates */ +#ifdef GL_S3_s3tc + CONST_CAST(GLEW_S3_s3tc) = glewGetExtension("GL_S3_s3tc"); +#endif /* GL_S3_s3tc */ +#ifdef GL_SGIS_color_range + CONST_CAST(GLEW_SGIS_color_range) = glewGetExtension("GL_SGIS_color_range"); +#endif /* GL_SGIS_color_range */ +#ifdef GL_SGIS_detail_texture + CONST_CAST(GLEW_SGIS_detail_texture) = glewGetExtension("GL_SGIS_detail_texture"); + if (glewExperimental || GLEW_SGIS_detail_texture) CONST_CAST(GLEW_SGIS_detail_texture) = !_glewInit_GL_SGIS_detail_texture(GLEW_CONTEXT_ARG_VAR_INIT); +#endif /* GL_SGIS_detail_texture */ +#ifdef GL_SGIS_fog_function + CONST_CAST(GLEW_SGIS_fog_function) = glewGetExtension("GL_SGIS_fog_function"); + if (glewExperimental || GLEW_SGIS_fog_function) CONST_CAST(GLEW_SGIS_fog_function) = !_glewInit_GL_SGIS_fog_function(GLEW_CONTEXT_ARG_VAR_INIT); +#endif /* GL_SGIS_fog_function */ +#ifdef GL_SGIS_generate_mipmap + CONST_CAST(GLEW_SGIS_generate_mipmap) = glewGetExtension("GL_SGIS_generate_mipmap"); +#endif /* GL_SGIS_generate_mipmap */ +#ifdef GL_SGIS_multisample + CONST_CAST(GLEW_SGIS_multisample) = glewGetExtension("GL_SGIS_multisample"); + if (glewExperimental || GLEW_SGIS_multisample) CONST_CAST(GLEW_SGIS_multisample) = !_glewInit_GL_SGIS_multisample(GLEW_CONTEXT_ARG_VAR_INIT); +#endif /* GL_SGIS_multisample */ +#ifdef GL_SGIS_pixel_texture + CONST_CAST(GLEW_SGIS_pixel_texture) = glewGetExtension("GL_SGIS_pixel_texture"); +#endif /* GL_SGIS_pixel_texture */ +#ifdef GL_SGIS_point_line_texgen + CONST_CAST(GLEW_SGIS_point_line_texgen) = glewGetExtension("GL_SGIS_point_line_texgen"); +#endif /* GL_SGIS_point_line_texgen */ +#ifdef GL_SGIS_sharpen_texture + CONST_CAST(GLEW_SGIS_sharpen_texture) = glewGetExtension("GL_SGIS_sharpen_texture"); + if (glewExperimental || GLEW_SGIS_sharpen_texture) CONST_CAST(GLEW_SGIS_sharpen_texture) = !_glewInit_GL_SGIS_sharpen_texture(GLEW_CONTEXT_ARG_VAR_INIT); +#endif /* GL_SGIS_sharpen_texture */ +#ifdef GL_SGIS_texture4D + CONST_CAST(GLEW_SGIS_texture4D) = glewGetExtension("GL_SGIS_texture4D"); + if (glewExperimental || GLEW_SGIS_texture4D) CONST_CAST(GLEW_SGIS_texture4D) = !_glewInit_GL_SGIS_texture4D(GLEW_CONTEXT_ARG_VAR_INIT); +#endif /* GL_SGIS_texture4D */ +#ifdef GL_SGIS_texture_border_clamp + CONST_CAST(GLEW_SGIS_texture_border_clamp) = glewGetExtension("GL_SGIS_texture_border_clamp"); +#endif /* GL_SGIS_texture_border_clamp */ +#ifdef GL_SGIS_texture_edge_clamp + CONST_CAST(GLEW_SGIS_texture_edge_clamp) = glewGetExtension("GL_SGIS_texture_edge_clamp"); +#endif /* GL_SGIS_texture_edge_clamp */ +#ifdef GL_SGIS_texture_filter4 + CONST_CAST(GLEW_SGIS_texture_filter4) = glewGetExtension("GL_SGIS_texture_filter4"); + if (glewExperimental || GLEW_SGIS_texture_filter4) CONST_CAST(GLEW_SGIS_texture_filter4) = !_glewInit_GL_SGIS_texture_filter4(GLEW_CONTEXT_ARG_VAR_INIT); +#endif /* GL_SGIS_texture_filter4 */ +#ifdef GL_SGIS_texture_lod + CONST_CAST(GLEW_SGIS_texture_lod) = glewGetExtension("GL_SGIS_texture_lod"); +#endif /* GL_SGIS_texture_lod */ +#ifdef GL_SGIS_texture_select + CONST_CAST(GLEW_SGIS_texture_select) = glewGetExtension("GL_SGIS_texture_select"); +#endif /* GL_SGIS_texture_select */ +#ifdef GL_SGIX_async + CONST_CAST(GLEW_SGIX_async) = glewGetExtension("GL_SGIX_async"); + if (glewExperimental || GLEW_SGIX_async) CONST_CAST(GLEW_SGIX_async) = !_glewInit_GL_SGIX_async(GLEW_CONTEXT_ARG_VAR_INIT); +#endif /* GL_SGIX_async */ +#ifdef GL_SGIX_async_histogram + CONST_CAST(GLEW_SGIX_async_histogram) = glewGetExtension("GL_SGIX_async_histogram"); +#endif /* GL_SGIX_async_histogram */ +#ifdef GL_SGIX_async_pixel + CONST_CAST(GLEW_SGIX_async_pixel) = glewGetExtension("GL_SGIX_async_pixel"); +#endif /* GL_SGIX_async_pixel */ +#ifdef GL_SGIX_blend_alpha_minmax + CONST_CAST(GLEW_SGIX_blend_alpha_minmax) = glewGetExtension("GL_SGIX_blend_alpha_minmax"); +#endif /* GL_SGIX_blend_alpha_minmax */ +#ifdef GL_SGIX_clipmap + CONST_CAST(GLEW_SGIX_clipmap) = glewGetExtension("GL_SGIX_clipmap"); +#endif /* GL_SGIX_clipmap */ +#ifdef GL_SGIX_convolution_accuracy + CONST_CAST(GLEW_SGIX_convolution_accuracy) = glewGetExtension("GL_SGIX_convolution_accuracy"); +#endif /* GL_SGIX_convolution_accuracy */ +#ifdef GL_SGIX_depth_texture + CONST_CAST(GLEW_SGIX_depth_texture) = glewGetExtension("GL_SGIX_depth_texture"); +#endif /* GL_SGIX_depth_texture */ +#ifdef GL_SGIX_flush_raster + CONST_CAST(GLEW_SGIX_flush_raster) = glewGetExtension("GL_SGIX_flush_raster"); + if (glewExperimental || GLEW_SGIX_flush_raster) CONST_CAST(GLEW_SGIX_flush_raster) = !_glewInit_GL_SGIX_flush_raster(GLEW_CONTEXT_ARG_VAR_INIT); +#endif /* GL_SGIX_flush_raster */ +#ifdef GL_SGIX_fog_offset + CONST_CAST(GLEW_SGIX_fog_offset) = glewGetExtension("GL_SGIX_fog_offset"); +#endif /* GL_SGIX_fog_offset */ +#ifdef GL_SGIX_fog_texture + CONST_CAST(GLEW_SGIX_fog_texture) = glewGetExtension("GL_SGIX_fog_texture"); + if (glewExperimental || GLEW_SGIX_fog_texture) CONST_CAST(GLEW_SGIX_fog_texture) = !_glewInit_GL_SGIX_fog_texture(GLEW_CONTEXT_ARG_VAR_INIT); +#endif /* GL_SGIX_fog_texture */ +#ifdef GL_SGIX_fragment_specular_lighting + CONST_CAST(GLEW_SGIX_fragment_specular_lighting) = glewGetExtension("GL_SGIX_fragment_specular_lighting"); + if (glewExperimental || GLEW_SGIX_fragment_specular_lighting) CONST_CAST(GLEW_SGIX_fragment_specular_lighting) = !_glewInit_GL_SGIX_fragment_specular_lighting(GLEW_CONTEXT_ARG_VAR_INIT); +#endif /* GL_SGIX_fragment_specular_lighting */ +#ifdef GL_SGIX_framezoom + CONST_CAST(GLEW_SGIX_framezoom) = glewGetExtension("GL_SGIX_framezoom"); + if (glewExperimental || GLEW_SGIX_framezoom) CONST_CAST(GLEW_SGIX_framezoom) = !_glewInit_GL_SGIX_framezoom(GLEW_CONTEXT_ARG_VAR_INIT); +#endif /* GL_SGIX_framezoom */ +#ifdef GL_SGIX_interlace + CONST_CAST(GLEW_SGIX_interlace) = glewGetExtension("GL_SGIX_interlace"); +#endif /* GL_SGIX_interlace */ +#ifdef GL_SGIX_ir_instrument1 + CONST_CAST(GLEW_SGIX_ir_instrument1) = glewGetExtension("GL_SGIX_ir_instrument1"); +#endif /* GL_SGIX_ir_instrument1 */ +#ifdef GL_SGIX_list_priority + CONST_CAST(GLEW_SGIX_list_priority) = glewGetExtension("GL_SGIX_list_priority"); +#endif /* GL_SGIX_list_priority */ +#ifdef GL_SGIX_pixel_texture + CONST_CAST(GLEW_SGIX_pixel_texture) = glewGetExtension("GL_SGIX_pixel_texture"); + if (glewExperimental || GLEW_SGIX_pixel_texture) CONST_CAST(GLEW_SGIX_pixel_texture) = !_glewInit_GL_SGIX_pixel_texture(GLEW_CONTEXT_ARG_VAR_INIT); +#endif /* GL_SGIX_pixel_texture */ +#ifdef GL_SGIX_pixel_texture_bits + CONST_CAST(GLEW_SGIX_pixel_texture_bits) = glewGetExtension("GL_SGIX_pixel_texture_bits"); +#endif /* GL_SGIX_pixel_texture_bits */ +#ifdef GL_SGIX_reference_plane + CONST_CAST(GLEW_SGIX_reference_plane) = glewGetExtension("GL_SGIX_reference_plane"); + if (glewExperimental || GLEW_SGIX_reference_plane) CONST_CAST(GLEW_SGIX_reference_plane) = !_glewInit_GL_SGIX_reference_plane(GLEW_CONTEXT_ARG_VAR_INIT); +#endif /* GL_SGIX_reference_plane */ +#ifdef GL_SGIX_resample + CONST_CAST(GLEW_SGIX_resample) = glewGetExtension("GL_SGIX_resample"); +#endif /* GL_SGIX_resample */ +#ifdef GL_SGIX_shadow + CONST_CAST(GLEW_SGIX_shadow) = glewGetExtension("GL_SGIX_shadow"); +#endif /* GL_SGIX_shadow */ +#ifdef GL_SGIX_shadow_ambient + CONST_CAST(GLEW_SGIX_shadow_ambient) = glewGetExtension("GL_SGIX_shadow_ambient"); +#endif /* GL_SGIX_shadow_ambient */ +#ifdef GL_SGIX_sprite + CONST_CAST(GLEW_SGIX_sprite) = glewGetExtension("GL_SGIX_sprite"); + if (glewExperimental || GLEW_SGIX_sprite) CONST_CAST(GLEW_SGIX_sprite) = !_glewInit_GL_SGIX_sprite(GLEW_CONTEXT_ARG_VAR_INIT); +#endif /* GL_SGIX_sprite */ +#ifdef GL_SGIX_tag_sample_buffer + CONST_CAST(GLEW_SGIX_tag_sample_buffer) = glewGetExtension("GL_SGIX_tag_sample_buffer"); + if (glewExperimental || GLEW_SGIX_tag_sample_buffer) CONST_CAST(GLEW_SGIX_tag_sample_buffer) = !_glewInit_GL_SGIX_tag_sample_buffer(GLEW_CONTEXT_ARG_VAR_INIT); +#endif /* GL_SGIX_tag_sample_buffer */ +#ifdef GL_SGIX_texture_add_env + CONST_CAST(GLEW_SGIX_texture_add_env) = glewGetExtension("GL_SGIX_texture_add_env"); +#endif /* GL_SGIX_texture_add_env */ +#ifdef GL_SGIX_texture_coordinate_clamp + CONST_CAST(GLEW_SGIX_texture_coordinate_clamp) = glewGetExtension("GL_SGIX_texture_coordinate_clamp"); +#endif /* GL_SGIX_texture_coordinate_clamp */ +#ifdef GL_SGIX_texture_lod_bias + CONST_CAST(GLEW_SGIX_texture_lod_bias) = glewGetExtension("GL_SGIX_texture_lod_bias"); +#endif /* GL_SGIX_texture_lod_bias */ +#ifdef GL_SGIX_texture_multi_buffer + CONST_CAST(GLEW_SGIX_texture_multi_buffer) = glewGetExtension("GL_SGIX_texture_multi_buffer"); +#endif /* GL_SGIX_texture_multi_buffer */ +#ifdef GL_SGIX_texture_range + CONST_CAST(GLEW_SGIX_texture_range) = glewGetExtension("GL_SGIX_texture_range"); +#endif /* GL_SGIX_texture_range */ +#ifdef GL_SGIX_texture_scale_bias + CONST_CAST(GLEW_SGIX_texture_scale_bias) = glewGetExtension("GL_SGIX_texture_scale_bias"); +#endif /* GL_SGIX_texture_scale_bias */ +#ifdef GL_SGIX_vertex_preclip + CONST_CAST(GLEW_SGIX_vertex_preclip) = glewGetExtension("GL_SGIX_vertex_preclip"); +#endif /* GL_SGIX_vertex_preclip */ +#ifdef GL_SGIX_vertex_preclip_hint + CONST_CAST(GLEW_SGIX_vertex_preclip_hint) = glewGetExtension("GL_SGIX_vertex_preclip_hint"); +#endif /* GL_SGIX_vertex_preclip_hint */ +#ifdef GL_SGIX_ycrcb + CONST_CAST(GLEW_SGIX_ycrcb) = glewGetExtension("GL_SGIX_ycrcb"); +#endif /* GL_SGIX_ycrcb */ +#ifdef GL_SGI_color_matrix + CONST_CAST(GLEW_SGI_color_matrix) = glewGetExtension("GL_SGI_color_matrix"); +#endif /* GL_SGI_color_matrix */ +#ifdef GL_SGI_color_table + CONST_CAST(GLEW_SGI_color_table) = glewGetExtension("GL_SGI_color_table"); + if (glewExperimental || GLEW_SGI_color_table) CONST_CAST(GLEW_SGI_color_table) = !_glewInit_GL_SGI_color_table(GLEW_CONTEXT_ARG_VAR_INIT); +#endif /* GL_SGI_color_table */ +#ifdef GL_SGI_texture_color_table + CONST_CAST(GLEW_SGI_texture_color_table) = glewGetExtension("GL_SGI_texture_color_table"); +#endif /* GL_SGI_texture_color_table */ +#ifdef GL_SUNX_constant_data + CONST_CAST(GLEW_SUNX_constant_data) = glewGetExtension("GL_SUNX_constant_data"); + if (glewExperimental || GLEW_SUNX_constant_data) CONST_CAST(GLEW_SUNX_constant_data) = !_glewInit_GL_SUNX_constant_data(GLEW_CONTEXT_ARG_VAR_INIT); +#endif /* GL_SUNX_constant_data */ +#ifdef GL_SUN_convolution_border_modes + CONST_CAST(GLEW_SUN_convolution_border_modes) = glewGetExtension("GL_SUN_convolution_border_modes"); +#endif /* GL_SUN_convolution_border_modes */ +#ifdef GL_SUN_global_alpha + CONST_CAST(GLEW_SUN_global_alpha) = glewGetExtension("GL_SUN_global_alpha"); + if (glewExperimental || GLEW_SUN_global_alpha) CONST_CAST(GLEW_SUN_global_alpha) = !_glewInit_GL_SUN_global_alpha(GLEW_CONTEXT_ARG_VAR_INIT); +#endif /* GL_SUN_global_alpha */ +#ifdef GL_SUN_mesh_array + CONST_CAST(GLEW_SUN_mesh_array) = glewGetExtension("GL_SUN_mesh_array"); +#endif /* GL_SUN_mesh_array */ +#ifdef GL_SUN_read_video_pixels + CONST_CAST(GLEW_SUN_read_video_pixels) = glewGetExtension("GL_SUN_read_video_pixels"); + if (glewExperimental || GLEW_SUN_read_video_pixels) CONST_CAST(GLEW_SUN_read_video_pixels) = !_glewInit_GL_SUN_read_video_pixels(GLEW_CONTEXT_ARG_VAR_INIT); +#endif /* GL_SUN_read_video_pixels */ +#ifdef GL_SUN_slice_accum + CONST_CAST(GLEW_SUN_slice_accum) = glewGetExtension("GL_SUN_slice_accum"); +#endif /* GL_SUN_slice_accum */ +#ifdef GL_SUN_triangle_list + CONST_CAST(GLEW_SUN_triangle_list) = glewGetExtension("GL_SUN_triangle_list"); + if (glewExperimental || GLEW_SUN_triangle_list) CONST_CAST(GLEW_SUN_triangle_list) = !_glewInit_GL_SUN_triangle_list(GLEW_CONTEXT_ARG_VAR_INIT); +#endif /* GL_SUN_triangle_list */ +#ifdef GL_SUN_vertex + CONST_CAST(GLEW_SUN_vertex) = glewGetExtension("GL_SUN_vertex"); + if (glewExperimental || GLEW_SUN_vertex) CONST_CAST(GLEW_SUN_vertex) = !_glewInit_GL_SUN_vertex(GLEW_CONTEXT_ARG_VAR_INIT); +#endif /* GL_SUN_vertex */ +#ifdef GL_WIN_phong_shading + CONST_CAST(GLEW_WIN_phong_shading) = glewGetExtension("GL_WIN_phong_shading"); +#endif /* GL_WIN_phong_shading */ +#ifdef GL_WIN_specular_fog + CONST_CAST(GLEW_WIN_specular_fog) = glewGetExtension("GL_WIN_specular_fog"); +#endif /* GL_WIN_specular_fog */ +#ifdef GL_WIN_swap_hint + CONST_CAST(GLEW_WIN_swap_hint) = glewGetExtension("GL_WIN_swap_hint"); + if (glewExperimental || GLEW_WIN_swap_hint) CONST_CAST(GLEW_WIN_swap_hint) = !_glewInit_GL_WIN_swap_hint(GLEW_CONTEXT_ARG_VAR_INIT); +#endif /* GL_WIN_swap_hint */ + + return GLEW_OK; +} + + +#if defined(_WIN32) + +#if !defined(GLEW_MX) + +PFNWGLSETSTEREOEMITTERSTATE3DLPROC __wglewSetStereoEmitterState3DL = NULL; + +PFNWGLCREATEBUFFERREGIONARBPROC __wglewCreateBufferRegionARB = NULL; +PFNWGLDELETEBUFFERREGIONARBPROC __wglewDeleteBufferRegionARB = NULL; +PFNWGLRESTOREBUFFERREGIONARBPROC __wglewRestoreBufferRegionARB = NULL; +PFNWGLSAVEBUFFERREGIONARBPROC __wglewSaveBufferRegionARB = NULL; + +PFNWGLCREATECONTEXTATTRIBSARBPROC __wglewCreateContextAttribsARB = NULL; + +PFNWGLGETEXTENSIONSSTRINGARBPROC __wglewGetExtensionsStringARB = NULL; + +PFNWGLGETCURRENTREADDCARBPROC __wglewGetCurrentReadDCARB = NULL; +PFNWGLMAKECONTEXTCURRENTARBPROC __wglewMakeContextCurrentARB = NULL; + +PFNWGLCREATEPBUFFERARBPROC __wglewCreatePbufferARB = NULL; +PFNWGLDESTROYPBUFFERARBPROC __wglewDestroyPbufferARB = NULL; +PFNWGLGETPBUFFERDCARBPROC __wglewGetPbufferDCARB = NULL; +PFNWGLQUERYPBUFFERARBPROC __wglewQueryPbufferARB = NULL; +PFNWGLRELEASEPBUFFERDCARBPROC __wglewReleasePbufferDCARB = NULL; + +PFNWGLCHOOSEPIXELFORMATARBPROC __wglewChoosePixelFormatARB = NULL; +PFNWGLGETPIXELFORMATATTRIBFVARBPROC __wglewGetPixelFormatAttribfvARB = NULL; +PFNWGLGETPIXELFORMATATTRIBIVARBPROC __wglewGetPixelFormatAttribivARB = NULL; + +PFNWGLBINDTEXIMAGEARBPROC __wglewBindTexImageARB = NULL; +PFNWGLRELEASETEXIMAGEARBPROC __wglewReleaseTexImageARB = NULL; +PFNWGLSETPBUFFERATTRIBARBPROC __wglewSetPbufferAttribARB = NULL; + +PFNWGLBINDDISPLAYCOLORTABLEEXTPROC __wglewBindDisplayColorTableEXT = NULL; +PFNWGLCREATEDISPLAYCOLORTABLEEXTPROC __wglewCreateDisplayColorTableEXT = NULL; +PFNWGLDESTROYDISPLAYCOLORTABLEEXTPROC __wglewDestroyDisplayColorTableEXT = NULL; +PFNWGLLOADDISPLAYCOLORTABLEEXTPROC __wglewLoadDisplayColorTableEXT = NULL; + +PFNWGLGETEXTENSIONSSTRINGEXTPROC __wglewGetExtensionsStringEXT = NULL; + +PFNWGLGETCURRENTREADDCEXTPROC __wglewGetCurrentReadDCEXT = NULL; +PFNWGLMAKECONTEXTCURRENTEXTPROC __wglewMakeContextCurrentEXT = NULL; + +PFNWGLCREATEPBUFFEREXTPROC __wglewCreatePbufferEXT = NULL; +PFNWGLDESTROYPBUFFEREXTPROC __wglewDestroyPbufferEXT = NULL; +PFNWGLGETPBUFFERDCEXTPROC __wglewGetPbufferDCEXT = NULL; +PFNWGLQUERYPBUFFEREXTPROC __wglewQueryPbufferEXT = NULL; +PFNWGLRELEASEPBUFFERDCEXTPROC __wglewReleasePbufferDCEXT = NULL; + +PFNWGLCHOOSEPIXELFORMATEXTPROC __wglewChoosePixelFormatEXT = NULL; +PFNWGLGETPIXELFORMATATTRIBFVEXTPROC __wglewGetPixelFormatAttribfvEXT = NULL; +PFNWGLGETPIXELFORMATATTRIBIVEXTPROC __wglewGetPixelFormatAttribivEXT = NULL; + +PFNWGLGETSWAPINTERVALEXTPROC __wglewGetSwapIntervalEXT = NULL; +PFNWGLSWAPINTERVALEXTPROC __wglewSwapIntervalEXT = NULL; + +PFNWGLGETDIGITALVIDEOPARAMETERSI3DPROC __wglewGetDigitalVideoParametersI3D = NULL; +PFNWGLSETDIGITALVIDEOPARAMETERSI3DPROC __wglewSetDigitalVideoParametersI3D = NULL; + +PFNWGLGETGAMMATABLEI3DPROC __wglewGetGammaTableI3D = NULL; +PFNWGLGETGAMMATABLEPARAMETERSI3DPROC __wglewGetGammaTableParametersI3D = NULL; +PFNWGLSETGAMMATABLEI3DPROC __wglewSetGammaTableI3D = NULL; +PFNWGLSETGAMMATABLEPARAMETERSI3DPROC __wglewSetGammaTableParametersI3D = NULL; + +PFNWGLDISABLEGENLOCKI3DPROC __wglewDisableGenlockI3D = NULL; +PFNWGLENABLEGENLOCKI3DPROC __wglewEnableGenlockI3D = NULL; +PFNWGLGENLOCKSAMPLERATEI3DPROC __wglewGenlockSampleRateI3D = NULL; +PFNWGLGENLOCKSOURCEDELAYI3DPROC __wglewGenlockSourceDelayI3D = NULL; +PFNWGLGENLOCKSOURCEEDGEI3DPROC __wglewGenlockSourceEdgeI3D = NULL; +PFNWGLGENLOCKSOURCEI3DPROC __wglewGenlockSourceI3D = NULL; +PFNWGLGETGENLOCKSAMPLERATEI3DPROC __wglewGetGenlockSampleRateI3D = NULL; +PFNWGLGETGENLOCKSOURCEDELAYI3DPROC __wglewGetGenlockSourceDelayI3D = NULL; +PFNWGLGETGENLOCKSOURCEEDGEI3DPROC __wglewGetGenlockSourceEdgeI3D = NULL; +PFNWGLGETGENLOCKSOURCEI3DPROC __wglewGetGenlockSourceI3D = NULL; +PFNWGLISENABLEDGENLOCKI3DPROC __wglewIsEnabledGenlockI3D = NULL; +PFNWGLQUERYGENLOCKMAXSOURCEDELAYI3DPROC __wglewQueryGenlockMaxSourceDelayI3D = NULL; + +PFNWGLASSOCIATEIMAGEBUFFEREVENTSI3DPROC __wglewAssociateImageBufferEventsI3D = NULL; +PFNWGLCREATEIMAGEBUFFERI3DPROC __wglewCreateImageBufferI3D = NULL; +PFNWGLDESTROYIMAGEBUFFERI3DPROC __wglewDestroyImageBufferI3D = NULL; +PFNWGLRELEASEIMAGEBUFFEREVENTSI3DPROC __wglewReleaseImageBufferEventsI3D = NULL; + +PFNWGLDISABLEFRAMELOCKI3DPROC __wglewDisableFrameLockI3D = NULL; +PFNWGLENABLEFRAMELOCKI3DPROC __wglewEnableFrameLockI3D = NULL; +PFNWGLISENABLEDFRAMELOCKI3DPROC __wglewIsEnabledFrameLockI3D = NULL; +PFNWGLQUERYFRAMELOCKMASTERI3DPROC __wglewQueryFrameLockMasterI3D = NULL; + +PFNWGLBEGINFRAMETRACKINGI3DPROC __wglewBeginFrameTrackingI3D = NULL; +PFNWGLENDFRAMETRACKINGI3DPROC __wglewEndFrameTrackingI3D = NULL; +PFNWGLGETFRAMEUSAGEI3DPROC __wglewGetFrameUsageI3D = NULL; +PFNWGLQUERYFRAMETRACKINGI3DPROC __wglewQueryFrameTrackingI3D = NULL; + +PFNWGLCREATEAFFINITYDCNVPROC __wglewCreateAffinityDCNV = NULL; +PFNWGLDELETEDCNVPROC __wglewDeleteDCNV = NULL; +PFNWGLENUMGPUDEVICESNVPROC __wglewEnumGpuDevicesNV = NULL; +PFNWGLENUMGPUSFROMAFFINITYDCNVPROC __wglewEnumGpusFromAffinityDCNV = NULL; +PFNWGLENUMGPUSNVPROC __wglewEnumGpusNV = NULL; + +PFNWGLBINDVIDEODEVICENVPROC __wglewBindVideoDeviceNV = NULL; +PFNWGLENUMERATEVIDEODEVICESNVPROC __wglewEnumerateVideoDevicesNV = NULL; +PFNWGLQUERYCURRENTCONTEXTNVPROC __wglewQueryCurrentContextNV = NULL; + +PFNWGLBINDSWAPBARRIERNVPROC __wglewBindSwapBarrierNV = NULL; +PFNWGLJOINSWAPGROUPNVPROC __wglewJoinSwapGroupNV = NULL; +PFNWGLQUERYFRAMECOUNTNVPROC __wglewQueryFrameCountNV = NULL; +PFNWGLQUERYMAXSWAPGROUPSNVPROC __wglewQueryMaxSwapGroupsNV = NULL; +PFNWGLQUERYSWAPGROUPNVPROC __wglewQuerySwapGroupNV = NULL; +PFNWGLRESETFRAMECOUNTNVPROC __wglewResetFrameCountNV = NULL; + +PFNWGLALLOCATEMEMORYNVPROC __wglewAllocateMemoryNV = NULL; +PFNWGLFREEMEMORYNVPROC __wglewFreeMemoryNV = NULL; + +PFNWGLBINDVIDEOIMAGENVPROC __wglewBindVideoImageNV = NULL; +PFNWGLGETVIDEODEVICENVPROC __wglewGetVideoDeviceNV = NULL; +PFNWGLGETVIDEOINFONVPROC __wglewGetVideoInfoNV = NULL; +PFNWGLRELEASEVIDEODEVICENVPROC __wglewReleaseVideoDeviceNV = NULL; +PFNWGLRELEASEVIDEOIMAGENVPROC __wglewReleaseVideoImageNV = NULL; +PFNWGLSENDPBUFFERTOVIDEONVPROC __wglewSendPbufferToVideoNV = NULL; + +PFNWGLGETMSCRATEOMLPROC __wglewGetMscRateOML = NULL; +PFNWGLGETSYNCVALUESOMLPROC __wglewGetSyncValuesOML = NULL; +PFNWGLSWAPBUFFERSMSCOMLPROC __wglewSwapBuffersMscOML = NULL; +PFNWGLSWAPLAYERBUFFERSMSCOMLPROC __wglewSwapLayerBuffersMscOML = NULL; +PFNWGLWAITFORMSCOMLPROC __wglewWaitForMscOML = NULL; +PFNWGLWAITFORSBCOMLPROC __wglewWaitForSbcOML = NULL; +GLboolean __WGLEW_3DFX_multisample = GL_FALSE; +GLboolean __WGLEW_3DL_stereo_control = GL_FALSE; +GLboolean __WGLEW_ARB_buffer_region = GL_FALSE; +GLboolean __WGLEW_ARB_create_context = GL_FALSE; +GLboolean __WGLEW_ARB_extensions_string = GL_FALSE; +GLboolean __WGLEW_ARB_framebuffer_sRGB = GL_FALSE; +GLboolean __WGLEW_ARB_make_current_read = GL_FALSE; +GLboolean __WGLEW_ARB_multisample = GL_FALSE; +GLboolean __WGLEW_ARB_pbuffer = GL_FALSE; +GLboolean __WGLEW_ARB_pixel_format = GL_FALSE; +GLboolean __WGLEW_ARB_pixel_format_float = GL_FALSE; +GLboolean __WGLEW_ARB_render_texture = GL_FALSE; +GLboolean __WGLEW_ATI_pixel_format_float = GL_FALSE; +GLboolean __WGLEW_ATI_render_texture_rectangle = GL_FALSE; +GLboolean __WGLEW_EXT_depth_float = GL_FALSE; +GLboolean __WGLEW_EXT_display_color_table = GL_FALSE; +GLboolean __WGLEW_EXT_extensions_string = GL_FALSE; +GLboolean __WGLEW_EXT_framebuffer_sRGB = GL_FALSE; +GLboolean __WGLEW_EXT_make_current_read = GL_FALSE; +GLboolean __WGLEW_EXT_multisample = GL_FALSE; +GLboolean __WGLEW_EXT_pbuffer = GL_FALSE; +GLboolean __WGLEW_EXT_pixel_format = GL_FALSE; +GLboolean __WGLEW_EXT_pixel_format_packed_float = GL_FALSE; +GLboolean __WGLEW_EXT_swap_control = GL_FALSE; +GLboolean __WGLEW_I3D_digital_video_control = GL_FALSE; +GLboolean __WGLEW_I3D_gamma = GL_FALSE; +GLboolean __WGLEW_I3D_genlock = GL_FALSE; +GLboolean __WGLEW_I3D_image_buffer = GL_FALSE; +GLboolean __WGLEW_I3D_swap_frame_lock = GL_FALSE; +GLboolean __WGLEW_I3D_swap_frame_usage = GL_FALSE; +GLboolean __WGLEW_NV_float_buffer = GL_FALSE; +GLboolean __WGLEW_NV_gpu_affinity = GL_FALSE; +GLboolean __WGLEW_NV_present_video = GL_FALSE; +GLboolean __WGLEW_NV_render_depth_texture = GL_FALSE; +GLboolean __WGLEW_NV_render_texture_rectangle = GL_FALSE; +GLboolean __WGLEW_NV_swap_group = GL_FALSE; +GLboolean __WGLEW_NV_vertex_array_range = GL_FALSE; +GLboolean __WGLEW_NV_video_output = GL_FALSE; +GLboolean __WGLEW_OML_sync_control = GL_FALSE; + +#endif /* !GLEW_MX */ + +#ifdef WGL_3DFX_multisample + +#endif /* WGL_3DFX_multisample */ + +#ifdef WGL_3DL_stereo_control + +static GLboolean _glewInit_WGL_3DL_stereo_control (WGLEW_CONTEXT_ARG_DEF_INIT) +{ + GLboolean r = GL_FALSE; + + r = ((wglSetStereoEmitterState3DL = (PFNWGLSETSTEREOEMITTERSTATE3DLPROC)glewGetProcAddress((const GLubyte*)"wglSetStereoEmitterState3DL")) == NULL) || r; + + return r; +} + +#endif /* WGL_3DL_stereo_control */ + +#ifdef WGL_ARB_buffer_region + +static GLboolean _glewInit_WGL_ARB_buffer_region (WGLEW_CONTEXT_ARG_DEF_INIT) +{ + GLboolean r = GL_FALSE; + + r = ((wglCreateBufferRegionARB = (PFNWGLCREATEBUFFERREGIONARBPROC)glewGetProcAddress((const GLubyte*)"wglCreateBufferRegionARB")) == NULL) || r; + r = ((wglDeleteBufferRegionARB = (PFNWGLDELETEBUFFERREGIONARBPROC)glewGetProcAddress((const GLubyte*)"wglDeleteBufferRegionARB")) == NULL) || r; + r = ((wglRestoreBufferRegionARB = (PFNWGLRESTOREBUFFERREGIONARBPROC)glewGetProcAddress((const GLubyte*)"wglRestoreBufferRegionARB")) == NULL) || r; + r = ((wglSaveBufferRegionARB = (PFNWGLSAVEBUFFERREGIONARBPROC)glewGetProcAddress((const GLubyte*)"wglSaveBufferRegionARB")) == NULL) || r; + + return r; +} + +#endif /* WGL_ARB_buffer_region */ + +#ifdef WGL_ARB_create_context + +static GLboolean _glewInit_WGL_ARB_create_context (WGLEW_CONTEXT_ARG_DEF_INIT) +{ + GLboolean r = GL_FALSE; + + r = ((wglCreateContextAttribsARB = (PFNWGLCREATECONTEXTATTRIBSARBPROC)glewGetProcAddress((const GLubyte*)"wglCreateContextAttribsARB")) == NULL) || r; + + return r; +} + +#endif /* WGL_ARB_create_context */ + +#ifdef WGL_ARB_extensions_string + +static GLboolean _glewInit_WGL_ARB_extensions_string (WGLEW_CONTEXT_ARG_DEF_INIT) +{ + GLboolean r = GL_FALSE; + + r = ((wglGetExtensionsStringARB = (PFNWGLGETEXTENSIONSSTRINGARBPROC)glewGetProcAddress((const GLubyte*)"wglGetExtensionsStringARB")) == NULL) || r; + + return r; +} + +#endif /* WGL_ARB_extensions_string */ + +#ifdef WGL_ARB_framebuffer_sRGB + +#endif /* WGL_ARB_framebuffer_sRGB */ + +#ifdef WGL_ARB_make_current_read + +static GLboolean _glewInit_WGL_ARB_make_current_read (WGLEW_CONTEXT_ARG_DEF_INIT) +{ + GLboolean r = GL_FALSE; + + r = ((wglGetCurrentReadDCARB = (PFNWGLGETCURRENTREADDCARBPROC)glewGetProcAddress((const GLubyte*)"wglGetCurrentReadDCARB")) == NULL) || r; + r = ((wglMakeContextCurrentARB = (PFNWGLMAKECONTEXTCURRENTARBPROC)glewGetProcAddress((const GLubyte*)"wglMakeContextCurrentARB")) == NULL) || r; + + return r; +} + +#endif /* WGL_ARB_make_current_read */ + +#ifdef WGL_ARB_multisample + +#endif /* WGL_ARB_multisample */ + +#ifdef WGL_ARB_pbuffer + +static GLboolean _glewInit_WGL_ARB_pbuffer (WGLEW_CONTEXT_ARG_DEF_INIT) +{ + GLboolean r = GL_FALSE; + + r = ((wglCreatePbufferARB = (PFNWGLCREATEPBUFFERARBPROC)glewGetProcAddress((const GLubyte*)"wglCreatePbufferARB")) == NULL) || r; + r = ((wglDestroyPbufferARB = (PFNWGLDESTROYPBUFFERARBPROC)glewGetProcAddress((const GLubyte*)"wglDestroyPbufferARB")) == NULL) || r; + r = ((wglGetPbufferDCARB = (PFNWGLGETPBUFFERDCARBPROC)glewGetProcAddress((const GLubyte*)"wglGetPbufferDCARB")) == NULL) || r; + r = ((wglQueryPbufferARB = (PFNWGLQUERYPBUFFERARBPROC)glewGetProcAddress((const GLubyte*)"wglQueryPbufferARB")) == NULL) || r; + r = ((wglReleasePbufferDCARB = (PFNWGLRELEASEPBUFFERDCARBPROC)glewGetProcAddress((const GLubyte*)"wglReleasePbufferDCARB")) == NULL) || r; + + return r; +} + +#endif /* WGL_ARB_pbuffer */ + +#ifdef WGL_ARB_pixel_format + +static GLboolean _glewInit_WGL_ARB_pixel_format (WGLEW_CONTEXT_ARG_DEF_INIT) +{ + GLboolean r = GL_FALSE; + + r = ((wglChoosePixelFormatARB = (PFNWGLCHOOSEPIXELFORMATARBPROC)glewGetProcAddress((const GLubyte*)"wglChoosePixelFormatARB")) == NULL) || r; + r = ((wglGetPixelFormatAttribfvARB = (PFNWGLGETPIXELFORMATATTRIBFVARBPROC)glewGetProcAddress((const GLubyte*)"wglGetPixelFormatAttribfvARB")) == NULL) || r; + r = ((wglGetPixelFormatAttribivARB = (PFNWGLGETPIXELFORMATATTRIBIVARBPROC)glewGetProcAddress((const GLubyte*)"wglGetPixelFormatAttribivARB")) == NULL) || r; + + return r; +} + +#endif /* WGL_ARB_pixel_format */ + +#ifdef WGL_ARB_pixel_format_float + +#endif /* WGL_ARB_pixel_format_float */ + +#ifdef WGL_ARB_render_texture + +static GLboolean _glewInit_WGL_ARB_render_texture (WGLEW_CONTEXT_ARG_DEF_INIT) +{ + GLboolean r = GL_FALSE; + + r = ((wglBindTexImageARB = (PFNWGLBINDTEXIMAGEARBPROC)glewGetProcAddress((const GLubyte*)"wglBindTexImageARB")) == NULL) || r; + r = ((wglReleaseTexImageARB = (PFNWGLRELEASETEXIMAGEARBPROC)glewGetProcAddress((const GLubyte*)"wglReleaseTexImageARB")) == NULL) || r; + r = ((wglSetPbufferAttribARB = (PFNWGLSETPBUFFERATTRIBARBPROC)glewGetProcAddress((const GLubyte*)"wglSetPbufferAttribARB")) == NULL) || r; + + return r; +} + +#endif /* WGL_ARB_render_texture */ + +#ifdef WGL_ATI_pixel_format_float + +#endif /* WGL_ATI_pixel_format_float */ + +#ifdef WGL_ATI_render_texture_rectangle + +#endif /* WGL_ATI_render_texture_rectangle */ + +#ifdef WGL_EXT_depth_float + +#endif /* WGL_EXT_depth_float */ + +#ifdef WGL_EXT_display_color_table + +static GLboolean _glewInit_WGL_EXT_display_color_table (WGLEW_CONTEXT_ARG_DEF_INIT) +{ + GLboolean r = GL_FALSE; + + r = ((wglBindDisplayColorTableEXT = (PFNWGLBINDDISPLAYCOLORTABLEEXTPROC)glewGetProcAddress((const GLubyte*)"wglBindDisplayColorTableEXT")) == NULL) || r; + r = ((wglCreateDisplayColorTableEXT = (PFNWGLCREATEDISPLAYCOLORTABLEEXTPROC)glewGetProcAddress((const GLubyte*)"wglCreateDisplayColorTableEXT")) == NULL) || r; + r = ((wglDestroyDisplayColorTableEXT = (PFNWGLDESTROYDISPLAYCOLORTABLEEXTPROC)glewGetProcAddress((const GLubyte*)"wglDestroyDisplayColorTableEXT")) == NULL) || r; + r = ((wglLoadDisplayColorTableEXT = (PFNWGLLOADDISPLAYCOLORTABLEEXTPROC)glewGetProcAddress((const GLubyte*)"wglLoadDisplayColorTableEXT")) == NULL) || r; + + return r; +} + +#endif /* WGL_EXT_display_color_table */ + +#ifdef WGL_EXT_extensions_string + +static GLboolean _glewInit_WGL_EXT_extensions_string (WGLEW_CONTEXT_ARG_DEF_INIT) +{ + GLboolean r = GL_FALSE; + + r = ((wglGetExtensionsStringEXT = (PFNWGLGETEXTENSIONSSTRINGEXTPROC)glewGetProcAddress((const GLubyte*)"wglGetExtensionsStringEXT")) == NULL) || r; + + return r; +} + +#endif /* WGL_EXT_extensions_string */ + +#ifdef WGL_EXT_framebuffer_sRGB + +#endif /* WGL_EXT_framebuffer_sRGB */ + +#ifdef WGL_EXT_make_current_read + +static GLboolean _glewInit_WGL_EXT_make_current_read (WGLEW_CONTEXT_ARG_DEF_INIT) +{ + GLboolean r = GL_FALSE; + + r = ((wglGetCurrentReadDCEXT = (PFNWGLGETCURRENTREADDCEXTPROC)glewGetProcAddress((const GLubyte*)"wglGetCurrentReadDCEXT")) == NULL) || r; + r = ((wglMakeContextCurrentEXT = (PFNWGLMAKECONTEXTCURRENTEXTPROC)glewGetProcAddress((const GLubyte*)"wglMakeContextCurrentEXT")) == NULL) || r; + + return r; +} + +#endif /* WGL_EXT_make_current_read */ + +#ifdef WGL_EXT_multisample + +#endif /* WGL_EXT_multisample */ + +#ifdef WGL_EXT_pbuffer + +static GLboolean _glewInit_WGL_EXT_pbuffer (WGLEW_CONTEXT_ARG_DEF_INIT) +{ + GLboolean r = GL_FALSE; + + r = ((wglCreatePbufferEXT = (PFNWGLCREATEPBUFFEREXTPROC)glewGetProcAddress((const GLubyte*)"wglCreatePbufferEXT")) == NULL) || r; + r = ((wglDestroyPbufferEXT = (PFNWGLDESTROYPBUFFEREXTPROC)glewGetProcAddress((const GLubyte*)"wglDestroyPbufferEXT")) == NULL) || r; + r = ((wglGetPbufferDCEXT = (PFNWGLGETPBUFFERDCEXTPROC)glewGetProcAddress((const GLubyte*)"wglGetPbufferDCEXT")) == NULL) || r; + r = ((wglQueryPbufferEXT = (PFNWGLQUERYPBUFFEREXTPROC)glewGetProcAddress((const GLubyte*)"wglQueryPbufferEXT")) == NULL) || r; + r = ((wglReleasePbufferDCEXT = (PFNWGLRELEASEPBUFFERDCEXTPROC)glewGetProcAddress((const GLubyte*)"wglReleasePbufferDCEXT")) == NULL) || r; + + return r; +} + +#endif /* WGL_EXT_pbuffer */ + +#ifdef WGL_EXT_pixel_format + +static GLboolean _glewInit_WGL_EXT_pixel_format (WGLEW_CONTEXT_ARG_DEF_INIT) +{ + GLboolean r = GL_FALSE; + + r = ((wglChoosePixelFormatEXT = (PFNWGLCHOOSEPIXELFORMATEXTPROC)glewGetProcAddress((const GLubyte*)"wglChoosePixelFormatEXT")) == NULL) || r; + r = ((wglGetPixelFormatAttribfvEXT = (PFNWGLGETPIXELFORMATATTRIBFVEXTPROC)glewGetProcAddress((const GLubyte*)"wglGetPixelFormatAttribfvEXT")) == NULL) || r; + r = ((wglGetPixelFormatAttribivEXT = (PFNWGLGETPIXELFORMATATTRIBIVEXTPROC)glewGetProcAddress((const GLubyte*)"wglGetPixelFormatAttribivEXT")) == NULL) || r; + + return r; +} + +#endif /* WGL_EXT_pixel_format */ + +#ifdef WGL_EXT_pixel_format_packed_float + +#endif /* WGL_EXT_pixel_format_packed_float */ + +#ifdef WGL_EXT_swap_control + +static GLboolean _glewInit_WGL_EXT_swap_control (WGLEW_CONTEXT_ARG_DEF_INIT) +{ + GLboolean r = GL_FALSE; + + r = ((wglGetSwapIntervalEXT = (PFNWGLGETSWAPINTERVALEXTPROC)glewGetProcAddress((const GLubyte*)"wglGetSwapIntervalEXT")) == NULL) || r; + r = ((wglSwapIntervalEXT = (PFNWGLSWAPINTERVALEXTPROC)glewGetProcAddress((const GLubyte*)"wglSwapIntervalEXT")) == NULL) || r; + + return r; +} + +#endif /* WGL_EXT_swap_control */ + +#ifdef WGL_I3D_digital_video_control + +static GLboolean _glewInit_WGL_I3D_digital_video_control (WGLEW_CONTEXT_ARG_DEF_INIT) +{ + GLboolean r = GL_FALSE; + + r = ((wglGetDigitalVideoParametersI3D = (PFNWGLGETDIGITALVIDEOPARAMETERSI3DPROC)glewGetProcAddress((const GLubyte*)"wglGetDigitalVideoParametersI3D")) == NULL) || r; + r = ((wglSetDigitalVideoParametersI3D = (PFNWGLSETDIGITALVIDEOPARAMETERSI3DPROC)glewGetProcAddress((const GLubyte*)"wglSetDigitalVideoParametersI3D")) == NULL) || r; + + return r; +} + +#endif /* WGL_I3D_digital_video_control */ + +#ifdef WGL_I3D_gamma + +static GLboolean _glewInit_WGL_I3D_gamma (WGLEW_CONTEXT_ARG_DEF_INIT) +{ + GLboolean r = GL_FALSE; + + r = ((wglGetGammaTableI3D = (PFNWGLGETGAMMATABLEI3DPROC)glewGetProcAddress((const GLubyte*)"wglGetGammaTableI3D")) == NULL) || r; + r = ((wglGetGammaTableParametersI3D = (PFNWGLGETGAMMATABLEPARAMETERSI3DPROC)glewGetProcAddress((const GLubyte*)"wglGetGammaTableParametersI3D")) == NULL) || r; + r = ((wglSetGammaTableI3D = (PFNWGLSETGAMMATABLEI3DPROC)glewGetProcAddress((const GLubyte*)"wglSetGammaTableI3D")) == NULL) || r; + r = ((wglSetGammaTableParametersI3D = (PFNWGLSETGAMMATABLEPARAMETERSI3DPROC)glewGetProcAddress((const GLubyte*)"wglSetGammaTableParametersI3D")) == NULL) || r; + + return r; +} + +#endif /* WGL_I3D_gamma */ + +#ifdef WGL_I3D_genlock + +static GLboolean _glewInit_WGL_I3D_genlock (WGLEW_CONTEXT_ARG_DEF_INIT) +{ + GLboolean r = GL_FALSE; + + r = ((wglDisableGenlockI3D = (PFNWGLDISABLEGENLOCKI3DPROC)glewGetProcAddress((const GLubyte*)"wglDisableGenlockI3D")) == NULL) || r; + r = ((wglEnableGenlockI3D = (PFNWGLENABLEGENLOCKI3DPROC)glewGetProcAddress((const GLubyte*)"wglEnableGenlockI3D")) == NULL) || r; + r = ((wglGenlockSampleRateI3D = (PFNWGLGENLOCKSAMPLERATEI3DPROC)glewGetProcAddress((const GLubyte*)"wglGenlockSampleRateI3D")) == NULL) || r; + r = ((wglGenlockSourceDelayI3D = (PFNWGLGENLOCKSOURCEDELAYI3DPROC)glewGetProcAddress((const GLubyte*)"wglGenlockSourceDelayI3D")) == NULL) || r; + r = ((wglGenlockSourceEdgeI3D = (PFNWGLGENLOCKSOURCEEDGEI3DPROC)glewGetProcAddress((const GLubyte*)"wglGenlockSourceEdgeI3D")) == NULL) || r; + r = ((wglGenlockSourceI3D = (PFNWGLGENLOCKSOURCEI3DPROC)glewGetProcAddress((const GLubyte*)"wglGenlockSourceI3D")) == NULL) || r; + r = ((wglGetGenlockSampleRateI3D = (PFNWGLGETGENLOCKSAMPLERATEI3DPROC)glewGetProcAddress((const GLubyte*)"wglGetGenlockSampleRateI3D")) == NULL) || r; + r = ((wglGetGenlockSourceDelayI3D = (PFNWGLGETGENLOCKSOURCEDELAYI3DPROC)glewGetProcAddress((const GLubyte*)"wglGetGenlockSourceDelayI3D")) == NULL) || r; + r = ((wglGetGenlockSourceEdgeI3D = (PFNWGLGETGENLOCKSOURCEEDGEI3DPROC)glewGetProcAddress((const GLubyte*)"wglGetGenlockSourceEdgeI3D")) == NULL) || r; + r = ((wglGetGenlockSourceI3D = (PFNWGLGETGENLOCKSOURCEI3DPROC)glewGetProcAddress((const GLubyte*)"wglGetGenlockSourceI3D")) == NULL) || r; + r = ((wglIsEnabledGenlockI3D = (PFNWGLISENABLEDGENLOCKI3DPROC)glewGetProcAddress((const GLubyte*)"wglIsEnabledGenlockI3D")) == NULL) || r; + r = ((wglQueryGenlockMaxSourceDelayI3D = (PFNWGLQUERYGENLOCKMAXSOURCEDELAYI3DPROC)glewGetProcAddress((const GLubyte*)"wglQueryGenlockMaxSourceDelayI3D")) == NULL) || r; + + return r; +} + +#endif /* WGL_I3D_genlock */ + +#ifdef WGL_I3D_image_buffer + +static GLboolean _glewInit_WGL_I3D_image_buffer (WGLEW_CONTEXT_ARG_DEF_INIT) +{ + GLboolean r = GL_FALSE; + + r = ((wglAssociateImageBufferEventsI3D = (PFNWGLASSOCIATEIMAGEBUFFEREVENTSI3DPROC)glewGetProcAddress((const GLubyte*)"wglAssociateImageBufferEventsI3D")) == NULL) || r; + r = ((wglCreateImageBufferI3D = (PFNWGLCREATEIMAGEBUFFERI3DPROC)glewGetProcAddress((const GLubyte*)"wglCreateImageBufferI3D")) == NULL) || r; + r = ((wglDestroyImageBufferI3D = (PFNWGLDESTROYIMAGEBUFFERI3DPROC)glewGetProcAddress((const GLubyte*)"wglDestroyImageBufferI3D")) == NULL) || r; + r = ((wglReleaseImageBufferEventsI3D = (PFNWGLRELEASEIMAGEBUFFEREVENTSI3DPROC)glewGetProcAddress((const GLubyte*)"wglReleaseImageBufferEventsI3D")) == NULL) || r; + + return r; +} + +#endif /* WGL_I3D_image_buffer */ + +#ifdef WGL_I3D_swap_frame_lock + +static GLboolean _glewInit_WGL_I3D_swap_frame_lock (WGLEW_CONTEXT_ARG_DEF_INIT) +{ + GLboolean r = GL_FALSE; + + r = ((wglDisableFrameLockI3D = (PFNWGLDISABLEFRAMELOCKI3DPROC)glewGetProcAddress((const GLubyte*)"wglDisableFrameLockI3D")) == NULL) || r; + r = ((wglEnableFrameLockI3D = (PFNWGLENABLEFRAMELOCKI3DPROC)glewGetProcAddress((const GLubyte*)"wglEnableFrameLockI3D")) == NULL) || r; + r = ((wglIsEnabledFrameLockI3D = (PFNWGLISENABLEDFRAMELOCKI3DPROC)glewGetProcAddress((const GLubyte*)"wglIsEnabledFrameLockI3D")) == NULL) || r; + r = ((wglQueryFrameLockMasterI3D = (PFNWGLQUERYFRAMELOCKMASTERI3DPROC)glewGetProcAddress((const GLubyte*)"wglQueryFrameLockMasterI3D")) == NULL) || r; + + return r; +} + +#endif /* WGL_I3D_swap_frame_lock */ + +#ifdef WGL_I3D_swap_frame_usage + +static GLboolean _glewInit_WGL_I3D_swap_frame_usage (WGLEW_CONTEXT_ARG_DEF_INIT) +{ + GLboolean r = GL_FALSE; + + r = ((wglBeginFrameTrackingI3D = (PFNWGLBEGINFRAMETRACKINGI3DPROC)glewGetProcAddress((const GLubyte*)"wglBeginFrameTrackingI3D")) == NULL) || r; + r = ((wglEndFrameTrackingI3D = (PFNWGLENDFRAMETRACKINGI3DPROC)glewGetProcAddress((const GLubyte*)"wglEndFrameTrackingI3D")) == NULL) || r; + r = ((wglGetFrameUsageI3D = (PFNWGLGETFRAMEUSAGEI3DPROC)glewGetProcAddress((const GLubyte*)"wglGetFrameUsageI3D")) == NULL) || r; + r = ((wglQueryFrameTrackingI3D = (PFNWGLQUERYFRAMETRACKINGI3DPROC)glewGetProcAddress((const GLubyte*)"wglQueryFrameTrackingI3D")) == NULL) || r; + + return r; +} + +#endif /* WGL_I3D_swap_frame_usage */ + +#ifdef WGL_NV_float_buffer + +#endif /* WGL_NV_float_buffer */ + +#ifdef WGL_NV_gpu_affinity + +static GLboolean _glewInit_WGL_NV_gpu_affinity (WGLEW_CONTEXT_ARG_DEF_INIT) +{ + GLboolean r = GL_FALSE; + + r = ((wglCreateAffinityDCNV = (PFNWGLCREATEAFFINITYDCNVPROC)glewGetProcAddress((const GLubyte*)"wglCreateAffinityDCNV")) == NULL) || r; + r = ((wglDeleteDCNV = (PFNWGLDELETEDCNVPROC)glewGetProcAddress((const GLubyte*)"wglDeleteDCNV")) == NULL) || r; + r = ((wglEnumGpuDevicesNV = (PFNWGLENUMGPUDEVICESNVPROC)glewGetProcAddress((const GLubyte*)"wglEnumGpuDevicesNV")) == NULL) || r; + r = ((wglEnumGpusFromAffinityDCNV = (PFNWGLENUMGPUSFROMAFFINITYDCNVPROC)glewGetProcAddress((const GLubyte*)"wglEnumGpusFromAffinityDCNV")) == NULL) || r; + r = ((wglEnumGpusNV = (PFNWGLENUMGPUSNVPROC)glewGetProcAddress((const GLubyte*)"wglEnumGpusNV")) == NULL) || r; + + return r; +} + +#endif /* WGL_NV_gpu_affinity */ + +#ifdef WGL_NV_present_video + +static GLboolean _glewInit_WGL_NV_present_video (WGLEW_CONTEXT_ARG_DEF_INIT) +{ + GLboolean r = GL_FALSE; + + r = ((wglBindVideoDeviceNV = (PFNWGLBINDVIDEODEVICENVPROC)glewGetProcAddress((const GLubyte*)"wglBindVideoDeviceNV")) == NULL) || r; + r = ((wglEnumerateVideoDevicesNV = (PFNWGLENUMERATEVIDEODEVICESNVPROC)glewGetProcAddress((const GLubyte*)"wglEnumerateVideoDevicesNV")) == NULL) || r; + r = ((wglQueryCurrentContextNV = (PFNWGLQUERYCURRENTCONTEXTNVPROC)glewGetProcAddress((const GLubyte*)"wglQueryCurrentContextNV")) == NULL) || r; + + return r; +} + +#endif /* WGL_NV_present_video */ + +#ifdef WGL_NV_render_depth_texture + +#endif /* WGL_NV_render_depth_texture */ + +#ifdef WGL_NV_render_texture_rectangle + +#endif /* WGL_NV_render_texture_rectangle */ + +#ifdef WGL_NV_swap_group + +static GLboolean _glewInit_WGL_NV_swap_group (WGLEW_CONTEXT_ARG_DEF_INIT) +{ + GLboolean r = GL_FALSE; + + r = ((wglBindSwapBarrierNV = (PFNWGLBINDSWAPBARRIERNVPROC)glewGetProcAddress((const GLubyte*)"wglBindSwapBarrierNV")) == NULL) || r; + r = ((wglJoinSwapGroupNV = (PFNWGLJOINSWAPGROUPNVPROC)glewGetProcAddress((const GLubyte*)"wglJoinSwapGroupNV")) == NULL) || r; + r = ((wglQueryFrameCountNV = (PFNWGLQUERYFRAMECOUNTNVPROC)glewGetProcAddress((const GLubyte*)"wglQueryFrameCountNV")) == NULL) || r; + r = ((wglQueryMaxSwapGroupsNV = (PFNWGLQUERYMAXSWAPGROUPSNVPROC)glewGetProcAddress((const GLubyte*)"wglQueryMaxSwapGroupsNV")) == NULL) || r; + r = ((wglQuerySwapGroupNV = (PFNWGLQUERYSWAPGROUPNVPROC)glewGetProcAddress((const GLubyte*)"wglQuerySwapGroupNV")) == NULL) || r; + r = ((wglResetFrameCountNV = (PFNWGLRESETFRAMECOUNTNVPROC)glewGetProcAddress((const GLubyte*)"wglResetFrameCountNV")) == NULL) || r; + + return r; +} + +#endif /* WGL_NV_swap_group */ + +#ifdef WGL_NV_vertex_array_range + +static GLboolean _glewInit_WGL_NV_vertex_array_range (WGLEW_CONTEXT_ARG_DEF_INIT) +{ + GLboolean r = GL_FALSE; + + r = ((wglAllocateMemoryNV = (PFNWGLALLOCATEMEMORYNVPROC)glewGetProcAddress((const GLubyte*)"wglAllocateMemoryNV")) == NULL) || r; + r = ((wglFreeMemoryNV = (PFNWGLFREEMEMORYNVPROC)glewGetProcAddress((const GLubyte*)"wglFreeMemoryNV")) == NULL) || r; + + return r; +} + +#endif /* WGL_NV_vertex_array_range */ + +#ifdef WGL_NV_video_output + +static GLboolean _glewInit_WGL_NV_video_output (WGLEW_CONTEXT_ARG_DEF_INIT) +{ + GLboolean r = GL_FALSE; + + r = ((wglBindVideoImageNV = (PFNWGLBINDVIDEOIMAGENVPROC)glewGetProcAddress((const GLubyte*)"wglBindVideoImageNV")) == NULL) || r; + r = ((wglGetVideoDeviceNV = (PFNWGLGETVIDEODEVICENVPROC)glewGetProcAddress((const GLubyte*)"wglGetVideoDeviceNV")) == NULL) || r; + r = ((wglGetVideoInfoNV = (PFNWGLGETVIDEOINFONVPROC)glewGetProcAddress((const GLubyte*)"wglGetVideoInfoNV")) == NULL) || r; + r = ((wglReleaseVideoDeviceNV = (PFNWGLRELEASEVIDEODEVICENVPROC)glewGetProcAddress((const GLubyte*)"wglReleaseVideoDeviceNV")) == NULL) || r; + r = ((wglReleaseVideoImageNV = (PFNWGLRELEASEVIDEOIMAGENVPROC)glewGetProcAddress((const GLubyte*)"wglReleaseVideoImageNV")) == NULL) || r; + r = ((wglSendPbufferToVideoNV = (PFNWGLSENDPBUFFERTOVIDEONVPROC)glewGetProcAddress((const GLubyte*)"wglSendPbufferToVideoNV")) == NULL) || r; + + return r; +} + +#endif /* WGL_NV_video_output */ + +#ifdef WGL_OML_sync_control + +static GLboolean _glewInit_WGL_OML_sync_control (WGLEW_CONTEXT_ARG_DEF_INIT) +{ + GLboolean r = GL_FALSE; + + r = ((wglGetMscRateOML = (PFNWGLGETMSCRATEOMLPROC)glewGetProcAddress((const GLubyte*)"wglGetMscRateOML")) == NULL) || r; + r = ((wglGetSyncValuesOML = (PFNWGLGETSYNCVALUESOMLPROC)glewGetProcAddress((const GLubyte*)"wglGetSyncValuesOML")) == NULL) || r; + r = ((wglSwapBuffersMscOML = (PFNWGLSWAPBUFFERSMSCOMLPROC)glewGetProcAddress((const GLubyte*)"wglSwapBuffersMscOML")) == NULL) || r; + r = ((wglSwapLayerBuffersMscOML = (PFNWGLSWAPLAYERBUFFERSMSCOMLPROC)glewGetProcAddress((const GLubyte*)"wglSwapLayerBuffersMscOML")) == NULL) || r; + r = ((wglWaitForMscOML = (PFNWGLWAITFORMSCOMLPROC)glewGetProcAddress((const GLubyte*)"wglWaitForMscOML")) == NULL) || r; + r = ((wglWaitForSbcOML = (PFNWGLWAITFORSBCOMLPROC)glewGetProcAddress((const GLubyte*)"wglWaitForSbcOML")) == NULL) || r; + + return r; +} + +#endif /* WGL_OML_sync_control */ + +/* ------------------------------------------------------------------------- */ + +static PFNWGLGETEXTENSIONSSTRINGARBPROC _wglewGetExtensionsStringARB = NULL; +static PFNWGLGETEXTENSIONSSTRINGEXTPROC _wglewGetExtensionsStringEXT = NULL; + +GLboolean wglewGetExtension (const char* name) +{ + GLubyte* p; + GLubyte* end; + GLuint len = _glewStrLen((const GLubyte*)name); + if (_wglewGetExtensionsStringARB == NULL) + if (_wglewGetExtensionsStringEXT == NULL) + return GL_FALSE; + else + p = (GLubyte*)_wglewGetExtensionsStringEXT(); + else + p = (GLubyte*)_wglewGetExtensionsStringARB(wglGetCurrentDC()); + if (0 == p) return GL_FALSE; + end = p + _glewStrLen(p); + while (p < end) + { + GLuint n = _glewStrCLen(p, ' '); + if (len == n && _glewStrSame((const GLubyte*)name, p, n)) return GL_TRUE; + p += n+1; + } + return GL_FALSE; +} + +GLenum wglewContextInit (WGLEW_CONTEXT_ARG_DEF_LIST) +{ + GLboolean crippled; + /* find wgl extension string query functions */ + _wglewGetExtensionsStringARB = (PFNWGLGETEXTENSIONSSTRINGARBPROC)glewGetProcAddress((const GLubyte*)"wglGetExtensionsStringARB"); + _wglewGetExtensionsStringEXT = (PFNWGLGETEXTENSIONSSTRINGEXTPROC)glewGetProcAddress((const GLubyte*)"wglGetExtensionsStringEXT"); + /* initialize extensions */ + crippled = _wglewGetExtensionsStringARB == NULL && _wglewGetExtensionsStringEXT == NULL; +#ifdef WGL_3DFX_multisample + CONST_CAST(WGLEW_3DFX_multisample) = wglewGetExtension("WGL_3DFX_multisample"); +#endif /* WGL_3DFX_multisample */ +#ifdef WGL_3DL_stereo_control + CONST_CAST(WGLEW_3DL_stereo_control) = wglewGetExtension("WGL_3DL_stereo_control"); + if (glewExperimental || WGLEW_3DL_stereo_control|| crippled) CONST_CAST(WGLEW_3DL_stereo_control)= !_glewInit_WGL_3DL_stereo_control(GLEW_CONTEXT_ARG_VAR_INIT); +#endif /* WGL_3DL_stereo_control */ +#ifdef WGL_ARB_buffer_region + CONST_CAST(WGLEW_ARB_buffer_region) = wglewGetExtension("WGL_ARB_buffer_region"); + if (glewExperimental || WGLEW_ARB_buffer_region|| crippled) CONST_CAST(WGLEW_ARB_buffer_region)= !_glewInit_WGL_ARB_buffer_region(GLEW_CONTEXT_ARG_VAR_INIT); +#endif /* WGL_ARB_buffer_region */ +#ifdef WGL_ARB_create_context + CONST_CAST(WGLEW_ARB_create_context) = wglewGetExtension("WGL_ARB_create_context"); + if (glewExperimental || WGLEW_ARB_create_context|| crippled) CONST_CAST(WGLEW_ARB_create_context)= !_glewInit_WGL_ARB_create_context(GLEW_CONTEXT_ARG_VAR_INIT); +#endif /* WGL_ARB_create_context */ +#ifdef WGL_ARB_extensions_string + CONST_CAST(WGLEW_ARB_extensions_string) = wglewGetExtension("WGL_ARB_extensions_string"); + if (glewExperimental || WGLEW_ARB_extensions_string|| crippled) CONST_CAST(WGLEW_ARB_extensions_string)= !_glewInit_WGL_ARB_extensions_string(GLEW_CONTEXT_ARG_VAR_INIT); +#endif /* WGL_ARB_extensions_string */ +#ifdef WGL_ARB_framebuffer_sRGB + CONST_CAST(WGLEW_ARB_framebuffer_sRGB) = wglewGetExtension("WGL_ARB_framebuffer_sRGB"); +#endif /* WGL_ARB_framebuffer_sRGB */ +#ifdef WGL_ARB_make_current_read + CONST_CAST(WGLEW_ARB_make_current_read) = wglewGetExtension("WGL_ARB_make_current_read"); + if (glewExperimental || WGLEW_ARB_make_current_read|| crippled) CONST_CAST(WGLEW_ARB_make_current_read)= !_glewInit_WGL_ARB_make_current_read(GLEW_CONTEXT_ARG_VAR_INIT); +#endif /* WGL_ARB_make_current_read */ +#ifdef WGL_ARB_multisample + CONST_CAST(WGLEW_ARB_multisample) = wglewGetExtension("WGL_ARB_multisample"); +#endif /* WGL_ARB_multisample */ +#ifdef WGL_ARB_pbuffer + CONST_CAST(WGLEW_ARB_pbuffer) = wglewGetExtension("WGL_ARB_pbuffer"); + if (glewExperimental || WGLEW_ARB_pbuffer|| crippled) CONST_CAST(WGLEW_ARB_pbuffer)= !_glewInit_WGL_ARB_pbuffer(GLEW_CONTEXT_ARG_VAR_INIT); +#endif /* WGL_ARB_pbuffer */ +#ifdef WGL_ARB_pixel_format + CONST_CAST(WGLEW_ARB_pixel_format) = wglewGetExtension("WGL_ARB_pixel_format"); + if (glewExperimental || WGLEW_ARB_pixel_format|| crippled) CONST_CAST(WGLEW_ARB_pixel_format)= !_glewInit_WGL_ARB_pixel_format(GLEW_CONTEXT_ARG_VAR_INIT); +#endif /* WGL_ARB_pixel_format */ +#ifdef WGL_ARB_pixel_format_float + CONST_CAST(WGLEW_ARB_pixel_format_float) = wglewGetExtension("WGL_ARB_pixel_format_float"); +#endif /* WGL_ARB_pixel_format_float */ +#ifdef WGL_ARB_render_texture + CONST_CAST(WGLEW_ARB_render_texture) = wglewGetExtension("WGL_ARB_render_texture"); + if (glewExperimental || WGLEW_ARB_render_texture|| crippled) CONST_CAST(WGLEW_ARB_render_texture)= !_glewInit_WGL_ARB_render_texture(GLEW_CONTEXT_ARG_VAR_INIT); +#endif /* WGL_ARB_render_texture */ +#ifdef WGL_ATI_pixel_format_float + CONST_CAST(WGLEW_ATI_pixel_format_float) = wglewGetExtension("WGL_ATI_pixel_format_float"); +#endif /* WGL_ATI_pixel_format_float */ +#ifdef WGL_ATI_render_texture_rectangle + CONST_CAST(WGLEW_ATI_render_texture_rectangle) = wglewGetExtension("WGL_ATI_render_texture_rectangle"); +#endif /* WGL_ATI_render_texture_rectangle */ +#ifdef WGL_EXT_depth_float + CONST_CAST(WGLEW_EXT_depth_float) = wglewGetExtension("WGL_EXT_depth_float"); +#endif /* WGL_EXT_depth_float */ +#ifdef WGL_EXT_display_color_table + CONST_CAST(WGLEW_EXT_display_color_table) = wglewGetExtension("WGL_EXT_display_color_table"); + if (glewExperimental || WGLEW_EXT_display_color_table|| crippled) CONST_CAST(WGLEW_EXT_display_color_table)= !_glewInit_WGL_EXT_display_color_table(GLEW_CONTEXT_ARG_VAR_INIT); +#endif /* WGL_EXT_display_color_table */ +#ifdef WGL_EXT_extensions_string + CONST_CAST(WGLEW_EXT_extensions_string) = wglewGetExtension("WGL_EXT_extensions_string"); + if (glewExperimental || WGLEW_EXT_extensions_string|| crippled) CONST_CAST(WGLEW_EXT_extensions_string)= !_glewInit_WGL_EXT_extensions_string(GLEW_CONTEXT_ARG_VAR_INIT); +#endif /* WGL_EXT_extensions_string */ +#ifdef WGL_EXT_framebuffer_sRGB + CONST_CAST(WGLEW_EXT_framebuffer_sRGB) = wglewGetExtension("WGL_EXT_framebuffer_sRGB"); +#endif /* WGL_EXT_framebuffer_sRGB */ +#ifdef WGL_EXT_make_current_read + CONST_CAST(WGLEW_EXT_make_current_read) = wglewGetExtension("WGL_EXT_make_current_read"); + if (glewExperimental || WGLEW_EXT_make_current_read|| crippled) CONST_CAST(WGLEW_EXT_make_current_read)= !_glewInit_WGL_EXT_make_current_read(GLEW_CONTEXT_ARG_VAR_INIT); +#endif /* WGL_EXT_make_current_read */ +#ifdef WGL_EXT_multisample + CONST_CAST(WGLEW_EXT_multisample) = wglewGetExtension("WGL_EXT_multisample"); +#endif /* WGL_EXT_multisample */ +#ifdef WGL_EXT_pbuffer + CONST_CAST(WGLEW_EXT_pbuffer) = wglewGetExtension("WGL_EXT_pbuffer"); + if (glewExperimental || WGLEW_EXT_pbuffer|| crippled) CONST_CAST(WGLEW_EXT_pbuffer)= !_glewInit_WGL_EXT_pbuffer(GLEW_CONTEXT_ARG_VAR_INIT); +#endif /* WGL_EXT_pbuffer */ +#ifdef WGL_EXT_pixel_format + CONST_CAST(WGLEW_EXT_pixel_format) = wglewGetExtension("WGL_EXT_pixel_format"); + if (glewExperimental || WGLEW_EXT_pixel_format|| crippled) CONST_CAST(WGLEW_EXT_pixel_format)= !_glewInit_WGL_EXT_pixel_format(GLEW_CONTEXT_ARG_VAR_INIT); +#endif /* WGL_EXT_pixel_format */ +#ifdef WGL_EXT_pixel_format_packed_float + CONST_CAST(WGLEW_EXT_pixel_format_packed_float) = wglewGetExtension("WGL_EXT_pixel_format_packed_float"); +#endif /* WGL_EXT_pixel_format_packed_float */ +#ifdef WGL_EXT_swap_control + CONST_CAST(WGLEW_EXT_swap_control) = wglewGetExtension("WGL_EXT_swap_control"); + if (glewExperimental || WGLEW_EXT_swap_control|| crippled) CONST_CAST(WGLEW_EXT_swap_control)= !_glewInit_WGL_EXT_swap_control(GLEW_CONTEXT_ARG_VAR_INIT); +#endif /* WGL_EXT_swap_control */ +#ifdef WGL_I3D_digital_video_control + CONST_CAST(WGLEW_I3D_digital_video_control) = wglewGetExtension("WGL_I3D_digital_video_control"); + if (glewExperimental || WGLEW_I3D_digital_video_control|| crippled) CONST_CAST(WGLEW_I3D_digital_video_control)= !_glewInit_WGL_I3D_digital_video_control(GLEW_CONTEXT_ARG_VAR_INIT); +#endif /* WGL_I3D_digital_video_control */ +#ifdef WGL_I3D_gamma + CONST_CAST(WGLEW_I3D_gamma) = wglewGetExtension("WGL_I3D_gamma"); + if (glewExperimental || WGLEW_I3D_gamma|| crippled) CONST_CAST(WGLEW_I3D_gamma)= !_glewInit_WGL_I3D_gamma(GLEW_CONTEXT_ARG_VAR_INIT); +#endif /* WGL_I3D_gamma */ +#ifdef WGL_I3D_genlock + CONST_CAST(WGLEW_I3D_genlock) = wglewGetExtension("WGL_I3D_genlock"); + if (glewExperimental || WGLEW_I3D_genlock|| crippled) CONST_CAST(WGLEW_I3D_genlock)= !_glewInit_WGL_I3D_genlock(GLEW_CONTEXT_ARG_VAR_INIT); +#endif /* WGL_I3D_genlock */ +#ifdef WGL_I3D_image_buffer + CONST_CAST(WGLEW_I3D_image_buffer) = wglewGetExtension("WGL_I3D_image_buffer"); + if (glewExperimental || WGLEW_I3D_image_buffer|| crippled) CONST_CAST(WGLEW_I3D_image_buffer)= !_glewInit_WGL_I3D_image_buffer(GLEW_CONTEXT_ARG_VAR_INIT); +#endif /* WGL_I3D_image_buffer */ +#ifdef WGL_I3D_swap_frame_lock + CONST_CAST(WGLEW_I3D_swap_frame_lock) = wglewGetExtension("WGL_I3D_swap_frame_lock"); + if (glewExperimental || WGLEW_I3D_swap_frame_lock|| crippled) CONST_CAST(WGLEW_I3D_swap_frame_lock)= !_glewInit_WGL_I3D_swap_frame_lock(GLEW_CONTEXT_ARG_VAR_INIT); +#endif /* WGL_I3D_swap_frame_lock */ +#ifdef WGL_I3D_swap_frame_usage + CONST_CAST(WGLEW_I3D_swap_frame_usage) = wglewGetExtension("WGL_I3D_swap_frame_usage"); + if (glewExperimental || WGLEW_I3D_swap_frame_usage|| crippled) CONST_CAST(WGLEW_I3D_swap_frame_usage)= !_glewInit_WGL_I3D_swap_frame_usage(GLEW_CONTEXT_ARG_VAR_INIT); +#endif /* WGL_I3D_swap_frame_usage */ +#ifdef WGL_NV_float_buffer + CONST_CAST(WGLEW_NV_float_buffer) = wglewGetExtension("WGL_NV_float_buffer"); +#endif /* WGL_NV_float_buffer */ +#ifdef WGL_NV_gpu_affinity + CONST_CAST(WGLEW_NV_gpu_affinity) = wglewGetExtension("WGL_NV_gpu_affinity"); + if (glewExperimental || WGLEW_NV_gpu_affinity|| crippled) CONST_CAST(WGLEW_NV_gpu_affinity)= !_glewInit_WGL_NV_gpu_affinity(GLEW_CONTEXT_ARG_VAR_INIT); +#endif /* WGL_NV_gpu_affinity */ +#ifdef WGL_NV_present_video + CONST_CAST(WGLEW_NV_present_video) = wglewGetExtension("WGL_NV_present_video"); + if (glewExperimental || WGLEW_NV_present_video|| crippled) CONST_CAST(WGLEW_NV_present_video)= !_glewInit_WGL_NV_present_video(GLEW_CONTEXT_ARG_VAR_INIT); +#endif /* WGL_NV_present_video */ +#ifdef WGL_NV_render_depth_texture + CONST_CAST(WGLEW_NV_render_depth_texture) = wglewGetExtension("WGL_NV_render_depth_texture"); +#endif /* WGL_NV_render_depth_texture */ +#ifdef WGL_NV_render_texture_rectangle + CONST_CAST(WGLEW_NV_render_texture_rectangle) = wglewGetExtension("WGL_NV_render_texture_rectangle"); +#endif /* WGL_NV_render_texture_rectangle */ +#ifdef WGL_NV_swap_group + CONST_CAST(WGLEW_NV_swap_group) = wglewGetExtension("WGL_NV_swap_group"); + if (glewExperimental || WGLEW_NV_swap_group|| crippled) CONST_CAST(WGLEW_NV_swap_group)= !_glewInit_WGL_NV_swap_group(GLEW_CONTEXT_ARG_VAR_INIT); +#endif /* WGL_NV_swap_group */ +#ifdef WGL_NV_vertex_array_range + CONST_CAST(WGLEW_NV_vertex_array_range) = wglewGetExtension("WGL_NV_vertex_array_range"); + if (glewExperimental || WGLEW_NV_vertex_array_range|| crippled) CONST_CAST(WGLEW_NV_vertex_array_range)= !_glewInit_WGL_NV_vertex_array_range(GLEW_CONTEXT_ARG_VAR_INIT); +#endif /* WGL_NV_vertex_array_range */ +#ifdef WGL_NV_video_output + CONST_CAST(WGLEW_NV_video_output) = wglewGetExtension("WGL_NV_video_output"); + if (glewExperimental || WGLEW_NV_video_output|| crippled) CONST_CAST(WGLEW_NV_video_output)= !_glewInit_WGL_NV_video_output(GLEW_CONTEXT_ARG_VAR_INIT); +#endif /* WGL_NV_video_output */ +#ifdef WGL_OML_sync_control + CONST_CAST(WGLEW_OML_sync_control) = wglewGetExtension("WGL_OML_sync_control"); + if (glewExperimental || WGLEW_OML_sync_control|| crippled) CONST_CAST(WGLEW_OML_sync_control)= !_glewInit_WGL_OML_sync_control(GLEW_CONTEXT_ARG_VAR_INIT); +#endif /* WGL_OML_sync_control */ + + return GLEW_OK; +} + +#elif !defined(__APPLE__) || defined(GLEW_APPLE_GLX) + +PFNGLXGETCURRENTDISPLAYPROC __glewXGetCurrentDisplay = NULL; + +PFNGLXCHOOSEFBCONFIGPROC __glewXChooseFBConfig = NULL; +PFNGLXCREATENEWCONTEXTPROC __glewXCreateNewContext = NULL; +PFNGLXCREATEPBUFFERPROC __glewXCreatePbuffer = NULL; +PFNGLXCREATEPIXMAPPROC __glewXCreatePixmap = NULL; +PFNGLXCREATEWINDOWPROC __glewXCreateWindow = NULL; +PFNGLXDESTROYPBUFFERPROC __glewXDestroyPbuffer = NULL; +PFNGLXDESTROYPIXMAPPROC __glewXDestroyPixmap = NULL; +PFNGLXDESTROYWINDOWPROC __glewXDestroyWindow = NULL; +PFNGLXGETCURRENTREADDRAWABLEPROC __glewXGetCurrentReadDrawable = NULL; +PFNGLXGETFBCONFIGATTRIBPROC __glewXGetFBConfigAttrib = NULL; +PFNGLXGETFBCONFIGSPROC __glewXGetFBConfigs = NULL; +PFNGLXGETSELECTEDEVENTPROC __glewXGetSelectedEvent = NULL; +PFNGLXGETVISUALFROMFBCONFIGPROC __glewXGetVisualFromFBConfig = NULL; +PFNGLXMAKECONTEXTCURRENTPROC __glewXMakeContextCurrent = NULL; +PFNGLXQUERYCONTEXTPROC __glewXQueryContext = NULL; +PFNGLXQUERYDRAWABLEPROC __glewXQueryDrawable = NULL; +PFNGLXSELECTEVENTPROC __glewXSelectEvent = NULL; + +PFNGLXCREATECONTEXTATTRIBSARBPROC __glewXCreateContextAttribsARB = NULL; + +PFNGLXBINDTEXIMAGEATIPROC __glewXBindTexImageATI = NULL; +PFNGLXDRAWABLEATTRIBATIPROC __glewXDrawableAttribATI = NULL; +PFNGLXRELEASETEXIMAGEATIPROC __glewXReleaseTexImageATI = NULL; + +PFNGLXFREECONTEXTEXTPROC __glewXFreeContextEXT = NULL; +PFNGLXGETCONTEXTIDEXTPROC __glewXGetContextIDEXT = NULL; +PFNGLXIMPORTCONTEXTEXTPROC __glewXImportContextEXT = NULL; +PFNGLXQUERYCONTEXTINFOEXTPROC __glewXQueryContextInfoEXT = NULL; + +PFNGLXBINDTEXIMAGEEXTPROC __glewXBindTexImageEXT = NULL; +PFNGLXRELEASETEXIMAGEEXTPROC __glewXReleaseTexImageEXT = NULL; + +PFNGLXGETAGPOFFSETMESAPROC __glewXGetAGPOffsetMESA = NULL; + +PFNGLXCOPYSUBBUFFERMESAPROC __glewXCopySubBufferMESA = NULL; + +PFNGLXCREATEGLXPIXMAPMESAPROC __glewXCreateGLXPixmapMESA = NULL; + +PFNGLXRELEASEBUFFERSMESAPROC __glewXReleaseBuffersMESA = NULL; + +PFNGLXSET3DFXMODEMESAPROC __glewXSet3DfxModeMESA = NULL; + +PFNGLXBINDVIDEODEVICENVPROC __glewXBindVideoDeviceNV = NULL; +PFNGLXENUMERATEVIDEODEVICESNVPROC __glewXEnumerateVideoDevicesNV = NULL; + +PFNGLXBINDSWAPBARRIERNVPROC __glewXBindSwapBarrierNV = NULL; +PFNGLXJOINSWAPGROUPNVPROC __glewXJoinSwapGroupNV = NULL; +PFNGLXQUERYFRAMECOUNTNVPROC __glewXQueryFrameCountNV = NULL; +PFNGLXQUERYMAXSWAPGROUPSNVPROC __glewXQueryMaxSwapGroupsNV = NULL; +PFNGLXQUERYSWAPGROUPNVPROC __glewXQuerySwapGroupNV = NULL; +PFNGLXRESETFRAMECOUNTNVPROC __glewXResetFrameCountNV = NULL; + +PFNGLXALLOCATEMEMORYNVPROC __glewXAllocateMemoryNV = NULL; +PFNGLXFREEMEMORYNVPROC __glewXFreeMemoryNV = NULL; + +PFNGLXBINDVIDEOIMAGENVPROC __glewXBindVideoImageNV = NULL; +PFNGLXGETVIDEODEVICENVPROC __glewXGetVideoDeviceNV = NULL; +PFNGLXGETVIDEOINFONVPROC __glewXGetVideoInfoNV = NULL; +PFNGLXRELEASEVIDEODEVICENVPROC __glewXReleaseVideoDeviceNV = NULL; +PFNGLXRELEASEVIDEOIMAGENVPROC __glewXReleaseVideoImageNV = NULL; +PFNGLXSENDPBUFFERTOVIDEONVPROC __glewXSendPbufferToVideoNV = NULL; + +#ifdef GLX_OML_sync_control +PFNGLXGETMSCRATEOMLPROC __glewXGetMscRateOML = NULL; +PFNGLXGETSYNCVALUESOMLPROC __glewXGetSyncValuesOML = NULL; +PFNGLXSWAPBUFFERSMSCOMLPROC __glewXSwapBuffersMscOML = NULL; +PFNGLXWAITFORMSCOMLPROC __glewXWaitForMscOML = NULL; +PFNGLXWAITFORSBCOMLPROC __glewXWaitForSbcOML = NULL; +#endif + +PFNGLXCHOOSEFBCONFIGSGIXPROC __glewXChooseFBConfigSGIX = NULL; +PFNGLXCREATECONTEXTWITHCONFIGSGIXPROC __glewXCreateContextWithConfigSGIX = NULL; +PFNGLXCREATEGLXPIXMAPWITHCONFIGSGIXPROC __glewXCreateGLXPixmapWithConfigSGIX = NULL; +PFNGLXGETFBCONFIGATTRIBSGIXPROC __glewXGetFBConfigAttribSGIX = NULL; +PFNGLXGETFBCONFIGFROMVISUALSGIXPROC __glewXGetFBConfigFromVisualSGIX = NULL; +PFNGLXGETVISUALFROMFBCONFIGSGIXPROC __glewXGetVisualFromFBConfigSGIX = NULL; + +PFNGLXBINDHYPERPIPESGIXPROC __glewXBindHyperpipeSGIX = NULL; +PFNGLXDESTROYHYPERPIPECONFIGSGIXPROC __glewXDestroyHyperpipeConfigSGIX = NULL; +PFNGLXHYPERPIPEATTRIBSGIXPROC __glewXHyperpipeAttribSGIX = NULL; +PFNGLXHYPERPIPECONFIGSGIXPROC __glewXHyperpipeConfigSGIX = NULL; +PFNGLXQUERYHYPERPIPEATTRIBSGIXPROC __glewXQueryHyperpipeAttribSGIX = NULL; +PFNGLXQUERYHYPERPIPEBESTATTRIBSGIXPROC __glewXQueryHyperpipeBestAttribSGIX = NULL; +PFNGLXQUERYHYPERPIPECONFIGSGIXPROC __glewXQueryHyperpipeConfigSGIX = NULL; +PFNGLXQUERYHYPERPIPENETWORKSGIXPROC __glewXQueryHyperpipeNetworkSGIX = NULL; + +PFNGLXCREATEGLXPBUFFERSGIXPROC __glewXCreateGLXPbufferSGIX = NULL; +PFNGLXDESTROYGLXPBUFFERSGIXPROC __glewXDestroyGLXPbufferSGIX = NULL; +PFNGLXGETSELECTEDEVENTSGIXPROC __glewXGetSelectedEventSGIX = NULL; +PFNGLXQUERYGLXPBUFFERSGIXPROC __glewXQueryGLXPbufferSGIX = NULL; +PFNGLXSELECTEVENTSGIXPROC __glewXSelectEventSGIX = NULL; + +PFNGLXBINDSWAPBARRIERSGIXPROC __glewXBindSwapBarrierSGIX = NULL; +PFNGLXQUERYMAXSWAPBARRIERSSGIXPROC __glewXQueryMaxSwapBarriersSGIX = NULL; + +PFNGLXJOINSWAPGROUPSGIXPROC __glewXJoinSwapGroupSGIX = NULL; + +PFNGLXBINDCHANNELTOWINDOWSGIXPROC __glewXBindChannelToWindowSGIX = NULL; +PFNGLXCHANNELRECTSGIXPROC __glewXChannelRectSGIX = NULL; +PFNGLXCHANNELRECTSYNCSGIXPROC __glewXChannelRectSyncSGIX = NULL; +PFNGLXQUERYCHANNELDELTASSGIXPROC __glewXQueryChannelDeltasSGIX = NULL; +PFNGLXQUERYCHANNELRECTSGIXPROC __glewXQueryChannelRectSGIX = NULL; + +PFNGLXCUSHIONSGIPROC __glewXCushionSGI = NULL; + +PFNGLXGETCURRENTREADDRAWABLESGIPROC __glewXGetCurrentReadDrawableSGI = NULL; +PFNGLXMAKECURRENTREADSGIPROC __glewXMakeCurrentReadSGI = NULL; + +PFNGLXSWAPINTERVALSGIPROC __glewXSwapIntervalSGI = NULL; + +PFNGLXGETVIDEOSYNCSGIPROC __glewXGetVideoSyncSGI = NULL; +PFNGLXWAITVIDEOSYNCSGIPROC __glewXWaitVideoSyncSGI = NULL; + +PFNGLXGETTRANSPARENTINDEXSUNPROC __glewXGetTransparentIndexSUN = NULL; + +PFNGLXGETVIDEORESIZESUNPROC __glewXGetVideoResizeSUN = NULL; +PFNGLXVIDEORESIZESUNPROC __glewXVideoResizeSUN = NULL; + +#if !defined(GLEW_MX) + +GLboolean __GLXEW_VERSION_1_0 = GL_FALSE; +GLboolean __GLXEW_VERSION_1_1 = GL_FALSE; +GLboolean __GLXEW_VERSION_1_2 = GL_FALSE; +GLboolean __GLXEW_VERSION_1_3 = GL_FALSE; +GLboolean __GLXEW_VERSION_1_4 = GL_FALSE; +GLboolean __GLXEW_3DFX_multisample = GL_FALSE; +GLboolean __GLXEW_ARB_create_context = GL_FALSE; +GLboolean __GLXEW_ARB_fbconfig_float = GL_FALSE; +GLboolean __GLXEW_ARB_framebuffer_sRGB = GL_FALSE; +GLboolean __GLXEW_ARB_get_proc_address = GL_FALSE; +GLboolean __GLXEW_ARB_multisample = GL_FALSE; +GLboolean __GLXEW_ATI_pixel_format_float = GL_FALSE; +GLboolean __GLXEW_ATI_render_texture = GL_FALSE; +GLboolean __GLXEW_EXT_fbconfig_packed_float = GL_FALSE; +GLboolean __GLXEW_EXT_framebuffer_sRGB = GL_FALSE; +GLboolean __GLXEW_EXT_import_context = GL_FALSE; +GLboolean __GLXEW_EXT_scene_marker = GL_FALSE; +GLboolean __GLXEW_EXT_texture_from_pixmap = GL_FALSE; +GLboolean __GLXEW_EXT_visual_info = GL_FALSE; +GLboolean __GLXEW_EXT_visual_rating = GL_FALSE; +GLboolean __GLXEW_MESA_agp_offset = GL_FALSE; +GLboolean __GLXEW_MESA_copy_sub_buffer = GL_FALSE; +GLboolean __GLXEW_MESA_pixmap_colormap = GL_FALSE; +GLboolean __GLXEW_MESA_release_buffers = GL_FALSE; +GLboolean __GLXEW_MESA_set_3dfx_mode = GL_FALSE; +GLboolean __GLXEW_NV_float_buffer = GL_FALSE; +GLboolean __GLXEW_NV_present_video = GL_FALSE; +GLboolean __GLXEW_NV_swap_group = GL_FALSE; +GLboolean __GLXEW_NV_vertex_array_range = GL_FALSE; +GLboolean __GLXEW_NV_video_output = GL_FALSE; +GLboolean __GLXEW_OML_swap_method = GL_FALSE; +#ifdef GLX_OML_sync_control +GLboolean __GLXEW_OML_sync_control = GL_FALSE; +#endif +GLboolean __GLXEW_SGIS_blended_overlay = GL_FALSE; +GLboolean __GLXEW_SGIS_color_range = GL_FALSE; +GLboolean __GLXEW_SGIS_multisample = GL_FALSE; +GLboolean __GLXEW_SGIS_shared_multisample = GL_FALSE; +GLboolean __GLXEW_SGIX_fbconfig = GL_FALSE; +GLboolean __GLXEW_SGIX_hyperpipe = GL_FALSE; +GLboolean __GLXEW_SGIX_pbuffer = GL_FALSE; +GLboolean __GLXEW_SGIX_swap_barrier = GL_FALSE; +GLboolean __GLXEW_SGIX_swap_group = GL_FALSE; +GLboolean __GLXEW_SGIX_video_resize = GL_FALSE; +GLboolean __GLXEW_SGIX_visual_select_group = GL_FALSE; +GLboolean __GLXEW_SGI_cushion = GL_FALSE; +GLboolean __GLXEW_SGI_make_current_read = GL_FALSE; +GLboolean __GLXEW_SGI_swap_control = GL_FALSE; +GLboolean __GLXEW_SGI_video_sync = GL_FALSE; +GLboolean __GLXEW_SUN_get_transparent_index = GL_FALSE; +GLboolean __GLXEW_SUN_video_resize = GL_FALSE; + +#endif /* !GLEW_MX */ + +#ifdef GLX_VERSION_1_2 + +static GLboolean _glewInit_GLX_VERSION_1_2 (GLXEW_CONTEXT_ARG_DEF_INIT) +{ + GLboolean r = GL_FALSE; + + r = ((glXGetCurrentDisplay = (PFNGLXGETCURRENTDISPLAYPROC)glewGetProcAddress((const GLubyte*)"glXGetCurrentDisplay")) == NULL) || r; + + return r; +} + +#endif /* GLX_VERSION_1_2 */ + +#ifdef GLX_VERSION_1_3 + +static GLboolean _glewInit_GLX_VERSION_1_3 (GLXEW_CONTEXT_ARG_DEF_INIT) +{ + GLboolean r = GL_FALSE; + + r = ((glXChooseFBConfig = (PFNGLXCHOOSEFBCONFIGPROC)glewGetProcAddress((const GLubyte*)"glXChooseFBConfig")) == NULL) || r; + r = ((glXCreateNewContext = (PFNGLXCREATENEWCONTEXTPROC)glewGetProcAddress((const GLubyte*)"glXCreateNewContext")) == NULL) || r; + r = ((glXCreatePbuffer = (PFNGLXCREATEPBUFFERPROC)glewGetProcAddress((const GLubyte*)"glXCreatePbuffer")) == NULL) || r; + r = ((glXCreatePixmap = (PFNGLXCREATEPIXMAPPROC)glewGetProcAddress((const GLubyte*)"glXCreatePixmap")) == NULL) || r; + r = ((glXCreateWindow = (PFNGLXCREATEWINDOWPROC)glewGetProcAddress((const GLubyte*)"glXCreateWindow")) == NULL) || r; + r = ((glXDestroyPbuffer = (PFNGLXDESTROYPBUFFERPROC)glewGetProcAddress((const GLubyte*)"glXDestroyPbuffer")) == NULL) || r; + r = ((glXDestroyPixmap = (PFNGLXDESTROYPIXMAPPROC)glewGetProcAddress((const GLubyte*)"glXDestroyPixmap")) == NULL) || r; + r = ((glXDestroyWindow = (PFNGLXDESTROYWINDOWPROC)glewGetProcAddress((const GLubyte*)"glXDestroyWindow")) == NULL) || r; + r = ((glXGetCurrentReadDrawable = (PFNGLXGETCURRENTREADDRAWABLEPROC)glewGetProcAddress((const GLubyte*)"glXGetCurrentReadDrawable")) == NULL) || r; + r = ((glXGetFBConfigAttrib = (PFNGLXGETFBCONFIGATTRIBPROC)glewGetProcAddress((const GLubyte*)"glXGetFBConfigAttrib")) == NULL) || r; + r = ((glXGetFBConfigs = (PFNGLXGETFBCONFIGSPROC)glewGetProcAddress((const GLubyte*)"glXGetFBConfigs")) == NULL) || r; + r = ((glXGetSelectedEvent = (PFNGLXGETSELECTEDEVENTPROC)glewGetProcAddress((const GLubyte*)"glXGetSelectedEvent")) == NULL) || r; + r = ((glXGetVisualFromFBConfig = (PFNGLXGETVISUALFROMFBCONFIGPROC)glewGetProcAddress((const GLubyte*)"glXGetVisualFromFBConfig")) == NULL) || r; + r = ((glXMakeContextCurrent = (PFNGLXMAKECONTEXTCURRENTPROC)glewGetProcAddress((const GLubyte*)"glXMakeContextCurrent")) == NULL) || r; + r = ((glXQueryContext = (PFNGLXQUERYCONTEXTPROC)glewGetProcAddress((const GLubyte*)"glXQueryContext")) == NULL) || r; + r = ((glXQueryDrawable = (PFNGLXQUERYDRAWABLEPROC)glewGetProcAddress((const GLubyte*)"glXQueryDrawable")) == NULL) || r; + r = ((glXSelectEvent = (PFNGLXSELECTEVENTPROC)glewGetProcAddress((const GLubyte*)"glXSelectEvent")) == NULL) || r; + + return r; +} + +#endif /* GLX_VERSION_1_3 */ + +#ifdef GLX_VERSION_1_4 + +#endif /* GLX_VERSION_1_4 */ + +#ifdef GLX_3DFX_multisample + +#endif /* GLX_3DFX_multisample */ + +#ifdef GLX_ARB_create_context + +static GLboolean _glewInit_GLX_ARB_create_context (GLXEW_CONTEXT_ARG_DEF_INIT) +{ + GLboolean r = GL_FALSE; + + r = ((glXCreateContextAttribsARB = (PFNGLXCREATECONTEXTATTRIBSARBPROC)glewGetProcAddress((const GLubyte*)"glXCreateContextAttribsARB")) == NULL) || r; + + return r; +} + +#endif /* GLX_ARB_create_context */ + +#ifdef GLX_ARB_fbconfig_float + +#endif /* GLX_ARB_fbconfig_float */ + +#ifdef GLX_ARB_framebuffer_sRGB + +#endif /* GLX_ARB_framebuffer_sRGB */ + +#ifdef GLX_ARB_get_proc_address + +#endif /* GLX_ARB_get_proc_address */ + +#ifdef GLX_ARB_multisample + +#endif /* GLX_ARB_multisample */ + +#ifdef GLX_ATI_pixel_format_float + +#endif /* GLX_ATI_pixel_format_float */ + +#ifdef GLX_ATI_render_texture + +static GLboolean _glewInit_GLX_ATI_render_texture (GLXEW_CONTEXT_ARG_DEF_INIT) +{ + GLboolean r = GL_FALSE; + + r = ((glXBindTexImageATI = (PFNGLXBINDTEXIMAGEATIPROC)glewGetProcAddress((const GLubyte*)"glXBindTexImageATI")) == NULL) || r; + r = ((glXDrawableAttribATI = (PFNGLXDRAWABLEATTRIBATIPROC)glewGetProcAddress((const GLubyte*)"glXDrawableAttribATI")) == NULL) || r; + r = ((glXReleaseTexImageATI = (PFNGLXRELEASETEXIMAGEATIPROC)glewGetProcAddress((const GLubyte*)"glXReleaseTexImageATI")) == NULL) || r; + + return r; +} + +#endif /* GLX_ATI_render_texture */ + +#ifdef GLX_EXT_fbconfig_packed_float + +#endif /* GLX_EXT_fbconfig_packed_float */ + +#ifdef GLX_EXT_framebuffer_sRGB + +#endif /* GLX_EXT_framebuffer_sRGB */ + +#ifdef GLX_EXT_import_context + +static GLboolean _glewInit_GLX_EXT_import_context (GLXEW_CONTEXT_ARG_DEF_INIT) +{ + GLboolean r = GL_FALSE; + + r = ((glXFreeContextEXT = (PFNGLXFREECONTEXTEXTPROC)glewGetProcAddress((const GLubyte*)"glXFreeContextEXT")) == NULL) || r; + r = ((glXGetContextIDEXT = (PFNGLXGETCONTEXTIDEXTPROC)glewGetProcAddress((const GLubyte*)"glXGetContextIDEXT")) == NULL) || r; + r = ((glXImportContextEXT = (PFNGLXIMPORTCONTEXTEXTPROC)glewGetProcAddress((const GLubyte*)"glXImportContextEXT")) == NULL) || r; + r = ((glXQueryContextInfoEXT = (PFNGLXQUERYCONTEXTINFOEXTPROC)glewGetProcAddress((const GLubyte*)"glXQueryContextInfoEXT")) == NULL) || r; + + return r; +} + +#endif /* GLX_EXT_import_context */ + +#ifdef GLX_EXT_scene_marker + +#endif /* GLX_EXT_scene_marker */ + +#ifdef GLX_EXT_texture_from_pixmap + +static GLboolean _glewInit_GLX_EXT_texture_from_pixmap (GLXEW_CONTEXT_ARG_DEF_INIT) +{ + GLboolean r = GL_FALSE; + + r = ((glXBindTexImageEXT = (PFNGLXBINDTEXIMAGEEXTPROC)glewGetProcAddress((const GLubyte*)"glXBindTexImageEXT")) == NULL) || r; + r = ((glXReleaseTexImageEXT = (PFNGLXRELEASETEXIMAGEEXTPROC)glewGetProcAddress((const GLubyte*)"glXReleaseTexImageEXT")) == NULL) || r; + + return r; +} + +#endif /* GLX_EXT_texture_from_pixmap */ + +#ifdef GLX_EXT_visual_info + +#endif /* GLX_EXT_visual_info */ + +#ifdef GLX_EXT_visual_rating + +#endif /* GLX_EXT_visual_rating */ + +#ifdef GLX_MESA_agp_offset + +static GLboolean _glewInit_GLX_MESA_agp_offset (GLXEW_CONTEXT_ARG_DEF_INIT) +{ + GLboolean r = GL_FALSE; + + r = ((glXGetAGPOffsetMESA = (PFNGLXGETAGPOFFSETMESAPROC)glewGetProcAddress((const GLubyte*)"glXGetAGPOffsetMESA")) == NULL) || r; + + return r; +} + +#endif /* GLX_MESA_agp_offset */ + +#ifdef GLX_MESA_copy_sub_buffer + +static GLboolean _glewInit_GLX_MESA_copy_sub_buffer (GLXEW_CONTEXT_ARG_DEF_INIT) +{ + GLboolean r = GL_FALSE; + + r = ((glXCopySubBufferMESA = (PFNGLXCOPYSUBBUFFERMESAPROC)glewGetProcAddress((const GLubyte*)"glXCopySubBufferMESA")) == NULL) || r; + + return r; +} + +#endif /* GLX_MESA_copy_sub_buffer */ + +#ifdef GLX_MESA_pixmap_colormap + +static GLboolean _glewInit_GLX_MESA_pixmap_colormap (GLXEW_CONTEXT_ARG_DEF_INIT) +{ + GLboolean r = GL_FALSE; + + r = ((glXCreateGLXPixmapMESA = (PFNGLXCREATEGLXPIXMAPMESAPROC)glewGetProcAddress((const GLubyte*)"glXCreateGLXPixmapMESA")) == NULL) || r; + + return r; +} + +#endif /* GLX_MESA_pixmap_colormap */ + +#ifdef GLX_MESA_release_buffers + +static GLboolean _glewInit_GLX_MESA_release_buffers (GLXEW_CONTEXT_ARG_DEF_INIT) +{ + GLboolean r = GL_FALSE; + + r = ((glXReleaseBuffersMESA = (PFNGLXRELEASEBUFFERSMESAPROC)glewGetProcAddress((const GLubyte*)"glXReleaseBuffersMESA")) == NULL) || r; + + return r; +} + +#endif /* GLX_MESA_release_buffers */ + +#ifdef GLX_MESA_set_3dfx_mode + +static GLboolean _glewInit_GLX_MESA_set_3dfx_mode (GLXEW_CONTEXT_ARG_DEF_INIT) +{ + GLboolean r = GL_FALSE; + + r = ((glXSet3DfxModeMESA = (PFNGLXSET3DFXMODEMESAPROC)glewGetProcAddress((const GLubyte*)"glXSet3DfxModeMESA")) == NULL) || r; + + return r; +} + +#endif /* GLX_MESA_set_3dfx_mode */ + +#ifdef GLX_NV_float_buffer + +#endif /* GLX_NV_float_buffer */ + +#ifdef GLX_NV_present_video + +static GLboolean _glewInit_GLX_NV_present_video (GLXEW_CONTEXT_ARG_DEF_INIT) +{ + GLboolean r = GL_FALSE; + + r = ((glXBindVideoDeviceNV = (PFNGLXBINDVIDEODEVICENVPROC)glewGetProcAddress((const GLubyte*)"glXBindVideoDeviceNV")) == NULL) || r; + r = ((glXEnumerateVideoDevicesNV = (PFNGLXENUMERATEVIDEODEVICESNVPROC)glewGetProcAddress((const GLubyte*)"glXEnumerateVideoDevicesNV")) == NULL) || r; + + return r; +} + +#endif /* GLX_NV_present_video */ + +#ifdef GLX_NV_swap_group + +static GLboolean _glewInit_GLX_NV_swap_group (GLXEW_CONTEXT_ARG_DEF_INIT) +{ + GLboolean r = GL_FALSE; + + r = ((glXBindSwapBarrierNV = (PFNGLXBINDSWAPBARRIERNVPROC)glewGetProcAddress((const GLubyte*)"glXBindSwapBarrierNV")) == NULL) || r; + r = ((glXJoinSwapGroupNV = (PFNGLXJOINSWAPGROUPNVPROC)glewGetProcAddress((const GLubyte*)"glXJoinSwapGroupNV")) == NULL) || r; + r = ((glXQueryFrameCountNV = (PFNGLXQUERYFRAMECOUNTNVPROC)glewGetProcAddress((const GLubyte*)"glXQueryFrameCountNV")) == NULL) || r; + r = ((glXQueryMaxSwapGroupsNV = (PFNGLXQUERYMAXSWAPGROUPSNVPROC)glewGetProcAddress((const GLubyte*)"glXQueryMaxSwapGroupsNV")) == NULL) || r; + r = ((glXQuerySwapGroupNV = (PFNGLXQUERYSWAPGROUPNVPROC)glewGetProcAddress((const GLubyte*)"glXQuerySwapGroupNV")) == NULL) || r; + r = ((glXResetFrameCountNV = (PFNGLXRESETFRAMECOUNTNVPROC)glewGetProcAddress((const GLubyte*)"glXResetFrameCountNV")) == NULL) || r; + + return r; +} + +#endif /* GLX_NV_swap_group */ + +#ifdef GLX_NV_vertex_array_range + +static GLboolean _glewInit_GLX_NV_vertex_array_range (GLXEW_CONTEXT_ARG_DEF_INIT) +{ + GLboolean r = GL_FALSE; + + r = ((glXAllocateMemoryNV = (PFNGLXALLOCATEMEMORYNVPROC)glewGetProcAddress((const GLubyte*)"glXAllocateMemoryNV")) == NULL) || r; + r = ((glXFreeMemoryNV = (PFNGLXFREEMEMORYNVPROC)glewGetProcAddress((const GLubyte*)"glXFreeMemoryNV")) == NULL) || r; + + return r; +} + +#endif /* GLX_NV_vertex_array_range */ + +#ifdef GLX_NV_video_output + +static GLboolean _glewInit_GLX_NV_video_output (GLXEW_CONTEXT_ARG_DEF_INIT) +{ + GLboolean r = GL_FALSE; + + r = ((glXBindVideoImageNV = (PFNGLXBINDVIDEOIMAGENVPROC)glewGetProcAddress((const GLubyte*)"glXBindVideoImageNV")) == NULL) || r; + r = ((glXGetVideoDeviceNV = (PFNGLXGETVIDEODEVICENVPROC)glewGetProcAddress((const GLubyte*)"glXGetVideoDeviceNV")) == NULL) || r; + r = ((glXGetVideoInfoNV = (PFNGLXGETVIDEOINFONVPROC)glewGetProcAddress((const GLubyte*)"glXGetVideoInfoNV")) == NULL) || r; + r = ((glXReleaseVideoDeviceNV = (PFNGLXRELEASEVIDEODEVICENVPROC)glewGetProcAddress((const GLubyte*)"glXReleaseVideoDeviceNV")) == NULL) || r; + r = ((glXReleaseVideoImageNV = (PFNGLXRELEASEVIDEOIMAGENVPROC)glewGetProcAddress((const GLubyte*)"glXReleaseVideoImageNV")) == NULL) || r; + r = ((glXSendPbufferToVideoNV = (PFNGLXSENDPBUFFERTOVIDEONVPROC)glewGetProcAddress((const GLubyte*)"glXSendPbufferToVideoNV")) == NULL) || r; + + return r; +} + +#endif /* GLX_NV_video_output */ + +#ifdef GLX_OML_swap_method + +#endif /* GLX_OML_swap_method */ + +#if defined(GLX_OML_sync_control) && defined(__STDC_VERSION__) && (__STDC_VERSION__ >= 199901L) +#include + +static GLboolean _glewInit_GLX_OML_sync_control (GLXEW_CONTEXT_ARG_DEF_INIT) +{ + GLboolean r = GL_FALSE; + + r = ((glXGetMscRateOML = (PFNGLXGETMSCRATEOMLPROC)glewGetProcAddress((const GLubyte*)"glXGetMscRateOML")) == NULL) || r; + r = ((glXGetSyncValuesOML = (PFNGLXGETSYNCVALUESOMLPROC)glewGetProcAddress((const GLubyte*)"glXGetSyncValuesOML")) == NULL) || r; + r = ((glXSwapBuffersMscOML = (PFNGLXSWAPBUFFERSMSCOMLPROC)glewGetProcAddress((const GLubyte*)"glXSwapBuffersMscOML")) == NULL) || r; + r = ((glXWaitForMscOML = (PFNGLXWAITFORMSCOMLPROC)glewGetProcAddress((const GLubyte*)"glXWaitForMscOML")) == NULL) || r; + r = ((glXWaitForSbcOML = (PFNGLXWAITFORSBCOMLPROC)glewGetProcAddress((const GLubyte*)"glXWaitForSbcOML")) == NULL) || r; + + return r; +} + +#endif /* GLX_OML_sync_control */ + +#ifdef GLX_SGIS_blended_overlay + +#endif /* GLX_SGIS_blended_overlay */ + +#ifdef GLX_SGIS_color_range + +#endif /* GLX_SGIS_color_range */ + +#ifdef GLX_SGIS_multisample + +#endif /* GLX_SGIS_multisample */ + +#ifdef GLX_SGIS_shared_multisample + +#endif /* GLX_SGIS_shared_multisample */ + +#ifdef GLX_SGIX_fbconfig + +static GLboolean _glewInit_GLX_SGIX_fbconfig (GLXEW_CONTEXT_ARG_DEF_INIT) +{ + GLboolean r = GL_FALSE; + + r = ((glXChooseFBConfigSGIX = (PFNGLXCHOOSEFBCONFIGSGIXPROC)glewGetProcAddress((const GLubyte*)"glXChooseFBConfigSGIX")) == NULL) || r; + r = ((glXCreateContextWithConfigSGIX = (PFNGLXCREATECONTEXTWITHCONFIGSGIXPROC)glewGetProcAddress((const GLubyte*)"glXCreateContextWithConfigSGIX")) == NULL) || r; + r = ((glXCreateGLXPixmapWithConfigSGIX = (PFNGLXCREATEGLXPIXMAPWITHCONFIGSGIXPROC)glewGetProcAddress((const GLubyte*)"glXCreateGLXPixmapWithConfigSGIX")) == NULL) || r; + r = ((glXGetFBConfigAttribSGIX = (PFNGLXGETFBCONFIGATTRIBSGIXPROC)glewGetProcAddress((const GLubyte*)"glXGetFBConfigAttribSGIX")) == NULL) || r; + r = ((glXGetFBConfigFromVisualSGIX = (PFNGLXGETFBCONFIGFROMVISUALSGIXPROC)glewGetProcAddress((const GLubyte*)"glXGetFBConfigFromVisualSGIX")) == NULL) || r; + r = ((glXGetVisualFromFBConfigSGIX = (PFNGLXGETVISUALFROMFBCONFIGSGIXPROC)glewGetProcAddress((const GLubyte*)"glXGetVisualFromFBConfigSGIX")) == NULL) || r; + + return r; +} + +#endif /* GLX_SGIX_fbconfig */ + +#ifdef GLX_SGIX_hyperpipe + +static GLboolean _glewInit_GLX_SGIX_hyperpipe (GLXEW_CONTEXT_ARG_DEF_INIT) +{ + GLboolean r = GL_FALSE; + + r = ((glXBindHyperpipeSGIX = (PFNGLXBINDHYPERPIPESGIXPROC)glewGetProcAddress((const GLubyte*)"glXBindHyperpipeSGIX")) == NULL) || r; + r = ((glXDestroyHyperpipeConfigSGIX = (PFNGLXDESTROYHYPERPIPECONFIGSGIXPROC)glewGetProcAddress((const GLubyte*)"glXDestroyHyperpipeConfigSGIX")) == NULL) || r; + r = ((glXHyperpipeAttribSGIX = (PFNGLXHYPERPIPEATTRIBSGIXPROC)glewGetProcAddress((const GLubyte*)"glXHyperpipeAttribSGIX")) == NULL) || r; + r = ((glXHyperpipeConfigSGIX = (PFNGLXHYPERPIPECONFIGSGIXPROC)glewGetProcAddress((const GLubyte*)"glXHyperpipeConfigSGIX")) == NULL) || r; + r = ((glXQueryHyperpipeAttribSGIX = (PFNGLXQUERYHYPERPIPEATTRIBSGIXPROC)glewGetProcAddress((const GLubyte*)"glXQueryHyperpipeAttribSGIX")) == NULL) || r; + r = ((glXQueryHyperpipeBestAttribSGIX = (PFNGLXQUERYHYPERPIPEBESTATTRIBSGIXPROC)glewGetProcAddress((const GLubyte*)"glXQueryHyperpipeBestAttribSGIX")) == NULL) || r; + r = ((glXQueryHyperpipeConfigSGIX = (PFNGLXQUERYHYPERPIPECONFIGSGIXPROC)glewGetProcAddress((const GLubyte*)"glXQueryHyperpipeConfigSGIX")) == NULL) || r; + r = ((glXQueryHyperpipeNetworkSGIX = (PFNGLXQUERYHYPERPIPENETWORKSGIXPROC)glewGetProcAddress((const GLubyte*)"glXQueryHyperpipeNetworkSGIX")) == NULL) || r; + + return r; +} + +#endif /* GLX_SGIX_hyperpipe */ + +#ifdef GLX_SGIX_pbuffer + +static GLboolean _glewInit_GLX_SGIX_pbuffer (GLXEW_CONTEXT_ARG_DEF_INIT) +{ + GLboolean r = GL_FALSE; + + r = ((glXCreateGLXPbufferSGIX = (PFNGLXCREATEGLXPBUFFERSGIXPROC)glewGetProcAddress((const GLubyte*)"glXCreateGLXPbufferSGIX")) == NULL) || r; + r = ((glXDestroyGLXPbufferSGIX = (PFNGLXDESTROYGLXPBUFFERSGIXPROC)glewGetProcAddress((const GLubyte*)"glXDestroyGLXPbufferSGIX")) == NULL) || r; + r = ((glXGetSelectedEventSGIX = (PFNGLXGETSELECTEDEVENTSGIXPROC)glewGetProcAddress((const GLubyte*)"glXGetSelectedEventSGIX")) == NULL) || r; + r = ((glXQueryGLXPbufferSGIX = (PFNGLXQUERYGLXPBUFFERSGIXPROC)glewGetProcAddress((const GLubyte*)"glXQueryGLXPbufferSGIX")) == NULL) || r; + r = ((glXSelectEventSGIX = (PFNGLXSELECTEVENTSGIXPROC)glewGetProcAddress((const GLubyte*)"glXSelectEventSGIX")) == NULL) || r; + + return r; +} + +#endif /* GLX_SGIX_pbuffer */ + +#ifdef GLX_SGIX_swap_barrier + +static GLboolean _glewInit_GLX_SGIX_swap_barrier (GLXEW_CONTEXT_ARG_DEF_INIT) +{ + GLboolean r = GL_FALSE; + + r = ((glXBindSwapBarrierSGIX = (PFNGLXBINDSWAPBARRIERSGIXPROC)glewGetProcAddress((const GLubyte*)"glXBindSwapBarrierSGIX")) == NULL) || r; + r = ((glXQueryMaxSwapBarriersSGIX = (PFNGLXQUERYMAXSWAPBARRIERSSGIXPROC)glewGetProcAddress((const GLubyte*)"glXQueryMaxSwapBarriersSGIX")) == NULL) || r; + + return r; +} + +#endif /* GLX_SGIX_swap_barrier */ + +#ifdef GLX_SGIX_swap_group + +static GLboolean _glewInit_GLX_SGIX_swap_group (GLXEW_CONTEXT_ARG_DEF_INIT) +{ + GLboolean r = GL_FALSE; + + r = ((glXJoinSwapGroupSGIX = (PFNGLXJOINSWAPGROUPSGIXPROC)glewGetProcAddress((const GLubyte*)"glXJoinSwapGroupSGIX")) == NULL) || r; + + return r; +} + +#endif /* GLX_SGIX_swap_group */ + +#ifdef GLX_SGIX_video_resize + +static GLboolean _glewInit_GLX_SGIX_video_resize (GLXEW_CONTEXT_ARG_DEF_INIT) +{ + GLboolean r = GL_FALSE; + + r = ((glXBindChannelToWindowSGIX = (PFNGLXBINDCHANNELTOWINDOWSGIXPROC)glewGetProcAddress((const GLubyte*)"glXBindChannelToWindowSGIX")) == NULL) || r; + r = ((glXChannelRectSGIX = (PFNGLXCHANNELRECTSGIXPROC)glewGetProcAddress((const GLubyte*)"glXChannelRectSGIX")) == NULL) || r; + r = ((glXChannelRectSyncSGIX = (PFNGLXCHANNELRECTSYNCSGIXPROC)glewGetProcAddress((const GLubyte*)"glXChannelRectSyncSGIX")) == NULL) || r; + r = ((glXQueryChannelDeltasSGIX = (PFNGLXQUERYCHANNELDELTASSGIXPROC)glewGetProcAddress((const GLubyte*)"glXQueryChannelDeltasSGIX")) == NULL) || r; + r = ((glXQueryChannelRectSGIX = (PFNGLXQUERYCHANNELRECTSGIXPROC)glewGetProcAddress((const GLubyte*)"glXQueryChannelRectSGIX")) == NULL) || r; + + return r; +} + +#endif /* GLX_SGIX_video_resize */ + +#ifdef GLX_SGIX_visual_select_group + +#endif /* GLX_SGIX_visual_select_group */ + +#ifdef GLX_SGI_cushion + +static GLboolean _glewInit_GLX_SGI_cushion (GLXEW_CONTEXT_ARG_DEF_INIT) +{ + GLboolean r = GL_FALSE; + + r = ((glXCushionSGI = (PFNGLXCUSHIONSGIPROC)glewGetProcAddress((const GLubyte*)"glXCushionSGI")) == NULL) || r; + + return r; +} + +#endif /* GLX_SGI_cushion */ + +#ifdef GLX_SGI_make_current_read + +static GLboolean _glewInit_GLX_SGI_make_current_read (GLXEW_CONTEXT_ARG_DEF_INIT) +{ + GLboolean r = GL_FALSE; + + r = ((glXGetCurrentReadDrawableSGI = (PFNGLXGETCURRENTREADDRAWABLESGIPROC)glewGetProcAddress((const GLubyte*)"glXGetCurrentReadDrawableSGI")) == NULL) || r; + r = ((glXMakeCurrentReadSGI = (PFNGLXMAKECURRENTREADSGIPROC)glewGetProcAddress((const GLubyte*)"glXMakeCurrentReadSGI")) == NULL) || r; + + return r; +} + +#endif /* GLX_SGI_make_current_read */ + +#ifdef GLX_SGI_swap_control + +static GLboolean _glewInit_GLX_SGI_swap_control (GLXEW_CONTEXT_ARG_DEF_INIT) +{ + GLboolean r = GL_FALSE; + + r = ((glXSwapIntervalSGI = (PFNGLXSWAPINTERVALSGIPROC)glewGetProcAddress((const GLubyte*)"glXSwapIntervalSGI")) == NULL) || r; + + return r; +} + +#endif /* GLX_SGI_swap_control */ + +#ifdef GLX_SGI_video_sync + +static GLboolean _glewInit_GLX_SGI_video_sync (GLXEW_CONTEXT_ARG_DEF_INIT) +{ + GLboolean r = GL_FALSE; + + r = ((glXGetVideoSyncSGI = (PFNGLXGETVIDEOSYNCSGIPROC)glewGetProcAddress((const GLubyte*)"glXGetVideoSyncSGI")) == NULL) || r; + r = ((glXWaitVideoSyncSGI = (PFNGLXWAITVIDEOSYNCSGIPROC)glewGetProcAddress((const GLubyte*)"glXWaitVideoSyncSGI")) == NULL) || r; + + return r; +} + +#endif /* GLX_SGI_video_sync */ + +#ifdef GLX_SUN_get_transparent_index + +static GLboolean _glewInit_GLX_SUN_get_transparent_index (GLXEW_CONTEXT_ARG_DEF_INIT) +{ + GLboolean r = GL_FALSE; + + r = ((glXGetTransparentIndexSUN = (PFNGLXGETTRANSPARENTINDEXSUNPROC)glewGetProcAddress((const GLubyte*)"glXGetTransparentIndexSUN")) == NULL) || r; + + return r; +} + +#endif /* GLX_SUN_get_transparent_index */ + +#ifdef GLX_SUN_video_resize + +static GLboolean _glewInit_GLX_SUN_video_resize (GLXEW_CONTEXT_ARG_DEF_INIT) +{ + GLboolean r = GL_FALSE; + + r = ((glXGetVideoResizeSUN = (PFNGLXGETVIDEORESIZESUNPROC)glewGetProcAddress((const GLubyte*)"glXGetVideoResizeSUN")) == NULL) || r; + r = ((glXVideoResizeSUN = (PFNGLXVIDEORESIZESUNPROC)glewGetProcAddress((const GLubyte*)"glXVideoResizeSUN")) == NULL) || r; + + return r; +} + +#endif /* GLX_SUN_video_resize */ + +/* ------------------------------------------------------------------------ */ + +GLboolean glxewGetExtension (const char* name) +{ + GLubyte* p; + GLubyte* end; + GLuint len = _glewStrLen((const GLubyte*)name); +/* if (glXQueryExtensionsString == NULL || glXGetCurrentDisplay == NULL) return GL_FALSE; */ +/* p = (GLubyte*)glXQueryExtensionsString(glXGetCurrentDisplay(), DefaultScreen(glXGetCurrentDisplay())); */ + if (glXGetClientString == NULL || glXGetCurrentDisplay == NULL) return GL_FALSE; + p = (GLubyte*)glXGetClientString(glXGetCurrentDisplay(), GLX_EXTENSIONS); + if (0 == p) return GL_FALSE; + end = p + _glewStrLen(p); + while (p < end) + { + GLuint n = _glewStrCLen(p, ' '); + if (len == n && _glewStrSame((const GLubyte*)name, p, n)) return GL_TRUE; + p += n+1; + } + return GL_FALSE; +} + +GLenum glxewContextInit (GLXEW_CONTEXT_ARG_DEF_LIST) +{ + int major, minor; + /* initialize core GLX 1.2 */ + if (_glewInit_GLX_VERSION_1_2(GLEW_CONTEXT_ARG_VAR_INIT)) return GLEW_ERROR_GLX_VERSION_11_ONLY; + /* initialize flags */ + CONST_CAST(GLXEW_VERSION_1_0) = GL_TRUE; + CONST_CAST(GLXEW_VERSION_1_1) = GL_TRUE; + CONST_CAST(GLXEW_VERSION_1_2) = GL_TRUE; + CONST_CAST(GLXEW_VERSION_1_3) = GL_TRUE; + CONST_CAST(GLXEW_VERSION_1_4) = GL_TRUE; + /* query GLX version */ + glXQueryVersion(glXGetCurrentDisplay(), &major, &minor); + if (major == 1 && minor <= 3) + { + switch (minor) + { + case 3: + CONST_CAST(GLXEW_VERSION_1_4) = GL_FALSE; + break; + case 2: + CONST_CAST(GLXEW_VERSION_1_4) = GL_FALSE; + CONST_CAST(GLXEW_VERSION_1_3) = GL_FALSE; + break; + default: + return GLEW_ERROR_GLX_VERSION_11_ONLY; + break; + } + } + /* initialize extensions */ +#ifdef GLX_VERSION_1_3 + if (glewExperimental || GLXEW_VERSION_1_3) CONST_CAST(GLXEW_VERSION_1_3) = !_glewInit_GLX_VERSION_1_3(GLEW_CONTEXT_ARG_VAR_INIT); +#endif /* GLX_VERSION_1_3 */ +#ifdef GLX_3DFX_multisample + CONST_CAST(GLXEW_3DFX_multisample) = glxewGetExtension("GLX_3DFX_multisample"); +#endif /* GLX_3DFX_multisample */ +#ifdef GLX_ARB_create_context + CONST_CAST(GLXEW_ARB_create_context) = glxewGetExtension("GLX_ARB_create_context"); + if (glewExperimental || GLXEW_ARB_create_context) CONST_CAST(GLXEW_ARB_create_context) = !_glewInit_GLX_ARB_create_context(GLEW_CONTEXT_ARG_VAR_INIT); +#endif /* GLX_ARB_create_context */ +#ifdef GLX_ARB_fbconfig_float + CONST_CAST(GLXEW_ARB_fbconfig_float) = glxewGetExtension("GLX_ARB_fbconfig_float"); +#endif /* GLX_ARB_fbconfig_float */ +#ifdef GLX_ARB_framebuffer_sRGB + CONST_CAST(GLXEW_ARB_framebuffer_sRGB) = glxewGetExtension("GLX_ARB_framebuffer_sRGB"); +#endif /* GLX_ARB_framebuffer_sRGB */ +#ifdef GLX_ARB_get_proc_address + CONST_CAST(GLXEW_ARB_get_proc_address) = glxewGetExtension("GLX_ARB_get_proc_address"); +#endif /* GLX_ARB_get_proc_address */ +#ifdef GLX_ARB_multisample + CONST_CAST(GLXEW_ARB_multisample) = glxewGetExtension("GLX_ARB_multisample"); +#endif /* GLX_ARB_multisample */ +#ifdef GLX_ATI_pixel_format_float + CONST_CAST(GLXEW_ATI_pixel_format_float) = glxewGetExtension("GLX_ATI_pixel_format_float"); +#endif /* GLX_ATI_pixel_format_float */ +#ifdef GLX_ATI_render_texture + CONST_CAST(GLXEW_ATI_render_texture) = glxewGetExtension("GLX_ATI_render_texture"); + if (glewExperimental || GLXEW_ATI_render_texture) CONST_CAST(GLXEW_ATI_render_texture) = !_glewInit_GLX_ATI_render_texture(GLEW_CONTEXT_ARG_VAR_INIT); +#endif /* GLX_ATI_render_texture */ +#ifdef GLX_EXT_fbconfig_packed_float + CONST_CAST(GLXEW_EXT_fbconfig_packed_float) = glxewGetExtension("GLX_EXT_fbconfig_packed_float"); +#endif /* GLX_EXT_fbconfig_packed_float */ +#ifdef GLX_EXT_framebuffer_sRGB + CONST_CAST(GLXEW_EXT_framebuffer_sRGB) = glxewGetExtension("GLX_EXT_framebuffer_sRGB"); +#endif /* GLX_EXT_framebuffer_sRGB */ +#ifdef GLX_EXT_import_context + CONST_CAST(GLXEW_EXT_import_context) = glxewGetExtension("GLX_EXT_import_context"); + if (glewExperimental || GLXEW_EXT_import_context) CONST_CAST(GLXEW_EXT_import_context) = !_glewInit_GLX_EXT_import_context(GLEW_CONTEXT_ARG_VAR_INIT); +#endif /* GLX_EXT_import_context */ +#ifdef GLX_EXT_scene_marker + CONST_CAST(GLXEW_EXT_scene_marker) = glxewGetExtension("GLX_EXT_scene_marker"); +#endif /* GLX_EXT_scene_marker */ +#ifdef GLX_EXT_texture_from_pixmap + CONST_CAST(GLXEW_EXT_texture_from_pixmap) = glxewGetExtension("GLX_EXT_texture_from_pixmap"); + if (glewExperimental || GLXEW_EXT_texture_from_pixmap) CONST_CAST(GLXEW_EXT_texture_from_pixmap) = !_glewInit_GLX_EXT_texture_from_pixmap(GLEW_CONTEXT_ARG_VAR_INIT); +#endif /* GLX_EXT_texture_from_pixmap */ +#ifdef GLX_EXT_visual_info + CONST_CAST(GLXEW_EXT_visual_info) = glxewGetExtension("GLX_EXT_visual_info"); +#endif /* GLX_EXT_visual_info */ +#ifdef GLX_EXT_visual_rating + CONST_CAST(GLXEW_EXT_visual_rating) = glxewGetExtension("GLX_EXT_visual_rating"); +#endif /* GLX_EXT_visual_rating */ +#ifdef GLX_MESA_agp_offset + CONST_CAST(GLXEW_MESA_agp_offset) = glxewGetExtension("GLX_MESA_agp_offset"); + if (glewExperimental || GLXEW_MESA_agp_offset) CONST_CAST(GLXEW_MESA_agp_offset) = !_glewInit_GLX_MESA_agp_offset(GLEW_CONTEXT_ARG_VAR_INIT); +#endif /* GLX_MESA_agp_offset */ +#ifdef GLX_MESA_copy_sub_buffer + CONST_CAST(GLXEW_MESA_copy_sub_buffer) = glxewGetExtension("GLX_MESA_copy_sub_buffer"); + if (glewExperimental || GLXEW_MESA_copy_sub_buffer) CONST_CAST(GLXEW_MESA_copy_sub_buffer) = !_glewInit_GLX_MESA_copy_sub_buffer(GLEW_CONTEXT_ARG_VAR_INIT); +#endif /* GLX_MESA_copy_sub_buffer */ +#ifdef GLX_MESA_pixmap_colormap + CONST_CAST(GLXEW_MESA_pixmap_colormap) = glxewGetExtension("GLX_MESA_pixmap_colormap"); + if (glewExperimental || GLXEW_MESA_pixmap_colormap) CONST_CAST(GLXEW_MESA_pixmap_colormap) = !_glewInit_GLX_MESA_pixmap_colormap(GLEW_CONTEXT_ARG_VAR_INIT); +#endif /* GLX_MESA_pixmap_colormap */ +#ifdef GLX_MESA_release_buffers + CONST_CAST(GLXEW_MESA_release_buffers) = glxewGetExtension("GLX_MESA_release_buffers"); + if (glewExperimental || GLXEW_MESA_release_buffers) CONST_CAST(GLXEW_MESA_release_buffers) = !_glewInit_GLX_MESA_release_buffers(GLEW_CONTEXT_ARG_VAR_INIT); +#endif /* GLX_MESA_release_buffers */ +#ifdef GLX_MESA_set_3dfx_mode + CONST_CAST(GLXEW_MESA_set_3dfx_mode) = glxewGetExtension("GLX_MESA_set_3dfx_mode"); + if (glewExperimental || GLXEW_MESA_set_3dfx_mode) CONST_CAST(GLXEW_MESA_set_3dfx_mode) = !_glewInit_GLX_MESA_set_3dfx_mode(GLEW_CONTEXT_ARG_VAR_INIT); +#endif /* GLX_MESA_set_3dfx_mode */ +#ifdef GLX_NV_float_buffer + CONST_CAST(GLXEW_NV_float_buffer) = glxewGetExtension("GLX_NV_float_buffer"); +#endif /* GLX_NV_float_buffer */ +#ifdef GLX_NV_present_video + CONST_CAST(GLXEW_NV_present_video) = glxewGetExtension("GLX_NV_present_video"); + if (glewExperimental || GLXEW_NV_present_video) CONST_CAST(GLXEW_NV_present_video) = !_glewInit_GLX_NV_present_video(GLEW_CONTEXT_ARG_VAR_INIT); +#endif /* GLX_NV_present_video */ +#ifdef GLX_NV_swap_group + CONST_CAST(GLXEW_NV_swap_group) = glxewGetExtension("GLX_NV_swap_group"); + if (glewExperimental || GLXEW_NV_swap_group) CONST_CAST(GLXEW_NV_swap_group) = !_glewInit_GLX_NV_swap_group(GLEW_CONTEXT_ARG_VAR_INIT); +#endif /* GLX_NV_swap_group */ +#ifdef GLX_NV_vertex_array_range + CONST_CAST(GLXEW_NV_vertex_array_range) = glxewGetExtension("GLX_NV_vertex_array_range"); + if (glewExperimental || GLXEW_NV_vertex_array_range) CONST_CAST(GLXEW_NV_vertex_array_range) = !_glewInit_GLX_NV_vertex_array_range(GLEW_CONTEXT_ARG_VAR_INIT); +#endif /* GLX_NV_vertex_array_range */ +#ifdef GLX_NV_video_output + CONST_CAST(GLXEW_NV_video_output) = glxewGetExtension("GLX_NV_video_output"); + if (glewExperimental || GLXEW_NV_video_output) CONST_CAST(GLXEW_NV_video_output) = !_glewInit_GLX_NV_video_output(GLEW_CONTEXT_ARG_VAR_INIT); +#endif /* GLX_NV_video_output */ +#ifdef GLX_OML_swap_method + CONST_CAST(GLXEW_OML_swap_method) = glxewGetExtension("GLX_OML_swap_method"); +#endif /* GLX_OML_swap_method */ +#if defined(GLX_OML_sync_control) && defined(__STDC_VERSION__) && (__STDC_VERSION__ >= 199901L) +#include + CONST_CAST(GLXEW_OML_sync_control) = glxewGetExtension("GLX_OML_sync_control"); + if (glewExperimental || GLXEW_OML_sync_control) CONST_CAST(GLXEW_OML_sync_control) = !_glewInit_GLX_OML_sync_control(GLEW_CONTEXT_ARG_VAR_INIT); +#endif /* GLX_OML_sync_control */ +#ifdef GLX_SGIS_blended_overlay + CONST_CAST(GLXEW_SGIS_blended_overlay) = glxewGetExtension("GLX_SGIS_blended_overlay"); +#endif /* GLX_SGIS_blended_overlay */ +#ifdef GLX_SGIS_color_range + CONST_CAST(GLXEW_SGIS_color_range) = glxewGetExtension("GLX_SGIS_color_range"); +#endif /* GLX_SGIS_color_range */ +#ifdef GLX_SGIS_multisample + CONST_CAST(GLXEW_SGIS_multisample) = glxewGetExtension("GLX_SGIS_multisample"); +#endif /* GLX_SGIS_multisample */ +#ifdef GLX_SGIS_shared_multisample + CONST_CAST(GLXEW_SGIS_shared_multisample) = glxewGetExtension("GLX_SGIS_shared_multisample"); +#endif /* GLX_SGIS_shared_multisample */ +#ifdef GLX_SGIX_fbconfig + CONST_CAST(GLXEW_SGIX_fbconfig) = glxewGetExtension("GLX_SGIX_fbconfig"); + if (glewExperimental || GLXEW_SGIX_fbconfig) CONST_CAST(GLXEW_SGIX_fbconfig) = !_glewInit_GLX_SGIX_fbconfig(GLEW_CONTEXT_ARG_VAR_INIT); +#endif /* GLX_SGIX_fbconfig */ +#ifdef GLX_SGIX_hyperpipe + CONST_CAST(GLXEW_SGIX_hyperpipe) = glxewGetExtension("GLX_SGIX_hyperpipe"); + if (glewExperimental || GLXEW_SGIX_hyperpipe) CONST_CAST(GLXEW_SGIX_hyperpipe) = !_glewInit_GLX_SGIX_hyperpipe(GLEW_CONTEXT_ARG_VAR_INIT); +#endif /* GLX_SGIX_hyperpipe */ +#ifdef GLX_SGIX_pbuffer + CONST_CAST(GLXEW_SGIX_pbuffer) = glxewGetExtension("GLX_SGIX_pbuffer"); + if (glewExperimental || GLXEW_SGIX_pbuffer) CONST_CAST(GLXEW_SGIX_pbuffer) = !_glewInit_GLX_SGIX_pbuffer(GLEW_CONTEXT_ARG_VAR_INIT); +#endif /* GLX_SGIX_pbuffer */ +#ifdef GLX_SGIX_swap_barrier + CONST_CAST(GLXEW_SGIX_swap_barrier) = glxewGetExtension("GLX_SGIX_swap_barrier"); + if (glewExperimental || GLXEW_SGIX_swap_barrier) CONST_CAST(GLXEW_SGIX_swap_barrier) = !_glewInit_GLX_SGIX_swap_barrier(GLEW_CONTEXT_ARG_VAR_INIT); +#endif /* GLX_SGIX_swap_barrier */ +#ifdef GLX_SGIX_swap_group + CONST_CAST(GLXEW_SGIX_swap_group) = glxewGetExtension("GLX_SGIX_swap_group"); + if (glewExperimental || GLXEW_SGIX_swap_group) CONST_CAST(GLXEW_SGIX_swap_group) = !_glewInit_GLX_SGIX_swap_group(GLEW_CONTEXT_ARG_VAR_INIT); +#endif /* GLX_SGIX_swap_group */ +#ifdef GLX_SGIX_video_resize + CONST_CAST(GLXEW_SGIX_video_resize) = glxewGetExtension("GLX_SGIX_video_resize"); + if (glewExperimental || GLXEW_SGIX_video_resize) CONST_CAST(GLXEW_SGIX_video_resize) = !_glewInit_GLX_SGIX_video_resize(GLEW_CONTEXT_ARG_VAR_INIT); +#endif /* GLX_SGIX_video_resize */ +#ifdef GLX_SGIX_visual_select_group + CONST_CAST(GLXEW_SGIX_visual_select_group) = glxewGetExtension("GLX_SGIX_visual_select_group"); +#endif /* GLX_SGIX_visual_select_group */ +#ifdef GLX_SGI_cushion + CONST_CAST(GLXEW_SGI_cushion) = glxewGetExtension("GLX_SGI_cushion"); + if (glewExperimental || GLXEW_SGI_cushion) CONST_CAST(GLXEW_SGI_cushion) = !_glewInit_GLX_SGI_cushion(GLEW_CONTEXT_ARG_VAR_INIT); +#endif /* GLX_SGI_cushion */ +#ifdef GLX_SGI_make_current_read + CONST_CAST(GLXEW_SGI_make_current_read) = glxewGetExtension("GLX_SGI_make_current_read"); + if (glewExperimental || GLXEW_SGI_make_current_read) CONST_CAST(GLXEW_SGI_make_current_read) = !_glewInit_GLX_SGI_make_current_read(GLEW_CONTEXT_ARG_VAR_INIT); +#endif /* GLX_SGI_make_current_read */ +#ifdef GLX_SGI_swap_control + CONST_CAST(GLXEW_SGI_swap_control) = glxewGetExtension("GLX_SGI_swap_control"); + if (glewExperimental || GLXEW_SGI_swap_control) CONST_CAST(GLXEW_SGI_swap_control) = !_glewInit_GLX_SGI_swap_control(GLEW_CONTEXT_ARG_VAR_INIT); +#endif /* GLX_SGI_swap_control */ +#ifdef GLX_SGI_video_sync + CONST_CAST(GLXEW_SGI_video_sync) = glxewGetExtension("GLX_SGI_video_sync"); + if (glewExperimental || GLXEW_SGI_video_sync) CONST_CAST(GLXEW_SGI_video_sync) = !_glewInit_GLX_SGI_video_sync(GLEW_CONTEXT_ARG_VAR_INIT); +#endif /* GLX_SGI_video_sync */ +#ifdef GLX_SUN_get_transparent_index + CONST_CAST(GLXEW_SUN_get_transparent_index) = glxewGetExtension("GLX_SUN_get_transparent_index"); + if (glewExperimental || GLXEW_SUN_get_transparent_index) CONST_CAST(GLXEW_SUN_get_transparent_index) = !_glewInit_GLX_SUN_get_transparent_index(GLEW_CONTEXT_ARG_VAR_INIT); +#endif /* GLX_SUN_get_transparent_index */ +#ifdef GLX_SUN_video_resize + CONST_CAST(GLXEW_SUN_video_resize) = glxewGetExtension("GLX_SUN_video_resize"); + if (glewExperimental || GLXEW_SUN_video_resize) CONST_CAST(GLXEW_SUN_video_resize) = !_glewInit_GLX_SUN_video_resize(GLEW_CONTEXT_ARG_VAR_INIT); +#endif /* GLX_SUN_video_resize */ + + return GLEW_OK; +} + +#endif /* !__APPLE__ || GLEW_APPLE_GLX */ + +/* ------------------------------------------------------------------------ */ + +const GLubyte* glewGetErrorString (GLenum error) +{ + static const GLubyte* _glewErrorString[] = + { + (const GLubyte*)"No error", + (const GLubyte*)"Missing GL version", + (const GLubyte*)"GL 1.1 and up are not supported", + (const GLubyte*)"GLX 1.2 and up are not supported", + (const GLubyte*)"Unknown error" + }; + const int max_error = sizeof(_glewErrorString)/sizeof(*_glewErrorString) - 1; + return _glewErrorString[(int)error > max_error ? max_error : (int)error]; +} + +const GLubyte* glewGetString (GLenum name) +{ + static const GLubyte* _glewString[] = + { + (const GLubyte*)NULL, + (const GLubyte*)"1.5.1", + (const GLubyte*)"1", + (const GLubyte*)"5", + (const GLubyte*)"1" + }; + const int max_string = sizeof(_glewString)/sizeof(*_glewString) - 1; + return _glewString[(int)name > max_string ? 0 : (int)name]; +} + +/* ------------------------------------------------------------------------ */ + +GLboolean glewExperimental = GL_FALSE; + +#if !defined(GLEW_MX) + +#if defined(_WIN32) +extern GLenum wglewContextInit (void); +#elif !defined(__APPLE__) || defined(GLEW_APPLE_GLX) /* _UNIX */ +extern GLenum glxewContextInit (void); +#endif /* _WIN32 */ + +GLenum glewInit () +{ + GLenum r; + if ( (r = glewContextInit())!=NULL ) return r; +#if defined(_WIN32) + return wglewContextInit(); +#elif !defined(__APPLE__) || defined(GLEW_APPLE_GLX) /* _UNIX */ + return glxewContextInit(); +#else + return r; +#endif /* _WIN32 */ +} + +#endif /* !GLEW_MX */ +#ifdef GLEW_MX +GLboolean glewContextIsSupported (GLEWContext* ctx, const char* name) +#else +GLboolean glewIsSupported (const char* name) +#endif +{ + GLubyte* pos = (GLubyte*)name; + GLuint len = _glewStrLen(pos); + GLboolean ret = GL_TRUE; + while (ret && len > 0) + { + if (_glewStrSame1(&pos, &len, (const GLubyte*)"GL_", 3)) + { + if (_glewStrSame2(&pos, &len, (const GLubyte*)"VERSION_", 8)) + { +#ifdef GL_VERSION_1_2 + if (_glewStrSame3(&pos, &len, (const GLubyte*)"1_2", 3)) + { + ret = GLEW_VERSION_1_2; + continue; + } +#endif +#ifdef GL_VERSION_1_3 + if (_glewStrSame3(&pos, &len, (const GLubyte*)"1_3", 3)) + { + ret = GLEW_VERSION_1_3; + continue; + } +#endif +#ifdef GL_VERSION_1_4 + if (_glewStrSame3(&pos, &len, (const GLubyte*)"1_4", 3)) + { + ret = GLEW_VERSION_1_4; + continue; + } +#endif +#ifdef GL_VERSION_1_5 + if (_glewStrSame3(&pos, &len, (const GLubyte*)"1_5", 3)) + { + ret = GLEW_VERSION_1_5; + continue; + } +#endif +#ifdef GL_VERSION_2_0 + if (_glewStrSame3(&pos, &len, (const GLubyte*)"2_0", 3)) + { + ret = GLEW_VERSION_2_0; + continue; + } +#endif +#ifdef GL_VERSION_2_1 + if (_glewStrSame3(&pos, &len, (const GLubyte*)"2_1", 3)) + { + ret = GLEW_VERSION_2_1; + continue; + } +#endif +#ifdef GL_VERSION_3_0 + if (_glewStrSame3(&pos, &len, (const GLubyte*)"3_0", 3)) + { + ret = GLEW_VERSION_3_0; + continue; + } +#endif + } + if (_glewStrSame2(&pos, &len, (const GLubyte*)"3DFX_", 5)) + { +#ifdef GL_3DFX_multisample + if (_glewStrSame3(&pos, &len, (const GLubyte*)"multisample", 11)) + { + ret = GLEW_3DFX_multisample; + continue; + } +#endif +#ifdef GL_3DFX_tbuffer + if (_glewStrSame3(&pos, &len, (const GLubyte*)"tbuffer", 7)) + { + ret = GLEW_3DFX_tbuffer; + continue; + } +#endif +#ifdef GL_3DFX_texture_compression_FXT1 + if (_glewStrSame3(&pos, &len, (const GLubyte*)"texture_compression_FXT1", 24)) + { + ret = GLEW_3DFX_texture_compression_FXT1; + continue; + } +#endif + } + if (_glewStrSame2(&pos, &len, (const GLubyte*)"APPLE_", 6)) + { +#ifdef GL_APPLE_client_storage + if (_glewStrSame3(&pos, &len, (const GLubyte*)"client_storage", 14)) + { + ret = GLEW_APPLE_client_storage; + continue; + } +#endif +#ifdef GL_APPLE_element_array + if (_glewStrSame3(&pos, &len, (const GLubyte*)"element_array", 13)) + { + ret = GLEW_APPLE_element_array; + continue; + } +#endif +#ifdef GL_APPLE_fence + if (_glewStrSame3(&pos, &len, (const GLubyte*)"fence", 5)) + { + ret = GLEW_APPLE_fence; + continue; + } +#endif +#ifdef GL_APPLE_float_pixels + if (_glewStrSame3(&pos, &len, (const GLubyte*)"float_pixels", 12)) + { + ret = GLEW_APPLE_float_pixels; + continue; + } +#endif +#ifdef GL_APPLE_flush_buffer_range + if (_glewStrSame3(&pos, &len, (const GLubyte*)"flush_buffer_range", 18)) + { + ret = GLEW_APPLE_flush_buffer_range; + continue; + } +#endif +#ifdef GL_APPLE_pixel_buffer + if (_glewStrSame3(&pos, &len, (const GLubyte*)"pixel_buffer", 12)) + { + ret = GLEW_APPLE_pixel_buffer; + continue; + } +#endif +#ifdef GL_APPLE_specular_vector + if (_glewStrSame3(&pos, &len, (const GLubyte*)"specular_vector", 15)) + { + ret = GLEW_APPLE_specular_vector; + continue; + } +#endif +#ifdef GL_APPLE_texture_range + if (_glewStrSame3(&pos, &len, (const GLubyte*)"texture_range", 13)) + { + ret = GLEW_APPLE_texture_range; + continue; + } +#endif +#ifdef GL_APPLE_transform_hint + if (_glewStrSame3(&pos, &len, (const GLubyte*)"transform_hint", 14)) + { + ret = GLEW_APPLE_transform_hint; + continue; + } +#endif +#ifdef GL_APPLE_vertex_array_object + if (_glewStrSame3(&pos, &len, (const GLubyte*)"vertex_array_object", 19)) + { + ret = GLEW_APPLE_vertex_array_object; + continue; + } +#endif +#ifdef GL_APPLE_vertex_array_range + if (_glewStrSame3(&pos, &len, (const GLubyte*)"vertex_array_range", 18)) + { + ret = GLEW_APPLE_vertex_array_range; + continue; + } +#endif +#ifdef GL_APPLE_ycbcr_422 + if (_glewStrSame3(&pos, &len, (const GLubyte*)"ycbcr_422", 9)) + { + ret = GLEW_APPLE_ycbcr_422; + continue; + } +#endif + } + if (_glewStrSame2(&pos, &len, (const GLubyte*)"ARB_", 4)) + { +#ifdef GL_ARB_color_buffer_float + if (_glewStrSame3(&pos, &len, (const GLubyte*)"color_buffer_float", 18)) + { + ret = GLEW_ARB_color_buffer_float; + continue; + } +#endif +#ifdef GL_ARB_depth_buffer_float + if (_glewStrSame3(&pos, &len, (const GLubyte*)"depth_buffer_float", 18)) + { + ret = GLEW_ARB_depth_buffer_float; + continue; + } +#endif +#ifdef GL_ARB_depth_texture + if (_glewStrSame3(&pos, &len, (const GLubyte*)"depth_texture", 13)) + { + ret = GLEW_ARB_depth_texture; + continue; + } +#endif +#ifdef GL_ARB_draw_buffers + if (_glewStrSame3(&pos, &len, (const GLubyte*)"draw_buffers", 12)) + { + ret = GLEW_ARB_draw_buffers; + continue; + } +#endif +#ifdef GL_ARB_draw_instanced + if (_glewStrSame3(&pos, &len, (const GLubyte*)"draw_instanced", 14)) + { + ret = GLEW_ARB_draw_instanced; + continue; + } +#endif +#ifdef GL_ARB_fragment_program + if (_glewStrSame3(&pos, &len, (const GLubyte*)"fragment_program", 16)) + { + ret = GLEW_ARB_fragment_program; + continue; + } +#endif +#ifdef GL_ARB_fragment_program_shadow + if (_glewStrSame3(&pos, &len, (const GLubyte*)"fragment_program_shadow", 23)) + { + ret = GLEW_ARB_fragment_program_shadow; + continue; + } +#endif +#ifdef GL_ARB_fragment_shader + if (_glewStrSame3(&pos, &len, (const GLubyte*)"fragment_shader", 15)) + { + ret = GLEW_ARB_fragment_shader; + continue; + } +#endif +#ifdef GL_ARB_framebuffer_object + if (_glewStrSame3(&pos, &len, (const GLubyte*)"framebuffer_object", 18)) + { + ret = GLEW_ARB_framebuffer_object; + continue; + } +#endif +#ifdef GL_ARB_framebuffer_sRGB + if (_glewStrSame3(&pos, &len, (const GLubyte*)"framebuffer_sRGB", 16)) + { + ret = GLEW_ARB_framebuffer_sRGB; + continue; + } +#endif +#ifdef GL_ARB_geometry_shader4 + if (_glewStrSame3(&pos, &len, (const GLubyte*)"geometry_shader4", 16)) + { + ret = GLEW_ARB_geometry_shader4; + continue; + } +#endif +#ifdef GL_ARB_half_float_pixel + if (_glewStrSame3(&pos, &len, (const GLubyte*)"half_float_pixel", 16)) + { + ret = GLEW_ARB_half_float_pixel; + continue; + } +#endif +#ifdef GL_ARB_half_float_vertex + if (_glewStrSame3(&pos, &len, (const GLubyte*)"half_float_vertex", 17)) + { + ret = GLEW_ARB_half_float_vertex; + continue; + } +#endif +#ifdef GL_ARB_imaging + if (_glewStrSame3(&pos, &len, (const GLubyte*)"imaging", 7)) + { + ret = GLEW_ARB_imaging; + continue; + } +#endif +#ifdef GL_ARB_instanced_arrays + if (_glewStrSame3(&pos, &len, (const GLubyte*)"instanced_arrays", 16)) + { + ret = GLEW_ARB_instanced_arrays; + continue; + } +#endif +#ifdef GL_ARB_map_buffer_range + if (_glewStrSame3(&pos, &len, (const GLubyte*)"map_buffer_range", 16)) + { + ret = GLEW_ARB_map_buffer_range; + continue; + } +#endif +#ifdef GL_ARB_matrix_palette + if (_glewStrSame3(&pos, &len, (const GLubyte*)"matrix_palette", 14)) + { + ret = GLEW_ARB_matrix_palette; + continue; + } +#endif +#ifdef GL_ARB_multisample + if (_glewStrSame3(&pos, &len, (const GLubyte*)"multisample", 11)) + { + ret = GLEW_ARB_multisample; + continue; + } +#endif +#ifdef GL_ARB_multitexture + if (_glewStrSame3(&pos, &len, (const GLubyte*)"multitexture", 12)) + { + ret = GLEW_ARB_multitexture; + continue; + } +#endif +#ifdef GL_ARB_occlusion_query + if (_glewStrSame3(&pos, &len, (const GLubyte*)"occlusion_query", 15)) + { + ret = GLEW_ARB_occlusion_query; + continue; + } +#endif +#ifdef GL_ARB_pixel_buffer_object + if (_glewStrSame3(&pos, &len, (const GLubyte*)"pixel_buffer_object", 19)) + { + ret = GLEW_ARB_pixel_buffer_object; + continue; + } +#endif +#ifdef GL_ARB_point_parameters + if (_glewStrSame3(&pos, &len, (const GLubyte*)"point_parameters", 16)) + { + ret = GLEW_ARB_point_parameters; + continue; + } +#endif +#ifdef GL_ARB_point_sprite + if (_glewStrSame3(&pos, &len, (const GLubyte*)"point_sprite", 12)) + { + ret = GLEW_ARB_point_sprite; + continue; + } +#endif +#ifdef GL_ARB_shader_objects + if (_glewStrSame3(&pos, &len, (const GLubyte*)"shader_objects", 14)) + { + ret = GLEW_ARB_shader_objects; + continue; + } +#endif +#ifdef GL_ARB_shading_language_100 + if (_glewStrSame3(&pos, &len, (const GLubyte*)"shading_language_100", 20)) + { + ret = GLEW_ARB_shading_language_100; + continue; + } +#endif +#ifdef GL_ARB_shadow + if (_glewStrSame3(&pos, &len, (const GLubyte*)"shadow", 6)) + { + ret = GLEW_ARB_shadow; + continue; + } +#endif +#ifdef GL_ARB_shadow_ambient + if (_glewStrSame3(&pos, &len, (const GLubyte*)"shadow_ambient", 14)) + { + ret = GLEW_ARB_shadow_ambient; + continue; + } +#endif +#ifdef GL_ARB_texture_border_clamp + if (_glewStrSame3(&pos, &len, (const GLubyte*)"texture_border_clamp", 20)) + { + ret = GLEW_ARB_texture_border_clamp; + continue; + } +#endif +#ifdef GL_ARB_texture_buffer_object + if (_glewStrSame3(&pos, &len, (const GLubyte*)"texture_buffer_object", 21)) + { + ret = GLEW_ARB_texture_buffer_object; + continue; + } +#endif +#ifdef GL_ARB_texture_compression + if (_glewStrSame3(&pos, &len, (const GLubyte*)"texture_compression", 19)) + { + ret = GLEW_ARB_texture_compression; + continue; + } +#endif +#ifdef GL_ARB_texture_compression_rgtc + if (_glewStrSame3(&pos, &len, (const GLubyte*)"texture_compression_rgtc", 24)) + { + ret = GLEW_ARB_texture_compression_rgtc; + continue; + } +#endif +#ifdef GL_ARB_texture_cube_map + if (_glewStrSame3(&pos, &len, (const GLubyte*)"texture_cube_map", 16)) + { + ret = GLEW_ARB_texture_cube_map; + continue; + } +#endif +#ifdef GL_ARB_texture_env_add + if (_glewStrSame3(&pos, &len, (const GLubyte*)"texture_env_add", 15)) + { + ret = GLEW_ARB_texture_env_add; + continue; + } +#endif +#ifdef GL_ARB_texture_env_combine + if (_glewStrSame3(&pos, &len, (const GLubyte*)"texture_env_combine", 19)) + { + ret = GLEW_ARB_texture_env_combine; + continue; + } +#endif +#ifdef GL_ARB_texture_env_crossbar + if (_glewStrSame3(&pos, &len, (const GLubyte*)"texture_env_crossbar", 20)) + { + ret = GLEW_ARB_texture_env_crossbar; + continue; + } +#endif +#ifdef GL_ARB_texture_env_dot3 + if (_glewStrSame3(&pos, &len, (const GLubyte*)"texture_env_dot3", 16)) + { + ret = GLEW_ARB_texture_env_dot3; + continue; + } +#endif +#ifdef GL_ARB_texture_float + if (_glewStrSame3(&pos, &len, (const GLubyte*)"texture_float", 13)) + { + ret = GLEW_ARB_texture_float; + continue; + } +#endif +#ifdef GL_ARB_texture_mirrored_repeat + if (_glewStrSame3(&pos, &len, (const GLubyte*)"texture_mirrored_repeat", 23)) + { + ret = GLEW_ARB_texture_mirrored_repeat; + continue; + } +#endif +#ifdef GL_ARB_texture_non_power_of_two + if (_glewStrSame3(&pos, &len, (const GLubyte*)"texture_non_power_of_two", 24)) + { + ret = GLEW_ARB_texture_non_power_of_two; + continue; + } +#endif +#ifdef GL_ARB_texture_rectangle + if (_glewStrSame3(&pos, &len, (const GLubyte*)"texture_rectangle", 17)) + { + ret = GLEW_ARB_texture_rectangle; + continue; + } +#endif +#ifdef GL_ARB_texture_rg + if (_glewStrSame3(&pos, &len, (const GLubyte*)"texture_rg", 10)) + { + ret = GLEW_ARB_texture_rg; + continue; + } +#endif +#ifdef GL_ARB_transpose_matrix + if (_glewStrSame3(&pos, &len, (const GLubyte*)"transpose_matrix", 16)) + { + ret = GLEW_ARB_transpose_matrix; + continue; + } +#endif +#ifdef GL_ARB_vertex_array_object + if (_glewStrSame3(&pos, &len, (const GLubyte*)"vertex_array_object", 19)) + { + ret = GLEW_ARB_vertex_array_object; + continue; + } +#endif +#ifdef GL_ARB_vertex_blend + if (_glewStrSame3(&pos, &len, (const GLubyte*)"vertex_blend", 12)) + { + ret = GLEW_ARB_vertex_blend; + continue; + } +#endif +#ifdef GL_ARB_vertex_buffer_object + if (_glewStrSame3(&pos, &len, (const GLubyte*)"vertex_buffer_object", 20)) + { + ret = GLEW_ARB_vertex_buffer_object; + continue; + } +#endif +#ifdef GL_ARB_vertex_program + if (_glewStrSame3(&pos, &len, (const GLubyte*)"vertex_program", 14)) + { + ret = GLEW_ARB_vertex_program; + continue; + } +#endif +#ifdef GL_ARB_vertex_shader + if (_glewStrSame3(&pos, &len, (const GLubyte*)"vertex_shader", 13)) + { + ret = GLEW_ARB_vertex_shader; + continue; + } +#endif +#ifdef GL_ARB_window_pos + if (_glewStrSame3(&pos, &len, (const GLubyte*)"window_pos", 10)) + { + ret = GLEW_ARB_window_pos; + continue; + } +#endif + } + if (_glewStrSame2(&pos, &len, (const GLubyte*)"ATIX_", 5)) + { +#ifdef GL_ATIX_point_sprites + if (_glewStrSame3(&pos, &len, (const GLubyte*)"point_sprites", 13)) + { + ret = GLEW_ATIX_point_sprites; + continue; + } +#endif +#ifdef GL_ATIX_texture_env_combine3 + if (_glewStrSame3(&pos, &len, (const GLubyte*)"texture_env_combine3", 20)) + { + ret = GLEW_ATIX_texture_env_combine3; + continue; + } +#endif +#ifdef GL_ATIX_texture_env_route + if (_glewStrSame3(&pos, &len, (const GLubyte*)"texture_env_route", 17)) + { + ret = GLEW_ATIX_texture_env_route; + continue; + } +#endif +#ifdef GL_ATIX_vertex_shader_output_point_size + if (_glewStrSame3(&pos, &len, (const GLubyte*)"vertex_shader_output_point_size", 31)) + { + ret = GLEW_ATIX_vertex_shader_output_point_size; + continue; + } +#endif + } + if (_glewStrSame2(&pos, &len, (const GLubyte*)"ATI_", 4)) + { +#ifdef GL_ATI_draw_buffers + if (_glewStrSame3(&pos, &len, (const GLubyte*)"draw_buffers", 12)) + { + ret = GLEW_ATI_draw_buffers; + continue; + } +#endif +#ifdef GL_ATI_element_array + if (_glewStrSame3(&pos, &len, (const GLubyte*)"element_array", 13)) + { + ret = GLEW_ATI_element_array; + continue; + } +#endif +#ifdef GL_ATI_envmap_bumpmap + if (_glewStrSame3(&pos, &len, (const GLubyte*)"envmap_bumpmap", 14)) + { + ret = GLEW_ATI_envmap_bumpmap; + continue; + } +#endif +#ifdef GL_ATI_fragment_shader + if (_glewStrSame3(&pos, &len, (const GLubyte*)"fragment_shader", 15)) + { + ret = GLEW_ATI_fragment_shader; + continue; + } +#endif +#ifdef GL_ATI_map_object_buffer + if (_glewStrSame3(&pos, &len, (const GLubyte*)"map_object_buffer", 17)) + { + ret = GLEW_ATI_map_object_buffer; + continue; + } +#endif +#ifdef GL_ATI_pn_triangles + if (_glewStrSame3(&pos, &len, (const GLubyte*)"pn_triangles", 12)) + { + ret = GLEW_ATI_pn_triangles; + continue; + } +#endif +#ifdef GL_ATI_separate_stencil + if (_glewStrSame3(&pos, &len, (const GLubyte*)"separate_stencil", 16)) + { + ret = GLEW_ATI_separate_stencil; + continue; + } +#endif +#ifdef GL_ATI_shader_texture_lod + if (_glewStrSame3(&pos, &len, (const GLubyte*)"shader_texture_lod", 18)) + { + ret = GLEW_ATI_shader_texture_lod; + continue; + } +#endif +#ifdef GL_ATI_text_fragment_shader + if (_glewStrSame3(&pos, &len, (const GLubyte*)"text_fragment_shader", 20)) + { + ret = GLEW_ATI_text_fragment_shader; + continue; + } +#endif +#ifdef GL_ATI_texture_compression_3dc + if (_glewStrSame3(&pos, &len, (const GLubyte*)"texture_compression_3dc", 23)) + { + ret = GLEW_ATI_texture_compression_3dc; + continue; + } +#endif +#ifdef GL_ATI_texture_env_combine3 + if (_glewStrSame3(&pos, &len, (const GLubyte*)"texture_env_combine3", 20)) + { + ret = GLEW_ATI_texture_env_combine3; + continue; + } +#endif +#ifdef GL_ATI_texture_float + if (_glewStrSame3(&pos, &len, (const GLubyte*)"texture_float", 13)) + { + ret = GLEW_ATI_texture_float; + continue; + } +#endif +#ifdef GL_ATI_texture_mirror_once + if (_glewStrSame3(&pos, &len, (const GLubyte*)"texture_mirror_once", 19)) + { + ret = GLEW_ATI_texture_mirror_once; + continue; + } +#endif +#ifdef GL_ATI_vertex_array_object + if (_glewStrSame3(&pos, &len, (const GLubyte*)"vertex_array_object", 19)) + { + ret = GLEW_ATI_vertex_array_object; + continue; + } +#endif +#ifdef GL_ATI_vertex_attrib_array_object + if (_glewStrSame3(&pos, &len, (const GLubyte*)"vertex_attrib_array_object", 26)) + { + ret = GLEW_ATI_vertex_attrib_array_object; + continue; + } +#endif +#ifdef GL_ATI_vertex_streams + if (_glewStrSame3(&pos, &len, (const GLubyte*)"vertex_streams", 14)) + { + ret = GLEW_ATI_vertex_streams; + continue; + } +#endif + } + if (_glewStrSame2(&pos, &len, (const GLubyte*)"EXT_", 4)) + { +#ifdef GL_EXT_422_pixels + if (_glewStrSame3(&pos, &len, (const GLubyte*)"422_pixels", 10)) + { + ret = GLEW_EXT_422_pixels; + continue; + } +#endif +#ifdef GL_EXT_Cg_shader + if (_glewStrSame3(&pos, &len, (const GLubyte*)"Cg_shader", 9)) + { + ret = GLEW_EXT_Cg_shader; + continue; + } +#endif +#ifdef GL_EXT_abgr + if (_glewStrSame3(&pos, &len, (const GLubyte*)"abgr", 4)) + { + ret = GLEW_EXT_abgr; + continue; + } +#endif +#ifdef GL_EXT_bgra + if (_glewStrSame3(&pos, &len, (const GLubyte*)"bgra", 4)) + { + ret = GLEW_EXT_bgra; + continue; + } +#endif +#ifdef GL_EXT_bindable_uniform + if (_glewStrSame3(&pos, &len, (const GLubyte*)"bindable_uniform", 16)) + { + ret = GLEW_EXT_bindable_uniform; + continue; + } +#endif +#ifdef GL_EXT_blend_color + if (_glewStrSame3(&pos, &len, (const GLubyte*)"blend_color", 11)) + { + ret = GLEW_EXT_blend_color; + continue; + } +#endif +#ifdef GL_EXT_blend_equation_separate + if (_glewStrSame3(&pos, &len, (const GLubyte*)"blend_equation_separate", 23)) + { + ret = GLEW_EXT_blend_equation_separate; + continue; + } +#endif +#ifdef GL_EXT_blend_func_separate + if (_glewStrSame3(&pos, &len, (const GLubyte*)"blend_func_separate", 19)) + { + ret = GLEW_EXT_blend_func_separate; + continue; + } +#endif +#ifdef GL_EXT_blend_logic_op + if (_glewStrSame3(&pos, &len, (const GLubyte*)"blend_logic_op", 14)) + { + ret = GLEW_EXT_blend_logic_op; + continue; + } +#endif +#ifdef GL_EXT_blend_minmax + if (_glewStrSame3(&pos, &len, (const GLubyte*)"blend_minmax", 12)) + { + ret = GLEW_EXT_blend_minmax; + continue; + } +#endif +#ifdef GL_EXT_blend_subtract + if (_glewStrSame3(&pos, &len, (const GLubyte*)"blend_subtract", 14)) + { + ret = GLEW_EXT_blend_subtract; + continue; + } +#endif +#ifdef GL_EXT_clip_volume_hint + if (_glewStrSame3(&pos, &len, (const GLubyte*)"clip_volume_hint", 16)) + { + ret = GLEW_EXT_clip_volume_hint; + continue; + } +#endif +#ifdef GL_EXT_cmyka + if (_glewStrSame3(&pos, &len, (const GLubyte*)"cmyka", 5)) + { + ret = GLEW_EXT_cmyka; + continue; + } +#endif +#ifdef GL_EXT_color_subtable + if (_glewStrSame3(&pos, &len, (const GLubyte*)"color_subtable", 14)) + { + ret = GLEW_EXT_color_subtable; + continue; + } +#endif +#ifdef GL_EXT_compiled_vertex_array + if (_glewStrSame3(&pos, &len, (const GLubyte*)"compiled_vertex_array", 21)) + { + ret = GLEW_EXT_compiled_vertex_array; + continue; + } +#endif +#ifdef GL_EXT_convolution + if (_glewStrSame3(&pos, &len, (const GLubyte*)"convolution", 11)) + { + ret = GLEW_EXT_convolution; + continue; + } +#endif +#ifdef GL_EXT_coordinate_frame + if (_glewStrSame3(&pos, &len, (const GLubyte*)"coordinate_frame", 16)) + { + ret = GLEW_EXT_coordinate_frame; + continue; + } +#endif +#ifdef GL_EXT_copy_texture + if (_glewStrSame3(&pos, &len, (const GLubyte*)"copy_texture", 12)) + { + ret = GLEW_EXT_copy_texture; + continue; + } +#endif +#ifdef GL_EXT_cull_vertex + if (_glewStrSame3(&pos, &len, (const GLubyte*)"cull_vertex", 11)) + { + ret = GLEW_EXT_cull_vertex; + continue; + } +#endif +#ifdef GL_EXT_depth_bounds_test + if (_glewStrSame3(&pos, &len, (const GLubyte*)"depth_bounds_test", 17)) + { + ret = GLEW_EXT_depth_bounds_test; + continue; + } +#endif +#ifdef GL_EXT_direct_state_access + if (_glewStrSame3(&pos, &len, (const GLubyte*)"direct_state_access", 19)) + { + ret = GLEW_EXT_direct_state_access; + continue; + } +#endif +#ifdef GL_EXT_draw_buffers2 + if (_glewStrSame3(&pos, &len, (const GLubyte*)"draw_buffers2", 13)) + { + ret = GLEW_EXT_draw_buffers2; + continue; + } +#endif +#ifdef GL_EXT_draw_instanced + if (_glewStrSame3(&pos, &len, (const GLubyte*)"draw_instanced", 14)) + { + ret = GLEW_EXT_draw_instanced; + continue; + } +#endif +#ifdef GL_EXT_draw_range_elements + if (_glewStrSame3(&pos, &len, (const GLubyte*)"draw_range_elements", 19)) + { + ret = GLEW_EXT_draw_range_elements; + continue; + } +#endif +#ifdef GL_EXT_fog_coord + if (_glewStrSame3(&pos, &len, (const GLubyte*)"fog_coord", 9)) + { + ret = GLEW_EXT_fog_coord; + continue; + } +#endif +#ifdef GL_EXT_fragment_lighting + if (_glewStrSame3(&pos, &len, (const GLubyte*)"fragment_lighting", 17)) + { + ret = GLEW_EXT_fragment_lighting; + continue; + } +#endif +#ifdef GL_EXT_framebuffer_blit + if (_glewStrSame3(&pos, &len, (const GLubyte*)"framebuffer_blit", 16)) + { + ret = GLEW_EXT_framebuffer_blit; + continue; + } +#endif +#ifdef GL_EXT_framebuffer_multisample + if (_glewStrSame3(&pos, &len, (const GLubyte*)"framebuffer_multisample", 23)) + { + ret = GLEW_EXT_framebuffer_multisample; + continue; + } +#endif +#ifdef GL_EXT_framebuffer_object + if (_glewStrSame3(&pos, &len, (const GLubyte*)"framebuffer_object", 18)) + { + ret = GLEW_EXT_framebuffer_object; + continue; + } +#endif +#ifdef GL_EXT_framebuffer_sRGB + if (_glewStrSame3(&pos, &len, (const GLubyte*)"framebuffer_sRGB", 16)) + { + ret = GLEW_EXT_framebuffer_sRGB; + continue; + } +#endif +#ifdef GL_EXT_geometry_shader4 + if (_glewStrSame3(&pos, &len, (const GLubyte*)"geometry_shader4", 16)) + { + ret = GLEW_EXT_geometry_shader4; + continue; + } +#endif +#ifdef GL_EXT_gpu_program_parameters + if (_glewStrSame3(&pos, &len, (const GLubyte*)"gpu_program_parameters", 22)) + { + ret = GLEW_EXT_gpu_program_parameters; + continue; + } +#endif +#ifdef GL_EXT_gpu_shader4 + if (_glewStrSame3(&pos, &len, (const GLubyte*)"gpu_shader4", 11)) + { + ret = GLEW_EXT_gpu_shader4; + continue; + } +#endif +#ifdef GL_EXT_histogram + if (_glewStrSame3(&pos, &len, (const GLubyte*)"histogram", 9)) + { + ret = GLEW_EXT_histogram; + continue; + } +#endif +#ifdef GL_EXT_index_array_formats + if (_glewStrSame3(&pos, &len, (const GLubyte*)"index_array_formats", 19)) + { + ret = GLEW_EXT_index_array_formats; + continue; + } +#endif +#ifdef GL_EXT_index_func + if (_glewStrSame3(&pos, &len, (const GLubyte*)"index_func", 10)) + { + ret = GLEW_EXT_index_func; + continue; + } +#endif +#ifdef GL_EXT_index_material + if (_glewStrSame3(&pos, &len, (const GLubyte*)"index_material", 14)) + { + ret = GLEW_EXT_index_material; + continue; + } +#endif +#ifdef GL_EXT_index_texture + if (_glewStrSame3(&pos, &len, (const GLubyte*)"index_texture", 13)) + { + ret = GLEW_EXT_index_texture; + continue; + } +#endif +#ifdef GL_EXT_light_texture + if (_glewStrSame3(&pos, &len, (const GLubyte*)"light_texture", 13)) + { + ret = GLEW_EXT_light_texture; + continue; + } +#endif +#ifdef GL_EXT_misc_attribute + if (_glewStrSame3(&pos, &len, (const GLubyte*)"misc_attribute", 14)) + { + ret = GLEW_EXT_misc_attribute; + continue; + } +#endif +#ifdef GL_EXT_multi_draw_arrays + if (_glewStrSame3(&pos, &len, (const GLubyte*)"multi_draw_arrays", 17)) + { + ret = GLEW_EXT_multi_draw_arrays; + continue; + } +#endif +#ifdef GL_EXT_multisample + if (_glewStrSame3(&pos, &len, (const GLubyte*)"multisample", 11)) + { + ret = GLEW_EXT_multisample; + continue; + } +#endif +#ifdef GL_EXT_packed_depth_stencil + if (_glewStrSame3(&pos, &len, (const GLubyte*)"packed_depth_stencil", 20)) + { + ret = GLEW_EXT_packed_depth_stencil; + continue; + } +#endif +#ifdef GL_EXT_packed_float + if (_glewStrSame3(&pos, &len, (const GLubyte*)"packed_float", 12)) + { + ret = GLEW_EXT_packed_float; + continue; + } +#endif +#ifdef GL_EXT_packed_pixels + if (_glewStrSame3(&pos, &len, (const GLubyte*)"packed_pixels", 13)) + { + ret = GLEW_EXT_packed_pixels; + continue; + } +#endif +#ifdef GL_EXT_paletted_texture + if (_glewStrSame3(&pos, &len, (const GLubyte*)"paletted_texture", 16)) + { + ret = GLEW_EXT_paletted_texture; + continue; + } +#endif +#ifdef GL_EXT_pixel_buffer_object + if (_glewStrSame3(&pos, &len, (const GLubyte*)"pixel_buffer_object", 19)) + { + ret = GLEW_EXT_pixel_buffer_object; + continue; + } +#endif +#ifdef GL_EXT_pixel_transform + if (_glewStrSame3(&pos, &len, (const GLubyte*)"pixel_transform", 15)) + { + ret = GLEW_EXT_pixel_transform; + continue; + } +#endif +#ifdef GL_EXT_pixel_transform_color_table + if (_glewStrSame3(&pos, &len, (const GLubyte*)"pixel_transform_color_table", 27)) + { + ret = GLEW_EXT_pixel_transform_color_table; + continue; + } +#endif +#ifdef GL_EXT_point_parameters + if (_glewStrSame3(&pos, &len, (const GLubyte*)"point_parameters", 16)) + { + ret = GLEW_EXT_point_parameters; + continue; + } +#endif +#ifdef GL_EXT_polygon_offset + if (_glewStrSame3(&pos, &len, (const GLubyte*)"polygon_offset", 14)) + { + ret = GLEW_EXT_polygon_offset; + continue; + } +#endif +#ifdef GL_EXT_rescale_normal + if (_glewStrSame3(&pos, &len, (const GLubyte*)"rescale_normal", 14)) + { + ret = GLEW_EXT_rescale_normal; + continue; + } +#endif +#ifdef GL_EXT_scene_marker + if (_glewStrSame3(&pos, &len, (const GLubyte*)"scene_marker", 12)) + { + ret = GLEW_EXT_scene_marker; + continue; + } +#endif +#ifdef GL_EXT_secondary_color + if (_glewStrSame3(&pos, &len, (const GLubyte*)"secondary_color", 15)) + { + ret = GLEW_EXT_secondary_color; + continue; + } +#endif +#ifdef GL_EXT_separate_specular_color + if (_glewStrSame3(&pos, &len, (const GLubyte*)"separate_specular_color", 23)) + { + ret = GLEW_EXT_separate_specular_color; + continue; + } +#endif +#ifdef GL_EXT_shadow_funcs + if (_glewStrSame3(&pos, &len, (const GLubyte*)"shadow_funcs", 12)) + { + ret = GLEW_EXT_shadow_funcs; + continue; + } +#endif +#ifdef GL_EXT_shared_texture_palette + if (_glewStrSame3(&pos, &len, (const GLubyte*)"shared_texture_palette", 22)) + { + ret = GLEW_EXT_shared_texture_palette; + continue; + } +#endif +#ifdef GL_EXT_stencil_clear_tag + if (_glewStrSame3(&pos, &len, (const GLubyte*)"stencil_clear_tag", 17)) + { + ret = GLEW_EXT_stencil_clear_tag; + continue; + } +#endif +#ifdef GL_EXT_stencil_two_side + if (_glewStrSame3(&pos, &len, (const GLubyte*)"stencil_two_side", 16)) + { + ret = GLEW_EXT_stencil_two_side; + continue; + } +#endif +#ifdef GL_EXT_stencil_wrap + if (_glewStrSame3(&pos, &len, (const GLubyte*)"stencil_wrap", 12)) + { + ret = GLEW_EXT_stencil_wrap; + continue; + } +#endif +#ifdef GL_EXT_subtexture + if (_glewStrSame3(&pos, &len, (const GLubyte*)"subtexture", 10)) + { + ret = GLEW_EXT_subtexture; + continue; + } +#endif +#ifdef GL_EXT_texture + if (_glewStrSame3(&pos, &len, (const GLubyte*)"texture", 7)) + { + ret = GLEW_EXT_texture; + continue; + } +#endif +#ifdef GL_EXT_texture3D + if (_glewStrSame3(&pos, &len, (const GLubyte*)"texture3D", 9)) + { + ret = GLEW_EXT_texture3D; + continue; + } +#endif +#ifdef GL_EXT_texture_array + if (_glewStrSame3(&pos, &len, (const GLubyte*)"texture_array", 13)) + { + ret = GLEW_EXT_texture_array; + continue; + } +#endif +#ifdef GL_EXT_texture_buffer_object + if (_glewStrSame3(&pos, &len, (const GLubyte*)"texture_buffer_object", 21)) + { + ret = GLEW_EXT_texture_buffer_object; + continue; + } +#endif +#ifdef GL_EXT_texture_compression_dxt1 + if (_glewStrSame3(&pos, &len, (const GLubyte*)"texture_compression_dxt1", 24)) + { + ret = GLEW_EXT_texture_compression_dxt1; + continue; + } +#endif +#ifdef GL_EXT_texture_compression_latc + if (_glewStrSame3(&pos, &len, (const GLubyte*)"texture_compression_latc", 24)) + { + ret = GLEW_EXT_texture_compression_latc; + continue; + } +#endif +#ifdef GL_EXT_texture_compression_rgtc + if (_glewStrSame3(&pos, &len, (const GLubyte*)"texture_compression_rgtc", 24)) + { + ret = GLEW_EXT_texture_compression_rgtc; + continue; + } +#endif +#ifdef GL_EXT_texture_compression_s3tc + if (_glewStrSame3(&pos, &len, (const GLubyte*)"texture_compression_s3tc", 24)) + { + ret = GLEW_EXT_texture_compression_s3tc; + continue; + } +#endif +#ifdef GL_EXT_texture_cube_map + if (_glewStrSame3(&pos, &len, (const GLubyte*)"texture_cube_map", 16)) + { + ret = GLEW_EXT_texture_cube_map; + continue; + } +#endif +#ifdef GL_EXT_texture_edge_clamp + if (_glewStrSame3(&pos, &len, (const GLubyte*)"texture_edge_clamp", 18)) + { + ret = GLEW_EXT_texture_edge_clamp; + continue; + } +#endif +#ifdef GL_EXT_texture_env + if (_glewStrSame3(&pos, &len, (const GLubyte*)"texture_env", 11)) + { + ret = GLEW_EXT_texture_env; + continue; + } +#endif +#ifdef GL_EXT_texture_env_add + if (_glewStrSame3(&pos, &len, (const GLubyte*)"texture_env_add", 15)) + { + ret = GLEW_EXT_texture_env_add; + continue; + } +#endif +#ifdef GL_EXT_texture_env_combine + if (_glewStrSame3(&pos, &len, (const GLubyte*)"texture_env_combine", 19)) + { + ret = GLEW_EXT_texture_env_combine; + continue; + } +#endif +#ifdef GL_EXT_texture_env_dot3 + if (_glewStrSame3(&pos, &len, (const GLubyte*)"texture_env_dot3", 16)) + { + ret = GLEW_EXT_texture_env_dot3; + continue; + } +#endif +#ifdef GL_EXT_texture_filter_anisotropic + if (_glewStrSame3(&pos, &len, (const GLubyte*)"texture_filter_anisotropic", 26)) + { + ret = GLEW_EXT_texture_filter_anisotropic; + continue; + } +#endif +#ifdef GL_EXT_texture_integer + if (_glewStrSame3(&pos, &len, (const GLubyte*)"texture_integer", 15)) + { + ret = GLEW_EXT_texture_integer; + continue; + } +#endif +#ifdef GL_EXT_texture_lod_bias + if (_glewStrSame3(&pos, &len, (const GLubyte*)"texture_lod_bias", 16)) + { + ret = GLEW_EXT_texture_lod_bias; + continue; + } +#endif +#ifdef GL_EXT_texture_mirror_clamp + if (_glewStrSame3(&pos, &len, (const GLubyte*)"texture_mirror_clamp", 20)) + { + ret = GLEW_EXT_texture_mirror_clamp; + continue; + } +#endif +#ifdef GL_EXT_texture_object + if (_glewStrSame3(&pos, &len, (const GLubyte*)"texture_object", 14)) + { + ret = GLEW_EXT_texture_object; + continue; + } +#endif +#ifdef GL_EXT_texture_perturb_normal + if (_glewStrSame3(&pos, &len, (const GLubyte*)"texture_perturb_normal", 22)) + { + ret = GLEW_EXT_texture_perturb_normal; + continue; + } +#endif +#ifdef GL_EXT_texture_rectangle + if (_glewStrSame3(&pos, &len, (const GLubyte*)"texture_rectangle", 17)) + { + ret = GLEW_EXT_texture_rectangle; + continue; + } +#endif +#ifdef GL_EXT_texture_sRGB + if (_glewStrSame3(&pos, &len, (const GLubyte*)"texture_sRGB", 12)) + { + ret = GLEW_EXT_texture_sRGB; + continue; + } +#endif +#ifdef GL_EXT_texture_shared_exponent + if (_glewStrSame3(&pos, &len, (const GLubyte*)"texture_shared_exponent", 23)) + { + ret = GLEW_EXT_texture_shared_exponent; + continue; + } +#endif +#ifdef GL_EXT_texture_swizzle + if (_glewStrSame3(&pos, &len, (const GLubyte*)"texture_swizzle", 15)) + { + ret = GLEW_EXT_texture_swizzle; + continue; + } +#endif +#ifdef GL_EXT_timer_query + if (_glewStrSame3(&pos, &len, (const GLubyte*)"timer_query", 11)) + { + ret = GLEW_EXT_timer_query; + continue; + } +#endif +#ifdef GL_EXT_transform_feedback + if (_glewStrSame3(&pos, &len, (const GLubyte*)"transform_feedback", 18)) + { + ret = GLEW_EXT_transform_feedback; + continue; + } +#endif +#ifdef GL_EXT_vertex_array + if (_glewStrSame3(&pos, &len, (const GLubyte*)"vertex_array", 12)) + { + ret = GLEW_EXT_vertex_array; + continue; + } +#endif +#ifdef GL_EXT_vertex_array_bgra + if (_glewStrSame3(&pos, &len, (const GLubyte*)"vertex_array_bgra", 17)) + { + ret = GLEW_EXT_vertex_array_bgra; + continue; + } +#endif +#ifdef GL_EXT_vertex_shader + if (_glewStrSame3(&pos, &len, (const GLubyte*)"vertex_shader", 13)) + { + ret = GLEW_EXT_vertex_shader; + continue; + } +#endif +#ifdef GL_EXT_vertex_weighting + if (_glewStrSame3(&pos, &len, (const GLubyte*)"vertex_weighting", 16)) + { + ret = GLEW_EXT_vertex_weighting; + continue; + } +#endif + } + if (_glewStrSame2(&pos, &len, (const GLubyte*)"GREMEDY_", 8)) + { +#ifdef GL_GREMEDY_frame_terminator + if (_glewStrSame3(&pos, &len, (const GLubyte*)"frame_terminator", 16)) + { + ret = GLEW_GREMEDY_frame_terminator; + continue; + } +#endif +#ifdef GL_GREMEDY_string_marker + if (_glewStrSame3(&pos, &len, (const GLubyte*)"string_marker", 13)) + { + ret = GLEW_GREMEDY_string_marker; + continue; + } +#endif + } + if (_glewStrSame2(&pos, &len, (const GLubyte*)"HP_", 3)) + { +#ifdef GL_HP_convolution_border_modes + if (_glewStrSame3(&pos, &len, (const GLubyte*)"convolution_border_modes", 24)) + { + ret = GLEW_HP_convolution_border_modes; + continue; + } +#endif +#ifdef GL_HP_image_transform + if (_glewStrSame3(&pos, &len, (const GLubyte*)"image_transform", 15)) + { + ret = GLEW_HP_image_transform; + continue; + } +#endif +#ifdef GL_HP_occlusion_test + if (_glewStrSame3(&pos, &len, (const GLubyte*)"occlusion_test", 14)) + { + ret = GLEW_HP_occlusion_test; + continue; + } +#endif +#ifdef GL_HP_texture_lighting + if (_glewStrSame3(&pos, &len, (const GLubyte*)"texture_lighting", 16)) + { + ret = GLEW_HP_texture_lighting; + continue; + } +#endif + } + if (_glewStrSame2(&pos, &len, (const GLubyte*)"IBM_", 4)) + { +#ifdef GL_IBM_cull_vertex + if (_glewStrSame3(&pos, &len, (const GLubyte*)"cull_vertex", 11)) + { + ret = GLEW_IBM_cull_vertex; + continue; + } +#endif +#ifdef GL_IBM_multimode_draw_arrays + if (_glewStrSame3(&pos, &len, (const GLubyte*)"multimode_draw_arrays", 21)) + { + ret = GLEW_IBM_multimode_draw_arrays; + continue; + } +#endif +#ifdef GL_IBM_rasterpos_clip + if (_glewStrSame3(&pos, &len, (const GLubyte*)"rasterpos_clip", 14)) + { + ret = GLEW_IBM_rasterpos_clip; + continue; + } +#endif +#ifdef GL_IBM_static_data + if (_glewStrSame3(&pos, &len, (const GLubyte*)"static_data", 11)) + { + ret = GLEW_IBM_static_data; + continue; + } +#endif +#ifdef GL_IBM_texture_mirrored_repeat + if (_glewStrSame3(&pos, &len, (const GLubyte*)"texture_mirrored_repeat", 23)) + { + ret = GLEW_IBM_texture_mirrored_repeat; + continue; + } +#endif +#ifdef GL_IBM_vertex_array_lists + if (_glewStrSame3(&pos, &len, (const GLubyte*)"vertex_array_lists", 18)) + { + ret = GLEW_IBM_vertex_array_lists; + continue; + } +#endif + } + if (_glewStrSame2(&pos, &len, (const GLubyte*)"INGR_", 5)) + { +#ifdef GL_INGR_color_clamp + if (_glewStrSame3(&pos, &len, (const GLubyte*)"color_clamp", 11)) + { + ret = GLEW_INGR_color_clamp; + continue; + } +#endif +#ifdef GL_INGR_interlace_read + if (_glewStrSame3(&pos, &len, (const GLubyte*)"interlace_read", 14)) + { + ret = GLEW_INGR_interlace_read; + continue; + } +#endif + } + if (_glewStrSame2(&pos, &len, (const GLubyte*)"INTEL_", 6)) + { +#ifdef GL_INTEL_parallel_arrays + if (_glewStrSame3(&pos, &len, (const GLubyte*)"parallel_arrays", 15)) + { + ret = GLEW_INTEL_parallel_arrays; + continue; + } +#endif +#ifdef GL_INTEL_texture_scissor + if (_glewStrSame3(&pos, &len, (const GLubyte*)"texture_scissor", 15)) + { + ret = GLEW_INTEL_texture_scissor; + continue; + } +#endif + } + if (_glewStrSame2(&pos, &len, (const GLubyte*)"KTX_", 4)) + { +#ifdef GL_KTX_buffer_region + if (_glewStrSame3(&pos, &len, (const GLubyte*)"buffer_region", 13)) + { + ret = GLEW_KTX_buffer_region; + continue; + } +#endif + } + if (_glewStrSame2(&pos, &len, (const GLubyte*)"MESAX_", 6)) + { +#ifdef GL_MESAX_texture_stack + if (_glewStrSame3(&pos, &len, (const GLubyte*)"texture_stack", 13)) + { + ret = GLEW_MESAX_texture_stack; + continue; + } +#endif + } + if (_glewStrSame2(&pos, &len, (const GLubyte*)"MESA_", 5)) + { +#ifdef GL_MESA_pack_invert + if (_glewStrSame3(&pos, &len, (const GLubyte*)"pack_invert", 11)) + { + ret = GLEW_MESA_pack_invert; + continue; + } +#endif +#ifdef GL_MESA_resize_buffers + if (_glewStrSame3(&pos, &len, (const GLubyte*)"resize_buffers", 14)) + { + ret = GLEW_MESA_resize_buffers; + continue; + } +#endif +#ifdef GL_MESA_window_pos + if (_glewStrSame3(&pos, &len, (const GLubyte*)"window_pos", 10)) + { + ret = GLEW_MESA_window_pos; + continue; + } +#endif +#ifdef GL_MESA_ycbcr_texture + if (_glewStrSame3(&pos, &len, (const GLubyte*)"ycbcr_texture", 13)) + { + ret = GLEW_MESA_ycbcr_texture; + continue; + } +#endif + } + if (_glewStrSame2(&pos, &len, (const GLubyte*)"NV_", 3)) + { +#ifdef GL_NV_blend_square + if (_glewStrSame3(&pos, &len, (const GLubyte*)"blend_square", 12)) + { + ret = GLEW_NV_blend_square; + continue; + } +#endif +#ifdef GL_NV_conditional_render + if (_glewStrSame3(&pos, &len, (const GLubyte*)"conditional_render", 18)) + { + ret = GLEW_NV_conditional_render; + continue; + } +#endif +#ifdef GL_NV_copy_depth_to_color + if (_glewStrSame3(&pos, &len, (const GLubyte*)"copy_depth_to_color", 19)) + { + ret = GLEW_NV_copy_depth_to_color; + continue; + } +#endif +#ifdef GL_NV_depth_buffer_float + if (_glewStrSame3(&pos, &len, (const GLubyte*)"depth_buffer_float", 18)) + { + ret = GLEW_NV_depth_buffer_float; + continue; + } +#endif +#ifdef GL_NV_depth_clamp + if (_glewStrSame3(&pos, &len, (const GLubyte*)"depth_clamp", 11)) + { + ret = GLEW_NV_depth_clamp; + continue; + } +#endif +#ifdef GL_NV_depth_range_unclamped + if (_glewStrSame3(&pos, &len, (const GLubyte*)"depth_range_unclamped", 21)) + { + ret = GLEW_NV_depth_range_unclamped; + continue; + } +#endif +#ifdef GL_NV_evaluators + if (_glewStrSame3(&pos, &len, (const GLubyte*)"evaluators", 10)) + { + ret = GLEW_NV_evaluators; + continue; + } +#endif +#ifdef GL_NV_explicit_multisample + if (_glewStrSame3(&pos, &len, (const GLubyte*)"explicit_multisample", 20)) + { + ret = GLEW_NV_explicit_multisample; + continue; + } +#endif +#ifdef GL_NV_fence + if (_glewStrSame3(&pos, &len, (const GLubyte*)"fence", 5)) + { + ret = GLEW_NV_fence; + continue; + } +#endif +#ifdef GL_NV_float_buffer + if (_glewStrSame3(&pos, &len, (const GLubyte*)"float_buffer", 12)) + { + ret = GLEW_NV_float_buffer; + continue; + } +#endif +#ifdef GL_NV_fog_distance + if (_glewStrSame3(&pos, &len, (const GLubyte*)"fog_distance", 12)) + { + ret = GLEW_NV_fog_distance; + continue; + } +#endif +#ifdef GL_NV_fragment_program + if (_glewStrSame3(&pos, &len, (const GLubyte*)"fragment_program", 16)) + { + ret = GLEW_NV_fragment_program; + continue; + } +#endif +#ifdef GL_NV_fragment_program2 + if (_glewStrSame3(&pos, &len, (const GLubyte*)"fragment_program2", 17)) + { + ret = GLEW_NV_fragment_program2; + continue; + } +#endif +#ifdef GL_NV_fragment_program4 + if (_glewStrSame3(&pos, &len, (const GLubyte*)"fragment_program4", 17)) + { + ret = GLEW_NV_fragment_program4; + continue; + } +#endif +#ifdef GL_NV_fragment_program_option + if (_glewStrSame3(&pos, &len, (const GLubyte*)"fragment_program_option", 23)) + { + ret = GLEW_NV_fragment_program_option; + continue; + } +#endif +#ifdef GL_NV_framebuffer_multisample_coverage + if (_glewStrSame3(&pos, &len, (const GLubyte*)"framebuffer_multisample_coverage", 32)) + { + ret = GLEW_NV_framebuffer_multisample_coverage; + continue; + } +#endif +#ifdef GL_NV_geometry_program4 + if (_glewStrSame3(&pos, &len, (const GLubyte*)"geometry_program4", 17)) + { + ret = GLEW_NV_geometry_program4; + continue; + } +#endif +#ifdef GL_NV_geometry_shader4 + if (_glewStrSame3(&pos, &len, (const GLubyte*)"geometry_shader4", 16)) + { + ret = GLEW_NV_geometry_shader4; + continue; + } +#endif +#ifdef GL_NV_gpu_program4 + if (_glewStrSame3(&pos, &len, (const GLubyte*)"gpu_program4", 12)) + { + ret = GLEW_NV_gpu_program4; + continue; + } +#endif +#ifdef GL_NV_half_float + if (_glewStrSame3(&pos, &len, (const GLubyte*)"half_float", 10)) + { + ret = GLEW_NV_half_float; + continue; + } +#endif +#ifdef GL_NV_light_max_exponent + if (_glewStrSame3(&pos, &len, (const GLubyte*)"light_max_exponent", 18)) + { + ret = GLEW_NV_light_max_exponent; + continue; + } +#endif +#ifdef GL_NV_multisample_filter_hint + if (_glewStrSame3(&pos, &len, (const GLubyte*)"multisample_filter_hint", 23)) + { + ret = GLEW_NV_multisample_filter_hint; + continue; + } +#endif +#ifdef GL_NV_occlusion_query + if (_glewStrSame3(&pos, &len, (const GLubyte*)"occlusion_query", 15)) + { + ret = GLEW_NV_occlusion_query; + continue; + } +#endif +#ifdef GL_NV_packed_depth_stencil + if (_glewStrSame3(&pos, &len, (const GLubyte*)"packed_depth_stencil", 20)) + { + ret = GLEW_NV_packed_depth_stencil; + continue; + } +#endif +#ifdef GL_NV_parameter_buffer_object + if (_glewStrSame3(&pos, &len, (const GLubyte*)"parameter_buffer_object", 23)) + { + ret = GLEW_NV_parameter_buffer_object; + continue; + } +#endif +#ifdef GL_NV_pixel_data_range + if (_glewStrSame3(&pos, &len, (const GLubyte*)"pixel_data_range", 16)) + { + ret = GLEW_NV_pixel_data_range; + continue; + } +#endif +#ifdef GL_NV_point_sprite + if (_glewStrSame3(&pos, &len, (const GLubyte*)"point_sprite", 12)) + { + ret = GLEW_NV_point_sprite; + continue; + } +#endif +#ifdef GL_NV_present_video + if (_glewStrSame3(&pos, &len, (const GLubyte*)"present_video", 13)) + { + ret = GLEW_NV_present_video; + continue; + } +#endif +#ifdef GL_NV_primitive_restart + if (_glewStrSame3(&pos, &len, (const GLubyte*)"primitive_restart", 17)) + { + ret = GLEW_NV_primitive_restart; + continue; + } +#endif +#ifdef GL_NV_register_combiners + if (_glewStrSame3(&pos, &len, (const GLubyte*)"register_combiners", 18)) + { + ret = GLEW_NV_register_combiners; + continue; + } +#endif +#ifdef GL_NV_register_combiners2 + if (_glewStrSame3(&pos, &len, (const GLubyte*)"register_combiners2", 19)) + { + ret = GLEW_NV_register_combiners2; + continue; + } +#endif +#ifdef GL_NV_texgen_emboss + if (_glewStrSame3(&pos, &len, (const GLubyte*)"texgen_emboss", 13)) + { + ret = GLEW_NV_texgen_emboss; + continue; + } +#endif +#ifdef GL_NV_texgen_reflection + if (_glewStrSame3(&pos, &len, (const GLubyte*)"texgen_reflection", 17)) + { + ret = GLEW_NV_texgen_reflection; + continue; + } +#endif +#ifdef GL_NV_texture_compression_vtc + if (_glewStrSame3(&pos, &len, (const GLubyte*)"texture_compression_vtc", 23)) + { + ret = GLEW_NV_texture_compression_vtc; + continue; + } +#endif +#ifdef GL_NV_texture_env_combine4 + if (_glewStrSame3(&pos, &len, (const GLubyte*)"texture_env_combine4", 20)) + { + ret = GLEW_NV_texture_env_combine4; + continue; + } +#endif +#ifdef GL_NV_texture_expand_normal + if (_glewStrSame3(&pos, &len, (const GLubyte*)"texture_expand_normal", 21)) + { + ret = GLEW_NV_texture_expand_normal; + continue; + } +#endif +#ifdef GL_NV_texture_rectangle + if (_glewStrSame3(&pos, &len, (const GLubyte*)"texture_rectangle", 17)) + { + ret = GLEW_NV_texture_rectangle; + continue; + } +#endif +#ifdef GL_NV_texture_shader + if (_glewStrSame3(&pos, &len, (const GLubyte*)"texture_shader", 14)) + { + ret = GLEW_NV_texture_shader; + continue; + } +#endif +#ifdef GL_NV_texture_shader2 + if (_glewStrSame3(&pos, &len, (const GLubyte*)"texture_shader2", 15)) + { + ret = GLEW_NV_texture_shader2; + continue; + } +#endif +#ifdef GL_NV_texture_shader3 + if (_glewStrSame3(&pos, &len, (const GLubyte*)"texture_shader3", 15)) + { + ret = GLEW_NV_texture_shader3; + continue; + } +#endif +#ifdef GL_NV_transform_feedback + if (_glewStrSame3(&pos, &len, (const GLubyte*)"transform_feedback", 18)) + { + ret = GLEW_NV_transform_feedback; + continue; + } +#endif +#ifdef GL_NV_vertex_array_range + if (_glewStrSame3(&pos, &len, (const GLubyte*)"vertex_array_range", 18)) + { + ret = GLEW_NV_vertex_array_range; + continue; + } +#endif +#ifdef GL_NV_vertex_array_range2 + if (_glewStrSame3(&pos, &len, (const GLubyte*)"vertex_array_range2", 19)) + { + ret = GLEW_NV_vertex_array_range2; + continue; + } +#endif +#ifdef GL_NV_vertex_program + if (_glewStrSame3(&pos, &len, (const GLubyte*)"vertex_program", 14)) + { + ret = GLEW_NV_vertex_program; + continue; + } +#endif +#ifdef GL_NV_vertex_program1_1 + if (_glewStrSame3(&pos, &len, (const GLubyte*)"vertex_program1_1", 17)) + { + ret = GLEW_NV_vertex_program1_1; + continue; + } +#endif +#ifdef GL_NV_vertex_program2 + if (_glewStrSame3(&pos, &len, (const GLubyte*)"vertex_program2", 15)) + { + ret = GLEW_NV_vertex_program2; + continue; + } +#endif +#ifdef GL_NV_vertex_program2_option + if (_glewStrSame3(&pos, &len, (const GLubyte*)"vertex_program2_option", 22)) + { + ret = GLEW_NV_vertex_program2_option; + continue; + } +#endif +#ifdef GL_NV_vertex_program3 + if (_glewStrSame3(&pos, &len, (const GLubyte*)"vertex_program3", 15)) + { + ret = GLEW_NV_vertex_program3; + continue; + } +#endif +#ifdef GL_NV_vertex_program4 + if (_glewStrSame3(&pos, &len, (const GLubyte*)"vertex_program4", 15)) + { + ret = GLEW_NV_vertex_program4; + continue; + } +#endif + } + if (_glewStrSame2(&pos, &len, (const GLubyte*)"OES_", 4)) + { +#ifdef GL_OES_byte_coordinates + if (_glewStrSame3(&pos, &len, (const GLubyte*)"byte_coordinates", 16)) + { + ret = GLEW_OES_byte_coordinates; + continue; + } +#endif +#ifdef GL_OES_compressed_paletted_texture + if (_glewStrSame3(&pos, &len, (const GLubyte*)"compressed_paletted_texture", 27)) + { + ret = GLEW_OES_compressed_paletted_texture; + continue; + } +#endif +#ifdef GL_OES_read_format + if (_glewStrSame3(&pos, &len, (const GLubyte*)"read_format", 11)) + { + ret = GLEW_OES_read_format; + continue; + } +#endif +#ifdef GL_OES_single_precision + if (_glewStrSame3(&pos, &len, (const GLubyte*)"single_precision", 16)) + { + ret = GLEW_OES_single_precision; + continue; + } +#endif + } + if (_glewStrSame2(&pos, &len, (const GLubyte*)"OML_", 4)) + { +#ifdef GL_OML_interlace + if (_glewStrSame3(&pos, &len, (const GLubyte*)"interlace", 9)) + { + ret = GLEW_OML_interlace; + continue; + } +#endif +#ifdef GL_OML_resample + if (_glewStrSame3(&pos, &len, (const GLubyte*)"resample", 8)) + { + ret = GLEW_OML_resample; + continue; + } +#endif +#ifdef GL_OML_subsample + if (_glewStrSame3(&pos, &len, (const GLubyte*)"subsample", 9)) + { + ret = GLEW_OML_subsample; + continue; + } +#endif + } + if (_glewStrSame2(&pos, &len, (const GLubyte*)"PGI_", 4)) + { +#ifdef GL_PGI_misc_hints + if (_glewStrSame3(&pos, &len, (const GLubyte*)"misc_hints", 10)) + { + ret = GLEW_PGI_misc_hints; + continue; + } +#endif +#ifdef GL_PGI_vertex_hints + if (_glewStrSame3(&pos, &len, (const GLubyte*)"vertex_hints", 12)) + { + ret = GLEW_PGI_vertex_hints; + continue; + } +#endif + } + if (_glewStrSame2(&pos, &len, (const GLubyte*)"REND_", 5)) + { +#ifdef GL_REND_screen_coordinates + if (_glewStrSame3(&pos, &len, (const GLubyte*)"screen_coordinates", 18)) + { + ret = GLEW_REND_screen_coordinates; + continue; + } +#endif + } + if (_glewStrSame2(&pos, &len, (const GLubyte*)"S3_", 3)) + { +#ifdef GL_S3_s3tc + if (_glewStrSame3(&pos, &len, (const GLubyte*)"s3tc", 4)) + { + ret = GLEW_S3_s3tc; + continue; + } +#endif + } + if (_glewStrSame2(&pos, &len, (const GLubyte*)"SGIS_", 5)) + { +#ifdef GL_SGIS_color_range + if (_glewStrSame3(&pos, &len, (const GLubyte*)"color_range", 11)) + { + ret = GLEW_SGIS_color_range; + continue; + } +#endif +#ifdef GL_SGIS_detail_texture + if (_glewStrSame3(&pos, &len, (const GLubyte*)"detail_texture", 14)) + { + ret = GLEW_SGIS_detail_texture; + continue; + } +#endif +#ifdef GL_SGIS_fog_function + if (_glewStrSame3(&pos, &len, (const GLubyte*)"fog_function", 12)) + { + ret = GLEW_SGIS_fog_function; + continue; + } +#endif +#ifdef GL_SGIS_generate_mipmap + if (_glewStrSame3(&pos, &len, (const GLubyte*)"generate_mipmap", 15)) + { + ret = GLEW_SGIS_generate_mipmap; + continue; + } +#endif +#ifdef GL_SGIS_multisample + if (_glewStrSame3(&pos, &len, (const GLubyte*)"multisample", 11)) + { + ret = GLEW_SGIS_multisample; + continue; + } +#endif +#ifdef GL_SGIS_pixel_texture + if (_glewStrSame3(&pos, &len, (const GLubyte*)"pixel_texture", 13)) + { + ret = GLEW_SGIS_pixel_texture; + continue; + } +#endif +#ifdef GL_SGIS_point_line_texgen + if (_glewStrSame3(&pos, &len, (const GLubyte*)"point_line_texgen", 17)) + { + ret = GLEW_SGIS_point_line_texgen; + continue; + } +#endif +#ifdef GL_SGIS_sharpen_texture + if (_glewStrSame3(&pos, &len, (const GLubyte*)"sharpen_texture", 15)) + { + ret = GLEW_SGIS_sharpen_texture; + continue; + } +#endif +#ifdef GL_SGIS_texture4D + if (_glewStrSame3(&pos, &len, (const GLubyte*)"texture4D", 9)) + { + ret = GLEW_SGIS_texture4D; + continue; + } +#endif +#ifdef GL_SGIS_texture_border_clamp + if (_glewStrSame3(&pos, &len, (const GLubyte*)"texture_border_clamp", 20)) + { + ret = GLEW_SGIS_texture_border_clamp; + continue; + } +#endif +#ifdef GL_SGIS_texture_edge_clamp + if (_glewStrSame3(&pos, &len, (const GLubyte*)"texture_edge_clamp", 18)) + { + ret = GLEW_SGIS_texture_edge_clamp; + continue; + } +#endif +#ifdef GL_SGIS_texture_filter4 + if (_glewStrSame3(&pos, &len, (const GLubyte*)"texture_filter4", 15)) + { + ret = GLEW_SGIS_texture_filter4; + continue; + } +#endif +#ifdef GL_SGIS_texture_lod + if (_glewStrSame3(&pos, &len, (const GLubyte*)"texture_lod", 11)) + { + ret = GLEW_SGIS_texture_lod; + continue; + } +#endif +#ifdef GL_SGIS_texture_select + if (_glewStrSame3(&pos, &len, (const GLubyte*)"texture_select", 14)) + { + ret = GLEW_SGIS_texture_select; + continue; + } +#endif + } + if (_glewStrSame2(&pos, &len, (const GLubyte*)"SGIX_", 5)) + { +#ifdef GL_SGIX_async + if (_glewStrSame3(&pos, &len, (const GLubyte*)"async", 5)) + { + ret = GLEW_SGIX_async; + continue; + } +#endif +#ifdef GL_SGIX_async_histogram + if (_glewStrSame3(&pos, &len, (const GLubyte*)"async_histogram", 15)) + { + ret = GLEW_SGIX_async_histogram; + continue; + } +#endif +#ifdef GL_SGIX_async_pixel + if (_glewStrSame3(&pos, &len, (const GLubyte*)"async_pixel", 11)) + { + ret = GLEW_SGIX_async_pixel; + continue; + } +#endif +#ifdef GL_SGIX_blend_alpha_minmax + if (_glewStrSame3(&pos, &len, (const GLubyte*)"blend_alpha_minmax", 18)) + { + ret = GLEW_SGIX_blend_alpha_minmax; + continue; + } +#endif +#ifdef GL_SGIX_clipmap + if (_glewStrSame3(&pos, &len, (const GLubyte*)"clipmap", 7)) + { + ret = GLEW_SGIX_clipmap; + continue; + } +#endif +#ifdef GL_SGIX_convolution_accuracy + if (_glewStrSame3(&pos, &len, (const GLubyte*)"convolution_accuracy", 20)) + { + ret = GLEW_SGIX_convolution_accuracy; + continue; + } +#endif +#ifdef GL_SGIX_depth_texture + if (_glewStrSame3(&pos, &len, (const GLubyte*)"depth_texture", 13)) + { + ret = GLEW_SGIX_depth_texture; + continue; + } +#endif +#ifdef GL_SGIX_flush_raster + if (_glewStrSame3(&pos, &len, (const GLubyte*)"flush_raster", 12)) + { + ret = GLEW_SGIX_flush_raster; + continue; + } +#endif +#ifdef GL_SGIX_fog_offset + if (_glewStrSame3(&pos, &len, (const GLubyte*)"fog_offset", 10)) + { + ret = GLEW_SGIX_fog_offset; + continue; + } +#endif +#ifdef GL_SGIX_fog_texture + if (_glewStrSame3(&pos, &len, (const GLubyte*)"fog_texture", 11)) + { + ret = GLEW_SGIX_fog_texture; + continue; + } +#endif +#ifdef GL_SGIX_fragment_specular_lighting + if (_glewStrSame3(&pos, &len, (const GLubyte*)"fragment_specular_lighting", 26)) + { + ret = GLEW_SGIX_fragment_specular_lighting; + continue; + } +#endif +#ifdef GL_SGIX_framezoom + if (_glewStrSame3(&pos, &len, (const GLubyte*)"framezoom", 9)) + { + ret = GLEW_SGIX_framezoom; + continue; + } +#endif +#ifdef GL_SGIX_interlace + if (_glewStrSame3(&pos, &len, (const GLubyte*)"interlace", 9)) + { + ret = GLEW_SGIX_interlace; + continue; + } +#endif +#ifdef GL_SGIX_ir_instrument1 + if (_glewStrSame3(&pos, &len, (const GLubyte*)"ir_instrument1", 14)) + { + ret = GLEW_SGIX_ir_instrument1; + continue; + } +#endif +#ifdef GL_SGIX_list_priority + if (_glewStrSame3(&pos, &len, (const GLubyte*)"list_priority", 13)) + { + ret = GLEW_SGIX_list_priority; + continue; + } +#endif +#ifdef GL_SGIX_pixel_texture + if (_glewStrSame3(&pos, &len, (const GLubyte*)"pixel_texture", 13)) + { + ret = GLEW_SGIX_pixel_texture; + continue; + } +#endif +#ifdef GL_SGIX_pixel_texture_bits + if (_glewStrSame3(&pos, &len, (const GLubyte*)"pixel_texture_bits", 18)) + { + ret = GLEW_SGIX_pixel_texture_bits; + continue; + } +#endif +#ifdef GL_SGIX_reference_plane + if (_glewStrSame3(&pos, &len, (const GLubyte*)"reference_plane", 15)) + { + ret = GLEW_SGIX_reference_plane; + continue; + } +#endif +#ifdef GL_SGIX_resample + if (_glewStrSame3(&pos, &len, (const GLubyte*)"resample", 8)) + { + ret = GLEW_SGIX_resample; + continue; + } +#endif +#ifdef GL_SGIX_shadow + if (_glewStrSame3(&pos, &len, (const GLubyte*)"shadow", 6)) + { + ret = GLEW_SGIX_shadow; + continue; + } +#endif +#ifdef GL_SGIX_shadow_ambient + if (_glewStrSame3(&pos, &len, (const GLubyte*)"shadow_ambient", 14)) + { + ret = GLEW_SGIX_shadow_ambient; + continue; + } +#endif +#ifdef GL_SGIX_sprite + if (_glewStrSame3(&pos, &len, (const GLubyte*)"sprite", 6)) + { + ret = GLEW_SGIX_sprite; + continue; + } +#endif +#ifdef GL_SGIX_tag_sample_buffer + if (_glewStrSame3(&pos, &len, (const GLubyte*)"tag_sample_buffer", 17)) + { + ret = GLEW_SGIX_tag_sample_buffer; + continue; + } +#endif +#ifdef GL_SGIX_texture_add_env + if (_glewStrSame3(&pos, &len, (const GLubyte*)"texture_add_env", 15)) + { + ret = GLEW_SGIX_texture_add_env; + continue; + } +#endif +#ifdef GL_SGIX_texture_coordinate_clamp + if (_glewStrSame3(&pos, &len, (const GLubyte*)"texture_coordinate_clamp", 24)) + { + ret = GLEW_SGIX_texture_coordinate_clamp; + continue; + } +#endif +#ifdef GL_SGIX_texture_lod_bias + if (_glewStrSame3(&pos, &len, (const GLubyte*)"texture_lod_bias", 16)) + { + ret = GLEW_SGIX_texture_lod_bias; + continue; + } +#endif +#ifdef GL_SGIX_texture_multi_buffer + if (_glewStrSame3(&pos, &len, (const GLubyte*)"texture_multi_buffer", 20)) + { + ret = GLEW_SGIX_texture_multi_buffer; + continue; + } +#endif +#ifdef GL_SGIX_texture_range + if (_glewStrSame3(&pos, &len, (const GLubyte*)"texture_range", 13)) + { + ret = GLEW_SGIX_texture_range; + continue; + } +#endif +#ifdef GL_SGIX_texture_scale_bias + if (_glewStrSame3(&pos, &len, (const GLubyte*)"texture_scale_bias", 18)) + { + ret = GLEW_SGIX_texture_scale_bias; + continue; + } +#endif +#ifdef GL_SGIX_vertex_preclip + if (_glewStrSame3(&pos, &len, (const GLubyte*)"vertex_preclip", 14)) + { + ret = GLEW_SGIX_vertex_preclip; + continue; + } +#endif +#ifdef GL_SGIX_vertex_preclip_hint + if (_glewStrSame3(&pos, &len, (const GLubyte*)"vertex_preclip_hint", 19)) + { + ret = GLEW_SGIX_vertex_preclip_hint; + continue; + } +#endif +#ifdef GL_SGIX_ycrcb + if (_glewStrSame3(&pos, &len, (const GLubyte*)"ycrcb", 5)) + { + ret = GLEW_SGIX_ycrcb; + continue; + } +#endif + } + if (_glewStrSame2(&pos, &len, (const GLubyte*)"SGI_", 4)) + { +#ifdef GL_SGI_color_matrix + if (_glewStrSame3(&pos, &len, (const GLubyte*)"color_matrix", 12)) + { + ret = GLEW_SGI_color_matrix; + continue; + } +#endif +#ifdef GL_SGI_color_table + if (_glewStrSame3(&pos, &len, (const GLubyte*)"color_table", 11)) + { + ret = GLEW_SGI_color_table; + continue; + } +#endif +#ifdef GL_SGI_texture_color_table + if (_glewStrSame3(&pos, &len, (const GLubyte*)"texture_color_table", 19)) + { + ret = GLEW_SGI_texture_color_table; + continue; + } +#endif + } + if (_glewStrSame2(&pos, &len, (const GLubyte*)"SUNX_", 5)) + { +#ifdef GL_SUNX_constant_data + if (_glewStrSame3(&pos, &len, (const GLubyte*)"constant_data", 13)) + { + ret = GLEW_SUNX_constant_data; + continue; + } +#endif + } + if (_glewStrSame2(&pos, &len, (const GLubyte*)"SUN_", 4)) + { +#ifdef GL_SUN_convolution_border_modes + if (_glewStrSame3(&pos, &len, (const GLubyte*)"convolution_border_modes", 24)) + { + ret = GLEW_SUN_convolution_border_modes; + continue; + } +#endif +#ifdef GL_SUN_global_alpha + if (_glewStrSame3(&pos, &len, (const GLubyte*)"global_alpha", 12)) + { + ret = GLEW_SUN_global_alpha; + continue; + } +#endif +#ifdef GL_SUN_mesh_array + if (_glewStrSame3(&pos, &len, (const GLubyte*)"mesh_array", 10)) + { + ret = GLEW_SUN_mesh_array; + continue; + } +#endif +#ifdef GL_SUN_read_video_pixels + if (_glewStrSame3(&pos, &len, (const GLubyte*)"read_video_pixels", 17)) + { + ret = GLEW_SUN_read_video_pixels; + continue; + } +#endif +#ifdef GL_SUN_slice_accum + if (_glewStrSame3(&pos, &len, (const GLubyte*)"slice_accum", 11)) + { + ret = GLEW_SUN_slice_accum; + continue; + } +#endif +#ifdef GL_SUN_triangle_list + if (_glewStrSame3(&pos, &len, (const GLubyte*)"triangle_list", 13)) + { + ret = GLEW_SUN_triangle_list; + continue; + } +#endif +#ifdef GL_SUN_vertex + if (_glewStrSame3(&pos, &len, (const GLubyte*)"vertex", 6)) + { + ret = GLEW_SUN_vertex; + continue; + } +#endif + } + if (_glewStrSame2(&pos, &len, (const GLubyte*)"WIN_", 4)) + { +#ifdef GL_WIN_phong_shading + if (_glewStrSame3(&pos, &len, (const GLubyte*)"phong_shading", 13)) + { + ret = GLEW_WIN_phong_shading; + continue; + } +#endif +#ifdef GL_WIN_specular_fog + if (_glewStrSame3(&pos, &len, (const GLubyte*)"specular_fog", 12)) + { + ret = GLEW_WIN_specular_fog; + continue; + } +#endif +#ifdef GL_WIN_swap_hint + if (_glewStrSame3(&pos, &len, (const GLubyte*)"swap_hint", 9)) + { + ret = GLEW_WIN_swap_hint; + continue; + } +#endif + } + } + ret = (len == 0); + } + return ret; +} + +#if defined(_WIN32) + +#if defined(GLEW_MX) +GLboolean wglewContextIsSupported (WGLEWContext* ctx, const char* name) +#else +GLboolean wglewIsSupported (const char* name) +#endif +{ + GLubyte* pos = (GLubyte*)name; + GLuint len = _glewStrLen(pos); + GLboolean ret = GL_TRUE; + while (ret && len > 0) + { + if (_glewStrSame1(&pos, &len, (const GLubyte*)"WGL_", 4)) + { + if (_glewStrSame2(&pos, &len, (const GLubyte*)"3DFX_", 5)) + { +#ifdef WGL_3DFX_multisample + if (_glewStrSame3(&pos, &len, (const GLubyte*)"multisample", 11)) + { + ret = WGLEW_3DFX_multisample; + continue; + } +#endif + } + if (_glewStrSame2(&pos, &len, (const GLubyte*)"3DL_", 4)) + { +#ifdef WGL_3DL_stereo_control + if (_glewStrSame3(&pos, &len, (const GLubyte*)"stereo_control", 14)) + { + ret = WGLEW_3DL_stereo_control; + continue; + } +#endif + } + if (_glewStrSame2(&pos, &len, (const GLubyte*)"ARB_", 4)) + { +#ifdef WGL_ARB_buffer_region + if (_glewStrSame3(&pos, &len, (const GLubyte*)"buffer_region", 13)) + { + ret = WGLEW_ARB_buffer_region; + continue; + } +#endif +#ifdef WGL_ARB_create_context + if (_glewStrSame3(&pos, &len, (const GLubyte*)"create_context", 14)) + { + ret = WGLEW_ARB_create_context; + continue; + } +#endif +#ifdef WGL_ARB_extensions_string + if (_glewStrSame3(&pos, &len, (const GLubyte*)"extensions_string", 17)) + { + ret = WGLEW_ARB_extensions_string; + continue; + } +#endif +#ifdef WGL_ARB_framebuffer_sRGB + if (_glewStrSame3(&pos, &len, (const GLubyte*)"framebuffer_sRGB", 16)) + { + ret = WGLEW_ARB_framebuffer_sRGB; + continue; + } +#endif +#ifdef WGL_ARB_make_current_read + if (_glewStrSame3(&pos, &len, (const GLubyte*)"make_current_read", 17)) + { + ret = WGLEW_ARB_make_current_read; + continue; + } +#endif +#ifdef WGL_ARB_multisample + if (_glewStrSame3(&pos, &len, (const GLubyte*)"multisample", 11)) + { + ret = WGLEW_ARB_multisample; + continue; + } +#endif +#ifdef WGL_ARB_pbuffer + if (_glewStrSame3(&pos, &len, (const GLubyte*)"pbuffer", 7)) + { + ret = WGLEW_ARB_pbuffer; + continue; + } +#endif +#ifdef WGL_ARB_pixel_format + if (_glewStrSame3(&pos, &len, (const GLubyte*)"pixel_format", 12)) + { + ret = WGLEW_ARB_pixel_format; + continue; + } +#endif +#ifdef WGL_ARB_pixel_format_float + if (_glewStrSame3(&pos, &len, (const GLubyte*)"pixel_format_float", 18)) + { + ret = WGLEW_ARB_pixel_format_float; + continue; + } +#endif +#ifdef WGL_ARB_render_texture + if (_glewStrSame3(&pos, &len, (const GLubyte*)"render_texture", 14)) + { + ret = WGLEW_ARB_render_texture; + continue; + } +#endif + } + if (_glewStrSame2(&pos, &len, (const GLubyte*)"ATI_", 4)) + { +#ifdef WGL_ATI_pixel_format_float + if (_glewStrSame3(&pos, &len, (const GLubyte*)"pixel_format_float", 18)) + { + ret = WGLEW_ATI_pixel_format_float; + continue; + } +#endif +#ifdef WGL_ATI_render_texture_rectangle + if (_glewStrSame3(&pos, &len, (const GLubyte*)"render_texture_rectangle", 24)) + { + ret = WGLEW_ATI_render_texture_rectangle; + continue; + } +#endif + } + if (_glewStrSame2(&pos, &len, (const GLubyte*)"EXT_", 4)) + { +#ifdef WGL_EXT_depth_float + if (_glewStrSame3(&pos, &len, (const GLubyte*)"depth_float", 11)) + { + ret = WGLEW_EXT_depth_float; + continue; + } +#endif +#ifdef WGL_EXT_display_color_table + if (_glewStrSame3(&pos, &len, (const GLubyte*)"display_color_table", 19)) + { + ret = WGLEW_EXT_display_color_table; + continue; + } +#endif +#ifdef WGL_EXT_extensions_string + if (_glewStrSame3(&pos, &len, (const GLubyte*)"extensions_string", 17)) + { + ret = WGLEW_EXT_extensions_string; + continue; + } +#endif +#ifdef WGL_EXT_framebuffer_sRGB + if (_glewStrSame3(&pos, &len, (const GLubyte*)"framebuffer_sRGB", 16)) + { + ret = WGLEW_EXT_framebuffer_sRGB; + continue; + } +#endif +#ifdef WGL_EXT_make_current_read + if (_glewStrSame3(&pos, &len, (const GLubyte*)"make_current_read", 17)) + { + ret = WGLEW_EXT_make_current_read; + continue; + } +#endif +#ifdef WGL_EXT_multisample + if (_glewStrSame3(&pos, &len, (const GLubyte*)"multisample", 11)) + { + ret = WGLEW_EXT_multisample; + continue; + } +#endif +#ifdef WGL_EXT_pbuffer + if (_glewStrSame3(&pos, &len, (const GLubyte*)"pbuffer", 7)) + { + ret = WGLEW_EXT_pbuffer; + continue; + } +#endif +#ifdef WGL_EXT_pixel_format + if (_glewStrSame3(&pos, &len, (const GLubyte*)"pixel_format", 12)) + { + ret = WGLEW_EXT_pixel_format; + continue; + } +#endif +#ifdef WGL_EXT_pixel_format_packed_float + if (_glewStrSame3(&pos, &len, (const GLubyte*)"pixel_format_packed_float", 25)) + { + ret = WGLEW_EXT_pixel_format_packed_float; + continue; + } +#endif +#ifdef WGL_EXT_swap_control + if (_glewStrSame3(&pos, &len, (const GLubyte*)"swap_control", 12)) + { + ret = WGLEW_EXT_swap_control; + continue; + } +#endif + } + if (_glewStrSame2(&pos, &len, (const GLubyte*)"I3D_", 4)) + { +#ifdef WGL_I3D_digital_video_control + if (_glewStrSame3(&pos, &len, (const GLubyte*)"digital_video_control", 21)) + { + ret = WGLEW_I3D_digital_video_control; + continue; + } +#endif +#ifdef WGL_I3D_gamma + if (_glewStrSame3(&pos, &len, (const GLubyte*)"gamma", 5)) + { + ret = WGLEW_I3D_gamma; + continue; + } +#endif +#ifdef WGL_I3D_genlock + if (_glewStrSame3(&pos, &len, (const GLubyte*)"genlock", 7)) + { + ret = WGLEW_I3D_genlock; + continue; + } +#endif +#ifdef WGL_I3D_image_buffer + if (_glewStrSame3(&pos, &len, (const GLubyte*)"image_buffer", 12)) + { + ret = WGLEW_I3D_image_buffer; + continue; + } +#endif +#ifdef WGL_I3D_swap_frame_lock + if (_glewStrSame3(&pos, &len, (const GLubyte*)"swap_frame_lock", 15)) + { + ret = WGLEW_I3D_swap_frame_lock; + continue; + } +#endif +#ifdef WGL_I3D_swap_frame_usage + if (_glewStrSame3(&pos, &len, (const GLubyte*)"swap_frame_usage", 16)) + { + ret = WGLEW_I3D_swap_frame_usage; + continue; + } +#endif + } + if (_glewStrSame2(&pos, &len, (const GLubyte*)"NV_", 3)) + { +#ifdef WGL_NV_float_buffer + if (_glewStrSame3(&pos, &len, (const GLubyte*)"float_buffer", 12)) + { + ret = WGLEW_NV_float_buffer; + continue; + } +#endif +#ifdef WGL_NV_gpu_affinity + if (_glewStrSame3(&pos, &len, (const GLubyte*)"gpu_affinity", 12)) + { + ret = WGLEW_NV_gpu_affinity; + continue; + } +#endif +#ifdef WGL_NV_present_video + if (_glewStrSame3(&pos, &len, (const GLubyte*)"present_video", 13)) + { + ret = WGLEW_NV_present_video; + continue; + } +#endif +#ifdef WGL_NV_render_depth_texture + if (_glewStrSame3(&pos, &len, (const GLubyte*)"render_depth_texture", 20)) + { + ret = WGLEW_NV_render_depth_texture; + continue; + } +#endif +#ifdef WGL_NV_render_texture_rectangle + if (_glewStrSame3(&pos, &len, (const GLubyte*)"render_texture_rectangle", 24)) + { + ret = WGLEW_NV_render_texture_rectangle; + continue; + } +#endif +#ifdef WGL_NV_swap_group + if (_glewStrSame3(&pos, &len, (const GLubyte*)"swap_group", 10)) + { + ret = WGLEW_NV_swap_group; + continue; + } +#endif +#ifdef WGL_NV_vertex_array_range + if (_glewStrSame3(&pos, &len, (const GLubyte*)"vertex_array_range", 18)) + { + ret = WGLEW_NV_vertex_array_range; + continue; + } +#endif +#ifdef WGL_NV_video_output + if (_glewStrSame3(&pos, &len, (const GLubyte*)"video_output", 12)) + { + ret = WGLEW_NV_video_output; + continue; + } +#endif + } + if (_glewStrSame2(&pos, &len, (const GLubyte*)"OML_", 4)) + { +#ifdef WGL_OML_sync_control + if (_glewStrSame3(&pos, &len, (const GLubyte*)"sync_control", 12)) + { + ret = WGLEW_OML_sync_control; + continue; + } +#endif + } + } + ret = (len == 0); + } + return ret; +} + +#elif !defined(__APPLE__) || defined(GLEW_APPLE_GLX) + +#if defined(GLEW_MX) +GLboolean glxewContextIsSupported (GLXEWContext* ctx, const char* name) +#else +GLboolean glxewIsSupported (const char* name) +#endif +{ + GLubyte* pos = (GLubyte*)name; + GLuint len = _glewStrLen(pos); + GLboolean ret = GL_TRUE; + while (ret && len > 0) + { + if(_glewStrSame1(&pos, &len, (const GLubyte*)"GLX_", 4)) + { + if (_glewStrSame2(&pos, &len, (const GLubyte*)"VERSION_", 8)) + { +#ifdef GLX_VERSION_1_2 + if (_glewStrSame3(&pos, &len, (const GLubyte*)"1_2", 3)) + { + ret = GLXEW_VERSION_1_2; + continue; + } +#endif +#ifdef GLX_VERSION_1_3 + if (_glewStrSame3(&pos, &len, (const GLubyte*)"1_3", 3)) + { + ret = GLXEW_VERSION_1_3; + continue; + } +#endif +#ifdef GLX_VERSION_1_4 + if (_glewStrSame3(&pos, &len, (const GLubyte*)"1_4", 3)) + { + ret = GLXEW_VERSION_1_4; + continue; + } +#endif + } + if (_glewStrSame2(&pos, &len, (const GLubyte*)"3DFX_", 5)) + { +#ifdef GLX_3DFX_multisample + if (_glewStrSame3(&pos, &len, (const GLubyte*)"multisample", 11)) + { + ret = GLXEW_3DFX_multisample; + continue; + } +#endif + } + if (_glewStrSame2(&pos, &len, (const GLubyte*)"ARB_", 4)) + { +#ifdef GLX_ARB_create_context + if (_glewStrSame3(&pos, &len, (const GLubyte*)"create_context", 14)) + { + ret = GLXEW_ARB_create_context; + continue; + } +#endif +#ifdef GLX_ARB_fbconfig_float + if (_glewStrSame3(&pos, &len, (const GLubyte*)"fbconfig_float", 14)) + { + ret = GLXEW_ARB_fbconfig_float; + continue; + } +#endif +#ifdef GLX_ARB_framebuffer_sRGB + if (_glewStrSame3(&pos, &len, (const GLubyte*)"framebuffer_sRGB", 16)) + { + ret = GLXEW_ARB_framebuffer_sRGB; + continue; + } +#endif +#ifdef GLX_ARB_get_proc_address + if (_glewStrSame3(&pos, &len, (const GLubyte*)"get_proc_address", 16)) + { + ret = GLXEW_ARB_get_proc_address; + continue; + } +#endif +#ifdef GLX_ARB_multisample + if (_glewStrSame3(&pos, &len, (const GLubyte*)"multisample", 11)) + { + ret = GLXEW_ARB_multisample; + continue; + } +#endif + } + if (_glewStrSame2(&pos, &len, (const GLubyte*)"ATI_", 4)) + { +#ifdef GLX_ATI_pixel_format_float + if (_glewStrSame3(&pos, &len, (const GLubyte*)"pixel_format_float", 18)) + { + ret = GLXEW_ATI_pixel_format_float; + continue; + } +#endif +#ifdef GLX_ATI_render_texture + if (_glewStrSame3(&pos, &len, (const GLubyte*)"render_texture", 14)) + { + ret = GLXEW_ATI_render_texture; + continue; + } +#endif + } + if (_glewStrSame2(&pos, &len, (const GLubyte*)"EXT_", 4)) + { +#ifdef GLX_EXT_fbconfig_packed_float + if (_glewStrSame3(&pos, &len, (const GLubyte*)"fbconfig_packed_float", 21)) + { + ret = GLXEW_EXT_fbconfig_packed_float; + continue; + } +#endif +#ifdef GLX_EXT_framebuffer_sRGB + if (_glewStrSame3(&pos, &len, (const GLubyte*)"framebuffer_sRGB", 16)) + { + ret = GLXEW_EXT_framebuffer_sRGB; + continue; + } +#endif +#ifdef GLX_EXT_import_context + if (_glewStrSame3(&pos, &len, (const GLubyte*)"import_context", 14)) + { + ret = GLXEW_EXT_import_context; + continue; + } +#endif +#ifdef GLX_EXT_scene_marker + if (_glewStrSame3(&pos, &len, (const GLubyte*)"scene_marker", 12)) + { + ret = GLXEW_EXT_scene_marker; + continue; + } +#endif +#ifdef GLX_EXT_texture_from_pixmap + if (_glewStrSame3(&pos, &len, (const GLubyte*)"texture_from_pixmap", 19)) + { + ret = GLXEW_EXT_texture_from_pixmap; + continue; + } +#endif +#ifdef GLX_EXT_visual_info + if (_glewStrSame3(&pos, &len, (const GLubyte*)"visual_info", 11)) + { + ret = GLXEW_EXT_visual_info; + continue; + } +#endif +#ifdef GLX_EXT_visual_rating + if (_glewStrSame3(&pos, &len, (const GLubyte*)"visual_rating", 13)) + { + ret = GLXEW_EXT_visual_rating; + continue; + } +#endif + } + if (_glewStrSame2(&pos, &len, (const GLubyte*)"MESA_", 5)) + { +#ifdef GLX_MESA_agp_offset + if (_glewStrSame3(&pos, &len, (const GLubyte*)"agp_offset", 10)) + { + ret = GLXEW_MESA_agp_offset; + continue; + } +#endif +#ifdef GLX_MESA_copy_sub_buffer + if (_glewStrSame3(&pos, &len, (const GLubyte*)"copy_sub_buffer", 15)) + { + ret = GLXEW_MESA_copy_sub_buffer; + continue; + } +#endif +#ifdef GLX_MESA_pixmap_colormap + if (_glewStrSame3(&pos, &len, (const GLubyte*)"pixmap_colormap", 15)) + { + ret = GLXEW_MESA_pixmap_colormap; + continue; + } +#endif +#ifdef GLX_MESA_release_buffers + if (_glewStrSame3(&pos, &len, (const GLubyte*)"release_buffers", 15)) + { + ret = GLXEW_MESA_release_buffers; + continue; + } +#endif +#ifdef GLX_MESA_set_3dfx_mode + if (_glewStrSame3(&pos, &len, (const GLubyte*)"set_3dfx_mode", 13)) + { + ret = GLXEW_MESA_set_3dfx_mode; + continue; + } +#endif + } + if (_glewStrSame2(&pos, &len, (const GLubyte*)"NV_", 3)) + { +#ifdef GLX_NV_float_buffer + if (_glewStrSame3(&pos, &len, (const GLubyte*)"float_buffer", 12)) + { + ret = GLXEW_NV_float_buffer; + continue; + } +#endif +#ifdef GLX_NV_present_video + if (_glewStrSame3(&pos, &len, (const GLubyte*)"present_video", 13)) + { + ret = GLXEW_NV_present_video; + continue; + } +#endif +#ifdef GLX_NV_swap_group + if (_glewStrSame3(&pos, &len, (const GLubyte*)"swap_group", 10)) + { + ret = GLXEW_NV_swap_group; + continue; + } +#endif +#ifdef GLX_NV_vertex_array_range + if (_glewStrSame3(&pos, &len, (const GLubyte*)"vertex_array_range", 18)) + { + ret = GLXEW_NV_vertex_array_range; + continue; + } +#endif +#ifdef GLX_NV_video_output + if (_glewStrSame3(&pos, &len, (const GLubyte*)"video_output", 12)) + { + ret = GLXEW_NV_video_output; + continue; + } +#endif + } + if (_glewStrSame2(&pos, &len, (const GLubyte*)"OML_", 4)) + { +#ifdef GLX_OML_swap_method + if (_glewStrSame3(&pos, &len, (const GLubyte*)"swap_method", 11)) + { + ret = GLXEW_OML_swap_method; + continue; + } +#endif +#if defined(GLX_OML_sync_control) && defined(__STDC_VERSION__) && (__STDC_VERSION__ >= 199901L) +#include + if (_glewStrSame3(&pos, &len, (const GLubyte*)"sync_control", 12)) + { + ret = GLXEW_OML_sync_control; + continue; + } +#endif + } + if (_glewStrSame2(&pos, &len, (const GLubyte*)"SGIS_", 5)) + { +#ifdef GLX_SGIS_blended_overlay + if (_glewStrSame3(&pos, &len, (const GLubyte*)"blended_overlay", 15)) + { + ret = GLXEW_SGIS_blended_overlay; + continue; + } +#endif +#ifdef GLX_SGIS_color_range + if (_glewStrSame3(&pos, &len, (const GLubyte*)"color_range", 11)) + { + ret = GLXEW_SGIS_color_range; + continue; + } +#endif +#ifdef GLX_SGIS_multisample + if (_glewStrSame3(&pos, &len, (const GLubyte*)"multisample", 11)) + { + ret = GLXEW_SGIS_multisample; + continue; + } +#endif +#ifdef GLX_SGIS_shared_multisample + if (_glewStrSame3(&pos, &len, (const GLubyte*)"shared_multisample", 18)) + { + ret = GLXEW_SGIS_shared_multisample; + continue; + } +#endif + } + if (_glewStrSame2(&pos, &len, (const GLubyte*)"SGIX_", 5)) + { +#ifdef GLX_SGIX_fbconfig + if (_glewStrSame3(&pos, &len, (const GLubyte*)"fbconfig", 8)) + { + ret = GLXEW_SGIX_fbconfig; + continue; + } +#endif +#ifdef GLX_SGIX_hyperpipe + if (_glewStrSame3(&pos, &len, (const GLubyte*)"hyperpipe", 9)) + { + ret = GLXEW_SGIX_hyperpipe; + continue; + } +#endif +#ifdef GLX_SGIX_pbuffer + if (_glewStrSame3(&pos, &len, (const GLubyte*)"pbuffer", 7)) + { + ret = GLXEW_SGIX_pbuffer; + continue; + } +#endif +#ifdef GLX_SGIX_swap_barrier + if (_glewStrSame3(&pos, &len, (const GLubyte*)"swap_barrier", 12)) + { + ret = GLXEW_SGIX_swap_barrier; + continue; + } +#endif +#ifdef GLX_SGIX_swap_group + if (_glewStrSame3(&pos, &len, (const GLubyte*)"swap_group", 10)) + { + ret = GLXEW_SGIX_swap_group; + continue; + } +#endif +#ifdef GLX_SGIX_video_resize + if (_glewStrSame3(&pos, &len, (const GLubyte*)"video_resize", 12)) + { + ret = GLXEW_SGIX_video_resize; + continue; + } +#endif +#ifdef GLX_SGIX_visual_select_group + if (_glewStrSame3(&pos, &len, (const GLubyte*)"visual_select_group", 19)) + { + ret = GLXEW_SGIX_visual_select_group; + continue; + } +#endif + } + if (_glewStrSame2(&pos, &len, (const GLubyte*)"SGI_", 4)) + { +#ifdef GLX_SGI_cushion + if (_glewStrSame3(&pos, &len, (const GLubyte*)"cushion", 7)) + { + ret = GLXEW_SGI_cushion; + continue; + } +#endif +#ifdef GLX_SGI_make_current_read + if (_glewStrSame3(&pos, &len, (const GLubyte*)"make_current_read", 17)) + { + ret = GLXEW_SGI_make_current_read; + continue; + } +#endif +#ifdef GLX_SGI_swap_control + if (_glewStrSame3(&pos, &len, (const GLubyte*)"swap_control", 12)) + { + ret = GLXEW_SGI_swap_control; + continue; + } +#endif +#ifdef GLX_SGI_video_sync + if (_glewStrSame3(&pos, &len, (const GLubyte*)"video_sync", 10)) + { + ret = GLXEW_SGI_video_sync; + continue; + } +#endif + } + if (_glewStrSame2(&pos, &len, (const GLubyte*)"SUN_", 4)) + { +#ifdef GLX_SUN_get_transparent_index + if (_glewStrSame3(&pos, &len, (const GLubyte*)"get_transparent_index", 21)) + { + ret = GLXEW_SUN_get_transparent_index; + continue; + } +#endif +#ifdef GLX_SUN_video_resize + if (_glewStrSame3(&pos, &len, (const GLubyte*)"video_resize", 12)) + { + ret = GLXEW_SUN_video_resize; + continue; + } +#endif + } + } + ret = (len == 0); + } + return ret; +} + +#endif /* _WIN32 */ diff --git a/opengl/glew.h b/opengl/glew.h new file mode 100644 index 00000000..262425c1 --- /dev/null +++ b/opengl/glew.h @@ -0,0 +1,12266 @@ +/* +** The OpenGL Extension Wrangler Library +** Copyright (C) 2002-2008, Milan Ikits +** Copyright (C) 2002-2008, Marcelo E. Magallon +** Copyright (C) 2002, Lev Povalahev +** All rights reserved. +** +** Redistribution and use in source and binary forms, with or without +** modification, are permitted provided that the following conditions are met: +** +** * Redistributions of source code must retain the above copyright notice, +** this list of conditions and the following disclaimer. +** * Redistributions in binary form must reproduce the above copyright notice, +** this list of conditions and the following disclaimer in the documentation +** and/or other materials provided with the distribution. +** * The name of the author may be used to endorse or promote products +** derived from this software without specific prior written permission. +** +** THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" +** AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE +** IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE +** ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE +** LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR +** CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF +** SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS +** INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN +** CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) +** ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF +** THE POSSIBILITY OF SUCH DAMAGE. +*/ + +/* + * Mesa 3-D graphics library + * Version: 7.0 + * + * Copyright (C) 1999-2007 Brian Paul All Rights Reserved. + * + * Permission is hereby granted, free of charge, to any person obtaining a + * copy of this software and associated documentation files (the "Software"), + * to deal in the Software without restriction, including without limitation + * the rights to use, copy, modify, merge, publish, distribute, sublicense, + * and/or sell copies of the Software, and to permit persons to whom the + * Software is furnished to do so, subject to the following conditions: + * + * The above copyright notice and this permission notice shall be included + * in all copies or substantial portions of the Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS + * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, + * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL + * BRIAN PAUL BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN + * AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN + * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. + */ + +/* +** Copyright (c) 2007 The Khronos Group Inc. +** +** Permission is hereby granted, free of charge, to any person obtaining a +** copy of this software and/or associated documentation files (the +** "Materials"), to deal in the Materials without restriction, including +** without limitation the rights to use, copy, modify, merge, publish, +** distribute, sublicense, and/or sell copies of the Materials, and to +** permit persons to whom the Materials are furnished to do so, subject to +** the following conditions: +** +** The above copyright notice and this permission notice shall be included +** in all copies or substantial portions of the Materials. +** +** THE MATERIALS ARE PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, +** EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF +** MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. +** IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY +** CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, +** TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE +** MATERIALS OR THE USE OR OTHER DEALINGS IN THE MATERIALS. +*/ + +#ifndef __glew_h__ +#define __glew_h__ +#define __GLEW_H__ + +#if defined(__gl_h_) || defined(__GL_H__) +#error gl.h included before glew.h +#endif +#if defined(__glext_h_) || defined(__GLEXT_H_) +#error glext.h included before glew.h +#endif +#if defined(__gl_ATI_h_) +#error glATI.h included before glew.h +#endif + +#define __gl_h_ +#define __GL_H__ +#define __glext_h_ +#define __GLEXT_H_ +#define __gl_ATI_h_ + +#if defined(_WIN32) + +/* + * GLEW does not include to avoid name space pollution. + * GL needs GLAPI and GLAPIENTRY, GLU needs APIENTRY, CALLBACK, and wchar_t + * defined properly. + */ +/* */ +#ifndef APIENTRY +#define GLEW_APIENTRY_DEFINED +# if defined(__MINGW32__) +# define APIENTRY __stdcall +# elif (_MSC_VER >= 800) || defined(_STDCALL_SUPPORTED) || defined(__BORLANDC__) +# define APIENTRY __stdcall +# else +# define APIENTRY +# endif +#endif +#ifndef GLAPI +# if defined(__MINGW32__) +# define GLAPI extern +# endif +#endif +/* */ +#ifndef CALLBACK +#define GLEW_CALLBACK_DEFINED +# if defined(__MINGW32__) +# define CALLBACK __attribute__ ((__stdcall__)) +# elif (defined(_M_MRX000) || defined(_M_IX86) || defined(_M_ALPHA) || defined(_M_PPC)) && !defined(MIDL_PASS) +# define CALLBACK __stdcall +# else +# define CALLBACK +# endif +#endif +/* and */ +#ifndef WINGDIAPI +#define GLEW_WINGDIAPI_DEFINED +#define WINGDIAPI __declspec(dllimport) +#endif +/* */ +#if (defined(_MSC_VER) || defined(__BORLANDC__)) && !defined(_WCHAR_T_DEFINED) +typedef unsigned short wchar_t; +# define _WCHAR_T_DEFINED +#endif +/* */ +#if !defined(_W64) +# if !defined(__midl) && (defined(_X86_) || defined(_M_IX86)) && defined(_MSC_VER) && _MSC_VER >= 1300 +# define _W64 __w64 +# else +# define _W64 +# endif +#endif +#if !defined(_PTRDIFF_T_DEFINED) && !defined(_PTRDIFF_T_) +# ifdef _WIN64 +typedef __int64 ptrdiff_t; +# else +//typedef _W64 int ptrdiff_t; +# endif +# define _PTRDIFF_T_DEFINED +# define _PTRDIFF_T_ +#endif + +#ifndef GLAPI +# if defined(__MINGW32__) +# define GLAPI extern +# else +# define GLAPI WINGDIAPI +# endif +#endif + +#ifndef GLAPIENTRY +#define GLAPIENTRY APIENTRY +#endif + +/* + * GLEW_STATIC needs to be set when using the static version. + * GLEW_BUILD is set when building the DLL version. + */ +#ifdef GLEW_STATIC +# define GLEWAPI extern +#else +# ifdef GLEW_BUILD +# define GLEWAPI extern __declspec(dllexport) +# else +# define GLEWAPI extern __declspec(dllimport) +# endif +#endif + +#else /* _UNIX */ + +/* + * Needed for ptrdiff_t in turn needed by VBO. This is defined by ISO + * C. On my system, this amounts to _3 lines_ of included code, all of + * them pretty much harmless. If you know of a way of detecting 32 vs + * 64 _targets_ at compile time you are free to replace this with + * something that's portable. For now, _this_ is the portable solution. + * (mem, 2004-01-04) + */ + +#include +#include + +#define GLEW_APIENTRY_DEFINED +#define APIENTRY +#define GLEWAPI extern + +/* */ +#ifndef GLAPI +#define GLAPI extern +#endif +#ifndef GLAPIENTRY +#define GLAPIENTRY +#endif + +#endif /* _WIN32 */ + +#ifdef __cplusplus +extern "C" { +#endif + +/* ----------------------------- GL_VERSION_1_1 ---------------------------- */ + +#ifndef GL_VERSION_1_1 +#define GL_VERSION_1_1 1 + +typedef unsigned int GLenum; +typedef unsigned int GLbitfield; +typedef unsigned int GLuint; +typedef int GLint; +typedef int GLsizei; +typedef unsigned char GLboolean; +typedef signed char GLbyte; +typedef short GLshort; +typedef unsigned char GLubyte; +typedef unsigned short GLushort; +typedef unsigned long GLulong; +typedef float GLfloat; +typedef float GLclampf; +typedef double GLdouble; +typedef double GLclampd; +typedef void GLvoid; +#if defined(_MSC_VER) +# if _MSC_VER < 1400 +typedef __int64 GLint64EXT; +typedef unsigned __int64 GLuint64EXT; +# else +typedef signed long long GLint64EXT; +typedef unsigned long long GLuint64EXT; +# endif +#else +# if defined(__MINGW32__) +#include +# endif +//typedef int64_t GLint64EXT; +//typedef uint64_t GLuint64EXT; +#endif + +#define GL_ACCUM 0x0100 +#define GL_LOAD 0x0101 +#define GL_RETURN 0x0102 +#define GL_MULT 0x0103 +#define GL_ADD 0x0104 +#define GL_NEVER 0x0200 +#define GL_LESS 0x0201 +#define GL_EQUAL 0x0202 +#define GL_LEQUAL 0x0203 +#define GL_GREATER 0x0204 +#define GL_NOTEQUAL 0x0205 +#define GL_GEQUAL 0x0206 +#define GL_ALWAYS 0x0207 +#define GL_CURRENT_BIT 0x00000001 +#define GL_POINT_BIT 0x00000002 +#define GL_LINE_BIT 0x00000004 +#define GL_POLYGON_BIT 0x00000008 +#define GL_POLYGON_STIPPLE_BIT 0x00000010 +#define GL_PIXEL_MODE_BIT 0x00000020 +#define GL_LIGHTING_BIT 0x00000040 +#define GL_FOG_BIT 0x00000080 +#define GL_DEPTH_BUFFER_BIT 0x00000100 +#define GL_ACCUM_BUFFER_BIT 0x00000200 +#define GL_STENCIL_BUFFER_BIT 0x00000400 +#define GL_VIEWPORT_BIT 0x00000800 +#define GL_TRANSFORM_BIT 0x00001000 +#define GL_ENABLE_BIT 0x00002000 +#define GL_COLOR_BUFFER_BIT 0x00004000 +#define GL_HINT_BIT 0x00008000 +#define GL_EVAL_BIT 0x00010000 +#define GL_LIST_BIT 0x00020000 +#define GL_TEXTURE_BIT 0x00040000 +#define GL_SCISSOR_BIT 0x00080000 +#define GL_ALL_ATTRIB_BITS 0x000fffff +#define GL_POINTS 0x0000 +#define GL_LINES 0x0001 +#define GL_LINE_LOOP 0x0002 +#define GL_LINE_STRIP 0x0003 +#define GL_TRIANGLES 0x0004 +#define GL_TRIANGLE_STRIP 0x0005 +#define GL_TRIANGLE_FAN 0x0006 +#define GL_QUADS 0x0007 +#define GL_QUAD_STRIP 0x0008 +#define GL_POLYGON 0x0009 +#define GL_ZERO 0 +#define GL_ONE 1 +#define GL_SRC_COLOR 0x0300 +#define GL_ONE_MINUS_SRC_COLOR 0x0301 +#define GL_SRC_ALPHA 0x0302 +#define GL_ONE_MINUS_SRC_ALPHA 0x0303 +#define GL_DST_ALPHA 0x0304 +#define GL_ONE_MINUS_DST_ALPHA 0x0305 +#define GL_DST_COLOR 0x0306 +#define GL_ONE_MINUS_DST_COLOR 0x0307 +#define GL_SRC_ALPHA_SATURATE 0x0308 +#define GL_TRUE 1 +#define GL_FALSE 0 +#define GL_CLIP_PLANE0 0x3000 +#define GL_CLIP_PLANE1 0x3001 +#define GL_CLIP_PLANE2 0x3002 +#define GL_CLIP_PLANE3 0x3003 +#define GL_CLIP_PLANE4 0x3004 +#define GL_CLIP_PLANE5 0x3005 +#define GL_BYTE 0x1400 +#define GL_UNSIGNED_BYTE 0x1401 +#define GL_SHORT 0x1402 +#define GL_UNSIGNED_SHORT 0x1403 +#define GL_INT 0x1404 +#define GL_UNSIGNED_INT 0x1405 +#define GL_FLOAT 0x1406 +#define GL_2_BYTES 0x1407 +#define GL_3_BYTES 0x1408 +#define GL_4_BYTES 0x1409 +#define GL_DOUBLE 0x140A +#define GL_NONE 0 +#define GL_FRONT_LEFT 0x0400 +#define GL_FRONT_RIGHT 0x0401 +#define GL_BACK_LEFT 0x0402 +#define GL_BACK_RIGHT 0x0403 +#define GL_FRONT 0x0404 +#define GL_BACK 0x0405 +#define GL_LEFT 0x0406 +#define GL_RIGHT 0x0407 +#define GL_FRONT_AND_BACK 0x0408 +#define GL_AUX0 0x0409 +#define GL_AUX1 0x040A +#define GL_AUX2 0x040B +#define GL_AUX3 0x040C +#define GL_NO_ERROR 0 +#define GL_INVALID_ENUM 0x0500 +#define GL_INVALID_VALUE 0x0501 +#define GL_INVALID_OPERATION 0x0502 +#define GL_STACK_OVERFLOW 0x0503 +#define GL_STACK_UNDERFLOW 0x0504 +#define GL_OUT_OF_MEMORY 0x0505 +#define GL_2D 0x0600 +#define GL_3D 0x0601 +#define GL_3D_COLOR 0x0602 +#define GL_3D_COLOR_TEXTURE 0x0603 +#define GL_4D_COLOR_TEXTURE 0x0604 +#define GL_PASS_THROUGH_TOKEN 0x0700 +#define GL_POINT_TOKEN 0x0701 +#define GL_LINE_TOKEN 0x0702 +#define GL_POLYGON_TOKEN 0x0703 +#define GL_BITMAP_TOKEN 0x0704 +#define GL_DRAW_PIXEL_TOKEN 0x0705 +#define GL_COPY_PIXEL_TOKEN 0x0706 +#define GL_LINE_RESET_TOKEN 0x0707 +#define GL_EXP 0x0800 +#define GL_EXP2 0x0801 +#define GL_CW 0x0900 +#define GL_CCW 0x0901 +#define GL_COEFF 0x0A00 +#define GL_ORDER 0x0A01 +#define GL_DOMAIN 0x0A02 +#define GL_CURRENT_COLOR 0x0B00 +#define GL_CURRENT_INDEX 0x0B01 +#define GL_CURRENT_NORMAL 0x0B02 +#define GL_CURRENT_TEXTURE_COORDS 0x0B03 +#define GL_CURRENT_RASTER_COLOR 0x0B04 +#define GL_CURRENT_RASTER_INDEX 0x0B05 +#define GL_CURRENT_RASTER_TEXTURE_COORDS 0x0B06 +#define GL_CURRENT_RASTER_POSITION 0x0B07 +#define GL_CURRENT_RASTER_POSITION_VALID 0x0B08 +#define GL_CURRENT_RASTER_DISTANCE 0x0B09 +#define GL_POINT_SMOOTH 0x0B10 +#define GL_POINT_SIZE 0x0B11 +#define GL_POINT_SIZE_RANGE 0x0B12 +#define GL_POINT_SIZE_GRANULARITY 0x0B13 +#define GL_LINE_SMOOTH 0x0B20 +#define GL_LINE_WIDTH 0x0B21 +#define GL_LINE_WIDTH_RANGE 0x0B22 +#define GL_LINE_WIDTH_GRANULARITY 0x0B23 +#define GL_LINE_STIPPLE 0x0B24 +#define GL_LINE_STIPPLE_PATTERN 0x0B25 +#define GL_LINE_STIPPLE_REPEAT 0x0B26 +#define GL_LIST_MODE 0x0B30 +#define GL_MAX_LIST_NESTING 0x0B31 +#define GL_LIST_BASE 0x0B32 +#define GL_LIST_INDEX 0x0B33 +#define GL_POLYGON_MODE 0x0B40 +#define GL_POLYGON_SMOOTH 0x0B41 +#define GL_POLYGON_STIPPLE 0x0B42 +#define GL_EDGE_FLAG 0x0B43 +#define GL_CULL_FACE 0x0B44 +#define GL_CULL_FACE_MODE 0x0B45 +#define GL_FRONT_FACE 0x0B46 +#define GL_LIGHTING 0x0B50 +#define GL_LIGHT_MODEL_LOCAL_VIEWER 0x0B51 +#define GL_LIGHT_MODEL_TWO_SIDE 0x0B52 +#define GL_LIGHT_MODEL_AMBIENT 0x0B53 +#define GL_SHADE_MODEL 0x0B54 +#define GL_COLOR_MATERIAL_FACE 0x0B55 +#define GL_COLOR_MATERIAL_PARAMETER 0x0B56 +#define GL_COLOR_MATERIAL 0x0B57 +#define GL_FOG 0x0B60 +#define GL_FOG_INDEX 0x0B61 +#define GL_FOG_DENSITY 0x0B62 +#define GL_FOG_START 0x0B63 +#define GL_FOG_END 0x0B64 +#define GL_FOG_MODE 0x0B65 +#define GL_FOG_COLOR 0x0B66 +#define GL_DEPTH_RANGE 0x0B70 +#define GL_DEPTH_TEST 0x0B71 +#define GL_DEPTH_WRITEMASK 0x0B72 +#define GL_DEPTH_CLEAR_VALUE 0x0B73 +#define GL_DEPTH_FUNC 0x0B74 +#define GL_ACCUM_CLEAR_VALUE 0x0B80 +#define GL_STENCIL_TEST 0x0B90 +#define GL_STENCIL_CLEAR_VALUE 0x0B91 +#define GL_STENCIL_FUNC 0x0B92 +#define GL_STENCIL_VALUE_MASK 0x0B93 +#define GL_STENCIL_FAIL 0x0B94 +#define GL_STENCIL_PASS_DEPTH_FAIL 0x0B95 +#define GL_STENCIL_PASS_DEPTH_PASS 0x0B96 +#define GL_STENCIL_REF 0x0B97 +#define GL_STENCIL_WRITEMASK 0x0B98 +#define GL_MATRIX_MODE 0x0BA0 +#define GL_NORMALIZE 0x0BA1 +#define GL_VIEWPORT 0x0BA2 +#define GL_MODELVIEW_STACK_DEPTH 0x0BA3 +#define GL_PROJECTION_STACK_DEPTH 0x0BA4 +#define GL_TEXTURE_STACK_DEPTH 0x0BA5 +#define GL_MODELVIEW_MATRIX 0x0BA6 +#define GL_PROJECTION_MATRIX 0x0BA7 +#define GL_TEXTURE_MATRIX 0x0BA8 +#define GL_ATTRIB_STACK_DEPTH 0x0BB0 +#define GL_CLIENT_ATTRIB_STACK_DEPTH 0x0BB1 +#define GL_ALPHA_TEST 0x0BC0 +#define GL_ALPHA_TEST_FUNC 0x0BC1 +#define GL_ALPHA_TEST_REF 0x0BC2 +#define GL_DITHER 0x0BD0 +#define GL_BLEND_DST 0x0BE0 +#define GL_BLEND_SRC 0x0BE1 +#define GL_BLEND 0x0BE2 +#define GL_LOGIC_OP_MODE 0x0BF0 +#define GL_INDEX_LOGIC_OP 0x0BF1 +#define GL_COLOR_LOGIC_OP 0x0BF2 +#define GL_AUX_BUFFERS 0x0C00 +#define GL_DRAW_BUFFER 0x0C01 +#define GL_READ_BUFFER 0x0C02 +#define GL_SCISSOR_BOX 0x0C10 +#define GL_SCISSOR_TEST 0x0C11 +#define GL_INDEX_CLEAR_VALUE 0x0C20 +#define GL_INDEX_WRITEMASK 0x0C21 +#define GL_COLOR_CLEAR_VALUE 0x0C22 +#define GL_COLOR_WRITEMASK 0x0C23 +#define GL_INDEX_MODE 0x0C30 +#define GL_RGBA_MODE 0x0C31 +#define GL_DOUBLEBUFFER 0x0C32 +#define GL_STEREO 0x0C33 +#define GL_RENDER_MODE 0x0C40 +#define GL_PERSPECTIVE_CORRECTION_HINT 0x0C50 +#define GL_POINT_SMOOTH_HINT 0x0C51 +#define GL_LINE_SMOOTH_HINT 0x0C52 +#define GL_POLYGON_SMOOTH_HINT 0x0C53 +#define GL_FOG_HINT 0x0C54 +#define GL_TEXTURE_GEN_S 0x0C60 +#define GL_TEXTURE_GEN_T 0x0C61 +#define GL_TEXTURE_GEN_R 0x0C62 +#define GL_TEXTURE_GEN_Q 0x0C63 +#define GL_PIXEL_MAP_I_TO_I 0x0C70 +#define GL_PIXEL_MAP_S_TO_S 0x0C71 +#define GL_PIXEL_MAP_I_TO_R 0x0C72 +#define GL_PIXEL_MAP_I_TO_G 0x0C73 +#define GL_PIXEL_MAP_I_TO_B 0x0C74 +#define GL_PIXEL_MAP_I_TO_A 0x0C75 +#define GL_PIXEL_MAP_R_TO_R 0x0C76 +#define GL_PIXEL_MAP_G_TO_G 0x0C77 +#define GL_PIXEL_MAP_B_TO_B 0x0C78 +#define GL_PIXEL_MAP_A_TO_A 0x0C79 +#define GL_PIXEL_MAP_I_TO_I_SIZE 0x0CB0 +#define GL_PIXEL_MAP_S_TO_S_SIZE 0x0CB1 +#define GL_PIXEL_MAP_I_TO_R_SIZE 0x0CB2 +#define GL_PIXEL_MAP_I_TO_G_SIZE 0x0CB3 +#define GL_PIXEL_MAP_I_TO_B_SIZE 0x0CB4 +#define GL_PIXEL_MAP_I_TO_A_SIZE 0x0CB5 +#define GL_PIXEL_MAP_R_TO_R_SIZE 0x0CB6 +#define GL_PIXEL_MAP_G_TO_G_SIZE 0x0CB7 +#define GL_PIXEL_MAP_B_TO_B_SIZE 0x0CB8 +#define GL_PIXEL_MAP_A_TO_A_SIZE 0x0CB9 +#define GL_UNPACK_SWAP_BYTES 0x0CF0 +#define GL_UNPACK_LSB_FIRST 0x0CF1 +#define GL_UNPACK_ROW_LENGTH 0x0CF2 +#define GL_UNPACK_SKIP_ROWS 0x0CF3 +#define GL_UNPACK_SKIP_PIXELS 0x0CF4 +#define GL_UNPACK_ALIGNMENT 0x0CF5 +#define GL_PACK_SWAP_BYTES 0x0D00 +#define GL_PACK_LSB_FIRST 0x0D01 +#define GL_PACK_ROW_LENGTH 0x0D02 +#define GL_PACK_SKIP_ROWS 0x0D03 +#define GL_PACK_SKIP_PIXELS 0x0D04 +#define GL_PACK_ALIGNMENT 0x0D05 +#define GL_MAP_COLOR 0x0D10 +#define GL_MAP_STENCIL 0x0D11 +#define GL_INDEX_SHIFT 0x0D12 +#define GL_INDEX_OFFSET 0x0D13 +#define GL_RED_SCALE 0x0D14 +#define GL_RED_BIAS 0x0D15 +#define GL_ZOOM_X 0x0D16 +#define GL_ZOOM_Y 0x0D17 +#define GL_GREEN_SCALE 0x0D18 +#define GL_GREEN_BIAS 0x0D19 +#define GL_BLUE_SCALE 0x0D1A +#define GL_BLUE_BIAS 0x0D1B +#define GL_ALPHA_SCALE 0x0D1C +#define GL_ALPHA_BIAS 0x0D1D +#define GL_DEPTH_SCALE 0x0D1E +#define GL_DEPTH_BIAS 0x0D1F +#define GL_MAX_EVAL_ORDER 0x0D30 +#define GL_MAX_LIGHTS 0x0D31 +#define GL_MAX_CLIP_PLANES 0x0D32 +#define GL_MAX_TEXTURE_SIZE 0x0D33 +#define GL_MAX_PIXEL_MAP_TABLE 0x0D34 +#define GL_MAX_ATTRIB_STACK_DEPTH 0x0D35 +#define GL_MAX_MODELVIEW_STACK_DEPTH 0x0D36 +#define GL_MAX_NAME_STACK_DEPTH 0x0D37 +#define GL_MAX_PROJECTION_STACK_DEPTH 0x0D38 +#define GL_MAX_TEXTURE_STACK_DEPTH 0x0D39 +#define GL_MAX_VIEWPORT_DIMS 0x0D3A +#define GL_MAX_CLIENT_ATTRIB_STACK_DEPTH 0x0D3B +#define GL_SUBPIXEL_BITS 0x0D50 +#define GL_INDEX_BITS 0x0D51 +#define GL_RED_BITS 0x0D52 +#define GL_GREEN_BITS 0x0D53 +#define GL_BLUE_BITS 0x0D54 +#define GL_ALPHA_BITS 0x0D55 +#define GL_DEPTH_BITS 0x0D56 +#define GL_STENCIL_BITS 0x0D57 +#define GL_ACCUM_RED_BITS 0x0D58 +#define GL_ACCUM_GREEN_BITS 0x0D59 +#define GL_ACCUM_BLUE_BITS 0x0D5A +#define GL_ACCUM_ALPHA_BITS 0x0D5B +#define GL_NAME_STACK_DEPTH 0x0D70 +#define GL_AUTO_NORMAL 0x0D80 +#define GL_MAP1_COLOR_4 0x0D90 +#define GL_MAP1_INDEX 0x0D91 +#define GL_MAP1_NORMAL 0x0D92 +#define GL_MAP1_TEXTURE_COORD_1 0x0D93 +#define GL_MAP1_TEXTURE_COORD_2 0x0D94 +#define GL_MAP1_TEXTURE_COORD_3 0x0D95 +#define GL_MAP1_TEXTURE_COORD_4 0x0D96 +#define GL_MAP1_VERTEX_3 0x0D97 +#define GL_MAP1_VERTEX_4 0x0D98 +#define GL_MAP2_COLOR_4 0x0DB0 +#define GL_MAP2_INDEX 0x0DB1 +#define GL_MAP2_NORMAL 0x0DB2 +#define GL_MAP2_TEXTURE_COORD_1 0x0DB3 +#define GL_MAP2_TEXTURE_COORD_2 0x0DB4 +#define GL_MAP2_TEXTURE_COORD_3 0x0DB5 +#define GL_MAP2_TEXTURE_COORD_4 0x0DB6 +#define GL_MAP2_VERTEX_3 0x0DB7 +#define GL_MAP2_VERTEX_4 0x0DB8 +#define GL_MAP1_GRID_DOMAIN 0x0DD0 +#define GL_MAP1_GRID_SEGMENTS 0x0DD1 +#define GL_MAP2_GRID_DOMAIN 0x0DD2 +#define GL_MAP2_GRID_SEGMENTS 0x0DD3 +#define GL_TEXTURE_1D 0x0DE0 +#define GL_TEXTURE_2D 0x0DE1 +#define GL_FEEDBACK_BUFFER_POINTER 0x0DF0 +#define GL_FEEDBACK_BUFFER_SIZE 0x0DF1 +#define GL_FEEDBACK_BUFFER_TYPE 0x0DF2 +#define GL_SELECTION_BUFFER_POINTER 0x0DF3 +#define GL_SELECTION_BUFFER_SIZE 0x0DF4 +#define GL_TEXTURE_WIDTH 0x1000 +#define GL_TEXTURE_HEIGHT 0x1001 +#define GL_TEXTURE_INTERNAL_FORMAT 0x1003 +#define GL_TEXTURE_BORDER_COLOR 0x1004 +#define GL_TEXTURE_BORDER 0x1005 +#define GL_DONT_CARE 0x1100 +#define GL_FASTEST 0x1101 +#define GL_NICEST 0x1102 +#define GL_LIGHT0 0x4000 +#define GL_LIGHT1 0x4001 +#define GL_LIGHT2 0x4002 +#define GL_LIGHT3 0x4003 +#define GL_LIGHT4 0x4004 +#define GL_LIGHT5 0x4005 +#define GL_LIGHT6 0x4006 +#define GL_LIGHT7 0x4007 +#define GL_AMBIENT 0x1200 +#define GL_DIFFUSE 0x1201 +#define GL_SPECULAR 0x1202 +#define GL_POSITION 0x1203 +#define GL_SPOT_DIRECTION 0x1204 +#define GL_SPOT_EXPONENT 0x1205 +#define GL_SPOT_CUTOFF 0x1206 +#define GL_CONSTANT_ATTENUATION 0x1207 +#define GL_LINEAR_ATTENUATION 0x1208 +#define GL_QUADRATIC_ATTENUATION 0x1209 +#define GL_COMPILE 0x1300 +#define GL_COMPILE_AND_EXECUTE 0x1301 +#define GL_CLEAR 0x1500 +#define GL_AND 0x1501 +#define GL_AND_REVERSE 0x1502 +#define GL_COPY 0x1503 +#define GL_AND_INVERTED 0x1504 +#define GL_NOOP 0x1505 +#define GL_XOR 0x1506 +#define GL_OR 0x1507 +#define GL_NOR 0x1508 +#define GL_EQUIV 0x1509 +#define GL_INVERT 0x150A +#define GL_OR_REVERSE 0x150B +#define GL_COPY_INVERTED 0x150C +#define GL_OR_INVERTED 0x150D +#define GL_NAND 0x150E +#define GL_SET 0x150F +#define GL_EMISSION 0x1600 +#define GL_SHININESS 0x1601 +#define GL_AMBIENT_AND_DIFFUSE 0x1602 +#define GL_COLOR_INDEXES 0x1603 +#define GL_MODELVIEW 0x1700 +#define GL_PROJECTION 0x1701 +#define GL_TEXTURE 0x1702 +#define GL_COLOR 0x1800 +#define GL_DEPTH 0x1801 +#define GL_STENCIL 0x1802 +#define GL_COLOR_INDEX 0x1900 +#define GL_STENCIL_INDEX 0x1901 +#define GL_DEPTH_COMPONENT 0x1902 +#define GL_RED 0x1903 +#define GL_GREEN 0x1904 +#define GL_BLUE 0x1905 +#define GL_ALPHA 0x1906 +#define GL_RGB 0x1907 +#define GL_RGBA 0x1908 +#define GL_LUMINANCE 0x1909 +#define GL_LUMINANCE_ALPHA 0x190A +#define GL_BITMAP 0x1A00 +#define GL_POINT 0x1B00 +#define GL_LINE 0x1B01 +#define GL_FILL 0x1B02 +#define GL_RENDER 0x1C00 +#define GL_FEEDBACK 0x1C01 +#define GL_SELECT 0x1C02 +#define GL_FLAT 0x1D00 +#define GL_SMOOTH 0x1D01 +#define GL_KEEP 0x1E00 +#define GL_REPLACE 0x1E01 +#define GL_INCR 0x1E02 +#define GL_DECR 0x1E03 +#define GL_VENDOR 0x1F00 +#define GL_RENDERER 0x1F01 +#define GL_VERSION 0x1F02 +#define GL_EXTENSIONS 0x1F03 +#define GL_S 0x2000 +#define GL_T 0x2001 +#define GL_R 0x2002 +#define GL_Q 0x2003 +#define GL_MODULATE 0x2100 +#define GL_DECAL 0x2101 +#define GL_TEXTURE_ENV_MODE 0x2200 +#define GL_TEXTURE_ENV_COLOR 0x2201 +#define GL_TEXTURE_ENV 0x2300 +#define GL_EYE_LINEAR 0x2400 +#define GL_OBJECT_LINEAR 0x2401 +#define GL_SPHERE_MAP 0x2402 +#define GL_TEXTURE_GEN_MODE 0x2500 +#define GL_OBJECT_PLANE 0x2501 +#define GL_EYE_PLANE 0x2502 +#define GL_NEAREST 0x2600 +#define GL_LINEAR 0x2601 +#define GL_NEAREST_MIPMAP_NEAREST 0x2700 +#define GL_LINEAR_MIPMAP_NEAREST 0x2701 +#define GL_NEAREST_MIPMAP_LINEAR 0x2702 +#define GL_LINEAR_MIPMAP_LINEAR 0x2703 +#define GL_TEXTURE_MAG_FILTER 0x2800 +#define GL_TEXTURE_MIN_FILTER 0x2801 +#define GL_TEXTURE_WRAP_S 0x2802 +#define GL_TEXTURE_WRAP_T 0x2803 +#define GL_CLAMP 0x2900 +#define GL_REPEAT 0x2901 +#define GL_CLIENT_PIXEL_STORE_BIT 0x00000001 +#define GL_CLIENT_VERTEX_ARRAY_BIT 0x00000002 +#define GL_CLIENT_ALL_ATTRIB_BITS 0xffffffff +#define GL_POLYGON_OFFSET_FACTOR 0x8038 +#define GL_POLYGON_OFFSET_UNITS 0x2A00 +#define GL_POLYGON_OFFSET_POINT 0x2A01 +#define GL_POLYGON_OFFSET_LINE 0x2A02 +#define GL_POLYGON_OFFSET_FILL 0x8037 +#define GL_ALPHA4 0x803B +#define GL_ALPHA8 0x803C +#define GL_ALPHA12 0x803D +#define GL_ALPHA16 0x803E +#define GL_LUMINANCE4 0x803F +#define GL_LUMINANCE8 0x8040 +#define GL_LUMINANCE12 0x8041 +#define GL_LUMINANCE16 0x8042 +#define GL_LUMINANCE4_ALPHA4 0x8043 +#define GL_LUMINANCE6_ALPHA2 0x8044 +#define GL_LUMINANCE8_ALPHA8 0x8045 +#define GL_LUMINANCE12_ALPHA4 0x8046 +#define GL_LUMINANCE12_ALPHA12 0x8047 +#define GL_LUMINANCE16_ALPHA16 0x8048 +#define GL_INTENSITY 0x8049 +#define GL_INTENSITY4 0x804A +#define GL_INTENSITY8 0x804B +#define GL_INTENSITY12 0x804C +#define GL_INTENSITY16 0x804D +#define GL_R3_G3_B2 0x2A10 +#define GL_RGB4 0x804F +#define GL_RGB5 0x8050 +#define GL_RGB8 0x8051 +#define GL_RGB10 0x8052 +#define GL_RGB12 0x8053 +#define GL_RGB16 0x8054 +#define GL_RGBA2 0x8055 +#define GL_RGBA4 0x8056 +#define GL_RGB5_A1 0x8057 +#define GL_RGBA8 0x8058 +#define GL_RGB10_A2 0x8059 +#define GL_RGBA12 0x805A +#define GL_RGBA16 0x805B +#define GL_TEXTURE_RED_SIZE 0x805C +#define GL_TEXTURE_GREEN_SIZE 0x805D +#define GL_TEXTURE_BLUE_SIZE 0x805E +#define GL_TEXTURE_ALPHA_SIZE 0x805F +#define GL_TEXTURE_LUMINANCE_SIZE 0x8060 +#define GL_TEXTURE_INTENSITY_SIZE 0x8061 +#define GL_PROXY_TEXTURE_1D 0x8063 +#define GL_PROXY_TEXTURE_2D 0x8064 +#define GL_TEXTURE_PRIORITY 0x8066 +#define GL_TEXTURE_RESIDENT 0x8067 +#define GL_TEXTURE_BINDING_1D 0x8068 +#define GL_TEXTURE_BINDING_2D 0x8069 +#define GL_VERTEX_ARRAY 0x8074 +#define GL_NORMAL_ARRAY 0x8075 +#define GL_COLOR_ARRAY 0x8076 +#define GL_INDEX_ARRAY 0x8077 +#define GL_TEXTURE_COORD_ARRAY 0x8078 +#define GL_EDGE_FLAG_ARRAY 0x8079 +#define GL_VERTEX_ARRAY_SIZE 0x807A +#define GL_VERTEX_ARRAY_TYPE 0x807B +#define GL_VERTEX_ARRAY_STRIDE 0x807C +#define GL_NORMAL_ARRAY_TYPE 0x807E +#define GL_NORMAL_ARRAY_STRIDE 0x807F +#define GL_COLOR_ARRAY_SIZE 0x8081 +#define GL_COLOR_ARRAY_TYPE 0x8082 +#define GL_COLOR_ARRAY_STRIDE 0x8083 +#define GL_INDEX_ARRAY_TYPE 0x8085 +#define GL_INDEX_ARRAY_STRIDE 0x8086 +#define GL_TEXTURE_COORD_ARRAY_SIZE 0x8088 +#define GL_TEXTURE_COORD_ARRAY_TYPE 0x8089 +#define GL_TEXTURE_COORD_ARRAY_STRIDE 0x808A +#define GL_EDGE_FLAG_ARRAY_STRIDE 0x808C +#define GL_VERTEX_ARRAY_POINTER 0x808E +#define GL_NORMAL_ARRAY_POINTER 0x808F +#define GL_COLOR_ARRAY_POINTER 0x8090 +#define GL_INDEX_ARRAY_POINTER 0x8091 +#define GL_TEXTURE_COORD_ARRAY_POINTER 0x8092 +#define GL_EDGE_FLAG_ARRAY_POINTER 0x8093 +#define GL_V2F 0x2A20 +#define GL_V3F 0x2A21 +#define GL_C4UB_V2F 0x2A22 +#define GL_C4UB_V3F 0x2A23 +#define GL_C3F_V3F 0x2A24 +#define GL_N3F_V3F 0x2A25 +#define GL_C4F_N3F_V3F 0x2A26 +#define GL_T2F_V3F 0x2A27 +#define GL_T4F_V4F 0x2A28 +#define GL_T2F_C4UB_V3F 0x2A29 +#define GL_T2F_C3F_V3F 0x2A2A +#define GL_T2F_N3F_V3F 0x2A2B +#define GL_T2F_C4F_N3F_V3F 0x2A2C +#define GL_T4F_C4F_N3F_V4F 0x2A2D +#define GL_LOGIC_OP GL_INDEX_LOGIC_OP +#define GL_TEXTURE_COMPONENTS GL_TEXTURE_INTERNAL_FORMAT +#define GL_COLOR_INDEX1_EXT 0x80E2 +#define GL_COLOR_INDEX2_EXT 0x80E3 +#define GL_COLOR_INDEX4_EXT 0x80E4 +#define GL_COLOR_INDEX8_EXT 0x80E5 +#define GL_COLOR_INDEX12_EXT 0x80E6 +#define GL_COLOR_INDEX16_EXT 0x80E7 + +GLAPI void GLAPIENTRY glAccum (GLenum op, GLfloat value); +GLAPI void GLAPIENTRY glAlphaFunc (GLenum func, GLclampf ref); +GLAPI GLboolean GLAPIENTRY glAreTexturesResident (GLsizei n, const GLuint *textures, GLboolean *residences); +GLAPI void GLAPIENTRY glArrayElement (GLint i); +GLAPI void GLAPIENTRY glBegin (GLenum mode); +GLAPI void GLAPIENTRY glBindTexture (GLenum target, GLuint texture); +GLAPI void GLAPIENTRY glBitmap (GLsizei width, GLsizei height, GLfloat xorig, GLfloat yorig, GLfloat xmove, GLfloat ymove, const GLubyte *bitmap); +GLAPI void GLAPIENTRY glBlendFunc (GLenum sfactor, GLenum dfactor); +GLAPI void GLAPIENTRY glCallList (GLuint list); +GLAPI void GLAPIENTRY glCallLists (GLsizei n, GLenum type, const GLvoid *lists); +GLAPI void GLAPIENTRY glClear (GLbitfield mask); +GLAPI void GLAPIENTRY glClearAccum (GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha); +GLAPI void GLAPIENTRY glClearColor (GLclampf red, GLclampf green, GLclampf blue, GLclampf alpha); +GLAPI void GLAPIENTRY glClearDepth (GLclampd depth); +GLAPI void GLAPIENTRY glClearIndex (GLfloat c); +GLAPI void GLAPIENTRY glClearStencil (GLint s); +GLAPI void GLAPIENTRY glClipPlane (GLenum plane, const GLdouble *equation); +GLAPI void GLAPIENTRY glColor3b (GLbyte red, GLbyte green, GLbyte blue); +GLAPI void GLAPIENTRY glColor3bv (const GLbyte *v); +GLAPI void GLAPIENTRY glColor3d (GLdouble red, GLdouble green, GLdouble blue); +GLAPI void GLAPIENTRY glColor3dv (const GLdouble *v); +GLAPI void GLAPIENTRY glColor3f (GLfloat red, GLfloat green, GLfloat blue); +GLAPI void GLAPIENTRY glColor3fv (const GLfloat *v); +GLAPI void GLAPIENTRY glColor3i (GLint red, GLint green, GLint blue); +GLAPI void GLAPIENTRY glColor3iv (const GLint *v); +GLAPI void GLAPIENTRY glColor3s (GLshort red, GLshort green, GLshort blue); +GLAPI void GLAPIENTRY glColor3sv (const GLshort *v); +GLAPI void GLAPIENTRY glColor3ub (GLubyte red, GLubyte green, GLubyte blue); +GLAPI void GLAPIENTRY glColor3ubv (const GLubyte *v); +GLAPI void GLAPIENTRY glColor3ui (GLuint red, GLuint green, GLuint blue); +GLAPI void GLAPIENTRY glColor3uiv (const GLuint *v); +GLAPI void GLAPIENTRY glColor3us (GLushort red, GLushort green, GLushort blue); +GLAPI void GLAPIENTRY glColor3usv (const GLushort *v); +GLAPI void GLAPIENTRY glColor4b (GLbyte red, GLbyte green, GLbyte blue, GLbyte alpha); +GLAPI void GLAPIENTRY glColor4bv (const GLbyte *v); +GLAPI void GLAPIENTRY glColor4d (GLdouble red, GLdouble green, GLdouble blue, GLdouble alpha); +GLAPI void GLAPIENTRY glColor4dv (const GLdouble *v); +GLAPI void GLAPIENTRY glColor4f (GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha); +GLAPI void GLAPIENTRY glColor4fv (const GLfloat *v); +GLAPI void GLAPIENTRY glColor4i (GLint red, GLint green, GLint blue, GLint alpha); +GLAPI void GLAPIENTRY glColor4iv (const GLint *v); +GLAPI void GLAPIENTRY glColor4s (GLshort red, GLshort green, GLshort blue, GLshort alpha); +GLAPI void GLAPIENTRY glColor4sv (const GLshort *v); +GLAPI void GLAPIENTRY glColor4ub (GLubyte red, GLubyte green, GLubyte blue, GLubyte alpha); +GLAPI void GLAPIENTRY glColor4ubv (const GLubyte *v); +GLAPI void GLAPIENTRY glColor4ui (GLuint red, GLuint green, GLuint blue, GLuint alpha); +GLAPI void GLAPIENTRY glColor4uiv (const GLuint *v); +GLAPI void GLAPIENTRY glColor4us (GLushort red, GLushort green, GLushort blue, GLushort alpha); +GLAPI void GLAPIENTRY glColor4usv (const GLushort *v); +GLAPI void GLAPIENTRY glColorMask (GLboolean red, GLboolean green, GLboolean blue, GLboolean alpha); +GLAPI void GLAPIENTRY glColorMaterial (GLenum face, GLenum mode); +GLAPI void GLAPIENTRY glColorPointer (GLint size, GLenum type, GLsizei stride, const GLvoid *pointer); +GLAPI void GLAPIENTRY glCopyPixels (GLint x, GLint y, GLsizei width, GLsizei height, GLenum type); +GLAPI void GLAPIENTRY glCopyTexImage1D (GLenum target, GLint level, GLenum internalFormat, GLint x, GLint y, GLsizei width, GLint border); +GLAPI void GLAPIENTRY glCopyTexImage2D (GLenum target, GLint level, GLenum internalFormat, GLint x, GLint y, GLsizei width, GLsizei height, GLint border); +GLAPI void GLAPIENTRY glCopyTexSubImage1D (GLenum target, GLint level, GLint xoffset, GLint x, GLint y, GLsizei width); +GLAPI void GLAPIENTRY glCopyTexSubImage2D (GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint x, GLint y, GLsizei width, GLsizei height); +GLAPI void GLAPIENTRY glCullFace (GLenum mode); +GLAPI void GLAPIENTRY glDeleteLists (GLuint list, GLsizei range); +GLAPI void GLAPIENTRY glDeleteTextures (GLsizei n, const GLuint *textures); +GLAPI void GLAPIENTRY glDepthFunc (GLenum func); +GLAPI void GLAPIENTRY glDepthMask (GLboolean flag); +GLAPI void GLAPIENTRY glDepthRange (GLclampd zNear, GLclampd zFar); +GLAPI void GLAPIENTRY glDisable (GLenum cap); +GLAPI void GLAPIENTRY glDisableClientState (GLenum array); +GLAPI void GLAPIENTRY glDrawArrays (GLenum mode, GLint first, GLsizei count); +GLAPI void GLAPIENTRY glDrawBuffer (GLenum mode); +GLAPI void GLAPIENTRY glDrawElements (GLenum mode, GLsizei count, GLenum type, const GLvoid *indices); +GLAPI void GLAPIENTRY glDrawPixels (GLsizei width, GLsizei height, GLenum format, GLenum type, const GLvoid *pixels); +GLAPI void GLAPIENTRY glEdgeFlag (GLboolean flag); +GLAPI void GLAPIENTRY glEdgeFlagPointer (GLsizei stride, const GLvoid *pointer); +GLAPI void GLAPIENTRY glEdgeFlagv (const GLboolean *flag); +GLAPI void GLAPIENTRY glEnable (GLenum cap); +GLAPI void GLAPIENTRY glEnableClientState (GLenum array); +GLAPI void GLAPIENTRY glEnd (void); +GLAPI void GLAPIENTRY glEndList (void); +GLAPI void GLAPIENTRY glEvalCoord1d (GLdouble u); +GLAPI void GLAPIENTRY glEvalCoord1dv (const GLdouble *u); +GLAPI void GLAPIENTRY glEvalCoord1f (GLfloat u); +GLAPI void GLAPIENTRY glEvalCoord1fv (const GLfloat *u); +GLAPI void GLAPIENTRY glEvalCoord2d (GLdouble u, GLdouble v); +GLAPI void GLAPIENTRY glEvalCoord2dv (const GLdouble *u); +GLAPI void GLAPIENTRY glEvalCoord2f (GLfloat u, GLfloat v); +GLAPI void GLAPIENTRY glEvalCoord2fv (const GLfloat *u); +GLAPI void GLAPIENTRY glEvalMesh1 (GLenum mode, GLint i1, GLint i2); +GLAPI void GLAPIENTRY glEvalMesh2 (GLenum mode, GLint i1, GLint i2, GLint j1, GLint j2); +GLAPI void GLAPIENTRY glEvalPoint1 (GLint i); +GLAPI void GLAPIENTRY glEvalPoint2 (GLint i, GLint j); +GLAPI void GLAPIENTRY glFeedbackBuffer (GLsizei size, GLenum type, GLfloat *buffer); +GLAPI void GLAPIENTRY glFinish (void); +GLAPI void GLAPIENTRY glFlush (void); +GLAPI void GLAPIENTRY glFogf (GLenum pname, GLfloat param); +GLAPI void GLAPIENTRY glFogfv (GLenum pname, const GLfloat *params); +GLAPI void GLAPIENTRY glFogi (GLenum pname, GLint param); +GLAPI void GLAPIENTRY glFogiv (GLenum pname, const GLint *params); +GLAPI void GLAPIENTRY glFrontFace (GLenum mode); +GLAPI void GLAPIENTRY glFrustum (GLdouble left, GLdouble right, GLdouble bottom, GLdouble top, GLdouble zNear, GLdouble zFar); +GLAPI GLuint GLAPIENTRY glGenLists (GLsizei range); +GLAPI void GLAPIENTRY glGenTextures (GLsizei n, GLuint *textures); +GLAPI void GLAPIENTRY glGetBooleanv (GLenum pname, GLboolean *params); +GLAPI void GLAPIENTRY glGetClipPlane (GLenum plane, GLdouble *equation); +GLAPI void GLAPIENTRY glGetDoublev (GLenum pname, GLdouble *params); +GLAPI GLenum GLAPIENTRY glGetError (void); +GLAPI void GLAPIENTRY glGetFloatv (GLenum pname, GLfloat *params); +GLAPI void GLAPIENTRY glGetIntegerv (GLenum pname, GLint *params); +GLAPI void GLAPIENTRY glGetLightfv (GLenum light, GLenum pname, GLfloat *params); +GLAPI void GLAPIENTRY glGetLightiv (GLenum light, GLenum pname, GLint *params); +GLAPI void GLAPIENTRY glGetMapdv (GLenum target, GLenum query, GLdouble *v); +GLAPI void GLAPIENTRY glGetMapfv (GLenum target, GLenum query, GLfloat *v); +GLAPI void GLAPIENTRY glGetMapiv (GLenum target, GLenum query, GLint *v); +GLAPI void GLAPIENTRY glGetMaterialfv (GLenum face, GLenum pname, GLfloat *params); +GLAPI void GLAPIENTRY glGetMaterialiv (GLenum face, GLenum pname, GLint *params); +GLAPI void GLAPIENTRY glGetPixelMapfv (GLenum map, GLfloat *values); +GLAPI void GLAPIENTRY glGetPixelMapuiv (GLenum map, GLuint *values); +GLAPI void GLAPIENTRY glGetPixelMapusv (GLenum map, GLushort *values); +GLAPI void GLAPIENTRY glGetPointerv (GLenum pname, GLvoid* *params); +GLAPI void GLAPIENTRY glGetPolygonStipple (GLubyte *mask); +GLAPI const GLubyte * GLAPIENTRY glGetString (GLenum name); +GLAPI void GLAPIENTRY glGetTexEnvfv (GLenum target, GLenum pname, GLfloat *params); +GLAPI void GLAPIENTRY glGetTexEnviv (GLenum target, GLenum pname, GLint *params); +GLAPI void GLAPIENTRY glGetTexGendv (GLenum coord, GLenum pname, GLdouble *params); +GLAPI void GLAPIENTRY glGetTexGenfv (GLenum coord, GLenum pname, GLfloat *params); +GLAPI void GLAPIENTRY glGetTexGeniv (GLenum coord, GLenum pname, GLint *params); +GLAPI void GLAPIENTRY glGetTexImage (GLenum target, GLint level, GLenum format, GLenum type, GLvoid *pixels); +GLAPI void GLAPIENTRY glGetTexLevelParameterfv (GLenum target, GLint level, GLenum pname, GLfloat *params); +GLAPI void GLAPIENTRY glGetTexLevelParameteriv (GLenum target, GLint level, GLenum pname, GLint *params); +GLAPI void GLAPIENTRY glGetTexParameterfv (GLenum target, GLenum pname, GLfloat *params); +GLAPI void GLAPIENTRY glGetTexParameteriv (GLenum target, GLenum pname, GLint *params); +GLAPI void GLAPIENTRY glHint (GLenum target, GLenum mode); +GLAPI void GLAPIENTRY glIndexMask (GLuint mask); +GLAPI void GLAPIENTRY glIndexPointer (GLenum type, GLsizei stride, const GLvoid *pointer); +GLAPI void GLAPIENTRY glIndexd (GLdouble c); +GLAPI void GLAPIENTRY glIndexdv (const GLdouble *c); +GLAPI void GLAPIENTRY glIndexf (GLfloat c); +GLAPI void GLAPIENTRY glIndexfv (const GLfloat *c); +GLAPI void GLAPIENTRY glIndexi (GLint c); +GLAPI void GLAPIENTRY glIndexiv (const GLint *c); +GLAPI void GLAPIENTRY glIndexs (GLshort c); +GLAPI void GLAPIENTRY glIndexsv (const GLshort *c); +GLAPI void GLAPIENTRY glIndexub (GLubyte c); +GLAPI void GLAPIENTRY glIndexubv (const GLubyte *c); +GLAPI void GLAPIENTRY glInitNames (void); +GLAPI void GLAPIENTRY glInterleavedArrays (GLenum format, GLsizei stride, const GLvoid *pointer); +GLAPI GLboolean GLAPIENTRY glIsEnabled (GLenum cap); +GLAPI GLboolean GLAPIENTRY glIsList (GLuint list); +GLAPI GLboolean GLAPIENTRY glIsTexture (GLuint texture); +GLAPI void GLAPIENTRY glLightModelf (GLenum pname, GLfloat param); +GLAPI void GLAPIENTRY glLightModelfv (GLenum pname, const GLfloat *params); +GLAPI void GLAPIENTRY glLightModeli (GLenum pname, GLint param); +GLAPI void GLAPIENTRY glLightModeliv (GLenum pname, const GLint *params); +GLAPI void GLAPIENTRY glLightf (GLenum light, GLenum pname, GLfloat param); +GLAPI void GLAPIENTRY glLightfv (GLenum light, GLenum pname, const GLfloat *params); +GLAPI void GLAPIENTRY glLighti (GLenum light, GLenum pname, GLint param); +GLAPI void GLAPIENTRY glLightiv (GLenum light, GLenum pname, const GLint *params); +GLAPI void GLAPIENTRY glLineStipple (GLint factor, GLushort pattern); +GLAPI void GLAPIENTRY glLineWidth (GLfloat width); +GLAPI void GLAPIENTRY glListBase (GLuint base); +GLAPI void GLAPIENTRY glLoadIdentity (void); +GLAPI void GLAPIENTRY glLoadMatrixd (const GLdouble *m); +GLAPI void GLAPIENTRY glLoadMatrixf (const GLfloat *m); +GLAPI void GLAPIENTRY glLoadName (GLuint name); +GLAPI void GLAPIENTRY glLogicOp (GLenum opcode); +GLAPI void GLAPIENTRY glMap1d (GLenum target, GLdouble u1, GLdouble u2, GLint stride, GLint order, const GLdouble *points); +GLAPI void GLAPIENTRY glMap1f (GLenum target, GLfloat u1, GLfloat u2, GLint stride, GLint order, const GLfloat *points); +GLAPI void GLAPIENTRY glMap2d (GLenum target, GLdouble u1, GLdouble u2, GLint ustride, GLint uorder, GLdouble v1, GLdouble v2, GLint vstride, GLint vorder, const GLdouble *points); +GLAPI void GLAPIENTRY glMap2f (GLenum target, GLfloat u1, GLfloat u2, GLint ustride, GLint uorder, GLfloat v1, GLfloat v2, GLint vstride, GLint vorder, const GLfloat *points); +GLAPI void GLAPIENTRY glMapGrid1d (GLint un, GLdouble u1, GLdouble u2); +GLAPI void GLAPIENTRY glMapGrid1f (GLint un, GLfloat u1, GLfloat u2); +GLAPI void GLAPIENTRY glMapGrid2d (GLint un, GLdouble u1, GLdouble u2, GLint vn, GLdouble v1, GLdouble v2); +GLAPI void GLAPIENTRY glMapGrid2f (GLint un, GLfloat u1, GLfloat u2, GLint vn, GLfloat v1, GLfloat v2); +GLAPI void GLAPIENTRY glMaterialf (GLenum face, GLenum pname, GLfloat param); +GLAPI void GLAPIENTRY glMaterialfv (GLenum face, GLenum pname, const GLfloat *params); +GLAPI void GLAPIENTRY glMateriali (GLenum face, GLenum pname, GLint param); +GLAPI void GLAPIENTRY glMaterialiv (GLenum face, GLenum pname, const GLint *params); +GLAPI void GLAPIENTRY glMatrixMode (GLenum mode); +GLAPI void GLAPIENTRY glMultMatrixd (const GLdouble *m); +GLAPI void GLAPIENTRY glMultMatrixf (const GLfloat *m); +GLAPI void GLAPIENTRY glNewList (GLuint list, GLenum mode); +GLAPI void GLAPIENTRY glNormal3b (GLbyte nx, GLbyte ny, GLbyte nz); +GLAPI void GLAPIENTRY glNormal3bv (const GLbyte *v); +GLAPI void GLAPIENTRY glNormal3d (GLdouble nx, GLdouble ny, GLdouble nz); +GLAPI void GLAPIENTRY glNormal3dv (const GLdouble *v); +GLAPI void GLAPIENTRY glNormal3f (GLfloat nx, GLfloat ny, GLfloat nz); +GLAPI void GLAPIENTRY glNormal3fv (const GLfloat *v); +GLAPI void GLAPIENTRY glNormal3i (GLint nx, GLint ny, GLint nz); +GLAPI void GLAPIENTRY glNormal3iv (const GLint *v); +GLAPI void GLAPIENTRY glNormal3s (GLshort nx, GLshort ny, GLshort nz); +GLAPI void GLAPIENTRY glNormal3sv (const GLshort *v); +GLAPI void GLAPIENTRY glNormalPointer (GLenum type, GLsizei stride, const GLvoid *pointer); +GLAPI void GLAPIENTRY glOrtho (GLdouble left, GLdouble right, GLdouble bottom, GLdouble top, GLdouble zNear, GLdouble zFar); +GLAPI void GLAPIENTRY glPassThrough (GLfloat token); +GLAPI void GLAPIENTRY glPixelMapfv (GLenum map, GLsizei mapsize, const GLfloat *values); +GLAPI void GLAPIENTRY glPixelMapuiv (GLenum map, GLsizei mapsize, const GLuint *values); +GLAPI void GLAPIENTRY glPixelMapusv (GLenum map, GLsizei mapsize, const GLushort *values); +GLAPI void GLAPIENTRY glPixelStoref (GLenum pname, GLfloat param); +GLAPI void GLAPIENTRY glPixelStorei (GLenum pname, GLint param); +GLAPI void GLAPIENTRY glPixelTransferf (GLenum pname, GLfloat param); +GLAPI void GLAPIENTRY glPixelTransferi (GLenum pname, GLint param); +GLAPI void GLAPIENTRY glPixelZoom (GLfloat xfactor, GLfloat yfactor); +GLAPI void GLAPIENTRY glPointSize (GLfloat size); +GLAPI void GLAPIENTRY glPolygonMode (GLenum face, GLenum mode); +GLAPI void GLAPIENTRY glPolygonOffset (GLfloat factor, GLfloat units); +GLAPI void GLAPIENTRY glPolygonStipple (const GLubyte *mask); +GLAPI void GLAPIENTRY glPopAttrib (void); +GLAPI void GLAPIENTRY glPopClientAttrib (void); +GLAPI void GLAPIENTRY glPopMatrix (void); +GLAPI void GLAPIENTRY glPopName (void); +GLAPI void GLAPIENTRY glPrioritizeTextures (GLsizei n, const GLuint *textures, const GLclampf *priorities); +GLAPI void GLAPIENTRY glPushAttrib (GLbitfield mask); +GLAPI void GLAPIENTRY glPushClientAttrib (GLbitfield mask); +GLAPI void GLAPIENTRY glPushMatrix (void); +GLAPI void GLAPIENTRY glPushName (GLuint name); +GLAPI void GLAPIENTRY glRasterPos2d (GLdouble x, GLdouble y); +GLAPI void GLAPIENTRY glRasterPos2dv (const GLdouble *v); +GLAPI void GLAPIENTRY glRasterPos2f (GLfloat x, GLfloat y); +GLAPI void GLAPIENTRY glRasterPos2fv (const GLfloat *v); +GLAPI void GLAPIENTRY glRasterPos2i (GLint x, GLint y); +GLAPI void GLAPIENTRY glRasterPos2iv (const GLint *v); +GLAPI void GLAPIENTRY glRasterPos2s (GLshort x, GLshort y); +GLAPI void GLAPIENTRY glRasterPos2sv (const GLshort *v); +GLAPI void GLAPIENTRY glRasterPos3d (GLdouble x, GLdouble y, GLdouble z); +GLAPI void GLAPIENTRY glRasterPos3dv (const GLdouble *v); +GLAPI void GLAPIENTRY glRasterPos3f (GLfloat x, GLfloat y, GLfloat z); +GLAPI void GLAPIENTRY glRasterPos3fv (const GLfloat *v); +GLAPI void GLAPIENTRY glRasterPos3i (GLint x, GLint y, GLint z); +GLAPI void GLAPIENTRY glRasterPos3iv (const GLint *v); +GLAPI void GLAPIENTRY glRasterPos3s (GLshort x, GLshort y, GLshort z); +GLAPI void GLAPIENTRY glRasterPos3sv (const GLshort *v); +GLAPI void GLAPIENTRY glRasterPos4d (GLdouble x, GLdouble y, GLdouble z, GLdouble w); +GLAPI void GLAPIENTRY glRasterPos4dv (const GLdouble *v); +GLAPI void GLAPIENTRY glRasterPos4f (GLfloat x, GLfloat y, GLfloat z, GLfloat w); +GLAPI void GLAPIENTRY glRasterPos4fv (const GLfloat *v); +GLAPI void GLAPIENTRY glRasterPos4i (GLint x, GLint y, GLint z, GLint w); +GLAPI void GLAPIENTRY glRasterPos4iv (const GLint *v); +GLAPI void GLAPIENTRY glRasterPos4s (GLshort x, GLshort y, GLshort z, GLshort w); +GLAPI void GLAPIENTRY glRasterPos4sv (const GLshort *v); +GLAPI void GLAPIENTRY glReadBuffer (GLenum mode); +GLAPI void GLAPIENTRY glReadPixels (GLint x, GLint y, GLsizei width, GLsizei height, GLenum format, GLenum type, GLvoid *pixels); +GLAPI void GLAPIENTRY glRectd (GLdouble x1, GLdouble y1, GLdouble x2, GLdouble y2); +GLAPI void GLAPIENTRY glRectdv (const GLdouble *v1, const GLdouble *v2); +GLAPI void GLAPIENTRY glRectf (GLfloat x1, GLfloat y1, GLfloat x2, GLfloat y2); +GLAPI void GLAPIENTRY glRectfv (const GLfloat *v1, const GLfloat *v2); +GLAPI void GLAPIENTRY glRecti (GLint x1, GLint y1, GLint x2, GLint y2); +GLAPI void GLAPIENTRY glRectiv (const GLint *v1, const GLint *v2); +GLAPI void GLAPIENTRY glRects (GLshort x1, GLshort y1, GLshort x2, GLshort y2); +GLAPI void GLAPIENTRY glRectsv (const GLshort *v1, const GLshort *v2); +GLAPI GLint GLAPIENTRY glRenderMode (GLenum mode); +GLAPI void GLAPIENTRY glRotated (GLdouble angle, GLdouble x, GLdouble y, GLdouble z); +GLAPI void GLAPIENTRY glRotatef (GLfloat angle, GLfloat x, GLfloat y, GLfloat z); +GLAPI void GLAPIENTRY glScaled (GLdouble x, GLdouble y, GLdouble z); +GLAPI void GLAPIENTRY glScalef (GLfloat x, GLfloat y, GLfloat z); +GLAPI void GLAPIENTRY glScissor (GLint x, GLint y, GLsizei width, GLsizei height); +GLAPI void GLAPIENTRY glSelectBuffer (GLsizei size, GLuint *buffer); +GLAPI void GLAPIENTRY glShadeModel (GLenum mode); +GLAPI void GLAPIENTRY glStencilFunc (GLenum func, GLint ref, GLuint mask); +GLAPI void GLAPIENTRY glStencilMask (GLuint mask); +GLAPI void GLAPIENTRY glStencilOp (GLenum fail, GLenum zfail, GLenum zpass); +GLAPI void GLAPIENTRY glTexCoord1d (GLdouble s); +GLAPI void GLAPIENTRY glTexCoord1dv (const GLdouble *v); +GLAPI void GLAPIENTRY glTexCoord1f (GLfloat s); +GLAPI void GLAPIENTRY glTexCoord1fv (const GLfloat *v); +GLAPI void GLAPIENTRY glTexCoord1i (GLint s); +GLAPI void GLAPIENTRY glTexCoord1iv (const GLint *v); +GLAPI void GLAPIENTRY glTexCoord1s (GLshort s); +GLAPI void GLAPIENTRY glTexCoord1sv (const GLshort *v); +GLAPI void GLAPIENTRY glTexCoord2d (GLdouble s, GLdouble t); +GLAPI void GLAPIENTRY glTexCoord2dv (const GLdouble *v); +GLAPI void GLAPIENTRY glTexCoord2f (GLfloat s, GLfloat t); +GLAPI void GLAPIENTRY glTexCoord2fv (const GLfloat *v); +GLAPI void GLAPIENTRY glTexCoord2i (GLint s, GLint t); +GLAPI void GLAPIENTRY glTexCoord2iv (const GLint *v); +GLAPI void GLAPIENTRY glTexCoord2s (GLshort s, GLshort t); +GLAPI void GLAPIENTRY glTexCoord2sv (const GLshort *v); +GLAPI void GLAPIENTRY glTexCoord3d (GLdouble s, GLdouble t, GLdouble r); +GLAPI void GLAPIENTRY glTexCoord3dv (const GLdouble *v); +GLAPI void GLAPIENTRY glTexCoord3f (GLfloat s, GLfloat t, GLfloat r); +GLAPI void GLAPIENTRY glTexCoord3fv (const GLfloat *v); +GLAPI void GLAPIENTRY glTexCoord3i (GLint s, GLint t, GLint r); +GLAPI void GLAPIENTRY glTexCoord3iv (const GLint *v); +GLAPI void GLAPIENTRY glTexCoord3s (GLshort s, GLshort t, GLshort r); +GLAPI void GLAPIENTRY glTexCoord3sv (const GLshort *v); +GLAPI void GLAPIENTRY glTexCoord4d (GLdouble s, GLdouble t, GLdouble r, GLdouble q); +GLAPI void GLAPIENTRY glTexCoord4dv (const GLdouble *v); +GLAPI void GLAPIENTRY glTexCoord4f (GLfloat s, GLfloat t, GLfloat r, GLfloat q); +GLAPI void GLAPIENTRY glTexCoord4fv (const GLfloat *v); +GLAPI void GLAPIENTRY glTexCoord4i (GLint s, GLint t, GLint r, GLint q); +GLAPI void GLAPIENTRY glTexCoord4iv (const GLint *v); +GLAPI void GLAPIENTRY glTexCoord4s (GLshort s, GLshort t, GLshort r, GLshort q); +GLAPI void GLAPIENTRY glTexCoord4sv (const GLshort *v); +GLAPI void GLAPIENTRY glTexCoordPointer (GLint size, GLenum type, GLsizei stride, const GLvoid *pointer); +GLAPI void GLAPIENTRY glTexEnvf (GLenum target, GLenum pname, GLfloat param); +GLAPI void GLAPIENTRY glTexEnvfv (GLenum target, GLenum pname, const GLfloat *params); +GLAPI void GLAPIENTRY glTexEnvi (GLenum target, GLenum pname, GLint param); +GLAPI void GLAPIENTRY glTexEnviv (GLenum target, GLenum pname, const GLint *params); +GLAPI void GLAPIENTRY glTexGend (GLenum coord, GLenum pname, GLdouble param); +GLAPI void GLAPIENTRY glTexGendv (GLenum coord, GLenum pname, const GLdouble *params); +GLAPI void GLAPIENTRY glTexGenf (GLenum coord, GLenum pname, GLfloat param); +GLAPI void GLAPIENTRY glTexGenfv (GLenum coord, GLenum pname, const GLfloat *params); +GLAPI void GLAPIENTRY glTexGeni (GLenum coord, GLenum pname, GLint param); +GLAPI void GLAPIENTRY glTexGeniv (GLenum coord, GLenum pname, const GLint *params); +GLAPI void GLAPIENTRY glTexImage1D (GLenum target, GLint level, GLint internalformat, GLsizei width, GLint border, GLenum format, GLenum type, const GLvoid *pixels); +GLAPI void GLAPIENTRY glTexImage2D (GLenum target, GLint level, GLint internalformat, GLsizei width, GLsizei height, GLint border, GLenum format, GLenum type, const GLvoid *pixels); +GLAPI void GLAPIENTRY glTexParameterf (GLenum target, GLenum pname, GLfloat param); +GLAPI void GLAPIENTRY glTexParameterfv (GLenum target, GLenum pname, const GLfloat *params); +GLAPI void GLAPIENTRY glTexParameteri (GLenum target, GLenum pname, GLint param); +GLAPI void GLAPIENTRY glTexParameteriv (GLenum target, GLenum pname, const GLint *params); +GLAPI void GLAPIENTRY glTexSubImage1D (GLenum target, GLint level, GLint xoffset, GLsizei width, GLenum format, GLenum type, const GLvoid *pixels); +GLAPI void GLAPIENTRY glTexSubImage2D (GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLenum type, const GLvoid *pixels); +GLAPI void GLAPIENTRY glTranslated (GLdouble x, GLdouble y, GLdouble z); +GLAPI void GLAPIENTRY glTranslatef (GLfloat x, GLfloat y, GLfloat z); +GLAPI void GLAPIENTRY glVertex2d (GLdouble x, GLdouble y); +GLAPI void GLAPIENTRY glVertex2dv (const GLdouble *v); +GLAPI void GLAPIENTRY glVertex2f (GLfloat x, GLfloat y); +GLAPI void GLAPIENTRY glVertex2fv (const GLfloat *v); +GLAPI void GLAPIENTRY glVertex2i (GLint x, GLint y); +GLAPI void GLAPIENTRY glVertex2iv (const GLint *v); +GLAPI void GLAPIENTRY glVertex2s (GLshort x, GLshort y); +GLAPI void GLAPIENTRY glVertex2sv (const GLshort *v); +GLAPI void GLAPIENTRY glVertex3d (GLdouble x, GLdouble y, GLdouble z); +GLAPI void GLAPIENTRY glVertex3dv (const GLdouble *v); +GLAPI void GLAPIENTRY glVertex3f (GLfloat x, GLfloat y, GLfloat z); +GLAPI void GLAPIENTRY glVertex3fv (const GLfloat *v); +GLAPI void GLAPIENTRY glVertex3i (GLint x, GLint y, GLint z); +GLAPI void GLAPIENTRY glVertex3iv (const GLint *v); +GLAPI void GLAPIENTRY glVertex3s (GLshort x, GLshort y, GLshort z); +GLAPI void GLAPIENTRY glVertex3sv (const GLshort *v); +GLAPI void GLAPIENTRY glVertex4d (GLdouble x, GLdouble y, GLdouble z, GLdouble w); +GLAPI void GLAPIENTRY glVertex4dv (const GLdouble *v); +GLAPI void GLAPIENTRY glVertex4f (GLfloat x, GLfloat y, GLfloat z, GLfloat w); +GLAPI void GLAPIENTRY glVertex4fv (const GLfloat *v); +GLAPI void GLAPIENTRY glVertex4i (GLint x, GLint y, GLint z, GLint w); +GLAPI void GLAPIENTRY glVertex4iv (const GLint *v); +GLAPI void GLAPIENTRY glVertex4s (GLshort x, GLshort y, GLshort z, GLshort w); +GLAPI void GLAPIENTRY glVertex4sv (const GLshort *v); +GLAPI void GLAPIENTRY glVertexPointer (GLint size, GLenum type, GLsizei stride, const GLvoid *pointer); +GLAPI void GLAPIENTRY glViewport (GLint x, GLint y, GLsizei width, GLsizei height); + +#define GLEW_VERSION_1_1 GLEW_GET_VAR(__GLEW_VERSION_1_1) + +#endif /* GL_VERSION_1_1 */ + +/* ---------------------------------- GLU ---------------------------------- */ + +/* this is where we can safely include GLU */ +#if defined(__APPLE__) && defined(__MACH__) +#include "OpenGL/glu.h" +#else +#include +#endif + +/* ----------------------------- GL_VERSION_1_2 ---------------------------- */ + +#ifndef GL_VERSION_1_2 +#define GL_VERSION_1_2 1 + +#define GL_SMOOTH_POINT_SIZE_RANGE 0x0B12 +#define GL_SMOOTH_POINT_SIZE_GRANULARITY 0x0B13 +#define GL_SMOOTH_LINE_WIDTH_RANGE 0x0B22 +#define GL_SMOOTH_LINE_WIDTH_GRANULARITY 0x0B23 +#define GL_UNSIGNED_BYTE_3_3_2 0x8032 +#define GL_UNSIGNED_SHORT_4_4_4_4 0x8033 +#define GL_UNSIGNED_SHORT_5_5_5_1 0x8034 +#define GL_UNSIGNED_INT_8_8_8_8 0x8035 +#define GL_UNSIGNED_INT_10_10_10_2 0x8036 +#define GL_RESCALE_NORMAL 0x803A +#define GL_TEXTURE_BINDING_3D 0x806A +#define GL_PACK_SKIP_IMAGES 0x806B +#define GL_PACK_IMAGE_HEIGHT 0x806C +#define GL_UNPACK_SKIP_IMAGES 0x806D +#define GL_UNPACK_IMAGE_HEIGHT 0x806E +#define GL_TEXTURE_3D 0x806F +#define GL_PROXY_TEXTURE_3D 0x8070 +#define GL_TEXTURE_DEPTH 0x8071 +#define GL_TEXTURE_WRAP_R 0x8072 +#define GL_MAX_3D_TEXTURE_SIZE 0x8073 +#define GL_BGR 0x80E0 +#define GL_BGRA 0x80E1 +#define GL_MAX_ELEMENTS_VERTICES 0x80E8 +#define GL_MAX_ELEMENTS_INDICES 0x80E9 +#define GL_CLAMP_TO_EDGE 0x812F +#define GL_TEXTURE_MIN_LOD 0x813A +#define GL_TEXTURE_MAX_LOD 0x813B +#define GL_TEXTURE_BASE_LEVEL 0x813C +#define GL_TEXTURE_MAX_LEVEL 0x813D +#define GL_LIGHT_MODEL_COLOR_CONTROL 0x81F8 +#define GL_SINGLE_COLOR 0x81F9 +#define GL_SEPARATE_SPECULAR_COLOR 0x81FA +#define GL_UNSIGNED_BYTE_2_3_3_REV 0x8362 +#define GL_UNSIGNED_SHORT_5_6_5 0x8363 +#define GL_UNSIGNED_SHORT_5_6_5_REV 0x8364 +#define GL_UNSIGNED_SHORT_4_4_4_4_REV 0x8365 +#define GL_UNSIGNED_SHORT_1_5_5_5_REV 0x8366 +#define GL_UNSIGNED_INT_8_8_8_8_REV 0x8367 +#define GL_UNSIGNED_INT_2_10_10_10_REV 0x8368 +#define GL_ALIASED_POINT_SIZE_RANGE 0x846D +#define GL_ALIASED_LINE_WIDTH_RANGE 0x846E + +typedef void (GLAPIENTRY * PFNGLCOPYTEXSUBIMAGE3DPROC) (GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLint x, GLint y, GLsizei width, GLsizei height); +typedef void (GLAPIENTRY * PFNGLDRAWRANGEELEMENTSPROC) (GLenum mode, GLuint start, GLuint end, GLsizei count, GLenum type, const GLvoid *indices); +typedef void (GLAPIENTRY * PFNGLTEXIMAGE3DPROC) (GLenum target, GLint level, GLint internalFormat, GLsizei width, GLsizei height, GLsizei depth, GLint border, GLenum format, GLenum type, const GLvoid *pixels); +typedef void (GLAPIENTRY * PFNGLTEXSUBIMAGE3DPROC) (GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLenum type, const GLvoid *pixels); + +#define glCopyTexSubImage3D GLEW_GET_FUN(__glewCopyTexSubImage3D) +#define glDrawRangeElements GLEW_GET_FUN(__glewDrawRangeElements) +#define glTexImage3D GLEW_GET_FUN(__glewTexImage3D) +#define glTexSubImage3D GLEW_GET_FUN(__glewTexSubImage3D) + +#define GLEW_VERSION_1_2 GLEW_GET_VAR(__GLEW_VERSION_1_2) + +#endif /* GL_VERSION_1_2 */ + +/* ----------------------------- GL_VERSION_1_3 ---------------------------- */ + +#ifndef GL_VERSION_1_3 +#define GL_VERSION_1_3 1 + +#define GL_MULTISAMPLE 0x809D +#define GL_SAMPLE_ALPHA_TO_COVERAGE 0x809E +#define GL_SAMPLE_ALPHA_TO_ONE 0x809F +#define GL_SAMPLE_COVERAGE 0x80A0 +#define GL_SAMPLE_BUFFERS 0x80A8 +#define GL_SAMPLES 0x80A9 +#define GL_SAMPLE_COVERAGE_VALUE 0x80AA +#define GL_SAMPLE_COVERAGE_INVERT 0x80AB +#define GL_CLAMP_TO_BORDER 0x812D +#define GL_TEXTURE0 0x84C0 +#define GL_TEXTURE1 0x84C1 +#define GL_TEXTURE2 0x84C2 +#define GL_TEXTURE3 0x84C3 +#define GL_TEXTURE4 0x84C4 +#define GL_TEXTURE5 0x84C5 +#define GL_TEXTURE6 0x84C6 +#define GL_TEXTURE7 0x84C7 +#define GL_TEXTURE8 0x84C8 +#define GL_TEXTURE9 0x84C9 +#define GL_TEXTURE10 0x84CA +#define GL_TEXTURE11 0x84CB +#define GL_TEXTURE12 0x84CC +#define GL_TEXTURE13 0x84CD +#define GL_TEXTURE14 0x84CE +#define GL_TEXTURE15 0x84CF +#define GL_TEXTURE16 0x84D0 +#define GL_TEXTURE17 0x84D1 +#define GL_TEXTURE18 0x84D2 +#define GL_TEXTURE19 0x84D3 +#define GL_TEXTURE20 0x84D4 +#define GL_TEXTURE21 0x84D5 +#define GL_TEXTURE22 0x84D6 +#define GL_TEXTURE23 0x84D7 +#define GL_TEXTURE24 0x84D8 +#define GL_TEXTURE25 0x84D9 +#define GL_TEXTURE26 0x84DA +#define GL_TEXTURE27 0x84DB +#define GL_TEXTURE28 0x84DC +#define GL_TEXTURE29 0x84DD +#define GL_TEXTURE30 0x84DE +#define GL_TEXTURE31 0x84DF +#define GL_ACTIVE_TEXTURE 0x84E0 +#define GL_CLIENT_ACTIVE_TEXTURE 0x84E1 +#define GL_MAX_TEXTURE_UNITS 0x84E2 +#define GL_TRANSPOSE_MODELVIEW_MATRIX 0x84E3 +#define GL_TRANSPOSE_PROJECTION_MATRIX 0x84E4 +#define GL_TRANSPOSE_TEXTURE_MATRIX 0x84E5 +#define GL_TRANSPOSE_COLOR_MATRIX 0x84E6 +#define GL_SUBTRACT 0x84E7 +#define GL_COMPRESSED_ALPHA 0x84E9 +#define GL_COMPRESSED_LUMINANCE 0x84EA +#define GL_COMPRESSED_LUMINANCE_ALPHA 0x84EB +#define GL_COMPRESSED_INTENSITY 0x84EC +#define GL_COMPRESSED_RGB 0x84ED +#define GL_COMPRESSED_RGBA 0x84EE +#define GL_TEXTURE_COMPRESSION_HINT 0x84EF +#define GL_NORMAL_MAP 0x8511 +#define GL_REFLECTION_MAP 0x8512 +#define GL_TEXTURE_CUBE_MAP 0x8513 +#define GL_TEXTURE_BINDING_CUBE_MAP 0x8514 +#define GL_TEXTURE_CUBE_MAP_POSITIVE_X 0x8515 +#define GL_TEXTURE_CUBE_MAP_NEGATIVE_X 0x8516 +#define GL_TEXTURE_CUBE_MAP_POSITIVE_Y 0x8517 +#define GL_TEXTURE_CUBE_MAP_NEGATIVE_Y 0x8518 +#define GL_TEXTURE_CUBE_MAP_POSITIVE_Z 0x8519 +#define GL_TEXTURE_CUBE_MAP_NEGATIVE_Z 0x851A +#define GL_PROXY_TEXTURE_CUBE_MAP 0x851B +#define GL_MAX_CUBE_MAP_TEXTURE_SIZE 0x851C +#define GL_COMBINE 0x8570 +#define GL_COMBINE_RGB 0x8571 +#define GL_COMBINE_ALPHA 0x8572 +#define GL_RGB_SCALE 0x8573 +#define GL_ADD_SIGNED 0x8574 +#define GL_INTERPOLATE 0x8575 +#define GL_CONSTANT 0x8576 +#define GL_PRIMARY_COLOR 0x8577 +#define GL_PREVIOUS 0x8578 +#define GL_SOURCE0_RGB 0x8580 +#define GL_SOURCE1_RGB 0x8581 +#define GL_SOURCE2_RGB 0x8582 +#define GL_SOURCE0_ALPHA 0x8588 +#define GL_SOURCE1_ALPHA 0x8589 +#define GL_SOURCE2_ALPHA 0x858A +#define GL_OPERAND0_RGB 0x8590 +#define GL_OPERAND1_RGB 0x8591 +#define GL_OPERAND2_RGB 0x8592 +#define GL_OPERAND0_ALPHA 0x8598 +#define GL_OPERAND1_ALPHA 0x8599 +#define GL_OPERAND2_ALPHA 0x859A +#define GL_TEXTURE_COMPRESSED_IMAGE_SIZE 0x86A0 +#define GL_TEXTURE_COMPRESSED 0x86A1 +#define GL_NUM_COMPRESSED_TEXTURE_FORMATS 0x86A2 +#define GL_COMPRESSED_TEXTURE_FORMATS 0x86A3 +#define GL_DOT3_RGB 0x86AE +#define GL_DOT3_RGBA 0x86AF +#define GL_MULTISAMPLE_BIT 0x20000000 + +typedef void (GLAPIENTRY * PFNGLACTIVETEXTUREPROC) (GLenum texture); +typedef void (GLAPIENTRY * PFNGLCLIENTACTIVETEXTUREPROC) (GLenum texture); +typedef void (GLAPIENTRY * PFNGLCOMPRESSEDTEXIMAGE1DPROC) (GLenum target, GLint level, GLenum internalformat, GLsizei width, GLint border, GLsizei imageSize, const GLvoid *data); +typedef void (GLAPIENTRY * PFNGLCOMPRESSEDTEXIMAGE2DPROC) (GLenum target, GLint level, GLenum internalformat, GLsizei width, GLsizei height, GLint border, GLsizei imageSize, const GLvoid *data); +typedef void (GLAPIENTRY * PFNGLCOMPRESSEDTEXIMAGE3DPROC) (GLenum target, GLint level, GLenum internalformat, GLsizei width, GLsizei height, GLsizei depth, GLint border, GLsizei imageSize, const GLvoid *data); +typedef void (GLAPIENTRY * PFNGLCOMPRESSEDTEXSUBIMAGE1DPROC) (GLenum target, GLint level, GLint xoffset, GLsizei width, GLenum format, GLsizei imageSize, const GLvoid *data); +typedef void (GLAPIENTRY * PFNGLCOMPRESSEDTEXSUBIMAGE2DPROC) (GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLsizei imageSize, const GLvoid *data); +typedef void (GLAPIENTRY * PFNGLCOMPRESSEDTEXSUBIMAGE3DPROC) (GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLsizei imageSize, const GLvoid *data); +typedef void (GLAPIENTRY * PFNGLGETCOMPRESSEDTEXIMAGEPROC) (GLenum target, GLint lod, GLvoid *img); +typedef void (GLAPIENTRY * PFNGLLOADTRANSPOSEMATRIXDPROC) (const GLdouble m[16]); +typedef void (GLAPIENTRY * PFNGLLOADTRANSPOSEMATRIXFPROC) (const GLfloat m[16]); +typedef void (GLAPIENTRY * PFNGLMULTTRANSPOSEMATRIXDPROC) (const GLdouble m[16]); +typedef void (GLAPIENTRY * PFNGLMULTTRANSPOSEMATRIXFPROC) (const GLfloat m[16]); +typedef void (GLAPIENTRY * PFNGLMULTITEXCOORD1DPROC) (GLenum target, GLdouble s); +typedef void (GLAPIENTRY * PFNGLMULTITEXCOORD1DVPROC) (GLenum target, const GLdouble *v); +typedef void (GLAPIENTRY * PFNGLMULTITEXCOORD1FPROC) (GLenum target, GLfloat s); +typedef void (GLAPIENTRY * PFNGLMULTITEXCOORD1FVPROC) (GLenum target, const GLfloat *v); +typedef void (GLAPIENTRY * PFNGLMULTITEXCOORD1IPROC) (GLenum target, GLint s); +typedef void (GLAPIENTRY * PFNGLMULTITEXCOORD1IVPROC) (GLenum target, const GLint *v); +typedef void (GLAPIENTRY * PFNGLMULTITEXCOORD1SPROC) (GLenum target, GLshort s); +typedef void (GLAPIENTRY * PFNGLMULTITEXCOORD1SVPROC) (GLenum target, const GLshort *v); +typedef void (GLAPIENTRY * PFNGLMULTITEXCOORD2DPROC) (GLenum target, GLdouble s, GLdouble t); +typedef void (GLAPIENTRY * PFNGLMULTITEXCOORD2DVPROC) (GLenum target, const GLdouble *v); +typedef void (GLAPIENTRY * PFNGLMULTITEXCOORD2FPROC) (GLenum target, GLfloat s, GLfloat t); +typedef void (GLAPIENTRY * PFNGLMULTITEXCOORD2FVPROC) (GLenum target, const GLfloat *v); +typedef void (GLAPIENTRY * PFNGLMULTITEXCOORD2IPROC) (GLenum target, GLint s, GLint t); +typedef void (GLAPIENTRY * PFNGLMULTITEXCOORD2IVPROC) (GLenum target, const GLint *v); +typedef void (GLAPIENTRY * PFNGLMULTITEXCOORD2SPROC) (GLenum target, GLshort s, GLshort t); +typedef void (GLAPIENTRY * PFNGLMULTITEXCOORD2SVPROC) (GLenum target, const GLshort *v); +typedef void (GLAPIENTRY * PFNGLMULTITEXCOORD3DPROC) (GLenum target, GLdouble s, GLdouble t, GLdouble r); +typedef void (GLAPIENTRY * PFNGLMULTITEXCOORD3DVPROC) (GLenum target, const GLdouble *v); +typedef void (GLAPIENTRY * PFNGLMULTITEXCOORD3FPROC) (GLenum target, GLfloat s, GLfloat t, GLfloat r); +typedef void (GLAPIENTRY * PFNGLMULTITEXCOORD3FVPROC) (GLenum target, const GLfloat *v); +typedef void (GLAPIENTRY * PFNGLMULTITEXCOORD3IPROC) (GLenum target, GLint s, GLint t, GLint r); +typedef void (GLAPIENTRY * PFNGLMULTITEXCOORD3IVPROC) (GLenum target, const GLint *v); +typedef void (GLAPIENTRY * PFNGLMULTITEXCOORD3SPROC) (GLenum target, GLshort s, GLshort t, GLshort r); +typedef void (GLAPIENTRY * PFNGLMULTITEXCOORD3SVPROC) (GLenum target, const GLshort *v); +typedef void (GLAPIENTRY * PFNGLMULTITEXCOORD4DPROC) (GLenum target, GLdouble s, GLdouble t, GLdouble r, GLdouble q); +typedef void (GLAPIENTRY * PFNGLMULTITEXCOORD4DVPROC) (GLenum target, const GLdouble *v); +typedef void (GLAPIENTRY * PFNGLMULTITEXCOORD4FPROC) (GLenum target, GLfloat s, GLfloat t, GLfloat r, GLfloat q); +typedef void (GLAPIENTRY * PFNGLMULTITEXCOORD4FVPROC) (GLenum target, const GLfloat *v); +typedef void (GLAPIENTRY * PFNGLMULTITEXCOORD4IPROC) (GLenum target, GLint s, GLint t, GLint r, GLint q); +typedef void (GLAPIENTRY * PFNGLMULTITEXCOORD4IVPROC) (GLenum target, const GLint *v); +typedef void (GLAPIENTRY * PFNGLMULTITEXCOORD4SPROC) (GLenum target, GLshort s, GLshort t, GLshort r, GLshort q); +typedef void (GLAPIENTRY * PFNGLMULTITEXCOORD4SVPROC) (GLenum target, const GLshort *v); +typedef void (GLAPIENTRY * PFNGLSAMPLECOVERAGEPROC) (GLclampf value, GLboolean invert); + +#define glActiveTexture GLEW_GET_FUN(__glewActiveTexture) +#define glClientActiveTexture GLEW_GET_FUN(__glewClientActiveTexture) +#define glCompressedTexImage1D GLEW_GET_FUN(__glewCompressedTexImage1D) +#define glCompressedTexImage2D GLEW_GET_FUN(__glewCompressedTexImage2D) +#define glCompressedTexImage3D GLEW_GET_FUN(__glewCompressedTexImage3D) +#define glCompressedTexSubImage1D GLEW_GET_FUN(__glewCompressedTexSubImage1D) +#define glCompressedTexSubImage2D GLEW_GET_FUN(__glewCompressedTexSubImage2D) +#define glCompressedTexSubImage3D GLEW_GET_FUN(__glewCompressedTexSubImage3D) +#define glGetCompressedTexImage GLEW_GET_FUN(__glewGetCompressedTexImage) +#define glLoadTransposeMatrixd GLEW_GET_FUN(__glewLoadTransposeMatrixd) +#define glLoadTransposeMatrixf GLEW_GET_FUN(__glewLoadTransposeMatrixf) +#define glMultTransposeMatrixd GLEW_GET_FUN(__glewMultTransposeMatrixd) +#define glMultTransposeMatrixf GLEW_GET_FUN(__glewMultTransposeMatrixf) +#define glMultiTexCoord1d GLEW_GET_FUN(__glewMultiTexCoord1d) +#define glMultiTexCoord1dv GLEW_GET_FUN(__glewMultiTexCoord1dv) +#define glMultiTexCoord1f GLEW_GET_FUN(__glewMultiTexCoord1f) +#define glMultiTexCoord1fv GLEW_GET_FUN(__glewMultiTexCoord1fv) +#define glMultiTexCoord1i GLEW_GET_FUN(__glewMultiTexCoord1i) +#define glMultiTexCoord1iv GLEW_GET_FUN(__glewMultiTexCoord1iv) +#define glMultiTexCoord1s GLEW_GET_FUN(__glewMultiTexCoord1s) +#define glMultiTexCoord1sv GLEW_GET_FUN(__glewMultiTexCoord1sv) +#define glMultiTexCoord2d GLEW_GET_FUN(__glewMultiTexCoord2d) +#define glMultiTexCoord2dv GLEW_GET_FUN(__glewMultiTexCoord2dv) +#define glMultiTexCoord2f GLEW_GET_FUN(__glewMultiTexCoord2f) +#define glMultiTexCoord2fv GLEW_GET_FUN(__glewMultiTexCoord2fv) +#define glMultiTexCoord2i GLEW_GET_FUN(__glewMultiTexCoord2i) +#define glMultiTexCoord2iv GLEW_GET_FUN(__glewMultiTexCoord2iv) +#define glMultiTexCoord2s GLEW_GET_FUN(__glewMultiTexCoord2s) +#define glMultiTexCoord2sv GLEW_GET_FUN(__glewMultiTexCoord2sv) +#define glMultiTexCoord3d GLEW_GET_FUN(__glewMultiTexCoord3d) +#define glMultiTexCoord3dv GLEW_GET_FUN(__glewMultiTexCoord3dv) +#define glMultiTexCoord3f GLEW_GET_FUN(__glewMultiTexCoord3f) +#define glMultiTexCoord3fv GLEW_GET_FUN(__glewMultiTexCoord3fv) +#define glMultiTexCoord3i GLEW_GET_FUN(__glewMultiTexCoord3i) +#define glMultiTexCoord3iv GLEW_GET_FUN(__glewMultiTexCoord3iv) +#define glMultiTexCoord3s GLEW_GET_FUN(__glewMultiTexCoord3s) +#define glMultiTexCoord3sv GLEW_GET_FUN(__glewMultiTexCoord3sv) +#define glMultiTexCoord4d GLEW_GET_FUN(__glewMultiTexCoord4d) +#define glMultiTexCoord4dv GLEW_GET_FUN(__glewMultiTexCoord4dv) +#define glMultiTexCoord4f GLEW_GET_FUN(__glewMultiTexCoord4f) +#define glMultiTexCoord4fv GLEW_GET_FUN(__glewMultiTexCoord4fv) +#define glMultiTexCoord4i GLEW_GET_FUN(__glewMultiTexCoord4i) +#define glMultiTexCoord4iv GLEW_GET_FUN(__glewMultiTexCoord4iv) +#define glMultiTexCoord4s GLEW_GET_FUN(__glewMultiTexCoord4s) +#define glMultiTexCoord4sv GLEW_GET_FUN(__glewMultiTexCoord4sv) +#define glSampleCoverage GLEW_GET_FUN(__glewSampleCoverage) + +#define GLEW_VERSION_1_3 GLEW_GET_VAR(__GLEW_VERSION_1_3) + +#endif /* GL_VERSION_1_3 */ + +/* ----------------------------- GL_VERSION_1_4 ---------------------------- */ + +#ifndef GL_VERSION_1_4 +#define GL_VERSION_1_4 1 + +#define GL_BLEND_DST_RGB 0x80C8 +#define GL_BLEND_SRC_RGB 0x80C9 +#define GL_BLEND_DST_ALPHA 0x80CA +#define GL_BLEND_SRC_ALPHA 0x80CB +#define GL_POINT_SIZE_MIN 0x8126 +#define GL_POINT_SIZE_MAX 0x8127 +#define GL_POINT_FADE_THRESHOLD_SIZE 0x8128 +#define GL_POINT_DISTANCE_ATTENUATION 0x8129 +#define GL_GENERATE_MIPMAP 0x8191 +#define GL_GENERATE_MIPMAP_HINT 0x8192 +#define GL_DEPTH_COMPONENT16 0x81A5 +#define GL_DEPTH_COMPONENT24 0x81A6 +#define GL_DEPTH_COMPONENT32 0x81A7 +#define GL_MIRRORED_REPEAT 0x8370 +#define GL_FOG_COORDINATE_SOURCE 0x8450 +#define GL_FOG_COORDINATE 0x8451 +#define GL_FRAGMENT_DEPTH 0x8452 +#define GL_CURRENT_FOG_COORDINATE 0x8453 +#define GL_FOG_COORDINATE_ARRAY_TYPE 0x8454 +#define GL_FOG_COORDINATE_ARRAY_STRIDE 0x8455 +#define GL_FOG_COORDINATE_ARRAY_POINTER 0x8456 +#define GL_FOG_COORDINATE_ARRAY 0x8457 +#define GL_COLOR_SUM 0x8458 +#define GL_CURRENT_SECONDARY_COLOR 0x8459 +#define GL_SECONDARY_COLOR_ARRAY_SIZE 0x845A +#define GL_SECONDARY_COLOR_ARRAY_TYPE 0x845B +#define GL_SECONDARY_COLOR_ARRAY_STRIDE 0x845C +#define GL_SECONDARY_COLOR_ARRAY_POINTER 0x845D +#define GL_SECONDARY_COLOR_ARRAY 0x845E +#define GL_MAX_TEXTURE_LOD_BIAS 0x84FD +#define GL_TEXTURE_FILTER_CONTROL 0x8500 +#define GL_TEXTURE_LOD_BIAS 0x8501 +#define GL_INCR_WRAP 0x8507 +#define GL_DECR_WRAP 0x8508 +#define GL_TEXTURE_DEPTH_SIZE 0x884A +#define GL_DEPTH_TEXTURE_MODE 0x884B +#define GL_TEXTURE_COMPARE_MODE 0x884C +#define GL_TEXTURE_COMPARE_FUNC 0x884D +#define GL_COMPARE_R_TO_TEXTURE 0x884E + +typedef void (GLAPIENTRY * PFNGLBLENDCOLORPROC) (GLclampf red, GLclampf green, GLclampf blue, GLclampf alpha); +typedef void (GLAPIENTRY * PFNGLBLENDEQUATIONPROC) (GLenum mode); +typedef void (GLAPIENTRY * PFNGLBLENDFUNCSEPARATEPROC) (GLenum sfactorRGB, GLenum dfactorRGB, GLenum sfactorAlpha, GLenum dfactorAlpha); +typedef void (GLAPIENTRY * PFNGLFOGCOORDPOINTERPROC) (GLenum type, GLsizei stride, const GLvoid *pointer); +typedef void (GLAPIENTRY * PFNGLFOGCOORDDPROC) (GLdouble coord); +typedef void (GLAPIENTRY * PFNGLFOGCOORDDVPROC) (const GLdouble *coord); +typedef void (GLAPIENTRY * PFNGLFOGCOORDFPROC) (GLfloat coord); +typedef void (GLAPIENTRY * PFNGLFOGCOORDFVPROC) (const GLfloat *coord); +typedef void (GLAPIENTRY * PFNGLMULTIDRAWARRAYSPROC) (GLenum mode, GLint *first, GLsizei *count, GLsizei primcount); +typedef void (GLAPIENTRY * PFNGLMULTIDRAWELEMENTSPROC) (GLenum mode, GLsizei *count, GLenum type, const GLvoid **indices, GLsizei primcount); +typedef void (GLAPIENTRY * PFNGLPOINTPARAMETERFPROC) (GLenum pname, GLfloat param); +typedef void (GLAPIENTRY * PFNGLPOINTPARAMETERFVPROC) (GLenum pname, GLfloat *params); +typedef void (GLAPIENTRY * PFNGLPOINTPARAMETERIPROC) (GLenum pname, GLint param); +typedef void (GLAPIENTRY * PFNGLPOINTPARAMETERIVPROC) (GLenum pname, GLint *params); +typedef void (GLAPIENTRY * PFNGLSECONDARYCOLOR3BPROC) (GLbyte red, GLbyte green, GLbyte blue); +typedef void (GLAPIENTRY * PFNGLSECONDARYCOLOR3BVPROC) (const GLbyte *v); +typedef void (GLAPIENTRY * PFNGLSECONDARYCOLOR3DPROC) (GLdouble red, GLdouble green, GLdouble blue); +typedef void (GLAPIENTRY * PFNGLSECONDARYCOLOR3DVPROC) (const GLdouble *v); +typedef void (GLAPIENTRY * PFNGLSECONDARYCOLOR3FPROC) (GLfloat red, GLfloat green, GLfloat blue); +typedef void (GLAPIENTRY * PFNGLSECONDARYCOLOR3FVPROC) (const GLfloat *v); +typedef void (GLAPIENTRY * PFNGLSECONDARYCOLOR3IPROC) (GLint red, GLint green, GLint blue); +typedef void (GLAPIENTRY * PFNGLSECONDARYCOLOR3IVPROC) (const GLint *v); +typedef void (GLAPIENTRY * PFNGLSECONDARYCOLOR3SPROC) (GLshort red, GLshort green, GLshort blue); +typedef void (GLAPIENTRY * PFNGLSECONDARYCOLOR3SVPROC) (const GLshort *v); +typedef void (GLAPIENTRY * PFNGLSECONDARYCOLOR3UBPROC) (GLubyte red, GLubyte green, GLubyte blue); +typedef void (GLAPIENTRY * PFNGLSECONDARYCOLOR3UBVPROC) (const GLubyte *v); +typedef void (GLAPIENTRY * PFNGLSECONDARYCOLOR3UIPROC) (GLuint red, GLuint green, GLuint blue); +typedef void (GLAPIENTRY * PFNGLSECONDARYCOLOR3UIVPROC) (const GLuint *v); +typedef void (GLAPIENTRY * PFNGLSECONDARYCOLOR3USPROC) (GLushort red, GLushort green, GLushort blue); +typedef void (GLAPIENTRY * PFNGLSECONDARYCOLOR3USVPROC) (const GLushort *v); +typedef void (GLAPIENTRY * PFNGLSECONDARYCOLORPOINTERPROC) (GLint size, GLenum type, GLsizei stride, GLvoid *pointer); +typedef void (GLAPIENTRY * PFNGLWINDOWPOS2DPROC) (GLdouble x, GLdouble y); +typedef void (GLAPIENTRY * PFNGLWINDOWPOS2DVPROC) (const GLdouble *p); +typedef void (GLAPIENTRY * PFNGLWINDOWPOS2FPROC) (GLfloat x, GLfloat y); +typedef void (GLAPIENTRY * PFNGLWINDOWPOS2FVPROC) (const GLfloat *p); +typedef void (GLAPIENTRY * PFNGLWINDOWPOS2IPROC) (GLint x, GLint y); +typedef void (GLAPIENTRY * PFNGLWINDOWPOS2IVPROC) (const GLint *p); +typedef void (GLAPIENTRY * PFNGLWINDOWPOS2SPROC) (GLshort x, GLshort y); +typedef void (GLAPIENTRY * PFNGLWINDOWPOS2SVPROC) (const GLshort *p); +typedef void (GLAPIENTRY * PFNGLWINDOWPOS3DPROC) (GLdouble x, GLdouble y, GLdouble z); +typedef void (GLAPIENTRY * PFNGLWINDOWPOS3DVPROC) (const GLdouble *p); +typedef void (GLAPIENTRY * PFNGLWINDOWPOS3FPROC) (GLfloat x, GLfloat y, GLfloat z); +typedef void (GLAPIENTRY * PFNGLWINDOWPOS3FVPROC) (const GLfloat *p); +typedef void (GLAPIENTRY * PFNGLWINDOWPOS3IPROC) (GLint x, GLint y, GLint z); +typedef void (GLAPIENTRY * PFNGLWINDOWPOS3IVPROC) (const GLint *p); +typedef void (GLAPIENTRY * PFNGLWINDOWPOS3SPROC) (GLshort x, GLshort y, GLshort z); +typedef void (GLAPIENTRY * PFNGLWINDOWPOS3SVPROC) (const GLshort *p); + +#define glBlendColor GLEW_GET_FUN(__glewBlendColor) +#define glBlendEquation GLEW_GET_FUN(__glewBlendEquation) +#define glBlendFuncSeparate GLEW_GET_FUN(__glewBlendFuncSeparate) +#define glFogCoordPointer GLEW_GET_FUN(__glewFogCoordPointer) +#define glFogCoordd GLEW_GET_FUN(__glewFogCoordd) +#define glFogCoorddv GLEW_GET_FUN(__glewFogCoorddv) +#define glFogCoordf GLEW_GET_FUN(__glewFogCoordf) +#define glFogCoordfv GLEW_GET_FUN(__glewFogCoordfv) +#define glMultiDrawArrays GLEW_GET_FUN(__glewMultiDrawArrays) +#define glMultiDrawElements GLEW_GET_FUN(__glewMultiDrawElements) +#define glPointParameterf GLEW_GET_FUN(__glewPointParameterf) +#define glPointParameterfv GLEW_GET_FUN(__glewPointParameterfv) +#define glPointParameteri GLEW_GET_FUN(__glewPointParameteri) +#define glPointParameteriv GLEW_GET_FUN(__glewPointParameteriv) +#define glSecondaryColor3b GLEW_GET_FUN(__glewSecondaryColor3b) +#define glSecondaryColor3bv GLEW_GET_FUN(__glewSecondaryColor3bv) +#define glSecondaryColor3d GLEW_GET_FUN(__glewSecondaryColor3d) +#define glSecondaryColor3dv GLEW_GET_FUN(__glewSecondaryColor3dv) +#define glSecondaryColor3f GLEW_GET_FUN(__glewSecondaryColor3f) +#define glSecondaryColor3fv GLEW_GET_FUN(__glewSecondaryColor3fv) +#define glSecondaryColor3i GLEW_GET_FUN(__glewSecondaryColor3i) +#define glSecondaryColor3iv GLEW_GET_FUN(__glewSecondaryColor3iv) +#define glSecondaryColor3s GLEW_GET_FUN(__glewSecondaryColor3s) +#define glSecondaryColor3sv GLEW_GET_FUN(__glewSecondaryColor3sv) +#define glSecondaryColor3ub GLEW_GET_FUN(__glewSecondaryColor3ub) +#define glSecondaryColor3ubv GLEW_GET_FUN(__glewSecondaryColor3ubv) +#define glSecondaryColor3ui GLEW_GET_FUN(__glewSecondaryColor3ui) +#define glSecondaryColor3uiv GLEW_GET_FUN(__glewSecondaryColor3uiv) +#define glSecondaryColor3us GLEW_GET_FUN(__glewSecondaryColor3us) +#define glSecondaryColor3usv GLEW_GET_FUN(__glewSecondaryColor3usv) +#define glSecondaryColorPointer GLEW_GET_FUN(__glewSecondaryColorPointer) +#define glWindowPos2d GLEW_GET_FUN(__glewWindowPos2d) +#define glWindowPos2dv GLEW_GET_FUN(__glewWindowPos2dv) +#define glWindowPos2f GLEW_GET_FUN(__glewWindowPos2f) +#define glWindowPos2fv GLEW_GET_FUN(__glewWindowPos2fv) +#define glWindowPos2i GLEW_GET_FUN(__glewWindowPos2i) +#define glWindowPos2iv GLEW_GET_FUN(__glewWindowPos2iv) +#define glWindowPos2s GLEW_GET_FUN(__glewWindowPos2s) +#define glWindowPos2sv GLEW_GET_FUN(__glewWindowPos2sv) +#define glWindowPos3d GLEW_GET_FUN(__glewWindowPos3d) +#define glWindowPos3dv GLEW_GET_FUN(__glewWindowPos3dv) +#define glWindowPos3f GLEW_GET_FUN(__glewWindowPos3f) +#define glWindowPos3fv GLEW_GET_FUN(__glewWindowPos3fv) +#define glWindowPos3i GLEW_GET_FUN(__glewWindowPos3i) +#define glWindowPos3iv GLEW_GET_FUN(__glewWindowPos3iv) +#define glWindowPos3s GLEW_GET_FUN(__glewWindowPos3s) +#define glWindowPos3sv GLEW_GET_FUN(__glewWindowPos3sv) + +#define GLEW_VERSION_1_4 GLEW_GET_VAR(__GLEW_VERSION_1_4) + +#endif /* GL_VERSION_1_4 */ + +/* ----------------------------- GL_VERSION_1_5 ---------------------------- */ + +#ifndef GL_VERSION_1_5 +#define GL_VERSION_1_5 1 + +#define GL_FOG_COORD_SRC GL_FOG_COORDINATE_SOURCE +#define GL_FOG_COORD GL_FOG_COORDINATE +#define GL_FOG_COORD_ARRAY GL_FOG_COORDINATE_ARRAY +#define GL_SRC0_RGB GL_SOURCE0_RGB +#define GL_FOG_COORD_ARRAY_POINTER GL_FOG_COORDINATE_ARRAY_POINTER +#define GL_FOG_COORD_ARRAY_TYPE GL_FOG_COORDINATE_ARRAY_TYPE +#define GL_SRC1_ALPHA GL_SOURCE1_ALPHA +#define GL_CURRENT_FOG_COORD GL_CURRENT_FOG_COORDINATE +#define GL_FOG_COORD_ARRAY_STRIDE GL_FOG_COORDINATE_ARRAY_STRIDE +#define GL_SRC0_ALPHA GL_SOURCE0_ALPHA +#define GL_SRC1_RGB GL_SOURCE1_RGB +#define GL_FOG_COORD_ARRAY_BUFFER_BINDING GL_FOG_COORDINATE_ARRAY_BUFFER_BINDING +#define GL_SRC2_ALPHA GL_SOURCE2_ALPHA +#define GL_SRC2_RGB GL_SOURCE2_RGB +#define GL_BUFFER_SIZE 0x8764 +#define GL_BUFFER_USAGE 0x8765 +#define GL_QUERY_COUNTER_BITS 0x8864 +#define GL_CURRENT_QUERY 0x8865 +#define GL_QUERY_RESULT 0x8866 +#define GL_QUERY_RESULT_AVAILABLE 0x8867 +#define GL_ARRAY_BUFFER 0x8892 +#define GL_ELEMENT_ARRAY_BUFFER 0x8893 +#define GL_ARRAY_BUFFER_BINDING 0x8894 +#define GL_ELEMENT_ARRAY_BUFFER_BINDING 0x8895 +#define GL_VERTEX_ARRAY_BUFFER_BINDING 0x8896 +#define GL_NORMAL_ARRAY_BUFFER_BINDING 0x8897 +#define GL_COLOR_ARRAY_BUFFER_BINDING 0x8898 +#define GL_INDEX_ARRAY_BUFFER_BINDING 0x8899 +#define GL_TEXTURE_COORD_ARRAY_BUFFER_BINDING 0x889A +#define GL_EDGE_FLAG_ARRAY_BUFFER_BINDING 0x889B +#define GL_SECONDARY_COLOR_ARRAY_BUFFER_BINDING 0x889C +#define GL_FOG_COORDINATE_ARRAY_BUFFER_BINDING 0x889D +#define GL_WEIGHT_ARRAY_BUFFER_BINDING 0x889E +#define GL_VERTEX_ATTRIB_ARRAY_BUFFER_BINDING 0x889F +#define GL_READ_ONLY 0x88B8 +#define GL_WRITE_ONLY 0x88B9 +#define GL_READ_WRITE 0x88BA +#define GL_BUFFER_ACCESS 0x88BB +#define GL_BUFFER_MAPPED 0x88BC +#define GL_BUFFER_MAP_POINTER 0x88BD +#define GL_STREAM_DRAW 0x88E0 +#define GL_STREAM_READ 0x88E1 +#define GL_STREAM_COPY 0x88E2 +#define GL_STATIC_DRAW 0x88E4 +#define GL_STATIC_READ 0x88E5 +#define GL_STATIC_COPY 0x88E6 +#define GL_DYNAMIC_DRAW 0x88E8 +#define GL_DYNAMIC_READ 0x88E9 +#define GL_DYNAMIC_COPY 0x88EA +#define GL_SAMPLES_PASSED 0x8914 + +//typedef ptrdiff_t GLsizeiptr; +//typedef ptrdiff_t GLintptr; +typedef unsigned int GLsizeiptr; +typedef unsigned int GLintptr; + +typedef void (GLAPIENTRY * PFNGLBEGINQUERYPROC) (GLenum target, GLuint id); +typedef void (GLAPIENTRY * PFNGLBINDBUFFERPROC) (GLenum target, GLuint buffer); +typedef void (GLAPIENTRY * PFNGLBUFFERDATAPROC) (GLenum target, GLsizeiptr size, const GLvoid* data, GLenum usage); +typedef void (GLAPIENTRY * PFNGLBUFFERSUBDATAPROC) (GLenum target, GLintptr offset, GLsizeiptr size, const GLvoid* data); +typedef void (GLAPIENTRY * PFNGLDELETEBUFFERSPROC) (GLsizei n, const GLuint* buffers); +typedef void (GLAPIENTRY * PFNGLDELETEQUERIESPROC) (GLsizei n, const GLuint* ids); +typedef void (GLAPIENTRY * PFNGLENDQUERYPROC) (GLenum target); +typedef void (GLAPIENTRY * PFNGLGENBUFFERSPROC) (GLsizei n, GLuint* buffers); +typedef void (GLAPIENTRY * PFNGLGENQUERIESPROC) (GLsizei n, GLuint* ids); +typedef void (GLAPIENTRY * PFNGLGETBUFFERPARAMETERIVPROC) (GLenum target, GLenum pname, GLint* params); +typedef void (GLAPIENTRY * PFNGLGETBUFFERPOINTERVPROC) (GLenum target, GLenum pname, GLvoid** params); +typedef void (GLAPIENTRY * PFNGLGETBUFFERSUBDATAPROC) (GLenum target, GLintptr offset, GLsizeiptr size, GLvoid* data); +typedef void (GLAPIENTRY * PFNGLGETQUERYOBJECTIVPROC) (GLuint id, GLenum pname, GLint* params); +typedef void (GLAPIENTRY * PFNGLGETQUERYOBJECTUIVPROC) (GLuint id, GLenum pname, GLuint* params); +typedef void (GLAPIENTRY * PFNGLGETQUERYIVPROC) (GLenum target, GLenum pname, GLint* params); +typedef GLboolean (GLAPIENTRY * PFNGLISBUFFERPROC) (GLuint buffer); +typedef GLboolean (GLAPIENTRY * PFNGLISQUERYPROC) (GLuint id); +typedef GLvoid* (GLAPIENTRY * PFNGLMAPBUFFERPROC) (GLenum target, GLenum access); +typedef GLboolean (GLAPIENTRY * PFNGLUNMAPBUFFERPROC) (GLenum target); + +#define glBeginQuery GLEW_GET_FUN(__glewBeginQuery) +#define glBindBuffer GLEW_GET_FUN(__glewBindBuffer) +#define glBufferData GLEW_GET_FUN(__glewBufferData) +#define glBufferSubData GLEW_GET_FUN(__glewBufferSubData) +#define glDeleteBuffers GLEW_GET_FUN(__glewDeleteBuffers) +#define glDeleteQueries GLEW_GET_FUN(__glewDeleteQueries) +#define glEndQuery GLEW_GET_FUN(__glewEndQuery) +#define glGenBuffers GLEW_GET_FUN(__glewGenBuffers) +#define glGenQueries GLEW_GET_FUN(__glewGenQueries) +#define glGetBufferParameteriv GLEW_GET_FUN(__glewGetBufferParameteriv) +#define glGetBufferPointerv GLEW_GET_FUN(__glewGetBufferPointerv) +#define glGetBufferSubData GLEW_GET_FUN(__glewGetBufferSubData) +#define glGetQueryObjectiv GLEW_GET_FUN(__glewGetQueryObjectiv) +#define glGetQueryObjectuiv GLEW_GET_FUN(__glewGetQueryObjectuiv) +#define glGetQueryiv GLEW_GET_FUN(__glewGetQueryiv) +#define glIsBuffer GLEW_GET_FUN(__glewIsBuffer) +#define glIsQuery GLEW_GET_FUN(__glewIsQuery) +#define glMapBuffer GLEW_GET_FUN(__glewMapBuffer) +#define glUnmapBuffer GLEW_GET_FUN(__glewUnmapBuffer) + +#define GLEW_VERSION_1_5 GLEW_GET_VAR(__GLEW_VERSION_1_5) + +#endif /* GL_VERSION_1_5 */ + +/* ----------------------------- GL_VERSION_2_0 ---------------------------- */ + +#ifndef GL_VERSION_2_0 +#define GL_VERSION_2_0 1 + +#define GL_BLEND_EQUATION_RGB GL_BLEND_EQUATION +#define GL_VERTEX_ATTRIB_ARRAY_ENABLED 0x8622 +#define GL_VERTEX_ATTRIB_ARRAY_SIZE 0x8623 +#define GL_VERTEX_ATTRIB_ARRAY_STRIDE 0x8624 +#define GL_VERTEX_ATTRIB_ARRAY_TYPE 0x8625 +#define GL_CURRENT_VERTEX_ATTRIB 0x8626 +#define GL_VERTEX_PROGRAM_POINT_SIZE 0x8642 +#define GL_VERTEX_PROGRAM_TWO_SIDE 0x8643 +#define GL_VERTEX_ATTRIB_ARRAY_POINTER 0x8645 +#define GL_STENCIL_BACK_FUNC 0x8800 +#define GL_STENCIL_BACK_FAIL 0x8801 +#define GL_STENCIL_BACK_PASS_DEPTH_FAIL 0x8802 +#define GL_STENCIL_BACK_PASS_DEPTH_PASS 0x8803 +#define GL_MAX_DRAW_BUFFERS 0x8824 +#define GL_DRAW_BUFFER0 0x8825 +#define GL_DRAW_BUFFER1 0x8826 +#define GL_DRAW_BUFFER2 0x8827 +#define GL_DRAW_BUFFER3 0x8828 +#define GL_DRAW_BUFFER4 0x8829 +#define GL_DRAW_BUFFER5 0x882A +#define GL_DRAW_BUFFER6 0x882B +#define GL_DRAW_BUFFER7 0x882C +#define GL_DRAW_BUFFER8 0x882D +#define GL_DRAW_BUFFER9 0x882E +#define GL_DRAW_BUFFER10 0x882F +#define GL_DRAW_BUFFER11 0x8830 +#define GL_DRAW_BUFFER12 0x8831 +#define GL_DRAW_BUFFER13 0x8832 +#define GL_DRAW_BUFFER14 0x8833 +#define GL_DRAW_BUFFER15 0x8834 +#define GL_BLEND_EQUATION_ALPHA 0x883D +#define GL_POINT_SPRITE 0x8861 +#define GL_COORD_REPLACE 0x8862 +#define GL_MAX_VERTEX_ATTRIBS 0x8869 +#define GL_VERTEX_ATTRIB_ARRAY_NORMALIZED 0x886A +#define GL_MAX_TEXTURE_COORDS 0x8871 +#define GL_MAX_TEXTURE_IMAGE_UNITS 0x8872 +#define GL_FRAGMENT_SHADER 0x8B30 +#define GL_VERTEX_SHADER 0x8B31 +#define GL_MAX_FRAGMENT_UNIFORM_COMPONENTS 0x8B49 +#define GL_MAX_VERTEX_UNIFORM_COMPONENTS 0x8B4A +#define GL_MAX_VARYING_FLOATS 0x8B4B +#define GL_MAX_VERTEX_TEXTURE_IMAGE_UNITS 0x8B4C +#define GL_MAX_COMBINED_TEXTURE_IMAGE_UNITS 0x8B4D +#define GL_SHADER_TYPE 0x8B4F +#define GL_FLOAT_VEC2 0x8B50 +#define GL_FLOAT_VEC3 0x8B51 +#define GL_FLOAT_VEC4 0x8B52 +#define GL_INT_VEC2 0x8B53 +#define GL_INT_VEC3 0x8B54 +#define GL_INT_VEC4 0x8B55 +#define GL_BOOL 0x8B56 +#define GL_BOOL_VEC2 0x8B57 +#define GL_BOOL_VEC3 0x8B58 +#define GL_BOOL_VEC4 0x8B59 +#define GL_FLOAT_MAT2 0x8B5A +#define GL_FLOAT_MAT3 0x8B5B +#define GL_FLOAT_MAT4 0x8B5C +#define GL_SAMPLER_1D 0x8B5D +#define GL_SAMPLER_2D 0x8B5E +#define GL_SAMPLER_3D 0x8B5F +#define GL_SAMPLER_CUBE 0x8B60 +#define GL_SAMPLER_1D_SHADOW 0x8B61 +#define GL_SAMPLER_2D_SHADOW 0x8B62 +#define GL_DELETE_STATUS 0x8B80 +#define GL_COMPILE_STATUS 0x8B81 +#define GL_LINK_STATUS 0x8B82 +#define GL_VALIDATE_STATUS 0x8B83 +#define GL_INFO_LOG_LENGTH 0x8B84 +#define GL_ATTACHED_SHADERS 0x8B85 +#define GL_ACTIVE_UNIFORMS 0x8B86 +#define GL_ACTIVE_UNIFORM_MAX_LENGTH 0x8B87 +#define GL_SHADER_SOURCE_LENGTH 0x8B88 +#define GL_ACTIVE_ATTRIBUTES 0x8B89 +#define GL_ACTIVE_ATTRIBUTE_MAX_LENGTH 0x8B8A +#define GL_FRAGMENT_SHADER_DERIVATIVE_HINT 0x8B8B +#define GL_SHADING_LANGUAGE_VERSION 0x8B8C +#define GL_CURRENT_PROGRAM 0x8B8D +#define GL_POINT_SPRITE_COORD_ORIGIN 0x8CA0 +#define GL_LOWER_LEFT 0x8CA1 +#define GL_UPPER_LEFT 0x8CA2 +#define GL_STENCIL_BACK_REF 0x8CA3 +#define GL_STENCIL_BACK_VALUE_MASK 0x8CA4 +#define GL_STENCIL_BACK_WRITEMASK 0x8CA5 + +typedef char GLchar; + +typedef void (GLAPIENTRY * PFNGLATTACHSHADERPROC) (GLuint program, GLuint shader); +typedef void (GLAPIENTRY * PFNGLBINDATTRIBLOCATIONPROC) (GLuint program, GLuint index, const GLchar* name); +typedef void (GLAPIENTRY * PFNGLBLENDEQUATIONSEPARATEPROC) (GLenum, GLenum); +typedef void (GLAPIENTRY * PFNGLCOMPILESHADERPROC) (GLuint shader); +typedef GLuint (GLAPIENTRY * PFNGLCREATEPROGRAMPROC) (void); +typedef GLuint (GLAPIENTRY * PFNGLCREATESHADERPROC) (GLenum type); +typedef void (GLAPIENTRY * PFNGLDELETEPROGRAMPROC) (GLuint program); +typedef void (GLAPIENTRY * PFNGLDELETESHADERPROC) (GLuint shader); +typedef void (GLAPIENTRY * PFNGLDETACHSHADERPROC) (GLuint program, GLuint shader); +typedef void (GLAPIENTRY * PFNGLDISABLEVERTEXATTRIBARRAYPROC) (GLuint); +typedef void (GLAPIENTRY * PFNGLDRAWBUFFERSPROC) (GLsizei n, const GLenum* bufs); +typedef void (GLAPIENTRY * PFNGLENABLEVERTEXATTRIBARRAYPROC) (GLuint); +typedef void (GLAPIENTRY * PFNGLGETACTIVEATTRIBPROC) (GLuint program, GLuint index, GLsizei maxLength, GLsizei* length, GLint* size, GLenum* type, GLchar* name); +typedef void (GLAPIENTRY * PFNGLGETACTIVEUNIFORMPROC) (GLuint program, GLuint index, GLsizei maxLength, GLsizei* length, GLint* size, GLenum* type, GLchar* name); +typedef void (GLAPIENTRY * PFNGLGETATTACHEDSHADERSPROC) (GLuint program, GLsizei maxCount, GLsizei* count, GLuint* shaders); +typedef GLint (GLAPIENTRY * PFNGLGETATTRIBLOCATIONPROC) (GLuint program, const GLchar* name); +typedef void (GLAPIENTRY * PFNGLGETPROGRAMINFOLOGPROC) (GLuint program, GLsizei bufSize, GLsizei* length, GLchar* infoLog); +typedef void (GLAPIENTRY * PFNGLGETPROGRAMIVPROC) (GLuint program, GLenum pname, GLint* param); +typedef void (GLAPIENTRY * PFNGLGETSHADERINFOLOGPROC) (GLuint shader, GLsizei bufSize, GLsizei* length, GLchar* infoLog); +typedef void (GLAPIENTRY * PFNGLGETSHADERSOURCEPROC) (GLint obj, GLsizei maxLength, GLsizei* length, GLchar* source); +typedef void (GLAPIENTRY * PFNGLGETSHADERIVPROC) (GLuint shader, GLenum pname, GLint* param); +typedef GLint (GLAPIENTRY * PFNGLGETUNIFORMLOCATIONPROC) (GLuint program, const GLchar* name); +typedef void (GLAPIENTRY * PFNGLGETUNIFORMFVPROC) (GLuint program, GLint location, GLfloat* params); +typedef void (GLAPIENTRY * PFNGLGETUNIFORMIVPROC) (GLuint program, GLint location, GLint* params); +typedef void (GLAPIENTRY * PFNGLGETVERTEXATTRIBPOINTERVPROC) (GLuint, GLenum, GLvoid*); +typedef void (GLAPIENTRY * PFNGLGETVERTEXATTRIBDVPROC) (GLuint, GLenum, GLdouble*); +typedef void (GLAPIENTRY * PFNGLGETVERTEXATTRIBFVPROC) (GLuint, GLenum, GLfloat*); +typedef void (GLAPIENTRY * PFNGLGETVERTEXATTRIBIVPROC) (GLuint, GLenum, GLint*); +typedef GLboolean (GLAPIENTRY * PFNGLISPROGRAMPROC) (GLuint program); +typedef GLboolean (GLAPIENTRY * PFNGLISSHADERPROC) (GLuint shader); +typedef void (GLAPIENTRY * PFNGLLINKPROGRAMPROC) (GLuint program); +typedef void (GLAPIENTRY * PFNGLSHADERSOURCEPROC) (GLuint shader, GLsizei count, const GLchar** strings, const GLint* lengths); +typedef void (GLAPIENTRY * PFNGLSTENCILFUNCSEPARATEPROC) (GLenum frontfunc, GLenum backfunc, GLint ref, GLuint mask); +typedef void (GLAPIENTRY * PFNGLSTENCILMASKSEPARATEPROC) (GLenum, GLuint); +typedef void (GLAPIENTRY * PFNGLSTENCILOPSEPARATEPROC) (GLenum face, GLenum sfail, GLenum dpfail, GLenum dppass); +typedef void (GLAPIENTRY * PFNGLUNIFORM1FPROC) (GLint location, GLfloat v0); +typedef void (GLAPIENTRY * PFNGLUNIFORM1FVPROC) (GLint location, GLsizei count, const GLfloat* value); +typedef void (GLAPIENTRY * PFNGLUNIFORM1IPROC) (GLint location, GLint v0); +typedef void (GLAPIENTRY * PFNGLUNIFORM1IVPROC) (GLint location, GLsizei count, const GLint* value); +typedef void (GLAPIENTRY * PFNGLUNIFORM2FPROC) (GLint location, GLfloat v0, GLfloat v1); +typedef void (GLAPIENTRY * PFNGLUNIFORM2FVPROC) (GLint location, GLsizei count, const GLfloat* value); +typedef void (GLAPIENTRY * PFNGLUNIFORM2IPROC) (GLint location, GLint v0, GLint v1); +typedef void (GLAPIENTRY * PFNGLUNIFORM2IVPROC) (GLint location, GLsizei count, const GLint* value); +typedef void (GLAPIENTRY * PFNGLUNIFORM3FPROC) (GLint location, GLfloat v0, GLfloat v1, GLfloat v2); +typedef void (GLAPIENTRY * PFNGLUNIFORM3FVPROC) (GLint location, GLsizei count, const GLfloat* value); +typedef void (GLAPIENTRY * PFNGLUNIFORM3IPROC) (GLint location, GLint v0, GLint v1, GLint v2); +typedef void (GLAPIENTRY * PFNGLUNIFORM3IVPROC) (GLint location, GLsizei count, const GLint* value); +typedef void (GLAPIENTRY * PFNGLUNIFORM4FPROC) (GLint location, GLfloat v0, GLfloat v1, GLfloat v2, GLfloat v3); +typedef void (GLAPIENTRY * PFNGLUNIFORM4FVPROC) (GLint location, GLsizei count, const GLfloat* value); +typedef void (GLAPIENTRY * PFNGLUNIFORM4IPROC) (GLint location, GLint v0, GLint v1, GLint v2, GLint v3); +typedef void (GLAPIENTRY * PFNGLUNIFORM4IVPROC) (GLint location, GLsizei count, const GLint* value); +typedef void (GLAPIENTRY * PFNGLUNIFORMMATRIX2FVPROC) (GLint location, GLsizei count, GLboolean transpose, const GLfloat* value); +typedef void (GLAPIENTRY * PFNGLUNIFORMMATRIX3FVPROC) (GLint location, GLsizei count, GLboolean transpose, const GLfloat* value); +typedef void (GLAPIENTRY * PFNGLUNIFORMMATRIX4FVPROC) (GLint location, GLsizei count, GLboolean transpose, const GLfloat* value); +typedef void (GLAPIENTRY * PFNGLUSEPROGRAMPROC) (GLuint program); +typedef void (GLAPIENTRY * PFNGLVALIDATEPROGRAMPROC) (GLuint program); +typedef void (GLAPIENTRY * PFNGLVERTEXATTRIB1DPROC) (GLuint index, GLdouble x); +typedef void (GLAPIENTRY * PFNGLVERTEXATTRIB1DVPROC) (GLuint index, const GLdouble* v); +typedef void (GLAPIENTRY * PFNGLVERTEXATTRIB1FPROC) (GLuint index, GLfloat x); +typedef void (GLAPIENTRY * PFNGLVERTEXATTRIB1FVPROC) (GLuint index, const GLfloat* v); +typedef void (GLAPIENTRY * PFNGLVERTEXATTRIB1SPROC) (GLuint index, GLshort x); +typedef void (GLAPIENTRY * PFNGLVERTEXATTRIB1SVPROC) (GLuint index, const GLshort* v); +typedef void (GLAPIENTRY * PFNGLVERTEXATTRIB2DPROC) (GLuint index, GLdouble x, GLdouble y); +typedef void (GLAPIENTRY * PFNGLVERTEXATTRIB2DVPROC) (GLuint index, const GLdouble* v); +typedef void (GLAPIENTRY * PFNGLVERTEXATTRIB2FPROC) (GLuint index, GLfloat x, GLfloat y); +typedef void (GLAPIENTRY * PFNGLVERTEXATTRIB2FVPROC) (GLuint index, const GLfloat* v); +typedef void (GLAPIENTRY * PFNGLVERTEXATTRIB2SPROC) (GLuint index, GLshort x, GLshort y); +typedef void (GLAPIENTRY * PFNGLVERTEXATTRIB2SVPROC) (GLuint index, const GLshort* v); +typedef void (GLAPIENTRY * PFNGLVERTEXATTRIB3DPROC) (GLuint index, GLdouble x, GLdouble y, GLdouble z); +typedef void (GLAPIENTRY * PFNGLVERTEXATTRIB3DVPROC) (GLuint index, const GLdouble* v); +typedef void (GLAPIENTRY * PFNGLVERTEXATTRIB3FPROC) (GLuint index, GLfloat x, GLfloat y, GLfloat z); +typedef void (GLAPIENTRY * PFNGLVERTEXATTRIB3FVPROC) (GLuint index, const GLfloat* v); +typedef void (GLAPIENTRY * PFNGLVERTEXATTRIB3SPROC) (GLuint index, GLshort x, GLshort y, GLshort z); +typedef void (GLAPIENTRY * PFNGLVERTEXATTRIB3SVPROC) (GLuint index, const GLshort* v); +typedef void (GLAPIENTRY * PFNGLVERTEXATTRIB4NBVPROC) (GLuint index, const GLbyte* v); +typedef void (GLAPIENTRY * PFNGLVERTEXATTRIB4NIVPROC) (GLuint index, const GLint* v); +typedef void (GLAPIENTRY * PFNGLVERTEXATTRIB4NSVPROC) (GLuint index, const GLshort* v); +typedef void (GLAPIENTRY * PFNGLVERTEXATTRIB4NUBPROC) (GLuint index, GLubyte x, GLubyte y, GLubyte z, GLubyte w); +typedef void (GLAPIENTRY * PFNGLVERTEXATTRIB4NUBVPROC) (GLuint index, const GLubyte* v); +typedef void (GLAPIENTRY * PFNGLVERTEXATTRIB4NUIVPROC) (GLuint index, const GLuint* v); +typedef void (GLAPIENTRY * PFNGLVERTEXATTRIB4NUSVPROC) (GLuint index, const GLushort* v); +typedef void (GLAPIENTRY * PFNGLVERTEXATTRIB4BVPROC) (GLuint index, const GLbyte* v); +typedef void (GLAPIENTRY * PFNGLVERTEXATTRIB4DPROC) (GLuint index, GLdouble x, GLdouble y, GLdouble z, GLdouble w); +typedef void (GLAPIENTRY * PFNGLVERTEXATTRIB4DVPROC) (GLuint index, const GLdouble* v); +typedef void (GLAPIENTRY * PFNGLVERTEXATTRIB4FPROC) (GLuint index, GLfloat x, GLfloat y, GLfloat z, GLfloat w); +typedef void (GLAPIENTRY * PFNGLVERTEXATTRIB4FVPROC) (GLuint index, const GLfloat* v); +typedef void (GLAPIENTRY * PFNGLVERTEXATTRIB4IVPROC) (GLuint index, const GLint* v); +typedef void (GLAPIENTRY * PFNGLVERTEXATTRIB4SPROC) (GLuint index, GLshort x, GLshort y, GLshort z, GLshort w); +typedef void (GLAPIENTRY * PFNGLVERTEXATTRIB4SVPROC) (GLuint index, const GLshort* v); +typedef void (GLAPIENTRY * PFNGLVERTEXATTRIB4UBVPROC) (GLuint index, const GLubyte* v); +typedef void (GLAPIENTRY * PFNGLVERTEXATTRIB4UIVPROC) (GLuint index, const GLuint* v); +typedef void (GLAPIENTRY * PFNGLVERTEXATTRIB4USVPROC) (GLuint index, const GLushort* v); +typedef void (GLAPIENTRY * PFNGLVERTEXATTRIBPOINTERPROC) (GLuint index, GLint size, GLenum type, GLboolean normalized, GLsizei stride, const GLvoid* pointer); + +#define glAttachShader GLEW_GET_FUN(__glewAttachShader) +#define glBindAttribLocation GLEW_GET_FUN(__glewBindAttribLocation) +#define glBlendEquationSeparate GLEW_GET_FUN(__glewBlendEquationSeparate) +#define glCompileShader GLEW_GET_FUN(__glewCompileShader) +#define glCreateProgram GLEW_GET_FUN(__glewCreateProgram) +#define glCreateShader GLEW_GET_FUN(__glewCreateShader) +#define glDeleteProgram GLEW_GET_FUN(__glewDeleteProgram) +#define glDeleteShader GLEW_GET_FUN(__glewDeleteShader) +#define glDetachShader GLEW_GET_FUN(__glewDetachShader) +#define glDisableVertexAttribArray GLEW_GET_FUN(__glewDisableVertexAttribArray) +#define glDrawBuffers GLEW_GET_FUN(__glewDrawBuffers) +#define glEnableVertexAttribArray GLEW_GET_FUN(__glewEnableVertexAttribArray) +#define glGetActiveAttrib GLEW_GET_FUN(__glewGetActiveAttrib) +#define glGetActiveUniform GLEW_GET_FUN(__glewGetActiveUniform) +#define glGetAttachedShaders GLEW_GET_FUN(__glewGetAttachedShaders) +#define glGetAttribLocation GLEW_GET_FUN(__glewGetAttribLocation) +#define glGetProgramInfoLog GLEW_GET_FUN(__glewGetProgramInfoLog) +#define glGetProgramiv GLEW_GET_FUN(__glewGetProgramiv) +#define glGetShaderInfoLog GLEW_GET_FUN(__glewGetShaderInfoLog) +#define glGetShaderSource GLEW_GET_FUN(__glewGetShaderSource) +#define glGetShaderiv GLEW_GET_FUN(__glewGetShaderiv) +#define glGetUniformLocation GLEW_GET_FUN(__glewGetUniformLocation) +#define glGetUniformfv GLEW_GET_FUN(__glewGetUniformfv) +#define glGetUniformiv GLEW_GET_FUN(__glewGetUniformiv) +#define glGetVertexAttribPointerv GLEW_GET_FUN(__glewGetVertexAttribPointerv) +#define glGetVertexAttribdv GLEW_GET_FUN(__glewGetVertexAttribdv) +#define glGetVertexAttribfv GLEW_GET_FUN(__glewGetVertexAttribfv) +#define glGetVertexAttribiv GLEW_GET_FUN(__glewGetVertexAttribiv) +#define glIsProgram GLEW_GET_FUN(__glewIsProgram) +#define glIsShader GLEW_GET_FUN(__glewIsShader) +#define glLinkProgram GLEW_GET_FUN(__glewLinkProgram) +#define glShaderSource GLEW_GET_FUN(__glewShaderSource) +#define glStencilFuncSeparate GLEW_GET_FUN(__glewStencilFuncSeparate) +#define glStencilMaskSeparate GLEW_GET_FUN(__glewStencilMaskSeparate) +#define glStencilOpSeparate GLEW_GET_FUN(__glewStencilOpSeparate) +#define glUniform1f GLEW_GET_FUN(__glewUniform1f) +#define glUniform1fv GLEW_GET_FUN(__glewUniform1fv) +#define glUniform1i GLEW_GET_FUN(__glewUniform1i) +#define glUniform1iv GLEW_GET_FUN(__glewUniform1iv) +#define glUniform2f GLEW_GET_FUN(__glewUniform2f) +#define glUniform2fv GLEW_GET_FUN(__glewUniform2fv) +#define glUniform2i GLEW_GET_FUN(__glewUniform2i) +#define glUniform2iv GLEW_GET_FUN(__glewUniform2iv) +#define glUniform3f GLEW_GET_FUN(__glewUniform3f) +#define glUniform3fv GLEW_GET_FUN(__glewUniform3fv) +#define glUniform3i GLEW_GET_FUN(__glewUniform3i) +#define glUniform3iv GLEW_GET_FUN(__glewUniform3iv) +#define glUniform4f GLEW_GET_FUN(__glewUniform4f) +#define glUniform4fv GLEW_GET_FUN(__glewUniform4fv) +#define glUniform4i GLEW_GET_FUN(__glewUniform4i) +#define glUniform4iv GLEW_GET_FUN(__glewUniform4iv) +#define glUniformMatrix2fv GLEW_GET_FUN(__glewUniformMatrix2fv) +#define glUniformMatrix3fv GLEW_GET_FUN(__glewUniformMatrix3fv) +#define glUniformMatrix4fv GLEW_GET_FUN(__glewUniformMatrix4fv) +#define glUseProgram GLEW_GET_FUN(__glewUseProgram) +#define glValidateProgram GLEW_GET_FUN(__glewValidateProgram) +#define glVertexAttrib1d GLEW_GET_FUN(__glewVertexAttrib1d) +#define glVertexAttrib1dv GLEW_GET_FUN(__glewVertexAttrib1dv) +#define glVertexAttrib1f GLEW_GET_FUN(__glewVertexAttrib1f) +#define glVertexAttrib1fv GLEW_GET_FUN(__glewVertexAttrib1fv) +#define glVertexAttrib1s GLEW_GET_FUN(__glewVertexAttrib1s) +#define glVertexAttrib1sv GLEW_GET_FUN(__glewVertexAttrib1sv) +#define glVertexAttrib2d GLEW_GET_FUN(__glewVertexAttrib2d) +#define glVertexAttrib2dv GLEW_GET_FUN(__glewVertexAttrib2dv) +#define glVertexAttrib2f GLEW_GET_FUN(__glewVertexAttrib2f) +#define glVertexAttrib2fv GLEW_GET_FUN(__glewVertexAttrib2fv) +#define glVertexAttrib2s GLEW_GET_FUN(__glewVertexAttrib2s) +#define glVertexAttrib2sv GLEW_GET_FUN(__glewVertexAttrib2sv) +#define glVertexAttrib3d GLEW_GET_FUN(__glewVertexAttrib3d) +#define glVertexAttrib3dv GLEW_GET_FUN(__glewVertexAttrib3dv) +#define glVertexAttrib3f GLEW_GET_FUN(__glewVertexAttrib3f) +#define glVertexAttrib3fv GLEW_GET_FUN(__glewVertexAttrib3fv) +#define glVertexAttrib3s GLEW_GET_FUN(__glewVertexAttrib3s) +#define glVertexAttrib3sv GLEW_GET_FUN(__glewVertexAttrib3sv) +#define glVertexAttrib4Nbv GLEW_GET_FUN(__glewVertexAttrib4Nbv) +#define glVertexAttrib4Niv GLEW_GET_FUN(__glewVertexAttrib4Niv) +#define glVertexAttrib4Nsv GLEW_GET_FUN(__glewVertexAttrib4Nsv) +#define glVertexAttrib4Nub GLEW_GET_FUN(__glewVertexAttrib4Nub) +#define glVertexAttrib4Nubv GLEW_GET_FUN(__glewVertexAttrib4Nubv) +#define glVertexAttrib4Nuiv GLEW_GET_FUN(__glewVertexAttrib4Nuiv) +#define glVertexAttrib4Nusv GLEW_GET_FUN(__glewVertexAttrib4Nusv) +#define glVertexAttrib4bv GLEW_GET_FUN(__glewVertexAttrib4bv) +#define glVertexAttrib4d GLEW_GET_FUN(__glewVertexAttrib4d) +#define glVertexAttrib4dv GLEW_GET_FUN(__glewVertexAttrib4dv) +#define glVertexAttrib4f GLEW_GET_FUN(__glewVertexAttrib4f) +#define glVertexAttrib4fv GLEW_GET_FUN(__glewVertexAttrib4fv) +#define glVertexAttrib4iv GLEW_GET_FUN(__glewVertexAttrib4iv) +#define glVertexAttrib4s GLEW_GET_FUN(__glewVertexAttrib4s) +#define glVertexAttrib4sv GLEW_GET_FUN(__glewVertexAttrib4sv) +#define glVertexAttrib4ubv GLEW_GET_FUN(__glewVertexAttrib4ubv) +#define glVertexAttrib4uiv GLEW_GET_FUN(__glewVertexAttrib4uiv) +#define glVertexAttrib4usv GLEW_GET_FUN(__glewVertexAttrib4usv) +#define glVertexAttribPointer GLEW_GET_FUN(__glewVertexAttribPointer) + +#define GLEW_VERSION_2_0 GLEW_GET_VAR(__GLEW_VERSION_2_0) + +#endif /* GL_VERSION_2_0 */ + +/* ----------------------------- GL_VERSION_2_1 ---------------------------- */ + +#ifndef GL_VERSION_2_1 +#define GL_VERSION_2_1 1 + +#define GL_CURRENT_RASTER_SECONDARY_COLOR 0x845F +#define GL_PIXEL_PACK_BUFFER 0x88EB +#define GL_PIXEL_UNPACK_BUFFER 0x88EC +#define GL_PIXEL_PACK_BUFFER_BINDING 0x88ED +#define GL_PIXEL_UNPACK_BUFFER_BINDING 0x88EF +#define GL_FLOAT_MAT2x3 0x8B65 +#define GL_FLOAT_MAT2x4 0x8B66 +#define GL_FLOAT_MAT3x2 0x8B67 +#define GL_FLOAT_MAT3x4 0x8B68 +#define GL_FLOAT_MAT4x2 0x8B69 +#define GL_FLOAT_MAT4x3 0x8B6A +#define GL_SRGB 0x8C40 +#define GL_SRGB8 0x8C41 +#define GL_SRGB_ALPHA 0x8C42 +#define GL_SRGB8_ALPHA8 0x8C43 +#define GL_SLUMINANCE_ALPHA 0x8C44 +#define GL_SLUMINANCE8_ALPHA8 0x8C45 +#define GL_SLUMINANCE 0x8C46 +#define GL_SLUMINANCE8 0x8C47 +#define GL_COMPRESSED_SRGB 0x8C48 +#define GL_COMPRESSED_SRGB_ALPHA 0x8C49 +#define GL_COMPRESSED_SLUMINANCE 0x8C4A +#define GL_COMPRESSED_SLUMINANCE_ALPHA 0x8C4B + +typedef void (GLAPIENTRY * PFNGLUNIFORMMATRIX2X3FVPROC) (GLint location, GLsizei count, GLboolean transpose, const GLfloat *value); +typedef void (GLAPIENTRY * PFNGLUNIFORMMATRIX2X4FVPROC) (GLint location, GLsizei count, GLboolean transpose, const GLfloat *value); +typedef void (GLAPIENTRY * PFNGLUNIFORMMATRIX3X2FVPROC) (GLint location, GLsizei count, GLboolean transpose, const GLfloat *value); +typedef void (GLAPIENTRY * PFNGLUNIFORMMATRIX3X4FVPROC) (GLint location, GLsizei count, GLboolean transpose, const GLfloat *value); +typedef void (GLAPIENTRY * PFNGLUNIFORMMATRIX4X2FVPROC) (GLint location, GLsizei count, GLboolean transpose, const GLfloat *value); +typedef void (GLAPIENTRY * PFNGLUNIFORMMATRIX4X3FVPROC) (GLint location, GLsizei count, GLboolean transpose, const GLfloat *value); + +#define glUniformMatrix2x3fv GLEW_GET_FUN(__glewUniformMatrix2x3fv) +#define glUniformMatrix2x4fv GLEW_GET_FUN(__glewUniformMatrix2x4fv) +#define glUniformMatrix3x2fv GLEW_GET_FUN(__glewUniformMatrix3x2fv) +#define glUniformMatrix3x4fv GLEW_GET_FUN(__glewUniformMatrix3x4fv) +#define glUniformMatrix4x2fv GLEW_GET_FUN(__glewUniformMatrix4x2fv) +#define glUniformMatrix4x3fv GLEW_GET_FUN(__glewUniformMatrix4x3fv) + +#define GLEW_VERSION_2_1 GLEW_GET_VAR(__GLEW_VERSION_2_1) + +#endif /* GL_VERSION_2_1 */ + +/* ----------------------------- GL_VERSION_3_0 ---------------------------- */ + +#ifndef GL_VERSION_3_0 +#define GL_VERSION_3_0 1 + +#define GL_MAX_CLIP_DISTANCES GL_MAX_CLIP_PLANES +#define GL_CLIP_DISTANCE5 GL_CLIP_PLANE5 +#define GL_CLIP_DISTANCE1 GL_CLIP_PLANE1 +#define GL_CLIP_DISTANCE3 GL_CLIP_PLANE3 +#define GL_COMPARE_REF_TO_TEXTURE GL_COMPARE_R_TO_TEXTURE_ARB +#define GL_CLIP_DISTANCE0 GL_CLIP_PLANE0 +#define GL_CLIP_DISTANCE4 GL_CLIP_PLANE4 +#define GL_CLIP_DISTANCE2 GL_CLIP_PLANE2 +#define GL_MAX_VARYING_COMPONENTS GL_MAX_VARYING_FLOATS +#define GL_CONTEXT_FLAG_FORWARD_COMPATIBLE_BIT 0x0001 +#define GL_MAJOR_VERSION 0x821B +#define GL_MINOR_VERSION 0x821C +#define GL_NUM_EXTENSIONS 0x821D +#define GL_CONTEXT_FLAGS 0x821E +#define GL_DEPTH_BUFFER 0x8223 +#define GL_STENCIL_BUFFER 0x8224 +#define GL_COMPRESSED_RED 0x8225 +#define GL_COMPRESSED_RG 0x8226 +#define GL_RGBA32F 0x8814 +#define GL_RGB32F 0x8815 +#define GL_RGBA16F 0x881A +#define GL_RGB16F 0x881B +#define GL_VERTEX_ATTRIB_ARRAY_INTEGER 0x88FD +#define GL_MAX_ARRAY_TEXTURE_LAYERS 0x88FF +#define GL_MIN_PROGRAM_TEXEL_OFFSET 0x8904 +#define GL_MAX_PROGRAM_TEXEL_OFFSET 0x8905 +#define GL_CLAMP_VERTEX_COLOR 0x891A +#define GL_CLAMP_FRAGMENT_COLOR 0x891B +#define GL_CLAMP_READ_COLOR 0x891C +#define GL_FIXED_ONLY 0x891D +#define GL_TEXTURE_RED_TYPE 0x8C10 +#define GL_TEXTURE_GREEN_TYPE 0x8C11 +#define GL_TEXTURE_BLUE_TYPE 0x8C12 +#define GL_TEXTURE_ALPHA_TYPE 0x8C13 +#define GL_TEXTURE_LUMINANCE_TYPE 0x8C14 +#define GL_TEXTURE_INTENSITY_TYPE 0x8C15 +#define GL_TEXTURE_DEPTH_TYPE 0x8C16 +#define GL_UNSIGNED_NORMALIZED 0x8C17 +#define GL_TEXTURE_1D_ARRAY 0x8C18 +#define GL_PROXY_TEXTURE_1D_ARRAY 0x8C19 +#define GL_TEXTURE_2D_ARRAY 0x8C1A +#define GL_PROXY_TEXTURE_2D_ARRAY 0x8C1B +#define GL_TEXTURE_BINDING_1D_ARRAY 0x8C1C +#define GL_TEXTURE_BINDING_2D_ARRAY 0x8C1D +#define GL_R11F_G11F_B10F 0x8C3A +#define GL_UNSIGNED_INT_10F_11F_11F_REV 0x8C3B +#define GL_RGB9_E5 0x8C3D +#define GL_UNSIGNED_INT_5_9_9_9_REV 0x8C3E +#define GL_TEXTURE_SHARED_SIZE 0x8C3F +#define GL_TRANSFORM_FEEDBACK_VARYING_MAX_LENGTH 0x8C76 +#define GL_TRANSFORM_FEEDBACK_BUFFER_MODE 0x8C7F +#define GL_MAX_TRANSFORM_FEEDBACK_SEPARATE_COMPONENTS 0x8C80 +#define GL_TRANSFORM_FEEDBACK_VARYINGS 0x8C83 +#define GL_TRANSFORM_FEEDBACK_BUFFER_START 0x8C84 +#define GL_TRANSFORM_FEEDBACK_BUFFER_SIZE 0x8C85 +#define GL_PRIMITIVES_GENERATED 0x8C87 +#define GL_TRANSFORM_FEEDBACK_PRIMITIVES_WRITTEN 0x8C88 +#define GL_RASTERIZER_DISCARD 0x8C89 +#define GL_MAX_TRANSFORM_FEEDBACK_INTERLEAVED_COMPONENTS 0x8C8A +#define GL_MAX_TRANSFORM_FEEDBACK_SEPARATE_ATTRIBS 0x8C8B +#define GL_INTERLEAVED_ATTRIBS 0x8C8C +#define GL_SEPARATE_ATTRIBS 0x8C8D +#define GL_TRANSFORM_FEEDBACK_BUFFER 0x8C8E +#define GL_TRANSFORM_FEEDBACK_BUFFER_BINDING 0x8C8F +#define GL_RGBA32UI 0x8D70 +#define GL_RGB32UI 0x8D71 +#define GL_RGBA16UI 0x8D76 +#define GL_RGB16UI 0x8D77 +#define GL_RGBA8UI 0x8D7C +#define GL_RGB8UI 0x8D7D +#define GL_RGBA32I 0x8D82 +#define GL_RGB32I 0x8D83 +#define GL_RGBA16I 0x8D88 +#define GL_RGB16I 0x8D89 +#define GL_RGBA8I 0x8D8E +#define GL_RGB8I 0x8D8F +#define GL_RED_INTEGER 0x8D94 +#define GL_GREEN_INTEGER 0x8D95 +#define GL_BLUE_INTEGER 0x8D96 +#define GL_ALPHA_INTEGER 0x8D97 +#define GL_RGB_INTEGER 0x8D98 +#define GL_RGBA_INTEGER 0x8D99 +#define GL_BGR_INTEGER 0x8D9A +#define GL_BGRA_INTEGER 0x8D9B +#define GL_SAMPLER_1D_ARRAY 0x8DC0 +#define GL_SAMPLER_2D_ARRAY 0x8DC1 +#define GL_SAMPLER_1D_ARRAY_SHADOW 0x8DC3 +#define GL_SAMPLER_2D_ARRAY_SHADOW 0x8DC4 +#define GL_SAMPLER_CUBE_SHADOW 0x8DC5 +#define GL_UNSIGNED_INT_VEC2 0x8DC6 +#define GL_UNSIGNED_INT_VEC3 0x8DC7 +#define GL_UNSIGNED_INT_VEC4 0x8DC8 +#define GL_INT_SAMPLER_1D 0x8DC9 +#define GL_INT_SAMPLER_2D 0x8DCA +#define GL_INT_SAMPLER_3D 0x8DCB +#define GL_INT_SAMPLER_CUBE 0x8DCC +#define GL_INT_SAMPLER_1D_ARRAY 0x8DCE +#define GL_INT_SAMPLER_2D_ARRAY 0x8DCF +#define GL_UNSIGNED_INT_SAMPLER_1D 0x8DD1 +#define GL_UNSIGNED_INT_SAMPLER_2D 0x8DD2 +#define GL_UNSIGNED_INT_SAMPLER_3D 0x8DD3 +#define GL_UNSIGNED_INT_SAMPLER_CUBE 0x8DD4 +#define GL_UNSIGNED_INT_SAMPLER_1D_ARRAY 0x8DD6 +#define GL_UNSIGNED_INT_SAMPLER_2D_ARRAY 0x8DD7 +#define GL_QUERY_WAIT 0x8E13 +#define GL_QUERY_NO_WAIT 0x8E14 +#define GL_QUERY_BY_REGION_WAIT 0x8E15 +#define GL_QUERY_BY_REGION_NO_WAIT 0x8E16 + +typedef void (GLAPIENTRY * PFNGLBEGINCONDITIONALRENDERPROC) (GLuint, GLenum); +typedef void (GLAPIENTRY * PFNGLBEGINTRANSFORMFEEDBACKPROC) (GLenum); +typedef void (GLAPIENTRY * PFNGLBINDBUFFERBASEPROC) (GLenum, GLuint, GLuint); +typedef void (GLAPIENTRY * PFNGLBINDBUFFERRANGEPROC) (GLenum, GLuint, GLuint, GLintptr, GLsizeiptr); +typedef void (GLAPIENTRY * PFNGLBINDFRAGDATALOCATIONPROC) (GLuint, GLuint, const GLchar*); +typedef void (GLAPIENTRY * PFNGLCLAMPCOLORPROC) (GLenum, GLenum); +typedef void (GLAPIENTRY * PFNGLCLEARBUFFERFIPROC) (GLenum, GLint, GLfloat, GLint); +typedef void (GLAPIENTRY * PFNGLCLEARBUFFERFVPROC) (GLenum, GLint, const GLfloat*); +typedef void (GLAPIENTRY * PFNGLCLEARBUFFERIVPROC) (GLenum, GLint, const GLint*); +typedef void (GLAPIENTRY * PFNGLCLEARBUFFERUIVPROC) (GLenum, GLint, const GLuint*); +typedef void (GLAPIENTRY * PFNGLCOLORMASKIPROC) (GLuint, GLboolean, GLboolean, GLboolean, GLboolean); +typedef void (GLAPIENTRY * PFNGLDISABLEIPROC) (GLenum, GLuint); +typedef void (GLAPIENTRY * PFNGLENABLEIPROC) (GLenum, GLuint); +typedef void (GLAPIENTRY * PFNGLENDCONDITIONALRENDERPROC) (void); +typedef void (GLAPIENTRY * PFNGLENDTRANSFORMFEEDBACKPROC) (void); +typedef void (GLAPIENTRY * PFNGLGETBOOLEANI_VPROC) (GLenum, GLuint, GLboolean*); +typedef GLint (GLAPIENTRY * PFNGLGETFRAGDATALOCATIONPROC) (GLuint, const GLchar*); +typedef void (GLAPIENTRY * PFNGLGETINTEGERI_VPROC) (GLenum, GLuint, GLint*); +typedef const GLubyte* (GLAPIENTRY * PFNGLGETSTRINGIPROC) (GLenum, GLuint); +typedef void (GLAPIENTRY * PFNGLGETTEXPARAMETERIIVPROC) (GLenum, GLenum, GLint*); +typedef void (GLAPIENTRY * PFNGLGETTEXPARAMETERIUIVPROC) (GLenum, GLenum, GLuint*); +typedef void (GLAPIENTRY * PFNGLGETTRANSFORMFEEDBACKVARYINGPROC) (GLuint, GLuint, GLint*); +typedef void (GLAPIENTRY * PFNGLGETUNIFORMUIVPROC) (GLuint, GLint, GLuint*); +typedef void (GLAPIENTRY * PFNGLGETVERTEXATTRIBIIVPROC) (GLuint, GLenum, GLint*); +typedef void (GLAPIENTRY * PFNGLGETVERTEXATTRIBIUIVPROC) (GLuint, GLenum, GLuint*); +typedef GLboolean (GLAPIENTRY * PFNGLISENABLEDIPROC) (GLenum, GLuint); +typedef void (GLAPIENTRY * PFNGLTEXPARAMETERIIVPROC) (GLenum, GLenum, const GLint*); +typedef void (GLAPIENTRY * PFNGLTEXPARAMETERIUIVPROC) (GLenum, GLenum, const GLuint*); +typedef void (GLAPIENTRY * PFNGLTRANSFORMFEEDBACKVARYINGSPROC) (GLuint, GLsizei, const GLint*, GLenum); +typedef void (GLAPIENTRY * PFNGLUNIFORM1UIPROC) (GLint, GLuint); +typedef void (GLAPIENTRY * PFNGLUNIFORM1UIVPROC) (GLint, GLsizei, const GLuint*); +typedef void (GLAPIENTRY * PFNGLUNIFORM2UIPROC) (GLint, GLuint, GLuint); +typedef void (GLAPIENTRY * PFNGLUNIFORM2UIVPROC) (GLint, GLsizei, const GLuint*); +typedef void (GLAPIENTRY * PFNGLUNIFORM3UIPROC) (GLint, GLuint, GLuint, GLuint); +typedef void (GLAPIENTRY * PFNGLUNIFORM3UIVPROC) (GLint, GLsizei, const GLuint*); +typedef void (GLAPIENTRY * PFNGLUNIFORM4UIPROC) (GLint, GLuint, GLuint, GLuint, GLuint); +typedef void (GLAPIENTRY * PFNGLUNIFORM4UIVPROC) (GLint, GLsizei, const GLuint*); +typedef void (GLAPIENTRY * PFNGLVERTEXATTRIBI1IPROC) (GLuint, GLint); +typedef void (GLAPIENTRY * PFNGLVERTEXATTRIBI1IVPROC) (GLuint, const GLint*); +typedef void (GLAPIENTRY * PFNGLVERTEXATTRIBI1UIPROC) (GLuint, GLuint); +typedef void (GLAPIENTRY * PFNGLVERTEXATTRIBI1UIVPROC) (GLuint, const GLuint*); +typedef void (GLAPIENTRY * PFNGLVERTEXATTRIBI2IPROC) (GLuint, GLint, GLint); +typedef void (GLAPIENTRY * PFNGLVERTEXATTRIBI2IVPROC) (GLuint, const GLint*); +typedef void (GLAPIENTRY * PFNGLVERTEXATTRIBI2UIPROC) (GLuint, GLuint, GLuint); +typedef void (GLAPIENTRY * PFNGLVERTEXATTRIBI2UIVPROC) (GLuint, const GLuint*); +typedef void (GLAPIENTRY * PFNGLVERTEXATTRIBI3IPROC) (GLuint, GLint, GLint, GLint); +typedef void (GLAPIENTRY * PFNGLVERTEXATTRIBI3IVPROC) (GLuint, const GLint*); +typedef void (GLAPIENTRY * PFNGLVERTEXATTRIBI3UIPROC) (GLuint, GLuint, GLuint, GLuint); +typedef void (GLAPIENTRY * PFNGLVERTEXATTRIBI3UIVPROC) (GLuint, const GLuint*); +typedef void (GLAPIENTRY * PFNGLVERTEXATTRIBI4BVPROC) (GLuint, const GLbyte*); +typedef void (GLAPIENTRY * PFNGLVERTEXATTRIBI4IPROC) (GLuint, GLint, GLint, GLint, GLint); +typedef void (GLAPIENTRY * PFNGLVERTEXATTRIBI4IVPROC) (GLuint, const GLint*); +typedef void (GLAPIENTRY * PFNGLVERTEXATTRIBI4SVPROC) (GLuint, const GLshort*); +typedef void (GLAPIENTRY * PFNGLVERTEXATTRIBI4UBVPROC) (GLuint, const GLubyte*); +typedef void (GLAPIENTRY * PFNGLVERTEXATTRIBI4UIPROC) (GLuint, GLuint, GLuint, GLuint, GLuint); +typedef void (GLAPIENTRY * PFNGLVERTEXATTRIBI4UIVPROC) (GLuint, const GLuint*); +typedef void (GLAPIENTRY * PFNGLVERTEXATTRIBI4USVPROC) (GLuint, const GLushort*); +typedef void (GLAPIENTRY * PFNGLVERTEXATTRIBIPOINTERPROC) (GLuint, GLint, GLenum, GLsizei, const GLvoid*); + +#define glBeginConditionalRender GLEW_GET_FUN(__glewBeginConditionalRender) +#define glBeginTransformFeedback GLEW_GET_FUN(__glewBeginTransformFeedback) +#define glBindBufferBase GLEW_GET_FUN(__glewBindBufferBase) +#define glBindBufferRange GLEW_GET_FUN(__glewBindBufferRange) +#define glBindFragDataLocation GLEW_GET_FUN(__glewBindFragDataLocation) +#define glClampColor GLEW_GET_FUN(__glewClampColor) +#define glClearBufferfi GLEW_GET_FUN(__glewClearBufferfi) +#define glClearBufferfv GLEW_GET_FUN(__glewClearBufferfv) +#define glClearBufferiv GLEW_GET_FUN(__glewClearBufferiv) +#define glClearBufferuiv GLEW_GET_FUN(__glewClearBufferuiv) +#define glColorMaski GLEW_GET_FUN(__glewColorMaski) +#define glDisablei GLEW_GET_FUN(__glewDisablei) +#define glEnablei GLEW_GET_FUN(__glewEnablei) +#define glEndConditionalRender GLEW_GET_FUN(__glewEndConditionalRender) +#define glEndTransformFeedback GLEW_GET_FUN(__glewEndTransformFeedback) +#define glGetBooleani_v GLEW_GET_FUN(__glewGetBooleani_v) +#define glGetFragDataLocation GLEW_GET_FUN(__glewGetFragDataLocation) +#define glGetIntegeri_v GLEW_GET_FUN(__glewGetIntegeri_v) +#define glGetStringi GLEW_GET_FUN(__glewGetStringi) +#define glGetTexParameterIiv GLEW_GET_FUN(__glewGetTexParameterIiv) +#define glGetTexParameterIuiv GLEW_GET_FUN(__glewGetTexParameterIuiv) +#define glGetTransformFeedbackVarying GLEW_GET_FUN(__glewGetTransformFeedbackVarying) +#define glGetUniformuiv GLEW_GET_FUN(__glewGetUniformuiv) +#define glGetVertexAttribIiv GLEW_GET_FUN(__glewGetVertexAttribIiv) +#define glGetVertexAttribIuiv GLEW_GET_FUN(__glewGetVertexAttribIuiv) +#define glIsEnabledi GLEW_GET_FUN(__glewIsEnabledi) +#define glTexParameterIiv GLEW_GET_FUN(__glewTexParameterIiv) +#define glTexParameterIuiv GLEW_GET_FUN(__glewTexParameterIuiv) +#define glTransformFeedbackVaryings GLEW_GET_FUN(__glewTransformFeedbackVaryings) +#define glUniform1ui GLEW_GET_FUN(__glewUniform1ui) +#define glUniform1uiv GLEW_GET_FUN(__glewUniform1uiv) +#define glUniform2ui GLEW_GET_FUN(__glewUniform2ui) +#define glUniform2uiv GLEW_GET_FUN(__glewUniform2uiv) +#define glUniform3ui GLEW_GET_FUN(__glewUniform3ui) +#define glUniform3uiv GLEW_GET_FUN(__glewUniform3uiv) +#define glUniform4ui GLEW_GET_FUN(__glewUniform4ui) +#define glUniform4uiv GLEW_GET_FUN(__glewUniform4uiv) +#define glVertexAttribI1i GLEW_GET_FUN(__glewVertexAttribI1i) +#define glVertexAttribI1iv GLEW_GET_FUN(__glewVertexAttribI1iv) +#define glVertexAttribI1ui GLEW_GET_FUN(__glewVertexAttribI1ui) +#define glVertexAttribI1uiv GLEW_GET_FUN(__glewVertexAttribI1uiv) +#define glVertexAttribI2i GLEW_GET_FUN(__glewVertexAttribI2i) +#define glVertexAttribI2iv GLEW_GET_FUN(__glewVertexAttribI2iv) +#define glVertexAttribI2ui GLEW_GET_FUN(__glewVertexAttribI2ui) +#define glVertexAttribI2uiv GLEW_GET_FUN(__glewVertexAttribI2uiv) +#define glVertexAttribI3i GLEW_GET_FUN(__glewVertexAttribI3i) +#define glVertexAttribI3iv GLEW_GET_FUN(__glewVertexAttribI3iv) +#define glVertexAttribI3ui GLEW_GET_FUN(__glewVertexAttribI3ui) +#define glVertexAttribI3uiv GLEW_GET_FUN(__glewVertexAttribI3uiv) +#define glVertexAttribI4bv GLEW_GET_FUN(__glewVertexAttribI4bv) +#define glVertexAttribI4i GLEW_GET_FUN(__glewVertexAttribI4i) +#define glVertexAttribI4iv GLEW_GET_FUN(__glewVertexAttribI4iv) +#define glVertexAttribI4sv GLEW_GET_FUN(__glewVertexAttribI4sv) +#define glVertexAttribI4ubv GLEW_GET_FUN(__glewVertexAttribI4ubv) +#define glVertexAttribI4ui GLEW_GET_FUN(__glewVertexAttribI4ui) +#define glVertexAttribI4uiv GLEW_GET_FUN(__glewVertexAttribI4uiv) +#define glVertexAttribI4usv GLEW_GET_FUN(__glewVertexAttribI4usv) +#define glVertexAttribIPointer GLEW_GET_FUN(__glewVertexAttribIPointer) + +#define GLEW_VERSION_3_0 GLEW_GET_VAR(__GLEW_VERSION_3_0) + +#endif /* GL_VERSION_3_0 */ + +/* -------------------------- GL_3DFX_multisample -------------------------- */ + +#ifndef GL_3DFX_multisample +#define GL_3DFX_multisample 1 + +#define GL_MULTISAMPLE_3DFX 0x86B2 +#define GL_SAMPLE_BUFFERS_3DFX 0x86B3 +#define GL_SAMPLES_3DFX 0x86B4 +#define GL_MULTISAMPLE_BIT_3DFX 0x20000000 + +#define GLEW_3DFX_multisample GLEW_GET_VAR(__GLEW_3DFX_multisample) + +#endif /* GL_3DFX_multisample */ + +/* ---------------------------- GL_3DFX_tbuffer ---------------------------- */ + +#ifndef GL_3DFX_tbuffer +#define GL_3DFX_tbuffer 1 + +typedef void (GLAPIENTRY * PFNGLTBUFFERMASK3DFXPROC) (GLuint mask); + +#define glTbufferMask3DFX GLEW_GET_FUN(__glewTbufferMask3DFX) + +#define GLEW_3DFX_tbuffer GLEW_GET_VAR(__GLEW_3DFX_tbuffer) + +#endif /* GL_3DFX_tbuffer */ + +/* -------------------- GL_3DFX_texture_compression_FXT1 ------------------- */ + +#ifndef GL_3DFX_texture_compression_FXT1 +#define GL_3DFX_texture_compression_FXT1 1 + +#define GL_COMPRESSED_RGB_FXT1_3DFX 0x86B0 +#define GL_COMPRESSED_RGBA_FXT1_3DFX 0x86B1 + +#define GLEW_3DFX_texture_compression_FXT1 GLEW_GET_VAR(__GLEW_3DFX_texture_compression_FXT1) + +#endif /* GL_3DFX_texture_compression_FXT1 */ + +/* ------------------------ GL_APPLE_client_storage ------------------------ */ + +#ifndef GL_APPLE_client_storage +#define GL_APPLE_client_storage 1 + +#define GL_UNPACK_CLIENT_STORAGE_APPLE 0x85B2 + +#define GLEW_APPLE_client_storage GLEW_GET_VAR(__GLEW_APPLE_client_storage) + +#endif /* GL_APPLE_client_storage */ + +/* ------------------------- GL_APPLE_element_array ------------------------ */ + +#ifndef GL_APPLE_element_array +#define GL_APPLE_element_array 1 + +#define GL_ELEMENT_ARRAY_APPLE 0x8768 +#define GL_ELEMENT_ARRAY_TYPE_APPLE 0x8769 +#define GL_ELEMENT_ARRAY_POINTER_APPLE 0x876A + +typedef void (GLAPIENTRY * PFNGLDRAWELEMENTARRAYAPPLEPROC) (GLenum mode, GLint first, GLsizei count); +typedef void (GLAPIENTRY * PFNGLDRAWRANGEELEMENTARRAYAPPLEPROC) (GLenum mode, GLuint start, GLuint end, GLint first, GLsizei count); +typedef void (GLAPIENTRY * PFNGLELEMENTPOINTERAPPLEPROC) (GLenum type, const void* pointer); +typedef void (GLAPIENTRY * PFNGLMULTIDRAWELEMENTARRAYAPPLEPROC) (GLenum mode, const GLint* first, const GLsizei *count, GLsizei primcount); +typedef void (GLAPIENTRY * PFNGLMULTIDRAWRANGEELEMENTARRAYAPPLEPROC) (GLenum mode, GLuint start, GLuint end, const GLint* first, const GLsizei *count, GLsizei primcount); + +#define glDrawElementArrayAPPLE GLEW_GET_FUN(__glewDrawElementArrayAPPLE) +#define glDrawRangeElementArrayAPPLE GLEW_GET_FUN(__glewDrawRangeElementArrayAPPLE) +#define glElementPointerAPPLE GLEW_GET_FUN(__glewElementPointerAPPLE) +#define glMultiDrawElementArrayAPPLE GLEW_GET_FUN(__glewMultiDrawElementArrayAPPLE) +#define glMultiDrawRangeElementArrayAPPLE GLEW_GET_FUN(__glewMultiDrawRangeElementArrayAPPLE) + +#define GLEW_APPLE_element_array GLEW_GET_VAR(__GLEW_APPLE_element_array) + +#endif /* GL_APPLE_element_array */ + +/* ----------------------------- GL_APPLE_fence ---------------------------- */ + +#ifndef GL_APPLE_fence +#define GL_APPLE_fence 1 + +#define GL_DRAW_PIXELS_APPLE 0x8A0A +#define GL_FENCE_APPLE 0x8A0B + +typedef void (GLAPIENTRY * PFNGLDELETEFENCESAPPLEPROC) (GLsizei n, const GLuint* fences); +typedef void (GLAPIENTRY * PFNGLFINISHFENCEAPPLEPROC) (GLuint fence); +typedef void (GLAPIENTRY * PFNGLFINISHOBJECTAPPLEPROC) (GLenum object, GLint name); +typedef void (GLAPIENTRY * PFNGLGENFENCESAPPLEPROC) (GLsizei n, GLuint* fences); +typedef GLboolean (GLAPIENTRY * PFNGLISFENCEAPPLEPROC) (GLuint fence); +typedef void (GLAPIENTRY * PFNGLSETFENCEAPPLEPROC) (GLuint fence); +typedef GLboolean (GLAPIENTRY * PFNGLTESTFENCEAPPLEPROC) (GLuint fence); +typedef GLboolean (GLAPIENTRY * PFNGLTESTOBJECTAPPLEPROC) (GLenum object, GLuint name); + +#define glDeleteFencesAPPLE GLEW_GET_FUN(__glewDeleteFencesAPPLE) +#define glFinishFenceAPPLE GLEW_GET_FUN(__glewFinishFenceAPPLE) +#define glFinishObjectAPPLE GLEW_GET_FUN(__glewFinishObjectAPPLE) +#define glGenFencesAPPLE GLEW_GET_FUN(__glewGenFencesAPPLE) +#define glIsFenceAPPLE GLEW_GET_FUN(__glewIsFenceAPPLE) +#define glSetFenceAPPLE GLEW_GET_FUN(__glewSetFenceAPPLE) +#define glTestFenceAPPLE GLEW_GET_FUN(__glewTestFenceAPPLE) +#define glTestObjectAPPLE GLEW_GET_FUN(__glewTestObjectAPPLE) + +#define GLEW_APPLE_fence GLEW_GET_VAR(__GLEW_APPLE_fence) + +#endif /* GL_APPLE_fence */ + +/* ------------------------- GL_APPLE_float_pixels ------------------------- */ + +#ifndef GL_APPLE_float_pixels +#define GL_APPLE_float_pixels 1 + +#define GL_HALF_APPLE 0x140B +#define GL_RGBA_FLOAT32_APPLE 0x8814 +#define GL_RGB_FLOAT32_APPLE 0x8815 +#define GL_ALPHA_FLOAT32_APPLE 0x8816 +#define GL_INTENSITY_FLOAT32_APPLE 0x8817 +#define GL_LUMINANCE_FLOAT32_APPLE 0x8818 +#define GL_LUMINANCE_ALPHA_FLOAT32_APPLE 0x8819 +#define GL_RGBA_FLOAT16_APPLE 0x881A +#define GL_RGB_FLOAT16_APPLE 0x881B +#define GL_ALPHA_FLOAT16_APPLE 0x881C +#define GL_INTENSITY_FLOAT16_APPLE 0x881D +#define GL_LUMINANCE_FLOAT16_APPLE 0x881E +#define GL_LUMINANCE_ALPHA_FLOAT16_APPLE 0x881F +#define GL_COLOR_FLOAT_APPLE 0x8A0F + +#define GLEW_APPLE_float_pixels GLEW_GET_VAR(__GLEW_APPLE_float_pixels) + +#endif /* GL_APPLE_float_pixels */ + +/* ---------------------- GL_APPLE_flush_buffer_range ---------------------- */ + +#ifndef GL_APPLE_flush_buffer_range +#define GL_APPLE_flush_buffer_range 1 + +#define GL_BUFFER_SERIALIZED_MODIFY_APPLE 0x8A12 +#define GL_BUFFER_FLUSHING_UNMAP_APPLE 0x8A13 + +typedef void (GLAPIENTRY * PFNGLBUFFERPARAMETERIAPPLEPROC) (GLenum target, GLenum pname, GLint param); +typedef void (GLAPIENTRY * PFNGLFLUSHMAPPEDBUFFERRANGEAPPLEPROC) (GLenum target, GLintptr offset, GLsizeiptr size); + +#define glBufferParameteriAPPLE GLEW_GET_FUN(__glewBufferParameteriAPPLE) +#define glFlushMappedBufferRangeAPPLE GLEW_GET_FUN(__glewFlushMappedBufferRangeAPPLE) + +#define GLEW_APPLE_flush_buffer_range GLEW_GET_VAR(__GLEW_APPLE_flush_buffer_range) + +#endif /* GL_APPLE_flush_buffer_range */ + +/* ------------------------- GL_APPLE_pixel_buffer ------------------------- */ + +#ifndef GL_APPLE_pixel_buffer +#define GL_APPLE_pixel_buffer 1 + +#define GL_MIN_PBUFFER_VIEWPORT_DIMS_APPLE 0x8A10 + +#define GLEW_APPLE_pixel_buffer GLEW_GET_VAR(__GLEW_APPLE_pixel_buffer) + +#endif /* GL_APPLE_pixel_buffer */ + +/* ------------------------ GL_APPLE_specular_vector ----------------------- */ + +#ifndef GL_APPLE_specular_vector +#define GL_APPLE_specular_vector 1 + +#define GL_LIGHT_MODEL_SPECULAR_VECTOR_APPLE 0x85B0 + +#define GLEW_APPLE_specular_vector GLEW_GET_VAR(__GLEW_APPLE_specular_vector) + +#endif /* GL_APPLE_specular_vector */ + +/* ------------------------- GL_APPLE_texture_range ------------------------ */ + +#ifndef GL_APPLE_texture_range +#define GL_APPLE_texture_range 1 + +#define GL_TEXTURE_RANGE_LENGTH_APPLE 0x85B7 +#define GL_TEXTURE_RANGE_POINTER_APPLE 0x85B8 +#define GL_TEXTURE_STORAGE_HINT_APPLE 0x85BC +#define GL_STORAGE_PRIVATE_APPLE 0x85BD +#define GL_STORAGE_CACHED_APPLE 0x85BE +#define GL_STORAGE_SHARED_APPLE 0x85BF + +typedef void (GLAPIENTRY * PFNGLGETTEXPARAMETERPOINTERVAPPLEPROC) (GLenum target, GLenum pname, GLvoid **params); +typedef void (GLAPIENTRY * PFNGLTEXTURERANGEAPPLEPROC) (GLenum target, GLsizei length, GLvoid *pointer); + +#define glGetTexParameterPointervAPPLE GLEW_GET_FUN(__glewGetTexParameterPointervAPPLE) +#define glTextureRangeAPPLE GLEW_GET_FUN(__glewTextureRangeAPPLE) + +#define GLEW_APPLE_texture_range GLEW_GET_VAR(__GLEW_APPLE_texture_range) + +#endif /* GL_APPLE_texture_range */ + +/* ------------------------ GL_APPLE_transform_hint ------------------------ */ + +#ifndef GL_APPLE_transform_hint +#define GL_APPLE_transform_hint 1 + +#define GL_TRANSFORM_HINT_APPLE 0x85B1 + +#define GLEW_APPLE_transform_hint GLEW_GET_VAR(__GLEW_APPLE_transform_hint) + +#endif /* GL_APPLE_transform_hint */ + +/* ---------------------- GL_APPLE_vertex_array_object --------------------- */ + +#ifndef GL_APPLE_vertex_array_object +#define GL_APPLE_vertex_array_object 1 + +#define GL_VERTEX_ARRAY_BINDING_APPLE 0x85B5 + +typedef void (GLAPIENTRY * PFNGLBINDVERTEXARRAYAPPLEPROC) (GLuint array); +typedef void (GLAPIENTRY * PFNGLDELETEVERTEXARRAYSAPPLEPROC) (GLsizei n, const GLuint* arrays); +typedef void (GLAPIENTRY * PFNGLGENVERTEXARRAYSAPPLEPROC) (GLsizei n, const GLuint* arrays); +typedef GLboolean (GLAPIENTRY * PFNGLISVERTEXARRAYAPPLEPROC) (GLuint array); + +#define glBindVertexArrayAPPLE GLEW_GET_FUN(__glewBindVertexArrayAPPLE) +#define glDeleteVertexArraysAPPLE GLEW_GET_FUN(__glewDeleteVertexArraysAPPLE) +#define glGenVertexArraysAPPLE GLEW_GET_FUN(__glewGenVertexArraysAPPLE) +#define glIsVertexArrayAPPLE GLEW_GET_FUN(__glewIsVertexArrayAPPLE) + +#define GLEW_APPLE_vertex_array_object GLEW_GET_VAR(__GLEW_APPLE_vertex_array_object) + +#endif /* GL_APPLE_vertex_array_object */ + +/* ---------------------- GL_APPLE_vertex_array_range ---------------------- */ + +#ifndef GL_APPLE_vertex_array_range +#define GL_APPLE_vertex_array_range 1 + +#define GL_VERTEX_ARRAY_RANGE_APPLE 0x851D +#define GL_VERTEX_ARRAY_RANGE_LENGTH_APPLE 0x851E +#define GL_VERTEX_ARRAY_STORAGE_HINT_APPLE 0x851F +#define GL_MAX_VERTEX_ARRAY_RANGE_ELEMENT_APPLE 0x8520 +#define GL_VERTEX_ARRAY_RANGE_POINTER_APPLE 0x8521 +#define GL_STORAGE_CACHED_APPLE 0x85BE +#define GL_STORAGE_SHARED_APPLE 0x85BF + +typedef void (GLAPIENTRY * PFNGLFLUSHVERTEXARRAYRANGEAPPLEPROC) (GLsizei length, void* pointer); +typedef void (GLAPIENTRY * PFNGLVERTEXARRAYPARAMETERIAPPLEPROC) (GLenum pname, GLint param); +typedef void (GLAPIENTRY * PFNGLVERTEXARRAYRANGEAPPLEPROC) (GLsizei length, void* pointer); + +#define glFlushVertexArrayRangeAPPLE GLEW_GET_FUN(__glewFlushVertexArrayRangeAPPLE) +#define glVertexArrayParameteriAPPLE GLEW_GET_FUN(__glewVertexArrayParameteriAPPLE) +#define glVertexArrayRangeAPPLE GLEW_GET_FUN(__glewVertexArrayRangeAPPLE) + +#define GLEW_APPLE_vertex_array_range GLEW_GET_VAR(__GLEW_APPLE_vertex_array_range) + +#endif /* GL_APPLE_vertex_array_range */ + +/* --------------------------- GL_APPLE_ycbcr_422 -------------------------- */ + +#ifndef GL_APPLE_ycbcr_422 +#define GL_APPLE_ycbcr_422 1 + +#define GL_YCBCR_422_APPLE 0x85B9 +#define GL_UNSIGNED_SHORT_8_8_APPLE 0x85BA +#define GL_UNSIGNED_SHORT_8_8_REV_APPLE 0x85BB + +#define GLEW_APPLE_ycbcr_422 GLEW_GET_VAR(__GLEW_APPLE_ycbcr_422) + +#endif /* GL_APPLE_ycbcr_422 */ + +/* ----------------------- GL_ARB_color_buffer_float ----------------------- */ + +#ifndef GL_ARB_color_buffer_float +#define GL_ARB_color_buffer_float 1 + +#define GL_RGBA_FLOAT_MODE_ARB 0x8820 +#define GL_CLAMP_VERTEX_COLOR_ARB 0x891A +#define GL_CLAMP_FRAGMENT_COLOR_ARB 0x891B +#define GL_CLAMP_READ_COLOR_ARB 0x891C +#define GL_FIXED_ONLY_ARB 0x891D + +typedef void (GLAPIENTRY * PFNGLCLAMPCOLORARBPROC) (GLenum target, GLenum clamp); + +#define glClampColorARB GLEW_GET_FUN(__glewClampColorARB) + +#define GLEW_ARB_color_buffer_float GLEW_GET_VAR(__GLEW_ARB_color_buffer_float) + +#endif /* GL_ARB_color_buffer_float */ + +/* ----------------------- GL_ARB_depth_buffer_float ----------------------- */ + +#ifndef GL_ARB_depth_buffer_float +#define GL_ARB_depth_buffer_float 1 + +#define GL_DEPTH_COMPONENT32F 0x8CAC +#define GL_DEPTH32F_STENCIL8 0x8CAD +#define GL_FLOAT_32_UNSIGNED_INT_24_8_REV 0x8DAD + +#define GLEW_ARB_depth_buffer_float GLEW_GET_VAR(__GLEW_ARB_depth_buffer_float) + +#endif /* GL_ARB_depth_buffer_float */ + +/* -------------------------- GL_ARB_depth_texture ------------------------- */ + +#ifndef GL_ARB_depth_texture +#define GL_ARB_depth_texture 1 + +#define GL_DEPTH_COMPONENT16_ARB 0x81A5 +#define GL_DEPTH_COMPONENT24_ARB 0x81A6 +#define GL_DEPTH_COMPONENT32_ARB 0x81A7 +#define GL_TEXTURE_DEPTH_SIZE_ARB 0x884A +#define GL_DEPTH_TEXTURE_MODE_ARB 0x884B + +#define GLEW_ARB_depth_texture GLEW_GET_VAR(__GLEW_ARB_depth_texture) + +#endif /* GL_ARB_depth_texture */ + +/* -------------------------- GL_ARB_draw_buffers -------------------------- */ + +#ifndef GL_ARB_draw_buffers +#define GL_ARB_draw_buffers 1 + +#define GL_MAX_DRAW_BUFFERS_ARB 0x8824 +#define GL_DRAW_BUFFER0_ARB 0x8825 +#define GL_DRAW_BUFFER1_ARB 0x8826 +#define GL_DRAW_BUFFER2_ARB 0x8827 +#define GL_DRAW_BUFFER3_ARB 0x8828 +#define GL_DRAW_BUFFER4_ARB 0x8829 +#define GL_DRAW_BUFFER5_ARB 0x882A +#define GL_DRAW_BUFFER6_ARB 0x882B +#define GL_DRAW_BUFFER7_ARB 0x882C +#define GL_DRAW_BUFFER8_ARB 0x882D +#define GL_DRAW_BUFFER9_ARB 0x882E +#define GL_DRAW_BUFFER10_ARB 0x882F +#define GL_DRAW_BUFFER11_ARB 0x8830 +#define GL_DRAW_BUFFER12_ARB 0x8831 +#define GL_DRAW_BUFFER13_ARB 0x8832 +#define GL_DRAW_BUFFER14_ARB 0x8833 +#define GL_DRAW_BUFFER15_ARB 0x8834 + +typedef void (GLAPIENTRY * PFNGLDRAWBUFFERSARBPROC) (GLsizei n, const GLenum* bufs); + +#define glDrawBuffersARB GLEW_GET_FUN(__glewDrawBuffersARB) + +#define GLEW_ARB_draw_buffers GLEW_GET_VAR(__GLEW_ARB_draw_buffers) + +#endif /* GL_ARB_draw_buffers */ + +/* ------------------------- GL_ARB_draw_instanced ------------------------- */ + +#ifndef GL_ARB_draw_instanced +#define GL_ARB_draw_instanced 1 + +typedef void (GLAPIENTRY * PFNGLDRAWARRAYSINSTANCEDARBPROC) (GLenum mode, GLint first, GLsizei count, GLsizei primcount); +typedef void (GLAPIENTRY * PFNGLDRAWELEMENTSINSTANCEDARBPROC) (GLenum mode, GLsizei count, GLenum type, const void* indices, GLsizei primcount); + +#define glDrawArraysInstancedARB GLEW_GET_FUN(__glewDrawArraysInstancedARB) +#define glDrawElementsInstancedARB GLEW_GET_FUN(__glewDrawElementsInstancedARB) + +#define GLEW_ARB_draw_instanced GLEW_GET_VAR(__GLEW_ARB_draw_instanced) + +#endif /* GL_ARB_draw_instanced */ + +/* ------------------------ GL_ARB_fragment_program ------------------------ */ + +#ifndef GL_ARB_fragment_program +#define GL_ARB_fragment_program 1 + +#define GL_FRAGMENT_PROGRAM_ARB 0x8804 +#define GL_PROGRAM_ALU_INSTRUCTIONS_ARB 0x8805 +#define GL_PROGRAM_TEX_INSTRUCTIONS_ARB 0x8806 +#define GL_PROGRAM_TEX_INDIRECTIONS_ARB 0x8807 +#define GL_PROGRAM_NATIVE_ALU_INSTRUCTIONS_ARB 0x8808 +#define GL_PROGRAM_NATIVE_TEX_INSTRUCTIONS_ARB 0x8809 +#define GL_PROGRAM_NATIVE_TEX_INDIRECTIONS_ARB 0x880A +#define GL_MAX_PROGRAM_ALU_INSTRUCTIONS_ARB 0x880B +#define GL_MAX_PROGRAM_TEX_INSTRUCTIONS_ARB 0x880C +#define GL_MAX_PROGRAM_TEX_INDIRECTIONS_ARB 0x880D +#define GL_MAX_PROGRAM_NATIVE_ALU_INSTRUCTIONS_ARB 0x880E +#define GL_MAX_PROGRAM_NATIVE_TEX_INSTRUCTIONS_ARB 0x880F +#define GL_MAX_PROGRAM_NATIVE_TEX_INDIRECTIONS_ARB 0x8810 +#define GL_MAX_TEXTURE_COORDS_ARB 0x8871 +#define GL_MAX_TEXTURE_IMAGE_UNITS_ARB 0x8872 + +#define GLEW_ARB_fragment_program GLEW_GET_VAR(__GLEW_ARB_fragment_program) + +#endif /* GL_ARB_fragment_program */ + +/* --------------------- GL_ARB_fragment_program_shadow -------------------- */ + +#ifndef GL_ARB_fragment_program_shadow +#define GL_ARB_fragment_program_shadow 1 + +#define GLEW_ARB_fragment_program_shadow GLEW_GET_VAR(__GLEW_ARB_fragment_program_shadow) + +#endif /* GL_ARB_fragment_program_shadow */ + +/* ------------------------- GL_ARB_fragment_shader ------------------------ */ + +#ifndef GL_ARB_fragment_shader +#define GL_ARB_fragment_shader 1 + +#define GL_FRAGMENT_SHADER_ARB 0x8B30 +#define GL_MAX_FRAGMENT_UNIFORM_COMPONENTS_ARB 0x8B49 +#define GL_FRAGMENT_SHADER_DERIVATIVE_HINT_ARB 0x8B8B + +#define GLEW_ARB_fragment_shader GLEW_GET_VAR(__GLEW_ARB_fragment_shader) + +#endif /* GL_ARB_fragment_shader */ + +/* ----------------------- GL_ARB_framebuffer_object ----------------------- */ + +#ifndef GL_ARB_framebuffer_object +#define GL_ARB_framebuffer_object 1 + +#define GL_INVALID_FRAMEBUFFER_OPERATION 0x0506 +#define GL_FRAMEBUFFER_ATTACHMENT_COLOR_ENCODING 0x8210 +#define GL_FRAMEBUFFER_ATTACHMENT_COMPONENT_TYPE 0x8211 +#define GL_FRAMEBUFFER_ATTACHMENT_RED_SIZE 0x8212 +#define GL_FRAMEBUFFER_ATTACHMENT_GREEN_SIZE 0x8213 +#define GL_FRAMEBUFFER_ATTACHMENT_BLUE_SIZE 0x8214 +#define GL_FRAMEBUFFER_ATTACHMENT_ALPHA_SIZE 0x8215 +#define GL_FRAMEBUFFER_ATTACHMENT_DEPTH_SIZE 0x8216 +#define GL_FRAMEBUFFER_ATTACHMENT_STENCIL_SIZE 0x8217 +#define GL_FRAMEBUFFER_DEFAULT 0x8218 +#define GL_FRAMEBUFFER_UNDEFINED 0x8219 +#define GL_DEPTH_STENCIL_ATTACHMENT 0x821A +#define GL_INDEX 0x8222 +#define GL_MAX_RENDERBUFFER_SIZE 0x84E8 +#define GL_DEPTH_STENCIL 0x84F9 +#define GL_UNSIGNED_INT_24_8 0x84FA +#define GL_DEPTH24_STENCIL8 0x88F0 +#define GL_TEXTURE_STENCIL_SIZE 0x88F1 +#define GL_UNSIGNED_NORMALIZED 0x8C17 +#define GL_SRGB 0x8C40 +#define GL_DRAW_FRAMEBUFFER_BINDING 0x8CA6 +#define GL_FRAMEBUFFER_BINDING 0x8CA6 +#define GL_RENDERBUFFER_BINDING 0x8CA7 +#define GL_READ_FRAMEBUFFER 0x8CA8 +#define GL_DRAW_FRAMEBUFFER 0x8CA9 +#define GL_READ_FRAMEBUFFER_BINDING 0x8CAA +#define GL_RENDERBUFFER_SAMPLES 0x8CAB +#define GL_FRAMEBUFFER_ATTACHMENT_OBJECT_TYPE 0x8CD0 +#define GL_FRAMEBUFFER_ATTACHMENT_OBJECT_NAME 0x8CD1 +#define GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_LEVEL 0x8CD2 +#define GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_CUBE_MAP_FACE 0x8CD3 +#define GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_LAYER 0x8CD4 +#define GL_FRAMEBUFFER_COMPLETE 0x8CD5 +#define GL_FRAMEBUFFER_INCOMPLETE_ATTACHMENT 0x8CD6 +#define GL_FRAMEBUFFER_INCOMPLETE_MISSING_ATTACHMENT 0x8CD7 +#define GL_FRAMEBUFFER_INCOMPLETE_DRAW_BUFFER 0x8CDB +#define GL_FRAMEBUFFER_INCOMPLETE_READ_BUFFER 0x8CDC +#define GL_FRAMEBUFFER_UNSUPPORTED 0x8CDD +#define GL_MAX_COLOR_ATTACHMENTS 0x8CDF +#define GL_COLOR_ATTACHMENT0 0x8CE0 +#define GL_COLOR_ATTACHMENT1 0x8CE1 +#define GL_COLOR_ATTACHMENT2 0x8CE2 +#define GL_COLOR_ATTACHMENT3 0x8CE3 +#define GL_COLOR_ATTACHMENT4 0x8CE4 +#define GL_COLOR_ATTACHMENT5 0x8CE5 +#define GL_COLOR_ATTACHMENT6 0x8CE6 +#define GL_COLOR_ATTACHMENT7 0x8CE7 +#define GL_COLOR_ATTACHMENT8 0x8CE8 +#define GL_COLOR_ATTACHMENT9 0x8CE9 +#define GL_COLOR_ATTACHMENT10 0x8CEA +#define GL_COLOR_ATTACHMENT11 0x8CEB +#define GL_COLOR_ATTACHMENT12 0x8CEC +#define GL_COLOR_ATTACHMENT13 0x8CED +#define GL_COLOR_ATTACHMENT14 0x8CEE +#define GL_COLOR_ATTACHMENT15 0x8CEF +#define GL_DEPTH_ATTACHMENT 0x8D00 +#define GL_STENCIL_ATTACHMENT 0x8D20 +#define GL_FRAMEBUFFER 0x8D40 +#define GL_RENDERBUFFER 0x8D41 +#define GL_RENDERBUFFER_WIDTH 0x8D42 +#define GL_RENDERBUFFER_HEIGHT 0x8D43 +#define GL_RENDERBUFFER_INTERNAL_FORMAT 0x8D44 +#define GL_STENCIL_INDEX1 0x8D46 +#define GL_STENCIL_INDEX4 0x8D47 +#define GL_STENCIL_INDEX8 0x8D48 +#define GL_STENCIL_INDEX16 0x8D49 +#define GL_RENDERBUFFER_RED_SIZE 0x8D50 +#define GL_RENDERBUFFER_GREEN_SIZE 0x8D51 +#define GL_RENDERBUFFER_BLUE_SIZE 0x8D52 +#define GL_RENDERBUFFER_ALPHA_SIZE 0x8D53 +#define GL_RENDERBUFFER_DEPTH_SIZE 0x8D54 +#define GL_RENDERBUFFER_STENCIL_SIZE 0x8D55 +#define GL_FRAMEBUFFER_INCOMPLETE_MULTISAMPLE 0x8D56 +#define GL_MAX_SAMPLES 0x8D57 + +typedef void (GLAPIENTRY * PFNGLBINDFRAMEBUFFERPROC) (GLenum target, GLuint framebuffer); +typedef void (GLAPIENTRY * PFNGLBINDRENDERBUFFERPROC) (GLenum target, GLuint renderbuffer); +typedef void (GLAPIENTRY * PFNGLBLITFRAMEBUFFERPROC) (GLint srcX0, GLint srcY0, GLint srcX1, GLint srcY1, GLint dstX0, GLint dstY0, GLint dstX1, GLint dstY1, GLbitfield mask, GLenum filter); +typedef GLenum (GLAPIENTRY * PFNGLCHECKFRAMEBUFFERSTATUSPROC) (GLenum target); +typedef void (GLAPIENTRY * PFNGLDELETEFRAMEBUFFERSPROC) (GLsizei n, const GLuint* framebuffers); +typedef void (GLAPIENTRY * PFNGLDELETERENDERBUFFERSPROC) (GLsizei n, const GLuint* renderbuffers); +typedef void (GLAPIENTRY * PFNGLFRAMEBUFFERRENDERBUFFERPROC) (GLenum target, GLenum attachment, GLenum renderbuffertarget, GLuint renderbuffer); +typedef void (GLAPIENTRY * PFNGLFRAMEBUFFERTEXTURLAYERPROC) (GLenum target,GLenum attachment, GLuint texture,GLint level,GLint layer); +typedef void (GLAPIENTRY * PFNGLFRAMEBUFFERTEXTURE1DPROC) (GLenum target, GLenum attachment, GLenum textarget, GLuint texture, GLint level); +typedef void (GLAPIENTRY * PFNGLFRAMEBUFFERTEXTURE2DPROC) (GLenum target, GLenum attachment, GLenum textarget, GLuint texture, GLint level); +typedef void (GLAPIENTRY * PFNGLFRAMEBUFFERTEXTURE3DPROC) (GLenum target, GLenum attachment, GLenum textarget, GLuint texture, GLint level, GLint layer); +typedef void (GLAPIENTRY * PFNGLGENFRAMEBUFFERSPROC) (GLsizei n, GLuint* framebuffers); +typedef void (GLAPIENTRY * PFNGLGENRENDERBUFFERSPROC) (GLsizei n, GLuint* renderbuffers); +typedef void (GLAPIENTRY * PFNGLGENERATEMIPMAPPROC) (GLenum target); +typedef void (GLAPIENTRY * PFNGLGETFRAMEBUFFERATTACHMENTPARAMETERIVPROC) (GLenum target, GLenum attachment, GLenum pname, GLint* params); +typedef void (GLAPIENTRY * PFNGLGETRENDERBUFFERPARAMETERIVPROC) (GLenum target, GLenum pname, GLint* params); +typedef GLboolean (GLAPIENTRY * PFNGLISFRAMEBUFFERPROC) (GLuint framebuffer); +typedef GLboolean (GLAPIENTRY * PFNGLISRENDERBUFFERPROC) (GLuint renderbuffer); +typedef void (GLAPIENTRY * PFNGLRENDERBUFFERSTORAGEPROC) (GLenum target, GLenum internalformat, GLsizei width, GLsizei height); +typedef void (GLAPIENTRY * PFNGLRENDERBUFFERSTORAGEMULTISAMPLEPROC) (GLenum target, GLsizei samples, GLenum internalformat, GLsizei width, GLsizei height); + +#define glBindFramebuffer GLEW_GET_FUN(__glewBindFramebuffer) +#define glBindRenderbuffer GLEW_GET_FUN(__glewBindRenderbuffer) +#define glBlitFramebuffer GLEW_GET_FUN(__glewBlitFramebuffer) +#define glCheckFramebufferStatus GLEW_GET_FUN(__glewCheckFramebufferStatus) +#define glDeleteFramebuffers GLEW_GET_FUN(__glewDeleteFramebuffers) +#define glDeleteRenderbuffers GLEW_GET_FUN(__glewDeleteRenderbuffers) +#define glFramebufferRenderbuffer GLEW_GET_FUN(__glewFramebufferRenderbuffer) +#define glFramebufferTexturLayer GLEW_GET_FUN(__glewFramebufferTexturLayer) +#define glFramebufferTexture1D GLEW_GET_FUN(__glewFramebufferTexture1D) +#define glFramebufferTexture2D GLEW_GET_FUN(__glewFramebufferTexture2D) +#define glFramebufferTexture3D GLEW_GET_FUN(__glewFramebufferTexture3D) +#define glGenFramebuffers GLEW_GET_FUN(__glewGenFramebuffers) +#define glGenRenderbuffers GLEW_GET_FUN(__glewGenRenderbuffers) +#define glGenerateMipmap GLEW_GET_FUN(__glewGenerateMipmap) +#define glGetFramebufferAttachmentParameteriv GLEW_GET_FUN(__glewGetFramebufferAttachmentParameteriv) +#define glGetRenderbufferParameteriv GLEW_GET_FUN(__glewGetRenderbufferParameteriv) +#define glIsFramebuffer GLEW_GET_FUN(__glewIsFramebuffer) +#define glIsRenderbuffer GLEW_GET_FUN(__glewIsRenderbuffer) +#define glRenderbufferStorage GLEW_GET_FUN(__glewRenderbufferStorage) +#define glRenderbufferStorageMultisample GLEW_GET_FUN(__glewRenderbufferStorageMultisample) + +#define GLEW_ARB_framebuffer_object GLEW_GET_VAR(__GLEW_ARB_framebuffer_object) + +#endif /* GL_ARB_framebuffer_object */ + +/* ------------------------ GL_ARB_framebuffer_sRGB ------------------------ */ + +#ifndef GL_ARB_framebuffer_sRGB +#define GL_ARB_framebuffer_sRGB 1 + +#define GL_FRAMEBUFFER_SRGB 0x8DB9 + +#define GLEW_ARB_framebuffer_sRGB GLEW_GET_VAR(__GLEW_ARB_framebuffer_sRGB) + +#endif /* GL_ARB_framebuffer_sRGB */ + +/* ------------------------ GL_ARB_geometry_shader4 ------------------------ */ + +#ifndef GL_ARB_geometry_shader4 +#define GL_ARB_geometry_shader4 1 + +#define GL_LINES_ADJACENCY_ARB 0xA +#define GL_LINE_STRIP_ADJACENCY_ARB 0xB +#define GL_TRIANGLES_ADJACENCY_ARB 0xC +#define GL_TRIANGLE_STRIP_ADJACENCY_ARB 0xD +#define GL_PROGRAM_POINT_SIZE_ARB 0x8642 +#define GL_MAX_GEOMETRY_TEXTURE_IMAGE_UNITS_ARB 0x8C29 +#define GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_LAYER 0x8CD4 +#define GL_FRAMEBUFFER_ATTACHMENT_LAYERED_ARB 0x8DA7 +#define GL_FRAMEBUFFER_INCOMPLETE_LAYER_TARGETS_ARB 0x8DA8 +#define GL_FRAMEBUFFER_INCOMPLETE_LAYER_COUNT_ARB 0x8DA9 +#define GL_GEOMETRY_SHADER_ARB 0x8DD9 +#define GL_GEOMETRY_VERTICES_OUT_ARB 0x8DDA +#define GL_GEOMETRY_INPUT_TYPE_ARB 0x8DDB +#define GL_GEOMETRY_OUTPUT_TYPE_ARB 0x8DDC +#define GL_MAX_GEOMETRY_VARYING_COMPONENTS_ARB 0x8DDD +#define GL_MAX_VERTEX_VARYING_COMPONENTS_ARB 0x8DDE +#define GL_MAX_GEOMETRY_UNIFORM_COMPONENTS_ARB 0x8DDF +#define GL_MAX_GEOMETRY_OUTPUT_VERTICES_ARB 0x8DE0 +#define GL_MAX_GEOMETRY_TOTAL_OUTPUT_COMPONENTS_ARB 0x8DE1 + +typedef void (GLAPIENTRY * PFNGLFRAMEBUFFERTEXTUREARBPROC) (GLenum target, GLenum attachment, GLuint texture, GLint level); +typedef void (GLAPIENTRY * PFNGLFRAMEBUFFERTEXTUREFACEARBPROC) (GLenum target, GLenum attachment, GLuint texture, GLint level, GLenum face); +typedef void (GLAPIENTRY * PFNGLFRAMEBUFFERTEXTURELAYERARBPROC) (GLenum target, GLenum attachment, GLuint texture, GLint level, GLint layer); +typedef void (GLAPIENTRY * PFNGLPROGRAMPARAMETERIARBPROC) (GLuint program, GLenum pname, GLint value); + +#define glFramebufferTextureARB GLEW_GET_FUN(__glewFramebufferTextureARB) +#define glFramebufferTextureFaceARB GLEW_GET_FUN(__glewFramebufferTextureFaceARB) +#define glFramebufferTextureLayerARB GLEW_GET_FUN(__glewFramebufferTextureLayerARB) +#define glProgramParameteriARB GLEW_GET_FUN(__glewProgramParameteriARB) + +#define GLEW_ARB_geometry_shader4 GLEW_GET_VAR(__GLEW_ARB_geometry_shader4) + +#endif /* GL_ARB_geometry_shader4 */ + +/* ------------------------ GL_ARB_half_float_pixel ------------------------ */ + +#ifndef GL_ARB_half_float_pixel +#define GL_ARB_half_float_pixel 1 + +#define GL_HALF_FLOAT_ARB 0x140B + +#define GLEW_ARB_half_float_pixel GLEW_GET_VAR(__GLEW_ARB_half_float_pixel) + +#endif /* GL_ARB_half_float_pixel */ + +/* ------------------------ GL_ARB_half_float_vertex ----------------------- */ + +#ifndef GL_ARB_half_float_vertex +#define GL_ARB_half_float_vertex 1 + +#define GL_HALF_FLOAT 0x140B + +#define GLEW_ARB_half_float_vertex GLEW_GET_VAR(__GLEW_ARB_half_float_vertex) + +#endif /* GL_ARB_half_float_vertex */ + +/* ----------------------------- GL_ARB_imaging ---------------------------- */ + +#ifndef GL_ARB_imaging +#define GL_ARB_imaging 1 + +#define GL_CONSTANT_COLOR 0x8001 +#define GL_ONE_MINUS_CONSTANT_COLOR 0x8002 +#define GL_CONSTANT_ALPHA 0x8003 +#define GL_ONE_MINUS_CONSTANT_ALPHA 0x8004 +#define GL_BLEND_COLOR 0x8005 +#define GL_FUNC_ADD 0x8006 +#define GL_MIN 0x8007 +#define GL_MAX 0x8008 +#define GL_BLEND_EQUATION 0x8009 +#define GL_FUNC_SUBTRACT 0x800A +#define GL_FUNC_REVERSE_SUBTRACT 0x800B +#define GL_CONVOLUTION_1D 0x8010 +#define GL_CONVOLUTION_2D 0x8011 +#define GL_SEPARABLE_2D 0x8012 +#define GL_CONVOLUTION_BORDER_MODE 0x8013 +#define GL_CONVOLUTION_FILTER_SCALE 0x8014 +#define GL_CONVOLUTION_FILTER_BIAS 0x8015 +#define GL_REDUCE 0x8016 +#define GL_CONVOLUTION_FORMAT 0x8017 +#define GL_CONVOLUTION_WIDTH 0x8018 +#define GL_CONVOLUTION_HEIGHT 0x8019 +#define GL_MAX_CONVOLUTION_WIDTH 0x801A +#define GL_MAX_CONVOLUTION_HEIGHT 0x801B +#define GL_POST_CONVOLUTION_RED_SCALE 0x801C +#define GL_POST_CONVOLUTION_GREEN_SCALE 0x801D +#define GL_POST_CONVOLUTION_BLUE_SCALE 0x801E +#define GL_POST_CONVOLUTION_ALPHA_SCALE 0x801F +#define GL_POST_CONVOLUTION_RED_BIAS 0x8020 +#define GL_POST_CONVOLUTION_GREEN_BIAS 0x8021 +#define GL_POST_CONVOLUTION_BLUE_BIAS 0x8022 +#define GL_POST_CONVOLUTION_ALPHA_BIAS 0x8023 +#define GL_HISTOGRAM 0x8024 +#define GL_PROXY_HISTOGRAM 0x8025 +#define GL_HISTOGRAM_WIDTH 0x8026 +#define GL_HISTOGRAM_FORMAT 0x8027 +#define GL_HISTOGRAM_RED_SIZE 0x8028 +#define GL_HISTOGRAM_GREEN_SIZE 0x8029 +#define GL_HISTOGRAM_BLUE_SIZE 0x802A +#define GL_HISTOGRAM_ALPHA_SIZE 0x802B +#define GL_HISTOGRAM_LUMINANCE_SIZE 0x802C +#define GL_HISTOGRAM_SINK 0x802D +#define GL_MINMAX 0x802E +#define GL_MINMAX_FORMAT 0x802F +#define GL_MINMAX_SINK 0x8030 +#define GL_TABLE_TOO_LARGE 0x8031 +#define GL_COLOR_MATRIX 0x80B1 +#define GL_COLOR_MATRIX_STACK_DEPTH 0x80B2 +#define GL_MAX_COLOR_MATRIX_STACK_DEPTH 0x80B3 +#define GL_POST_COLOR_MATRIX_RED_SCALE 0x80B4 +#define GL_POST_COLOR_MATRIX_GREEN_SCALE 0x80B5 +#define GL_POST_COLOR_MATRIX_BLUE_SCALE 0x80B6 +#define GL_POST_COLOR_MATRIX_ALPHA_SCALE 0x80B7 +#define GL_POST_COLOR_MATRIX_RED_BIAS 0x80B8 +#define GL_POST_COLOR_MATRIX_GREEN_BIAS 0x80B9 +#define GL_POST_COLOR_MATRIX_BLUE_BIAS 0x80BA +#define GL_POST_COLOR_MATRIX_ALPHA_BIAS 0x80BB +#define GL_COLOR_TABLE 0x80D0 +#define GL_POST_CONVOLUTION_COLOR_TABLE 0x80D1 +#define GL_POST_COLOR_MATRIX_COLOR_TABLE 0x80D2 +#define GL_PROXY_COLOR_TABLE 0x80D3 +#define GL_PROXY_POST_CONVOLUTION_COLOR_TABLE 0x80D4 +#define GL_PROXY_POST_COLOR_MATRIX_COLOR_TABLE 0x80D5 +#define GL_COLOR_TABLE_SCALE 0x80D6 +#define GL_COLOR_TABLE_BIAS 0x80D7 +#define GL_COLOR_TABLE_FORMAT 0x80D8 +#define GL_COLOR_TABLE_WIDTH 0x80D9 +#define GL_COLOR_TABLE_RED_SIZE 0x80DA +#define GL_COLOR_TABLE_GREEN_SIZE 0x80DB +#define GL_COLOR_TABLE_BLUE_SIZE 0x80DC +#define GL_COLOR_TABLE_ALPHA_SIZE 0x80DD +#define GL_COLOR_TABLE_LUMINANCE_SIZE 0x80DE +#define GL_COLOR_TABLE_INTENSITY_SIZE 0x80DF +#define GL_IGNORE_BORDER 0x8150 +#define GL_CONSTANT_BORDER 0x8151 +#define GL_WRAP_BORDER 0x8152 +#define GL_REPLICATE_BORDER 0x8153 +#define GL_CONVOLUTION_BORDER_COLOR 0x8154 + +typedef void (GLAPIENTRY * PFNGLCOLORSUBTABLEPROC) (GLenum target, GLsizei start, GLsizei count, GLenum format, GLenum type, const GLvoid *data); +typedef void (GLAPIENTRY * PFNGLCOLORTABLEPROC) (GLenum target, GLenum internalformat, GLsizei width, GLenum format, GLenum type, const GLvoid *table); +typedef void (GLAPIENTRY * PFNGLCOLORTABLEPARAMETERFVPROC) (GLenum target, GLenum pname, const GLfloat *params); +typedef void (GLAPIENTRY * PFNGLCOLORTABLEPARAMETERIVPROC) (GLenum target, GLenum pname, const GLint *params); +typedef void (GLAPIENTRY * PFNGLCONVOLUTIONFILTER1DPROC) (GLenum target, GLenum internalformat, GLsizei width, GLenum format, GLenum type, const GLvoid *image); +typedef void (GLAPIENTRY * PFNGLCONVOLUTIONFILTER2DPROC) (GLenum target, GLenum internalformat, GLsizei width, GLsizei height, GLenum format, GLenum type, const GLvoid *image); +typedef void (GLAPIENTRY * PFNGLCONVOLUTIONPARAMETERFPROC) (GLenum target, GLenum pname, GLfloat params); +typedef void (GLAPIENTRY * PFNGLCONVOLUTIONPARAMETERFVPROC) (GLenum target, GLenum pname, const GLfloat *params); +typedef void (GLAPIENTRY * PFNGLCONVOLUTIONPARAMETERIPROC) (GLenum target, GLenum pname, GLint params); +typedef void (GLAPIENTRY * PFNGLCONVOLUTIONPARAMETERIVPROC) (GLenum target, GLenum pname, const GLint *params); +typedef void (GLAPIENTRY * PFNGLCOPYCOLORSUBTABLEPROC) (GLenum target, GLsizei start, GLint x, GLint y, GLsizei width); +typedef void (GLAPIENTRY * PFNGLCOPYCOLORTABLEPROC) (GLenum target, GLenum internalformat, GLint x, GLint y, GLsizei width); +typedef void (GLAPIENTRY * PFNGLCOPYCONVOLUTIONFILTER1DPROC) (GLenum target, GLenum internalformat, GLint x, GLint y, GLsizei width); +typedef void (GLAPIENTRY * PFNGLCOPYCONVOLUTIONFILTER2DPROC) (GLenum target, GLenum internalformat, GLint x, GLint y, GLsizei width, GLsizei height); +typedef void (GLAPIENTRY * PFNGLGETCOLORTABLEPROC) (GLenum target, GLenum format, GLenum type, GLvoid *table); +typedef void (GLAPIENTRY * PFNGLGETCOLORTABLEPARAMETERFVPROC) (GLenum target, GLenum pname, GLfloat *params); +typedef void (GLAPIENTRY * PFNGLGETCOLORTABLEPARAMETERIVPROC) (GLenum target, GLenum pname, GLint *params); +typedef void (GLAPIENTRY * PFNGLGETCONVOLUTIONFILTERPROC) (GLenum target, GLenum format, GLenum type, GLvoid *image); +typedef void (GLAPIENTRY * PFNGLGETCONVOLUTIONPARAMETERFVPROC) (GLenum target, GLenum pname, GLfloat *params); +typedef void (GLAPIENTRY * PFNGLGETCONVOLUTIONPARAMETERIVPROC) (GLenum target, GLenum pname, GLint *params); +typedef void (GLAPIENTRY * PFNGLGETHISTOGRAMPROC) (GLenum target, GLboolean reset, GLenum format, GLenum type, GLvoid *values); +typedef void (GLAPIENTRY * PFNGLGETHISTOGRAMPARAMETERFVPROC) (GLenum target, GLenum pname, GLfloat *params); +typedef void (GLAPIENTRY * PFNGLGETHISTOGRAMPARAMETERIVPROC) (GLenum target, GLenum pname, GLint *params); +typedef void (GLAPIENTRY * PFNGLGETMINMAXPROC) (GLenum target, GLboolean reset, GLenum format, GLenum types, GLvoid *values); +typedef void (GLAPIENTRY * PFNGLGETMINMAXPARAMETERFVPROC) (GLenum target, GLenum pname, GLfloat *params); +typedef void (GLAPIENTRY * PFNGLGETMINMAXPARAMETERIVPROC) (GLenum target, GLenum pname, GLint *params); +typedef void (GLAPIENTRY * PFNGLGETSEPARABLEFILTERPROC) (GLenum target, GLenum format, GLenum type, GLvoid *row, GLvoid *column, GLvoid *span); +typedef void (GLAPIENTRY * PFNGLHISTOGRAMPROC) (GLenum target, GLsizei width, GLenum internalformat, GLboolean sink); +typedef void (GLAPIENTRY * PFNGLMINMAXPROC) (GLenum target, GLenum internalformat, GLboolean sink); +typedef void (GLAPIENTRY * PFNGLRESETHISTOGRAMPROC) (GLenum target); +typedef void (GLAPIENTRY * PFNGLRESETMINMAXPROC) (GLenum target); +typedef void (GLAPIENTRY * PFNGLSEPARABLEFILTER2DPROC) (GLenum target, GLenum internalformat, GLsizei width, GLsizei height, GLenum format, GLenum type, const GLvoid *row, const GLvoid *column); + +#define glColorSubTable GLEW_GET_FUN(__glewColorSubTable) +#define glColorTable GLEW_GET_FUN(__glewColorTable) +#define glColorTableParameterfv GLEW_GET_FUN(__glewColorTableParameterfv) +#define glColorTableParameteriv GLEW_GET_FUN(__glewColorTableParameteriv) +#define glConvolutionFilter1D GLEW_GET_FUN(__glewConvolutionFilter1D) +#define glConvolutionFilter2D GLEW_GET_FUN(__glewConvolutionFilter2D) +#define glConvolutionParameterf GLEW_GET_FUN(__glewConvolutionParameterf) +#define glConvolutionParameterfv GLEW_GET_FUN(__glewConvolutionParameterfv) +#define glConvolutionParameteri GLEW_GET_FUN(__glewConvolutionParameteri) +#define glConvolutionParameteriv GLEW_GET_FUN(__glewConvolutionParameteriv) +#define glCopyColorSubTable GLEW_GET_FUN(__glewCopyColorSubTable) +#define glCopyColorTable GLEW_GET_FUN(__glewCopyColorTable) +#define glCopyConvolutionFilter1D GLEW_GET_FUN(__glewCopyConvolutionFilter1D) +#define glCopyConvolutionFilter2D GLEW_GET_FUN(__glewCopyConvolutionFilter2D) +#define glGetColorTable GLEW_GET_FUN(__glewGetColorTable) +#define glGetColorTableParameterfv GLEW_GET_FUN(__glewGetColorTableParameterfv) +#define glGetColorTableParameteriv GLEW_GET_FUN(__glewGetColorTableParameteriv) +#define glGetConvolutionFilter GLEW_GET_FUN(__glewGetConvolutionFilter) +#define glGetConvolutionParameterfv GLEW_GET_FUN(__glewGetConvolutionParameterfv) +#define glGetConvolutionParameteriv GLEW_GET_FUN(__glewGetConvolutionParameteriv) +#define glGetHistogram GLEW_GET_FUN(__glewGetHistogram) +#define glGetHistogramParameterfv GLEW_GET_FUN(__glewGetHistogramParameterfv) +#define glGetHistogramParameteriv GLEW_GET_FUN(__glewGetHistogramParameteriv) +#define glGetMinmax GLEW_GET_FUN(__glewGetMinmax) +#define glGetMinmaxParameterfv GLEW_GET_FUN(__glewGetMinmaxParameterfv) +#define glGetMinmaxParameteriv GLEW_GET_FUN(__glewGetMinmaxParameteriv) +#define glGetSeparableFilter GLEW_GET_FUN(__glewGetSeparableFilter) +#define glHistogram GLEW_GET_FUN(__glewHistogram) +#define glMinmax GLEW_GET_FUN(__glewMinmax) +#define glResetHistogram GLEW_GET_FUN(__glewResetHistogram) +#define glResetMinmax GLEW_GET_FUN(__glewResetMinmax) +#define glSeparableFilter2D GLEW_GET_FUN(__glewSeparableFilter2D) + +#define GLEW_ARB_imaging GLEW_GET_VAR(__GLEW_ARB_imaging) + +#endif /* GL_ARB_imaging */ + +/* ------------------------ GL_ARB_instanced_arrays ------------------------ */ + +#ifndef GL_ARB_instanced_arrays +#define GL_ARB_instanced_arrays 1 + +#define GL_VERTEX_ATTRIB_ARRAY_DIVISOR_ARB 0x88FE + +typedef void (GLAPIENTRY * PFNGLVERTEXATTRIBDIVISORARBPROC) (GLuint index, GLuint divisor); + +#define glVertexAttribDivisorARB GLEW_GET_FUN(__glewVertexAttribDivisorARB) + +#define GLEW_ARB_instanced_arrays GLEW_GET_VAR(__GLEW_ARB_instanced_arrays) + +#endif /* GL_ARB_instanced_arrays */ + +/* ------------------------ GL_ARB_map_buffer_range ------------------------ */ + +#ifndef GL_ARB_map_buffer_range +#define GL_ARB_map_buffer_range 1 + +#define GL_MAP_READ_BIT 0x0001 +#define GL_MAP_WRITE_BIT 0x0002 +#define GL_MAP_INVALIDATE_RANGE_BIT 0x0004 +#define GL_MAP_INVALIDATE_BUFFER_BIT 0x0008 +#define GL_MAP_FLUSH_EXPLICIT_BIT 0x0010 +#define GL_MAP_UNSYNCHRONIZED_BIT 0x0020 + +typedef void (GLAPIENTRY * PFNGLFLUSHMAPPEDBUFFERRANGEPROC) (GLenum target, GLintptr offset, GLsizeiptr length); +typedef GLvoid * (GLAPIENTRY * PFNGLMAPBUFFERRANGEPROC) (GLenum target, GLintptr offset, GLsizeiptr length, GLbitfield access); + +#define glFlushMappedBufferRange GLEW_GET_FUN(__glewFlushMappedBufferRange) +#define glMapBufferRange GLEW_GET_FUN(__glewMapBufferRange) + +#define GLEW_ARB_map_buffer_range GLEW_GET_VAR(__GLEW_ARB_map_buffer_range) + +#endif /* GL_ARB_map_buffer_range */ + +/* ------------------------- GL_ARB_matrix_palette ------------------------- */ + +#ifndef GL_ARB_matrix_palette +#define GL_ARB_matrix_palette 1 + +#define GL_MATRIX_PALETTE_ARB 0x8840 +#define GL_MAX_MATRIX_PALETTE_STACK_DEPTH_ARB 0x8841 +#define GL_MAX_PALETTE_MATRICES_ARB 0x8842 +#define GL_CURRENT_PALETTE_MATRIX_ARB 0x8843 +#define GL_MATRIX_INDEX_ARRAY_ARB 0x8844 +#define GL_CURRENT_MATRIX_INDEX_ARB 0x8845 +#define GL_MATRIX_INDEX_ARRAY_SIZE_ARB 0x8846 +#define GL_MATRIX_INDEX_ARRAY_TYPE_ARB 0x8847 +#define GL_MATRIX_INDEX_ARRAY_STRIDE_ARB 0x8848 +#define GL_MATRIX_INDEX_ARRAY_POINTER_ARB 0x8849 + +typedef void (GLAPIENTRY * PFNGLCURRENTPALETTEMATRIXARBPROC) (GLint index); +typedef void (GLAPIENTRY * PFNGLMATRIXINDEXPOINTERARBPROC) (GLint size, GLenum type, GLsizei stride, GLvoid *pointer); +typedef void (GLAPIENTRY * PFNGLMATRIXINDEXUBVARBPROC) (GLint size, GLubyte *indices); +typedef void (GLAPIENTRY * PFNGLMATRIXINDEXUIVARBPROC) (GLint size, GLuint *indices); +typedef void (GLAPIENTRY * PFNGLMATRIXINDEXUSVARBPROC) (GLint size, GLushort *indices); + +#define glCurrentPaletteMatrixARB GLEW_GET_FUN(__glewCurrentPaletteMatrixARB) +#define glMatrixIndexPointerARB GLEW_GET_FUN(__glewMatrixIndexPointerARB) +#define glMatrixIndexubvARB GLEW_GET_FUN(__glewMatrixIndexubvARB) +#define glMatrixIndexuivARB GLEW_GET_FUN(__glewMatrixIndexuivARB) +#define glMatrixIndexusvARB GLEW_GET_FUN(__glewMatrixIndexusvARB) + +#define GLEW_ARB_matrix_palette GLEW_GET_VAR(__GLEW_ARB_matrix_palette) + +#endif /* GL_ARB_matrix_palette */ + +/* --------------------------- GL_ARB_multisample -------------------------- */ + +#ifndef GL_ARB_multisample +#define GL_ARB_multisample 1 + +#define GL_MULTISAMPLE_ARB 0x809D +#define GL_SAMPLE_ALPHA_TO_COVERAGE_ARB 0x809E +#define GL_SAMPLE_ALPHA_TO_ONE_ARB 0x809F +#define GL_SAMPLE_COVERAGE_ARB 0x80A0 +#define GL_SAMPLE_BUFFERS_ARB 0x80A8 +#define GL_SAMPLES_ARB 0x80A9 +#define GL_SAMPLE_COVERAGE_VALUE_ARB 0x80AA +#define GL_SAMPLE_COVERAGE_INVERT_ARB 0x80AB +#define GL_MULTISAMPLE_BIT_ARB 0x20000000 + +typedef void (GLAPIENTRY * PFNGLSAMPLECOVERAGEARBPROC) (GLclampf value, GLboolean invert); + +#define glSampleCoverageARB GLEW_GET_FUN(__glewSampleCoverageARB) + +#define GLEW_ARB_multisample GLEW_GET_VAR(__GLEW_ARB_multisample) + +#endif /* GL_ARB_multisample */ + +/* -------------------------- GL_ARB_multitexture -------------------------- */ + +#ifndef GL_ARB_multitexture +#define GL_ARB_multitexture 1 + +#define GL_TEXTURE0_ARB 0x84C0 +#define GL_TEXTURE1_ARB 0x84C1 +#define GL_TEXTURE2_ARB 0x84C2 +#define GL_TEXTURE3_ARB 0x84C3 +#define GL_TEXTURE4_ARB 0x84C4 +#define GL_TEXTURE5_ARB 0x84C5 +#define GL_TEXTURE6_ARB 0x84C6 +#define GL_TEXTURE7_ARB 0x84C7 +#define GL_TEXTURE8_ARB 0x84C8 +#define GL_TEXTURE9_ARB 0x84C9 +#define GL_TEXTURE10_ARB 0x84CA +#define GL_TEXTURE11_ARB 0x84CB +#define GL_TEXTURE12_ARB 0x84CC +#define GL_TEXTURE13_ARB 0x84CD +#define GL_TEXTURE14_ARB 0x84CE +#define GL_TEXTURE15_ARB 0x84CF +#define GL_TEXTURE16_ARB 0x84D0 +#define GL_TEXTURE17_ARB 0x84D1 +#define GL_TEXTURE18_ARB 0x84D2 +#define GL_TEXTURE19_ARB 0x84D3 +#define GL_TEXTURE20_ARB 0x84D4 +#define GL_TEXTURE21_ARB 0x84D5 +#define GL_TEXTURE22_ARB 0x84D6 +#define GL_TEXTURE23_ARB 0x84D7 +#define GL_TEXTURE24_ARB 0x84D8 +#define GL_TEXTURE25_ARB 0x84D9 +#define GL_TEXTURE26_ARB 0x84DA +#define GL_TEXTURE27_ARB 0x84DB +#define GL_TEXTURE28_ARB 0x84DC +#define GL_TEXTURE29_ARB 0x84DD +#define GL_TEXTURE30_ARB 0x84DE +#define GL_TEXTURE31_ARB 0x84DF +#define GL_ACTIVE_TEXTURE_ARB 0x84E0 +#define GL_CLIENT_ACTIVE_TEXTURE_ARB 0x84E1 +#define GL_MAX_TEXTURE_UNITS_ARB 0x84E2 + +typedef void (GLAPIENTRY * PFNGLACTIVETEXTUREARBPROC) (GLenum texture); +typedef void (GLAPIENTRY * PFNGLCLIENTACTIVETEXTUREARBPROC) (GLenum texture); +typedef void (GLAPIENTRY * PFNGLMULTITEXCOORD1DARBPROC) (GLenum target, GLdouble s); +typedef void (GLAPIENTRY * PFNGLMULTITEXCOORD1DVARBPROC) (GLenum target, const GLdouble *v); +typedef void (GLAPIENTRY * PFNGLMULTITEXCOORD1FARBPROC) (GLenum target, GLfloat s); +typedef void (GLAPIENTRY * PFNGLMULTITEXCOORD1FVARBPROC) (GLenum target, const GLfloat *v); +typedef void (GLAPIENTRY * PFNGLMULTITEXCOORD1IARBPROC) (GLenum target, GLint s); +typedef void (GLAPIENTRY * PFNGLMULTITEXCOORD1IVARBPROC) (GLenum target, const GLint *v); +typedef void (GLAPIENTRY * PFNGLMULTITEXCOORD1SARBPROC) (GLenum target, GLshort s); +typedef void (GLAPIENTRY * PFNGLMULTITEXCOORD1SVARBPROC) (GLenum target, const GLshort *v); +typedef void (GLAPIENTRY * PFNGLMULTITEXCOORD2DARBPROC) (GLenum target, GLdouble s, GLdouble t); +typedef void (GLAPIENTRY * PFNGLMULTITEXCOORD2DVARBPROC) (GLenum target, const GLdouble *v); +typedef void (GLAPIENTRY * PFNGLMULTITEXCOORD2FARBPROC) (GLenum target, GLfloat s, GLfloat t); +typedef void (GLAPIENTRY * PFNGLMULTITEXCOORD2FVARBPROC) (GLenum target, const GLfloat *v); +typedef void (GLAPIENTRY * PFNGLMULTITEXCOORD2IARBPROC) (GLenum target, GLint s, GLint t); +typedef void (GLAPIENTRY * PFNGLMULTITEXCOORD2IVARBPROC) (GLenum target, const GLint *v); +typedef void (GLAPIENTRY * PFNGLMULTITEXCOORD2SARBPROC) (GLenum target, GLshort s, GLshort t); +typedef void (GLAPIENTRY * PFNGLMULTITEXCOORD2SVARBPROC) (GLenum target, const GLshort *v); +typedef void (GLAPIENTRY * PFNGLMULTITEXCOORD3DARBPROC) (GLenum target, GLdouble s, GLdouble t, GLdouble r); +typedef void (GLAPIENTRY * PFNGLMULTITEXCOORD3DVARBPROC) (GLenum target, const GLdouble *v); +typedef void (GLAPIENTRY * PFNGLMULTITEXCOORD3FARBPROC) (GLenum target, GLfloat s, GLfloat t, GLfloat r); +typedef void (GLAPIENTRY * PFNGLMULTITEXCOORD3FVARBPROC) (GLenum target, const GLfloat *v); +typedef void (GLAPIENTRY * PFNGLMULTITEXCOORD3IARBPROC) (GLenum target, GLint s, GLint t, GLint r); +typedef void (GLAPIENTRY * PFNGLMULTITEXCOORD3IVARBPROC) (GLenum target, const GLint *v); +typedef void (GLAPIENTRY * PFNGLMULTITEXCOORD3SARBPROC) (GLenum target, GLshort s, GLshort t, GLshort r); +typedef void (GLAPIENTRY * PFNGLMULTITEXCOORD3SVARBPROC) (GLenum target, const GLshort *v); +typedef void (GLAPIENTRY * PFNGLMULTITEXCOORD4DARBPROC) (GLenum target, GLdouble s, GLdouble t, GLdouble r, GLdouble q); +typedef void (GLAPIENTRY * PFNGLMULTITEXCOORD4DVARBPROC) (GLenum target, const GLdouble *v); +typedef void (GLAPIENTRY * PFNGLMULTITEXCOORD4FARBPROC) (GLenum target, GLfloat s, GLfloat t, GLfloat r, GLfloat q); +typedef void (GLAPIENTRY * PFNGLMULTITEXCOORD4FVARBPROC) (GLenum target, const GLfloat *v); +typedef void (GLAPIENTRY * PFNGLMULTITEXCOORD4IARBPROC) (GLenum target, GLint s, GLint t, GLint r, GLint q); +typedef void (GLAPIENTRY * PFNGLMULTITEXCOORD4IVARBPROC) (GLenum target, const GLint *v); +typedef void (GLAPIENTRY * PFNGLMULTITEXCOORD4SARBPROC) (GLenum target, GLshort s, GLshort t, GLshort r, GLshort q); +typedef void (GLAPIENTRY * PFNGLMULTITEXCOORD4SVARBPROC) (GLenum target, const GLshort *v); + +#define glActiveTextureARB GLEW_GET_FUN(__glewActiveTextureARB) +#define glClientActiveTextureARB GLEW_GET_FUN(__glewClientActiveTextureARB) +#define glMultiTexCoord1dARB GLEW_GET_FUN(__glewMultiTexCoord1dARB) +#define glMultiTexCoord1dvARB GLEW_GET_FUN(__glewMultiTexCoord1dvARB) +#define glMultiTexCoord1fARB GLEW_GET_FUN(__glewMultiTexCoord1fARB) +#define glMultiTexCoord1fvARB GLEW_GET_FUN(__glewMultiTexCoord1fvARB) +#define glMultiTexCoord1iARB GLEW_GET_FUN(__glewMultiTexCoord1iARB) +#define glMultiTexCoord1ivARB GLEW_GET_FUN(__glewMultiTexCoord1ivARB) +#define glMultiTexCoord1sARB GLEW_GET_FUN(__glewMultiTexCoord1sARB) +#define glMultiTexCoord1svARB GLEW_GET_FUN(__glewMultiTexCoord1svARB) +#define glMultiTexCoord2dARB GLEW_GET_FUN(__glewMultiTexCoord2dARB) +#define glMultiTexCoord2dvARB GLEW_GET_FUN(__glewMultiTexCoord2dvARB) +#define glMultiTexCoord2fARB GLEW_GET_FUN(__glewMultiTexCoord2fARB) +#define glMultiTexCoord2fvARB GLEW_GET_FUN(__glewMultiTexCoord2fvARB) +#define glMultiTexCoord2iARB GLEW_GET_FUN(__glewMultiTexCoord2iARB) +#define glMultiTexCoord2ivARB GLEW_GET_FUN(__glewMultiTexCoord2ivARB) +#define glMultiTexCoord2sARB GLEW_GET_FUN(__glewMultiTexCoord2sARB) +#define glMultiTexCoord2svARB GLEW_GET_FUN(__glewMultiTexCoord2svARB) +#define glMultiTexCoord3dARB GLEW_GET_FUN(__glewMultiTexCoord3dARB) +#define glMultiTexCoord3dvARB GLEW_GET_FUN(__glewMultiTexCoord3dvARB) +#define glMultiTexCoord3fARB GLEW_GET_FUN(__glewMultiTexCoord3fARB) +#define glMultiTexCoord3fvARB GLEW_GET_FUN(__glewMultiTexCoord3fvARB) +#define glMultiTexCoord3iARB GLEW_GET_FUN(__glewMultiTexCoord3iARB) +#define glMultiTexCoord3ivARB GLEW_GET_FUN(__glewMultiTexCoord3ivARB) +#define glMultiTexCoord3sARB GLEW_GET_FUN(__glewMultiTexCoord3sARB) +#define glMultiTexCoord3svARB GLEW_GET_FUN(__glewMultiTexCoord3svARB) +#define glMultiTexCoord4dARB GLEW_GET_FUN(__glewMultiTexCoord4dARB) +#define glMultiTexCoord4dvARB GLEW_GET_FUN(__glewMultiTexCoord4dvARB) +#define glMultiTexCoord4fARB GLEW_GET_FUN(__glewMultiTexCoord4fARB) +#define glMultiTexCoord4fvARB GLEW_GET_FUN(__glewMultiTexCoord4fvARB) +#define glMultiTexCoord4iARB GLEW_GET_FUN(__glewMultiTexCoord4iARB) +#define glMultiTexCoord4ivARB GLEW_GET_FUN(__glewMultiTexCoord4ivARB) +#define glMultiTexCoord4sARB GLEW_GET_FUN(__glewMultiTexCoord4sARB) +#define glMultiTexCoord4svARB GLEW_GET_FUN(__glewMultiTexCoord4svARB) + +#define GLEW_ARB_multitexture GLEW_GET_VAR(__GLEW_ARB_multitexture) + +#endif /* GL_ARB_multitexture */ + +/* ------------------------- GL_ARB_occlusion_query ------------------------ */ + +#ifndef GL_ARB_occlusion_query +#define GL_ARB_occlusion_query 1 + +#define GL_QUERY_COUNTER_BITS_ARB 0x8864 +#define GL_CURRENT_QUERY_ARB 0x8865 +#define GL_QUERY_RESULT_ARB 0x8866 +#define GL_QUERY_RESULT_AVAILABLE_ARB 0x8867 +#define GL_SAMPLES_PASSED_ARB 0x8914 + +typedef void (GLAPIENTRY * PFNGLBEGINQUERYARBPROC) (GLenum target, GLuint id); +typedef void (GLAPIENTRY * PFNGLDELETEQUERIESARBPROC) (GLsizei n, const GLuint* ids); +typedef void (GLAPIENTRY * PFNGLENDQUERYARBPROC) (GLenum target); +typedef void (GLAPIENTRY * PFNGLGENQUERIESARBPROC) (GLsizei n, GLuint* ids); +typedef void (GLAPIENTRY * PFNGLGETQUERYOBJECTIVARBPROC) (GLuint id, GLenum pname, GLint* params); +typedef void (GLAPIENTRY * PFNGLGETQUERYOBJECTUIVARBPROC) (GLuint id, GLenum pname, GLuint* params); +typedef void (GLAPIENTRY * PFNGLGETQUERYIVARBPROC) (GLenum target, GLenum pname, GLint* params); +typedef GLboolean (GLAPIENTRY * PFNGLISQUERYARBPROC) (GLuint id); + +#define glBeginQueryARB GLEW_GET_FUN(__glewBeginQueryARB) +#define glDeleteQueriesARB GLEW_GET_FUN(__glewDeleteQueriesARB) +#define glEndQueryARB GLEW_GET_FUN(__glewEndQueryARB) +#define glGenQueriesARB GLEW_GET_FUN(__glewGenQueriesARB) +#define glGetQueryObjectivARB GLEW_GET_FUN(__glewGetQueryObjectivARB) +#define glGetQueryObjectuivARB GLEW_GET_FUN(__glewGetQueryObjectuivARB) +#define glGetQueryivARB GLEW_GET_FUN(__glewGetQueryivARB) +#define glIsQueryARB GLEW_GET_FUN(__glewIsQueryARB) + +#define GLEW_ARB_occlusion_query GLEW_GET_VAR(__GLEW_ARB_occlusion_query) + +#endif /* GL_ARB_occlusion_query */ + +/* ----------------------- GL_ARB_pixel_buffer_object ---------------------- */ + +#ifndef GL_ARB_pixel_buffer_object +#define GL_ARB_pixel_buffer_object 1 + +#define GL_PIXEL_PACK_BUFFER_ARB 0x88EB +#define GL_PIXEL_UNPACK_BUFFER_ARB 0x88EC +#define GL_PIXEL_PACK_BUFFER_BINDING_ARB 0x88ED +#define GL_PIXEL_UNPACK_BUFFER_BINDING_ARB 0x88EF + +#define GLEW_ARB_pixel_buffer_object GLEW_GET_VAR(__GLEW_ARB_pixel_buffer_object) + +#endif /* GL_ARB_pixel_buffer_object */ + +/* ------------------------ GL_ARB_point_parameters ------------------------ */ + +#ifndef GL_ARB_point_parameters +#define GL_ARB_point_parameters 1 + +#define GL_POINT_SIZE_MIN_ARB 0x8126 +#define GL_POINT_SIZE_MAX_ARB 0x8127 +#define GL_POINT_FADE_THRESHOLD_SIZE_ARB 0x8128 +#define GL_POINT_DISTANCE_ATTENUATION_ARB 0x8129 + +typedef void (GLAPIENTRY * PFNGLPOINTPARAMETERFARBPROC) (GLenum pname, GLfloat param); +typedef void (GLAPIENTRY * PFNGLPOINTPARAMETERFVARBPROC) (GLenum pname, GLfloat* params); + +#define glPointParameterfARB GLEW_GET_FUN(__glewPointParameterfARB) +#define glPointParameterfvARB GLEW_GET_FUN(__glewPointParameterfvARB) + +#define GLEW_ARB_point_parameters GLEW_GET_VAR(__GLEW_ARB_point_parameters) + +#endif /* GL_ARB_point_parameters */ + +/* -------------------------- GL_ARB_point_sprite -------------------------- */ + +#ifndef GL_ARB_point_sprite +#define GL_ARB_point_sprite 1 + +#define GL_POINT_SPRITE_ARB 0x8861 +#define GL_COORD_REPLACE_ARB 0x8862 + +#define GLEW_ARB_point_sprite GLEW_GET_VAR(__GLEW_ARB_point_sprite) + +#endif /* GL_ARB_point_sprite */ + +/* ------------------------- GL_ARB_shader_objects ------------------------- */ + +#ifndef GL_ARB_shader_objects +#define GL_ARB_shader_objects 1 + +#define GL_PROGRAM_OBJECT_ARB 0x8B40 +#define GL_SHADER_OBJECT_ARB 0x8B48 +#define GL_OBJECT_TYPE_ARB 0x8B4E +#define GL_OBJECT_SUBTYPE_ARB 0x8B4F +#define GL_FLOAT_VEC2_ARB 0x8B50 +#define GL_FLOAT_VEC3_ARB 0x8B51 +#define GL_FLOAT_VEC4_ARB 0x8B52 +#define GL_INT_VEC2_ARB 0x8B53 +#define GL_INT_VEC3_ARB 0x8B54 +#define GL_INT_VEC4_ARB 0x8B55 +#define GL_BOOL_ARB 0x8B56 +#define GL_BOOL_VEC2_ARB 0x8B57 +#define GL_BOOL_VEC3_ARB 0x8B58 +#define GL_BOOL_VEC4_ARB 0x8B59 +#define GL_FLOAT_MAT2_ARB 0x8B5A +#define GL_FLOAT_MAT3_ARB 0x8B5B +#define GL_FLOAT_MAT4_ARB 0x8B5C +#define GL_SAMPLER_1D_ARB 0x8B5D +#define GL_SAMPLER_2D_ARB 0x8B5E +#define GL_SAMPLER_3D_ARB 0x8B5F +#define GL_SAMPLER_CUBE_ARB 0x8B60 +#define GL_SAMPLER_1D_SHADOW_ARB 0x8B61 +#define GL_SAMPLER_2D_SHADOW_ARB 0x8B62 +#define GL_SAMPLER_2D_RECT_ARB 0x8B63 +#define GL_SAMPLER_2D_RECT_SHADOW_ARB 0x8B64 +#define GL_OBJECT_DELETE_STATUS_ARB 0x8B80 +#define GL_OBJECT_COMPILE_STATUS_ARB 0x8B81 +#define GL_OBJECT_LINK_STATUS_ARB 0x8B82 +#define GL_OBJECT_VALIDATE_STATUS_ARB 0x8B83 +#define GL_OBJECT_INFO_LOG_LENGTH_ARB 0x8B84 +#define GL_OBJECT_ATTACHED_OBJECTS_ARB 0x8B85 +#define GL_OBJECT_ACTIVE_UNIFORMS_ARB 0x8B86 +#define GL_OBJECT_ACTIVE_UNIFORM_MAX_LENGTH_ARB 0x8B87 +#define GL_OBJECT_SHADER_SOURCE_LENGTH_ARB 0x8B88 + +typedef char GLcharARB; +typedef unsigned int GLhandleARB; + +typedef void (GLAPIENTRY * PFNGLATTACHOBJECTARBPROC) (GLhandleARB containerObj, GLhandleARB obj); +typedef void (GLAPIENTRY * PFNGLCOMPILESHADERARBPROC) (GLhandleARB shaderObj); +typedef GLhandleARB (GLAPIENTRY * PFNGLCREATEPROGRAMOBJECTARBPROC) (void); +typedef GLhandleARB (GLAPIENTRY * PFNGLCREATESHADEROBJECTARBPROC) (GLenum shaderType); +typedef void (GLAPIENTRY * PFNGLDELETEOBJECTARBPROC) (GLhandleARB obj); +typedef void (GLAPIENTRY * PFNGLDETACHOBJECTARBPROC) (GLhandleARB containerObj, GLhandleARB attachedObj); +typedef void (GLAPIENTRY * PFNGLGETACTIVEUNIFORMARBPROC) (GLhandleARB programObj, GLuint index, GLsizei maxLength, GLsizei* length, GLint *size, GLenum *type, GLcharARB *name); +typedef void (GLAPIENTRY * PFNGLGETATTACHEDOBJECTSARBPROC) (GLhandleARB containerObj, GLsizei maxCount, GLsizei* count, GLhandleARB *obj); +typedef GLhandleARB (GLAPIENTRY * PFNGLGETHANDLEARBPROC) (GLenum pname); +typedef void (GLAPIENTRY * PFNGLGETINFOLOGARBPROC) (GLhandleARB obj, GLsizei maxLength, GLsizei* length, GLcharARB *infoLog); +typedef void (GLAPIENTRY * PFNGLGETOBJECTPARAMETERFVARBPROC) (GLhandleARB obj, GLenum pname, GLfloat* params); +typedef void (GLAPIENTRY * PFNGLGETOBJECTPARAMETERIVARBPROC) (GLhandleARB obj, GLenum pname, GLint* params); +typedef void (GLAPIENTRY * PFNGLGETSHADERSOURCEARBPROC) (GLhandleARB obj, GLsizei maxLength, GLsizei* length, GLcharARB *source); +typedef GLint (GLAPIENTRY * PFNGLGETUNIFORMLOCATIONARBPROC) (GLhandleARB programObj, const GLcharARB* name); +typedef void (GLAPIENTRY * PFNGLGETUNIFORMFVARBPROC) (GLhandleARB programObj, GLint location, GLfloat* params); +typedef void (GLAPIENTRY * PFNGLGETUNIFORMIVARBPROC) (GLhandleARB programObj, GLint location, GLint* params); +typedef void (GLAPIENTRY * PFNGLLINKPROGRAMARBPROC) (GLhandleARB programObj); +typedef void (GLAPIENTRY * PFNGLSHADERSOURCEARBPROC) (GLhandleARB shaderObj, GLsizei count, const GLcharARB ** string, const GLint *length); +typedef void (GLAPIENTRY * PFNGLUNIFORM1FARBPROC) (GLint location, GLfloat v0); +typedef void (GLAPIENTRY * PFNGLUNIFORM1FVARBPROC) (GLint location, GLsizei count, const GLfloat* value); +typedef void (GLAPIENTRY * PFNGLUNIFORM1IARBPROC) (GLint location, GLint v0); +typedef void (GLAPIENTRY * PFNGLUNIFORM1IVARBPROC) (GLint location, GLsizei count, const GLint* value); +typedef void (GLAPIENTRY * PFNGLUNIFORM2FARBPROC) (GLint location, GLfloat v0, GLfloat v1); +typedef void (GLAPIENTRY * PFNGLUNIFORM2FVARBPROC) (GLint location, GLsizei count, const GLfloat* value); +typedef void (GLAPIENTRY * PFNGLUNIFORM2IARBPROC) (GLint location, GLint v0, GLint v1); +typedef void (GLAPIENTRY * PFNGLUNIFORM2IVARBPROC) (GLint location, GLsizei count, const GLint* value); +typedef void (GLAPIENTRY * PFNGLUNIFORM3FARBPROC) (GLint location, GLfloat v0, GLfloat v1, GLfloat v2); +typedef void (GLAPIENTRY * PFNGLUNIFORM3FVARBPROC) (GLint location, GLsizei count, const GLfloat* value); +typedef void (GLAPIENTRY * PFNGLUNIFORM3IARBPROC) (GLint location, GLint v0, GLint v1, GLint v2); +typedef void (GLAPIENTRY * PFNGLUNIFORM3IVARBPROC) (GLint location, GLsizei count, const GLint* value); +typedef void (GLAPIENTRY * PFNGLUNIFORM4FARBPROC) (GLint location, GLfloat v0, GLfloat v1, GLfloat v2, GLfloat v3); +typedef void (GLAPIENTRY * PFNGLUNIFORM4FVARBPROC) (GLint location, GLsizei count, const GLfloat* value); +typedef void (GLAPIENTRY * PFNGLUNIFORM4IARBPROC) (GLint location, GLint v0, GLint v1, GLint v2, GLint v3); +typedef void (GLAPIENTRY * PFNGLUNIFORM4IVARBPROC) (GLint location, GLsizei count, const GLint* value); +typedef void (GLAPIENTRY * PFNGLUNIFORMMATRIX2FVARBPROC) (GLint location, GLsizei count, GLboolean transpose, const GLfloat* value); +typedef void (GLAPIENTRY * PFNGLUNIFORMMATRIX3FVARBPROC) (GLint location, GLsizei count, GLboolean transpose, const GLfloat* value); +typedef void (GLAPIENTRY * PFNGLUNIFORMMATRIX4FVARBPROC) (GLint location, GLsizei count, GLboolean transpose, const GLfloat* value); +typedef void (GLAPIENTRY * PFNGLUSEPROGRAMOBJECTARBPROC) (GLhandleARB programObj); +typedef void (GLAPIENTRY * PFNGLVALIDATEPROGRAMARBPROC) (GLhandleARB programObj); + +#define glAttachObjectARB GLEW_GET_FUN(__glewAttachObjectARB) +#define glCompileShaderARB GLEW_GET_FUN(__glewCompileShaderARB) +#define glCreateProgramObjectARB GLEW_GET_FUN(__glewCreateProgramObjectARB) +#define glCreateShaderObjectARB GLEW_GET_FUN(__glewCreateShaderObjectARB) +#define glDeleteObjectARB GLEW_GET_FUN(__glewDeleteObjectARB) +#define glDetachObjectARB GLEW_GET_FUN(__glewDetachObjectARB) +#define glGetActiveUniformARB GLEW_GET_FUN(__glewGetActiveUniformARB) +#define glGetAttachedObjectsARB GLEW_GET_FUN(__glewGetAttachedObjectsARB) +#define glGetHandleARB GLEW_GET_FUN(__glewGetHandleARB) +#define glGetInfoLogARB GLEW_GET_FUN(__glewGetInfoLogARB) +#define glGetObjectParameterfvARB GLEW_GET_FUN(__glewGetObjectParameterfvARB) +#define glGetObjectParameterivARB GLEW_GET_FUN(__glewGetObjectParameterivARB) +#define glGetShaderSourceARB GLEW_GET_FUN(__glewGetShaderSourceARB) +#define glGetUniformLocationARB GLEW_GET_FUN(__glewGetUniformLocationARB) +#define glGetUniformfvARB GLEW_GET_FUN(__glewGetUniformfvARB) +#define glGetUniformivARB GLEW_GET_FUN(__glewGetUniformivARB) +#define glLinkProgramARB GLEW_GET_FUN(__glewLinkProgramARB) +#define glShaderSourceARB GLEW_GET_FUN(__glewShaderSourceARB) +#define glUniform1fARB GLEW_GET_FUN(__glewUniform1fARB) +#define glUniform1fvARB GLEW_GET_FUN(__glewUniform1fvARB) +#define glUniform1iARB GLEW_GET_FUN(__glewUniform1iARB) +#define glUniform1ivARB GLEW_GET_FUN(__glewUniform1ivARB) +#define glUniform2fARB GLEW_GET_FUN(__glewUniform2fARB) +#define glUniform2fvARB GLEW_GET_FUN(__glewUniform2fvARB) +#define glUniform2iARB GLEW_GET_FUN(__glewUniform2iARB) +#define glUniform2ivARB GLEW_GET_FUN(__glewUniform2ivARB) +#define glUniform3fARB GLEW_GET_FUN(__glewUniform3fARB) +#define glUniform3fvARB GLEW_GET_FUN(__glewUniform3fvARB) +#define glUniform3iARB GLEW_GET_FUN(__glewUniform3iARB) +#define glUniform3ivARB GLEW_GET_FUN(__glewUniform3ivARB) +#define glUniform4fARB GLEW_GET_FUN(__glewUniform4fARB) +#define glUniform4fvARB GLEW_GET_FUN(__glewUniform4fvARB) +#define glUniform4iARB GLEW_GET_FUN(__glewUniform4iARB) +#define glUniform4ivARB GLEW_GET_FUN(__glewUniform4ivARB) +#define glUniformMatrix2fvARB GLEW_GET_FUN(__glewUniformMatrix2fvARB) +#define glUniformMatrix3fvARB GLEW_GET_FUN(__glewUniformMatrix3fvARB) +#define glUniformMatrix4fvARB GLEW_GET_FUN(__glewUniformMatrix4fvARB) +#define glUseProgramObjectARB GLEW_GET_FUN(__glewUseProgramObjectARB) +#define glValidateProgramARB GLEW_GET_FUN(__glewValidateProgramARB) + +#define GLEW_ARB_shader_objects GLEW_GET_VAR(__GLEW_ARB_shader_objects) + +#endif /* GL_ARB_shader_objects */ + +/* ---------------------- GL_ARB_shading_language_100 ---------------------- */ + +#ifndef GL_ARB_shading_language_100 +#define GL_ARB_shading_language_100 1 + +#define GL_SHADING_LANGUAGE_VERSION_ARB 0x8B8C + +#define GLEW_ARB_shading_language_100 GLEW_GET_VAR(__GLEW_ARB_shading_language_100) + +#endif /* GL_ARB_shading_language_100 */ + +/* ----------------------------- GL_ARB_shadow ----------------------------- */ + +#ifndef GL_ARB_shadow +#define GL_ARB_shadow 1 + +#define GL_TEXTURE_COMPARE_MODE_ARB 0x884C +#define GL_TEXTURE_COMPARE_FUNC_ARB 0x884D +#define GL_COMPARE_R_TO_TEXTURE_ARB 0x884E + +#define GLEW_ARB_shadow GLEW_GET_VAR(__GLEW_ARB_shadow) + +#endif /* GL_ARB_shadow */ + +/* ------------------------- GL_ARB_shadow_ambient ------------------------- */ + +#ifndef GL_ARB_shadow_ambient +#define GL_ARB_shadow_ambient 1 + +#define GL_TEXTURE_COMPARE_FAIL_VALUE_ARB 0x80BF + +#define GLEW_ARB_shadow_ambient GLEW_GET_VAR(__GLEW_ARB_shadow_ambient) + +#endif /* GL_ARB_shadow_ambient */ + +/* ---------------------- GL_ARB_texture_border_clamp ---------------------- */ + +#ifndef GL_ARB_texture_border_clamp +#define GL_ARB_texture_border_clamp 1 + +#define GL_CLAMP_TO_BORDER_ARB 0x812D + +#define GLEW_ARB_texture_border_clamp GLEW_GET_VAR(__GLEW_ARB_texture_border_clamp) + +#endif /* GL_ARB_texture_border_clamp */ + +/* ---------------------- GL_ARB_texture_buffer_object --------------------- */ + +#ifndef GL_ARB_texture_buffer_object +#define GL_ARB_texture_buffer_object 1 + +#define GL_TEXTURE_BUFFER_ARB 0x8C2A +#define GL_MAX_TEXTURE_BUFFER_SIZE_ARB 0x8C2B +#define GL_TEXTURE_BINDING_BUFFER_ARB 0x8C2C +#define GL_TEXTURE_BUFFER_DATA_STORE_BINDING_ARB 0x8C2D +#define GL_TEXTURE_BUFFER_FORMAT_ARB 0x8C2E + +typedef void (GLAPIENTRY * PFNGLTEXBUFFERARBPROC) (GLenum target, GLenum internalformat, GLuint buffer); + +#define glTexBufferARB GLEW_GET_FUN(__glewTexBufferARB) + +#define GLEW_ARB_texture_buffer_object GLEW_GET_VAR(__GLEW_ARB_texture_buffer_object) + +#endif /* GL_ARB_texture_buffer_object */ + +/* ----------------------- GL_ARB_texture_compression ---------------------- */ + +#ifndef GL_ARB_texture_compression +#define GL_ARB_texture_compression 1 + +#define GL_COMPRESSED_ALPHA_ARB 0x84E9 +#define GL_COMPRESSED_LUMINANCE_ARB 0x84EA +#define GL_COMPRESSED_LUMINANCE_ALPHA_ARB 0x84EB +#define GL_COMPRESSED_INTENSITY_ARB 0x84EC +#define GL_COMPRESSED_RGB_ARB 0x84ED +#define GL_COMPRESSED_RGBA_ARB 0x84EE +#define GL_TEXTURE_COMPRESSION_HINT_ARB 0x84EF +#define GL_TEXTURE_COMPRESSED_IMAGE_SIZE_ARB 0x86A0 +#define GL_TEXTURE_COMPRESSED_ARB 0x86A1 +#define GL_NUM_COMPRESSED_TEXTURE_FORMATS_ARB 0x86A2 +#define GL_COMPRESSED_TEXTURE_FORMATS_ARB 0x86A3 + +typedef void (GLAPIENTRY * PFNGLCOMPRESSEDTEXIMAGE1DARBPROC) (GLenum target, GLint level, GLenum internalformat, GLsizei width, GLint border, GLsizei imageSize, const void* data); +typedef void (GLAPIENTRY * PFNGLCOMPRESSEDTEXIMAGE2DARBPROC) (GLenum target, GLint level, GLenum internalformat, GLsizei width, GLsizei height, GLint border, GLsizei imageSize, const void* data); +typedef void (GLAPIENTRY * PFNGLCOMPRESSEDTEXIMAGE3DARBPROC) (GLenum target, GLint level, GLenum internalformat, GLsizei width, GLsizei height, GLsizei depth, GLint border, GLsizei imageSize, const void* data); +typedef void (GLAPIENTRY * PFNGLCOMPRESSEDTEXSUBIMAGE1DARBPROC) (GLenum target, GLint level, GLint xoffset, GLsizei width, GLenum format, GLsizei imageSize, const void* data); +typedef void (GLAPIENTRY * PFNGLCOMPRESSEDTEXSUBIMAGE2DARBPROC) (GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLsizei imageSize, const void* data); +typedef void (GLAPIENTRY * PFNGLCOMPRESSEDTEXSUBIMAGE3DARBPROC) (GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLsizei imageSize, const void* data); +typedef void (GLAPIENTRY * PFNGLGETCOMPRESSEDTEXIMAGEARBPROC) (GLenum target, GLint lod, void* img); + +#define glCompressedTexImage1DARB GLEW_GET_FUN(__glewCompressedTexImage1DARB) +#define glCompressedTexImage2DARB GLEW_GET_FUN(__glewCompressedTexImage2DARB) +#define glCompressedTexImage3DARB GLEW_GET_FUN(__glewCompressedTexImage3DARB) +#define glCompressedTexSubImage1DARB GLEW_GET_FUN(__glewCompressedTexSubImage1DARB) +#define glCompressedTexSubImage2DARB GLEW_GET_FUN(__glewCompressedTexSubImage2DARB) +#define glCompressedTexSubImage3DARB GLEW_GET_FUN(__glewCompressedTexSubImage3DARB) +#define glGetCompressedTexImageARB GLEW_GET_FUN(__glewGetCompressedTexImageARB) + +#define GLEW_ARB_texture_compression GLEW_GET_VAR(__GLEW_ARB_texture_compression) + +#endif /* GL_ARB_texture_compression */ + +/* -------------------- GL_ARB_texture_compression_rgtc -------------------- */ + +#ifndef GL_ARB_texture_compression_rgtc +#define GL_ARB_texture_compression_rgtc 1 + +#define GL_COMPRESSED_RED_RGTC1 0x8DBB +#define GL_COMPRESSED_SIGNED_RED_RGTC1 0x8DBC +#define GL_COMPRESSED_RG_RGTC2 0x8DBD +#define GL_COMPRESSED_SIGNED_RG_RGTC2 0x8DBE + +#define GLEW_ARB_texture_compression_rgtc GLEW_GET_VAR(__GLEW_ARB_texture_compression_rgtc) + +#endif /* GL_ARB_texture_compression_rgtc */ + +/* ------------------------ GL_ARB_texture_cube_map ------------------------ */ + +#ifndef GL_ARB_texture_cube_map +#define GL_ARB_texture_cube_map 1 + +#define GL_NORMAL_MAP_ARB 0x8511 +#define GL_REFLECTION_MAP_ARB 0x8512 +#define GL_TEXTURE_CUBE_MAP_ARB 0x8513 +#define GL_TEXTURE_BINDING_CUBE_MAP_ARB 0x8514 +#define GL_TEXTURE_CUBE_MAP_POSITIVE_X_ARB 0x8515 +#define GL_TEXTURE_CUBE_MAP_NEGATIVE_X_ARB 0x8516 +#define GL_TEXTURE_CUBE_MAP_POSITIVE_Y_ARB 0x8517 +#define GL_TEXTURE_CUBE_MAP_NEGATIVE_Y_ARB 0x8518 +#define GL_TEXTURE_CUBE_MAP_POSITIVE_Z_ARB 0x8519 +#define GL_TEXTURE_CUBE_MAP_NEGATIVE_Z_ARB 0x851A +#define GL_PROXY_TEXTURE_CUBE_MAP_ARB 0x851B +#define GL_MAX_CUBE_MAP_TEXTURE_SIZE_ARB 0x851C + +#define GLEW_ARB_texture_cube_map GLEW_GET_VAR(__GLEW_ARB_texture_cube_map) + +#endif /* GL_ARB_texture_cube_map */ + +/* ------------------------- GL_ARB_texture_env_add ------------------------ */ + +#ifndef GL_ARB_texture_env_add +#define GL_ARB_texture_env_add 1 + +#define GLEW_ARB_texture_env_add GLEW_GET_VAR(__GLEW_ARB_texture_env_add) + +#endif /* GL_ARB_texture_env_add */ + +/* ----------------------- GL_ARB_texture_env_combine ---------------------- */ + +#ifndef GL_ARB_texture_env_combine +#define GL_ARB_texture_env_combine 1 + +#define GL_SUBTRACT_ARB 0x84E7 +#define GL_COMBINE_ARB 0x8570 +#define GL_COMBINE_RGB_ARB 0x8571 +#define GL_COMBINE_ALPHA_ARB 0x8572 +#define GL_RGB_SCALE_ARB 0x8573 +#define GL_ADD_SIGNED_ARB 0x8574 +#define GL_INTERPOLATE_ARB 0x8575 +#define GL_CONSTANT_ARB 0x8576 +#define GL_PRIMARY_COLOR_ARB 0x8577 +#define GL_PREVIOUS_ARB 0x8578 +#define GL_SOURCE0_RGB_ARB 0x8580 +#define GL_SOURCE1_RGB_ARB 0x8581 +#define GL_SOURCE2_RGB_ARB 0x8582 +#define GL_SOURCE0_ALPHA_ARB 0x8588 +#define GL_SOURCE1_ALPHA_ARB 0x8589 +#define GL_SOURCE2_ALPHA_ARB 0x858A +#define GL_OPERAND0_RGB_ARB 0x8590 +#define GL_OPERAND1_RGB_ARB 0x8591 +#define GL_OPERAND2_RGB_ARB 0x8592 +#define GL_OPERAND0_ALPHA_ARB 0x8598 +#define GL_OPERAND1_ALPHA_ARB 0x8599 +#define GL_OPERAND2_ALPHA_ARB 0x859A + +#define GLEW_ARB_texture_env_combine GLEW_GET_VAR(__GLEW_ARB_texture_env_combine) + +#endif /* GL_ARB_texture_env_combine */ + +/* ---------------------- GL_ARB_texture_env_crossbar ---------------------- */ + +#ifndef GL_ARB_texture_env_crossbar +#define GL_ARB_texture_env_crossbar 1 + +#define GLEW_ARB_texture_env_crossbar GLEW_GET_VAR(__GLEW_ARB_texture_env_crossbar) + +#endif /* GL_ARB_texture_env_crossbar */ + +/* ------------------------ GL_ARB_texture_env_dot3 ------------------------ */ + +#ifndef GL_ARB_texture_env_dot3 +#define GL_ARB_texture_env_dot3 1 + +#define GL_DOT3_RGB_ARB 0x86AE +#define GL_DOT3_RGBA_ARB 0x86AF + +#define GLEW_ARB_texture_env_dot3 GLEW_GET_VAR(__GLEW_ARB_texture_env_dot3) + +#endif /* GL_ARB_texture_env_dot3 */ + +/* -------------------------- GL_ARB_texture_float ------------------------- */ + +#ifndef GL_ARB_texture_float +#define GL_ARB_texture_float 1 + +#define GL_RGBA32F_ARB 0x8814 +#define GL_RGB32F_ARB 0x8815 +#define GL_ALPHA32F_ARB 0x8816 +#define GL_INTENSITY32F_ARB 0x8817 +#define GL_LUMINANCE32F_ARB 0x8818 +#define GL_LUMINANCE_ALPHA32F_ARB 0x8819 +#define GL_RGBA16F_ARB 0x881A +#define GL_RGB16F_ARB 0x881B +#define GL_ALPHA16F_ARB 0x881C +#define GL_INTENSITY16F_ARB 0x881D +#define GL_LUMINANCE16F_ARB 0x881E +#define GL_LUMINANCE_ALPHA16F_ARB 0x881F +#define GL_TEXTURE_RED_TYPE_ARB 0x8C10 +#define GL_TEXTURE_GREEN_TYPE_ARB 0x8C11 +#define GL_TEXTURE_BLUE_TYPE_ARB 0x8C12 +#define GL_TEXTURE_ALPHA_TYPE_ARB 0x8C13 +#define GL_TEXTURE_LUMINANCE_TYPE_ARB 0x8C14 +#define GL_TEXTURE_INTENSITY_TYPE_ARB 0x8C15 +#define GL_TEXTURE_DEPTH_TYPE_ARB 0x8C16 +#define GL_UNSIGNED_NORMALIZED_ARB 0x8C17 + +#define GLEW_ARB_texture_float GLEW_GET_VAR(__GLEW_ARB_texture_float) + +#endif /* GL_ARB_texture_float */ + +/* --------------------- GL_ARB_texture_mirrored_repeat -------------------- */ + +#ifndef GL_ARB_texture_mirrored_repeat +#define GL_ARB_texture_mirrored_repeat 1 + +#define GL_MIRRORED_REPEAT_ARB 0x8370 + +#define GLEW_ARB_texture_mirrored_repeat GLEW_GET_VAR(__GLEW_ARB_texture_mirrored_repeat) + +#endif /* GL_ARB_texture_mirrored_repeat */ + +/* -------------------- GL_ARB_texture_non_power_of_two -------------------- */ + +#ifndef GL_ARB_texture_non_power_of_two +#define GL_ARB_texture_non_power_of_two 1 + +#define GLEW_ARB_texture_non_power_of_two GLEW_GET_VAR(__GLEW_ARB_texture_non_power_of_two) + +#endif /* GL_ARB_texture_non_power_of_two */ + +/* ------------------------ GL_ARB_texture_rectangle ----------------------- */ + +#ifndef GL_ARB_texture_rectangle +#define GL_ARB_texture_rectangle 1 + +#define GL_TEXTURE_RECTANGLE_ARB 0x84F5 +#define GL_TEXTURE_BINDING_RECTANGLE_ARB 0x84F6 +#define GL_PROXY_TEXTURE_RECTANGLE_ARB 0x84F7 +#define GL_MAX_RECTANGLE_TEXTURE_SIZE_ARB 0x84F8 +#define GL_SAMPLER_2D_RECT_ARB 0x8B63 +#define GL_SAMPLER_2D_RECT_SHADOW_ARB 0x8B64 + +#define GLEW_ARB_texture_rectangle GLEW_GET_VAR(__GLEW_ARB_texture_rectangle) + +#endif /* GL_ARB_texture_rectangle */ + +/* --------------------------- GL_ARB_texture_rg --------------------------- */ + +#ifndef GL_ARB_texture_rg +#define GL_ARB_texture_rg 1 + +#define GL_RED 0x1903 +#define GL_RG 0x8227 +#define GL_RG_INTEGER 0x8228 +#define GL_R8 0x8229 +#define GL_R16 0x822A +#define GL_RG8 0x822B +#define GL_RG16 0x822C +#define GL_R16F 0x822D +#define GL_R32F 0x822E +#define GL_RG16F 0x822F +#define GL_RG32F 0x8230 +#define GL_R8I 0x8231 +#define GL_R8UI 0x8232 +#define GL_R16I 0x8233 +#define GL_R16UI 0x8234 +#define GL_R32I 0x8235 +#define GL_R32UI 0x8236 +#define GL_RG8I 0x8237 +#define GL_RG8UI 0x8238 +#define GL_RG16I 0x8239 +#define GL_RG16UI 0x823A +#define GL_RG32I 0x823B +#define GL_RG32UI 0x823C + +#define GLEW_ARB_texture_rg GLEW_GET_VAR(__GLEW_ARB_texture_rg) + +#endif /* GL_ARB_texture_rg */ + +/* ------------------------ GL_ARB_transpose_matrix ------------------------ */ + +#ifndef GL_ARB_transpose_matrix +#define GL_ARB_transpose_matrix 1 + +#define GL_TRANSPOSE_MODELVIEW_MATRIX_ARB 0x84E3 +#define GL_TRANSPOSE_PROJECTION_MATRIX_ARB 0x84E4 +#define GL_TRANSPOSE_TEXTURE_MATRIX_ARB 0x84E5 +#define GL_TRANSPOSE_COLOR_MATRIX_ARB 0x84E6 + +typedef void (GLAPIENTRY * PFNGLLOADTRANSPOSEMATRIXDARBPROC) (GLdouble m[16]); +typedef void (GLAPIENTRY * PFNGLLOADTRANSPOSEMATRIXFARBPROC) (GLfloat m[16]); +typedef void (GLAPIENTRY * PFNGLMULTTRANSPOSEMATRIXDARBPROC) (GLdouble m[16]); +typedef void (GLAPIENTRY * PFNGLMULTTRANSPOSEMATRIXFARBPROC) (GLfloat m[16]); + +#define glLoadTransposeMatrixdARB GLEW_GET_FUN(__glewLoadTransposeMatrixdARB) +#define glLoadTransposeMatrixfARB GLEW_GET_FUN(__glewLoadTransposeMatrixfARB) +#define glMultTransposeMatrixdARB GLEW_GET_FUN(__glewMultTransposeMatrixdARB) +#define glMultTransposeMatrixfARB GLEW_GET_FUN(__glewMultTransposeMatrixfARB) + +#define GLEW_ARB_transpose_matrix GLEW_GET_VAR(__GLEW_ARB_transpose_matrix) + +#endif /* GL_ARB_transpose_matrix */ + +/* ----------------------- GL_ARB_vertex_array_object ---------------------- */ + +#ifndef GL_ARB_vertex_array_object +#define GL_ARB_vertex_array_object 1 + +#define GL_VERTEX_ARRAY_BINDING 0x85B5 + +typedef void (GLAPIENTRY * PFNGLBINDVERTEXARRAYPROC) (GLuint array); +typedef void (GLAPIENTRY * PFNGLDELETEVERTEXARRAYSPROC) (GLsizei n, const GLuint* arrays); +typedef void (GLAPIENTRY * PFNGLGENVERTEXARRAYSPROC) (GLsizei n, GLuint* arrays); +typedef GLboolean (GLAPIENTRY * PFNGLISVERTEXARRAYPROC) (GLuint array); + +#define glBindVertexArray GLEW_GET_FUN(__glewBindVertexArray) +#define glDeleteVertexArrays GLEW_GET_FUN(__glewDeleteVertexArrays) +#define glGenVertexArrays GLEW_GET_FUN(__glewGenVertexArrays) +#define glIsVertexArray GLEW_GET_FUN(__glewIsVertexArray) + +#define GLEW_ARB_vertex_array_object GLEW_GET_VAR(__GLEW_ARB_vertex_array_object) + +#endif /* GL_ARB_vertex_array_object */ + +/* -------------------------- GL_ARB_vertex_blend -------------------------- */ + +#ifndef GL_ARB_vertex_blend +#define GL_ARB_vertex_blend 1 + +#define GL_MODELVIEW0_ARB 0x1700 +#define GL_MODELVIEW1_ARB 0x850A +#define GL_MAX_VERTEX_UNITS_ARB 0x86A4 +#define GL_ACTIVE_VERTEX_UNITS_ARB 0x86A5 +#define GL_WEIGHT_SUM_UNITY_ARB 0x86A6 +#define GL_VERTEX_BLEND_ARB 0x86A7 +#define GL_CURRENT_WEIGHT_ARB 0x86A8 +#define GL_WEIGHT_ARRAY_TYPE_ARB 0x86A9 +#define GL_WEIGHT_ARRAY_STRIDE_ARB 0x86AA +#define GL_WEIGHT_ARRAY_SIZE_ARB 0x86AB +#define GL_WEIGHT_ARRAY_POINTER_ARB 0x86AC +#define GL_WEIGHT_ARRAY_ARB 0x86AD +#define GL_MODELVIEW2_ARB 0x8722 +#define GL_MODELVIEW3_ARB 0x8723 +#define GL_MODELVIEW4_ARB 0x8724 +#define GL_MODELVIEW5_ARB 0x8725 +#define GL_MODELVIEW6_ARB 0x8726 +#define GL_MODELVIEW7_ARB 0x8727 +#define GL_MODELVIEW8_ARB 0x8728 +#define GL_MODELVIEW9_ARB 0x8729 +#define GL_MODELVIEW10_ARB 0x872A +#define GL_MODELVIEW11_ARB 0x872B +#define GL_MODELVIEW12_ARB 0x872C +#define GL_MODELVIEW13_ARB 0x872D +#define GL_MODELVIEW14_ARB 0x872E +#define GL_MODELVIEW15_ARB 0x872F +#define GL_MODELVIEW16_ARB 0x8730 +#define GL_MODELVIEW17_ARB 0x8731 +#define GL_MODELVIEW18_ARB 0x8732 +#define GL_MODELVIEW19_ARB 0x8733 +#define GL_MODELVIEW20_ARB 0x8734 +#define GL_MODELVIEW21_ARB 0x8735 +#define GL_MODELVIEW22_ARB 0x8736 +#define GL_MODELVIEW23_ARB 0x8737 +#define GL_MODELVIEW24_ARB 0x8738 +#define GL_MODELVIEW25_ARB 0x8739 +#define GL_MODELVIEW26_ARB 0x873A +#define GL_MODELVIEW27_ARB 0x873B +#define GL_MODELVIEW28_ARB 0x873C +#define GL_MODELVIEW29_ARB 0x873D +#define GL_MODELVIEW30_ARB 0x873E +#define GL_MODELVIEW31_ARB 0x873F + +typedef void (GLAPIENTRY * PFNGLVERTEXBLENDARBPROC) (GLint count); +typedef void (GLAPIENTRY * PFNGLWEIGHTPOINTERARBPROC) (GLint size, GLenum type, GLsizei stride, GLvoid *pointer); +typedef void (GLAPIENTRY * PFNGLWEIGHTBVARBPROC) (GLint size, GLbyte *weights); +typedef void (GLAPIENTRY * PFNGLWEIGHTDVARBPROC) (GLint size, GLdouble *weights); +typedef void (GLAPIENTRY * PFNGLWEIGHTFVARBPROC) (GLint size, GLfloat *weights); +typedef void (GLAPIENTRY * PFNGLWEIGHTIVARBPROC) (GLint size, GLint *weights); +typedef void (GLAPIENTRY * PFNGLWEIGHTSVARBPROC) (GLint size, GLshort *weights); +typedef void (GLAPIENTRY * PFNGLWEIGHTUBVARBPROC) (GLint size, GLubyte *weights); +typedef void (GLAPIENTRY * PFNGLWEIGHTUIVARBPROC) (GLint size, GLuint *weights); +typedef void (GLAPIENTRY * PFNGLWEIGHTUSVARBPROC) (GLint size, GLushort *weights); + +#define glVertexBlendARB GLEW_GET_FUN(__glewVertexBlendARB) +#define glWeightPointerARB GLEW_GET_FUN(__glewWeightPointerARB) +#define glWeightbvARB GLEW_GET_FUN(__glewWeightbvARB) +#define glWeightdvARB GLEW_GET_FUN(__glewWeightdvARB) +#define glWeightfvARB GLEW_GET_FUN(__glewWeightfvARB) +#define glWeightivARB GLEW_GET_FUN(__glewWeightivARB) +#define glWeightsvARB GLEW_GET_FUN(__glewWeightsvARB) +#define glWeightubvARB GLEW_GET_FUN(__glewWeightubvARB) +#define glWeightuivARB GLEW_GET_FUN(__glewWeightuivARB) +#define glWeightusvARB GLEW_GET_FUN(__glewWeightusvARB) + +#define GLEW_ARB_vertex_blend GLEW_GET_VAR(__GLEW_ARB_vertex_blend) + +#endif /* GL_ARB_vertex_blend */ + +/* ---------------------- GL_ARB_vertex_buffer_object ---------------------- */ + +#ifndef GL_ARB_vertex_buffer_object +#define GL_ARB_vertex_buffer_object 1 + +#define GL_BUFFER_SIZE_ARB 0x8764 +#define GL_BUFFER_USAGE_ARB 0x8765 +#define GL_ARRAY_BUFFER_ARB 0x8892 +#define GL_ELEMENT_ARRAY_BUFFER_ARB 0x8893 +#define GL_ARRAY_BUFFER_BINDING_ARB 0x8894 +#define GL_ELEMENT_ARRAY_BUFFER_BINDING_ARB 0x8895 +#define GL_VERTEX_ARRAY_BUFFER_BINDING_ARB 0x8896 +#define GL_NORMAL_ARRAY_BUFFER_BINDING_ARB 0x8897 +#define GL_COLOR_ARRAY_BUFFER_BINDING_ARB 0x8898 +#define GL_INDEX_ARRAY_BUFFER_BINDING_ARB 0x8899 +#define GL_TEXTURE_COORD_ARRAY_BUFFER_BINDING_ARB 0x889A +#define GL_EDGE_FLAG_ARRAY_BUFFER_BINDING_ARB 0x889B +#define GL_SECONDARY_COLOR_ARRAY_BUFFER_BINDING_ARB 0x889C +#define GL_FOG_COORDINATE_ARRAY_BUFFER_BINDING_ARB 0x889D +#define GL_WEIGHT_ARRAY_BUFFER_BINDING_ARB 0x889E +#define GL_VERTEX_ATTRIB_ARRAY_BUFFER_BINDING_ARB 0x889F +#define GL_READ_ONLY_ARB 0x88B8 +#define GL_WRITE_ONLY_ARB 0x88B9 +#define GL_READ_WRITE_ARB 0x88BA +#define GL_BUFFER_ACCESS_ARB 0x88BB +#define GL_BUFFER_MAPPED_ARB 0x88BC +#define GL_BUFFER_MAP_POINTER_ARB 0x88BD +#define GL_STREAM_DRAW_ARB 0x88E0 +#define GL_STREAM_READ_ARB 0x88E1 +#define GL_STREAM_COPY_ARB 0x88E2 +#define GL_STATIC_DRAW_ARB 0x88E4 +#define GL_STATIC_READ_ARB 0x88E5 +#define GL_STATIC_COPY_ARB 0x88E6 +#define GL_DYNAMIC_DRAW_ARB 0x88E8 +#define GL_DYNAMIC_READ_ARB 0x88E9 +#define GL_DYNAMIC_COPY_ARB 0x88EA + +//typedef ptrdiff_t GLsizeiptrARB; +//typedef ptrdiff_t GLintptrARB; +typedef unsigned int GLsizeiptrARB; +typedef unsigned int GLintptrARB; + +typedef void (GLAPIENTRY * PFNGLBINDBUFFERARBPROC) (GLenum target, GLuint buffer); +typedef void (GLAPIENTRY * PFNGLBUFFERDATAARBPROC) (GLenum target, GLsizeiptrARB size, const GLvoid* data, GLenum usage); +typedef void (GLAPIENTRY * PFNGLBUFFERSUBDATAARBPROC) (GLenum target, GLintptrARB offset, GLsizeiptrARB size, const GLvoid* data); +typedef void (GLAPIENTRY * PFNGLDELETEBUFFERSARBPROC) (GLsizei n, const GLuint* buffers); +typedef void (GLAPIENTRY * PFNGLGENBUFFERSARBPROC) (GLsizei n, GLuint* buffers); +typedef void (GLAPIENTRY * PFNGLGETBUFFERPARAMETERIVARBPROC) (GLenum target, GLenum pname, GLint* params); +typedef void (GLAPIENTRY * PFNGLGETBUFFERPOINTERVARBPROC) (GLenum target, GLenum pname, GLvoid** params); +typedef void (GLAPIENTRY * PFNGLGETBUFFERSUBDATAARBPROC) (GLenum target, GLintptrARB offset, GLsizeiptrARB size, GLvoid* data); +typedef GLboolean (GLAPIENTRY * PFNGLISBUFFERARBPROC) (GLuint buffer); +typedef GLvoid * (GLAPIENTRY * PFNGLMAPBUFFERARBPROC) (GLenum target, GLenum access); +typedef GLboolean (GLAPIENTRY * PFNGLUNMAPBUFFERARBPROC) (GLenum target); + +#define glBindBufferARB GLEW_GET_FUN(__glewBindBufferARB) +#define glBufferDataARB GLEW_GET_FUN(__glewBufferDataARB) +#define glBufferSubDataARB GLEW_GET_FUN(__glewBufferSubDataARB) +#define glDeleteBuffersARB GLEW_GET_FUN(__glewDeleteBuffersARB) +#define glGenBuffersARB GLEW_GET_FUN(__glewGenBuffersARB) +#define glGetBufferParameterivARB GLEW_GET_FUN(__glewGetBufferParameterivARB) +#define glGetBufferPointervARB GLEW_GET_FUN(__glewGetBufferPointervARB) +#define glGetBufferSubDataARB GLEW_GET_FUN(__glewGetBufferSubDataARB) +#define glIsBufferARB GLEW_GET_FUN(__glewIsBufferARB) +#define glMapBufferARB GLEW_GET_FUN(__glewMapBufferARB) +#define glUnmapBufferARB GLEW_GET_FUN(__glewUnmapBufferARB) + +#define GLEW_ARB_vertex_buffer_object GLEW_GET_VAR(__GLEW_ARB_vertex_buffer_object) + +#endif /* GL_ARB_vertex_buffer_object */ + +/* ------------------------- GL_ARB_vertex_program ------------------------- */ + +#ifndef GL_ARB_vertex_program +#define GL_ARB_vertex_program 1 + +#define GL_COLOR_SUM_ARB 0x8458 +#define GL_VERTEX_PROGRAM_ARB 0x8620 +#define GL_VERTEX_ATTRIB_ARRAY_ENABLED_ARB 0x8622 +#define GL_VERTEX_ATTRIB_ARRAY_SIZE_ARB 0x8623 +#define GL_VERTEX_ATTRIB_ARRAY_STRIDE_ARB 0x8624 +#define GL_VERTEX_ATTRIB_ARRAY_TYPE_ARB 0x8625 +#define GL_CURRENT_VERTEX_ATTRIB_ARB 0x8626 +#define GL_PROGRAM_LENGTH_ARB 0x8627 +#define GL_PROGRAM_STRING_ARB 0x8628 +#define GL_MAX_PROGRAM_MATRIX_STACK_DEPTH_ARB 0x862E +#define GL_MAX_PROGRAM_MATRICES_ARB 0x862F +#define GL_CURRENT_MATRIX_STACK_DEPTH_ARB 0x8640 +#define GL_CURRENT_MATRIX_ARB 0x8641 +#define GL_VERTEX_PROGRAM_POINT_SIZE_ARB 0x8642 +#define GL_VERTEX_PROGRAM_TWO_SIDE_ARB 0x8643 +#define GL_VERTEX_ATTRIB_ARRAY_POINTER_ARB 0x8645 +#define GL_PROGRAM_ERROR_POSITION_ARB 0x864B +#define GL_PROGRAM_BINDING_ARB 0x8677 +#define GL_MAX_VERTEX_ATTRIBS_ARB 0x8869 +#define GL_VERTEX_ATTRIB_ARRAY_NORMALIZED_ARB 0x886A +#define GL_PROGRAM_ERROR_STRING_ARB 0x8874 +#define GL_PROGRAM_FORMAT_ASCII_ARB 0x8875 +#define GL_PROGRAM_FORMAT_ARB 0x8876 +#define GL_PROGRAM_INSTRUCTIONS_ARB 0x88A0 +#define GL_MAX_PROGRAM_INSTRUCTIONS_ARB 0x88A1 +#define GL_PROGRAM_NATIVE_INSTRUCTIONS_ARB 0x88A2 +#define GL_MAX_PROGRAM_NATIVE_INSTRUCTIONS_ARB 0x88A3 +#define GL_PROGRAM_TEMPORARIES_ARB 0x88A4 +#define GL_MAX_PROGRAM_TEMPORARIES_ARB 0x88A5 +#define GL_PROGRAM_NATIVE_TEMPORARIES_ARB 0x88A6 +#define GL_MAX_PROGRAM_NATIVE_TEMPORARIES_ARB 0x88A7 +#define GL_PROGRAM_PARAMETERS_ARB 0x88A8 +#define GL_MAX_PROGRAM_PARAMETERS_ARB 0x88A9 +#define GL_PROGRAM_NATIVE_PARAMETERS_ARB 0x88AA +#define GL_MAX_PROGRAM_NATIVE_PARAMETERS_ARB 0x88AB +#define GL_PROGRAM_ATTRIBS_ARB 0x88AC +#define GL_MAX_PROGRAM_ATTRIBS_ARB 0x88AD +#define GL_PROGRAM_NATIVE_ATTRIBS_ARB 0x88AE +#define GL_MAX_PROGRAM_NATIVE_ATTRIBS_ARB 0x88AF +#define GL_PROGRAM_ADDRESS_REGISTERS_ARB 0x88B0 +#define GL_MAX_PROGRAM_ADDRESS_REGISTERS_ARB 0x88B1 +#define GL_PROGRAM_NATIVE_ADDRESS_REGISTERS_ARB 0x88B2 +#define GL_MAX_PROGRAM_NATIVE_ADDRESS_REGISTERS_ARB 0x88B3 +#define GL_MAX_PROGRAM_LOCAL_PARAMETERS_ARB 0x88B4 +#define GL_MAX_PROGRAM_ENV_PARAMETERS_ARB 0x88B5 +#define GL_PROGRAM_UNDER_NATIVE_LIMITS_ARB 0x88B6 +#define GL_TRANSPOSE_CURRENT_MATRIX_ARB 0x88B7 +#define GL_MATRIX0_ARB 0x88C0 +#define GL_MATRIX1_ARB 0x88C1 +#define GL_MATRIX2_ARB 0x88C2 +#define GL_MATRIX3_ARB 0x88C3 +#define GL_MATRIX4_ARB 0x88C4 +#define GL_MATRIX5_ARB 0x88C5 +#define GL_MATRIX6_ARB 0x88C6 +#define GL_MATRIX7_ARB 0x88C7 +#define GL_MATRIX8_ARB 0x88C8 +#define GL_MATRIX9_ARB 0x88C9 +#define GL_MATRIX10_ARB 0x88CA +#define GL_MATRIX11_ARB 0x88CB +#define GL_MATRIX12_ARB 0x88CC +#define GL_MATRIX13_ARB 0x88CD +#define GL_MATRIX14_ARB 0x88CE +#define GL_MATRIX15_ARB 0x88CF +#define GL_MATRIX16_ARB 0x88D0 +#define GL_MATRIX17_ARB 0x88D1 +#define GL_MATRIX18_ARB 0x88D2 +#define GL_MATRIX19_ARB 0x88D3 +#define GL_MATRIX20_ARB 0x88D4 +#define GL_MATRIX21_ARB 0x88D5 +#define GL_MATRIX22_ARB 0x88D6 +#define GL_MATRIX23_ARB 0x88D7 +#define GL_MATRIX24_ARB 0x88D8 +#define GL_MATRIX25_ARB 0x88D9 +#define GL_MATRIX26_ARB 0x88DA +#define GL_MATRIX27_ARB 0x88DB +#define GL_MATRIX28_ARB 0x88DC +#define GL_MATRIX29_ARB 0x88DD +#define GL_MATRIX30_ARB 0x88DE +#define GL_MATRIX31_ARB 0x88DF + +typedef void (GLAPIENTRY * PFNGLBINDPROGRAMARBPROC) (GLenum target, GLuint program); +typedef void (GLAPIENTRY * PFNGLDELETEPROGRAMSARBPROC) (GLsizei n, const GLuint* programs); +typedef void (GLAPIENTRY * PFNGLDISABLEVERTEXATTRIBARRAYARBPROC) (GLuint index); +typedef void (GLAPIENTRY * PFNGLENABLEVERTEXATTRIBARRAYARBPROC) (GLuint index); +typedef void (GLAPIENTRY * PFNGLGENPROGRAMSARBPROC) (GLsizei n, GLuint* programs); +typedef void (GLAPIENTRY * PFNGLGETPROGRAMENVPARAMETERDVARBPROC) (GLenum target, GLuint index, GLdouble* params); +typedef void (GLAPIENTRY * PFNGLGETPROGRAMENVPARAMETERFVARBPROC) (GLenum target, GLuint index, GLfloat* params); +typedef void (GLAPIENTRY * PFNGLGETPROGRAMLOCALPARAMETERDVARBPROC) (GLenum target, GLuint index, GLdouble* params); +typedef void (GLAPIENTRY * PFNGLGETPROGRAMLOCALPARAMETERFVARBPROC) (GLenum target, GLuint index, GLfloat* params); +typedef void (GLAPIENTRY * PFNGLGETPROGRAMSTRINGARBPROC) (GLenum target, GLenum pname, void* string); +typedef void (GLAPIENTRY * PFNGLGETPROGRAMIVARBPROC) (GLenum target, GLenum pname, GLint* params); +typedef void (GLAPIENTRY * PFNGLGETVERTEXATTRIBPOINTERVARBPROC) (GLuint index, GLenum pname, GLvoid** pointer); +typedef void (GLAPIENTRY * PFNGLGETVERTEXATTRIBDVARBPROC) (GLuint index, GLenum pname, GLdouble* params); +typedef void (GLAPIENTRY * PFNGLGETVERTEXATTRIBFVARBPROC) (GLuint index, GLenum pname, GLfloat* params); +typedef void (GLAPIENTRY * PFNGLGETVERTEXATTRIBIVARBPROC) (GLuint index, GLenum pname, GLint* params); +typedef GLboolean (GLAPIENTRY * PFNGLISPROGRAMARBPROC) (GLuint program); +typedef void (GLAPIENTRY * PFNGLPROGRAMENVPARAMETER4DARBPROC) (GLenum target, GLuint index, GLdouble x, GLdouble y, GLdouble z, GLdouble w); +typedef void (GLAPIENTRY * PFNGLPROGRAMENVPARAMETER4DVARBPROC) (GLenum target, GLuint index, const GLdouble* params); +typedef void (GLAPIENTRY * PFNGLPROGRAMENVPARAMETER4FARBPROC) (GLenum target, GLuint index, GLfloat x, GLfloat y, GLfloat z, GLfloat w); +typedef void (GLAPIENTRY * PFNGLPROGRAMENVPARAMETER4FVARBPROC) (GLenum target, GLuint index, const GLfloat* params); +typedef void (GLAPIENTRY * PFNGLPROGRAMLOCALPARAMETER4DARBPROC) (GLenum target, GLuint index, GLdouble x, GLdouble y, GLdouble z, GLdouble w); +typedef void (GLAPIENTRY * PFNGLPROGRAMLOCALPARAMETER4DVARBPROC) (GLenum target, GLuint index, const GLdouble* params); +typedef void (GLAPIENTRY * PFNGLPROGRAMLOCALPARAMETER4FARBPROC) (GLenum target, GLuint index, GLfloat x, GLfloat y, GLfloat z, GLfloat w); +typedef void (GLAPIENTRY * PFNGLPROGRAMLOCALPARAMETER4FVARBPROC) (GLenum target, GLuint index, const GLfloat* params); +typedef void (GLAPIENTRY * PFNGLPROGRAMSTRINGARBPROC) (GLenum target, GLenum format, GLsizei len, const void* string); +typedef void (GLAPIENTRY * PFNGLVERTEXATTRIB1DARBPROC) (GLuint index, GLdouble x); +typedef void (GLAPIENTRY * PFNGLVERTEXATTRIB1DVARBPROC) (GLuint index, const GLdouble* v); +typedef void (GLAPIENTRY * PFNGLVERTEXATTRIB1FARBPROC) (GLuint index, GLfloat x); +typedef void (GLAPIENTRY * PFNGLVERTEXATTRIB1FVARBPROC) (GLuint index, const GLfloat* v); +typedef void (GLAPIENTRY * PFNGLVERTEXATTRIB1SARBPROC) (GLuint index, GLshort x); +typedef void (GLAPIENTRY * PFNGLVERTEXATTRIB1SVARBPROC) (GLuint index, const GLshort* v); +typedef void (GLAPIENTRY * PFNGLVERTEXATTRIB2DARBPROC) (GLuint index, GLdouble x, GLdouble y); +typedef void (GLAPIENTRY * PFNGLVERTEXATTRIB2DVARBPROC) (GLuint index, const GLdouble* v); +typedef void (GLAPIENTRY * PFNGLVERTEXATTRIB2FARBPROC) (GLuint index, GLfloat x, GLfloat y); +typedef void (GLAPIENTRY * PFNGLVERTEXATTRIB2FVARBPROC) (GLuint index, const GLfloat* v); +typedef void (GLAPIENTRY * PFNGLVERTEXATTRIB2SARBPROC) (GLuint index, GLshort x, GLshort y); +typedef void (GLAPIENTRY * PFNGLVERTEXATTRIB2SVARBPROC) (GLuint index, const GLshort* v); +typedef void (GLAPIENTRY * PFNGLVERTEXATTRIB3DARBPROC) (GLuint index, GLdouble x, GLdouble y, GLdouble z); +typedef void (GLAPIENTRY * PFNGLVERTEXATTRIB3DVARBPROC) (GLuint index, const GLdouble* v); +typedef void (GLAPIENTRY * PFNGLVERTEXATTRIB3FARBPROC) (GLuint index, GLfloat x, GLfloat y, GLfloat z); +typedef void (GLAPIENTRY * PFNGLVERTEXATTRIB3FVARBPROC) (GLuint index, const GLfloat* v); +typedef void (GLAPIENTRY * PFNGLVERTEXATTRIB3SARBPROC) (GLuint index, GLshort x, GLshort y, GLshort z); +typedef void (GLAPIENTRY * PFNGLVERTEXATTRIB3SVARBPROC) (GLuint index, const GLshort* v); +typedef void (GLAPIENTRY * PFNGLVERTEXATTRIB4NBVARBPROC) (GLuint index, const GLbyte* v); +typedef void (GLAPIENTRY * PFNGLVERTEXATTRIB4NIVARBPROC) (GLuint index, const GLint* v); +typedef void (GLAPIENTRY * PFNGLVERTEXATTRIB4NSVARBPROC) (GLuint index, const GLshort* v); +typedef void (GLAPIENTRY * PFNGLVERTEXATTRIB4NUBARBPROC) (GLuint index, GLubyte x, GLubyte y, GLubyte z, GLubyte w); +typedef void (GLAPIENTRY * PFNGLVERTEXATTRIB4NUBVARBPROC) (GLuint index, const GLubyte* v); +typedef void (GLAPIENTRY * PFNGLVERTEXATTRIB4NUIVARBPROC) (GLuint index, const GLuint* v); +typedef void (GLAPIENTRY * PFNGLVERTEXATTRIB4NUSVARBPROC) (GLuint index, const GLushort* v); +typedef void (GLAPIENTRY * PFNGLVERTEXATTRIB4BVARBPROC) (GLuint index, const GLbyte* v); +typedef void (GLAPIENTRY * PFNGLVERTEXATTRIB4DARBPROC) (GLuint index, GLdouble x, GLdouble y, GLdouble z, GLdouble w); +typedef void (GLAPIENTRY * PFNGLVERTEXATTRIB4DVARBPROC) (GLuint index, const GLdouble* v); +typedef void (GLAPIENTRY * PFNGLVERTEXATTRIB4FARBPROC) (GLuint index, GLfloat x, GLfloat y, GLfloat z, GLfloat w); +typedef void (GLAPIENTRY * PFNGLVERTEXATTRIB4FVARBPROC) (GLuint index, const GLfloat* v); +typedef void (GLAPIENTRY * PFNGLVERTEXATTRIB4IVARBPROC) (GLuint index, const GLint* v); +typedef void (GLAPIENTRY * PFNGLVERTEXATTRIB4SARBPROC) (GLuint index, GLshort x, GLshort y, GLshort z, GLshort w); +typedef void (GLAPIENTRY * PFNGLVERTEXATTRIB4SVARBPROC) (GLuint index, const GLshort* v); +typedef void (GLAPIENTRY * PFNGLVERTEXATTRIB4UBVARBPROC) (GLuint index, const GLubyte* v); +typedef void (GLAPIENTRY * PFNGLVERTEXATTRIB4UIVARBPROC) (GLuint index, const GLuint* v); +typedef void (GLAPIENTRY * PFNGLVERTEXATTRIB4USVARBPROC) (GLuint index, const GLushort* v); +typedef void (GLAPIENTRY * PFNGLVERTEXATTRIBPOINTERARBPROC) (GLuint index, GLint size, GLenum type, GLboolean normalized, GLsizei stride, const void* pointer); + +#define glBindProgramARB GLEW_GET_FUN(__glewBindProgramARB) +#define glDeleteProgramsARB GLEW_GET_FUN(__glewDeleteProgramsARB) +#define glDisableVertexAttribArrayARB GLEW_GET_FUN(__glewDisableVertexAttribArrayARB) +#define glEnableVertexAttribArrayARB GLEW_GET_FUN(__glewEnableVertexAttribArrayARB) +#define glGenProgramsARB GLEW_GET_FUN(__glewGenProgramsARB) +#define glGetProgramEnvParameterdvARB GLEW_GET_FUN(__glewGetProgramEnvParameterdvARB) +#define glGetProgramEnvParameterfvARB GLEW_GET_FUN(__glewGetProgramEnvParameterfvARB) +#define glGetProgramLocalParameterdvARB GLEW_GET_FUN(__glewGetProgramLocalParameterdvARB) +#define glGetProgramLocalParameterfvARB GLEW_GET_FUN(__glewGetProgramLocalParameterfvARB) +#define glGetProgramStringARB GLEW_GET_FUN(__glewGetProgramStringARB) +#define glGetProgramivARB GLEW_GET_FUN(__glewGetProgramivARB) +#define glGetVertexAttribPointervARB GLEW_GET_FUN(__glewGetVertexAttribPointervARB) +#define glGetVertexAttribdvARB GLEW_GET_FUN(__glewGetVertexAttribdvARB) +#define glGetVertexAttribfvARB GLEW_GET_FUN(__glewGetVertexAttribfvARB) +#define glGetVertexAttribivARB GLEW_GET_FUN(__glewGetVertexAttribivARB) +#define glIsProgramARB GLEW_GET_FUN(__glewIsProgramARB) +#define glProgramEnvParameter4dARB GLEW_GET_FUN(__glewProgramEnvParameter4dARB) +#define glProgramEnvParameter4dvARB GLEW_GET_FUN(__glewProgramEnvParameter4dvARB) +#define glProgramEnvParameter4fARB GLEW_GET_FUN(__glewProgramEnvParameter4fARB) +#define glProgramEnvParameter4fvARB GLEW_GET_FUN(__glewProgramEnvParameter4fvARB) +#define glProgramLocalParameter4dARB GLEW_GET_FUN(__glewProgramLocalParameter4dARB) +#define glProgramLocalParameter4dvARB GLEW_GET_FUN(__glewProgramLocalParameter4dvARB) +#define glProgramLocalParameter4fARB GLEW_GET_FUN(__glewProgramLocalParameter4fARB) +#define glProgramLocalParameter4fvARB GLEW_GET_FUN(__glewProgramLocalParameter4fvARB) +#define glProgramStringARB GLEW_GET_FUN(__glewProgramStringARB) +#define glVertexAttrib1dARB GLEW_GET_FUN(__glewVertexAttrib1dARB) +#define glVertexAttrib1dvARB GLEW_GET_FUN(__glewVertexAttrib1dvARB) +#define glVertexAttrib1fARB GLEW_GET_FUN(__glewVertexAttrib1fARB) +#define glVertexAttrib1fvARB GLEW_GET_FUN(__glewVertexAttrib1fvARB) +#define glVertexAttrib1sARB GLEW_GET_FUN(__glewVertexAttrib1sARB) +#define glVertexAttrib1svARB GLEW_GET_FUN(__glewVertexAttrib1svARB) +#define glVertexAttrib2dARB GLEW_GET_FUN(__glewVertexAttrib2dARB) +#define glVertexAttrib2dvARB GLEW_GET_FUN(__glewVertexAttrib2dvARB) +#define glVertexAttrib2fARB GLEW_GET_FUN(__glewVertexAttrib2fARB) +#define glVertexAttrib2fvARB GLEW_GET_FUN(__glewVertexAttrib2fvARB) +#define glVertexAttrib2sARB GLEW_GET_FUN(__glewVertexAttrib2sARB) +#define glVertexAttrib2svARB GLEW_GET_FUN(__glewVertexAttrib2svARB) +#define glVertexAttrib3dARB GLEW_GET_FUN(__glewVertexAttrib3dARB) +#define glVertexAttrib3dvARB GLEW_GET_FUN(__glewVertexAttrib3dvARB) +#define glVertexAttrib3fARB GLEW_GET_FUN(__glewVertexAttrib3fARB) +#define glVertexAttrib3fvARB GLEW_GET_FUN(__glewVertexAttrib3fvARB) +#define glVertexAttrib3sARB GLEW_GET_FUN(__glewVertexAttrib3sARB) +#define glVertexAttrib3svARB GLEW_GET_FUN(__glewVertexAttrib3svARB) +#define glVertexAttrib4NbvARB GLEW_GET_FUN(__glewVertexAttrib4NbvARB) +#define glVertexAttrib4NivARB GLEW_GET_FUN(__glewVertexAttrib4NivARB) +#define glVertexAttrib4NsvARB GLEW_GET_FUN(__glewVertexAttrib4NsvARB) +#define glVertexAttrib4NubARB GLEW_GET_FUN(__glewVertexAttrib4NubARB) +#define glVertexAttrib4NubvARB GLEW_GET_FUN(__glewVertexAttrib4NubvARB) +#define glVertexAttrib4NuivARB GLEW_GET_FUN(__glewVertexAttrib4NuivARB) +#define glVertexAttrib4NusvARB GLEW_GET_FUN(__glewVertexAttrib4NusvARB) +#define glVertexAttrib4bvARB GLEW_GET_FUN(__glewVertexAttrib4bvARB) +#define glVertexAttrib4dARB GLEW_GET_FUN(__glewVertexAttrib4dARB) +#define glVertexAttrib4dvARB GLEW_GET_FUN(__glewVertexAttrib4dvARB) +#define glVertexAttrib4fARB GLEW_GET_FUN(__glewVertexAttrib4fARB) +#define glVertexAttrib4fvARB GLEW_GET_FUN(__glewVertexAttrib4fvARB) +#define glVertexAttrib4ivARB GLEW_GET_FUN(__glewVertexAttrib4ivARB) +#define glVertexAttrib4sARB GLEW_GET_FUN(__glewVertexAttrib4sARB) +#define glVertexAttrib4svARB GLEW_GET_FUN(__glewVertexAttrib4svARB) +#define glVertexAttrib4ubvARB GLEW_GET_FUN(__glewVertexAttrib4ubvARB) +#define glVertexAttrib4uivARB GLEW_GET_FUN(__glewVertexAttrib4uivARB) +#define glVertexAttrib4usvARB GLEW_GET_FUN(__glewVertexAttrib4usvARB) +#define glVertexAttribPointerARB GLEW_GET_FUN(__glewVertexAttribPointerARB) + +#define GLEW_ARB_vertex_program GLEW_GET_VAR(__GLEW_ARB_vertex_program) + +#endif /* GL_ARB_vertex_program */ + +/* -------------------------- GL_ARB_vertex_shader ------------------------- */ + +#ifndef GL_ARB_vertex_shader +#define GL_ARB_vertex_shader 1 + +#define GL_VERTEX_SHADER_ARB 0x8B31 +#define GL_MAX_VERTEX_UNIFORM_COMPONENTS_ARB 0x8B4A +#define GL_MAX_VARYING_FLOATS_ARB 0x8B4B +#define GL_MAX_VERTEX_TEXTURE_IMAGE_UNITS_ARB 0x8B4C +#define GL_MAX_COMBINED_TEXTURE_IMAGE_UNITS_ARB 0x8B4D +#define GL_OBJECT_ACTIVE_ATTRIBUTES_ARB 0x8B89 +#define GL_OBJECT_ACTIVE_ATTRIBUTE_MAX_LENGTH_ARB 0x8B8A + +typedef void (GLAPIENTRY * PFNGLBINDATTRIBLOCATIONARBPROC) (GLhandleARB programObj, GLuint index, const GLcharARB* name); +typedef void (GLAPIENTRY * PFNGLGETACTIVEATTRIBARBPROC) (GLhandleARB programObj, GLuint index, GLsizei maxLength, GLsizei* length, GLint *size, GLenum *type, GLcharARB *name); +typedef GLint (GLAPIENTRY * PFNGLGETATTRIBLOCATIONARBPROC) (GLhandleARB programObj, const GLcharARB* name); + +#define glBindAttribLocationARB GLEW_GET_FUN(__glewBindAttribLocationARB) +#define glGetActiveAttribARB GLEW_GET_FUN(__glewGetActiveAttribARB) +#define glGetAttribLocationARB GLEW_GET_FUN(__glewGetAttribLocationARB) + +#define GLEW_ARB_vertex_shader GLEW_GET_VAR(__GLEW_ARB_vertex_shader) + +#endif /* GL_ARB_vertex_shader */ + +/* --------------------------- GL_ARB_window_pos --------------------------- */ + +#ifndef GL_ARB_window_pos +#define GL_ARB_window_pos 1 + +typedef void (GLAPIENTRY * PFNGLWINDOWPOS2DARBPROC) (GLdouble x, GLdouble y); +typedef void (GLAPIENTRY * PFNGLWINDOWPOS2DVARBPROC) (const GLdouble* p); +typedef void (GLAPIENTRY * PFNGLWINDOWPOS2FARBPROC) (GLfloat x, GLfloat y); +typedef void (GLAPIENTRY * PFNGLWINDOWPOS2FVARBPROC) (const GLfloat* p); +typedef void (GLAPIENTRY * PFNGLWINDOWPOS2IARBPROC) (GLint x, GLint y); +typedef void (GLAPIENTRY * PFNGLWINDOWPOS2IVARBPROC) (const GLint* p); +typedef void (GLAPIENTRY * PFNGLWINDOWPOS2SARBPROC) (GLshort x, GLshort y); +typedef void (GLAPIENTRY * PFNGLWINDOWPOS2SVARBPROC) (const GLshort* p); +typedef void (GLAPIENTRY * PFNGLWINDOWPOS3DARBPROC) (GLdouble x, GLdouble y, GLdouble z); +typedef void (GLAPIENTRY * PFNGLWINDOWPOS3DVARBPROC) (const GLdouble* p); +typedef void (GLAPIENTRY * PFNGLWINDOWPOS3FARBPROC) (GLfloat x, GLfloat y, GLfloat z); +typedef void (GLAPIENTRY * PFNGLWINDOWPOS3FVARBPROC) (const GLfloat* p); +typedef void (GLAPIENTRY * PFNGLWINDOWPOS3IARBPROC) (GLint x, GLint y, GLint z); +typedef void (GLAPIENTRY * PFNGLWINDOWPOS3IVARBPROC) (const GLint* p); +typedef void (GLAPIENTRY * PFNGLWINDOWPOS3SARBPROC) (GLshort x, GLshort y, GLshort z); +typedef void (GLAPIENTRY * PFNGLWINDOWPOS3SVARBPROC) (const GLshort* p); + +#define glWindowPos2dARB GLEW_GET_FUN(__glewWindowPos2dARB) +#define glWindowPos2dvARB GLEW_GET_FUN(__glewWindowPos2dvARB) +#define glWindowPos2fARB GLEW_GET_FUN(__glewWindowPos2fARB) +#define glWindowPos2fvARB GLEW_GET_FUN(__glewWindowPos2fvARB) +#define glWindowPos2iARB GLEW_GET_FUN(__glewWindowPos2iARB) +#define glWindowPos2ivARB GLEW_GET_FUN(__glewWindowPos2ivARB) +#define glWindowPos2sARB GLEW_GET_FUN(__glewWindowPos2sARB) +#define glWindowPos2svARB GLEW_GET_FUN(__glewWindowPos2svARB) +#define glWindowPos3dARB GLEW_GET_FUN(__glewWindowPos3dARB) +#define glWindowPos3dvARB GLEW_GET_FUN(__glewWindowPos3dvARB) +#define glWindowPos3fARB GLEW_GET_FUN(__glewWindowPos3fARB) +#define glWindowPos3fvARB GLEW_GET_FUN(__glewWindowPos3fvARB) +#define glWindowPos3iARB GLEW_GET_FUN(__glewWindowPos3iARB) +#define glWindowPos3ivARB GLEW_GET_FUN(__glewWindowPos3ivARB) +#define glWindowPos3sARB GLEW_GET_FUN(__glewWindowPos3sARB) +#define glWindowPos3svARB GLEW_GET_FUN(__glewWindowPos3svARB) + +#define GLEW_ARB_window_pos GLEW_GET_VAR(__GLEW_ARB_window_pos) + +#endif /* GL_ARB_window_pos */ + +/* ------------------------- GL_ATIX_point_sprites ------------------------- */ + +#ifndef GL_ATIX_point_sprites +#define GL_ATIX_point_sprites 1 + +#define GL_TEXTURE_POINT_MODE_ATIX 0x60B0 +#define GL_TEXTURE_POINT_ONE_COORD_ATIX 0x60B1 +#define GL_TEXTURE_POINT_SPRITE_ATIX 0x60B2 +#define GL_POINT_SPRITE_CULL_MODE_ATIX 0x60B3 +#define GL_POINT_SPRITE_CULL_CENTER_ATIX 0x60B4 +#define GL_POINT_SPRITE_CULL_CLIP_ATIX 0x60B5 + +#define GLEW_ATIX_point_sprites GLEW_GET_VAR(__GLEW_ATIX_point_sprites) + +#endif /* GL_ATIX_point_sprites */ + +/* ---------------------- GL_ATIX_texture_env_combine3 --------------------- */ + +#ifndef GL_ATIX_texture_env_combine3 +#define GL_ATIX_texture_env_combine3 1 + +#define GL_MODULATE_ADD_ATIX 0x8744 +#define GL_MODULATE_SIGNED_ADD_ATIX 0x8745 +#define GL_MODULATE_SUBTRACT_ATIX 0x8746 + +#define GLEW_ATIX_texture_env_combine3 GLEW_GET_VAR(__GLEW_ATIX_texture_env_combine3) + +#endif /* GL_ATIX_texture_env_combine3 */ + +/* ----------------------- GL_ATIX_texture_env_route ----------------------- */ + +#ifndef GL_ATIX_texture_env_route +#define GL_ATIX_texture_env_route 1 + +#define GL_SECONDARY_COLOR_ATIX 0x8747 +#define GL_TEXTURE_OUTPUT_RGB_ATIX 0x8748 +#define GL_TEXTURE_OUTPUT_ALPHA_ATIX 0x8749 + +#define GLEW_ATIX_texture_env_route GLEW_GET_VAR(__GLEW_ATIX_texture_env_route) + +#endif /* GL_ATIX_texture_env_route */ + +/* ---------------- GL_ATIX_vertex_shader_output_point_size ---------------- */ + +#ifndef GL_ATIX_vertex_shader_output_point_size +#define GL_ATIX_vertex_shader_output_point_size 1 + +#define GL_OUTPUT_POINT_SIZE_ATIX 0x610E + +#define GLEW_ATIX_vertex_shader_output_point_size GLEW_GET_VAR(__GLEW_ATIX_vertex_shader_output_point_size) + +#endif /* GL_ATIX_vertex_shader_output_point_size */ + +/* -------------------------- GL_ATI_draw_buffers -------------------------- */ + +#ifndef GL_ATI_draw_buffers +#define GL_ATI_draw_buffers 1 + +#define GL_MAX_DRAW_BUFFERS_ATI 0x8824 +#define GL_DRAW_BUFFER0_ATI 0x8825 +#define GL_DRAW_BUFFER1_ATI 0x8826 +#define GL_DRAW_BUFFER2_ATI 0x8827 +#define GL_DRAW_BUFFER3_ATI 0x8828 +#define GL_DRAW_BUFFER4_ATI 0x8829 +#define GL_DRAW_BUFFER5_ATI 0x882A +#define GL_DRAW_BUFFER6_ATI 0x882B +#define GL_DRAW_BUFFER7_ATI 0x882C +#define GL_DRAW_BUFFER8_ATI 0x882D +#define GL_DRAW_BUFFER9_ATI 0x882E +#define GL_DRAW_BUFFER10_ATI 0x882F +#define GL_DRAW_BUFFER11_ATI 0x8830 +#define GL_DRAW_BUFFER12_ATI 0x8831 +#define GL_DRAW_BUFFER13_ATI 0x8832 +#define GL_DRAW_BUFFER14_ATI 0x8833 +#define GL_DRAW_BUFFER15_ATI 0x8834 + +typedef void (GLAPIENTRY * PFNGLDRAWBUFFERSATIPROC) (GLsizei n, const GLenum* bufs); + +#define glDrawBuffersATI GLEW_GET_FUN(__glewDrawBuffersATI) + +#define GLEW_ATI_draw_buffers GLEW_GET_VAR(__GLEW_ATI_draw_buffers) + +#endif /* GL_ATI_draw_buffers */ + +/* -------------------------- GL_ATI_element_array ------------------------- */ + +#ifndef GL_ATI_element_array +#define GL_ATI_element_array 1 + +#define GL_ELEMENT_ARRAY_ATI 0x8768 +#define GL_ELEMENT_ARRAY_TYPE_ATI 0x8769 +#define GL_ELEMENT_ARRAY_POINTER_ATI 0x876A + +typedef void (GLAPIENTRY * PFNGLDRAWELEMENTARRAYATIPROC) (GLenum mode, GLsizei count); +typedef void (GLAPIENTRY * PFNGLDRAWRANGEELEMENTARRAYATIPROC) (GLenum mode, GLuint start, GLuint end, GLsizei count); +typedef void (GLAPIENTRY * PFNGLELEMENTPOINTERATIPROC) (GLenum type, const void* pointer); + +#define glDrawElementArrayATI GLEW_GET_FUN(__glewDrawElementArrayATI) +#define glDrawRangeElementArrayATI GLEW_GET_FUN(__glewDrawRangeElementArrayATI) +#define glElementPointerATI GLEW_GET_FUN(__glewElementPointerATI) + +#define GLEW_ATI_element_array GLEW_GET_VAR(__GLEW_ATI_element_array) + +#endif /* GL_ATI_element_array */ + +/* ------------------------- GL_ATI_envmap_bumpmap ------------------------- */ + +#ifndef GL_ATI_envmap_bumpmap +#define GL_ATI_envmap_bumpmap 1 + +#define GL_BUMP_ROT_MATRIX_ATI 0x8775 +#define GL_BUMP_ROT_MATRIX_SIZE_ATI 0x8776 +#define GL_BUMP_NUM_TEX_UNITS_ATI 0x8777 +#define GL_BUMP_TEX_UNITS_ATI 0x8778 +#define GL_DUDV_ATI 0x8779 +#define GL_DU8DV8_ATI 0x877A +#define GL_BUMP_ENVMAP_ATI 0x877B +#define GL_BUMP_TARGET_ATI 0x877C + +typedef void (GLAPIENTRY * PFNGLGETTEXBUMPPARAMETERFVATIPROC) (GLenum pname, GLfloat *param); +typedef void (GLAPIENTRY * PFNGLGETTEXBUMPPARAMETERIVATIPROC) (GLenum pname, GLint *param); +typedef void (GLAPIENTRY * PFNGLTEXBUMPPARAMETERFVATIPROC) (GLenum pname, GLfloat *param); +typedef void (GLAPIENTRY * PFNGLTEXBUMPPARAMETERIVATIPROC) (GLenum pname, GLint *param); + +#define glGetTexBumpParameterfvATI GLEW_GET_FUN(__glewGetTexBumpParameterfvATI) +#define glGetTexBumpParameterivATI GLEW_GET_FUN(__glewGetTexBumpParameterivATI) +#define glTexBumpParameterfvATI GLEW_GET_FUN(__glewTexBumpParameterfvATI) +#define glTexBumpParameterivATI GLEW_GET_FUN(__glewTexBumpParameterivATI) + +#define GLEW_ATI_envmap_bumpmap GLEW_GET_VAR(__GLEW_ATI_envmap_bumpmap) + +#endif /* GL_ATI_envmap_bumpmap */ + +/* ------------------------- GL_ATI_fragment_shader ------------------------ */ + +#ifndef GL_ATI_fragment_shader +#define GL_ATI_fragment_shader 1 + +#define GL_RED_BIT_ATI 0x00000001 +#define GL_2X_BIT_ATI 0x00000001 +#define GL_4X_BIT_ATI 0x00000002 +#define GL_GREEN_BIT_ATI 0x00000002 +#define GL_COMP_BIT_ATI 0x00000002 +#define GL_BLUE_BIT_ATI 0x00000004 +#define GL_8X_BIT_ATI 0x00000004 +#define GL_NEGATE_BIT_ATI 0x00000004 +#define GL_BIAS_BIT_ATI 0x00000008 +#define GL_HALF_BIT_ATI 0x00000008 +#define GL_QUARTER_BIT_ATI 0x00000010 +#define GL_EIGHTH_BIT_ATI 0x00000020 +#define GL_SATURATE_BIT_ATI 0x00000040 +#define GL_FRAGMENT_SHADER_ATI 0x8920 +#define GL_REG_0_ATI 0x8921 +#define GL_REG_1_ATI 0x8922 +#define GL_REG_2_ATI 0x8923 +#define GL_REG_3_ATI 0x8924 +#define GL_REG_4_ATI 0x8925 +#define GL_REG_5_ATI 0x8926 +#define GL_CON_0_ATI 0x8941 +#define GL_CON_1_ATI 0x8942 +#define GL_CON_2_ATI 0x8943 +#define GL_CON_3_ATI 0x8944 +#define GL_CON_4_ATI 0x8945 +#define GL_CON_5_ATI 0x8946 +#define GL_CON_6_ATI 0x8947 +#define GL_CON_7_ATI 0x8948 +#define GL_MOV_ATI 0x8961 +#define GL_ADD_ATI 0x8963 +#define GL_MUL_ATI 0x8964 +#define GL_SUB_ATI 0x8965 +#define GL_DOT3_ATI 0x8966 +#define GL_DOT4_ATI 0x8967 +#define GL_MAD_ATI 0x8968 +#define GL_LERP_ATI 0x8969 +#define GL_CND_ATI 0x896A +#define GL_CND0_ATI 0x896B +#define GL_DOT2_ADD_ATI 0x896C +#define GL_SECONDARY_INTERPOLATOR_ATI 0x896D +#define GL_NUM_FRAGMENT_REGISTERS_ATI 0x896E +#define GL_NUM_FRAGMENT_CONSTANTS_ATI 0x896F +#define GL_NUM_PASSES_ATI 0x8970 +#define GL_NUM_INSTRUCTIONS_PER_PASS_ATI 0x8971 +#define GL_NUM_INSTRUCTIONS_TOTAL_ATI 0x8972 +#define GL_NUM_INPUT_INTERPOLATOR_COMPONENTS_ATI 0x8973 +#define GL_NUM_LOOPBACK_COMPONENTS_ATI 0x8974 +#define GL_COLOR_ALPHA_PAIRING_ATI 0x8975 +#define GL_SWIZZLE_STR_ATI 0x8976 +#define GL_SWIZZLE_STQ_ATI 0x8977 +#define GL_SWIZZLE_STR_DR_ATI 0x8978 +#define GL_SWIZZLE_STQ_DQ_ATI 0x8979 +#define GL_SWIZZLE_STRQ_ATI 0x897A +#define GL_SWIZZLE_STRQ_DQ_ATI 0x897B + +typedef void (GLAPIENTRY * PFNGLALPHAFRAGMENTOP1ATIPROC) (GLenum op, GLuint dst, GLuint dstMod, GLuint arg1, GLuint arg1Rep, GLuint arg1Mod); +typedef void (GLAPIENTRY * PFNGLALPHAFRAGMENTOP2ATIPROC) (GLenum op, GLuint dst, GLuint dstMod, GLuint arg1, GLuint arg1Rep, GLuint arg1Mod, GLuint arg2, GLuint arg2Rep, GLuint arg2Mod); +typedef void (GLAPIENTRY * PFNGLALPHAFRAGMENTOP3ATIPROC) (GLenum op, GLuint dst, GLuint dstMod, GLuint arg1, GLuint arg1Rep, GLuint arg1Mod, GLuint arg2, GLuint arg2Rep, GLuint arg2Mod, GLuint arg3, GLuint arg3Rep, GLuint arg3Mod); +typedef void (GLAPIENTRY * PFNGLBEGINFRAGMENTSHADERATIPROC) (void); +typedef void (GLAPIENTRY * PFNGLBINDFRAGMENTSHADERATIPROC) (GLuint id); +typedef void (GLAPIENTRY * PFNGLCOLORFRAGMENTOP1ATIPROC) (GLenum op, GLuint dst, GLuint dstMask, GLuint dstMod, GLuint arg1, GLuint arg1Rep, GLuint arg1Mod); +typedef void (GLAPIENTRY * PFNGLCOLORFRAGMENTOP2ATIPROC) (GLenum op, GLuint dst, GLuint dstMask, GLuint dstMod, GLuint arg1, GLuint arg1Rep, GLuint arg1Mod, GLuint arg2, GLuint arg2Rep, GLuint arg2Mod); +typedef void (GLAPIENTRY * PFNGLCOLORFRAGMENTOP3ATIPROC) (GLenum op, GLuint dst, GLuint dstMask, GLuint dstMod, GLuint arg1, GLuint arg1Rep, GLuint arg1Mod, GLuint arg2, GLuint arg2Rep, GLuint arg2Mod, GLuint arg3, GLuint arg3Rep, GLuint arg3Mod); +typedef void (GLAPIENTRY * PFNGLDELETEFRAGMENTSHADERATIPROC) (GLuint id); +typedef void (GLAPIENTRY * PFNGLENDFRAGMENTSHADERATIPROC) (void); +typedef GLuint (GLAPIENTRY * PFNGLGENFRAGMENTSHADERSATIPROC) (GLuint range); +typedef void (GLAPIENTRY * PFNGLPASSTEXCOORDATIPROC) (GLuint dst, GLuint coord, GLenum swizzle); +typedef void (GLAPIENTRY * PFNGLSAMPLEMAPATIPROC) (GLuint dst, GLuint interp, GLenum swizzle); +typedef void (GLAPIENTRY * PFNGLSETFRAGMENTSHADERCONSTANTATIPROC) (GLuint dst, const GLfloat* value); + +#define glAlphaFragmentOp1ATI GLEW_GET_FUN(__glewAlphaFragmentOp1ATI) +#define glAlphaFragmentOp2ATI GLEW_GET_FUN(__glewAlphaFragmentOp2ATI) +#define glAlphaFragmentOp3ATI GLEW_GET_FUN(__glewAlphaFragmentOp3ATI) +#define glBeginFragmentShaderATI GLEW_GET_FUN(__glewBeginFragmentShaderATI) +#define glBindFragmentShaderATI GLEW_GET_FUN(__glewBindFragmentShaderATI) +#define glColorFragmentOp1ATI GLEW_GET_FUN(__glewColorFragmentOp1ATI) +#define glColorFragmentOp2ATI GLEW_GET_FUN(__glewColorFragmentOp2ATI) +#define glColorFragmentOp3ATI GLEW_GET_FUN(__glewColorFragmentOp3ATI) +#define glDeleteFragmentShaderATI GLEW_GET_FUN(__glewDeleteFragmentShaderATI) +#define glEndFragmentShaderATI GLEW_GET_FUN(__glewEndFragmentShaderATI) +#define glGenFragmentShadersATI GLEW_GET_FUN(__glewGenFragmentShadersATI) +#define glPassTexCoordATI GLEW_GET_FUN(__glewPassTexCoordATI) +#define glSampleMapATI GLEW_GET_FUN(__glewSampleMapATI) +#define glSetFragmentShaderConstantATI GLEW_GET_FUN(__glewSetFragmentShaderConstantATI) + +#define GLEW_ATI_fragment_shader GLEW_GET_VAR(__GLEW_ATI_fragment_shader) + +#endif /* GL_ATI_fragment_shader */ + +/* ------------------------ GL_ATI_map_object_buffer ----------------------- */ + +#ifndef GL_ATI_map_object_buffer +#define GL_ATI_map_object_buffer 1 + +typedef void* (GLAPIENTRY * PFNGLMAPOBJECTBUFFERATIPROC) (GLuint buffer); +typedef void (GLAPIENTRY * PFNGLUNMAPOBJECTBUFFERATIPROC) (GLuint buffer); + +#define glMapObjectBufferATI GLEW_GET_FUN(__glewMapObjectBufferATI) +#define glUnmapObjectBufferATI GLEW_GET_FUN(__glewUnmapObjectBufferATI) + +#define GLEW_ATI_map_object_buffer GLEW_GET_VAR(__GLEW_ATI_map_object_buffer) + +#endif /* GL_ATI_map_object_buffer */ + +/* -------------------------- GL_ATI_pn_triangles -------------------------- */ + +#ifndef GL_ATI_pn_triangles +#define GL_ATI_pn_triangles 1 + +#define GL_PN_TRIANGLES_ATI 0x87F0 +#define GL_MAX_PN_TRIANGLES_TESSELATION_LEVEL_ATI 0x87F1 +#define GL_PN_TRIANGLES_POINT_MODE_ATI 0x87F2 +#define GL_PN_TRIANGLES_NORMAL_MODE_ATI 0x87F3 +#define GL_PN_TRIANGLES_TESSELATION_LEVEL_ATI 0x87F4 +#define GL_PN_TRIANGLES_POINT_MODE_LINEAR_ATI 0x87F5 +#define GL_PN_TRIANGLES_POINT_MODE_CUBIC_ATI 0x87F6 +#define GL_PN_TRIANGLES_NORMAL_MODE_LINEAR_ATI 0x87F7 +#define GL_PN_TRIANGLES_NORMAL_MODE_QUADRATIC_ATI 0x87F8 + +typedef void (GLAPIENTRY * PFNGLPNTRIANGLESFATIPROC) (GLenum pname, GLfloat param); +typedef void (GLAPIENTRY * PFNGLPNTRIANGLESIATIPROC) (GLenum pname, GLint param); + +#define glPNTrianglesfATI GLEW_GET_FUN(__glPNTrianglewesfATI) +#define glPNTrianglesiATI GLEW_GET_FUN(__glPNTrianglewesiATI) + +#define GLEW_ATI_pn_triangles GLEW_GET_VAR(__GLEW_ATI_pn_triangles) + +#endif /* GL_ATI_pn_triangles */ + +/* ------------------------ GL_ATI_separate_stencil ------------------------ */ + +#ifndef GL_ATI_separate_stencil +#define GL_ATI_separate_stencil 1 + +#define GL_STENCIL_BACK_FUNC_ATI 0x8800 +#define GL_STENCIL_BACK_FAIL_ATI 0x8801 +#define GL_STENCIL_BACK_PASS_DEPTH_FAIL_ATI 0x8802 +#define GL_STENCIL_BACK_PASS_DEPTH_PASS_ATI 0x8803 + +typedef void (GLAPIENTRY * PFNGLSTENCILFUNCSEPARATEATIPROC) (GLenum frontfunc, GLenum backfunc, GLint ref, GLuint mask); +typedef void (GLAPIENTRY * PFNGLSTENCILOPSEPARATEATIPROC) (GLenum face, GLenum sfail, GLenum dpfail, GLenum dppass); + +#define glStencilFuncSeparateATI GLEW_GET_FUN(__glewStencilFuncSeparateATI) +#define glStencilOpSeparateATI GLEW_GET_FUN(__glewStencilOpSeparateATI) + +#define GLEW_ATI_separate_stencil GLEW_GET_VAR(__GLEW_ATI_separate_stencil) + +#endif /* GL_ATI_separate_stencil */ + +/* ----------------------- GL_ATI_shader_texture_lod ----------------------- */ + +#ifndef GL_ATI_shader_texture_lod +#define GL_ATI_shader_texture_lod 1 + +#define GLEW_ATI_shader_texture_lod GLEW_GET_VAR(__GLEW_ATI_shader_texture_lod) + +#endif /* GL_ATI_shader_texture_lod */ + +/* ---------------------- GL_ATI_text_fragment_shader ---------------------- */ + +#ifndef GL_ATI_text_fragment_shader +#define GL_ATI_text_fragment_shader 1 + +#define GL_TEXT_FRAGMENT_SHADER_ATI 0x8200 + +#define GLEW_ATI_text_fragment_shader GLEW_GET_VAR(__GLEW_ATI_text_fragment_shader) + +#endif /* GL_ATI_text_fragment_shader */ + +/* --------------------- GL_ATI_texture_compression_3dc -------------------- */ + +#ifndef GL_ATI_texture_compression_3dc +#define GL_ATI_texture_compression_3dc 1 + +#define GL_COMPRESSED_LUMINANCE_ALPHA_3DC_ATI 0x8837 + +#define GLEW_ATI_texture_compression_3dc GLEW_GET_VAR(__GLEW_ATI_texture_compression_3dc) + +#endif /* GL_ATI_texture_compression_3dc */ + +/* ---------------------- GL_ATI_texture_env_combine3 ---------------------- */ + +#ifndef GL_ATI_texture_env_combine3 +#define GL_ATI_texture_env_combine3 1 + +#define GL_MODULATE_ADD_ATI 0x8744 +#define GL_MODULATE_SIGNED_ADD_ATI 0x8745 +#define GL_MODULATE_SUBTRACT_ATI 0x8746 + +#define GLEW_ATI_texture_env_combine3 GLEW_GET_VAR(__GLEW_ATI_texture_env_combine3) + +#endif /* GL_ATI_texture_env_combine3 */ + +/* -------------------------- GL_ATI_texture_float ------------------------- */ + +#ifndef GL_ATI_texture_float +#define GL_ATI_texture_float 1 + +#define GL_RGBA_FLOAT32_ATI 0x8814 +#define GL_RGB_FLOAT32_ATI 0x8815 +#define GL_ALPHA_FLOAT32_ATI 0x8816 +#define GL_INTENSITY_FLOAT32_ATI 0x8817 +#define GL_LUMINANCE_FLOAT32_ATI 0x8818 +#define GL_LUMINANCE_ALPHA_FLOAT32_ATI 0x8819 +#define GL_RGBA_FLOAT16_ATI 0x881A +#define GL_RGB_FLOAT16_ATI 0x881B +#define GL_ALPHA_FLOAT16_ATI 0x881C +#define GL_INTENSITY_FLOAT16_ATI 0x881D +#define GL_LUMINANCE_FLOAT16_ATI 0x881E +#define GL_LUMINANCE_ALPHA_FLOAT16_ATI 0x881F + +#define GLEW_ATI_texture_float GLEW_GET_VAR(__GLEW_ATI_texture_float) + +#endif /* GL_ATI_texture_float */ + +/* ----------------------- GL_ATI_texture_mirror_once ---------------------- */ + +#ifndef GL_ATI_texture_mirror_once +#define GL_ATI_texture_mirror_once 1 + +#define GL_MIRROR_CLAMP_ATI 0x8742 +#define GL_MIRROR_CLAMP_TO_EDGE_ATI 0x8743 + +#define GLEW_ATI_texture_mirror_once GLEW_GET_VAR(__GLEW_ATI_texture_mirror_once) + +#endif /* GL_ATI_texture_mirror_once */ + +/* ----------------------- GL_ATI_vertex_array_object ---------------------- */ + +#ifndef GL_ATI_vertex_array_object +#define GL_ATI_vertex_array_object 1 + +#define GL_STATIC_ATI 0x8760 +#define GL_DYNAMIC_ATI 0x8761 +#define GL_PRESERVE_ATI 0x8762 +#define GL_DISCARD_ATI 0x8763 +#define GL_OBJECT_BUFFER_SIZE_ATI 0x8764 +#define GL_OBJECT_BUFFER_USAGE_ATI 0x8765 +#define GL_ARRAY_OBJECT_BUFFER_ATI 0x8766 +#define GL_ARRAY_OBJECT_OFFSET_ATI 0x8767 + +typedef void (GLAPIENTRY * PFNGLARRAYOBJECTATIPROC) (GLenum array, GLint size, GLenum type, GLsizei stride, GLuint buffer, GLuint offset); +typedef void (GLAPIENTRY * PFNGLFREEOBJECTBUFFERATIPROC) (GLuint buffer); +typedef void (GLAPIENTRY * PFNGLGETARRAYOBJECTFVATIPROC) (GLenum array, GLenum pname, GLfloat* params); +typedef void (GLAPIENTRY * PFNGLGETARRAYOBJECTIVATIPROC) (GLenum array, GLenum pname, GLint* params); +typedef void (GLAPIENTRY * PFNGLGETOBJECTBUFFERFVATIPROC) (GLuint buffer, GLenum pname, GLfloat* params); +typedef void (GLAPIENTRY * PFNGLGETOBJECTBUFFERIVATIPROC) (GLuint buffer, GLenum pname, GLint* params); +typedef void (GLAPIENTRY * PFNGLGETVARIANTARRAYOBJECTFVATIPROC) (GLuint id, GLenum pname, GLfloat* params); +typedef void (GLAPIENTRY * PFNGLGETVARIANTARRAYOBJECTIVATIPROC) (GLuint id, GLenum pname, GLint* params); +typedef GLboolean (GLAPIENTRY * PFNGLISOBJECTBUFFERATIPROC) (GLuint buffer); +typedef GLuint (GLAPIENTRY * PFNGLNEWOBJECTBUFFERATIPROC) (GLsizei size, const void* pointer, GLenum usage); +typedef void (GLAPIENTRY * PFNGLUPDATEOBJECTBUFFERATIPROC) (GLuint buffer, GLuint offset, GLsizei size, const void* pointer, GLenum preserve); +typedef void (GLAPIENTRY * PFNGLVARIANTARRAYOBJECTATIPROC) (GLuint id, GLenum type, GLsizei stride, GLuint buffer, GLuint offset); + +#define glArrayObjectATI GLEW_GET_FUN(__glewArrayObjectATI) +#define glFreeObjectBufferATI GLEW_GET_FUN(__glewFreeObjectBufferATI) +#define glGetArrayObjectfvATI GLEW_GET_FUN(__glewGetArrayObjectfvATI) +#define glGetArrayObjectivATI GLEW_GET_FUN(__glewGetArrayObjectivATI) +#define glGetObjectBufferfvATI GLEW_GET_FUN(__glewGetObjectBufferfvATI) +#define glGetObjectBufferivATI GLEW_GET_FUN(__glewGetObjectBufferivATI) +#define glGetVariantArrayObjectfvATI GLEW_GET_FUN(__glewGetVariantArrayObjectfvATI) +#define glGetVariantArrayObjectivATI GLEW_GET_FUN(__glewGetVariantArrayObjectivATI) +#define glIsObjectBufferATI GLEW_GET_FUN(__glewIsObjectBufferATI) +#define glNewObjectBufferATI GLEW_GET_FUN(__glewNewObjectBufferATI) +#define glUpdateObjectBufferATI GLEW_GET_FUN(__glewUpdateObjectBufferATI) +#define glVariantArrayObjectATI GLEW_GET_FUN(__glewVariantArrayObjectATI) + +#define GLEW_ATI_vertex_array_object GLEW_GET_VAR(__GLEW_ATI_vertex_array_object) + +#endif /* GL_ATI_vertex_array_object */ + +/* ------------------- GL_ATI_vertex_attrib_array_object ------------------- */ + +#ifndef GL_ATI_vertex_attrib_array_object +#define GL_ATI_vertex_attrib_array_object 1 + +typedef void (GLAPIENTRY * PFNGLGETVERTEXATTRIBARRAYOBJECTFVATIPROC) (GLuint index, GLenum pname, GLfloat* params); +typedef void (GLAPIENTRY * PFNGLGETVERTEXATTRIBARRAYOBJECTIVATIPROC) (GLuint index, GLenum pname, GLint* params); +typedef void (GLAPIENTRY * PFNGLVERTEXATTRIBARRAYOBJECTATIPROC) (GLuint index, GLint size, GLenum type, GLboolean normalized, GLsizei stride, GLuint buffer, GLuint offset); + +#define glGetVertexAttribArrayObjectfvATI GLEW_GET_FUN(__glewGetVertexAttribArrayObjectfvATI) +#define glGetVertexAttribArrayObjectivATI GLEW_GET_FUN(__glewGetVertexAttribArrayObjectivATI) +#define glVertexAttribArrayObjectATI GLEW_GET_FUN(__glewVertexAttribArrayObjectATI) + +#define GLEW_ATI_vertex_attrib_array_object GLEW_GET_VAR(__GLEW_ATI_vertex_attrib_array_object) + +#endif /* GL_ATI_vertex_attrib_array_object */ + +/* ------------------------- GL_ATI_vertex_streams ------------------------- */ + +#ifndef GL_ATI_vertex_streams +#define GL_ATI_vertex_streams 1 + +#define GL_MAX_VERTEX_STREAMS_ATI 0x876B +#define GL_VERTEX_SOURCE_ATI 0x876C +#define GL_VERTEX_STREAM0_ATI 0x876D +#define GL_VERTEX_STREAM1_ATI 0x876E +#define GL_VERTEX_STREAM2_ATI 0x876F +#define GL_VERTEX_STREAM3_ATI 0x8770 +#define GL_VERTEX_STREAM4_ATI 0x8771 +#define GL_VERTEX_STREAM5_ATI 0x8772 +#define GL_VERTEX_STREAM6_ATI 0x8773 +#define GL_VERTEX_STREAM7_ATI 0x8774 + +typedef void (GLAPIENTRY * PFNGLCLIENTACTIVEVERTEXSTREAMATIPROC) (GLenum stream); +typedef void (GLAPIENTRY * PFNGLNORMALSTREAM3BATIPROC) (GLenum stream, GLbyte x, GLbyte y, GLbyte z); +typedef void (GLAPIENTRY * PFNGLNORMALSTREAM3BVATIPROC) (GLenum stream, const GLbyte *v); +typedef void (GLAPIENTRY * PFNGLNORMALSTREAM3DATIPROC) (GLenum stream, GLdouble x, GLdouble y, GLdouble z); +typedef void (GLAPIENTRY * PFNGLNORMALSTREAM3DVATIPROC) (GLenum stream, const GLdouble *v); +typedef void (GLAPIENTRY * PFNGLNORMALSTREAM3FATIPROC) (GLenum stream, GLfloat x, GLfloat y, GLfloat z); +typedef void (GLAPIENTRY * PFNGLNORMALSTREAM3FVATIPROC) (GLenum stream, const GLfloat *v); +typedef void (GLAPIENTRY * PFNGLNORMALSTREAM3IATIPROC) (GLenum stream, GLint x, GLint y, GLint z); +typedef void (GLAPIENTRY * PFNGLNORMALSTREAM3IVATIPROC) (GLenum stream, const GLint *v); +typedef void (GLAPIENTRY * PFNGLNORMALSTREAM3SATIPROC) (GLenum stream, GLshort x, GLshort y, GLshort z); +typedef void (GLAPIENTRY * PFNGLNORMALSTREAM3SVATIPROC) (GLenum stream, const GLshort *v); +typedef void (GLAPIENTRY * PFNGLVERTEXBLENDENVFATIPROC) (GLenum pname, GLfloat param); +typedef void (GLAPIENTRY * PFNGLVERTEXBLENDENVIATIPROC) (GLenum pname, GLint param); +typedef void (GLAPIENTRY * PFNGLVERTEXSTREAM2DATIPROC) (GLenum stream, GLdouble x, GLdouble y); +typedef void (GLAPIENTRY * PFNGLVERTEXSTREAM2DVATIPROC) (GLenum stream, const GLdouble *v); +typedef void (GLAPIENTRY * PFNGLVERTEXSTREAM2FATIPROC) (GLenum stream, GLfloat x, GLfloat y); +typedef void (GLAPIENTRY * PFNGLVERTEXSTREAM2FVATIPROC) (GLenum stream, const GLfloat *v); +typedef void (GLAPIENTRY * PFNGLVERTEXSTREAM2IATIPROC) (GLenum stream, GLint x, GLint y); +typedef void (GLAPIENTRY * PFNGLVERTEXSTREAM2IVATIPROC) (GLenum stream, const GLint *v); +typedef void (GLAPIENTRY * PFNGLVERTEXSTREAM2SATIPROC) (GLenum stream, GLshort x, GLshort y); +typedef void (GLAPIENTRY * PFNGLVERTEXSTREAM2SVATIPROC) (GLenum stream, const GLshort *v); +typedef void (GLAPIENTRY * PFNGLVERTEXSTREAM3DATIPROC) (GLenum stream, GLdouble x, GLdouble y, GLdouble z); +typedef void (GLAPIENTRY * PFNGLVERTEXSTREAM3DVATIPROC) (GLenum stream, const GLdouble *v); +typedef void (GLAPIENTRY * PFNGLVERTEXSTREAM3FATIPROC) (GLenum stream, GLfloat x, GLfloat y, GLfloat z); +typedef void (GLAPIENTRY * PFNGLVERTEXSTREAM3FVATIPROC) (GLenum stream, const GLfloat *v); +typedef void (GLAPIENTRY * PFNGLVERTEXSTREAM3IATIPROC) (GLenum stream, GLint x, GLint y, GLint z); +typedef void (GLAPIENTRY * PFNGLVERTEXSTREAM3IVATIPROC) (GLenum stream, const GLint *v); +typedef void (GLAPIENTRY * PFNGLVERTEXSTREAM3SATIPROC) (GLenum stream, GLshort x, GLshort y, GLshort z); +typedef void (GLAPIENTRY * PFNGLVERTEXSTREAM3SVATIPROC) (GLenum stream, const GLshort *v); +typedef void (GLAPIENTRY * PFNGLVERTEXSTREAM4DATIPROC) (GLenum stream, GLdouble x, GLdouble y, GLdouble z, GLdouble w); +typedef void (GLAPIENTRY * PFNGLVERTEXSTREAM4DVATIPROC) (GLenum stream, const GLdouble *v); +typedef void (GLAPIENTRY * PFNGLVERTEXSTREAM4FATIPROC) (GLenum stream, GLfloat x, GLfloat y, GLfloat z, GLfloat w); +typedef void (GLAPIENTRY * PFNGLVERTEXSTREAM4FVATIPROC) (GLenum stream, const GLfloat *v); +typedef void (GLAPIENTRY * PFNGLVERTEXSTREAM4IATIPROC) (GLenum stream, GLint x, GLint y, GLint z, GLint w); +typedef void (GLAPIENTRY * PFNGLVERTEXSTREAM4IVATIPROC) (GLenum stream, const GLint *v); +typedef void (GLAPIENTRY * PFNGLVERTEXSTREAM4SATIPROC) (GLenum stream, GLshort x, GLshort y, GLshort z, GLshort w); +typedef void (GLAPIENTRY * PFNGLVERTEXSTREAM4SVATIPROC) (GLenum stream, const GLshort *v); + +#define glClientActiveVertexStreamATI GLEW_GET_FUN(__glewClientActiveVertexStreamATI) +#define glNormalStream3bATI GLEW_GET_FUN(__glewNormalStream3bATI) +#define glNormalStream3bvATI GLEW_GET_FUN(__glewNormalStream3bvATI) +#define glNormalStream3dATI GLEW_GET_FUN(__glewNormalStream3dATI) +#define glNormalStream3dvATI GLEW_GET_FUN(__glewNormalStream3dvATI) +#define glNormalStream3fATI GLEW_GET_FUN(__glewNormalStream3fATI) +#define glNormalStream3fvATI GLEW_GET_FUN(__glewNormalStream3fvATI) +#define glNormalStream3iATI GLEW_GET_FUN(__glewNormalStream3iATI) +#define glNormalStream3ivATI GLEW_GET_FUN(__glewNormalStream3ivATI) +#define glNormalStream3sATI GLEW_GET_FUN(__glewNormalStream3sATI) +#define glNormalStream3svATI GLEW_GET_FUN(__glewNormalStream3svATI) +#define glVertexBlendEnvfATI GLEW_GET_FUN(__glewVertexBlendEnvfATI) +#define glVertexBlendEnviATI GLEW_GET_FUN(__glewVertexBlendEnviATI) +#define glVertexStream2dATI GLEW_GET_FUN(__glewVertexStream2dATI) +#define glVertexStream2dvATI GLEW_GET_FUN(__glewVertexStream2dvATI) +#define glVertexStream2fATI GLEW_GET_FUN(__glewVertexStream2fATI) +#define glVertexStream2fvATI GLEW_GET_FUN(__glewVertexStream2fvATI) +#define glVertexStream2iATI GLEW_GET_FUN(__glewVertexStream2iATI) +#define glVertexStream2ivATI GLEW_GET_FUN(__glewVertexStream2ivATI) +#define glVertexStream2sATI GLEW_GET_FUN(__glewVertexStream2sATI) +#define glVertexStream2svATI GLEW_GET_FUN(__glewVertexStream2svATI) +#define glVertexStream3dATI GLEW_GET_FUN(__glewVertexStream3dATI) +#define glVertexStream3dvATI GLEW_GET_FUN(__glewVertexStream3dvATI) +#define glVertexStream3fATI GLEW_GET_FUN(__glewVertexStream3fATI) +#define glVertexStream3fvATI GLEW_GET_FUN(__glewVertexStream3fvATI) +#define glVertexStream3iATI GLEW_GET_FUN(__glewVertexStream3iATI) +#define glVertexStream3ivATI GLEW_GET_FUN(__glewVertexStream3ivATI) +#define glVertexStream3sATI GLEW_GET_FUN(__glewVertexStream3sATI) +#define glVertexStream3svATI GLEW_GET_FUN(__glewVertexStream3svATI) +#define glVertexStream4dATI GLEW_GET_FUN(__glewVertexStream4dATI) +#define glVertexStream4dvATI GLEW_GET_FUN(__glewVertexStream4dvATI) +#define glVertexStream4fATI GLEW_GET_FUN(__glewVertexStream4fATI) +#define glVertexStream4fvATI GLEW_GET_FUN(__glewVertexStream4fvATI) +#define glVertexStream4iATI GLEW_GET_FUN(__glewVertexStream4iATI) +#define glVertexStream4ivATI GLEW_GET_FUN(__glewVertexStream4ivATI) +#define glVertexStream4sATI GLEW_GET_FUN(__glewVertexStream4sATI) +#define glVertexStream4svATI GLEW_GET_FUN(__glewVertexStream4svATI) + +#define GLEW_ATI_vertex_streams GLEW_GET_VAR(__GLEW_ATI_vertex_streams) + +#endif /* GL_ATI_vertex_streams */ + +/* --------------------------- GL_EXT_422_pixels --------------------------- */ + +#ifndef GL_EXT_422_pixels +#define GL_EXT_422_pixels 1 + +#define GL_422_EXT 0x80CC +#define GL_422_REV_EXT 0x80CD +#define GL_422_AVERAGE_EXT 0x80CE +#define GL_422_REV_AVERAGE_EXT 0x80CF + +#define GLEW_EXT_422_pixels GLEW_GET_VAR(__GLEW_EXT_422_pixels) + +#endif /* GL_EXT_422_pixels */ + +/* ---------------------------- GL_EXT_Cg_shader --------------------------- */ + +#ifndef GL_EXT_Cg_shader +#define GL_EXT_Cg_shader 1 + +#define GL_CG_VERTEX_SHADER_EXT 0x890E +#define GL_CG_FRAGMENT_SHADER_EXT 0x890F + +#define GLEW_EXT_Cg_shader GLEW_GET_VAR(__GLEW_EXT_Cg_shader) + +#endif /* GL_EXT_Cg_shader */ + +/* ------------------------------ GL_EXT_abgr ------------------------------ */ + +#ifndef GL_EXT_abgr +#define GL_EXT_abgr 1 + +#define GL_ABGR_EXT 0x8000 + +#define GLEW_EXT_abgr GLEW_GET_VAR(__GLEW_EXT_abgr) + +#endif /* GL_EXT_abgr */ + +/* ------------------------------ GL_EXT_bgra ------------------------------ */ + +#ifndef GL_EXT_bgra +#define GL_EXT_bgra 1 + +#define GL_BGR_EXT 0x80E0 +#define GL_BGRA_EXT 0x80E1 + +#define GLEW_EXT_bgra GLEW_GET_VAR(__GLEW_EXT_bgra) + +#endif /* GL_EXT_bgra */ + +/* ------------------------ GL_EXT_bindable_uniform ------------------------ */ + +#ifndef GL_EXT_bindable_uniform +#define GL_EXT_bindable_uniform 1 + +#define GL_MAX_VERTEX_BINDABLE_UNIFORMS_EXT 0x8DE2 +#define GL_MAX_FRAGMENT_BINDABLE_UNIFORMS_EXT 0x8DE3 +#define GL_MAX_GEOMETRY_BINDABLE_UNIFORMS_EXT 0x8DE4 +#define GL_MAX_BINDABLE_UNIFORM_SIZE_EXT 0x8DED +#define GL_UNIFORM_BUFFER_EXT 0x8DEE +#define GL_UNIFORM_BUFFER_BINDING_EXT 0x8DEF + +typedef GLint (GLAPIENTRY * PFNGLGETUNIFORMBUFFERSIZEEXTPROC) (GLuint program, GLint location); +typedef GLintptr (GLAPIENTRY * PFNGLGETUNIFORMOFFSETEXTPROC) (GLuint program, GLint location); +typedef void (GLAPIENTRY * PFNGLUNIFORMBUFFEREXTPROC) (GLuint program, GLint location, GLuint buffer); + +#define glGetUniformBufferSizeEXT GLEW_GET_FUN(__glewGetUniformBufferSizeEXT) +#define glGetUniformOffsetEXT GLEW_GET_FUN(__glewGetUniformOffsetEXT) +#define glUniformBufferEXT GLEW_GET_FUN(__glewUniformBufferEXT) + +#define GLEW_EXT_bindable_uniform GLEW_GET_VAR(__GLEW_EXT_bindable_uniform) + +#endif /* GL_EXT_bindable_uniform */ + +/* --------------------------- GL_EXT_blend_color -------------------------- */ + +#ifndef GL_EXT_blend_color +#define GL_EXT_blend_color 1 + +#define GL_CONSTANT_COLOR_EXT 0x8001 +#define GL_ONE_MINUS_CONSTANT_COLOR_EXT 0x8002 +#define GL_CONSTANT_ALPHA_EXT 0x8003 +#define GL_ONE_MINUS_CONSTANT_ALPHA_EXT 0x8004 +#define GL_BLEND_COLOR_EXT 0x8005 + +typedef void (GLAPIENTRY * PFNGLBLENDCOLOREXTPROC) (GLclampf red, GLclampf green, GLclampf blue, GLclampf alpha); + +#define glBlendColorEXT GLEW_GET_FUN(__glewBlendColorEXT) + +#define GLEW_EXT_blend_color GLEW_GET_VAR(__GLEW_EXT_blend_color) + +#endif /* GL_EXT_blend_color */ + +/* --------------------- GL_EXT_blend_equation_separate -------------------- */ + +#ifndef GL_EXT_blend_equation_separate +#define GL_EXT_blend_equation_separate 1 + +#define GL_BLEND_EQUATION_RGB_EXT 0x8009 +#define GL_BLEND_EQUATION_ALPHA_EXT 0x883D + +typedef void (GLAPIENTRY * PFNGLBLENDEQUATIONSEPARATEEXTPROC) (GLenum modeRGB, GLenum modeAlpha); + +#define glBlendEquationSeparateEXT GLEW_GET_FUN(__glewBlendEquationSeparateEXT) + +#define GLEW_EXT_blend_equation_separate GLEW_GET_VAR(__GLEW_EXT_blend_equation_separate) + +#endif /* GL_EXT_blend_equation_separate */ + +/* ----------------------- GL_EXT_blend_func_separate ---------------------- */ + +#ifndef GL_EXT_blend_func_separate +#define GL_EXT_blend_func_separate 1 + +#define GL_BLEND_DST_RGB_EXT 0x80C8 +#define GL_BLEND_SRC_RGB_EXT 0x80C9 +#define GL_BLEND_DST_ALPHA_EXT 0x80CA +#define GL_BLEND_SRC_ALPHA_EXT 0x80CB + +typedef void (GLAPIENTRY * PFNGLBLENDFUNCSEPARATEEXTPROC) (GLenum sfactorRGB, GLenum dfactorRGB, GLenum sfactorAlpha, GLenum dfactorAlpha); + +#define glBlendFuncSeparateEXT GLEW_GET_FUN(__glewBlendFuncSeparateEXT) + +#define GLEW_EXT_blend_func_separate GLEW_GET_VAR(__GLEW_EXT_blend_func_separate) + +#endif /* GL_EXT_blend_func_separate */ + +/* ------------------------- GL_EXT_blend_logic_op ------------------------- */ + +#ifndef GL_EXT_blend_logic_op +#define GL_EXT_blend_logic_op 1 + +#define GLEW_EXT_blend_logic_op GLEW_GET_VAR(__GLEW_EXT_blend_logic_op) + +#endif /* GL_EXT_blend_logic_op */ + +/* -------------------------- GL_EXT_blend_minmax -------------------------- */ + +#ifndef GL_EXT_blend_minmax +#define GL_EXT_blend_minmax 1 + +#define GL_FUNC_ADD_EXT 0x8006 +#define GL_MIN_EXT 0x8007 +#define GL_MAX_EXT 0x8008 +#define GL_BLEND_EQUATION_EXT 0x8009 + +typedef void (GLAPIENTRY * PFNGLBLENDEQUATIONEXTPROC) (GLenum mode); + +#define glBlendEquationEXT GLEW_GET_FUN(__glewBlendEquationEXT) + +#define GLEW_EXT_blend_minmax GLEW_GET_VAR(__GLEW_EXT_blend_minmax) + +#endif /* GL_EXT_blend_minmax */ + +/* ------------------------- GL_EXT_blend_subtract ------------------------- */ + +#ifndef GL_EXT_blend_subtract +#define GL_EXT_blend_subtract 1 + +#define GL_FUNC_SUBTRACT_EXT 0x800A +#define GL_FUNC_REVERSE_SUBTRACT_EXT 0x800B + +#define GLEW_EXT_blend_subtract GLEW_GET_VAR(__GLEW_EXT_blend_subtract) + +#endif /* GL_EXT_blend_subtract */ + +/* ------------------------ GL_EXT_clip_volume_hint ------------------------ */ + +#ifndef GL_EXT_clip_volume_hint +#define GL_EXT_clip_volume_hint 1 + +#define GL_CLIP_VOLUME_CLIPPING_HINT_EXT 0x80F0 + +#define GLEW_EXT_clip_volume_hint GLEW_GET_VAR(__GLEW_EXT_clip_volume_hint) + +#endif /* GL_EXT_clip_volume_hint */ + +/* ------------------------------ GL_EXT_cmyka ----------------------------- */ + +#ifndef GL_EXT_cmyka +#define GL_EXT_cmyka 1 + +#define GL_CMYK_EXT 0x800C +#define GL_CMYKA_EXT 0x800D +#define GL_PACK_CMYK_HINT_EXT 0x800E +#define GL_UNPACK_CMYK_HINT_EXT 0x800F + +#define GLEW_EXT_cmyka GLEW_GET_VAR(__GLEW_EXT_cmyka) + +#endif /* GL_EXT_cmyka */ + +/* ------------------------- GL_EXT_color_subtable ------------------------- */ + +#ifndef GL_EXT_color_subtable +#define GL_EXT_color_subtable 1 + +typedef void (GLAPIENTRY * PFNGLCOLORSUBTABLEEXTPROC) (GLenum target, GLsizei start, GLsizei count, GLenum format, GLenum type, const void* data); +typedef void (GLAPIENTRY * PFNGLCOPYCOLORSUBTABLEEXTPROC) (GLenum target, GLsizei start, GLint x, GLint y, GLsizei width); + +#define glColorSubTableEXT GLEW_GET_FUN(__glewColorSubTableEXT) +#define glCopyColorSubTableEXT GLEW_GET_FUN(__glewCopyColorSubTableEXT) + +#define GLEW_EXT_color_subtable GLEW_GET_VAR(__GLEW_EXT_color_subtable) + +#endif /* GL_EXT_color_subtable */ + +/* ---------------------- GL_EXT_compiled_vertex_array --------------------- */ + +#ifndef GL_EXT_compiled_vertex_array +#define GL_EXT_compiled_vertex_array 1 + +#define GL_ARRAY_ELEMENT_LOCK_FIRST_EXT 0x81A8 +#define GL_ARRAY_ELEMENT_LOCK_COUNT_EXT 0x81A9 + +typedef void (GLAPIENTRY * PFNGLLOCKARRAYSEXTPROC) (GLint first, GLsizei count); +typedef void (GLAPIENTRY * PFNGLUNLOCKARRAYSEXTPROC) (void); + +#define glLockArraysEXT GLEW_GET_FUN(__glewLockArraysEXT) +#define glUnlockArraysEXT GLEW_GET_FUN(__glewUnlockArraysEXT) + +#define GLEW_EXT_compiled_vertex_array GLEW_GET_VAR(__GLEW_EXT_compiled_vertex_array) + +#endif /* GL_EXT_compiled_vertex_array */ + +/* --------------------------- GL_EXT_convolution -------------------------- */ + +#ifndef GL_EXT_convolution +#define GL_EXT_convolution 1 + +#define GL_CONVOLUTION_1D_EXT 0x8010 +#define GL_CONVOLUTION_2D_EXT 0x8011 +#define GL_SEPARABLE_2D_EXT 0x8012 +#define GL_CONVOLUTION_BORDER_MODE_EXT 0x8013 +#define GL_CONVOLUTION_FILTER_SCALE_EXT 0x8014 +#define GL_CONVOLUTION_FILTER_BIAS_EXT 0x8015 +#define GL_REDUCE_EXT 0x8016 +#define GL_CONVOLUTION_FORMAT_EXT 0x8017 +#define GL_CONVOLUTION_WIDTH_EXT 0x8018 +#define GL_CONVOLUTION_HEIGHT_EXT 0x8019 +#define GL_MAX_CONVOLUTION_WIDTH_EXT 0x801A +#define GL_MAX_CONVOLUTION_HEIGHT_EXT 0x801B +#define GL_POST_CONVOLUTION_RED_SCALE_EXT 0x801C +#define GL_POST_CONVOLUTION_GREEN_SCALE_EXT 0x801D +#define GL_POST_CONVOLUTION_BLUE_SCALE_EXT 0x801E +#define GL_POST_CONVOLUTION_ALPHA_SCALE_EXT 0x801F +#define GL_POST_CONVOLUTION_RED_BIAS_EXT 0x8020 +#define GL_POST_CONVOLUTION_GREEN_BIAS_EXT 0x8021 +#define GL_POST_CONVOLUTION_BLUE_BIAS_EXT 0x8022 +#define GL_POST_CONVOLUTION_ALPHA_BIAS_EXT 0x8023 + +typedef void (GLAPIENTRY * PFNGLCONVOLUTIONFILTER1DEXTPROC) (GLenum target, GLenum internalformat, GLsizei width, GLenum format, GLenum type, const void* image); +typedef void (GLAPIENTRY * PFNGLCONVOLUTIONFILTER2DEXTPROC) (GLenum target, GLenum internalformat, GLsizei width, GLsizei height, GLenum format, GLenum type, const void* image); +typedef void (GLAPIENTRY * PFNGLCONVOLUTIONPARAMETERFEXTPROC) (GLenum target, GLenum pname, GLfloat param); +typedef void (GLAPIENTRY * PFNGLCONVOLUTIONPARAMETERFVEXTPROC) (GLenum target, GLenum pname, const GLfloat* params); +typedef void (GLAPIENTRY * PFNGLCONVOLUTIONPARAMETERIEXTPROC) (GLenum target, GLenum pname, GLint param); +typedef void (GLAPIENTRY * PFNGLCONVOLUTIONPARAMETERIVEXTPROC) (GLenum target, GLenum pname, const GLint* params); +typedef void (GLAPIENTRY * PFNGLCOPYCONVOLUTIONFILTER1DEXTPROC) (GLenum target, GLenum internalformat, GLint x, GLint y, GLsizei width); +typedef void (GLAPIENTRY * PFNGLCOPYCONVOLUTIONFILTER2DEXTPROC) (GLenum target, GLenum internalformat, GLint x, GLint y, GLsizei width, GLsizei height); +typedef void (GLAPIENTRY * PFNGLGETCONVOLUTIONFILTEREXTPROC) (GLenum target, GLenum format, GLenum type, void* image); +typedef void (GLAPIENTRY * PFNGLGETCONVOLUTIONPARAMETERFVEXTPROC) (GLenum target, GLenum pname, GLfloat* params); +typedef void (GLAPIENTRY * PFNGLGETCONVOLUTIONPARAMETERIVEXTPROC) (GLenum target, GLenum pname, GLint* params); +typedef void (GLAPIENTRY * PFNGLGETSEPARABLEFILTEREXTPROC) (GLenum target, GLenum format, GLenum type, void* row, void* column, void* span); +typedef void (GLAPIENTRY * PFNGLSEPARABLEFILTER2DEXTPROC) (GLenum target, GLenum internalformat, GLsizei width, GLsizei height, GLenum format, GLenum type, const void* row, const void* column); + +#define glConvolutionFilter1DEXT GLEW_GET_FUN(__glewConvolutionFilter1DEXT) +#define glConvolutionFilter2DEXT GLEW_GET_FUN(__glewConvolutionFilter2DEXT) +#define glConvolutionParameterfEXT GLEW_GET_FUN(__glewConvolutionParameterfEXT) +#define glConvolutionParameterfvEXT GLEW_GET_FUN(__glewConvolutionParameterfvEXT) +#define glConvolutionParameteriEXT GLEW_GET_FUN(__glewConvolutionParameteriEXT) +#define glConvolutionParameterivEXT GLEW_GET_FUN(__glewConvolutionParameterivEXT) +#define glCopyConvolutionFilter1DEXT GLEW_GET_FUN(__glewCopyConvolutionFilter1DEXT) +#define glCopyConvolutionFilter2DEXT GLEW_GET_FUN(__glewCopyConvolutionFilter2DEXT) +#define glGetConvolutionFilterEXT GLEW_GET_FUN(__glewGetConvolutionFilterEXT) +#define glGetConvolutionParameterfvEXT GLEW_GET_FUN(__glewGetConvolutionParameterfvEXT) +#define glGetConvolutionParameterivEXT GLEW_GET_FUN(__glewGetConvolutionParameterivEXT) +#define glGetSeparableFilterEXT GLEW_GET_FUN(__glewGetSeparableFilterEXT) +#define glSeparableFilter2DEXT GLEW_GET_FUN(__glewSeparableFilter2DEXT) + +#define GLEW_EXT_convolution GLEW_GET_VAR(__GLEW_EXT_convolution) + +#endif /* GL_EXT_convolution */ + +/* ------------------------ GL_EXT_coordinate_frame ------------------------ */ + +#ifndef GL_EXT_coordinate_frame +#define GL_EXT_coordinate_frame 1 + +#define GL_TANGENT_ARRAY_EXT 0x8439 +#define GL_BINORMAL_ARRAY_EXT 0x843A +#define GL_CURRENT_TANGENT_EXT 0x843B +#define GL_CURRENT_BINORMAL_EXT 0x843C +#define GL_TANGENT_ARRAY_TYPE_EXT 0x843E +#define GL_TANGENT_ARRAY_STRIDE_EXT 0x843F +#define GL_BINORMAL_ARRAY_TYPE_EXT 0x8440 +#define GL_BINORMAL_ARRAY_STRIDE_EXT 0x8441 +#define GL_TANGENT_ARRAY_POINTER_EXT 0x8442 +#define GL_BINORMAL_ARRAY_POINTER_EXT 0x8443 +#define GL_MAP1_TANGENT_EXT 0x8444 +#define GL_MAP2_TANGENT_EXT 0x8445 +#define GL_MAP1_BINORMAL_EXT 0x8446 +#define GL_MAP2_BINORMAL_EXT 0x8447 + +typedef void (GLAPIENTRY * PFNGLBINORMALPOINTEREXTPROC) (GLenum type, GLsizei stride, void* pointer); +typedef void (GLAPIENTRY * PFNGLTANGENTPOINTEREXTPROC) (GLenum type, GLsizei stride, void* pointer); + +#define glBinormalPointerEXT GLEW_GET_FUN(__glewBinormalPointerEXT) +#define glTangentPointerEXT GLEW_GET_FUN(__glewTangentPointerEXT) + +#define GLEW_EXT_coordinate_frame GLEW_GET_VAR(__GLEW_EXT_coordinate_frame) + +#endif /* GL_EXT_coordinate_frame */ + +/* -------------------------- GL_EXT_copy_texture -------------------------- */ + +#ifndef GL_EXT_copy_texture +#define GL_EXT_copy_texture 1 + +typedef void (GLAPIENTRY * PFNGLCOPYTEXIMAGE1DEXTPROC) (GLenum target, GLint level, GLenum internalformat, GLint x, GLint y, GLsizei width, GLint border); +typedef void (GLAPIENTRY * PFNGLCOPYTEXIMAGE2DEXTPROC) (GLenum target, GLint level, GLenum internalformat, GLint x, GLint y, GLsizei width, GLsizei height, GLint border); +typedef void (GLAPIENTRY * PFNGLCOPYTEXSUBIMAGE1DEXTPROC) (GLenum target, GLint level, GLint xoffset, GLint x, GLint y, GLsizei width); +typedef void (GLAPIENTRY * PFNGLCOPYTEXSUBIMAGE2DEXTPROC) (GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint x, GLint y, GLsizei width, GLsizei height); +typedef void (GLAPIENTRY * PFNGLCOPYTEXSUBIMAGE3DEXTPROC) (GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLint x, GLint y, GLsizei width, GLsizei height); + +#define glCopyTexImage1DEXT GLEW_GET_FUN(__glewCopyTexImage1DEXT) +#define glCopyTexImage2DEXT GLEW_GET_FUN(__glewCopyTexImage2DEXT) +#define glCopyTexSubImage1DEXT GLEW_GET_FUN(__glewCopyTexSubImage1DEXT) +#define glCopyTexSubImage2DEXT GLEW_GET_FUN(__glewCopyTexSubImage2DEXT) +#define glCopyTexSubImage3DEXT GLEW_GET_FUN(__glewCopyTexSubImage3DEXT) + +#define GLEW_EXT_copy_texture GLEW_GET_VAR(__GLEW_EXT_copy_texture) + +#endif /* GL_EXT_copy_texture */ + +/* --------------------------- GL_EXT_cull_vertex -------------------------- */ + +#ifndef GL_EXT_cull_vertex +#define GL_EXT_cull_vertex 1 + +typedef void (GLAPIENTRY * PFNGLCULLPARAMETERDVEXTPROC) (GLenum pname, GLdouble* params); +typedef void (GLAPIENTRY * PFNGLCULLPARAMETERFVEXTPROC) (GLenum pname, GLfloat* params); + +#define glCullParameterdvEXT GLEW_GET_FUN(__glewCullParameterdvEXT) +#define glCullParameterfvEXT GLEW_GET_FUN(__glewCullParameterfvEXT) + +#define GLEW_EXT_cull_vertex GLEW_GET_VAR(__GLEW_EXT_cull_vertex) + +#endif /* GL_EXT_cull_vertex */ + +/* ------------------------ GL_EXT_depth_bounds_test ----------------------- */ + +#ifndef GL_EXT_depth_bounds_test +#define GL_EXT_depth_bounds_test 1 + +#define GL_DEPTH_BOUNDS_TEST_EXT 0x8890 +#define GL_DEPTH_BOUNDS_EXT 0x8891 + +typedef void (GLAPIENTRY * PFNGLDEPTHBOUNDSEXTPROC) (GLclampd zmin, GLclampd zmax); + +#define glDepthBoundsEXT GLEW_GET_FUN(__glewDepthBoundsEXT) + +#define GLEW_EXT_depth_bounds_test GLEW_GET_VAR(__GLEW_EXT_depth_bounds_test) + +#endif /* GL_EXT_depth_bounds_test */ + +/* ----------------------- GL_EXT_direct_state_access ---------------------- */ + +#ifndef GL_EXT_direct_state_access +#define GL_EXT_direct_state_access 1 + +#define GL_PROGRAM_MATRIX_EXT 0x8E2D +#define GL_TRANSPOSE_PROGRAM_MATRIX_EXT 0x8E2E +#define GL_PROGRAM_MATRIX_STACK_DEPTH_EXT 0x8E2F + +typedef void (GLAPIENTRY * PFNGLBINDMULTITEXTUREEXTPROC) (GLenum texunit, GLenum target, GLuint texture); +typedef GLenum (GLAPIENTRY * PFNGLCHECKNAMEDFRAMEBUFFERSTATUSEXTPROC) (GLuint framebuffer, GLenum target); +typedef void (GLAPIENTRY * PFNGLCLIENTATTRIBDEFAULTEXTPROC) (GLbitfield mask); +typedef void (GLAPIENTRY * PFNGLCOMPRESSEDMULTITEXIMAGE1DEXTPROC) (GLenum texunit, GLenum target, GLint level, GLenum internalformat, GLsizei width, GLint border, GLsizei imageSize, const void* data); +typedef void (GLAPIENTRY * PFNGLCOMPRESSEDMULTITEXIMAGE2DEXTPROC) (GLenum texunit, GLenum target, GLint level, GLenum internalformat, GLsizei width, GLsizei height, GLint border, GLsizei imageSize, const void* data); +typedef void (GLAPIENTRY * PFNGLCOMPRESSEDMULTITEXIMAGE3DEXTPROC) (GLenum texunit, GLenum target, GLint level, GLenum internalformat, GLsizei width, GLsizei height, GLsizei depth, GLint border, GLsizei imageSize, const void* data); +typedef void (GLAPIENTRY * PFNGLCOMPRESSEDMULTITEXSUBIMAGE1DEXTPROC) (GLenum texunit, GLenum target, GLint level, GLint xoffset, GLsizei width, GLenum format, GLsizei imageSize, const void* data); +typedef void (GLAPIENTRY * PFNGLCOMPRESSEDMULTITEXSUBIMAGE2DEXTPROC) (GLenum texunit, GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLsizei imageSize, const void* data); +typedef void (GLAPIENTRY * PFNGLCOMPRESSEDMULTITEXSUBIMAGE3DEXTPROC) (GLenum texunit, GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLsizei imageSize, const void* data); +typedef void (GLAPIENTRY * PFNGLCOMPRESSEDTEXTUREIMAGE1DEXTPROC) (GLuint texture, GLenum target, GLint level, GLenum internalformat, GLsizei width, GLint border, GLsizei imageSize, const void* data); +typedef void (GLAPIENTRY * PFNGLCOMPRESSEDTEXTUREIMAGE2DEXTPROC) (GLuint texture, GLenum target, GLint level, GLenum internalformat, GLsizei width, GLsizei height, GLint border, GLsizei imageSize, const void* data); +typedef void (GLAPIENTRY * PFNGLCOMPRESSEDTEXTUREIMAGE3DEXTPROC) (GLuint texture, GLenum target, GLint level, GLenum internalformat, GLsizei width, GLsizei height, GLsizei depth, GLint border, GLsizei imageSize, const void* data); +typedef void (GLAPIENTRY * PFNGLCOMPRESSEDTEXTURESUBIMAGE1DEXTPROC) (GLuint texture, GLenum target, GLint level, GLint xoffset, GLsizei width, GLenum format, GLsizei imageSize, const void* data); +typedef void (GLAPIENTRY * PFNGLCOMPRESSEDTEXTURESUBIMAGE2DEXTPROC) (GLuint texture, GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLsizei imageSize, const void* data); +typedef void (GLAPIENTRY * PFNGLCOMPRESSEDTEXTURESUBIMAGE3DEXTPROC) (GLuint texture, GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLsizei imageSize, const void* data); +typedef void (GLAPIENTRY * PFNGLCOPYMULTITEXIMAGE1DEXTPROC) (GLenum texunit, GLenum target, GLint level, GLenum internalformat, GLint x, GLint y, GLsizei width, GLint border); +typedef void (GLAPIENTRY * PFNGLCOPYMULTITEXIMAGE2DEXTPROC) (GLenum texunit, GLenum target, GLint level, GLenum internalformat, GLint x, GLint y, GLsizei width, GLsizei height, GLint border); +typedef void (GLAPIENTRY * PFNGLCOPYMULTITEXSUBIMAGE1DEXTPROC) (GLenum texunit, GLenum target, GLint level, GLint xoffset, GLint x, GLint y, GLsizei width); +typedef void (GLAPIENTRY * PFNGLCOPYMULTITEXSUBIMAGE2DEXTPROC) (GLenum texunit, GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint x, GLint y, GLsizei width, GLsizei height); +typedef void (GLAPIENTRY * PFNGLCOPYMULTITEXSUBIMAGE3DEXTPROC) (GLenum texunit, GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLint x, GLint y, GLsizei width, GLsizei height); +typedef void (GLAPIENTRY * PFNGLCOPYTEXTUREIMAGE1DEXTPROC) (GLuint texture, GLenum target, GLint level, GLenum internalformat, GLint x, GLint y, GLsizei width, GLint border); +typedef void (GLAPIENTRY * PFNGLCOPYTEXTUREIMAGE2DEXTPROC) (GLuint texture, GLenum target, GLint level, GLenum internalformat, GLint x, GLint y, GLsizei width, GLsizei height, GLint border); +typedef void (GLAPIENTRY * PFNGLCOPYTEXTURESUBIMAGE1DEXTPROC) (GLuint texture, GLenum target, GLint level, GLint xoffset, GLint x, GLint y, GLsizei width); +typedef void (GLAPIENTRY * PFNGLCOPYTEXTURESUBIMAGE2DEXTPROC) (GLuint texture, GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint x, GLint y, GLsizei width, GLsizei height); +typedef void (GLAPIENTRY * PFNGLCOPYTEXTURESUBIMAGE3DEXTPROC) (GLuint texture, GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLint x, GLint y, GLsizei width, GLsizei height); +typedef void (GLAPIENTRY * PFNGLDISABLECLIENTSTATEINDEXEDEXTPROC) (GLenum array, GLuint index); +typedef void (GLAPIENTRY * PFNGLENABLECLIENTSTATEINDEXEDEXTPROC) (GLenum array, GLuint index); +typedef void (GLAPIENTRY * PFNGLFRAMEBUFFERDRAWBUFFEREXTPROC) (GLuint framebuffer, GLenum mode); +typedef void (GLAPIENTRY * PFNGLFRAMEBUFFERDRAWBUFFERSEXTPROC) (GLuint framebuffer, GLsizei n, const GLenum* bufs); +typedef void (GLAPIENTRY * PFNGLFRAMEBUFFERREADBUFFEREXTPROC) (GLuint framebuffer, GLenum mode); +typedef void (GLAPIENTRY * PFNGLGENERATEMULTITEXMIPMAPEXTPROC) (GLenum texunit, GLenum target); +typedef void (GLAPIENTRY * PFNGLGENERATETEXTUREMIPMAPEXTPROC) (GLuint texture, GLenum target); +typedef void (GLAPIENTRY * PFNGLGETCOMPRESSEDMULTITEXIMAGEEXTPROC) (GLenum texunit, GLenum target, GLint level, void* img); +typedef void (GLAPIENTRY * PFNGLGETCOMPRESSEDTEXTUREIMAGEEXTPROC) (GLuint texture, GLenum target, GLint level, void* img); +typedef void (GLAPIENTRY * PFNGLGETDOUBLEINDEXEDVEXTPROC) (GLenum pname, GLuint index, GLdouble* params); +typedef void (GLAPIENTRY * PFNGLGETFLOATINDEXEDVEXTPROC) (GLenum pname, GLuint index, GLfloat* params); +typedef void (GLAPIENTRY * PFNGLGETFRAMEBUFFERPARAMETERIVEXTPROC) (GLuint framebuffer, GLenum pname, GLint* param); +typedef void (GLAPIENTRY * PFNGLGETMULTITEXENVFVEXTPROC) (GLenum texunit, GLenum target, GLenum pname, GLfloat* params); +typedef void (GLAPIENTRY * PFNGLGETMULTITEXENVIVEXTPROC) (GLenum texunit, GLenum target, GLenum pname, GLint* params); +typedef void (GLAPIENTRY * PFNGLGETMULTITEXGENDVEXTPROC) (GLenum texunit, GLenum coord, GLenum pname, GLdouble* params); +typedef void (GLAPIENTRY * PFNGLGETMULTITEXGENFVEXTPROC) (GLenum texunit, GLenum coord, GLenum pname, GLfloat* params); +typedef void (GLAPIENTRY * PFNGLGETMULTITEXGENIVEXTPROC) (GLenum texunit, GLenum coord, GLenum pname, GLint* params); +typedef void (GLAPIENTRY * PFNGLGETMULTITEXIMAGEEXTPROC) (GLenum texunit, GLenum target, GLint level, GLenum format, GLenum type, void* pixels); +typedef void (GLAPIENTRY * PFNGLGETMULTITEXLEVELPARAMETERFVEXTPROC) (GLenum texunit, GLenum target, GLint level, GLenum pname, GLfloat* params); +typedef void (GLAPIENTRY * PFNGLGETMULTITEXLEVELPARAMETERIVEXTPROC) (GLenum texunit, GLenum target, GLint level, GLenum pname, GLint* params); +typedef void (GLAPIENTRY * PFNGLGETMULTITEXPARAMETERIIVEXTPROC) (GLenum texunit, GLenum target, GLenum pname, GLint* params); +typedef void (GLAPIENTRY * PFNGLGETMULTITEXPARAMETERIUIVEXTPROC) (GLenum texunit, GLenum target, GLenum pname, GLuint* params); +typedef void (GLAPIENTRY * PFNGLGETMULTITEXPARAMETERFVEXTPROC) (GLenum texunit, GLenum target, GLenum pname, GLfloat* params); +typedef void (GLAPIENTRY * PFNGLGETMULTITEXPARAMETERIVEXTPROC) (GLenum texunit, GLenum target, GLenum pname, GLint* params); +typedef void (GLAPIENTRY * PFNGLGETNAMEDBUFFERPARAMETERIVEXTPROC) (GLuint buffer, GLenum pname, GLint* params); +typedef void (GLAPIENTRY * PFNGLGETNAMEDBUFFERPOINTERVEXTPROC) (GLuint buffer, GLenum pname, void** params); +typedef void (GLAPIENTRY * PFNGLGETNAMEDBUFFERSUBDATAEXTPROC) (GLuint buffer, GLintptr offset, GLsizeiptr size, void* data); +typedef void (GLAPIENTRY * PFNGLGETNAMEDFRAMEBUFFERATTACHMENTPARAMETERIVEXTPROC) (GLuint framebuffer, GLenum attachment, GLenum pname, GLint* params); +typedef void (GLAPIENTRY * PFNGLGETNAMEDPROGRAMLOCALPARAMETERIIVEXTPROC) (GLuint program, GLenum target, GLuint index, GLint* params); +typedef void (GLAPIENTRY * PFNGLGETNAMEDPROGRAMLOCALPARAMETERIUIVEXTPROC) (GLuint program, GLenum target, GLuint index, GLuint* params); +typedef void (GLAPIENTRY * PFNGLGETNAMEDPROGRAMLOCALPARAMETERDVEXTPROC) (GLuint program, GLenum target, GLuint index, GLdouble* params); +typedef void (GLAPIENTRY * PFNGLGETNAMEDPROGRAMLOCALPARAMETERFVEXTPROC) (GLuint program, GLenum target, GLuint index, GLfloat* params); +typedef void (GLAPIENTRY * PFNGLGETNAMEDPROGRAMSTRINGEXTPROC) (GLuint program, GLenum target, GLenum pname, void* string); +typedef void (GLAPIENTRY * PFNGLGETNAMEDPROGRAMIVEXTPROC) (GLuint program, GLenum target, GLenum pname, GLint* params); +typedef void (GLAPIENTRY * PFNGLGETNAMEDRENDERBUFFERPARAMETERIVEXTPROC) (GLuint renderbuffer, GLenum pname, GLint* params); +typedef void (GLAPIENTRY * PFNGLGETPOINTERINDEXEDVEXTPROC) (GLenum pname, GLuint index, GLvoid** params); +typedef void (GLAPIENTRY * PFNGLGETTEXTUREIMAGEEXTPROC) (GLuint texture, GLenum target, GLint level, GLenum format, GLenum type, void* pixels); +typedef void (GLAPIENTRY * PFNGLGETTEXTURELEVELPARAMETERFVEXTPROC) (GLuint texture, GLenum target, GLint level, GLenum pname, GLfloat* params); +typedef void (GLAPIENTRY * PFNGLGETTEXTURELEVELPARAMETERIVEXTPROC) (GLuint texture, GLenum target, GLint level, GLenum pname, GLint* params); +typedef void (GLAPIENTRY * PFNGLGETTEXTUREPARAMETERIIVEXTPROC) (GLuint texture, GLenum target, GLenum pname, GLint* params); +typedef void (GLAPIENTRY * PFNGLGETTEXTUREPARAMETERIUIVEXTPROC) (GLuint texture, GLenum target, GLenum pname, GLuint* params); +typedef void (GLAPIENTRY * PFNGLGETTEXTUREPARAMETERFVEXTPROC) (GLuint texture, GLenum target, GLenum pname, GLfloat* params); +typedef void (GLAPIENTRY * PFNGLGETTEXTUREPARAMETERIVEXTPROC) (GLuint texture, GLenum target, GLenum pname, GLint* params); +typedef GLvoid * (GLAPIENTRY * PFNGLMAPNAMEDBUFFEREXTPROC) (GLuint buffer, GLenum access); +typedef void (GLAPIENTRY * PFNGLMATRIXFRUSTUMEXTPROC) (GLenum matrixMode, GLdouble l, GLdouble r, GLdouble b, GLdouble t, GLdouble n, GLdouble f); +typedef void (GLAPIENTRY * PFNGLMATRIXLOADIDENTITYEXTPROC) (GLenum matrixMode); +typedef void (GLAPIENTRY * PFNGLMATRIXLOADTRANSPOSEDEXTPROC) (GLenum matrixMode, const GLdouble* m); +typedef void (GLAPIENTRY * PFNGLMATRIXLOADTRANSPOSEFEXTPROC) (GLenum matrixMode, const GLfloat* m); +typedef void (GLAPIENTRY * PFNGLMATRIXLOADDEXTPROC) (GLenum matrixMode, const GLdouble* m); +typedef void (GLAPIENTRY * PFNGLMATRIXLOADFEXTPROC) (GLenum matrixMode, const GLfloat* m); +typedef void (GLAPIENTRY * PFNGLMATRIXMULTTRANSPOSEDEXTPROC) (GLenum matrixMode, const GLdouble* m); +typedef void (GLAPIENTRY * PFNGLMATRIXMULTTRANSPOSEFEXTPROC) (GLenum matrixMode, const GLfloat* m); +typedef void (GLAPIENTRY * PFNGLMATRIXMULTDEXTPROC) (GLenum matrixMode, const GLdouble* m); +typedef void (GLAPIENTRY * PFNGLMATRIXMULTFEXTPROC) (GLenum matrixMode, const GLfloat* m); +typedef void (GLAPIENTRY * PFNGLMATRIXORTHOEXTPROC) (GLenum matrixMode, GLdouble l, GLdouble r, GLdouble b, GLdouble t, GLdouble n, GLdouble f); +typedef void (GLAPIENTRY * PFNGLMATRIXPOPEXTPROC) (GLenum matrixMode); +typedef void (GLAPIENTRY * PFNGLMATRIXPUSHEXTPROC) (GLenum matrixMode); +typedef void (GLAPIENTRY * PFNGLMATRIXROTATEDEXTPROC) (GLenum matrixMode, GLdouble angle, GLdouble x, GLdouble y, GLdouble z); +typedef void (GLAPIENTRY * PFNGLMATRIXROTATEFEXTPROC) (GLenum matrixMode, GLfloat angle, GLfloat x, GLfloat y, GLfloat z); +typedef void (GLAPIENTRY * PFNGLMATRIXSCALEDEXTPROC) (GLenum matrixMode, GLdouble x, GLdouble y, GLdouble z); +typedef void (GLAPIENTRY * PFNGLMATRIXSCALEFEXTPROC) (GLenum matrixMode, GLfloat x, GLfloat y, GLfloat z); +typedef void (GLAPIENTRY * PFNGLMATRIXTRANSLATEDEXTPROC) (GLenum matrixMode, GLdouble x, GLdouble y, GLdouble z); +typedef void (GLAPIENTRY * PFNGLMATRIXTRANSLATEFEXTPROC) (GLenum matrixMode, GLfloat x, GLfloat y, GLfloat z); +typedef void (GLAPIENTRY * PFNGLMULTITEXBUFFEREXTPROC) (GLenum texunit, GLenum target, GLenum internalformat, GLuint buffer); +typedef void (GLAPIENTRY * PFNGLMULTITEXCOORDPOINTEREXTPROC) (GLenum texunit, GLint size, GLenum type, GLsizei stride, const void* pointer); +typedef void (GLAPIENTRY * PFNGLMULTITEXENVFEXTPROC) (GLenum texunit, GLenum target, GLenum pname, GLfloat param); +typedef void (GLAPIENTRY * PFNGLMULTITEXENVFVEXTPROC) (GLenum texunit, GLenum target, GLenum pname, const GLfloat* params); +typedef void (GLAPIENTRY * PFNGLMULTITEXENVIEXTPROC) (GLenum texunit, GLenum target, GLenum pname, GLint param); +typedef void (GLAPIENTRY * PFNGLMULTITEXENVIVEXTPROC) (GLenum texunit, GLenum target, GLenum pname, const GLint* params); +typedef void (GLAPIENTRY * PFNGLMULTITEXGENDEXTPROC) (GLenum texunit, GLenum coord, GLenum pname, GLdouble param); +typedef void (GLAPIENTRY * PFNGLMULTITEXGENDVEXTPROC) (GLenum texunit, GLenum coord, GLenum pname, const GLdouble* params); +typedef void (GLAPIENTRY * PFNGLMULTITEXGENFEXTPROC) (GLenum texunit, GLenum coord, GLenum pname, GLfloat param); +typedef void (GLAPIENTRY * PFNGLMULTITEXGENFVEXTPROC) (GLenum texunit, GLenum coord, GLenum pname, const GLfloat* params); +typedef void (GLAPIENTRY * PFNGLMULTITEXGENIEXTPROC) (GLenum texunit, GLenum coord, GLenum pname, GLint param); +typedef void (GLAPIENTRY * PFNGLMULTITEXGENIVEXTPROC) (GLenum texunit, GLenum coord, GLenum pname, const GLint* params); +typedef void (GLAPIENTRY * PFNGLMULTITEXIMAGE1DEXTPROC) (GLenum texunit, GLenum target, GLint level, GLint internalformat, GLsizei width, GLint border, GLenum format, GLenum type, const void* pixels); +typedef void (GLAPIENTRY * PFNGLMULTITEXIMAGE2DEXTPROC) (GLenum texunit, GLenum target, GLint level, GLint internalformat, GLsizei width, GLsizei height, GLint border, GLenum format, GLenum type, const void* pixels); +typedef void (GLAPIENTRY * PFNGLMULTITEXIMAGE3DEXTPROC) (GLenum texunit, GLenum target, GLint level, GLint internalformat, GLsizei width, GLsizei height, GLsizei depth, GLint border, GLenum format, GLenum type, const void* pixels); +typedef void (GLAPIENTRY * PFNGLMULTITEXPARAMETERIIVEXTPROC) (GLenum texunit, GLenum target, GLenum pname, const GLint* params); +typedef void (GLAPIENTRY * PFNGLMULTITEXPARAMETERIUIVEXTPROC) (GLenum texunit, GLenum target, GLenum pname, const GLuint* params); +typedef void (GLAPIENTRY * PFNGLMULTITEXPARAMETERFEXTPROC) (GLenum texunit, GLenum target, GLenum pname, GLfloat param); +typedef void (GLAPIENTRY * PFNGLMULTITEXPARAMETERFVEXTPROC) (GLenum texunit, GLenum target, GLenum pname, const GLfloat* param); +typedef void (GLAPIENTRY * PFNGLMULTITEXPARAMETERIEXTPROC) (GLenum texunit, GLenum target, GLenum pname, GLint param); +typedef void (GLAPIENTRY * PFNGLMULTITEXPARAMETERIVEXTPROC) (GLenum texunit, GLenum target, GLenum pname, const GLint* param); +typedef void (GLAPIENTRY * PFNGLMULTITEXRENDERBUFFEREXTPROC) (GLenum texunit, GLenum target, GLuint renderbuffer); +typedef void (GLAPIENTRY * PFNGLMULTITEXSUBIMAGE1DEXTPROC) (GLenum texunit, GLenum target, GLint level, GLint xoffset, GLsizei width, GLenum format, GLenum type, const void* pixels); +typedef void (GLAPIENTRY * PFNGLMULTITEXSUBIMAGE2DEXTPROC) (GLenum texunit, GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLenum type, const void* pixels); +typedef void (GLAPIENTRY * PFNGLMULTITEXSUBIMAGE3DEXTPROC) (GLenum texunit, GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLenum type, const void* pixels); +typedef void (GLAPIENTRY * PFNGLNAMEDBUFFERDATAEXTPROC) (GLuint buffer, GLsizeiptr size, const void* data, GLenum usage); +typedef void (GLAPIENTRY * PFNGLNAMEDBUFFERSUBDATAEXTPROC) (GLuint buffer, GLintptr offset, GLsizeiptr size, const void* data); +typedef void (GLAPIENTRY * PFNGLNAMEDFRAMEBUFFERRENDERBUFFEREXTPROC) (GLuint framebuffer, GLenum attachment, GLenum renderbuffertarget, GLuint renderbuffer); +typedef void (GLAPIENTRY * PFNGLNAMEDFRAMEBUFFERTEXTURE1DEXTPROC) (GLuint framebuffer, GLenum attachment, GLenum textarget, GLuint texture, GLint level); +typedef void (GLAPIENTRY * PFNGLNAMEDFRAMEBUFFERTEXTURE2DEXTPROC) (GLuint framebuffer, GLenum attachment, GLenum textarget, GLuint texture, GLint level); +typedef void (GLAPIENTRY * PFNGLNAMEDFRAMEBUFFERTEXTURE3DEXTPROC) (GLuint framebuffer, GLenum attachment, GLenum textarget, GLuint texture, GLint level, GLint zoffset); +typedef void (GLAPIENTRY * PFNGLNAMEDFRAMEBUFFERTEXTUREEXTPROC) (GLuint framebuffer, GLenum attachment, GLuint texture, GLint level); +typedef void (GLAPIENTRY * PFNGLNAMEDFRAMEBUFFERTEXTUREFACEEXTPROC) (GLuint framebuffer, GLenum attachment, GLuint texture, GLint level, GLenum face); +typedef void (GLAPIENTRY * PFNGLNAMEDFRAMEBUFFERTEXTURELAYEREXTPROC) (GLuint framebuffer, GLenum attachment, GLuint texture, GLint level, GLint layer); +typedef void (GLAPIENTRY * PFNGLNAMEDPROGRAMLOCALPARAMETER4DEXTPROC) (GLuint program, GLenum target, GLuint index, GLdouble x, GLdouble y, GLdouble z, GLdouble w); +typedef void (GLAPIENTRY * PFNGLNAMEDPROGRAMLOCALPARAMETER4DVEXTPROC) (GLuint program, GLenum target, GLuint index, const GLdouble* params); +typedef void (GLAPIENTRY * PFNGLNAMEDPROGRAMLOCALPARAMETER4FEXTPROC) (GLuint program, GLenum target, GLuint index, GLfloat x, GLfloat y, GLfloat z, GLfloat w); +typedef void (GLAPIENTRY * PFNGLNAMEDPROGRAMLOCALPARAMETER4FVEXTPROC) (GLuint program, GLenum target, GLuint index, const GLfloat* params); +typedef void (GLAPIENTRY * PFNGLNAMEDPROGRAMLOCALPARAMETERI4IEXTPROC) (GLuint program, GLenum target, GLuint index, GLint x, GLint y, GLint z, GLint w); +typedef void (GLAPIENTRY * PFNGLNAMEDPROGRAMLOCALPARAMETERI4IVEXTPROC) (GLuint program, GLenum target, GLuint index, const GLint* params); +typedef void (GLAPIENTRY * PFNGLNAMEDPROGRAMLOCALPARAMETERI4UIEXTPROC) (GLuint program, GLenum target, GLuint index, GLuint x, GLuint y, GLuint z, GLuint w); +typedef void (GLAPIENTRY * PFNGLNAMEDPROGRAMLOCALPARAMETERI4UIVEXTPROC) (GLuint program, GLenum target, GLuint index, const GLuint* params); +typedef void (GLAPIENTRY * PFNGLNAMEDPROGRAMLOCALPARAMETERS4FVEXTPROC) (GLuint program, GLenum target, GLuint index, GLsizei count, const GLfloat* params); +typedef void (GLAPIENTRY * PFNGLNAMEDPROGRAMLOCALPARAMETERSI4IVEXTPROC) (GLuint program, GLenum target, GLuint index, GLsizei count, const GLint* params); +typedef void (GLAPIENTRY * PFNGLNAMEDPROGRAMLOCALPARAMETERSI4UIVEXTPROC) (GLuint program, GLenum target, GLuint index, GLsizei count, const GLuint* params); +typedef void (GLAPIENTRY * PFNGLNAMEDPROGRAMSTRINGEXTPROC) (GLuint program, GLenum target, GLenum format, GLsizei len, const void* string); +typedef void (GLAPIENTRY * PFNGLNAMEDRENDERBUFFERSTORAGEEXTPROC) (GLuint renderbuffer, GLenum internalformat, GLsizei width, GLsizei height); +typedef void (GLAPIENTRY * PFNGLNAMEDRENDERBUFFERSTORAGEMULTISAMPLECOVERAGEEXTPROC) (GLuint renderbuffer, GLsizei coverageSamples, GLsizei colorSamples, GLenum internalformat, GLsizei width, GLsizei height); +typedef void (GLAPIENTRY * PFNGLNAMEDRENDERBUFFERSTORAGEMULTISAMPLEEXTPROC) (GLuint renderbuffer, GLsizei samples, GLenum internalformat, GLsizei width, GLsizei height); +typedef void (GLAPIENTRY * PFNGLPROGRAMUNIFORM1FEXTPROC) (GLuint program, GLint location, GLfloat v0); +typedef void (GLAPIENTRY * PFNGLPROGRAMUNIFORM1FVEXTPROC) (GLuint program, GLint location, GLsizei count, const GLfloat* value); +typedef void (GLAPIENTRY * PFNGLPROGRAMUNIFORM1IEXTPROC) (GLuint program, GLint location, GLint v0); +typedef void (GLAPIENTRY * PFNGLPROGRAMUNIFORM1IVEXTPROC) (GLuint program, GLint location, GLsizei count, const GLint* value); +typedef void (GLAPIENTRY * PFNGLPROGRAMUNIFORM1UIEXTPROC) (GLuint program, GLint location, GLuint v0); +typedef void (GLAPIENTRY * PFNGLPROGRAMUNIFORM1UIVEXTPROC) (GLuint program, GLint location, GLsizei count, const GLuint* value); +typedef void (GLAPIENTRY * PFNGLPROGRAMUNIFORM2FEXTPROC) (GLuint program, GLint location, GLfloat v0, GLfloat v1); +typedef void (GLAPIENTRY * PFNGLPROGRAMUNIFORM2FVEXTPROC) (GLuint program, GLint location, GLsizei count, const GLfloat* value); +typedef void (GLAPIENTRY * PFNGLPROGRAMUNIFORM2IEXTPROC) (GLuint program, GLint location, GLint v0, GLint v1); +typedef void (GLAPIENTRY * PFNGLPROGRAMUNIFORM2IVEXTPROC) (GLuint program, GLint location, GLsizei count, const GLint* value); +typedef void (GLAPIENTRY * PFNGLPROGRAMUNIFORM2UIEXTPROC) (GLuint program, GLint location, GLuint v0, GLuint v1); +typedef void (GLAPIENTRY * PFNGLPROGRAMUNIFORM2UIVEXTPROC) (GLuint program, GLint location, GLsizei count, const GLuint* value); +typedef void (GLAPIENTRY * PFNGLPROGRAMUNIFORM3FEXTPROC) (GLuint program, GLint location, GLfloat v0, GLfloat v1, GLfloat v2); +typedef void (GLAPIENTRY * PFNGLPROGRAMUNIFORM3FVEXTPROC) (GLuint program, GLint location, GLsizei count, const GLfloat* value); +typedef void (GLAPIENTRY * PFNGLPROGRAMUNIFORM3IEXTPROC) (GLuint program, GLint location, GLint v0, GLint v1, GLint v2); +typedef void (GLAPIENTRY * PFNGLPROGRAMUNIFORM3IVEXTPROC) (GLuint program, GLint location, GLsizei count, const GLint* value); +typedef void (GLAPIENTRY * PFNGLPROGRAMUNIFORM3UIEXTPROC) (GLuint program, GLint location, GLuint v0, GLuint v1, GLuint v2); +typedef void (GLAPIENTRY * PFNGLPROGRAMUNIFORM3UIVEXTPROC) (GLuint program, GLint location, GLsizei count, const GLuint* value); +typedef void (GLAPIENTRY * PFNGLPROGRAMUNIFORM4FEXTPROC) (GLuint program, GLint location, GLfloat v0, GLfloat v1, GLfloat v2, GLfloat v3); +typedef void (GLAPIENTRY * PFNGLPROGRAMUNIFORM4FVEXTPROC) (GLuint program, GLint location, GLsizei count, const GLfloat* value); +typedef void (GLAPIENTRY * PFNGLPROGRAMUNIFORM4IEXTPROC) (GLuint program, GLint location, GLint v0, GLint v1, GLint v2, GLint v3); +typedef void (GLAPIENTRY * PFNGLPROGRAMUNIFORM4IVEXTPROC) (GLuint program, GLint location, GLsizei count, const GLint* value); +typedef void (GLAPIENTRY * PFNGLPROGRAMUNIFORM4UIEXTPROC) (GLuint program, GLint location, GLuint v0, GLuint v1, GLuint v2, GLuint v3); +typedef void (GLAPIENTRY * PFNGLPROGRAMUNIFORM4UIVEXTPROC) (GLuint program, GLint location, GLsizei count, const GLuint* value); +typedef void (GLAPIENTRY * PFNGLPROGRAMUNIFORMMATRIX2FVEXTPROC) (GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLfloat* value); +typedef void (GLAPIENTRY * PFNGLPROGRAMUNIFORMMATRIX2X3FVEXTPROC) (GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLfloat* value); +typedef void (GLAPIENTRY * PFNGLPROGRAMUNIFORMMATRIX2X4FVEXTPROC) (GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLfloat* value); +typedef void (GLAPIENTRY * PFNGLPROGRAMUNIFORMMATRIX3FVEXTPROC) (GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLfloat* value); +typedef void (GLAPIENTRY * PFNGLPROGRAMUNIFORMMATRIX3X2FVEXTPROC) (GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLfloat* value); +typedef void (GLAPIENTRY * PFNGLPROGRAMUNIFORMMATRIX3X4FVEXTPROC) (GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLfloat* value); +typedef void (GLAPIENTRY * PFNGLPROGRAMUNIFORMMATRIX4FVEXTPROC) (GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLfloat* value); +typedef void (GLAPIENTRY * PFNGLPROGRAMUNIFORMMATRIX4X2FVEXTPROC) (GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLfloat* value); +typedef void (GLAPIENTRY * PFNGLPROGRAMUNIFORMMATRIX4X3FVEXTPROC) (GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLfloat* value); +typedef void (GLAPIENTRY * PFNGLPUSHCLIENTATTRIBDEFAULTEXTPROC) (GLbitfield mask); +typedef void (GLAPIENTRY * PFNGLTEXTUREBUFFEREXTPROC) (GLuint texture, GLenum target, GLenum internalformat, GLuint buffer); +typedef void (GLAPIENTRY * PFNGLTEXTUREIMAGE1DEXTPROC) (GLuint texture, GLenum target, GLint level, GLint internalformat, GLsizei width, GLint border, GLenum format, GLenum type, const void* pixels); +typedef void (GLAPIENTRY * PFNGLTEXTUREIMAGE2DEXTPROC) (GLuint texture, GLenum target, GLint level, GLint internalformat, GLsizei width, GLsizei height, GLint border, GLenum format, GLenum type, const void* pixels); +typedef void (GLAPIENTRY * PFNGLTEXTUREIMAGE3DEXTPROC) (GLuint texture, GLenum target, GLint level, GLint internalformat, GLsizei width, GLsizei height, GLsizei depth, GLint border, GLenum format, GLenum type, const void* pixels); +typedef void (GLAPIENTRY * PFNGLTEXTUREPARAMETERIIVEXTPROC) (GLuint texture, GLenum target, GLenum pname, const GLint* params); +typedef void (GLAPIENTRY * PFNGLTEXTUREPARAMETERIUIVEXTPROC) (GLuint texture, GLenum target, GLenum pname, const GLuint* params); +typedef void (GLAPIENTRY * PFNGLTEXTUREPARAMETERFEXTPROC) (GLuint texture, GLenum target, GLenum pname, GLfloat param); +typedef void (GLAPIENTRY * PFNGLTEXTUREPARAMETERFVEXTPROC) (GLuint texture, GLenum target, GLenum pname, const GLfloat* param); +typedef void (GLAPIENTRY * PFNGLTEXTUREPARAMETERIEXTPROC) (GLuint texture, GLenum target, GLenum pname, GLint param); +typedef void (GLAPIENTRY * PFNGLTEXTUREPARAMETERIVEXTPROC) (GLuint texture, GLenum target, GLenum pname, const GLint* param); +typedef void (GLAPIENTRY * PFNGLTEXTURERENDERBUFFEREXTPROC) (GLuint texture, GLenum target, GLuint renderbuffer); +typedef void (GLAPIENTRY * PFNGLTEXTURESUBIMAGE1DEXTPROC) (GLuint texture, GLenum target, GLint level, GLint xoffset, GLsizei width, GLenum format, GLenum type, const void* pixels); +typedef void (GLAPIENTRY * PFNGLTEXTURESUBIMAGE2DEXTPROC) (GLuint texture, GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLenum type, const void* pixels); +typedef void (GLAPIENTRY * PFNGLTEXTURESUBIMAGE3DEXTPROC) (GLuint texture, GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLenum type, const void* pixels); +typedef GLboolean (GLAPIENTRY * PFNGLUNMAPNAMEDBUFFEREXTPROC) (GLuint buffer); + +#define glBindMultiTextureEXT GLEW_GET_FUN(__glewBindMultiTextureEXT) +#define glCheckNamedFramebufferStatusEXT GLEW_GET_FUN(__glewCheckNamedFramebufferStatusEXT) +#define glClientAttribDefaultEXT GLEW_GET_FUN(__glewClientAttribDefaultEXT) +#define glCompressedMultiTexImage1DEXT GLEW_GET_FUN(__glewCompressedMultiTexImage1DEXT) +#define glCompressedMultiTexImage2DEXT GLEW_GET_FUN(__glewCompressedMultiTexImage2DEXT) +#define glCompressedMultiTexImage3DEXT GLEW_GET_FUN(__glewCompressedMultiTexImage3DEXT) +#define glCompressedMultiTexSubImage1DEXT GLEW_GET_FUN(__glewCompressedMultiTexSubImage1DEXT) +#define glCompressedMultiTexSubImage2DEXT GLEW_GET_FUN(__glewCompressedMultiTexSubImage2DEXT) +#define glCompressedMultiTexSubImage3DEXT GLEW_GET_FUN(__glewCompressedMultiTexSubImage3DEXT) +#define glCompressedTextureImage1DEXT GLEW_GET_FUN(__glewCompressedTextureImage1DEXT) +#define glCompressedTextureImage2DEXT GLEW_GET_FUN(__glewCompressedTextureImage2DEXT) +#define glCompressedTextureImage3DEXT GLEW_GET_FUN(__glewCompressedTextureImage3DEXT) +#define glCompressedTextureSubImage1DEXT GLEW_GET_FUN(__glewCompressedTextureSubImage1DEXT) +#define glCompressedTextureSubImage2DEXT GLEW_GET_FUN(__glewCompressedTextureSubImage2DEXT) +#define glCompressedTextureSubImage3DEXT GLEW_GET_FUN(__glewCompressedTextureSubImage3DEXT) +#define glCopyMultiTexImage1DEXT GLEW_GET_FUN(__glewCopyMultiTexImage1DEXT) +#define glCopyMultiTexImage2DEXT GLEW_GET_FUN(__glewCopyMultiTexImage2DEXT) +#define glCopyMultiTexSubImage1DEXT GLEW_GET_FUN(__glewCopyMultiTexSubImage1DEXT) +#define glCopyMultiTexSubImage2DEXT GLEW_GET_FUN(__glewCopyMultiTexSubImage2DEXT) +#define glCopyMultiTexSubImage3DEXT GLEW_GET_FUN(__glewCopyMultiTexSubImage3DEXT) +#define glCopyTextureImage1DEXT GLEW_GET_FUN(__glewCopyTextureImage1DEXT) +#define glCopyTextureImage2DEXT GLEW_GET_FUN(__glewCopyTextureImage2DEXT) +#define glCopyTextureSubImage1DEXT GLEW_GET_FUN(__glewCopyTextureSubImage1DEXT) +#define glCopyTextureSubImage2DEXT GLEW_GET_FUN(__glewCopyTextureSubImage2DEXT) +#define glCopyTextureSubImage3DEXT GLEW_GET_FUN(__glewCopyTextureSubImage3DEXT) +#define glDisableClientStateIndexedEXT GLEW_GET_FUN(__glewDisableClientStateIndexedEXT) +#define glEnableClientStateIndexedEXT GLEW_GET_FUN(__glewEnableClientStateIndexedEXT) +#define glFramebufferDrawBufferEXT GLEW_GET_FUN(__glewFramebufferDrawBufferEXT) +#define glFramebufferDrawBuffersEXT GLEW_GET_FUN(__glewFramebufferDrawBuffersEXT) +#define glFramebufferReadBufferEXT GLEW_GET_FUN(__glewFramebufferReadBufferEXT) +#define glGenerateMultiTexMipmapEXT GLEW_GET_FUN(__glewGenerateMultiTexMipmapEXT) +#define glGenerateTextureMipmapEXT GLEW_GET_FUN(__glewGenerateTextureMipmapEXT) +#define glGetCompressedMultiTexImageEXT GLEW_GET_FUN(__glewGetCompressedMultiTexImageEXT) +#define glGetCompressedTextureImageEXT GLEW_GET_FUN(__glewGetCompressedTextureImageEXT) +#define glGetDoubleIndexedvEXT GLEW_GET_FUN(__glewGetDoubleIndexedvEXT) +#define glGetFloatIndexedvEXT GLEW_GET_FUN(__glewGetFloatIndexedvEXT) +#define glGetFramebufferParameterivEXT GLEW_GET_FUN(__glewGetFramebufferParameterivEXT) +#define glGetMultiTexEnvfvEXT GLEW_GET_FUN(__glewGetMultiTexEnvfvEXT) +#define glGetMultiTexEnvivEXT GLEW_GET_FUN(__glewGetMultiTexEnvivEXT) +#define glGetMultiTexGendvEXT GLEW_GET_FUN(__glewGetMultiTexGendvEXT) +#define glGetMultiTexGenfvEXT GLEW_GET_FUN(__glewGetMultiTexGenfvEXT) +#define glGetMultiTexGenivEXT GLEW_GET_FUN(__glewGetMultiTexGenivEXT) +#define glGetMultiTexImageEXT GLEW_GET_FUN(__glewGetMultiTexImageEXT) +#define glGetMultiTexLevelParameterfvEXT GLEW_GET_FUN(__glewGetMultiTexLevelParameterfvEXT) +#define glGetMultiTexLevelParameterivEXT GLEW_GET_FUN(__glewGetMultiTexLevelParameterivEXT) +#define glGetMultiTexParameterIivEXT GLEW_GET_FUN(__glewGetMultiTexParameterIivEXT) +#define glGetMultiTexParameterIuivEXT GLEW_GET_FUN(__glewGetMultiTexParameterIuivEXT) +#define glGetMultiTexParameterfvEXT GLEW_GET_FUN(__glewGetMultiTexParameterfvEXT) +#define glGetMultiTexParameterivEXT GLEW_GET_FUN(__glewGetMultiTexParameterivEXT) +#define glGetNamedBufferParameterivEXT GLEW_GET_FUN(__glewGetNamedBufferParameterivEXT) +#define glGetNamedBufferPointervEXT GLEW_GET_FUN(__glewGetNamedBufferPointervEXT) +#define glGetNamedBufferSubDataEXT GLEW_GET_FUN(__glewGetNamedBufferSubDataEXT) +#define glGetNamedFramebufferAttachmentParameterivEXT GLEW_GET_FUN(__glewGetNamedFramebufferAttachmentParameterivEXT) +#define glGetNamedProgramLocalParameterIivEXT GLEW_GET_FUN(__glewGetNamedProgramLocalParameterIivEXT) +#define glGetNamedProgramLocalParameterIuivEXT GLEW_GET_FUN(__glewGetNamedProgramLocalParameterIuivEXT) +#define glGetNamedProgramLocalParameterdvEXT GLEW_GET_FUN(__glewGetNamedProgramLocalParameterdvEXT) +#define glGetNamedProgramLocalParameterfvEXT GLEW_GET_FUN(__glewGetNamedProgramLocalParameterfvEXT) +#define glGetNamedProgramStringEXT GLEW_GET_FUN(__glewGetNamedProgramStringEXT) +#define glGetNamedProgramivEXT GLEW_GET_FUN(__glewGetNamedProgramivEXT) +#define glGetNamedRenderbufferParameterivEXT GLEW_GET_FUN(__glewGetNamedRenderbufferParameterivEXT) +#define glGetPointerIndexedvEXT GLEW_GET_FUN(__glewGetPointerIndexedvEXT) +#define glGetTextureImageEXT GLEW_GET_FUN(__glewGetTextureImageEXT) +#define glGetTextureLevelParameterfvEXT GLEW_GET_FUN(__glewGetTextureLevelParameterfvEXT) +#define glGetTextureLevelParameterivEXT GLEW_GET_FUN(__glewGetTextureLevelParameterivEXT) +#define glGetTextureParameterIivEXT GLEW_GET_FUN(__glewGetTextureParameterIivEXT) +#define glGetTextureParameterIuivEXT GLEW_GET_FUN(__glewGetTextureParameterIuivEXT) +#define glGetTextureParameterfvEXT GLEW_GET_FUN(__glewGetTextureParameterfvEXT) +#define glGetTextureParameterivEXT GLEW_GET_FUN(__glewGetTextureParameterivEXT) +#define glMapNamedBufferEXT GLEW_GET_FUN(__glewMapNamedBufferEXT) +#define glMatrixFrustumEXT GLEW_GET_FUN(__glewMatrixFrustumEXT) +#define glMatrixLoadIdentityEXT GLEW_GET_FUN(__glewMatrixLoadIdentityEXT) +#define glMatrixLoadTransposedEXT GLEW_GET_FUN(__glewMatrixLoadTransposedEXT) +#define glMatrixLoadTransposefEXT GLEW_GET_FUN(__glewMatrixLoadTransposefEXT) +#define glMatrixLoaddEXT GLEW_GET_FUN(__glewMatrixLoaddEXT) +#define glMatrixLoadfEXT GLEW_GET_FUN(__glewMatrixLoadfEXT) +#define glMatrixMultTransposedEXT GLEW_GET_FUN(__glewMatrixMultTransposedEXT) +#define glMatrixMultTransposefEXT GLEW_GET_FUN(__glewMatrixMultTransposefEXT) +#define glMatrixMultdEXT GLEW_GET_FUN(__glewMatrixMultdEXT) +#define glMatrixMultfEXT GLEW_GET_FUN(__glewMatrixMultfEXT) +#define glMatrixOrthoEXT GLEW_GET_FUN(__glewMatrixOrthoEXT) +#define glMatrixPopEXT GLEW_GET_FUN(__glewMatrixPopEXT) +#define glMatrixPushEXT GLEW_GET_FUN(__glewMatrixPushEXT) +#define glMatrixRotatedEXT GLEW_GET_FUN(__glewMatrixRotatedEXT) +#define glMatrixRotatefEXT GLEW_GET_FUN(__glewMatrixRotatefEXT) +#define glMatrixScaledEXT GLEW_GET_FUN(__glewMatrixScaledEXT) +#define glMatrixScalefEXT GLEW_GET_FUN(__glewMatrixScalefEXT) +#define glMatrixTranslatedEXT GLEW_GET_FUN(__glewMatrixTranslatedEXT) +#define glMatrixTranslatefEXT GLEW_GET_FUN(__glewMatrixTranslatefEXT) +#define glMultiTexBufferEXT GLEW_GET_FUN(__glewMultiTexBufferEXT) +#define glMultiTexCoordPointerEXT GLEW_GET_FUN(__glewMultiTexCoordPointerEXT) +#define glMultiTexEnvfEXT GLEW_GET_FUN(__glewMultiTexEnvfEXT) +#define glMultiTexEnvfvEXT GLEW_GET_FUN(__glewMultiTexEnvfvEXT) +#define glMultiTexEnviEXT GLEW_GET_FUN(__glewMultiTexEnviEXT) +#define glMultiTexEnvivEXT GLEW_GET_FUN(__glewMultiTexEnvivEXT) +#define glMultiTexGendEXT GLEW_GET_FUN(__glewMultiTexGendEXT) +#define glMultiTexGendvEXT GLEW_GET_FUN(__glewMultiTexGendvEXT) +#define glMultiTexGenfEXT GLEW_GET_FUN(__glewMultiTexGenfEXT) +#define glMultiTexGenfvEXT GLEW_GET_FUN(__glewMultiTexGenfvEXT) +#define glMultiTexGeniEXT GLEW_GET_FUN(__glewMultiTexGeniEXT) +#define glMultiTexGenivEXT GLEW_GET_FUN(__glewMultiTexGenivEXT) +#define glMultiTexImage1DEXT GLEW_GET_FUN(__glewMultiTexImage1DEXT) +#define glMultiTexImage2DEXT GLEW_GET_FUN(__glewMultiTexImage2DEXT) +#define glMultiTexImage3DEXT GLEW_GET_FUN(__glewMultiTexImage3DEXT) +#define glMultiTexParameterIivEXT GLEW_GET_FUN(__glewMultiTexParameterIivEXT) +#define glMultiTexParameterIuivEXT GLEW_GET_FUN(__glewMultiTexParameterIuivEXT) +#define glMultiTexParameterfEXT GLEW_GET_FUN(__glewMultiTexParameterfEXT) +#define glMultiTexParameterfvEXT GLEW_GET_FUN(__glewMultiTexParameterfvEXT) +#define glMultiTexParameteriEXT GLEW_GET_FUN(__glewMultiTexParameteriEXT) +#define glMultiTexParameterivEXT GLEW_GET_FUN(__glewMultiTexParameterivEXT) +#define glMultiTexRenderbufferEXT GLEW_GET_FUN(__glewMultiTexRenderbufferEXT) +#define glMultiTexSubImage1DEXT GLEW_GET_FUN(__glewMultiTexSubImage1DEXT) +#define glMultiTexSubImage2DEXT GLEW_GET_FUN(__glewMultiTexSubImage2DEXT) +#define glMultiTexSubImage3DEXT GLEW_GET_FUN(__glewMultiTexSubImage3DEXT) +#define glNamedBufferDataEXT GLEW_GET_FUN(__glewNamedBufferDataEXT) +#define glNamedBufferSubDataEXT GLEW_GET_FUN(__glewNamedBufferSubDataEXT) +#define glNamedFramebufferRenderbufferEXT GLEW_GET_FUN(__glewNamedFramebufferRenderbufferEXT) +#define glNamedFramebufferTexture1DEXT GLEW_GET_FUN(__glewNamedFramebufferTexture1DEXT) +#define glNamedFramebufferTexture2DEXT GLEW_GET_FUN(__glewNamedFramebufferTexture2DEXT) +#define glNamedFramebufferTexture3DEXT GLEW_GET_FUN(__glewNamedFramebufferTexture3DEXT) +#define glNamedFramebufferTextureEXT GLEW_GET_FUN(__glewNamedFramebufferTextureEXT) +#define glNamedFramebufferTextureFaceEXT GLEW_GET_FUN(__glewNamedFramebufferTextureFaceEXT) +#define glNamedFramebufferTextureLayerEXT GLEW_GET_FUN(__glewNamedFramebufferTextureLayerEXT) +#define glNamedProgramLocalParameter4dEXT GLEW_GET_FUN(__glewNamedProgramLocalParameter4dEXT) +#define glNamedProgramLocalParameter4dvEXT GLEW_GET_FUN(__glewNamedProgramLocalParameter4dvEXT) +#define glNamedProgramLocalParameter4fEXT GLEW_GET_FUN(__glewNamedProgramLocalParameter4fEXT) +#define glNamedProgramLocalParameter4fvEXT GLEW_GET_FUN(__glewNamedProgramLocalParameter4fvEXT) +#define glNamedProgramLocalParameterI4iEXT GLEW_GET_FUN(__glewNamedProgramLocalParameterI4iEXT) +#define glNamedProgramLocalParameterI4ivEXT GLEW_GET_FUN(__glewNamedProgramLocalParameterI4ivEXT) +#define glNamedProgramLocalParameterI4uiEXT GLEW_GET_FUN(__glewNamedProgramLocalParameterI4uiEXT) +#define glNamedProgramLocalParameterI4uivEXT GLEW_GET_FUN(__glewNamedProgramLocalParameterI4uivEXT) +#define glNamedProgramLocalParameters4fvEXT GLEW_GET_FUN(__glewNamedProgramLocalParameters4fvEXT) +#define glNamedProgramLocalParametersI4ivEXT GLEW_GET_FUN(__glewNamedProgramLocalParametersI4ivEXT) +#define glNamedProgramLocalParametersI4uivEXT GLEW_GET_FUN(__glewNamedProgramLocalParametersI4uivEXT) +#define glNamedProgramStringEXT GLEW_GET_FUN(__glewNamedProgramStringEXT) +#define glNamedRenderbufferStorageEXT GLEW_GET_FUN(__glewNamedRenderbufferStorageEXT) +#define glNamedRenderbufferStorageMultisampleCoverageEXT GLEW_GET_FUN(__glewNamedRenderbufferStorageMultisampleCoverageEXT) +#define glNamedRenderbufferStorageMultisampleEXT GLEW_GET_FUN(__glewNamedRenderbufferStorageMultisampleEXT) +#define glProgramUniform1fEXT GLEW_GET_FUN(__glewProgramUniform1fEXT) +#define glProgramUniform1fvEXT GLEW_GET_FUN(__glewProgramUniform1fvEXT) +#define glProgramUniform1iEXT GLEW_GET_FUN(__glewProgramUniform1iEXT) +#define glProgramUniform1ivEXT GLEW_GET_FUN(__glewProgramUniform1ivEXT) +#define glProgramUniform1uiEXT GLEW_GET_FUN(__glewProgramUniform1uiEXT) +#define glProgramUniform1uivEXT GLEW_GET_FUN(__glewProgramUniform1uivEXT) +#define glProgramUniform2fEXT GLEW_GET_FUN(__glewProgramUniform2fEXT) +#define glProgramUniform2fvEXT GLEW_GET_FUN(__glewProgramUniform2fvEXT) +#define glProgramUniform2iEXT GLEW_GET_FUN(__glewProgramUniform2iEXT) +#define glProgramUniform2ivEXT GLEW_GET_FUN(__glewProgramUniform2ivEXT) +#define glProgramUniform2uiEXT GLEW_GET_FUN(__glewProgramUniform2uiEXT) +#define glProgramUniform2uivEXT GLEW_GET_FUN(__glewProgramUniform2uivEXT) +#define glProgramUniform3fEXT GLEW_GET_FUN(__glewProgramUniform3fEXT) +#define glProgramUniform3fvEXT GLEW_GET_FUN(__glewProgramUniform3fvEXT) +#define glProgramUniform3iEXT GLEW_GET_FUN(__glewProgramUniform3iEXT) +#define glProgramUniform3ivEXT GLEW_GET_FUN(__glewProgramUniform3ivEXT) +#define glProgramUniform3uiEXT GLEW_GET_FUN(__glewProgramUniform3uiEXT) +#define glProgramUniform3uivEXT GLEW_GET_FUN(__glewProgramUniform3uivEXT) +#define glProgramUniform4fEXT GLEW_GET_FUN(__glewProgramUniform4fEXT) +#define glProgramUniform4fvEXT GLEW_GET_FUN(__glewProgramUniform4fvEXT) +#define glProgramUniform4iEXT GLEW_GET_FUN(__glewProgramUniform4iEXT) +#define glProgramUniform4ivEXT GLEW_GET_FUN(__glewProgramUniform4ivEXT) +#define glProgramUniform4uiEXT GLEW_GET_FUN(__glewProgramUniform4uiEXT) +#define glProgramUniform4uivEXT GLEW_GET_FUN(__glewProgramUniform4uivEXT) +#define glProgramUniformMatrix2fvEXT GLEW_GET_FUN(__glewProgramUniformMatrix2fvEXT) +#define glProgramUniformMatrix2x3fvEXT GLEW_GET_FUN(__glewProgramUniformMatrix2x3fvEXT) +#define glProgramUniformMatrix2x4fvEXT GLEW_GET_FUN(__glewProgramUniformMatrix2x4fvEXT) +#define glProgramUniformMatrix3fvEXT GLEW_GET_FUN(__glewProgramUniformMatrix3fvEXT) +#define glProgramUniformMatrix3x2fvEXT GLEW_GET_FUN(__glewProgramUniformMatrix3x2fvEXT) +#define glProgramUniformMatrix3x4fvEXT GLEW_GET_FUN(__glewProgramUniformMatrix3x4fvEXT) +#define glProgramUniformMatrix4fvEXT GLEW_GET_FUN(__glewProgramUniformMatrix4fvEXT) +#define glProgramUniformMatrix4x2fvEXT GLEW_GET_FUN(__glewProgramUniformMatrix4x2fvEXT) +#define glProgramUniformMatrix4x3fvEXT GLEW_GET_FUN(__glewProgramUniformMatrix4x3fvEXT) +#define glPushClientAttribDefaultEXT GLEW_GET_FUN(__glewPushClientAttribDefaultEXT) +#define glTextureBufferEXT GLEW_GET_FUN(__glewTextureBufferEXT) +#define glTextureImage1DEXT GLEW_GET_FUN(__glewTextureImage1DEXT) +#define glTextureImage2DEXT GLEW_GET_FUN(__glewTextureImage2DEXT) +#define glTextureImage3DEXT GLEW_GET_FUN(__glewTextureImage3DEXT) +#define glTextureParameterIivEXT GLEW_GET_FUN(__glewTextureParameterIivEXT) +#define glTextureParameterIuivEXT GLEW_GET_FUN(__glewTextureParameterIuivEXT) +#define glTextureParameterfEXT GLEW_GET_FUN(__glewTextureParameterfEXT) +#define glTextureParameterfvEXT GLEW_GET_FUN(__glewTextureParameterfvEXT) +#define glTextureParameteriEXT GLEW_GET_FUN(__glewTextureParameteriEXT) +#define glTextureParameterivEXT GLEW_GET_FUN(__glewTextureParameterivEXT) +#define glTextureRenderbufferEXT GLEW_GET_FUN(__glewTextureRenderbufferEXT) +#define glTextureSubImage1DEXT GLEW_GET_FUN(__glewTextureSubImage1DEXT) +#define glTextureSubImage2DEXT GLEW_GET_FUN(__glewTextureSubImage2DEXT) +#define glTextureSubImage3DEXT GLEW_GET_FUN(__glewTextureSubImage3DEXT) +#define glUnmapNamedBufferEXT GLEW_GET_FUN(__glewUnmapNamedBufferEXT) + +#define GLEW_EXT_direct_state_access GLEW_GET_VAR(__GLEW_EXT_direct_state_access) + +#endif /* GL_EXT_direct_state_access */ + +/* -------------------------- GL_EXT_draw_buffers2 ------------------------- */ + +#ifndef GL_EXT_draw_buffers2 +#define GL_EXT_draw_buffers2 1 + +typedef void (GLAPIENTRY * PFNGLCOLORMASKINDEXEDEXTPROC) (GLuint buf, GLboolean r, GLboolean g, GLboolean b, GLboolean a); +typedef void (GLAPIENTRY * PFNGLDISABLEINDEXEDEXTPROC) (GLenum target, GLuint index); +typedef void (GLAPIENTRY * PFNGLENABLEINDEXEDEXTPROC) (GLenum target, GLuint index); +typedef void (GLAPIENTRY * PFNGLGETBOOLEANINDEXEDVEXTPROC) (GLenum value, GLuint index, GLboolean* data); +typedef void (GLAPIENTRY * PFNGLGETINTEGERINDEXEDVEXTPROC) (GLenum value, GLuint index, GLint* data); +typedef GLboolean (GLAPIENTRY * PFNGLISENABLEDINDEXEDEXTPROC) (GLenum target, GLuint index); + +#define glColorMaskIndexedEXT GLEW_GET_FUN(__glewColorMaskIndexedEXT) +#define glDisableIndexedEXT GLEW_GET_FUN(__glewDisableIndexedEXT) +#define glEnableIndexedEXT GLEW_GET_FUN(__glewEnableIndexedEXT) +#define glGetBooleanIndexedvEXT GLEW_GET_FUN(__glewGetBooleanIndexedvEXT) +#define glGetIntegerIndexedvEXT GLEW_GET_FUN(__glewGetIntegerIndexedvEXT) +#define glIsEnabledIndexedEXT GLEW_GET_FUN(__glewIsEnabledIndexedEXT) + +#define GLEW_EXT_draw_buffers2 GLEW_GET_VAR(__GLEW_EXT_draw_buffers2) + +#endif /* GL_EXT_draw_buffers2 */ + +/* ------------------------- GL_EXT_draw_instanced ------------------------- */ + +#ifndef GL_EXT_draw_instanced +#define GL_EXT_draw_instanced 1 + +typedef void (GLAPIENTRY * PFNGLDRAWARRAYSINSTANCEDEXTPROC) (GLenum mode, GLint start, GLsizei count, GLsizei primcount); +typedef void (GLAPIENTRY * PFNGLDRAWELEMENTSINSTANCEDEXTPROC) (GLenum mode, GLsizei count, GLenum type, const GLvoid *indices, GLsizei primcount); + +#define glDrawArraysInstancedEXT GLEW_GET_FUN(__glewDrawArraysInstancedEXT) +#define glDrawElementsInstancedEXT GLEW_GET_FUN(__glewDrawElementsInstancedEXT) + +#define GLEW_EXT_draw_instanced GLEW_GET_VAR(__GLEW_EXT_draw_instanced) + +#endif /* GL_EXT_draw_instanced */ + +/* ----------------------- GL_EXT_draw_range_elements ---------------------- */ + +#ifndef GL_EXT_draw_range_elements +#define GL_EXT_draw_range_elements 1 + +#define GL_MAX_ELEMENTS_VERTICES 0x80E8 +#define GL_MAX_ELEMENTS_INDICES 0x80E9 + +typedef void (GLAPIENTRY * PFNGLDRAWRANGEELEMENTSEXTPROC) (GLenum mode, GLuint start, GLuint end, GLsizei count, GLenum type, const GLvoid *indices); + +#define glDrawRangeElementsEXT GLEW_GET_FUN(__glewDrawRangeElementsEXT) + +#define GLEW_EXT_draw_range_elements GLEW_GET_VAR(__GLEW_EXT_draw_range_elements) + +#endif /* GL_EXT_draw_range_elements */ + +/* ---------------------------- GL_EXT_fog_coord --------------------------- */ + +#ifndef GL_EXT_fog_coord +#define GL_EXT_fog_coord 1 + +#define GL_FOG_COORDINATE_SOURCE_EXT 0x8450 +#define GL_FOG_COORDINATE_EXT 0x8451 +#define GL_FRAGMENT_DEPTH_EXT 0x8452 +#define GL_CURRENT_FOG_COORDINATE_EXT 0x8453 +#define GL_FOG_COORDINATE_ARRAY_TYPE_EXT 0x8454 +#define GL_FOG_COORDINATE_ARRAY_STRIDE_EXT 0x8455 +#define GL_FOG_COORDINATE_ARRAY_POINTER_EXT 0x8456 +#define GL_FOG_COORDINATE_ARRAY_EXT 0x8457 + +typedef void (GLAPIENTRY * PFNGLFOGCOORDPOINTEREXTPROC) (GLenum type, GLsizei stride, const GLvoid *pointer); +typedef void (GLAPIENTRY * PFNGLFOGCOORDDEXTPROC) (GLdouble coord); +typedef void (GLAPIENTRY * PFNGLFOGCOORDDVEXTPROC) (const GLdouble *coord); +typedef void (GLAPIENTRY * PFNGLFOGCOORDFEXTPROC) (GLfloat coord); +typedef void (GLAPIENTRY * PFNGLFOGCOORDFVEXTPROC) (const GLfloat *coord); + +#define glFogCoordPointerEXT GLEW_GET_FUN(__glewFogCoordPointerEXT) +#define glFogCoorddEXT GLEW_GET_FUN(__glewFogCoorddEXT) +#define glFogCoorddvEXT GLEW_GET_FUN(__glewFogCoorddvEXT) +#define glFogCoordfEXT GLEW_GET_FUN(__glewFogCoordfEXT) +#define glFogCoordfvEXT GLEW_GET_FUN(__glewFogCoordfvEXT) + +#define GLEW_EXT_fog_coord GLEW_GET_VAR(__GLEW_EXT_fog_coord) + +#endif /* GL_EXT_fog_coord */ + +/* ------------------------ GL_EXT_fragment_lighting ----------------------- */ + +#ifndef GL_EXT_fragment_lighting +#define GL_EXT_fragment_lighting 1 + +#define GL_FRAGMENT_LIGHTING_EXT 0x8400 +#define GL_FRAGMENT_COLOR_MATERIAL_EXT 0x8401 +#define GL_FRAGMENT_COLOR_MATERIAL_FACE_EXT 0x8402 +#define GL_FRAGMENT_COLOR_MATERIAL_PARAMETER_EXT 0x8403 +#define GL_MAX_FRAGMENT_LIGHTS_EXT 0x8404 +#define GL_MAX_ACTIVE_LIGHTS_EXT 0x8405 +#define GL_CURRENT_RASTER_NORMAL_EXT 0x8406 +#define GL_LIGHT_ENV_MODE_EXT 0x8407 +#define GL_FRAGMENT_LIGHT_MODEL_LOCAL_VIEWER_EXT 0x8408 +#define GL_FRAGMENT_LIGHT_MODEL_TWO_SIDE_EXT 0x8409 +#define GL_FRAGMENT_LIGHT_MODEL_AMBIENT_EXT 0x840A +#define GL_FRAGMENT_LIGHT_MODEL_NORMAL_INTERPOLATION_EXT 0x840B +#define GL_FRAGMENT_LIGHT0_EXT 0x840C +#define GL_FRAGMENT_LIGHT7_EXT 0x8413 + +typedef void (GLAPIENTRY * PFNGLFRAGMENTCOLORMATERIALEXTPROC) (GLenum face, GLenum mode); +typedef void (GLAPIENTRY * PFNGLFRAGMENTLIGHTMODELFEXTPROC) (GLenum pname, GLfloat param); +typedef void (GLAPIENTRY * PFNGLFRAGMENTLIGHTMODELFVEXTPROC) (GLenum pname, GLfloat* params); +typedef void (GLAPIENTRY * PFNGLFRAGMENTLIGHTMODELIEXTPROC) (GLenum pname, GLint param); +typedef void (GLAPIENTRY * PFNGLFRAGMENTLIGHTMODELIVEXTPROC) (GLenum pname, GLint* params); +typedef void (GLAPIENTRY * PFNGLFRAGMENTLIGHTFEXTPROC) (GLenum light, GLenum pname, GLfloat param); +typedef void (GLAPIENTRY * PFNGLFRAGMENTLIGHTFVEXTPROC) (GLenum light, GLenum pname, GLfloat* params); +typedef void (GLAPIENTRY * PFNGLFRAGMENTLIGHTIEXTPROC) (GLenum light, GLenum pname, GLint param); +typedef void (GLAPIENTRY * PFNGLFRAGMENTLIGHTIVEXTPROC) (GLenum light, GLenum pname, GLint* params); +typedef void (GLAPIENTRY * PFNGLFRAGMENTMATERIALFEXTPROC) (GLenum face, GLenum pname, const GLfloat param); +typedef void (GLAPIENTRY * PFNGLFRAGMENTMATERIALFVEXTPROC) (GLenum face, GLenum pname, const GLfloat* params); +typedef void (GLAPIENTRY * PFNGLFRAGMENTMATERIALIEXTPROC) (GLenum face, GLenum pname, const GLint param); +typedef void (GLAPIENTRY * PFNGLFRAGMENTMATERIALIVEXTPROC) (GLenum face, GLenum pname, const GLint* params); +typedef void (GLAPIENTRY * PFNGLGETFRAGMENTLIGHTFVEXTPROC) (GLenum light, GLenum pname, GLfloat* params); +typedef void (GLAPIENTRY * PFNGLGETFRAGMENTLIGHTIVEXTPROC) (GLenum light, GLenum pname, GLint* params); +typedef void (GLAPIENTRY * PFNGLGETFRAGMENTMATERIALFVEXTPROC) (GLenum face, GLenum pname, const GLfloat* params); +typedef void (GLAPIENTRY * PFNGLGETFRAGMENTMATERIALIVEXTPROC) (GLenum face, GLenum pname, const GLint* params); +typedef void (GLAPIENTRY * PFNGLLIGHTENVIEXTPROC) (GLenum pname, GLint param); + +#define glFragmentColorMaterialEXT GLEW_GET_FUN(__glewFragmentColorMaterialEXT) +#define glFragmentLightModelfEXT GLEW_GET_FUN(__glewFragmentLightModelfEXT) +#define glFragmentLightModelfvEXT GLEW_GET_FUN(__glewFragmentLightModelfvEXT) +#define glFragmentLightModeliEXT GLEW_GET_FUN(__glewFragmentLightModeliEXT) +#define glFragmentLightModelivEXT GLEW_GET_FUN(__glewFragmentLightModelivEXT) +#define glFragmentLightfEXT GLEW_GET_FUN(__glewFragmentLightfEXT) +#define glFragmentLightfvEXT GLEW_GET_FUN(__glewFragmentLightfvEXT) +#define glFragmentLightiEXT GLEW_GET_FUN(__glewFragmentLightiEXT) +#define glFragmentLightivEXT GLEW_GET_FUN(__glewFragmentLightivEXT) +#define glFragmentMaterialfEXT GLEW_GET_FUN(__glewFragmentMaterialfEXT) +#define glFragmentMaterialfvEXT GLEW_GET_FUN(__glewFragmentMaterialfvEXT) +#define glFragmentMaterialiEXT GLEW_GET_FUN(__glewFragmentMaterialiEXT) +#define glFragmentMaterialivEXT GLEW_GET_FUN(__glewFragmentMaterialivEXT) +#define glGetFragmentLightfvEXT GLEW_GET_FUN(__glewGetFragmentLightfvEXT) +#define glGetFragmentLightivEXT GLEW_GET_FUN(__glewGetFragmentLightivEXT) +#define glGetFragmentMaterialfvEXT GLEW_GET_FUN(__glewGetFragmentMaterialfvEXT) +#define glGetFragmentMaterialivEXT GLEW_GET_FUN(__glewGetFragmentMaterialivEXT) +#define glLightEnviEXT GLEW_GET_FUN(__glewLightEnviEXT) + +#define GLEW_EXT_fragment_lighting GLEW_GET_VAR(__GLEW_EXT_fragment_lighting) + +#endif /* GL_EXT_fragment_lighting */ + +/* ------------------------ GL_EXT_framebuffer_blit ------------------------ */ + +#ifndef GL_EXT_framebuffer_blit +#define GL_EXT_framebuffer_blit 1 + +#define GL_DRAW_FRAMEBUFFER_BINDING_EXT 0x8CA6 +#define GL_READ_FRAMEBUFFER_EXT 0x8CA8 +#define GL_DRAW_FRAMEBUFFER_EXT 0x8CA9 +#define GL_READ_FRAMEBUFFER_BINDING_EXT 0x8CAA + +typedef void (GLAPIENTRY * PFNGLBLITFRAMEBUFFEREXTPROC) (GLint srcX0, GLint srcY0, GLint srcX1, GLint srcY1, GLint dstX0, GLint dstY0, GLint dstX1, GLint dstY1, GLbitfield mask, GLenum filter); + +#define glBlitFramebufferEXT GLEW_GET_FUN(__glewBlitFramebufferEXT) + +#define GLEW_EXT_framebuffer_blit GLEW_GET_VAR(__GLEW_EXT_framebuffer_blit) + +#endif /* GL_EXT_framebuffer_blit */ + +/* --------------------- GL_EXT_framebuffer_multisample -------------------- */ + +#ifndef GL_EXT_framebuffer_multisample +#define GL_EXT_framebuffer_multisample 1 + +#define GL_RENDERBUFFER_SAMPLES_EXT 0x8CAB +#define GL_FRAMEBUFFER_INCOMPLETE_MULTISAMPLE_EXT 0x8D56 +#define GL_MAX_SAMPLES_EXT 0x8D57 + +typedef void (GLAPIENTRY * PFNGLRENDERBUFFERSTORAGEMULTISAMPLEEXTPROC) (GLenum target, GLsizei samples, GLenum internalformat, GLsizei width, GLsizei height); + +#define glRenderbufferStorageMultisampleEXT GLEW_GET_FUN(__glewRenderbufferStorageMultisampleEXT) + +#define GLEW_EXT_framebuffer_multisample GLEW_GET_VAR(__GLEW_EXT_framebuffer_multisample) + +#endif /* GL_EXT_framebuffer_multisample */ + +/* ----------------------- GL_EXT_framebuffer_object ----------------------- */ + +#ifndef GL_EXT_framebuffer_object +#define GL_EXT_framebuffer_object 1 + +#define GL_INVALID_FRAMEBUFFER_OPERATION_EXT 0x0506 +#define GL_MAX_RENDERBUFFER_SIZE_EXT 0x84E8 +#define GL_FRAMEBUFFER_BINDING_EXT 0x8CA6 +#define GL_RENDERBUFFER_BINDING_EXT 0x8CA7 +#define GL_FRAMEBUFFER_ATTACHMENT_OBJECT_TYPE_EXT 0x8CD0 +#define GL_FRAMEBUFFER_ATTACHMENT_OBJECT_NAME_EXT 0x8CD1 +#define GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_LEVEL_EXT 0x8CD2 +#define GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_CUBE_MAP_FACE_EXT 0x8CD3 +#define GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_3D_ZOFFSET_EXT 0x8CD4 +#define GL_FRAMEBUFFER_COMPLETE_EXT 0x8CD5 +#define GL_FRAMEBUFFER_INCOMPLETE_ATTACHMENT_EXT 0x8CD6 +#define GL_FRAMEBUFFER_INCOMPLETE_MISSING_ATTACHMENT_EXT 0x8CD7 +#define GL_FRAMEBUFFER_INCOMPLETE_DIMENSIONS_EXT 0x8CD9 +#define GL_FRAMEBUFFER_INCOMPLETE_FORMATS_EXT 0x8CDA +#define GL_FRAMEBUFFER_INCOMPLETE_DRAW_BUFFER_EXT 0x8CDB +#define GL_FRAMEBUFFER_INCOMPLETE_READ_BUFFER_EXT 0x8CDC +#define GL_FRAMEBUFFER_UNSUPPORTED_EXT 0x8CDD +#define GL_MAX_COLOR_ATTACHMENTS_EXT 0x8CDF +#define GL_COLOR_ATTACHMENT0_EXT 0x8CE0 +#define GL_COLOR_ATTACHMENT1_EXT 0x8CE1 +#define GL_COLOR_ATTACHMENT2_EXT 0x8CE2 +#define GL_COLOR_ATTACHMENT3_EXT 0x8CE3 +#define GL_COLOR_ATTACHMENT4_EXT 0x8CE4 +#define GL_COLOR_ATTACHMENT5_EXT 0x8CE5 +#define GL_COLOR_ATTACHMENT6_EXT 0x8CE6 +#define GL_COLOR_ATTACHMENT7_EXT 0x8CE7 +#define GL_COLOR_ATTACHMENT8_EXT 0x8CE8 +#define GL_COLOR_ATTACHMENT9_EXT 0x8CE9 +#define GL_COLOR_ATTACHMENT10_EXT 0x8CEA +#define GL_COLOR_ATTACHMENT11_EXT 0x8CEB +#define GL_COLOR_ATTACHMENT12_EXT 0x8CEC +#define GL_COLOR_ATTACHMENT13_EXT 0x8CED +#define GL_COLOR_ATTACHMENT14_EXT 0x8CEE +#define GL_COLOR_ATTACHMENT15_EXT 0x8CEF +#define GL_DEPTH_ATTACHMENT_EXT 0x8D00 +#define GL_STENCIL_ATTACHMENT_EXT 0x8D20 +#define GL_FRAMEBUFFER_EXT 0x8D40 +#define GL_RENDERBUFFER_EXT 0x8D41 +#define GL_RENDERBUFFER_WIDTH_EXT 0x8D42 +#define GL_RENDERBUFFER_HEIGHT_EXT 0x8D43 +#define GL_RENDERBUFFER_INTERNAL_FORMAT_EXT 0x8D44 +#define GL_STENCIL_INDEX1_EXT 0x8D46 +#define GL_STENCIL_INDEX4_EXT 0x8D47 +#define GL_STENCIL_INDEX8_EXT 0x8D48 +#define GL_STENCIL_INDEX16_EXT 0x8D49 +#define GL_RENDERBUFFER_RED_SIZE_EXT 0x8D50 +#define GL_RENDERBUFFER_GREEN_SIZE_EXT 0x8D51 +#define GL_RENDERBUFFER_BLUE_SIZE_EXT 0x8D52 +#define GL_RENDERBUFFER_ALPHA_SIZE_EXT 0x8D53 +#define GL_RENDERBUFFER_DEPTH_SIZE_EXT 0x8D54 +#define GL_RENDERBUFFER_STENCIL_SIZE_EXT 0x8D55 + +typedef void (GLAPIENTRY * PFNGLBINDFRAMEBUFFEREXTPROC) (GLenum target, GLuint framebuffer); +typedef void (GLAPIENTRY * PFNGLBINDRENDERBUFFEREXTPROC) (GLenum target, GLuint renderbuffer); +typedef GLenum (GLAPIENTRY * PFNGLCHECKFRAMEBUFFERSTATUSEXTPROC) (GLenum target); +typedef void (GLAPIENTRY * PFNGLDELETEFRAMEBUFFERSEXTPROC) (GLsizei n, const GLuint* framebuffers); +typedef void (GLAPIENTRY * PFNGLDELETERENDERBUFFERSEXTPROC) (GLsizei n, const GLuint* renderbuffers); +typedef void (GLAPIENTRY * PFNGLFRAMEBUFFERRENDERBUFFEREXTPROC) (GLenum target, GLenum attachment, GLenum renderbuffertarget, GLuint renderbuffer); +typedef void (GLAPIENTRY * PFNGLFRAMEBUFFERTEXTURE1DEXTPROC) (GLenum target, GLenum attachment, GLenum textarget, GLuint texture, GLint level); +typedef void (GLAPIENTRY * PFNGLFRAMEBUFFERTEXTURE2DEXTPROC) (GLenum target, GLenum attachment, GLenum textarget, GLuint texture, GLint level); +typedef void (GLAPIENTRY * PFNGLFRAMEBUFFERTEXTURE3DEXTPROC) (GLenum target, GLenum attachment, GLenum textarget, GLuint texture, GLint level, GLint zoffset); +typedef void (GLAPIENTRY * PFNGLGENFRAMEBUFFERSEXTPROC) (GLsizei n, GLuint* framebuffers); +typedef void (GLAPIENTRY * PFNGLGENRENDERBUFFERSEXTPROC) (GLsizei n, GLuint* renderbuffers); +typedef void (GLAPIENTRY * PFNGLGENERATEMIPMAPEXTPROC) (GLenum target); +typedef void (GLAPIENTRY * PFNGLGETFRAMEBUFFERATTACHMENTPARAMETERIVEXTPROC) (GLenum target, GLenum attachment, GLenum pname, GLint* params); +typedef void (GLAPIENTRY * PFNGLGETRENDERBUFFERPARAMETERIVEXTPROC) (GLenum target, GLenum pname, GLint* params); +typedef GLboolean (GLAPIENTRY * PFNGLISFRAMEBUFFEREXTPROC) (GLuint framebuffer); +typedef GLboolean (GLAPIENTRY * PFNGLISRENDERBUFFEREXTPROC) (GLuint renderbuffer); +typedef void (GLAPIENTRY * PFNGLRENDERBUFFERSTORAGEEXTPROC) (GLenum target, GLenum internalformat, GLsizei width, GLsizei height); + +#define glBindFramebufferEXT GLEW_GET_FUN(__glewBindFramebufferEXT) +#define glBindRenderbufferEXT GLEW_GET_FUN(__glewBindRenderbufferEXT) +#define glCheckFramebufferStatusEXT GLEW_GET_FUN(__glewCheckFramebufferStatusEXT) +#define glDeleteFramebuffersEXT GLEW_GET_FUN(__glewDeleteFramebuffersEXT) +#define glDeleteRenderbuffersEXT GLEW_GET_FUN(__glewDeleteRenderbuffersEXT) +#define glFramebufferRenderbufferEXT GLEW_GET_FUN(__glewFramebufferRenderbufferEXT) +#define glFramebufferTexture1DEXT GLEW_GET_FUN(__glewFramebufferTexture1DEXT) +#define glFramebufferTexture2DEXT GLEW_GET_FUN(__glewFramebufferTexture2DEXT) +#define glFramebufferTexture3DEXT GLEW_GET_FUN(__glewFramebufferTexture3DEXT) +#define glGenFramebuffersEXT GLEW_GET_FUN(__glewGenFramebuffersEXT) +#define glGenRenderbuffersEXT GLEW_GET_FUN(__glewGenRenderbuffersEXT) +#define glGenerateMipmapEXT GLEW_GET_FUN(__glewGenerateMipmapEXT) +#define glGetFramebufferAttachmentParameterivEXT GLEW_GET_FUN(__glewGetFramebufferAttachmentParameterivEXT) +#define glGetRenderbufferParameterivEXT GLEW_GET_FUN(__glewGetRenderbufferParameterivEXT) +#define glIsFramebufferEXT GLEW_GET_FUN(__glewIsFramebufferEXT) +#define glIsRenderbufferEXT GLEW_GET_FUN(__glewIsRenderbufferEXT) +#define glRenderbufferStorageEXT GLEW_GET_FUN(__glewRenderbufferStorageEXT) + +#define GLEW_EXT_framebuffer_object GLEW_GET_VAR(__GLEW_EXT_framebuffer_object) + +#endif /* GL_EXT_framebuffer_object */ + +/* ------------------------ GL_EXT_framebuffer_sRGB ------------------------ */ + +#ifndef GL_EXT_framebuffer_sRGB +#define GL_EXT_framebuffer_sRGB 1 + +#define GL_FRAMEBUFFER_SRGB_EXT 0x8DB9 +#define GL_FRAMEBUFFER_SRGB_CAPABLE_EXT 0x8DBA + +#define GLEW_EXT_framebuffer_sRGB GLEW_GET_VAR(__GLEW_EXT_framebuffer_sRGB) + +#endif /* GL_EXT_framebuffer_sRGB */ + +/* ------------------------ GL_EXT_geometry_shader4 ------------------------ */ + +#ifndef GL_EXT_geometry_shader4 +#define GL_EXT_geometry_shader4 1 + +#define GL_LINES_ADJACENCY_EXT 0xA +#define GL_LINE_STRIP_ADJACENCY_EXT 0xB +#define GL_TRIANGLES_ADJACENCY_EXT 0xC +#define GL_TRIANGLE_STRIP_ADJACENCY_EXT 0xD +#define GL_PROGRAM_POINT_SIZE_EXT 0x8642 +#define GL_MAX_VARYING_COMPONENTS_EXT 0x8B4B +#define GL_MAX_GEOMETRY_TEXTURE_IMAGE_UNITS_EXT 0x8C29 +#define GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_LAYER_EXT 0x8CD4 +#define GL_FRAMEBUFFER_ATTACHMENT_LAYERED_EXT 0x8DA7 +#define GL_FRAMEBUFFER_INCOMPLETE_LAYER_TARGETS_EXT 0x8DA8 +#define GL_FRAMEBUFFER_INCOMPLETE_LAYER_COUNT_EXT 0x8DA9 +#define GL_GEOMETRY_SHADER_EXT 0x8DD9 +#define GL_GEOMETRY_VERTICES_OUT_EXT 0x8DDA +#define GL_GEOMETRY_INPUT_TYPE_EXT 0x8DDB +#define GL_GEOMETRY_OUTPUT_TYPE_EXT 0x8DDC +#define GL_MAX_GEOMETRY_VARYING_COMPONENTS_EXT 0x8DDD +#define GL_MAX_VERTEX_VARYING_COMPONENTS_EXT 0x8DDE +#define GL_MAX_GEOMETRY_UNIFORM_COMPONENTS_EXT 0x8DDF +#define GL_MAX_GEOMETRY_OUTPUT_VERTICES_EXT 0x8DE0 +#define GL_MAX_GEOMETRY_TOTAL_OUTPUT_COMPONENTS_EXT 0x8DE1 + +typedef void (GLAPIENTRY * PFNGLFRAMEBUFFERTEXTUREEXTPROC) (GLenum target, GLenum attachment, GLuint texture, GLint level); +typedef void (GLAPIENTRY * PFNGLFRAMEBUFFERTEXTUREFACEEXTPROC) (GLenum target, GLenum attachment, GLuint texture, GLint level, GLenum face); +typedef void (GLAPIENTRY * PFNGLFRAMEBUFFERTEXTURELAYEREXTPROC) (GLenum target, GLenum attachment, GLuint texture, GLint level, GLint layer); +typedef void (GLAPIENTRY * PFNGLPROGRAMPARAMETERIEXTPROC) (GLuint program, GLenum pname, GLint value); + +#define glFramebufferTextureEXT GLEW_GET_FUN(__glewFramebufferTextureEXT) +#define glFramebufferTextureFaceEXT GLEW_GET_FUN(__glewFramebufferTextureFaceEXT) +#define glFramebufferTextureLayerEXT GLEW_GET_FUN(__glewFramebufferTextureLayerEXT) +#define glProgramParameteriEXT GLEW_GET_FUN(__glewProgramParameteriEXT) + +#define GLEW_EXT_geometry_shader4 GLEW_GET_VAR(__GLEW_EXT_geometry_shader4) + +#endif /* GL_EXT_geometry_shader4 */ + +/* --------------------- GL_EXT_gpu_program_parameters --------------------- */ + +#ifndef GL_EXT_gpu_program_parameters +#define GL_EXT_gpu_program_parameters 1 + +typedef void (GLAPIENTRY * PFNGLPROGRAMENVPARAMETERS4FVEXTPROC) (GLenum target, GLuint index, GLsizei count, const GLfloat* params); +typedef void (GLAPIENTRY * PFNGLPROGRAMLOCALPARAMETERS4FVEXTPROC) (GLenum target, GLuint index, GLsizei count, const GLfloat* params); + +#define glProgramEnvParameters4fvEXT GLEW_GET_FUN(__glewProgramEnvParameters4fvEXT) +#define glProgramLocalParameters4fvEXT GLEW_GET_FUN(__glewProgramLocalParameters4fvEXT) + +#define GLEW_EXT_gpu_program_parameters GLEW_GET_VAR(__GLEW_EXT_gpu_program_parameters) + +#endif /* GL_EXT_gpu_program_parameters */ + +/* --------------------------- GL_EXT_gpu_shader4 -------------------------- */ + +#ifndef GL_EXT_gpu_shader4 +#define GL_EXT_gpu_shader4 1 + +#define GL_VERTEX_ATTRIB_ARRAY_INTEGER_EXT 0x88FD +#define GL_SAMPLER_1D_ARRAY_EXT 0x8DC0 +#define GL_SAMPLER_2D_ARRAY_EXT 0x8DC1 +#define GL_SAMPLER_BUFFER_EXT 0x8DC2 +#define GL_SAMPLER_1D_ARRAY_SHADOW_EXT 0x8DC3 +#define GL_SAMPLER_2D_ARRAY_SHADOW_EXT 0x8DC4 +#define GL_SAMPLER_CUBE_SHADOW_EXT 0x8DC5 +#define GL_UNSIGNED_INT_VEC2_EXT 0x8DC6 +#define GL_UNSIGNED_INT_VEC3_EXT 0x8DC7 +#define GL_UNSIGNED_INT_VEC4_EXT 0x8DC8 +#define GL_INT_SAMPLER_1D_EXT 0x8DC9 +#define GL_INT_SAMPLER_2D_EXT 0x8DCA +#define GL_INT_SAMPLER_3D_EXT 0x8DCB +#define GL_INT_SAMPLER_CUBE_EXT 0x8DCC +#define GL_INT_SAMPLER_2D_RECT_EXT 0x8DCD +#define GL_INT_SAMPLER_1D_ARRAY_EXT 0x8DCE +#define GL_INT_SAMPLER_2D_ARRAY_EXT 0x8DCF +#define GL_INT_SAMPLER_BUFFER_EXT 0x8DD0 +#define GL_UNSIGNED_INT_SAMPLER_1D_EXT 0x8DD1 +#define GL_UNSIGNED_INT_SAMPLER_2D_EXT 0x8DD2 +#define GL_UNSIGNED_INT_SAMPLER_3D_EXT 0x8DD3 +#define GL_UNSIGNED_INT_SAMPLER_CUBE_EXT 0x8DD4 +#define GL_UNSIGNED_INT_SAMPLER_2D_RECT_EXT 0x8DD5 +#define GL_UNSIGNED_INT_SAMPLER_1D_ARRAY_EXT 0x8DD6 +#define GL_UNSIGNED_INT_SAMPLER_2D_ARRAY_EXT 0x8DD7 +#define GL_UNSIGNED_INT_SAMPLER_BUFFER_EXT 0x8DD8 + +typedef void (GLAPIENTRY * PFNGLBINDFRAGDATALOCATIONEXTPROC) (GLuint program, GLuint color, const GLchar *name); +typedef GLint (GLAPIENTRY * PFNGLGETFRAGDATALOCATIONEXTPROC) (GLuint program, const GLchar *name); +typedef void (GLAPIENTRY * PFNGLGETUNIFORMUIVEXTPROC) (GLuint program, GLint location, GLuint *params); +typedef void (GLAPIENTRY * PFNGLGETVERTEXATTRIBIIVEXTPROC) (GLuint index, GLenum pname, GLint *params); +typedef void (GLAPIENTRY * PFNGLGETVERTEXATTRIBIUIVEXTPROC) (GLuint index, GLenum pname, GLuint *params); +typedef void (GLAPIENTRY * PFNGLUNIFORM1UIEXTPROC) (GLint location, GLuint v0); +typedef void (GLAPIENTRY * PFNGLUNIFORM1UIVEXTPROC) (GLint location, GLsizei count, const GLuint *value); +typedef void (GLAPIENTRY * PFNGLUNIFORM2UIEXTPROC) (GLint location, GLuint v0, GLuint v1); +typedef void (GLAPIENTRY * PFNGLUNIFORM2UIVEXTPROC) (GLint location, GLsizei count, const GLuint *value); +typedef void (GLAPIENTRY * PFNGLUNIFORM3UIEXTPROC) (GLint location, GLuint v0, GLuint v1, GLuint v2); +typedef void (GLAPIENTRY * PFNGLUNIFORM3UIVEXTPROC) (GLint location, GLsizei count, const GLuint *value); +typedef void (GLAPIENTRY * PFNGLUNIFORM4UIEXTPROC) (GLint location, GLuint v0, GLuint v1, GLuint v2, GLuint v3); +typedef void (GLAPIENTRY * PFNGLUNIFORM4UIVEXTPROC) (GLint location, GLsizei count, const GLuint *value); +typedef void (GLAPIENTRY * PFNGLVERTEXATTRIBI1IEXTPROC) (GLuint index, GLint x); +typedef void (GLAPIENTRY * PFNGLVERTEXATTRIBI1IVEXTPROC) (GLuint index, const GLint *v); +typedef void (GLAPIENTRY * PFNGLVERTEXATTRIBI1UIEXTPROC) (GLuint index, GLuint x); +typedef void (GLAPIENTRY * PFNGLVERTEXATTRIBI1UIVEXTPROC) (GLuint index, const GLuint *v); +typedef void (GLAPIENTRY * PFNGLVERTEXATTRIBI2IEXTPROC) (GLuint index, GLint x, GLint y); +typedef void (GLAPIENTRY * PFNGLVERTEXATTRIBI2IVEXTPROC) (GLuint index, const GLint *v); +typedef void (GLAPIENTRY * PFNGLVERTEXATTRIBI2UIEXTPROC) (GLuint index, GLuint x, GLuint y); +typedef void (GLAPIENTRY * PFNGLVERTEXATTRIBI2UIVEXTPROC) (GLuint index, const GLuint *v); +typedef void (GLAPIENTRY * PFNGLVERTEXATTRIBI3IEXTPROC) (GLuint index, GLint x, GLint y, GLint z); +typedef void (GLAPIENTRY * PFNGLVERTEXATTRIBI3IVEXTPROC) (GLuint index, const GLint *v); +typedef void (GLAPIENTRY * PFNGLVERTEXATTRIBI3UIEXTPROC) (GLuint index, GLuint x, GLuint y, GLuint z); +typedef void (GLAPIENTRY * PFNGLVERTEXATTRIBI3UIVEXTPROC) (GLuint index, const GLuint *v); +typedef void (GLAPIENTRY * PFNGLVERTEXATTRIBI4BVEXTPROC) (GLuint index, const GLbyte *v); +typedef void (GLAPIENTRY * PFNGLVERTEXATTRIBI4IEXTPROC) (GLuint index, GLint x, GLint y, GLint z, GLint w); +typedef void (GLAPIENTRY * PFNGLVERTEXATTRIBI4IVEXTPROC) (GLuint index, const GLint *v); +typedef void (GLAPIENTRY * PFNGLVERTEXATTRIBI4SVEXTPROC) (GLuint index, const GLshort *v); +typedef void (GLAPIENTRY * PFNGLVERTEXATTRIBI4UBVEXTPROC) (GLuint index, const GLubyte *v); +typedef void (GLAPIENTRY * PFNGLVERTEXATTRIBI4UIEXTPROC) (GLuint index, GLuint x, GLuint y, GLuint z, GLuint w); +typedef void (GLAPIENTRY * PFNGLVERTEXATTRIBI4UIVEXTPROC) (GLuint index, const GLuint *v); +typedef void (GLAPIENTRY * PFNGLVERTEXATTRIBI4USVEXTPROC) (GLuint index, const GLushort *v); +typedef void (GLAPIENTRY * PFNGLVERTEXATTRIBIPOINTEREXTPROC) (GLuint index, GLint size, GLenum type, GLsizei stride, const GLvoid *pointer); + +#define glBindFragDataLocationEXT GLEW_GET_FUN(__glewBindFragDataLocationEXT) +#define glGetFragDataLocationEXT GLEW_GET_FUN(__glewGetFragDataLocationEXT) +#define glGetUniformuivEXT GLEW_GET_FUN(__glewGetUniformuivEXT) +#define glGetVertexAttribIivEXT GLEW_GET_FUN(__glewGetVertexAttribIivEXT) +#define glGetVertexAttribIuivEXT GLEW_GET_FUN(__glewGetVertexAttribIuivEXT) +#define glUniform1uiEXT GLEW_GET_FUN(__glewUniform1uiEXT) +#define glUniform1uivEXT GLEW_GET_FUN(__glewUniform1uivEXT) +#define glUniform2uiEXT GLEW_GET_FUN(__glewUniform2uiEXT) +#define glUniform2uivEXT GLEW_GET_FUN(__glewUniform2uivEXT) +#define glUniform3uiEXT GLEW_GET_FUN(__glewUniform3uiEXT) +#define glUniform3uivEXT GLEW_GET_FUN(__glewUniform3uivEXT) +#define glUniform4uiEXT GLEW_GET_FUN(__glewUniform4uiEXT) +#define glUniform4uivEXT GLEW_GET_FUN(__glewUniform4uivEXT) +#define glVertexAttribI1iEXT GLEW_GET_FUN(__glewVertexAttribI1iEXT) +#define glVertexAttribI1ivEXT GLEW_GET_FUN(__glewVertexAttribI1ivEXT) +#define glVertexAttribI1uiEXT GLEW_GET_FUN(__glewVertexAttribI1uiEXT) +#define glVertexAttribI1uivEXT GLEW_GET_FUN(__glewVertexAttribI1uivEXT) +#define glVertexAttribI2iEXT GLEW_GET_FUN(__glewVertexAttribI2iEXT) +#define glVertexAttribI2ivEXT GLEW_GET_FUN(__glewVertexAttribI2ivEXT) +#define glVertexAttribI2uiEXT GLEW_GET_FUN(__glewVertexAttribI2uiEXT) +#define glVertexAttribI2uivEXT GLEW_GET_FUN(__glewVertexAttribI2uivEXT) +#define glVertexAttribI3iEXT GLEW_GET_FUN(__glewVertexAttribI3iEXT) +#define glVertexAttribI3ivEXT GLEW_GET_FUN(__glewVertexAttribI3ivEXT) +#define glVertexAttribI3uiEXT GLEW_GET_FUN(__glewVertexAttribI3uiEXT) +#define glVertexAttribI3uivEXT GLEW_GET_FUN(__glewVertexAttribI3uivEXT) +#define glVertexAttribI4bvEXT GLEW_GET_FUN(__glewVertexAttribI4bvEXT) +#define glVertexAttribI4iEXT GLEW_GET_FUN(__glewVertexAttribI4iEXT) +#define glVertexAttribI4ivEXT GLEW_GET_FUN(__glewVertexAttribI4ivEXT) +#define glVertexAttribI4svEXT GLEW_GET_FUN(__glewVertexAttribI4svEXT) +#define glVertexAttribI4ubvEXT GLEW_GET_FUN(__glewVertexAttribI4ubvEXT) +#define glVertexAttribI4uiEXT GLEW_GET_FUN(__glewVertexAttribI4uiEXT) +#define glVertexAttribI4uivEXT GLEW_GET_FUN(__glewVertexAttribI4uivEXT) +#define glVertexAttribI4usvEXT GLEW_GET_FUN(__glewVertexAttribI4usvEXT) +#define glVertexAttribIPointerEXT GLEW_GET_FUN(__glewVertexAttribIPointerEXT) + +#define GLEW_EXT_gpu_shader4 GLEW_GET_VAR(__GLEW_EXT_gpu_shader4) + +#endif /* GL_EXT_gpu_shader4 */ + +/* ---------------------------- GL_EXT_histogram --------------------------- */ + +#ifndef GL_EXT_histogram +#define GL_EXT_histogram 1 + +#define GL_HISTOGRAM_EXT 0x8024 +#define GL_PROXY_HISTOGRAM_EXT 0x8025 +#define GL_HISTOGRAM_WIDTH_EXT 0x8026 +#define GL_HISTOGRAM_FORMAT_EXT 0x8027 +#define GL_HISTOGRAM_RED_SIZE_EXT 0x8028 +#define GL_HISTOGRAM_GREEN_SIZE_EXT 0x8029 +#define GL_HISTOGRAM_BLUE_SIZE_EXT 0x802A +#define GL_HISTOGRAM_ALPHA_SIZE_EXT 0x802B +#define GL_HISTOGRAM_LUMINANCE_SIZE_EXT 0x802C +#define GL_HISTOGRAM_SINK_EXT 0x802D +#define GL_MINMAX_EXT 0x802E +#define GL_MINMAX_FORMAT_EXT 0x802F +#define GL_MINMAX_SINK_EXT 0x8030 + +typedef void (GLAPIENTRY * PFNGLGETHISTOGRAMEXTPROC) (GLenum target, GLboolean reset, GLenum format, GLenum type, void* values); +typedef void (GLAPIENTRY * PFNGLGETHISTOGRAMPARAMETERFVEXTPROC) (GLenum target, GLenum pname, GLfloat* params); +typedef void (GLAPIENTRY * PFNGLGETHISTOGRAMPARAMETERIVEXTPROC) (GLenum target, GLenum pname, GLint* params); +typedef void (GLAPIENTRY * PFNGLGETMINMAXEXTPROC) (GLenum target, GLboolean reset, GLenum format, GLenum type, void* values); +typedef void (GLAPIENTRY * PFNGLGETMINMAXPARAMETERFVEXTPROC) (GLenum target, GLenum pname, GLfloat* params); +typedef void (GLAPIENTRY * PFNGLGETMINMAXPARAMETERIVEXTPROC) (GLenum target, GLenum pname, GLint* params); +typedef void (GLAPIENTRY * PFNGLHISTOGRAMEXTPROC) (GLenum target, GLsizei width, GLenum internalformat, GLboolean sink); +typedef void (GLAPIENTRY * PFNGLMINMAXEXTPROC) (GLenum target, GLenum internalformat, GLboolean sink); +typedef void (GLAPIENTRY * PFNGLRESETHISTOGRAMEXTPROC) (GLenum target); +typedef void (GLAPIENTRY * PFNGLRESETMINMAXEXTPROC) (GLenum target); + +#define glGetHistogramEXT GLEW_GET_FUN(__glewGetHistogramEXT) +#define glGetHistogramParameterfvEXT GLEW_GET_FUN(__glewGetHistogramParameterfvEXT) +#define glGetHistogramParameterivEXT GLEW_GET_FUN(__glewGetHistogramParameterivEXT) +#define glGetMinmaxEXT GLEW_GET_FUN(__glewGetMinmaxEXT) +#define glGetMinmaxParameterfvEXT GLEW_GET_FUN(__glewGetMinmaxParameterfvEXT) +#define glGetMinmaxParameterivEXT GLEW_GET_FUN(__glewGetMinmaxParameterivEXT) +#define glHistogramEXT GLEW_GET_FUN(__glewHistogramEXT) +#define glMinmaxEXT GLEW_GET_FUN(__glewMinmaxEXT) +#define glResetHistogramEXT GLEW_GET_FUN(__glewResetHistogramEXT) +#define glResetMinmaxEXT GLEW_GET_FUN(__glewResetMinmaxEXT) + +#define GLEW_EXT_histogram GLEW_GET_VAR(__GLEW_EXT_histogram) + +#endif /* GL_EXT_histogram */ + +/* ----------------------- GL_EXT_index_array_formats ---------------------- */ + +#ifndef GL_EXT_index_array_formats +#define GL_EXT_index_array_formats 1 + +#define GLEW_EXT_index_array_formats GLEW_GET_VAR(__GLEW_EXT_index_array_formats) + +#endif /* GL_EXT_index_array_formats */ + +/* --------------------------- GL_EXT_index_func --------------------------- */ + +#ifndef GL_EXT_index_func +#define GL_EXT_index_func 1 + +typedef void (GLAPIENTRY * PFNGLINDEXFUNCEXTPROC) (GLenum func, GLfloat ref); + +#define glIndexFuncEXT GLEW_GET_FUN(__glewIndexFuncEXT) + +#define GLEW_EXT_index_func GLEW_GET_VAR(__GLEW_EXT_index_func) + +#endif /* GL_EXT_index_func */ + +/* ------------------------- GL_EXT_index_material ------------------------- */ + +#ifndef GL_EXT_index_material +#define GL_EXT_index_material 1 + +typedef void (GLAPIENTRY * PFNGLINDEXMATERIALEXTPROC) (GLenum face, GLenum mode); + +#define glIndexMaterialEXT GLEW_GET_FUN(__glewIndexMaterialEXT) + +#define GLEW_EXT_index_material GLEW_GET_VAR(__GLEW_EXT_index_material) + +#endif /* GL_EXT_index_material */ + +/* -------------------------- GL_EXT_index_texture ------------------------- */ + +#ifndef GL_EXT_index_texture +#define GL_EXT_index_texture 1 + +#define GLEW_EXT_index_texture GLEW_GET_VAR(__GLEW_EXT_index_texture) + +#endif /* GL_EXT_index_texture */ + +/* -------------------------- GL_EXT_light_texture ------------------------- */ + +#ifndef GL_EXT_light_texture +#define GL_EXT_light_texture 1 + +#define GL_FRAGMENT_MATERIAL_EXT 0x8349 +#define GL_FRAGMENT_NORMAL_EXT 0x834A +#define GL_FRAGMENT_COLOR_EXT 0x834C +#define GL_ATTENUATION_EXT 0x834D +#define GL_SHADOW_ATTENUATION_EXT 0x834E +#define GL_TEXTURE_APPLICATION_MODE_EXT 0x834F +#define GL_TEXTURE_LIGHT_EXT 0x8350 +#define GL_TEXTURE_MATERIAL_FACE_EXT 0x8351 +#define GL_TEXTURE_MATERIAL_PARAMETER_EXT 0x8352 +#define GL_FRAGMENT_DEPTH_EXT 0x8452 + +typedef void (GLAPIENTRY * PFNGLAPPLYTEXTUREEXTPROC) (GLenum mode); +typedef void (GLAPIENTRY * PFNGLTEXTURELIGHTEXTPROC) (GLenum pname); +typedef void (GLAPIENTRY * PFNGLTEXTUREMATERIALEXTPROC) (GLenum face, GLenum mode); + +#define glApplyTextureEXT GLEW_GET_FUN(__glewApplyTextureEXT) +#define glTextureLightEXT GLEW_GET_FUN(__glewTextureLightEXT) +#define glTextureMaterialEXT GLEW_GET_FUN(__glewTextureMaterialEXT) + +#define GLEW_EXT_light_texture GLEW_GET_VAR(__GLEW_EXT_light_texture) + +#endif /* GL_EXT_light_texture */ + +/* ------------------------- GL_EXT_misc_attribute ------------------------- */ + +#ifndef GL_EXT_misc_attribute +#define GL_EXT_misc_attribute 1 + +#define GLEW_EXT_misc_attribute GLEW_GET_VAR(__GLEW_EXT_misc_attribute) + +#endif /* GL_EXT_misc_attribute */ + +/* ------------------------ GL_EXT_multi_draw_arrays ----------------------- */ + +#ifndef GL_EXT_multi_draw_arrays +#define GL_EXT_multi_draw_arrays 1 + +typedef void (GLAPIENTRY * PFNGLMULTIDRAWARRAYSEXTPROC) (GLenum mode, GLint* first, GLsizei *count, GLsizei primcount); +typedef void (GLAPIENTRY * PFNGLMULTIDRAWELEMENTSEXTPROC) (GLenum mode, GLsizei* count, GLenum type, const GLvoid **indices, GLsizei primcount); + +#define glMultiDrawArraysEXT GLEW_GET_FUN(__glewMultiDrawArraysEXT) +#define glMultiDrawElementsEXT GLEW_GET_FUN(__glewMultiDrawElementsEXT) + +#define GLEW_EXT_multi_draw_arrays GLEW_GET_VAR(__GLEW_EXT_multi_draw_arrays) + +#endif /* GL_EXT_multi_draw_arrays */ + +/* --------------------------- GL_EXT_multisample -------------------------- */ + +#ifndef GL_EXT_multisample +#define GL_EXT_multisample 1 + +#define GL_MULTISAMPLE_EXT 0x809D +#define GL_SAMPLE_ALPHA_TO_MASK_EXT 0x809E +#define GL_SAMPLE_ALPHA_TO_ONE_EXT 0x809F +#define GL_SAMPLE_MASK_EXT 0x80A0 +#define GL_1PASS_EXT 0x80A1 +#define GL_2PASS_0_EXT 0x80A2 +#define GL_2PASS_1_EXT 0x80A3 +#define GL_4PASS_0_EXT 0x80A4 +#define GL_4PASS_1_EXT 0x80A5 +#define GL_4PASS_2_EXT 0x80A6 +#define GL_4PASS_3_EXT 0x80A7 +#define GL_SAMPLE_BUFFERS_EXT 0x80A8 +#define GL_SAMPLES_EXT 0x80A9 +#define GL_SAMPLE_MASK_VALUE_EXT 0x80AA +#define GL_SAMPLE_MASK_INVERT_EXT 0x80AB +#define GL_SAMPLE_PATTERN_EXT 0x80AC +#define GL_MULTISAMPLE_BIT_EXT 0x20000000 + +typedef void (GLAPIENTRY * PFNGLSAMPLEMASKEXTPROC) (GLclampf value, GLboolean invert); +typedef void (GLAPIENTRY * PFNGLSAMPLEPATTERNEXTPROC) (GLenum pattern); + +#define glSampleMaskEXT GLEW_GET_FUN(__glewSampleMaskEXT) +#define glSamplePatternEXT GLEW_GET_FUN(__glewSamplePatternEXT) + +#define GLEW_EXT_multisample GLEW_GET_VAR(__GLEW_EXT_multisample) + +#endif /* GL_EXT_multisample */ + +/* ---------------------- GL_EXT_packed_depth_stencil ---------------------- */ + +#ifndef GL_EXT_packed_depth_stencil +#define GL_EXT_packed_depth_stencil 1 + +#define GL_DEPTH_STENCIL_EXT 0x84F9 +#define GL_UNSIGNED_INT_24_8_EXT 0x84FA +#define GL_DEPTH24_STENCIL8_EXT 0x88F0 +#define GL_TEXTURE_STENCIL_SIZE_EXT 0x88F1 + +#define GLEW_EXT_packed_depth_stencil GLEW_GET_VAR(__GLEW_EXT_packed_depth_stencil) + +#endif /* GL_EXT_packed_depth_stencil */ + +/* -------------------------- GL_EXT_packed_float -------------------------- */ + +#ifndef GL_EXT_packed_float +#define GL_EXT_packed_float 1 + +#define GL_R11F_G11F_B10F_EXT 0x8C3A +#define GL_UNSIGNED_INT_10F_11F_11F_REV_EXT 0x8C3B +#define GL_RGBA_SIGNED_COMPONENTS_EXT 0x8C3C + +#define GLEW_EXT_packed_float GLEW_GET_VAR(__GLEW_EXT_packed_float) + +#endif /* GL_EXT_packed_float */ + +/* -------------------------- GL_EXT_packed_pixels ------------------------- */ + +#ifndef GL_EXT_packed_pixels +#define GL_EXT_packed_pixels 1 + +#define GL_UNSIGNED_BYTE_3_3_2_EXT 0x8032 +#define GL_UNSIGNED_SHORT_4_4_4_4_EXT 0x8033 +#define GL_UNSIGNED_SHORT_5_5_5_1_EXT 0x8034 +#define GL_UNSIGNED_INT_8_8_8_8_EXT 0x8035 +#define GL_UNSIGNED_INT_10_10_10_2_EXT 0x8036 + +#define GLEW_EXT_packed_pixels GLEW_GET_VAR(__GLEW_EXT_packed_pixels) + +#endif /* GL_EXT_packed_pixels */ + +/* ------------------------ GL_EXT_paletted_texture ------------------------ */ + +#ifndef GL_EXT_paletted_texture +#define GL_EXT_paletted_texture 1 + +#define GL_TEXTURE_1D 0x0DE0 +#define GL_TEXTURE_2D 0x0DE1 +#define GL_PROXY_TEXTURE_1D 0x8063 +#define GL_PROXY_TEXTURE_2D 0x8064 +#define GL_TEXTURE_3D_EXT 0x806F +#define GL_PROXY_TEXTURE_3D_EXT 0x8070 +#define GL_COLOR_TABLE_FORMAT_EXT 0x80D8 +#define GL_COLOR_TABLE_WIDTH_EXT 0x80D9 +#define GL_COLOR_TABLE_RED_SIZE_EXT 0x80DA +#define GL_COLOR_TABLE_GREEN_SIZE_EXT 0x80DB +#define GL_COLOR_TABLE_BLUE_SIZE_EXT 0x80DC +#define GL_COLOR_TABLE_ALPHA_SIZE_EXT 0x80DD +#define GL_COLOR_TABLE_LUMINANCE_SIZE_EXT 0x80DE +#define GL_COLOR_TABLE_INTENSITY_SIZE_EXT 0x80DF +#define GL_COLOR_INDEX1_EXT 0x80E2 +#define GL_COLOR_INDEX2_EXT 0x80E3 +#define GL_COLOR_INDEX4_EXT 0x80E4 +#define GL_COLOR_INDEX8_EXT 0x80E5 +#define GL_COLOR_INDEX12_EXT 0x80E6 +#define GL_COLOR_INDEX16_EXT 0x80E7 +#define GL_TEXTURE_INDEX_SIZE_EXT 0x80ED +#define GL_TEXTURE_CUBE_MAP_ARB 0x8513 +#define GL_PROXY_TEXTURE_CUBE_MAP_ARB 0x851B + +typedef void (GLAPIENTRY * PFNGLCOLORTABLEEXTPROC) (GLenum target, GLenum internalFormat, GLsizei width, GLenum format, GLenum type, const void* data); +typedef void (GLAPIENTRY * PFNGLGETCOLORTABLEEXTPROC) (GLenum target, GLenum format, GLenum type, void* data); +typedef void (GLAPIENTRY * PFNGLGETCOLORTABLEPARAMETERFVEXTPROC) (GLenum target, GLenum pname, GLfloat* params); +typedef void (GLAPIENTRY * PFNGLGETCOLORTABLEPARAMETERIVEXTPROC) (GLenum target, GLenum pname, GLint* params); + +#define glColorTableEXT GLEW_GET_FUN(__glewColorTableEXT) +#define glGetColorTableEXT GLEW_GET_FUN(__glewGetColorTableEXT) +#define glGetColorTableParameterfvEXT GLEW_GET_FUN(__glewGetColorTableParameterfvEXT) +#define glGetColorTableParameterivEXT GLEW_GET_FUN(__glewGetColorTableParameterivEXT) + +#define GLEW_EXT_paletted_texture GLEW_GET_VAR(__GLEW_EXT_paletted_texture) + +#endif /* GL_EXT_paletted_texture */ + +/* ----------------------- GL_EXT_pixel_buffer_object ---------------------- */ + +#ifndef GL_EXT_pixel_buffer_object +#define GL_EXT_pixel_buffer_object 1 + +#define GL_PIXEL_PACK_BUFFER_EXT 0x88EB +#define GL_PIXEL_UNPACK_BUFFER_EXT 0x88EC +#define GL_PIXEL_PACK_BUFFER_BINDING_EXT 0x88ED +#define GL_PIXEL_UNPACK_BUFFER_BINDING_EXT 0x88EF + +#define GLEW_EXT_pixel_buffer_object GLEW_GET_VAR(__GLEW_EXT_pixel_buffer_object) + +#endif /* GL_EXT_pixel_buffer_object */ + +/* ------------------------- GL_EXT_pixel_transform ------------------------ */ + +#ifndef GL_EXT_pixel_transform +#define GL_EXT_pixel_transform 1 + +#define GL_PIXEL_TRANSFORM_2D_EXT 0x8330 +#define GL_PIXEL_MAG_FILTER_EXT 0x8331 +#define GL_PIXEL_MIN_FILTER_EXT 0x8332 +#define GL_PIXEL_CUBIC_WEIGHT_EXT 0x8333 +#define GL_CUBIC_EXT 0x8334 +#define GL_AVERAGE_EXT 0x8335 +#define GL_PIXEL_TRANSFORM_2D_STACK_DEPTH_EXT 0x8336 +#define GL_MAX_PIXEL_TRANSFORM_2D_STACK_DEPTH_EXT 0x8337 +#define GL_PIXEL_TRANSFORM_2D_MATRIX_EXT 0x8338 + +typedef void (GLAPIENTRY * PFNGLGETPIXELTRANSFORMPARAMETERFVEXTPROC) (GLenum target, GLenum pname, const GLfloat* params); +typedef void (GLAPIENTRY * PFNGLGETPIXELTRANSFORMPARAMETERIVEXTPROC) (GLenum target, GLenum pname, const GLint* params); +typedef void (GLAPIENTRY * PFNGLPIXELTRANSFORMPARAMETERFEXTPROC) (GLenum target, GLenum pname, const GLfloat param); +typedef void (GLAPIENTRY * PFNGLPIXELTRANSFORMPARAMETERFVEXTPROC) (GLenum target, GLenum pname, const GLfloat* params); +typedef void (GLAPIENTRY * PFNGLPIXELTRANSFORMPARAMETERIEXTPROC) (GLenum target, GLenum pname, const GLint param); +typedef void (GLAPIENTRY * PFNGLPIXELTRANSFORMPARAMETERIVEXTPROC) (GLenum target, GLenum pname, const GLint* params); + +#define glGetPixelTransformParameterfvEXT GLEW_GET_FUN(__glewGetPixelTransformParameterfvEXT) +#define glGetPixelTransformParameterivEXT GLEW_GET_FUN(__glewGetPixelTransformParameterivEXT) +#define glPixelTransformParameterfEXT GLEW_GET_FUN(__glewPixelTransformParameterfEXT) +#define glPixelTransformParameterfvEXT GLEW_GET_FUN(__glewPixelTransformParameterfvEXT) +#define glPixelTransformParameteriEXT GLEW_GET_FUN(__glewPixelTransformParameteriEXT) +#define glPixelTransformParameterivEXT GLEW_GET_FUN(__glewPixelTransformParameterivEXT) + +#define GLEW_EXT_pixel_transform GLEW_GET_VAR(__GLEW_EXT_pixel_transform) + +#endif /* GL_EXT_pixel_transform */ + +/* ------------------- GL_EXT_pixel_transform_color_table ------------------ */ + +#ifndef GL_EXT_pixel_transform_color_table +#define GL_EXT_pixel_transform_color_table 1 + +#define GLEW_EXT_pixel_transform_color_table GLEW_GET_VAR(__GLEW_EXT_pixel_transform_color_table) + +#endif /* GL_EXT_pixel_transform_color_table */ + +/* ------------------------ GL_EXT_point_parameters ------------------------ */ + +#ifndef GL_EXT_point_parameters +#define GL_EXT_point_parameters 1 + +#define GL_POINT_SIZE_MIN_EXT 0x8126 +#define GL_POINT_SIZE_MAX_EXT 0x8127 +#define GL_POINT_FADE_THRESHOLD_SIZE_EXT 0x8128 +#define GL_DISTANCE_ATTENUATION_EXT 0x8129 + +typedef void (GLAPIENTRY * PFNGLPOINTPARAMETERFEXTPROC) (GLenum pname, GLfloat param); +typedef void (GLAPIENTRY * PFNGLPOINTPARAMETERFVEXTPROC) (GLenum pname, GLfloat* params); + +#define glPointParameterfEXT GLEW_GET_FUN(__glewPointParameterfEXT) +#define glPointParameterfvEXT GLEW_GET_FUN(__glewPointParameterfvEXT) + +#define GLEW_EXT_point_parameters GLEW_GET_VAR(__GLEW_EXT_point_parameters) + +#endif /* GL_EXT_point_parameters */ + +/* ------------------------- GL_EXT_polygon_offset ------------------------- */ + +#ifndef GL_EXT_polygon_offset +#define GL_EXT_polygon_offset 1 + +#define GL_POLYGON_OFFSET_EXT 0x8037 +#define GL_POLYGON_OFFSET_FACTOR_EXT 0x8038 +#define GL_POLYGON_OFFSET_BIAS_EXT 0x8039 + +typedef void (GLAPIENTRY * PFNGLPOLYGONOFFSETEXTPROC) (GLfloat factor, GLfloat bias); + +#define glPolygonOffsetEXT GLEW_GET_FUN(__glewPolygonOffsetEXT) + +#define GLEW_EXT_polygon_offset GLEW_GET_VAR(__GLEW_EXT_polygon_offset) + +#endif /* GL_EXT_polygon_offset */ + +/* ------------------------- GL_EXT_rescale_normal ------------------------- */ + +#ifndef GL_EXT_rescale_normal +#define GL_EXT_rescale_normal 1 + +#define GL_RESCALE_NORMAL_EXT 0x803A + +#define GLEW_EXT_rescale_normal GLEW_GET_VAR(__GLEW_EXT_rescale_normal) + +#endif /* GL_EXT_rescale_normal */ + +/* -------------------------- GL_EXT_scene_marker -------------------------- */ + +#ifndef GL_EXT_scene_marker +#define GL_EXT_scene_marker 1 + +typedef void (GLAPIENTRY * PFNGLBEGINSCENEEXTPROC) (void); +typedef void (GLAPIENTRY * PFNGLENDSCENEEXTPROC) (void); + +#define glBeginSceneEXT GLEW_GET_FUN(__glewBeginSceneEXT) +#define glEndSceneEXT GLEW_GET_FUN(__glewEndSceneEXT) + +#define GLEW_EXT_scene_marker GLEW_GET_VAR(__GLEW_EXT_scene_marker) + +#endif /* GL_EXT_scene_marker */ + +/* ------------------------- GL_EXT_secondary_color ------------------------ */ + +#ifndef GL_EXT_secondary_color +#define GL_EXT_secondary_color 1 + +#define GL_COLOR_SUM_EXT 0x8458 +#define GL_CURRENT_SECONDARY_COLOR_EXT 0x8459 +#define GL_SECONDARY_COLOR_ARRAY_SIZE_EXT 0x845A +#define GL_SECONDARY_COLOR_ARRAY_TYPE_EXT 0x845B +#define GL_SECONDARY_COLOR_ARRAY_STRIDE_EXT 0x845C +#define GL_SECONDARY_COLOR_ARRAY_POINTER_EXT 0x845D +#define GL_SECONDARY_COLOR_ARRAY_EXT 0x845E + +typedef void (GLAPIENTRY * PFNGLSECONDARYCOLOR3BEXTPROC) (GLbyte red, GLbyte green, GLbyte blue); +typedef void (GLAPIENTRY * PFNGLSECONDARYCOLOR3BVEXTPROC) (const GLbyte *v); +typedef void (GLAPIENTRY * PFNGLSECONDARYCOLOR3DEXTPROC) (GLdouble red, GLdouble green, GLdouble blue); +typedef void (GLAPIENTRY * PFNGLSECONDARYCOLOR3DVEXTPROC) (const GLdouble *v); +typedef void (GLAPIENTRY * PFNGLSECONDARYCOLOR3FEXTPROC) (GLfloat red, GLfloat green, GLfloat blue); +typedef void (GLAPIENTRY * PFNGLSECONDARYCOLOR3FVEXTPROC) (const GLfloat *v); +typedef void (GLAPIENTRY * PFNGLSECONDARYCOLOR3IEXTPROC) (GLint red, GLint green, GLint blue); +typedef void (GLAPIENTRY * PFNGLSECONDARYCOLOR3IVEXTPROC) (const GLint *v); +typedef void (GLAPIENTRY * PFNGLSECONDARYCOLOR3SEXTPROC) (GLshort red, GLshort green, GLshort blue); +typedef void (GLAPIENTRY * PFNGLSECONDARYCOLOR3SVEXTPROC) (const GLshort *v); +typedef void (GLAPIENTRY * PFNGLSECONDARYCOLOR3UBEXTPROC) (GLubyte red, GLubyte green, GLubyte blue); +typedef void (GLAPIENTRY * PFNGLSECONDARYCOLOR3UBVEXTPROC) (const GLubyte *v); +typedef void (GLAPIENTRY * PFNGLSECONDARYCOLOR3UIEXTPROC) (GLuint red, GLuint green, GLuint blue); +typedef void (GLAPIENTRY * PFNGLSECONDARYCOLOR3UIVEXTPROC) (const GLuint *v); +typedef void (GLAPIENTRY * PFNGLSECONDARYCOLOR3USEXTPROC) (GLushort red, GLushort green, GLushort blue); +typedef void (GLAPIENTRY * PFNGLSECONDARYCOLOR3USVEXTPROC) (const GLushort *v); +typedef void (GLAPIENTRY * PFNGLSECONDARYCOLORPOINTEREXTPROC) (GLint size, GLenum type, GLsizei stride, GLvoid *pointer); + +#define glSecondaryColor3bEXT GLEW_GET_FUN(__glewSecondaryColor3bEXT) +#define glSecondaryColor3bvEXT GLEW_GET_FUN(__glewSecondaryColor3bvEXT) +#define glSecondaryColor3dEXT GLEW_GET_FUN(__glewSecondaryColor3dEXT) +#define glSecondaryColor3dvEXT GLEW_GET_FUN(__glewSecondaryColor3dvEXT) +#define glSecondaryColor3fEXT GLEW_GET_FUN(__glewSecondaryColor3fEXT) +#define glSecondaryColor3fvEXT GLEW_GET_FUN(__glewSecondaryColor3fvEXT) +#define glSecondaryColor3iEXT GLEW_GET_FUN(__glewSecondaryColor3iEXT) +#define glSecondaryColor3ivEXT GLEW_GET_FUN(__glewSecondaryColor3ivEXT) +#define glSecondaryColor3sEXT GLEW_GET_FUN(__glewSecondaryColor3sEXT) +#define glSecondaryColor3svEXT GLEW_GET_FUN(__glewSecondaryColor3svEXT) +#define glSecondaryColor3ubEXT GLEW_GET_FUN(__glewSecondaryColor3ubEXT) +#define glSecondaryColor3ubvEXT GLEW_GET_FUN(__glewSecondaryColor3ubvEXT) +#define glSecondaryColor3uiEXT GLEW_GET_FUN(__glewSecondaryColor3uiEXT) +#define glSecondaryColor3uivEXT GLEW_GET_FUN(__glewSecondaryColor3uivEXT) +#define glSecondaryColor3usEXT GLEW_GET_FUN(__glewSecondaryColor3usEXT) +#define glSecondaryColor3usvEXT GLEW_GET_FUN(__glewSecondaryColor3usvEXT) +#define glSecondaryColorPointerEXT GLEW_GET_FUN(__glewSecondaryColorPointerEXT) + +#define GLEW_EXT_secondary_color GLEW_GET_VAR(__GLEW_EXT_secondary_color) + +#endif /* GL_EXT_secondary_color */ + +/* --------------------- GL_EXT_separate_specular_color -------------------- */ + +#ifndef GL_EXT_separate_specular_color +#define GL_EXT_separate_specular_color 1 + +#define GL_LIGHT_MODEL_COLOR_CONTROL_EXT 0x81F8 +#define GL_SINGLE_COLOR_EXT 0x81F9 +#define GL_SEPARATE_SPECULAR_COLOR_EXT 0x81FA + +#define GLEW_EXT_separate_specular_color GLEW_GET_VAR(__GLEW_EXT_separate_specular_color) + +#endif /* GL_EXT_separate_specular_color */ + +/* -------------------------- GL_EXT_shadow_funcs -------------------------- */ + +#ifndef GL_EXT_shadow_funcs +#define GL_EXT_shadow_funcs 1 + +#define GLEW_EXT_shadow_funcs GLEW_GET_VAR(__GLEW_EXT_shadow_funcs) + +#endif /* GL_EXT_shadow_funcs */ + +/* --------------------- GL_EXT_shared_texture_palette --------------------- */ + +#ifndef GL_EXT_shared_texture_palette +#define GL_EXT_shared_texture_palette 1 + +#define GL_SHARED_TEXTURE_PALETTE_EXT 0x81FB + +#define GLEW_EXT_shared_texture_palette GLEW_GET_VAR(__GLEW_EXT_shared_texture_palette) + +#endif /* GL_EXT_shared_texture_palette */ + +/* ------------------------ GL_EXT_stencil_clear_tag ----------------------- */ + +#ifndef GL_EXT_stencil_clear_tag +#define GL_EXT_stencil_clear_tag 1 + +#define GL_STENCIL_TAG_BITS_EXT 0x88F2 +#define GL_STENCIL_CLEAR_TAG_VALUE_EXT 0x88F3 + +#define GLEW_EXT_stencil_clear_tag GLEW_GET_VAR(__GLEW_EXT_stencil_clear_tag) + +#endif /* GL_EXT_stencil_clear_tag */ + +/* ------------------------ GL_EXT_stencil_two_side ------------------------ */ + +#ifndef GL_EXT_stencil_two_side +#define GL_EXT_stencil_two_side 1 + +#define GL_STENCIL_TEST_TWO_SIDE_EXT 0x8910 +#define GL_ACTIVE_STENCIL_FACE_EXT 0x8911 + +typedef void (GLAPIENTRY * PFNGLACTIVESTENCILFACEEXTPROC) (GLenum face); + +#define glActiveStencilFaceEXT GLEW_GET_FUN(__glewActiveStencilFaceEXT) + +#define GLEW_EXT_stencil_two_side GLEW_GET_VAR(__GLEW_EXT_stencil_two_side) + +#endif /* GL_EXT_stencil_two_side */ + +/* -------------------------- GL_EXT_stencil_wrap -------------------------- */ + +#ifndef GL_EXT_stencil_wrap +#define GL_EXT_stencil_wrap 1 + +#define GL_INCR_WRAP_EXT 0x8507 +#define GL_DECR_WRAP_EXT 0x8508 + +#define GLEW_EXT_stencil_wrap GLEW_GET_VAR(__GLEW_EXT_stencil_wrap) + +#endif /* GL_EXT_stencil_wrap */ + +/* --------------------------- GL_EXT_subtexture --------------------------- */ + +#ifndef GL_EXT_subtexture +#define GL_EXT_subtexture 1 + +typedef void (GLAPIENTRY * PFNGLTEXSUBIMAGE1DEXTPROC) (GLenum target, GLint level, GLint xoffset, GLsizei width, GLenum format, GLenum type, const void* pixels); +typedef void (GLAPIENTRY * PFNGLTEXSUBIMAGE2DEXTPROC) (GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLenum type, const void* pixels); +typedef void (GLAPIENTRY * PFNGLTEXSUBIMAGE3DEXTPROC) (GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLenum type, const void* pixels); + +#define glTexSubImage1DEXT GLEW_GET_FUN(__glewTexSubImage1DEXT) +#define glTexSubImage2DEXT GLEW_GET_FUN(__glewTexSubImage2DEXT) +#define glTexSubImage3DEXT GLEW_GET_FUN(__glewTexSubImage3DEXT) + +#define GLEW_EXT_subtexture GLEW_GET_VAR(__GLEW_EXT_subtexture) + +#endif /* GL_EXT_subtexture */ + +/* ----------------------------- GL_EXT_texture ---------------------------- */ + +#ifndef GL_EXT_texture +#define GL_EXT_texture 1 + +#define GL_ALPHA4_EXT 0x803B +#define GL_ALPHA8_EXT 0x803C +#define GL_ALPHA12_EXT 0x803D +#define GL_ALPHA16_EXT 0x803E +#define GL_LUMINANCE4_EXT 0x803F +#define GL_LUMINANCE8_EXT 0x8040 +#define GL_LUMINANCE12_EXT 0x8041 +#define GL_LUMINANCE16_EXT 0x8042 +#define GL_LUMINANCE4_ALPHA4_EXT 0x8043 +#define GL_LUMINANCE6_ALPHA2_EXT 0x8044 +#define GL_LUMINANCE8_ALPHA8_EXT 0x8045 +#define GL_LUMINANCE12_ALPHA4_EXT 0x8046 +#define GL_LUMINANCE12_ALPHA12_EXT 0x8047 +#define GL_LUMINANCE16_ALPHA16_EXT 0x8048 +#define GL_INTENSITY_EXT 0x8049 +#define GL_INTENSITY4_EXT 0x804A +#define GL_INTENSITY8_EXT 0x804B +#define GL_INTENSITY12_EXT 0x804C +#define GL_INTENSITY16_EXT 0x804D +#define GL_RGB2_EXT 0x804E +#define GL_RGB4_EXT 0x804F +#define GL_RGB5_EXT 0x8050 +#define GL_RGB8_EXT 0x8051 +#define GL_RGB10_EXT 0x8052 +#define GL_RGB12_EXT 0x8053 +#define GL_RGB16_EXT 0x8054 +#define GL_RGBA2_EXT 0x8055 +#define GL_RGBA4_EXT 0x8056 +#define GL_RGB5_A1_EXT 0x8057 +#define GL_RGBA8_EXT 0x8058 +#define GL_RGB10_A2_EXT 0x8059 +#define GL_RGBA12_EXT 0x805A +#define GL_RGBA16_EXT 0x805B +#define GL_TEXTURE_RED_SIZE_EXT 0x805C +#define GL_TEXTURE_GREEN_SIZE_EXT 0x805D +#define GL_TEXTURE_BLUE_SIZE_EXT 0x805E +#define GL_TEXTURE_ALPHA_SIZE_EXT 0x805F +#define GL_TEXTURE_LUMINANCE_SIZE_EXT 0x8060 +#define GL_TEXTURE_INTENSITY_SIZE_EXT 0x8061 +#define GL_REPLACE_EXT 0x8062 +#define GL_PROXY_TEXTURE_1D_EXT 0x8063 +#define GL_PROXY_TEXTURE_2D_EXT 0x8064 + +#define GLEW_EXT_texture GLEW_GET_VAR(__GLEW_EXT_texture) + +#endif /* GL_EXT_texture */ + +/* ---------------------------- GL_EXT_texture3D --------------------------- */ + +#ifndef GL_EXT_texture3D +#define GL_EXT_texture3D 1 + +#define GL_PACK_SKIP_IMAGES_EXT 0x806B +#define GL_PACK_IMAGE_HEIGHT_EXT 0x806C +#define GL_UNPACK_SKIP_IMAGES_EXT 0x806D +#define GL_UNPACK_IMAGE_HEIGHT_EXT 0x806E +#define GL_TEXTURE_3D_EXT 0x806F +#define GL_PROXY_TEXTURE_3D_EXT 0x8070 +#define GL_TEXTURE_DEPTH_EXT 0x8071 +#define GL_TEXTURE_WRAP_R_EXT 0x8072 +#define GL_MAX_3D_TEXTURE_SIZE_EXT 0x8073 + +typedef void (GLAPIENTRY * PFNGLTEXIMAGE3DEXTPROC) (GLenum target, GLint level, GLenum internalformat, GLsizei width, GLsizei height, GLsizei depth, GLint border, GLenum format, GLenum type, const void* pixels); + +#define glTexImage3DEXT GLEW_GET_FUN(__glewTexImage3DEXT) + +#define GLEW_EXT_texture3D GLEW_GET_VAR(__GLEW_EXT_texture3D) + +#endif /* GL_EXT_texture3D */ + +/* -------------------------- GL_EXT_texture_array ------------------------- */ + +#ifndef GL_EXT_texture_array +#define GL_EXT_texture_array 1 + +#define GL_COMPARE_REF_DEPTH_TO_TEXTURE_EXT 0x884E +#define GL_MAX_ARRAY_TEXTURE_LAYERS_EXT 0x88FF +#define GL_TEXTURE_1D_ARRAY_EXT 0x8C18 +#define GL_PROXY_TEXTURE_1D_ARRAY_EXT 0x8C19 +#define GL_TEXTURE_2D_ARRAY_EXT 0x8C1A +#define GL_PROXY_TEXTURE_2D_ARRAY_EXT 0x8C1B +#define GL_TEXTURE_BINDING_1D_ARRAY_EXT 0x8C1C +#define GL_TEXTURE_BINDING_2D_ARRAY_EXT 0x8C1D + +#define GLEW_EXT_texture_array GLEW_GET_VAR(__GLEW_EXT_texture_array) + +#endif /* GL_EXT_texture_array */ + +/* ---------------------- GL_EXT_texture_buffer_object --------------------- */ + +#ifndef GL_EXT_texture_buffer_object +#define GL_EXT_texture_buffer_object 1 + +#define GL_TEXTURE_BUFFER_EXT 0x8C2A +#define GL_MAX_TEXTURE_BUFFER_SIZE_EXT 0x8C2B +#define GL_TEXTURE_BINDING_BUFFER_EXT 0x8C2C +#define GL_TEXTURE_BUFFER_DATA_STORE_BINDING_EXT 0x8C2D +#define GL_TEXTURE_BUFFER_FORMAT_EXT 0x8C2E + +typedef void (GLAPIENTRY * PFNGLTEXBUFFEREXTPROC) (GLenum target, GLenum internalformat, GLuint buffer); + +#define glTexBufferEXT GLEW_GET_FUN(__glewTexBufferEXT) + +#define GLEW_EXT_texture_buffer_object GLEW_GET_VAR(__GLEW_EXT_texture_buffer_object) + +#endif /* GL_EXT_texture_buffer_object */ + +/* -------------------- GL_EXT_texture_compression_dxt1 -------------------- */ + +#ifndef GL_EXT_texture_compression_dxt1 +#define GL_EXT_texture_compression_dxt1 1 + +#define GL_COMPRESSED_RGB_S3TC_DXT1_EXT 0x83F0 +#define GL_COMPRESSED_RGBA_S3TC_DXT1_EXT 0x83F1 + +#define GLEW_EXT_texture_compression_dxt1 GLEW_GET_VAR(__GLEW_EXT_texture_compression_dxt1) + +#endif /* GL_EXT_texture_compression_dxt1 */ + +/* -------------------- GL_EXT_texture_compression_latc -------------------- */ + +#ifndef GL_EXT_texture_compression_latc +#define GL_EXT_texture_compression_latc 1 + +#define GL_COMPRESSED_LUMINANCE_LATC1_EXT 0x8C70 +#define GL_COMPRESSED_SIGNED_LUMINANCE_LATC1_EXT 0x8C71 +#define GL_COMPRESSED_LUMINANCE_ALPHA_LATC2_EXT 0x8C72 +#define GL_COMPRESSED_SIGNED_LUMINANCE_ALPHA_LATC2_EXT 0x8C73 + +#define GLEW_EXT_texture_compression_latc GLEW_GET_VAR(__GLEW_EXT_texture_compression_latc) + +#endif /* GL_EXT_texture_compression_latc */ + +/* -------------------- GL_EXT_texture_compression_rgtc -------------------- */ + +#ifndef GL_EXT_texture_compression_rgtc +#define GL_EXT_texture_compression_rgtc 1 + +#define GL_COMPRESSED_RED_RGTC1_EXT 0x8DBB +#define GL_COMPRESSED_SIGNED_RED_RGTC1_EXT 0x8DBC +#define GL_COMPRESSED_RED_GREEN_RGTC2_EXT 0x8DBD +#define GL_COMPRESSED_SIGNED_RED_GREEN_RGTC2_EXT 0x8DBE + +#define GLEW_EXT_texture_compression_rgtc GLEW_GET_VAR(__GLEW_EXT_texture_compression_rgtc) + +#endif /* GL_EXT_texture_compression_rgtc */ + +/* -------------------- GL_EXT_texture_compression_s3tc -------------------- */ + +#ifndef GL_EXT_texture_compression_s3tc +#define GL_EXT_texture_compression_s3tc 1 + +#define GL_COMPRESSED_RGB_S3TC_DXT1_EXT 0x83F0 +#define GL_COMPRESSED_RGBA_S3TC_DXT1_EXT 0x83F1 +#define GL_COMPRESSED_RGBA_S3TC_DXT3_EXT 0x83F2 +#define GL_COMPRESSED_RGBA_S3TC_DXT5_EXT 0x83F3 + +#define GLEW_EXT_texture_compression_s3tc GLEW_GET_VAR(__GLEW_EXT_texture_compression_s3tc) + +#endif /* GL_EXT_texture_compression_s3tc */ + +/* ------------------------ GL_EXT_texture_cube_map ------------------------ */ + +#ifndef GL_EXT_texture_cube_map +#define GL_EXT_texture_cube_map 1 + +#define GL_NORMAL_MAP_EXT 0x8511 +#define GL_REFLECTION_MAP_EXT 0x8512 +#define GL_TEXTURE_CUBE_MAP_EXT 0x8513 +#define GL_TEXTURE_BINDING_CUBE_MAP_EXT 0x8514 +#define GL_TEXTURE_CUBE_MAP_POSITIVE_X_EXT 0x8515 +#define GL_TEXTURE_CUBE_MAP_NEGATIVE_X_EXT 0x8516 +#define GL_TEXTURE_CUBE_MAP_POSITIVE_Y_EXT 0x8517 +#define GL_TEXTURE_CUBE_MAP_NEGATIVE_Y_EXT 0x8518 +#define GL_TEXTURE_CUBE_MAP_POSITIVE_Z_EXT 0x8519 +#define GL_TEXTURE_CUBE_MAP_NEGATIVE_Z_EXT 0x851A +#define GL_PROXY_TEXTURE_CUBE_MAP_EXT 0x851B +#define GL_MAX_CUBE_MAP_TEXTURE_SIZE_EXT 0x851C + +#define GLEW_EXT_texture_cube_map GLEW_GET_VAR(__GLEW_EXT_texture_cube_map) + +#endif /* GL_EXT_texture_cube_map */ + +/* ----------------------- GL_EXT_texture_edge_clamp ----------------------- */ + +#ifndef GL_EXT_texture_edge_clamp +#define GL_EXT_texture_edge_clamp 1 + +#define GL_CLAMP_TO_EDGE_EXT 0x812F + +#define GLEW_EXT_texture_edge_clamp GLEW_GET_VAR(__GLEW_EXT_texture_edge_clamp) + +#endif /* GL_EXT_texture_edge_clamp */ + +/* --------------------------- GL_EXT_texture_env -------------------------- */ + +#ifndef GL_EXT_texture_env +#define GL_EXT_texture_env 1 + +#define GL_TEXTURE_ENV0_EXT 0 +#define GL_ENV_BLEND_EXT 0 +#define GL_TEXTURE_ENV_SHIFT_EXT 0 +#define GL_ENV_REPLACE_EXT 0 +#define GL_ENV_ADD_EXT 0 +#define GL_ENV_SUBTRACT_EXT 0 +#define GL_TEXTURE_ENV_MODE_ALPHA_EXT 0 +#define GL_ENV_REVERSE_SUBTRACT_EXT 0 +#define GL_ENV_REVERSE_BLEND_EXT 0 +#define GL_ENV_COPY_EXT 0 +#define GL_ENV_MODULATE_EXT 0 + +#define GLEW_EXT_texture_env GLEW_GET_VAR(__GLEW_EXT_texture_env) + +#endif /* GL_EXT_texture_env */ + +/* ------------------------- GL_EXT_texture_env_add ------------------------ */ + +#ifndef GL_EXT_texture_env_add +#define GL_EXT_texture_env_add 1 + +#define GLEW_EXT_texture_env_add GLEW_GET_VAR(__GLEW_EXT_texture_env_add) + +#endif /* GL_EXT_texture_env_add */ + +/* ----------------------- GL_EXT_texture_env_combine ---------------------- */ + +#ifndef GL_EXT_texture_env_combine +#define GL_EXT_texture_env_combine 1 + +#define GL_COMBINE_EXT 0x8570 +#define GL_COMBINE_RGB_EXT 0x8571 +#define GL_COMBINE_ALPHA_EXT 0x8572 +#define GL_RGB_SCALE_EXT 0x8573 +#define GL_ADD_SIGNED_EXT 0x8574 +#define GL_INTERPOLATE_EXT 0x8575 +#define GL_CONSTANT_EXT 0x8576 +#define GL_PRIMARY_COLOR_EXT 0x8577 +#define GL_PREVIOUS_EXT 0x8578 +#define GL_SOURCE0_RGB_EXT 0x8580 +#define GL_SOURCE1_RGB_EXT 0x8581 +#define GL_SOURCE2_RGB_EXT 0x8582 +#define GL_SOURCE0_ALPHA_EXT 0x8588 +#define GL_SOURCE1_ALPHA_EXT 0x8589 +#define GL_SOURCE2_ALPHA_EXT 0x858A +#define GL_OPERAND0_RGB_EXT 0x8590 +#define GL_OPERAND1_RGB_EXT 0x8591 +#define GL_OPERAND2_RGB_EXT 0x8592 +#define GL_OPERAND0_ALPHA_EXT 0x8598 +#define GL_OPERAND1_ALPHA_EXT 0x8599 +#define GL_OPERAND2_ALPHA_EXT 0x859A + +#define GLEW_EXT_texture_env_combine GLEW_GET_VAR(__GLEW_EXT_texture_env_combine) + +#endif /* GL_EXT_texture_env_combine */ + +/* ------------------------ GL_EXT_texture_env_dot3 ------------------------ */ + +#ifndef GL_EXT_texture_env_dot3 +#define GL_EXT_texture_env_dot3 1 + +#define GL_DOT3_RGB_EXT 0x8740 +#define GL_DOT3_RGBA_EXT 0x8741 + +#define GLEW_EXT_texture_env_dot3 GLEW_GET_VAR(__GLEW_EXT_texture_env_dot3) + +#endif /* GL_EXT_texture_env_dot3 */ + +/* ------------------- GL_EXT_texture_filter_anisotropic ------------------- */ + +#ifndef GL_EXT_texture_filter_anisotropic +#define GL_EXT_texture_filter_anisotropic 1 + +#define GL_TEXTURE_MAX_ANISOTROPY_EXT 0x84FE +#define GL_MAX_TEXTURE_MAX_ANISOTROPY_EXT 0x84FF + +#define GLEW_EXT_texture_filter_anisotropic GLEW_GET_VAR(__GLEW_EXT_texture_filter_anisotropic) + +#endif /* GL_EXT_texture_filter_anisotropic */ + +/* ------------------------- GL_EXT_texture_integer ------------------------ */ + +#ifndef GL_EXT_texture_integer +#define GL_EXT_texture_integer 1 + +#define GL_RGBA32UI_EXT 0x8D70 +#define GL_RGB32UI_EXT 0x8D71 +#define GL_ALPHA32UI_EXT 0x8D72 +#define GL_INTENSITY32UI_EXT 0x8D73 +#define GL_LUMINANCE32UI_EXT 0x8D74 +#define GL_LUMINANCE_ALPHA32UI_EXT 0x8D75 +#define GL_RGBA16UI_EXT 0x8D76 +#define GL_RGB16UI_EXT 0x8D77 +#define GL_ALPHA16UI_EXT 0x8D78 +#define GL_INTENSITY16UI_EXT 0x8D79 +#define GL_LUMINANCE16UI_EXT 0x8D7A +#define GL_LUMINANCE_ALPHA16UI_EXT 0x8D7B +#define GL_RGBA8UI_EXT 0x8D7C +#define GL_RGB8UI_EXT 0x8D7D +#define GL_ALPHA8UI_EXT 0x8D7E +#define GL_INTENSITY8UI_EXT 0x8D7F +#define GL_LUMINANCE8UI_EXT 0x8D80 +#define GL_LUMINANCE_ALPHA8UI_EXT 0x8D81 +#define GL_RGBA32I_EXT 0x8D82 +#define GL_RGB32I_EXT 0x8D83 +#define GL_ALPHA32I_EXT 0x8D84 +#define GL_INTENSITY32I_EXT 0x8D85 +#define GL_LUMINANCE32I_EXT 0x8D86 +#define GL_LUMINANCE_ALPHA32I_EXT 0x8D87 +#define GL_RGBA16I_EXT 0x8D88 +#define GL_RGB16I_EXT 0x8D89 +#define GL_ALPHA16I_EXT 0x8D8A +#define GL_INTENSITY16I_EXT 0x8D8B +#define GL_LUMINANCE16I_EXT 0x8D8C +#define GL_LUMINANCE_ALPHA16I_EXT 0x8D8D +#define GL_RGBA8I_EXT 0x8D8E +#define GL_RGB8I_EXT 0x8D8F +#define GL_ALPHA8I_EXT 0x8D90 +#define GL_INTENSITY8I_EXT 0x8D91 +#define GL_LUMINANCE8I_EXT 0x8D92 +#define GL_LUMINANCE_ALPHA8I_EXT 0x8D93 +#define GL_RED_INTEGER_EXT 0x8D94 +#define GL_GREEN_INTEGER_EXT 0x8D95 +#define GL_BLUE_INTEGER_EXT 0x8D96 +#define GL_ALPHA_INTEGER_EXT 0x8D97 +#define GL_RGB_INTEGER_EXT 0x8D98 +#define GL_RGBA_INTEGER_EXT 0x8D99 +#define GL_BGR_INTEGER_EXT 0x8D9A +#define GL_BGRA_INTEGER_EXT 0x8D9B +#define GL_LUMINANCE_INTEGER_EXT 0x8D9C +#define GL_LUMINANCE_ALPHA_INTEGER_EXT 0x8D9D +#define GL_RGBA_INTEGER_MODE_EXT 0x8D9E + +typedef void (GLAPIENTRY * PFNGLCLEARCOLORIIEXTPROC) (GLint red, GLint green, GLint blue, GLint alpha); +typedef void (GLAPIENTRY * PFNGLCLEARCOLORIUIEXTPROC) (GLuint red, GLuint green, GLuint blue, GLuint alpha); +typedef void (GLAPIENTRY * PFNGLGETTEXPARAMETERIIVEXTPROC) (GLenum target, GLenum pname, GLint *params); +typedef void (GLAPIENTRY * PFNGLGETTEXPARAMETERIUIVEXTPROC) (GLenum target, GLenum pname, GLuint *params); +typedef void (GLAPIENTRY * PFNGLTEXPARAMETERIIVEXTPROC) (GLenum target, GLenum pname, const GLint *params); +typedef void (GLAPIENTRY * PFNGLTEXPARAMETERIUIVEXTPROC) (GLenum target, GLenum pname, const GLuint *params); + +#define glClearColorIiEXT GLEW_GET_FUN(__glewClearColorIiEXT) +#define glClearColorIuiEXT GLEW_GET_FUN(__glewClearColorIuiEXT) +#define glGetTexParameterIivEXT GLEW_GET_FUN(__glewGetTexParameterIivEXT) +#define glGetTexParameterIuivEXT GLEW_GET_FUN(__glewGetTexParameterIuivEXT) +#define glTexParameterIivEXT GLEW_GET_FUN(__glewTexParameterIivEXT) +#define glTexParameterIuivEXT GLEW_GET_FUN(__glewTexParameterIuivEXT) + +#define GLEW_EXT_texture_integer GLEW_GET_VAR(__GLEW_EXT_texture_integer) + +#endif /* GL_EXT_texture_integer */ + +/* ------------------------ GL_EXT_texture_lod_bias ------------------------ */ + +#ifndef GL_EXT_texture_lod_bias +#define GL_EXT_texture_lod_bias 1 + +#define GL_MAX_TEXTURE_LOD_BIAS_EXT 0x84FD +#define GL_TEXTURE_FILTER_CONTROL_EXT 0x8500 +#define GL_TEXTURE_LOD_BIAS_EXT 0x8501 + +#define GLEW_EXT_texture_lod_bias GLEW_GET_VAR(__GLEW_EXT_texture_lod_bias) + +#endif /* GL_EXT_texture_lod_bias */ + +/* ---------------------- GL_EXT_texture_mirror_clamp ---------------------- */ + +#ifndef GL_EXT_texture_mirror_clamp +#define GL_EXT_texture_mirror_clamp 1 + +#define GL_MIRROR_CLAMP_EXT 0x8742 +#define GL_MIRROR_CLAMP_TO_EDGE_EXT 0x8743 +#define GL_MIRROR_CLAMP_TO_BORDER_EXT 0x8912 + +#define GLEW_EXT_texture_mirror_clamp GLEW_GET_VAR(__GLEW_EXT_texture_mirror_clamp) + +#endif /* GL_EXT_texture_mirror_clamp */ + +/* ------------------------- GL_EXT_texture_object ------------------------- */ + +#ifndef GL_EXT_texture_object +#define GL_EXT_texture_object 1 + +#define GL_TEXTURE_PRIORITY_EXT 0x8066 +#define GL_TEXTURE_RESIDENT_EXT 0x8067 +#define GL_TEXTURE_1D_BINDING_EXT 0x8068 +#define GL_TEXTURE_2D_BINDING_EXT 0x8069 +#define GL_TEXTURE_3D_BINDING_EXT 0x806A + +typedef GLboolean (GLAPIENTRY * PFNGLARETEXTURESRESIDENTEXTPROC) (GLsizei n, const GLuint* textures, GLboolean* residences); +typedef void (GLAPIENTRY * PFNGLBINDTEXTUREEXTPROC) (GLenum target, GLuint texture); +typedef void (GLAPIENTRY * PFNGLDELETETEXTURESEXTPROC) (GLsizei n, const GLuint* textures); +typedef void (GLAPIENTRY * PFNGLGENTEXTURESEXTPROC) (GLsizei n, GLuint* textures); +typedef GLboolean (GLAPIENTRY * PFNGLISTEXTUREEXTPROC) (GLuint texture); +typedef void (GLAPIENTRY * PFNGLPRIORITIZETEXTURESEXTPROC) (GLsizei n, const GLuint* textures, const GLclampf* priorities); + +#define glAreTexturesResidentEXT GLEW_GET_FUN(__glewAreTexturesResidentEXT) +#define glBindTextureEXT GLEW_GET_FUN(__glewBindTextureEXT) +#define glDeleteTexturesEXT GLEW_GET_FUN(__glewDeleteTexturesEXT) +#define glGenTexturesEXT GLEW_GET_FUN(__glewGenTexturesEXT) +#define glIsTextureEXT GLEW_GET_FUN(__glewIsTextureEXT) +#define glPrioritizeTexturesEXT GLEW_GET_FUN(__glewPrioritizeTexturesEXT) + +#define GLEW_EXT_texture_object GLEW_GET_VAR(__GLEW_EXT_texture_object) + +#endif /* GL_EXT_texture_object */ + +/* --------------------- GL_EXT_texture_perturb_normal --------------------- */ + +#ifndef GL_EXT_texture_perturb_normal +#define GL_EXT_texture_perturb_normal 1 + +#define GL_PERTURB_EXT 0x85AE +#define GL_TEXTURE_NORMAL_EXT 0x85AF + +typedef void (GLAPIENTRY * PFNGLTEXTURENORMALEXTPROC) (GLenum mode); + +#define glTextureNormalEXT GLEW_GET_FUN(__glewTextureNormalEXT) + +#define GLEW_EXT_texture_perturb_normal GLEW_GET_VAR(__GLEW_EXT_texture_perturb_normal) + +#endif /* GL_EXT_texture_perturb_normal */ + +/* ------------------------ GL_EXT_texture_rectangle ----------------------- */ + +#ifndef GL_EXT_texture_rectangle +#define GL_EXT_texture_rectangle 1 + +#define GL_TEXTURE_RECTANGLE_EXT 0x84F5 +#define GL_TEXTURE_BINDING_RECTANGLE_EXT 0x84F6 +#define GL_PROXY_TEXTURE_RECTANGLE_EXT 0x84F7 +#define GL_MAX_RECTANGLE_TEXTURE_SIZE_EXT 0x84F8 + +#define GLEW_EXT_texture_rectangle GLEW_GET_VAR(__GLEW_EXT_texture_rectangle) + +#endif /* GL_EXT_texture_rectangle */ + +/* -------------------------- GL_EXT_texture_sRGB -------------------------- */ + +#ifndef GL_EXT_texture_sRGB +#define GL_EXT_texture_sRGB 1 + +#define GL_SRGB_EXT 0x8C40 +#define GL_SRGB8_EXT 0x8C41 +#define GL_SRGB_ALPHA_EXT 0x8C42 +#define GL_SRGB8_ALPHA8_EXT 0x8C43 +#define GL_SLUMINANCE_ALPHA_EXT 0x8C44 +#define GL_SLUMINANCE8_ALPHA8_EXT 0x8C45 +#define GL_SLUMINANCE_EXT 0x8C46 +#define GL_SLUMINANCE8_EXT 0x8C47 +#define GL_COMPRESSED_SRGB_EXT 0x8C48 +#define GL_COMPRESSED_SRGB_ALPHA_EXT 0x8C49 +#define GL_COMPRESSED_SLUMINANCE_EXT 0x8C4A +#define GL_COMPRESSED_SLUMINANCE_ALPHA_EXT 0x8C4B +#define GL_COMPRESSED_SRGB_S3TC_DXT1_EXT 0x8C4C +#define GL_COMPRESSED_SRGB_ALPHA_S3TC_DXT1_EXT 0x8C4D +#define GL_COMPRESSED_SRGB_ALPHA_S3TC_DXT3_EXT 0x8C4E +#define GL_COMPRESSED_SRGB_ALPHA_S3TC_DXT5_EXT 0x8C4F + +#define GLEW_EXT_texture_sRGB GLEW_GET_VAR(__GLEW_EXT_texture_sRGB) + +#endif /* GL_EXT_texture_sRGB */ + +/* --------------------- GL_EXT_texture_shared_exponent -------------------- */ + +#ifndef GL_EXT_texture_shared_exponent +#define GL_EXT_texture_shared_exponent 1 + +#define GL_RGB9_E5_EXT 0x8C3D +#define GL_UNSIGNED_INT_5_9_9_9_REV_EXT 0x8C3E +#define GL_TEXTURE_SHARED_SIZE_EXT 0x8C3F + +#define GLEW_EXT_texture_shared_exponent GLEW_GET_VAR(__GLEW_EXT_texture_shared_exponent) + +#endif /* GL_EXT_texture_shared_exponent */ + +/* ------------------------- GL_EXT_texture_swizzle ------------------------ */ + +#ifndef GL_EXT_texture_swizzle +#define GL_EXT_texture_swizzle 1 + +#define GL_TEXTURE_SWIZZLE_R_EXT 0x8E42 +#define GL_TEXTURE_SWIZZLE_G_EXT 0x8E43 +#define GL_TEXTURE_SWIZZLE_B_EXT 0x8E44 +#define GL_TEXTURE_SWIZZLE_A_EXT 0x8E45 +#define GL_TEXTURE_SWIZZLE_RGBA_EXT 0x8E46 + +#define GLEW_EXT_texture_swizzle GLEW_GET_VAR(__GLEW_EXT_texture_swizzle) + +#endif /* GL_EXT_texture_swizzle */ + +/* --------------------------- GL_EXT_timer_query -------------------------- */ + +#ifndef GL_EXT_timer_query +#define GL_EXT_timer_query 1 + +#define GL_TIME_ELAPSED_EXT 0x88BF + +//typedef void (GLAPIENTRY * PFNGLGETQUERYOBJECTI64VEXTPROC) (GLuint id, GLenum pname, GLint64EXT *params); +//typedef void (GLAPIENTRY * PFNGLGETQUERYOBJECTUI64VEXTPROC) (GLuint id, GLenum pname, GLuint64EXT *params); + +#define glGetQueryObjecti64vEXT GLEW_GET_FUN(__glewGetQueryObjecti64vEXT) +#define glGetQueryObjectui64vEXT GLEW_GET_FUN(__glewGetQueryObjectui64vEXT) + +#define GLEW_EXT_timer_query GLEW_GET_VAR(__GLEW_EXT_timer_query) + +#endif /* GL_EXT_timer_query */ + +/* ----------------------- GL_EXT_transform_feedback ----------------------- */ + +#ifndef GL_EXT_transform_feedback +#define GL_EXT_transform_feedback 1 + +#define GL_TRANSFORM_FEEDBACK_VARYING_MAX_LENGTH_EXT 0x8C76 +#define GL_TRANSFORM_FEEDBACK_BUFFER_MODE_EXT 0x8C7F +#define GL_MAX_TRANSFORM_FEEDBACK_SEPARATE_COMPONENTS_EXT 0x8C80 +#define GL_TRANSFORM_FEEDBACK_VARYINGS_EXT 0x8C83 +#define GL_TRANSFORM_FEEDBACK_BUFFER_START_EXT 0x8C84 +#define GL_TRANSFORM_FEEDBACK_BUFFER_SIZE_EXT 0x8C85 +#define GL_PRIMITIVES_GENERATED_EXT 0x8C87 +#define GL_TRANSFORM_FEEDBACK_PRIMITIVES_WRITTEN_EXT 0x8C88 +#define GL_RASTERIZER_DISCARD_EXT 0x8C89 +#define GL_MAX_TRANSFORM_FEEDBACK_INTERLEAVED_COMPONENTS_EXT 0x8C8A +#define GL_MAX_TRANSFORM_FEEDBACK_SEPARATE_ATTRIBS_EXT 0x8C8B +#define GL_INTERLEAVED_ATTRIBS_EXT 0x8C8C +#define GL_SEPARATE_ATTRIBS_EXT 0x8C8D +#define GL_TRANSFORM_FEEDBACK_BUFFER_EXT 0x8C8E +#define GL_TRANSFORM_FEEDBACK_BUFFER_BINDING_EXT 0x8C8F + +typedef void (GLAPIENTRY * PFNGLBEGINTRANSFORMFEEDBACKEXTPROC) (GLenum primitiveMode); +typedef void (GLAPIENTRY * PFNGLBINDBUFFERBASEEXTPROC) (GLenum target, GLuint index, GLuint buffer); +typedef void (GLAPIENTRY * PFNGLBINDBUFFEROFFSETEXTPROC) (GLenum target, GLuint index, GLuint buffer, GLintptr offset); +typedef void (GLAPIENTRY * PFNGLBINDBUFFERRANGEEXTPROC) (GLenum target, GLuint index, GLuint buffer, GLintptr offset, GLsizeiptr size); +typedef void (GLAPIENTRY * PFNGLENDTRANSFORMFEEDBACKEXTPROC) (void); +typedef void (GLAPIENTRY * PFNGLGETTRANSFORMFEEDBACKVARYINGEXTPROC) (GLuint program, GLuint index, GLsizei bufSize, GLsizei* length, GLsizei *size, GLenum *type, char *name); +typedef void (GLAPIENTRY * PFNGLTRANSFORMFEEDBACKVARYINGSEXTPROC) (GLuint program, GLsizei count, const char ** varyings, GLenum bufferMode); + +#define glBeginTransformFeedbackEXT GLEW_GET_FUN(__glewBeginTransformFeedbackEXT) +#define glBindBufferBaseEXT GLEW_GET_FUN(__glewBindBufferBaseEXT) +#define glBindBufferOffsetEXT GLEW_GET_FUN(__glewBindBufferOffsetEXT) +#define glBindBufferRangeEXT GLEW_GET_FUN(__glewBindBufferRangeEXT) +#define glEndTransformFeedbackEXT GLEW_GET_FUN(__glewEndTransformFeedbackEXT) +#define glGetTransformFeedbackVaryingEXT GLEW_GET_FUN(__glewGetTransformFeedbackVaryingEXT) +#define glTransformFeedbackVaryingsEXT GLEW_GET_FUN(__glewTransformFeedbackVaryingsEXT) + +#define GLEW_EXT_transform_feedback GLEW_GET_VAR(__GLEW_EXT_transform_feedback) + +#endif /* GL_EXT_transform_feedback */ + +/* -------------------------- GL_EXT_vertex_array -------------------------- */ + +#ifndef GL_EXT_vertex_array +#define GL_EXT_vertex_array 1 + +#define GL_DOUBLE_EXT 0x140A +#define GL_VERTEX_ARRAY_EXT 0x8074 +#define GL_NORMAL_ARRAY_EXT 0x8075 +#define GL_COLOR_ARRAY_EXT 0x8076 +#define GL_INDEX_ARRAY_EXT 0x8077 +#define GL_TEXTURE_COORD_ARRAY_EXT 0x8078 +#define GL_EDGE_FLAG_ARRAY_EXT 0x8079 +#define GL_VERTEX_ARRAY_SIZE_EXT 0x807A +#define GL_VERTEX_ARRAY_TYPE_EXT 0x807B +#define GL_VERTEX_ARRAY_STRIDE_EXT 0x807C +#define GL_VERTEX_ARRAY_COUNT_EXT 0x807D +#define GL_NORMAL_ARRAY_TYPE_EXT 0x807E +#define GL_NORMAL_ARRAY_STRIDE_EXT 0x807F +#define GL_NORMAL_ARRAY_COUNT_EXT 0x8080 +#define GL_COLOR_ARRAY_SIZE_EXT 0x8081 +#define GL_COLOR_ARRAY_TYPE_EXT 0x8082 +#define GL_COLOR_ARRAY_STRIDE_EXT 0x8083 +#define GL_COLOR_ARRAY_COUNT_EXT 0x8084 +#define GL_INDEX_ARRAY_TYPE_EXT 0x8085 +#define GL_INDEX_ARRAY_STRIDE_EXT 0x8086 +#define GL_INDEX_ARRAY_COUNT_EXT 0x8087 +#define GL_TEXTURE_COORD_ARRAY_SIZE_EXT 0x8088 +#define GL_TEXTURE_COORD_ARRAY_TYPE_EXT 0x8089 +#define GL_TEXTURE_COORD_ARRAY_STRIDE_EXT 0x808A +#define GL_TEXTURE_COORD_ARRAY_COUNT_EXT 0x808B +#define GL_EDGE_FLAG_ARRAY_STRIDE_EXT 0x808C +#define GL_EDGE_FLAG_ARRAY_COUNT_EXT 0x808D +#define GL_VERTEX_ARRAY_POINTER_EXT 0x808E +#define GL_NORMAL_ARRAY_POINTER_EXT 0x808F +#define GL_COLOR_ARRAY_POINTER_EXT 0x8090 +#define GL_INDEX_ARRAY_POINTER_EXT 0x8091 +#define GL_TEXTURE_COORD_ARRAY_POINTER_EXT 0x8092 +#define GL_EDGE_FLAG_ARRAY_POINTER_EXT 0x8093 + +typedef void (GLAPIENTRY * PFNGLARRAYELEMENTEXTPROC) (GLint i); +typedef void (GLAPIENTRY * PFNGLCOLORPOINTEREXTPROC) (GLint size, GLenum type, GLsizei stride, GLsizei count, const void* pointer); +typedef void (GLAPIENTRY * PFNGLDRAWARRAYSEXTPROC) (GLenum mode, GLint first, GLsizei count); +typedef void (GLAPIENTRY * PFNGLEDGEFLAGPOINTEREXTPROC) (GLsizei stride, GLsizei count, const GLboolean* pointer); +typedef void (GLAPIENTRY * PFNGLGETPOINTERVEXTPROC) (GLenum pname, void** params); +typedef void (GLAPIENTRY * PFNGLINDEXPOINTEREXTPROC) (GLenum type, GLsizei stride, GLsizei count, const void* pointer); +typedef void (GLAPIENTRY * PFNGLNORMALPOINTEREXTPROC) (GLenum type, GLsizei stride, GLsizei count, const void* pointer); +typedef void (GLAPIENTRY * PFNGLTEXCOORDPOINTEREXTPROC) (GLint size, GLenum type, GLsizei stride, GLsizei count, const void* pointer); +typedef void (GLAPIENTRY * PFNGLVERTEXPOINTEREXTPROC) (GLint size, GLenum type, GLsizei stride, GLsizei count, const void* pointer); + +#define glArrayElementEXT GLEW_GET_FUN(__glewArrayElementEXT) +#define glColorPointerEXT GLEW_GET_FUN(__glewColorPointerEXT) +#define glDrawArraysEXT GLEW_GET_FUN(__glewDrawArraysEXT) +#define glEdgeFlagPointerEXT GLEW_GET_FUN(__glewEdgeFlagPointerEXT) +#define glGetPointervEXT GLEW_GET_FUN(__glewGetPointervEXT) +#define glIndexPointerEXT GLEW_GET_FUN(__glewIndexPointerEXT) +#define glNormalPointerEXT GLEW_GET_FUN(__glewNormalPointerEXT) +#define glTexCoordPointerEXT GLEW_GET_FUN(__glewTexCoordPointerEXT) +#define glVertexPointerEXT GLEW_GET_FUN(__glewVertexPointerEXT) + +#define GLEW_EXT_vertex_array GLEW_GET_VAR(__GLEW_EXT_vertex_array) + +#endif /* GL_EXT_vertex_array */ + +/* ------------------------ GL_EXT_vertex_array_bgra ----------------------- */ + +#ifndef GL_EXT_vertex_array_bgra +#define GL_EXT_vertex_array_bgra 1 + +#define GL_BGRA 0x80E1 + +#define GLEW_EXT_vertex_array_bgra GLEW_GET_VAR(__GLEW_EXT_vertex_array_bgra) + +#endif /* GL_EXT_vertex_array_bgra */ + +/* -------------------------- GL_EXT_vertex_shader ------------------------- */ + +#ifndef GL_EXT_vertex_shader +#define GL_EXT_vertex_shader 1 + +#define GL_VERTEX_SHADER_EXT 0x8780 +#define GL_VERTEX_SHADER_BINDING_EXT 0x8781 +#define GL_OP_INDEX_EXT 0x8782 +#define GL_OP_NEGATE_EXT 0x8783 +#define GL_OP_DOT3_EXT 0x8784 +#define GL_OP_DOT4_EXT 0x8785 +#define GL_OP_MUL_EXT 0x8786 +#define GL_OP_ADD_EXT 0x8787 +#define GL_OP_MADD_EXT 0x8788 +#define GL_OP_FRAC_EXT 0x8789 +#define GL_OP_MAX_EXT 0x878A +#define GL_OP_MIN_EXT 0x878B +#define GL_OP_SET_GE_EXT 0x878C +#define GL_OP_SET_LT_EXT 0x878D +#define GL_OP_CLAMP_EXT 0x878E +#define GL_OP_FLOOR_EXT 0x878F +#define GL_OP_ROUND_EXT 0x8790 +#define GL_OP_EXP_BASE_2_EXT 0x8791 +#define GL_OP_LOG_BASE_2_EXT 0x8792 +#define GL_OP_POWER_EXT 0x8793 +#define GL_OP_RECIP_EXT 0x8794 +#define GL_OP_RECIP_SQRT_EXT 0x8795 +#define GL_OP_SUB_EXT 0x8796 +#define GL_OP_CROSS_PRODUCT_EXT 0x8797 +#define GL_OP_MULTIPLY_MATRIX_EXT 0x8798 +#define GL_OP_MOV_EXT 0x8799 +#define GL_OUTPUT_VERTEX_EXT 0x879A +#define GL_OUTPUT_COLOR0_EXT 0x879B +#define GL_OUTPUT_COLOR1_EXT 0x879C +#define GL_OUTPUT_TEXTURE_COORD0_EXT 0x879D +#define GL_OUTPUT_TEXTURE_COORD1_EXT 0x879E +#define GL_OUTPUT_TEXTURE_COORD2_EXT 0x879F +#define GL_OUTPUT_TEXTURE_COORD3_EXT 0x87A0 +#define GL_OUTPUT_TEXTURE_COORD4_EXT 0x87A1 +#define GL_OUTPUT_TEXTURE_COORD5_EXT 0x87A2 +#define GL_OUTPUT_TEXTURE_COORD6_EXT 0x87A3 +#define GL_OUTPUT_TEXTURE_COORD7_EXT 0x87A4 +#define GL_OUTPUT_TEXTURE_COORD8_EXT 0x87A5 +#define GL_OUTPUT_TEXTURE_COORD9_EXT 0x87A6 +#define GL_OUTPUT_TEXTURE_COORD10_EXT 0x87A7 +#define GL_OUTPUT_TEXTURE_COORD11_EXT 0x87A8 +#define GL_OUTPUT_TEXTURE_COORD12_EXT 0x87A9 +#define GL_OUTPUT_TEXTURE_COORD13_EXT 0x87AA +#define GL_OUTPUT_TEXTURE_COORD14_EXT 0x87AB +#define GL_OUTPUT_TEXTURE_COORD15_EXT 0x87AC +#define GL_OUTPUT_TEXTURE_COORD16_EXT 0x87AD +#define GL_OUTPUT_TEXTURE_COORD17_EXT 0x87AE +#define GL_OUTPUT_TEXTURE_COORD18_EXT 0x87AF +#define GL_OUTPUT_TEXTURE_COORD19_EXT 0x87B0 +#define GL_OUTPUT_TEXTURE_COORD20_EXT 0x87B1 +#define GL_OUTPUT_TEXTURE_COORD21_EXT 0x87B2 +#define GL_OUTPUT_TEXTURE_COORD22_EXT 0x87B3 +#define GL_OUTPUT_TEXTURE_COORD23_EXT 0x87B4 +#define GL_OUTPUT_TEXTURE_COORD24_EXT 0x87B5 +#define GL_OUTPUT_TEXTURE_COORD25_EXT 0x87B6 +#define GL_OUTPUT_TEXTURE_COORD26_EXT 0x87B7 +#define GL_OUTPUT_TEXTURE_COORD27_EXT 0x87B8 +#define GL_OUTPUT_TEXTURE_COORD28_EXT 0x87B9 +#define GL_OUTPUT_TEXTURE_COORD29_EXT 0x87BA +#define GL_OUTPUT_TEXTURE_COORD30_EXT 0x87BB +#define GL_OUTPUT_TEXTURE_COORD31_EXT 0x87BC +#define GL_OUTPUT_FOG_EXT 0x87BD +#define GL_SCALAR_EXT 0x87BE +#define GL_VECTOR_EXT 0x87BF +#define GL_MATRIX_EXT 0x87C0 +#define GL_VARIANT_EXT 0x87C1 +#define GL_INVARIANT_EXT 0x87C2 +#define GL_LOCAL_CONSTANT_EXT 0x87C3 +#define GL_LOCAL_EXT 0x87C4 +#define GL_MAX_VERTEX_SHADER_INSTRUCTIONS_EXT 0x87C5 +#define GL_MAX_VERTEX_SHADER_VARIANTS_EXT 0x87C6 +#define GL_MAX_VERTEX_SHADER_INVARIANTS_EXT 0x87C7 +#define GL_MAX_VERTEX_SHADER_LOCAL_CONSTANTS_EXT 0x87C8 +#define GL_MAX_VERTEX_SHADER_LOCALS_EXT 0x87C9 +#define GL_MAX_OPTIMIZED_VERTEX_SHADER_INSTRUCTIONS_EXT 0x87CA +#define GL_MAX_OPTIMIZED_VERTEX_SHADER_VARIANTS_EXT 0x87CB +#define GL_MAX_OPTIMIZED_VERTEX_SHADER_INVARIANTS_EXT 0x87CC +#define GL_MAX_OPTIMIZED_VERTEX_SHADER_LOCAL_CONSTANTS_EXT 0x87CD +#define GL_MAX_OPTIMIZED_VERTEX_SHADER_LOCALS_EXT 0x87CE +#define GL_VERTEX_SHADER_INSTRUCTIONS_EXT 0x87CF +#define GL_VERTEX_SHADER_VARIANTS_EXT 0x87D0 +#define GL_VERTEX_SHADER_INVARIANTS_EXT 0x87D1 +#define GL_VERTEX_SHADER_LOCAL_CONSTANTS_EXT 0x87D2 +#define GL_VERTEX_SHADER_LOCALS_EXT 0x87D3 +#define GL_VERTEX_SHADER_OPTIMIZED_EXT 0x87D4 +#define GL_X_EXT 0x87D5 +#define GL_Y_EXT 0x87D6 +#define GL_Z_EXT 0x87D7 +#define GL_W_EXT 0x87D8 +#define GL_NEGATIVE_X_EXT 0x87D9 +#define GL_NEGATIVE_Y_EXT 0x87DA +#define GL_NEGATIVE_Z_EXT 0x87DB +#define GL_NEGATIVE_W_EXT 0x87DC +#define GL_ZERO_EXT 0x87DD +#define GL_ONE_EXT 0x87DE +#define GL_NEGATIVE_ONE_EXT 0x87DF +#define GL_NORMALIZED_RANGE_EXT 0x87E0 +#define GL_FULL_RANGE_EXT 0x87E1 +#define GL_CURRENT_VERTEX_EXT 0x87E2 +#define GL_MVP_MATRIX_EXT 0x87E3 +#define GL_VARIANT_VALUE_EXT 0x87E4 +#define GL_VARIANT_DATATYPE_EXT 0x87E5 +#define GL_VARIANT_ARRAY_STRIDE_EXT 0x87E6 +#define GL_VARIANT_ARRAY_TYPE_EXT 0x87E7 +#define GL_VARIANT_ARRAY_EXT 0x87E8 +#define GL_VARIANT_ARRAY_POINTER_EXT 0x87E9 +#define GL_INVARIANT_VALUE_EXT 0x87EA +#define GL_INVARIANT_DATATYPE_EXT 0x87EB +#define GL_LOCAL_CONSTANT_VALUE_EXT 0x87EC +#define GL_LOCAL_CONSTANT_DATATYPE_EXT 0x87ED + +typedef void (GLAPIENTRY * PFNGLBEGINVERTEXSHADEREXTPROC) (void); +typedef GLuint (GLAPIENTRY * PFNGLBINDLIGHTPARAMETEREXTPROC) (GLenum light, GLenum value); +typedef GLuint (GLAPIENTRY * PFNGLBINDMATERIALPARAMETEREXTPROC) (GLenum face, GLenum value); +typedef GLuint (GLAPIENTRY * PFNGLBINDPARAMETEREXTPROC) (GLenum value); +typedef GLuint (GLAPIENTRY * PFNGLBINDTEXGENPARAMETEREXTPROC) (GLenum unit, GLenum coord, GLenum value); +typedef GLuint (GLAPIENTRY * PFNGLBINDTEXTUREUNITPARAMETEREXTPROC) (GLenum unit, GLenum value); +typedef void (GLAPIENTRY * PFNGLBINDVERTEXSHADEREXTPROC) (GLuint id); +typedef void (GLAPIENTRY * PFNGLDELETEVERTEXSHADEREXTPROC) (GLuint id); +typedef void (GLAPIENTRY * PFNGLDISABLEVARIANTCLIENTSTATEEXTPROC) (GLuint id); +typedef void (GLAPIENTRY * PFNGLENABLEVARIANTCLIENTSTATEEXTPROC) (GLuint id); +typedef void (GLAPIENTRY * PFNGLENDVERTEXSHADEREXTPROC) (void); +typedef void (GLAPIENTRY * PFNGLEXTRACTCOMPONENTEXTPROC) (GLuint res, GLuint src, GLuint num); +typedef GLuint (GLAPIENTRY * PFNGLGENSYMBOLSEXTPROC) (GLenum dataType, GLenum storageType, GLenum range, GLuint components); +typedef GLuint (GLAPIENTRY * PFNGLGENVERTEXSHADERSEXTPROC) (GLuint range); +typedef void (GLAPIENTRY * PFNGLGETINVARIANTBOOLEANVEXTPROC) (GLuint id, GLenum value, GLboolean *data); +typedef void (GLAPIENTRY * PFNGLGETINVARIANTFLOATVEXTPROC) (GLuint id, GLenum value, GLfloat *data); +typedef void (GLAPIENTRY * PFNGLGETINVARIANTINTEGERVEXTPROC) (GLuint id, GLenum value, GLint *data); +typedef void (GLAPIENTRY * PFNGLGETLOCALCONSTANTBOOLEANVEXTPROC) (GLuint id, GLenum value, GLboolean *data); +typedef void (GLAPIENTRY * PFNGLGETLOCALCONSTANTFLOATVEXTPROC) (GLuint id, GLenum value, GLfloat *data); +typedef void (GLAPIENTRY * PFNGLGETLOCALCONSTANTINTEGERVEXTPROC) (GLuint id, GLenum value, GLint *data); +typedef void (GLAPIENTRY * PFNGLGETVARIANTBOOLEANVEXTPROC) (GLuint id, GLenum value, GLboolean *data); +typedef void (GLAPIENTRY * PFNGLGETVARIANTFLOATVEXTPROC) (GLuint id, GLenum value, GLfloat *data); +typedef void (GLAPIENTRY * PFNGLGETVARIANTINTEGERVEXTPROC) (GLuint id, GLenum value, GLint *data); +typedef void (GLAPIENTRY * PFNGLGETVARIANTPOINTERVEXTPROC) (GLuint id, GLenum value, GLvoid **data); +typedef void (GLAPIENTRY * PFNGLINSERTCOMPONENTEXTPROC) (GLuint res, GLuint src, GLuint num); +typedef GLboolean (GLAPIENTRY * PFNGLISVARIANTENABLEDEXTPROC) (GLuint id, GLenum cap); +typedef void (GLAPIENTRY * PFNGLSETINVARIANTEXTPROC) (GLuint id, GLenum type, GLvoid *addr); +typedef void (GLAPIENTRY * PFNGLSETLOCALCONSTANTEXTPROC) (GLuint id, GLenum type, GLvoid *addr); +typedef void (GLAPIENTRY * PFNGLSHADEROP1EXTPROC) (GLenum op, GLuint res, GLuint arg1); +typedef void (GLAPIENTRY * PFNGLSHADEROP2EXTPROC) (GLenum op, GLuint res, GLuint arg1, GLuint arg2); +typedef void (GLAPIENTRY * PFNGLSHADEROP3EXTPROC) (GLenum op, GLuint res, GLuint arg1, GLuint arg2, GLuint arg3); +typedef void (GLAPIENTRY * PFNGLSWIZZLEEXTPROC) (GLuint res, GLuint in, GLenum outX, GLenum outY, GLenum outZ, GLenum outW); +typedef void (GLAPIENTRY * PFNGLVARIANTPOINTEREXTPROC) (GLuint id, GLenum type, GLuint stride, GLvoid *addr); +typedef void (GLAPIENTRY * PFNGLVARIANTBVEXTPROC) (GLuint id, GLbyte *addr); +typedef void (GLAPIENTRY * PFNGLVARIANTDVEXTPROC) (GLuint id, GLdouble *addr); +typedef void (GLAPIENTRY * PFNGLVARIANTFVEXTPROC) (GLuint id, GLfloat *addr); +typedef void (GLAPIENTRY * PFNGLVARIANTIVEXTPROC) (GLuint id, GLint *addr); +typedef void (GLAPIENTRY * PFNGLVARIANTSVEXTPROC) (GLuint id, GLshort *addr); +typedef void (GLAPIENTRY * PFNGLVARIANTUBVEXTPROC) (GLuint id, GLubyte *addr); +typedef void (GLAPIENTRY * PFNGLVARIANTUIVEXTPROC) (GLuint id, GLuint *addr); +typedef void (GLAPIENTRY * PFNGLVARIANTUSVEXTPROC) (GLuint id, GLushort *addr); +typedef void (GLAPIENTRY * PFNGLWRITEMASKEXTPROC) (GLuint res, GLuint in, GLenum outX, GLenum outY, GLenum outZ, GLenum outW); + +#define glBeginVertexShaderEXT GLEW_GET_FUN(__glewBeginVertexShaderEXT) +#define glBindLightParameterEXT GLEW_GET_FUN(__glewBindLightParameterEXT) +#define glBindMaterialParameterEXT GLEW_GET_FUN(__glewBindMaterialParameterEXT) +#define glBindParameterEXT GLEW_GET_FUN(__glewBindParameterEXT) +#define glBindTexGenParameterEXT GLEW_GET_FUN(__glewBindTexGenParameterEXT) +#define glBindTextureUnitParameterEXT GLEW_GET_FUN(__glewBindTextureUnitParameterEXT) +#define glBindVertexShaderEXT GLEW_GET_FUN(__glewBindVertexShaderEXT) +#define glDeleteVertexShaderEXT GLEW_GET_FUN(__glewDeleteVertexShaderEXT) +#define glDisableVariantClientStateEXT GLEW_GET_FUN(__glewDisableVariantClientStateEXT) +#define glEnableVariantClientStateEXT GLEW_GET_FUN(__glewEnableVariantClientStateEXT) +#define glEndVertexShaderEXT GLEW_GET_FUN(__glewEndVertexShaderEXT) +#define glExtractComponentEXT GLEW_GET_FUN(__glewExtractComponentEXT) +#define glGenSymbolsEXT GLEW_GET_FUN(__glewGenSymbolsEXT) +#define glGenVertexShadersEXT GLEW_GET_FUN(__glewGenVertexShadersEXT) +#define glGetInvariantBooleanvEXT GLEW_GET_FUN(__glewGetInvariantBooleanvEXT) +#define glGetInvariantFloatvEXT GLEW_GET_FUN(__glewGetInvariantFloatvEXT) +#define glGetInvariantIntegervEXT GLEW_GET_FUN(__glewGetInvariantIntegervEXT) +#define glGetLocalConstantBooleanvEXT GLEW_GET_FUN(__glewGetLocalConstantBooleanvEXT) +#define glGetLocalConstantFloatvEXT GLEW_GET_FUN(__glewGetLocalConstantFloatvEXT) +#define glGetLocalConstantIntegervEXT GLEW_GET_FUN(__glewGetLocalConstantIntegervEXT) +#define glGetVariantBooleanvEXT GLEW_GET_FUN(__glewGetVariantBooleanvEXT) +#define glGetVariantFloatvEXT GLEW_GET_FUN(__glewGetVariantFloatvEXT) +#define glGetVariantIntegervEXT GLEW_GET_FUN(__glewGetVariantIntegervEXT) +#define glGetVariantPointervEXT GLEW_GET_FUN(__glewGetVariantPointervEXT) +#define glInsertComponentEXT GLEW_GET_FUN(__glewInsertComponentEXT) +#define glIsVariantEnabledEXT GLEW_GET_FUN(__glewIsVariantEnabledEXT) +#define glSetInvariantEXT GLEW_GET_FUN(__glewSetInvariantEXT) +#define glSetLocalConstantEXT GLEW_GET_FUN(__glewSetLocalConstantEXT) +#define glShaderOp1EXT GLEW_GET_FUN(__glewShaderOp1EXT) +#define glShaderOp2EXT GLEW_GET_FUN(__glewShaderOp2EXT) +#define glShaderOp3EXT GLEW_GET_FUN(__glewShaderOp3EXT) +#define glSwizzleEXT GLEW_GET_FUN(__glewSwizzleEXT) +#define glVariantPointerEXT GLEW_GET_FUN(__glewVariantPointerEXT) +#define glVariantbvEXT GLEW_GET_FUN(__glewVariantbvEXT) +#define glVariantdvEXT GLEW_GET_FUN(__glewVariantdvEXT) +#define glVariantfvEXT GLEW_GET_FUN(__glewVariantfvEXT) +#define glVariantivEXT GLEW_GET_FUN(__glewVariantivEXT) +#define glVariantsvEXT GLEW_GET_FUN(__glewVariantsvEXT) +#define glVariantubvEXT GLEW_GET_FUN(__glewVariantubvEXT) +#define glVariantuivEXT GLEW_GET_FUN(__glewVariantuivEXT) +#define glVariantusvEXT GLEW_GET_FUN(__glewVariantusvEXT) +#define glWriteMaskEXT GLEW_GET_FUN(__glewWriteMaskEXT) + +#define GLEW_EXT_vertex_shader GLEW_GET_VAR(__GLEW_EXT_vertex_shader) + +#endif /* GL_EXT_vertex_shader */ + +/* ------------------------ GL_EXT_vertex_weighting ------------------------ */ + +#ifndef GL_EXT_vertex_weighting +#define GL_EXT_vertex_weighting 1 + +#define GL_MODELVIEW0_STACK_DEPTH_EXT 0x0BA3 +#define GL_MODELVIEW0_MATRIX_EXT 0x0BA6 +#define GL_MODELVIEW0_EXT 0x1700 +#define GL_MODELVIEW1_STACK_DEPTH_EXT 0x8502 +#define GL_MODELVIEW1_MATRIX_EXT 0x8506 +#define GL_VERTEX_WEIGHTING_EXT 0x8509 +#define GL_MODELVIEW1_EXT 0x850A +#define GL_CURRENT_VERTEX_WEIGHT_EXT 0x850B +#define GL_VERTEX_WEIGHT_ARRAY_EXT 0x850C +#define GL_VERTEX_WEIGHT_ARRAY_SIZE_EXT 0x850D +#define GL_VERTEX_WEIGHT_ARRAY_TYPE_EXT 0x850E +#define GL_VERTEX_WEIGHT_ARRAY_STRIDE_EXT 0x850F +#define GL_VERTEX_WEIGHT_ARRAY_POINTER_EXT 0x8510 + +typedef void (GLAPIENTRY * PFNGLVERTEXWEIGHTPOINTEREXTPROC) (GLint size, GLenum type, GLsizei stride, void* pointer); +typedef void (GLAPIENTRY * PFNGLVERTEXWEIGHTFEXTPROC) (GLfloat weight); +typedef void (GLAPIENTRY * PFNGLVERTEXWEIGHTFVEXTPROC) (GLfloat* weight); + +#define glVertexWeightPointerEXT GLEW_GET_FUN(__glewVertexWeightPointerEXT) +#define glVertexWeightfEXT GLEW_GET_FUN(__glewVertexWeightfEXT) +#define glVertexWeightfvEXT GLEW_GET_FUN(__glewVertexWeightfvEXT) + +#define GLEW_EXT_vertex_weighting GLEW_GET_VAR(__GLEW_EXT_vertex_weighting) + +#endif /* GL_EXT_vertex_weighting */ + +/* ---------------------- GL_GREMEDY_frame_terminator ---------------------- */ + +#ifndef GL_GREMEDY_frame_terminator +#define GL_GREMEDY_frame_terminator 1 + +typedef void (GLAPIENTRY * PFNGLFRAMETERMINATORGREMEDYPROC) (void); + +#define glFrameTerminatorGREMEDY GLEW_GET_FUN(__glewFrameTerminatorGREMEDY) + +#define GLEW_GREMEDY_frame_terminator GLEW_GET_VAR(__GLEW_GREMEDY_frame_terminator) + +#endif /* GL_GREMEDY_frame_terminator */ + +/* ------------------------ GL_GREMEDY_string_marker ----------------------- */ + +#ifndef GL_GREMEDY_string_marker +#define GL_GREMEDY_string_marker 1 + +typedef void (GLAPIENTRY * PFNGLSTRINGMARKERGREMEDYPROC) (GLsizei len, const void* string); + +#define glStringMarkerGREMEDY GLEW_GET_FUN(__glewStringMarkerGREMEDY) + +#define GLEW_GREMEDY_string_marker GLEW_GET_VAR(__GLEW_GREMEDY_string_marker) + +#endif /* GL_GREMEDY_string_marker */ + +/* --------------------- GL_HP_convolution_border_modes -------------------- */ + +#ifndef GL_HP_convolution_border_modes +#define GL_HP_convolution_border_modes 1 + +#define GLEW_HP_convolution_border_modes GLEW_GET_VAR(__GLEW_HP_convolution_border_modes) + +#endif /* GL_HP_convolution_border_modes */ + +/* ------------------------- GL_HP_image_transform ------------------------- */ + +#ifndef GL_HP_image_transform +#define GL_HP_image_transform 1 + +typedef void (GLAPIENTRY * PFNGLGETIMAGETRANSFORMPARAMETERFVHPPROC) (GLenum target, GLenum pname, const GLfloat* params); +typedef void (GLAPIENTRY * PFNGLGETIMAGETRANSFORMPARAMETERIVHPPROC) (GLenum target, GLenum pname, const GLint* params); +typedef void (GLAPIENTRY * PFNGLIMAGETRANSFORMPARAMETERFHPPROC) (GLenum target, GLenum pname, const GLfloat param); +typedef void (GLAPIENTRY * PFNGLIMAGETRANSFORMPARAMETERFVHPPROC) (GLenum target, GLenum pname, const GLfloat* params); +typedef void (GLAPIENTRY * PFNGLIMAGETRANSFORMPARAMETERIHPPROC) (GLenum target, GLenum pname, const GLint param); +typedef void (GLAPIENTRY * PFNGLIMAGETRANSFORMPARAMETERIVHPPROC) (GLenum target, GLenum pname, const GLint* params); + +#define glGetImageTransformParameterfvHP GLEW_GET_FUN(__glewGetImageTransformParameterfvHP) +#define glGetImageTransformParameterivHP GLEW_GET_FUN(__glewGetImageTransformParameterivHP) +#define glImageTransformParameterfHP GLEW_GET_FUN(__glewImageTransformParameterfHP) +#define glImageTransformParameterfvHP GLEW_GET_FUN(__glewImageTransformParameterfvHP) +#define glImageTransformParameteriHP GLEW_GET_FUN(__glewImageTransformParameteriHP) +#define glImageTransformParameterivHP GLEW_GET_FUN(__glewImageTransformParameterivHP) + +#define GLEW_HP_image_transform GLEW_GET_VAR(__GLEW_HP_image_transform) + +#endif /* GL_HP_image_transform */ + +/* -------------------------- GL_HP_occlusion_test ------------------------- */ + +#ifndef GL_HP_occlusion_test +#define GL_HP_occlusion_test 1 + +#define GL_OCCLUSION_TEST_HP 0x8165 +#define GL_OCCLUSION_TEST_RESULT_HP 0x8166 + +#define GLEW_HP_occlusion_test GLEW_GET_VAR(__GLEW_HP_occlusion_test) + +#endif /* GL_HP_occlusion_test */ + +/* ------------------------- GL_HP_texture_lighting ------------------------ */ + +#ifndef GL_HP_texture_lighting +#define GL_HP_texture_lighting 1 + +#define GLEW_HP_texture_lighting GLEW_GET_VAR(__GLEW_HP_texture_lighting) + +#endif /* GL_HP_texture_lighting */ + +/* --------------------------- GL_IBM_cull_vertex -------------------------- */ + +#ifndef GL_IBM_cull_vertex +#define GL_IBM_cull_vertex 1 + +#define GL_CULL_VERTEX_IBM 103050 + +#define GLEW_IBM_cull_vertex GLEW_GET_VAR(__GLEW_IBM_cull_vertex) + +#endif /* GL_IBM_cull_vertex */ + +/* ---------------------- GL_IBM_multimode_draw_arrays --------------------- */ + +#ifndef GL_IBM_multimode_draw_arrays +#define GL_IBM_multimode_draw_arrays 1 + +typedef void (GLAPIENTRY * PFNGLMULTIMODEDRAWARRAYSIBMPROC) (const GLenum* mode, const GLint *first, const GLsizei *count, GLsizei primcount, GLint modestride); +typedef void (GLAPIENTRY * PFNGLMULTIMODEDRAWELEMENTSIBMPROC) (const GLenum* mode, const GLsizei *count, GLenum type, const GLvoid * const *indices, GLsizei primcount, GLint modestride); + +#define glMultiModeDrawArraysIBM GLEW_GET_FUN(__glewMultiModeDrawArraysIBM) +#define glMultiModeDrawElementsIBM GLEW_GET_FUN(__glewMultiModeDrawElementsIBM) + +#define GLEW_IBM_multimode_draw_arrays GLEW_GET_VAR(__GLEW_IBM_multimode_draw_arrays) + +#endif /* GL_IBM_multimode_draw_arrays */ + +/* ------------------------- GL_IBM_rasterpos_clip ------------------------- */ + +#ifndef GL_IBM_rasterpos_clip +#define GL_IBM_rasterpos_clip 1 + +#define GL_RASTER_POSITION_UNCLIPPED_IBM 103010 + +#define GLEW_IBM_rasterpos_clip GLEW_GET_VAR(__GLEW_IBM_rasterpos_clip) + +#endif /* GL_IBM_rasterpos_clip */ + +/* --------------------------- GL_IBM_static_data -------------------------- */ + +#ifndef GL_IBM_static_data +#define GL_IBM_static_data 1 + +#define GL_ALL_STATIC_DATA_IBM 103060 +#define GL_STATIC_VERTEX_ARRAY_IBM 103061 + +#define GLEW_IBM_static_data GLEW_GET_VAR(__GLEW_IBM_static_data) + +#endif /* GL_IBM_static_data */ + +/* --------------------- GL_IBM_texture_mirrored_repeat -------------------- */ + +#ifndef GL_IBM_texture_mirrored_repeat +#define GL_IBM_texture_mirrored_repeat 1 + +#define GL_MIRRORED_REPEAT_IBM 0x8370 + +#define GLEW_IBM_texture_mirrored_repeat GLEW_GET_VAR(__GLEW_IBM_texture_mirrored_repeat) + +#endif /* GL_IBM_texture_mirrored_repeat */ + +/* ----------------------- GL_IBM_vertex_array_lists ----------------------- */ + +#ifndef GL_IBM_vertex_array_lists +#define GL_IBM_vertex_array_lists 1 + +#define GL_VERTEX_ARRAY_LIST_IBM 103070 +#define GL_NORMAL_ARRAY_LIST_IBM 103071 +#define GL_COLOR_ARRAY_LIST_IBM 103072 +#define GL_INDEX_ARRAY_LIST_IBM 103073 +#define GL_TEXTURE_COORD_ARRAY_LIST_IBM 103074 +#define GL_EDGE_FLAG_ARRAY_LIST_IBM 103075 +#define GL_FOG_COORDINATE_ARRAY_LIST_IBM 103076 +#define GL_SECONDARY_COLOR_ARRAY_LIST_IBM 103077 +#define GL_VERTEX_ARRAY_LIST_STRIDE_IBM 103080 +#define GL_NORMAL_ARRAY_LIST_STRIDE_IBM 103081 +#define GL_COLOR_ARRAY_LIST_STRIDE_IBM 103082 +#define GL_INDEX_ARRAY_LIST_STRIDE_IBM 103083 +#define GL_TEXTURE_COORD_ARRAY_LIST_STRIDE_IBM 103084 +#define GL_EDGE_FLAG_ARRAY_LIST_STRIDE_IBM 103085 +#define GL_FOG_COORDINATE_ARRAY_LIST_STRIDE_IBM 103086 +#define GL_SECONDARY_COLOR_ARRAY_LIST_STRIDE_IBM 103087 + +typedef void (GLAPIENTRY * PFNGLCOLORPOINTERLISTIBMPROC) (GLint size, GLenum type, GLint stride, const GLvoid ** pointer, GLint ptrstride); +typedef void (GLAPIENTRY * PFNGLEDGEFLAGPOINTERLISTIBMPROC) (GLint stride, const GLboolean ** pointer, GLint ptrstride); +typedef void (GLAPIENTRY * PFNGLFOGCOORDPOINTERLISTIBMPROC) (GLenum type, GLint stride, const GLvoid ** pointer, GLint ptrstride); +typedef void (GLAPIENTRY * PFNGLINDEXPOINTERLISTIBMPROC) (GLenum type, GLint stride, const GLvoid ** pointer, GLint ptrstride); +typedef void (GLAPIENTRY * PFNGLNORMALPOINTERLISTIBMPROC) (GLenum type, GLint stride, const GLvoid ** pointer, GLint ptrstride); +typedef void (GLAPIENTRY * PFNGLSECONDARYCOLORPOINTERLISTIBMPROC) (GLint size, GLenum type, GLint stride, const GLvoid ** pointer, GLint ptrstride); +typedef void (GLAPIENTRY * PFNGLTEXCOORDPOINTERLISTIBMPROC) (GLint size, GLenum type, GLint stride, const GLvoid ** pointer, GLint ptrstride); +typedef void (GLAPIENTRY * PFNGLVERTEXPOINTERLISTIBMPROC) (GLint size, GLenum type, GLint stride, const GLvoid ** pointer, GLint ptrstride); + +#define glColorPointerListIBM GLEW_GET_FUN(__glewColorPointerListIBM) +#define glEdgeFlagPointerListIBM GLEW_GET_FUN(__glewEdgeFlagPointerListIBM) +#define glFogCoordPointerListIBM GLEW_GET_FUN(__glewFogCoordPointerListIBM) +#define glIndexPointerListIBM GLEW_GET_FUN(__glewIndexPointerListIBM) +#define glNormalPointerListIBM GLEW_GET_FUN(__glewNormalPointerListIBM) +#define glSecondaryColorPointerListIBM GLEW_GET_FUN(__glewSecondaryColorPointerListIBM) +#define glTexCoordPointerListIBM GLEW_GET_FUN(__glewTexCoordPointerListIBM) +#define glVertexPointerListIBM GLEW_GET_FUN(__glewVertexPointerListIBM) + +#define GLEW_IBM_vertex_array_lists GLEW_GET_VAR(__GLEW_IBM_vertex_array_lists) + +#endif /* GL_IBM_vertex_array_lists */ + +/* -------------------------- GL_INGR_color_clamp -------------------------- */ + +#ifndef GL_INGR_color_clamp +#define GL_INGR_color_clamp 1 + +#define GL_RED_MIN_CLAMP_INGR 0x8560 +#define GL_GREEN_MIN_CLAMP_INGR 0x8561 +#define GL_BLUE_MIN_CLAMP_INGR 0x8562 +#define GL_ALPHA_MIN_CLAMP_INGR 0x8563 +#define GL_RED_MAX_CLAMP_INGR 0x8564 +#define GL_GREEN_MAX_CLAMP_INGR 0x8565 +#define GL_BLUE_MAX_CLAMP_INGR 0x8566 +#define GL_ALPHA_MAX_CLAMP_INGR 0x8567 + +#define GLEW_INGR_color_clamp GLEW_GET_VAR(__GLEW_INGR_color_clamp) + +#endif /* GL_INGR_color_clamp */ + +/* ------------------------- GL_INGR_interlace_read ------------------------ */ + +#ifndef GL_INGR_interlace_read +#define GL_INGR_interlace_read 1 + +#define GL_INTERLACE_READ_INGR 0x8568 + +#define GLEW_INGR_interlace_read GLEW_GET_VAR(__GLEW_INGR_interlace_read) + +#endif /* GL_INGR_interlace_read */ + +/* ------------------------ GL_INTEL_parallel_arrays ----------------------- */ + +#ifndef GL_INTEL_parallel_arrays +#define GL_INTEL_parallel_arrays 1 + +#define GL_PARALLEL_ARRAYS_INTEL 0x83F4 +#define GL_VERTEX_ARRAY_PARALLEL_POINTERS_INTEL 0x83F5 +#define GL_NORMAL_ARRAY_PARALLEL_POINTERS_INTEL 0x83F6 +#define GL_COLOR_ARRAY_PARALLEL_POINTERS_INTEL 0x83F7 +#define GL_TEXTURE_COORD_ARRAY_PARALLEL_POINTERS_INTEL 0x83F8 + +typedef void (GLAPIENTRY * PFNGLCOLORPOINTERVINTELPROC) (GLint size, GLenum type, const void** pointer); +typedef void (GLAPIENTRY * PFNGLNORMALPOINTERVINTELPROC) (GLenum type, const void** pointer); +typedef void (GLAPIENTRY * PFNGLTEXCOORDPOINTERVINTELPROC) (GLint size, GLenum type, const void** pointer); +typedef void (GLAPIENTRY * PFNGLVERTEXPOINTERVINTELPROC) (GLint size, GLenum type, const void** pointer); + +#define glColorPointervINTEL GLEW_GET_FUN(__glewColorPointervINTEL) +#define glNormalPointervINTEL GLEW_GET_FUN(__glewNormalPointervINTEL) +#define glTexCoordPointervINTEL GLEW_GET_FUN(__glewTexCoordPointervINTEL) +#define glVertexPointervINTEL GLEW_GET_FUN(__glewVertexPointervINTEL) + +#define GLEW_INTEL_parallel_arrays GLEW_GET_VAR(__GLEW_INTEL_parallel_arrays) + +#endif /* GL_INTEL_parallel_arrays */ + +/* ------------------------ GL_INTEL_texture_scissor ----------------------- */ + +#ifndef GL_INTEL_texture_scissor +#define GL_INTEL_texture_scissor 1 + +typedef void (GLAPIENTRY * PFNGLTEXSCISSORFUNCINTELPROC) (GLenum target, GLenum lfunc, GLenum hfunc); +typedef void (GLAPIENTRY * PFNGLTEXSCISSORINTELPROC) (GLenum target, GLclampf tlow, GLclampf thigh); + +#define glTexScissorFuncINTEL GLEW_GET_FUN(__glewTexScissorFuncINTEL) +#define glTexScissorINTEL GLEW_GET_FUN(__glewTexScissorINTEL) + +#define GLEW_INTEL_texture_scissor GLEW_GET_VAR(__GLEW_INTEL_texture_scissor) + +#endif /* GL_INTEL_texture_scissor */ + +/* -------------------------- GL_KTX_buffer_region ------------------------- */ + +#ifndef GL_KTX_buffer_region +#define GL_KTX_buffer_region 1 + +#define GL_KTX_FRONT_REGION 0x0 +#define GL_KTX_BACK_REGION 0x1 +#define GL_KTX_Z_REGION 0x2 +#define GL_KTX_STENCIL_REGION 0x3 + +typedef GLuint (GLAPIENTRY * PFNGLBUFFERREGIONENABLEDEXTPROC) (void); +typedef void (GLAPIENTRY * PFNGLDELETEBUFFERREGIONEXTPROC) (GLenum region); +typedef void (GLAPIENTRY * PFNGLDRAWBUFFERREGIONEXTPROC) (GLuint region, GLint x, GLint y, GLsizei width, GLsizei height, GLint xDest, GLint yDest); +typedef GLuint (GLAPIENTRY * PFNGLNEWBUFFERREGIONEXTPROC) (GLenum region); +typedef void (GLAPIENTRY * PFNGLREADBUFFERREGIONEXTPROC) (GLuint region, GLint x, GLint y, GLsizei width, GLsizei height); + +#define glBufferRegionEnabledEXT GLEW_GET_FUN(__glewBufferRegionEnabledEXT) +#define glDeleteBufferRegionEXT GLEW_GET_FUN(__glewDeleteBufferRegionEXT) +#define glDrawBufferRegionEXT GLEW_GET_FUN(__glewDrawBufferRegionEXT) +#define glNewBufferRegionEXT GLEW_GET_FUN(__glewNewBufferRegionEXT) +#define glReadBufferRegionEXT GLEW_GET_FUN(__glewReadBufferRegionEXT) + +#define GLEW_KTX_buffer_region GLEW_GET_VAR(__GLEW_KTX_buffer_region) + +#endif /* GL_KTX_buffer_region */ + +/* ------------------------- GL_MESAX_texture_stack ------------------------ */ + +#ifndef GL_MESAX_texture_stack +#define GL_MESAX_texture_stack 1 + +#define GL_TEXTURE_1D_STACK_MESAX 0x8759 +#define GL_TEXTURE_2D_STACK_MESAX 0x875A +#define GL_PROXY_TEXTURE_1D_STACK_MESAX 0x875B +#define GL_PROXY_TEXTURE_2D_STACK_MESAX 0x875C +#define GL_TEXTURE_1D_STACK_BINDING_MESAX 0x875D +#define GL_TEXTURE_2D_STACK_BINDING_MESAX 0x875E + +#define GLEW_MESAX_texture_stack GLEW_GET_VAR(__GLEW_MESAX_texture_stack) + +#endif /* GL_MESAX_texture_stack */ + +/* -------------------------- GL_MESA_pack_invert -------------------------- */ + +#ifndef GL_MESA_pack_invert +#define GL_MESA_pack_invert 1 + +#define GL_PACK_INVERT_MESA 0x8758 + +#define GLEW_MESA_pack_invert GLEW_GET_VAR(__GLEW_MESA_pack_invert) + +#endif /* GL_MESA_pack_invert */ + +/* ------------------------- GL_MESA_resize_buffers ------------------------ */ + +#ifndef GL_MESA_resize_buffers +#define GL_MESA_resize_buffers 1 + +typedef void (GLAPIENTRY * PFNGLRESIZEBUFFERSMESAPROC) (void); + +#define glResizeBuffersMESA GLEW_GET_FUN(__glewResizeBuffersMESA) + +#define GLEW_MESA_resize_buffers GLEW_GET_VAR(__GLEW_MESA_resize_buffers) + +#endif /* GL_MESA_resize_buffers */ + +/* --------------------------- GL_MESA_window_pos -------------------------- */ + +#ifndef GL_MESA_window_pos +#define GL_MESA_window_pos 1 + +typedef void (GLAPIENTRY * PFNGLWINDOWPOS2DMESAPROC) (GLdouble x, GLdouble y); +typedef void (GLAPIENTRY * PFNGLWINDOWPOS2DVMESAPROC) (const GLdouble* p); +typedef void (GLAPIENTRY * PFNGLWINDOWPOS2FMESAPROC) (GLfloat x, GLfloat y); +typedef void (GLAPIENTRY * PFNGLWINDOWPOS2FVMESAPROC) (const GLfloat* p); +typedef void (GLAPIENTRY * PFNGLWINDOWPOS2IMESAPROC) (GLint x, GLint y); +typedef void (GLAPIENTRY * PFNGLWINDOWPOS2IVMESAPROC) (const GLint* p); +typedef void (GLAPIENTRY * PFNGLWINDOWPOS2SMESAPROC) (GLshort x, GLshort y); +typedef void (GLAPIENTRY * PFNGLWINDOWPOS2SVMESAPROC) (const GLshort* p); +typedef void (GLAPIENTRY * PFNGLWINDOWPOS3DMESAPROC) (GLdouble x, GLdouble y, GLdouble z); +typedef void (GLAPIENTRY * PFNGLWINDOWPOS3DVMESAPROC) (const GLdouble* p); +typedef void (GLAPIENTRY * PFNGLWINDOWPOS3FMESAPROC) (GLfloat x, GLfloat y, GLfloat z); +typedef void (GLAPIENTRY * PFNGLWINDOWPOS3FVMESAPROC) (const GLfloat* p); +typedef void (GLAPIENTRY * PFNGLWINDOWPOS3IMESAPROC) (GLint x, GLint y, GLint z); +typedef void (GLAPIENTRY * PFNGLWINDOWPOS3IVMESAPROC) (const GLint* p); +typedef void (GLAPIENTRY * PFNGLWINDOWPOS3SMESAPROC) (GLshort x, GLshort y, GLshort z); +typedef void (GLAPIENTRY * PFNGLWINDOWPOS3SVMESAPROC) (const GLshort* p); +typedef void (GLAPIENTRY * PFNGLWINDOWPOS4DMESAPROC) (GLdouble x, GLdouble y, GLdouble z, GLdouble); +typedef void (GLAPIENTRY * PFNGLWINDOWPOS4DVMESAPROC) (const GLdouble* p); +typedef void (GLAPIENTRY * PFNGLWINDOWPOS4FMESAPROC) (GLfloat x, GLfloat y, GLfloat z, GLfloat w); +typedef void (GLAPIENTRY * PFNGLWINDOWPOS4FVMESAPROC) (const GLfloat* p); +typedef void (GLAPIENTRY * PFNGLWINDOWPOS4IMESAPROC) (GLint x, GLint y, GLint z, GLint w); +typedef void (GLAPIENTRY * PFNGLWINDOWPOS4IVMESAPROC) (const GLint* p); +typedef void (GLAPIENTRY * PFNGLWINDOWPOS4SMESAPROC) (GLshort x, GLshort y, GLshort z, GLshort w); +typedef void (GLAPIENTRY * PFNGLWINDOWPOS4SVMESAPROC) (const GLshort* p); + +#define glWindowPos2dMESA GLEW_GET_FUN(__glewWindowPos2dMESA) +#define glWindowPos2dvMESA GLEW_GET_FUN(__glewWindowPos2dvMESA) +#define glWindowPos2fMESA GLEW_GET_FUN(__glewWindowPos2fMESA) +#define glWindowPos2fvMESA GLEW_GET_FUN(__glewWindowPos2fvMESA) +#define glWindowPos2iMESA GLEW_GET_FUN(__glewWindowPos2iMESA) +#define glWindowPos2ivMESA GLEW_GET_FUN(__glewWindowPos2ivMESA) +#define glWindowPos2sMESA GLEW_GET_FUN(__glewWindowPos2sMESA) +#define glWindowPos2svMESA GLEW_GET_FUN(__glewWindowPos2svMESA) +#define glWindowPos3dMESA GLEW_GET_FUN(__glewWindowPos3dMESA) +#define glWindowPos3dvMESA GLEW_GET_FUN(__glewWindowPos3dvMESA) +#define glWindowPos3fMESA GLEW_GET_FUN(__glewWindowPos3fMESA) +#define glWindowPos3fvMESA GLEW_GET_FUN(__glewWindowPos3fvMESA) +#define glWindowPos3iMESA GLEW_GET_FUN(__glewWindowPos3iMESA) +#define glWindowPos3ivMESA GLEW_GET_FUN(__glewWindowPos3ivMESA) +#define glWindowPos3sMESA GLEW_GET_FUN(__glewWindowPos3sMESA) +#define glWindowPos3svMESA GLEW_GET_FUN(__glewWindowPos3svMESA) +#define glWindowPos4dMESA GLEW_GET_FUN(__glewWindowPos4dMESA) +#define glWindowPos4dvMESA GLEW_GET_FUN(__glewWindowPos4dvMESA) +#define glWindowPos4fMESA GLEW_GET_FUN(__glewWindowPos4fMESA) +#define glWindowPos4fvMESA GLEW_GET_FUN(__glewWindowPos4fvMESA) +#define glWindowPos4iMESA GLEW_GET_FUN(__glewWindowPos4iMESA) +#define glWindowPos4ivMESA GLEW_GET_FUN(__glewWindowPos4ivMESA) +#define glWindowPos4sMESA GLEW_GET_FUN(__glewWindowPos4sMESA) +#define glWindowPos4svMESA GLEW_GET_FUN(__glewWindowPos4svMESA) + +#define GLEW_MESA_window_pos GLEW_GET_VAR(__GLEW_MESA_window_pos) + +#endif /* GL_MESA_window_pos */ + +/* ------------------------- GL_MESA_ycbcr_texture ------------------------- */ + +#ifndef GL_MESA_ycbcr_texture +#define GL_MESA_ycbcr_texture 1 + +#define GL_UNSIGNED_SHORT_8_8_MESA 0x85BA +#define GL_UNSIGNED_SHORT_8_8_REV_MESA 0x85BB +#define GL_YCBCR_MESA 0x8757 + +#define GLEW_MESA_ycbcr_texture GLEW_GET_VAR(__GLEW_MESA_ycbcr_texture) + +#endif /* GL_MESA_ycbcr_texture */ + +/* --------------------------- GL_NV_blend_square -------------------------- */ + +#ifndef GL_NV_blend_square +#define GL_NV_blend_square 1 + +#define GLEW_NV_blend_square GLEW_GET_VAR(__GLEW_NV_blend_square) + +#endif /* GL_NV_blend_square */ + +/* ------------------------ GL_NV_conditional_render ----------------------- */ + +#ifndef GL_NV_conditional_render +#define GL_NV_conditional_render 1 + +#define GL_QUERY_WAIT_NV 0x8E13 +#define GL_QUERY_NO_WAIT_NV 0x8E14 +#define GL_QUERY_BY_REGION_WAIT_NV 0x8E15 +#define GL_QUERY_BY_REGION_NO_WAIT_NV 0x8E16 + +typedef void (GLAPIENTRY * PFNGLBEGINCONDITIONALRENDERNVPROC) (GLuint id, GLenum mode); +typedef void (GLAPIENTRY * PFNGLENDCONDITIONALRENDERNVPROC) (void); + +#define glBeginConditionalRenderNV GLEW_GET_FUN(__glewBeginConditionalRenderNV) +#define glEndConditionalRenderNV GLEW_GET_FUN(__glewEndConditionalRenderNV) + +#define GLEW_NV_conditional_render GLEW_GET_VAR(__GLEW_NV_conditional_render) + +#endif /* GL_NV_conditional_render */ + +/* ----------------------- GL_NV_copy_depth_to_color ----------------------- */ + +#ifndef GL_NV_copy_depth_to_color +#define GL_NV_copy_depth_to_color 1 + +#define GL_DEPTH_STENCIL_TO_RGBA_NV 0x886E +#define GL_DEPTH_STENCIL_TO_BGRA_NV 0x886F + +#define GLEW_NV_copy_depth_to_color GLEW_GET_VAR(__GLEW_NV_copy_depth_to_color) + +#endif /* GL_NV_copy_depth_to_color */ + +/* ------------------------ GL_NV_depth_buffer_float ----------------------- */ + +#ifndef GL_NV_depth_buffer_float +#define GL_NV_depth_buffer_float 1 + +#define GL_DEPTH_COMPONENT32F_NV 0x8DAB +#define GL_DEPTH32F_STENCIL8_NV 0x8DAC +#define GL_FLOAT_32_UNSIGNED_INT_24_8_REV_NV 0x8DAD +#define GL_DEPTH_BUFFER_FLOAT_MODE_NV 0x8DAF + +typedef void (GLAPIENTRY * PFNGLCLEARDEPTHDNVPROC) (GLdouble depth); +typedef void (GLAPIENTRY * PFNGLDEPTHBOUNDSDNVPROC) (GLdouble zmin, GLdouble zmax); +typedef void (GLAPIENTRY * PFNGLDEPTHRANGEDNVPROC) (GLdouble zNear, GLdouble zFar); + +#define glClearDepthdNV GLEW_GET_FUN(__glewClearDepthdNV) +#define glDepthBoundsdNV GLEW_GET_FUN(__glewDepthBoundsdNV) +#define glDepthRangedNV GLEW_GET_FUN(__glewDepthRangedNV) + +#define GLEW_NV_depth_buffer_float GLEW_GET_VAR(__GLEW_NV_depth_buffer_float) + +#endif /* GL_NV_depth_buffer_float */ + +/* --------------------------- GL_NV_depth_clamp --------------------------- */ + +#ifndef GL_NV_depth_clamp +#define GL_NV_depth_clamp 1 + +#define GL_DEPTH_CLAMP_NV 0x864F + +#define GLEW_NV_depth_clamp GLEW_GET_VAR(__GLEW_NV_depth_clamp) + +#endif /* GL_NV_depth_clamp */ + +/* ---------------------- GL_NV_depth_range_unclamped ---------------------- */ + +#ifndef GL_NV_depth_range_unclamped +#define GL_NV_depth_range_unclamped 1 + +#define GL_SAMPLE_COUNT_BITS_NV 0x8864 +#define GL_CURRENT_SAMPLE_COUNT_QUERY_NV 0x8865 +#define GL_QUERY_RESULT_NV 0x8866 +#define GL_QUERY_RESULT_AVAILABLE_NV 0x8867 +#define GL_SAMPLE_COUNT_NV 0x8914 + +#define GLEW_NV_depth_range_unclamped GLEW_GET_VAR(__GLEW_NV_depth_range_unclamped) + +#endif /* GL_NV_depth_range_unclamped */ + +/* ---------------------------- GL_NV_evaluators --------------------------- */ + +#ifndef GL_NV_evaluators +#define GL_NV_evaluators 1 + +#define GL_EVAL_2D_NV 0x86C0 +#define GL_EVAL_TRIANGULAR_2D_NV 0x86C1 +#define GL_MAP_TESSELLATION_NV 0x86C2 +#define GL_MAP_ATTRIB_U_ORDER_NV 0x86C3 +#define GL_MAP_ATTRIB_V_ORDER_NV 0x86C4 +#define GL_EVAL_FRACTIONAL_TESSELLATION_NV 0x86C5 +#define GL_EVAL_VERTEX_ATTRIB0_NV 0x86C6 +#define GL_EVAL_VERTEX_ATTRIB1_NV 0x86C7 +#define GL_EVAL_VERTEX_ATTRIB2_NV 0x86C8 +#define GL_EVAL_VERTEX_ATTRIB3_NV 0x86C9 +#define GL_EVAL_VERTEX_ATTRIB4_NV 0x86CA +#define GL_EVAL_VERTEX_ATTRIB5_NV 0x86CB +#define GL_EVAL_VERTEX_ATTRIB6_NV 0x86CC +#define GL_EVAL_VERTEX_ATTRIB7_NV 0x86CD +#define GL_EVAL_VERTEX_ATTRIB8_NV 0x86CE +#define GL_EVAL_VERTEX_ATTRIB9_NV 0x86CF +#define GL_EVAL_VERTEX_ATTRIB10_NV 0x86D0 +#define GL_EVAL_VERTEX_ATTRIB11_NV 0x86D1 +#define GL_EVAL_VERTEX_ATTRIB12_NV 0x86D2 +#define GL_EVAL_VERTEX_ATTRIB13_NV 0x86D3 +#define GL_EVAL_VERTEX_ATTRIB14_NV 0x86D4 +#define GL_EVAL_VERTEX_ATTRIB15_NV 0x86D5 +#define GL_MAX_MAP_TESSELLATION_NV 0x86D6 +#define GL_MAX_RATIONAL_EVAL_ORDER_NV 0x86D7 + +typedef void (GLAPIENTRY * PFNGLEVALMAPSNVPROC) (GLenum target, GLenum mode); +typedef void (GLAPIENTRY * PFNGLGETMAPATTRIBPARAMETERFVNVPROC) (GLenum target, GLuint index, GLenum pname, GLfloat* params); +typedef void (GLAPIENTRY * PFNGLGETMAPATTRIBPARAMETERIVNVPROC) (GLenum target, GLuint index, GLenum pname, GLint* params); +typedef void (GLAPIENTRY * PFNGLGETMAPCONTROLPOINTSNVPROC) (GLenum target, GLuint index, GLenum type, GLsizei ustride, GLsizei vstride, GLboolean packed, void* points); +typedef void (GLAPIENTRY * PFNGLGETMAPPARAMETERFVNVPROC) (GLenum target, GLenum pname, GLfloat* params); +typedef void (GLAPIENTRY * PFNGLGETMAPPARAMETERIVNVPROC) (GLenum target, GLenum pname, GLint* params); +typedef void (GLAPIENTRY * PFNGLMAPCONTROLPOINTSNVPROC) (GLenum target, GLuint index, GLenum type, GLsizei ustride, GLsizei vstride, GLint uorder, GLint vorder, GLboolean packed, const void* points); +typedef void (GLAPIENTRY * PFNGLMAPPARAMETERFVNVPROC) (GLenum target, GLenum pname, const GLfloat* params); +typedef void (GLAPIENTRY * PFNGLMAPPARAMETERIVNVPROC) (GLenum target, GLenum pname, const GLint* params); + +#define glEvalMapsNV GLEW_GET_FUN(__glewEvalMapsNV) +#define glGetMapAttribParameterfvNV GLEW_GET_FUN(__glewGetMapAttribParameterfvNV) +#define glGetMapAttribParameterivNV GLEW_GET_FUN(__glewGetMapAttribParameterivNV) +#define glGetMapControlPointsNV GLEW_GET_FUN(__glewGetMapControlPointsNV) +#define glGetMapParameterfvNV GLEW_GET_FUN(__glewGetMapParameterfvNV) +#define glGetMapParameterivNV GLEW_GET_FUN(__glewGetMapParameterivNV) +#define glMapControlPointsNV GLEW_GET_FUN(__glewMapControlPointsNV) +#define glMapParameterfvNV GLEW_GET_FUN(__glewMapParameterfvNV) +#define glMapParameterivNV GLEW_GET_FUN(__glewMapParameterivNV) + +#define GLEW_NV_evaluators GLEW_GET_VAR(__GLEW_NV_evaluators) + +#endif /* GL_NV_evaluators */ + +/* ----------------------- GL_NV_explicit_multisample ---------------------- */ + +#ifndef GL_NV_explicit_multisample +#define GL_NV_explicit_multisample 1 + +#define GL_SAMPLE_POSITION_NV 0x8E50 +#define GL_SAMPLE_MASK_NV 0x8E51 +#define GL_SAMPLE_MASK_VALUE_NV 0x8E52 +#define GL_TEXTURE_BINDING_RENDERBUFFER_NV 0x8E53 +#define GL_TEXTURE_RENDERBUFFER_DATA_STORE_BINDING_NV 0x8E54 +#define GL_TEXTURE_RENDERBUFFER_NV 0x8E55 +#define GL_SAMPLER_RENDERBUFFER_NV 0x8E56 +#define GL_INT_SAMPLER_RENDERBUFFER_NV 0x8E57 +#define GL_UNSIGNED_INT_SAMPLER_RENDERBUFFER_NV 0x8E58 +#define GL_MAX_SAMPLE_MASK_WORDS_NV 0x8E59 + +typedef void (GLAPIENTRY * PFNGLGETMULTISAMPLEFVNVPROC) (GLenum pname, GLuint index, GLfloat* val); +typedef void (GLAPIENTRY * PFNGLSAMPLEMASKINDEXEDNVPROC) (GLuint index, GLbitfield mask); +typedef void (GLAPIENTRY * PFNGLTEXRENDERBUFFERNVPROC) (GLenum target, GLuint renderbuffer); + +#define glGetMultisamplefvNV GLEW_GET_FUN(__glewGetMultisamplefvNV) +#define glSampleMaskIndexedNV GLEW_GET_FUN(__glewSampleMaskIndexedNV) +#define glTexRenderbufferNV GLEW_GET_FUN(__glewTexRenderbufferNV) + +#define GLEW_NV_explicit_multisample GLEW_GET_VAR(__GLEW_NV_explicit_multisample) + +#endif /* GL_NV_explicit_multisample */ + +/* ------------------------------ GL_NV_fence ------------------------------ */ + +#ifndef GL_NV_fence +#define GL_NV_fence 1 + +#define GL_ALL_COMPLETED_NV 0x84F2 +#define GL_FENCE_STATUS_NV 0x84F3 +#define GL_FENCE_CONDITION_NV 0x84F4 + +typedef void (GLAPIENTRY * PFNGLDELETEFENCESNVPROC) (GLsizei n, const GLuint* fences); +typedef void (GLAPIENTRY * PFNGLFINISHFENCENVPROC) (GLuint fence); +typedef void (GLAPIENTRY * PFNGLGENFENCESNVPROC) (GLsizei n, GLuint* fences); +typedef void (GLAPIENTRY * PFNGLGETFENCEIVNVPROC) (GLuint fence, GLenum pname, GLint* params); +typedef GLboolean (GLAPIENTRY * PFNGLISFENCENVPROC) (GLuint fence); +typedef void (GLAPIENTRY * PFNGLSETFENCENVPROC) (GLuint fence, GLenum condition); +typedef GLboolean (GLAPIENTRY * PFNGLTESTFENCENVPROC) (GLuint fence); + +#define glDeleteFencesNV GLEW_GET_FUN(__glewDeleteFencesNV) +#define glFinishFenceNV GLEW_GET_FUN(__glewFinishFenceNV) +#define glGenFencesNV GLEW_GET_FUN(__glewGenFencesNV) +#define glGetFenceivNV GLEW_GET_FUN(__glewGetFenceivNV) +#define glIsFenceNV GLEW_GET_FUN(__glewIsFenceNV) +#define glSetFenceNV GLEW_GET_FUN(__glewSetFenceNV) +#define glTestFenceNV GLEW_GET_FUN(__glewTestFenceNV) + +#define GLEW_NV_fence GLEW_GET_VAR(__GLEW_NV_fence) + +#endif /* GL_NV_fence */ + +/* --------------------------- GL_NV_float_buffer -------------------------- */ + +#ifndef GL_NV_float_buffer +#define GL_NV_float_buffer 1 + +#define GL_FLOAT_R_NV 0x8880 +#define GL_FLOAT_RG_NV 0x8881 +#define GL_FLOAT_RGB_NV 0x8882 +#define GL_FLOAT_RGBA_NV 0x8883 +#define GL_FLOAT_R16_NV 0x8884 +#define GL_FLOAT_R32_NV 0x8885 +#define GL_FLOAT_RG16_NV 0x8886 +#define GL_FLOAT_RG32_NV 0x8887 +#define GL_FLOAT_RGB16_NV 0x8888 +#define GL_FLOAT_RGB32_NV 0x8889 +#define GL_FLOAT_RGBA16_NV 0x888A +#define GL_FLOAT_RGBA32_NV 0x888B +#define GL_TEXTURE_FLOAT_COMPONENTS_NV 0x888C +#define GL_FLOAT_CLEAR_COLOR_VALUE_NV 0x888D +#define GL_FLOAT_RGBA_MODE_NV 0x888E + +#define GLEW_NV_float_buffer GLEW_GET_VAR(__GLEW_NV_float_buffer) + +#endif /* GL_NV_float_buffer */ + +/* --------------------------- GL_NV_fog_distance -------------------------- */ + +#ifndef GL_NV_fog_distance +#define GL_NV_fog_distance 1 + +#define GL_FOG_DISTANCE_MODE_NV 0x855A +#define GL_EYE_RADIAL_NV 0x855B +#define GL_EYE_PLANE_ABSOLUTE_NV 0x855C + +#define GLEW_NV_fog_distance GLEW_GET_VAR(__GLEW_NV_fog_distance) + +#endif /* GL_NV_fog_distance */ + +/* ------------------------- GL_NV_fragment_program ------------------------ */ + +#ifndef GL_NV_fragment_program +#define GL_NV_fragment_program 1 + +#define GL_MAX_FRAGMENT_PROGRAM_LOCAL_PARAMETERS_NV 0x8868 +#define GL_FRAGMENT_PROGRAM_NV 0x8870 +#define GL_MAX_TEXTURE_COORDS_NV 0x8871 +#define GL_MAX_TEXTURE_IMAGE_UNITS_NV 0x8872 +#define GL_FRAGMENT_PROGRAM_BINDING_NV 0x8873 +#define GL_PROGRAM_ERROR_STRING_NV 0x8874 + +typedef void (GLAPIENTRY * PFNGLGETPROGRAMNAMEDPARAMETERDVNVPROC) (GLuint id, GLsizei len, const GLubyte* name, GLdouble *params); +typedef void (GLAPIENTRY * PFNGLGETPROGRAMNAMEDPARAMETERFVNVPROC) (GLuint id, GLsizei len, const GLubyte* name, GLfloat *params); +typedef void (GLAPIENTRY * PFNGLPROGRAMNAMEDPARAMETER4DNVPROC) (GLuint id, GLsizei len, const GLubyte* name, GLdouble x, GLdouble y, GLdouble z, GLdouble w); +typedef void (GLAPIENTRY * PFNGLPROGRAMNAMEDPARAMETER4DVNVPROC) (GLuint id, GLsizei len, const GLubyte* name, const GLdouble v[]); +typedef void (GLAPIENTRY * PFNGLPROGRAMNAMEDPARAMETER4FNVPROC) (GLuint id, GLsizei len, const GLubyte* name, GLfloat x, GLfloat y, GLfloat z, GLfloat w); +typedef void (GLAPIENTRY * PFNGLPROGRAMNAMEDPARAMETER4FVNVPROC) (GLuint id, GLsizei len, const GLubyte* name, const GLfloat v[]); + +#define glGetProgramNamedParameterdvNV GLEW_GET_FUN(__glewGetProgramNamedParameterdvNV) +#define glGetProgramNamedParameterfvNV GLEW_GET_FUN(__glewGetProgramNamedParameterfvNV) +#define glProgramNamedParameter4dNV GLEW_GET_FUN(__glewProgramNamedParameter4dNV) +#define glProgramNamedParameter4dvNV GLEW_GET_FUN(__glewProgramNamedParameter4dvNV) +#define glProgramNamedParameter4fNV GLEW_GET_FUN(__glewProgramNamedParameter4fNV) +#define glProgramNamedParameter4fvNV GLEW_GET_FUN(__glewProgramNamedParameter4fvNV) + +#define GLEW_NV_fragment_program GLEW_GET_VAR(__GLEW_NV_fragment_program) + +#endif /* GL_NV_fragment_program */ + +/* ------------------------ GL_NV_fragment_program2 ------------------------ */ + +#ifndef GL_NV_fragment_program2 +#define GL_NV_fragment_program2 1 + +#define GL_MAX_PROGRAM_EXEC_INSTRUCTIONS_NV 0x88F4 +#define GL_MAX_PROGRAM_CALL_DEPTH_NV 0x88F5 +#define GL_MAX_PROGRAM_IF_DEPTH_NV 0x88F6 +#define GL_MAX_PROGRAM_LOOP_DEPTH_NV 0x88F7 +#define GL_MAX_PROGRAM_LOOP_COUNT_NV 0x88F8 + +#define GLEW_NV_fragment_program2 GLEW_GET_VAR(__GLEW_NV_fragment_program2) + +#endif /* GL_NV_fragment_program2 */ + +/* ------------------------ GL_NV_fragment_program4 ------------------------ */ + +#ifndef GL_NV_fragment_program4 +#define GL_NV_fragment_program4 1 + +#define GLEW_NV_fragment_program4 GLEW_GET_VAR(__GLEW_NV_fragment_program4) + +#endif /* GL_NV_fragment_program4 */ + +/* --------------------- GL_NV_fragment_program_option --------------------- */ + +#ifndef GL_NV_fragment_program_option +#define GL_NV_fragment_program_option 1 + +#define GLEW_NV_fragment_program_option GLEW_GET_VAR(__GLEW_NV_fragment_program_option) + +#endif /* GL_NV_fragment_program_option */ + +/* ----------------- GL_NV_framebuffer_multisample_coverage ---------------- */ + +#ifndef GL_NV_framebuffer_multisample_coverage +#define GL_NV_framebuffer_multisample_coverage 1 + +#define GL_RENDERBUFFER_COVERAGE_SAMPLES_NV 0x8CAB +#define GL_RENDERBUFFER_COLOR_SAMPLES_NV 0x8E10 +#define GL_MAX_MULTISAMPLE_COVERAGE_MODES_NV 0x8E11 +#define GL_MULTISAMPLE_COVERAGE_MODES_NV 0x8E12 + +typedef void (GLAPIENTRY * PFNGLRENDERBUFFERSTORAGEMULTISAMPLECOVERAGENVPROC) (GLenum target, GLsizei coverageSamples, GLsizei colorSamples, GLenum internalformat, GLsizei width, GLsizei height); + +#define glRenderbufferStorageMultisampleCoverageNV GLEW_GET_FUN(__glewRenderbufferStorageMultisampleCoverageNV) + +#define GLEW_NV_framebuffer_multisample_coverage GLEW_GET_VAR(__GLEW_NV_framebuffer_multisample_coverage) + +#endif /* GL_NV_framebuffer_multisample_coverage */ + +/* ------------------------ GL_NV_geometry_program4 ------------------------ */ + +#ifndef GL_NV_geometry_program4 +#define GL_NV_geometry_program4 1 + +#define GL_GEOMETRY_PROGRAM_NV 0x8C26 +#define GL_MAX_PROGRAM_OUTPUT_VERTICES_NV 0x8C27 +#define GL_MAX_PROGRAM_TOTAL_OUTPUT_COMPONENTS_NV 0x8C28 + +typedef void (GLAPIENTRY * PFNGLPROGRAMVERTEXLIMITNVPROC) (GLenum target, GLint limit); + +#define glProgramVertexLimitNV GLEW_GET_FUN(__glewProgramVertexLimitNV) + +#define GLEW_NV_geometry_program4 GLEW_GET_VAR(__GLEW_NV_geometry_program4) + +#endif /* GL_NV_geometry_program4 */ + +/* ------------------------- GL_NV_geometry_shader4 ------------------------ */ + +#ifndef GL_NV_geometry_shader4 +#define GL_NV_geometry_shader4 1 + +#define GLEW_NV_geometry_shader4 GLEW_GET_VAR(__GLEW_NV_geometry_shader4) + +#endif /* GL_NV_geometry_shader4 */ + +/* --------------------------- GL_NV_gpu_program4 -------------------------- */ + +#ifndef GL_NV_gpu_program4 +#define GL_NV_gpu_program4 1 + +#define GL_MIN_PROGRAM_TEXEL_OFFSET_NV 0x8904 +#define GL_MAX_PROGRAM_TEXEL_OFFSET_NV 0x8905 +#define GL_PROGRAM_ATTRIB_COMPONENTS_NV 0x8906 +#define GL_PROGRAM_RESULT_COMPONENTS_NV 0x8907 +#define GL_MAX_PROGRAM_ATTRIB_COMPONENTS_NV 0x8908 +#define GL_MAX_PROGRAM_RESULT_COMPONENTS_NV 0x8909 +#define GL_MAX_PROGRAM_GENERIC_ATTRIBS_NV 0x8DA5 +#define GL_MAX_PROGRAM_GENERIC_RESULTS_NV 0x8DA6 + +typedef void (GLAPIENTRY * PFNGLPROGRAMENVPARAMETERI4INVPROC) (GLenum target, GLuint index, GLint x, GLint y, GLint z, GLint w); +typedef void (GLAPIENTRY * PFNGLPROGRAMENVPARAMETERI4IVNVPROC) (GLenum target, GLuint index, const GLint *params); +typedef void (GLAPIENTRY * PFNGLPROGRAMENVPARAMETERI4UINVPROC) (GLenum target, GLuint index, GLuint x, GLuint y, GLuint z, GLuint w); +typedef void (GLAPIENTRY * PFNGLPROGRAMENVPARAMETERI4UIVNVPROC) (GLenum target, GLuint index, const GLuint *params); +typedef void (GLAPIENTRY * PFNGLPROGRAMENVPARAMETERSI4IVNVPROC) (GLenum target, GLuint index, GLsizei count, const GLint *params); +typedef void (GLAPIENTRY * PFNGLPROGRAMENVPARAMETERSI4UIVNVPROC) (GLenum target, GLuint index, GLsizei count, const GLuint *params); +typedef void (GLAPIENTRY * PFNGLPROGRAMLOCALPARAMETERI4INVPROC) (GLenum target, GLuint index, GLint x, GLint y, GLint z, GLint w); +typedef void (GLAPIENTRY * PFNGLPROGRAMLOCALPARAMETERI4IVNVPROC) (GLenum target, GLuint index, const GLint *params); +typedef void (GLAPIENTRY * PFNGLPROGRAMLOCALPARAMETERI4UINVPROC) (GLenum target, GLuint index, GLuint x, GLuint y, GLuint z, GLuint w); +typedef void (GLAPIENTRY * PFNGLPROGRAMLOCALPARAMETERI4UIVNVPROC) (GLenum target, GLuint index, const GLuint *params); +typedef void (GLAPIENTRY * PFNGLPROGRAMLOCALPARAMETERSI4IVNVPROC) (GLenum target, GLuint index, GLsizei count, const GLint *params); +typedef void (GLAPIENTRY * PFNGLPROGRAMLOCALPARAMETERSI4UIVNVPROC) (GLenum target, GLuint index, GLsizei count, const GLuint *params); + +#define glProgramEnvParameterI4iNV GLEW_GET_FUN(__glewProgramEnvParameterI4iNV) +#define glProgramEnvParameterI4ivNV GLEW_GET_FUN(__glewProgramEnvParameterI4ivNV) +#define glProgramEnvParameterI4uiNV GLEW_GET_FUN(__glewProgramEnvParameterI4uiNV) +#define glProgramEnvParameterI4uivNV GLEW_GET_FUN(__glewProgramEnvParameterI4uivNV) +#define glProgramEnvParametersI4ivNV GLEW_GET_FUN(__glewProgramEnvParametersI4ivNV) +#define glProgramEnvParametersI4uivNV GLEW_GET_FUN(__glewProgramEnvParametersI4uivNV) +#define glProgramLocalParameterI4iNV GLEW_GET_FUN(__glewProgramLocalParameterI4iNV) +#define glProgramLocalParameterI4ivNV GLEW_GET_FUN(__glewProgramLocalParameterI4ivNV) +#define glProgramLocalParameterI4uiNV GLEW_GET_FUN(__glewProgramLocalParameterI4uiNV) +#define glProgramLocalParameterI4uivNV GLEW_GET_FUN(__glewProgramLocalParameterI4uivNV) +#define glProgramLocalParametersI4ivNV GLEW_GET_FUN(__glewProgramLocalParametersI4ivNV) +#define glProgramLocalParametersI4uivNV GLEW_GET_FUN(__glewProgramLocalParametersI4uivNV) + +#define GLEW_NV_gpu_program4 GLEW_GET_VAR(__GLEW_NV_gpu_program4) + +#endif /* GL_NV_gpu_program4 */ + +/* ---------------------------- GL_NV_half_float --------------------------- */ + +#ifndef GL_NV_half_float +#define GL_NV_half_float 1 + +#define GL_HALF_FLOAT_NV 0x140B + +typedef unsigned short GLhalf; + +typedef void (GLAPIENTRY * PFNGLCOLOR3HNVPROC) (GLhalf red, GLhalf green, GLhalf blue); +typedef void (GLAPIENTRY * PFNGLCOLOR3HVNVPROC) (const GLhalf* v); +typedef void (GLAPIENTRY * PFNGLCOLOR4HNVPROC) (GLhalf red, GLhalf green, GLhalf blue, GLhalf alpha); +typedef void (GLAPIENTRY * PFNGLCOLOR4HVNVPROC) (const GLhalf* v); +typedef void (GLAPIENTRY * PFNGLFOGCOORDHNVPROC) (GLhalf fog); +typedef void (GLAPIENTRY * PFNGLFOGCOORDHVNVPROC) (const GLhalf* fog); +typedef void (GLAPIENTRY * PFNGLMULTITEXCOORD1HNVPROC) (GLenum target, GLhalf s); +typedef void (GLAPIENTRY * PFNGLMULTITEXCOORD1HVNVPROC) (GLenum target, const GLhalf* v); +typedef void (GLAPIENTRY * PFNGLMULTITEXCOORD2HNVPROC) (GLenum target, GLhalf s, GLhalf t); +typedef void (GLAPIENTRY * PFNGLMULTITEXCOORD2HVNVPROC) (GLenum target, const GLhalf* v); +typedef void (GLAPIENTRY * PFNGLMULTITEXCOORD3HNVPROC) (GLenum target, GLhalf s, GLhalf t, GLhalf r); +typedef void (GLAPIENTRY * PFNGLMULTITEXCOORD3HVNVPROC) (GLenum target, const GLhalf* v); +typedef void (GLAPIENTRY * PFNGLMULTITEXCOORD4HNVPROC) (GLenum target, GLhalf s, GLhalf t, GLhalf r, GLhalf q); +typedef void (GLAPIENTRY * PFNGLMULTITEXCOORD4HVNVPROC) (GLenum target, const GLhalf* v); +typedef void (GLAPIENTRY * PFNGLNORMAL3HNVPROC) (GLhalf nx, GLhalf ny, GLhalf nz); +typedef void (GLAPIENTRY * PFNGLNORMAL3HVNVPROC) (const GLhalf* v); +typedef void (GLAPIENTRY * PFNGLSECONDARYCOLOR3HNVPROC) (GLhalf red, GLhalf green, GLhalf blue); +typedef void (GLAPIENTRY * PFNGLSECONDARYCOLOR3HVNVPROC) (const GLhalf* v); +typedef void (GLAPIENTRY * PFNGLTEXCOORD1HNVPROC) (GLhalf s); +typedef void (GLAPIENTRY * PFNGLTEXCOORD1HVNVPROC) (const GLhalf* v); +typedef void (GLAPIENTRY * PFNGLTEXCOORD2HNVPROC) (GLhalf s, GLhalf t); +typedef void (GLAPIENTRY * PFNGLTEXCOORD2HVNVPROC) (const GLhalf* v); +typedef void (GLAPIENTRY * PFNGLTEXCOORD3HNVPROC) (GLhalf s, GLhalf t, GLhalf r); +typedef void (GLAPIENTRY * PFNGLTEXCOORD3HVNVPROC) (const GLhalf* v); +typedef void (GLAPIENTRY * PFNGLTEXCOORD4HNVPROC) (GLhalf s, GLhalf t, GLhalf r, GLhalf q); +typedef void (GLAPIENTRY * PFNGLTEXCOORD4HVNVPROC) (const GLhalf* v); +typedef void (GLAPIENTRY * PFNGLVERTEX2HNVPROC) (GLhalf x, GLhalf y); +typedef void (GLAPIENTRY * PFNGLVERTEX2HVNVPROC) (const GLhalf* v); +typedef void (GLAPIENTRY * PFNGLVERTEX3HNVPROC) (GLhalf x, GLhalf y, GLhalf z); +typedef void (GLAPIENTRY * PFNGLVERTEX3HVNVPROC) (const GLhalf* v); +typedef void (GLAPIENTRY * PFNGLVERTEX4HNVPROC) (GLhalf x, GLhalf y, GLhalf z, GLhalf w); +typedef void (GLAPIENTRY * PFNGLVERTEX4HVNVPROC) (const GLhalf* v); +typedef void (GLAPIENTRY * PFNGLVERTEXATTRIB1HNVPROC) (GLuint index, GLhalf x); +typedef void (GLAPIENTRY * PFNGLVERTEXATTRIB1HVNVPROC) (GLuint index, const GLhalf* v); +typedef void (GLAPIENTRY * PFNGLVERTEXATTRIB2HNVPROC) (GLuint index, GLhalf x, GLhalf y); +typedef void (GLAPIENTRY * PFNGLVERTEXATTRIB2HVNVPROC) (GLuint index, const GLhalf* v); +typedef void (GLAPIENTRY * PFNGLVERTEXATTRIB3HNVPROC) (GLuint index, GLhalf x, GLhalf y, GLhalf z); +typedef void (GLAPIENTRY * PFNGLVERTEXATTRIB3HVNVPROC) (GLuint index, const GLhalf* v); +typedef void (GLAPIENTRY * PFNGLVERTEXATTRIB4HNVPROC) (GLuint index, GLhalf x, GLhalf y, GLhalf z, GLhalf w); +typedef void (GLAPIENTRY * PFNGLVERTEXATTRIB4HVNVPROC) (GLuint index, const GLhalf* v); +typedef void (GLAPIENTRY * PFNGLVERTEXATTRIBS1HVNVPROC) (GLuint index, GLsizei n, const GLhalf* v); +typedef void (GLAPIENTRY * PFNGLVERTEXATTRIBS2HVNVPROC) (GLuint index, GLsizei n, const GLhalf* v); +typedef void (GLAPIENTRY * PFNGLVERTEXATTRIBS3HVNVPROC) (GLuint index, GLsizei n, const GLhalf* v); +typedef void (GLAPIENTRY * PFNGLVERTEXATTRIBS4HVNVPROC) (GLuint index, GLsizei n, const GLhalf* v); +typedef void (GLAPIENTRY * PFNGLVERTEXWEIGHTHNVPROC) (GLhalf weight); +typedef void (GLAPIENTRY * PFNGLVERTEXWEIGHTHVNVPROC) (const GLhalf* weight); + +#define glColor3hNV GLEW_GET_FUN(__glewColor3hNV) +#define glColor3hvNV GLEW_GET_FUN(__glewColor3hvNV) +#define glColor4hNV GLEW_GET_FUN(__glewColor4hNV) +#define glColor4hvNV GLEW_GET_FUN(__glewColor4hvNV) +#define glFogCoordhNV GLEW_GET_FUN(__glewFogCoordhNV) +#define glFogCoordhvNV GLEW_GET_FUN(__glewFogCoordhvNV) +#define glMultiTexCoord1hNV GLEW_GET_FUN(__glewMultiTexCoord1hNV) +#define glMultiTexCoord1hvNV GLEW_GET_FUN(__glewMultiTexCoord1hvNV) +#define glMultiTexCoord2hNV GLEW_GET_FUN(__glewMultiTexCoord2hNV) +#define glMultiTexCoord2hvNV GLEW_GET_FUN(__glewMultiTexCoord2hvNV) +#define glMultiTexCoord3hNV GLEW_GET_FUN(__glewMultiTexCoord3hNV) +#define glMultiTexCoord3hvNV GLEW_GET_FUN(__glewMultiTexCoord3hvNV) +#define glMultiTexCoord4hNV GLEW_GET_FUN(__glewMultiTexCoord4hNV) +#define glMultiTexCoord4hvNV GLEW_GET_FUN(__glewMultiTexCoord4hvNV) +#define glNormal3hNV GLEW_GET_FUN(__glewNormal3hNV) +#define glNormal3hvNV GLEW_GET_FUN(__glewNormal3hvNV) +#define glSecondaryColor3hNV GLEW_GET_FUN(__glewSecondaryColor3hNV) +#define glSecondaryColor3hvNV GLEW_GET_FUN(__glewSecondaryColor3hvNV) +#define glTexCoord1hNV GLEW_GET_FUN(__glewTexCoord1hNV) +#define glTexCoord1hvNV GLEW_GET_FUN(__glewTexCoord1hvNV) +#define glTexCoord2hNV GLEW_GET_FUN(__glewTexCoord2hNV) +#define glTexCoord2hvNV GLEW_GET_FUN(__glewTexCoord2hvNV) +#define glTexCoord3hNV GLEW_GET_FUN(__glewTexCoord3hNV) +#define glTexCoord3hvNV GLEW_GET_FUN(__glewTexCoord3hvNV) +#define glTexCoord4hNV GLEW_GET_FUN(__glewTexCoord4hNV) +#define glTexCoord4hvNV GLEW_GET_FUN(__glewTexCoord4hvNV) +#define glVertex2hNV GLEW_GET_FUN(__glewVertex2hNV) +#define glVertex2hvNV GLEW_GET_FUN(__glewVertex2hvNV) +#define glVertex3hNV GLEW_GET_FUN(__glewVertex3hNV) +#define glVertex3hvNV GLEW_GET_FUN(__glewVertex3hvNV) +#define glVertex4hNV GLEW_GET_FUN(__glewVertex4hNV) +#define glVertex4hvNV GLEW_GET_FUN(__glewVertex4hvNV) +#define glVertexAttrib1hNV GLEW_GET_FUN(__glewVertexAttrib1hNV) +#define glVertexAttrib1hvNV GLEW_GET_FUN(__glewVertexAttrib1hvNV) +#define glVertexAttrib2hNV GLEW_GET_FUN(__glewVertexAttrib2hNV) +#define glVertexAttrib2hvNV GLEW_GET_FUN(__glewVertexAttrib2hvNV) +#define glVertexAttrib3hNV GLEW_GET_FUN(__glewVertexAttrib3hNV) +#define glVertexAttrib3hvNV GLEW_GET_FUN(__glewVertexAttrib3hvNV) +#define glVertexAttrib4hNV GLEW_GET_FUN(__glewVertexAttrib4hNV) +#define glVertexAttrib4hvNV GLEW_GET_FUN(__glewVertexAttrib4hvNV) +#define glVertexAttribs1hvNV GLEW_GET_FUN(__glewVertexAttribs1hvNV) +#define glVertexAttribs2hvNV GLEW_GET_FUN(__glewVertexAttribs2hvNV) +#define glVertexAttribs3hvNV GLEW_GET_FUN(__glewVertexAttribs3hvNV) +#define glVertexAttribs4hvNV GLEW_GET_FUN(__glewVertexAttribs4hvNV) +#define glVertexWeighthNV GLEW_GET_FUN(__glewVertexWeighthNV) +#define glVertexWeighthvNV GLEW_GET_FUN(__glewVertexWeighthvNV) + +#define GLEW_NV_half_float GLEW_GET_VAR(__GLEW_NV_half_float) + +#endif /* GL_NV_half_float */ + +/* ------------------------ GL_NV_light_max_exponent ----------------------- */ + +#ifndef GL_NV_light_max_exponent +#define GL_NV_light_max_exponent 1 + +#define GL_MAX_SHININESS_NV 0x8504 +#define GL_MAX_SPOT_EXPONENT_NV 0x8505 + +#define GLEW_NV_light_max_exponent GLEW_GET_VAR(__GLEW_NV_light_max_exponent) + +#endif /* GL_NV_light_max_exponent */ + +/* --------------------- GL_NV_multisample_filter_hint --------------------- */ + +#ifndef GL_NV_multisample_filter_hint +#define GL_NV_multisample_filter_hint 1 + +#define GL_MULTISAMPLE_FILTER_HINT_NV 0x8534 + +#define GLEW_NV_multisample_filter_hint GLEW_GET_VAR(__GLEW_NV_multisample_filter_hint) + +#endif /* GL_NV_multisample_filter_hint */ + +/* ------------------------- GL_NV_occlusion_query ------------------------- */ + +#ifndef GL_NV_occlusion_query +#define GL_NV_occlusion_query 1 + +#define GL_PIXEL_COUNTER_BITS_NV 0x8864 +#define GL_CURRENT_OCCLUSION_QUERY_ID_NV 0x8865 +#define GL_PIXEL_COUNT_NV 0x8866 +#define GL_PIXEL_COUNT_AVAILABLE_NV 0x8867 + +typedef void (GLAPIENTRY * PFNGLBEGINOCCLUSIONQUERYNVPROC) (GLuint id); +typedef void (GLAPIENTRY * PFNGLDELETEOCCLUSIONQUERIESNVPROC) (GLsizei n, const GLuint* ids); +typedef void (GLAPIENTRY * PFNGLENDOCCLUSIONQUERYNVPROC) (void); +typedef void (GLAPIENTRY * PFNGLGENOCCLUSIONQUERIESNVPROC) (GLsizei n, GLuint* ids); +typedef void (GLAPIENTRY * PFNGLGETOCCLUSIONQUERYIVNVPROC) (GLuint id, GLenum pname, GLint* params); +typedef void (GLAPIENTRY * PFNGLGETOCCLUSIONQUERYUIVNVPROC) (GLuint id, GLenum pname, GLuint* params); +typedef GLboolean (GLAPIENTRY * PFNGLISOCCLUSIONQUERYNVPROC) (GLuint id); + +#define glBeginOcclusionQueryNV GLEW_GET_FUN(__glewBeginOcclusionQueryNV) +#define glDeleteOcclusionQueriesNV GLEW_GET_FUN(__glewDeleteOcclusionQueriesNV) +#define glEndOcclusionQueryNV GLEW_GET_FUN(__glewEndOcclusionQueryNV) +#define glGenOcclusionQueriesNV GLEW_GET_FUN(__glewGenOcclusionQueriesNV) +#define glGetOcclusionQueryivNV GLEW_GET_FUN(__glewGetOcclusionQueryivNV) +#define glGetOcclusionQueryuivNV GLEW_GET_FUN(__glewGetOcclusionQueryuivNV) +#define glIsOcclusionQueryNV GLEW_GET_FUN(__glewIsOcclusionQueryNV) + +#define GLEW_NV_occlusion_query GLEW_GET_VAR(__GLEW_NV_occlusion_query) + +#endif /* GL_NV_occlusion_query */ + +/* ----------------------- GL_NV_packed_depth_stencil ---------------------- */ + +#ifndef GL_NV_packed_depth_stencil +#define GL_NV_packed_depth_stencil 1 + +#define GL_DEPTH_STENCIL_NV 0x84F9 +#define GL_UNSIGNED_INT_24_8_NV 0x84FA + +#define GLEW_NV_packed_depth_stencil GLEW_GET_VAR(__GLEW_NV_packed_depth_stencil) + +#endif /* GL_NV_packed_depth_stencil */ + +/* --------------------- GL_NV_parameter_buffer_object --------------------- */ + +#ifndef GL_NV_parameter_buffer_object +#define GL_NV_parameter_buffer_object 1 + +#define GL_MAX_PROGRAM_PARAMETER_BUFFER_BINDINGS_NV 0x8DA0 +#define GL_MAX_PROGRAM_PARAMETER_BUFFER_SIZE_NV 0x8DA1 +#define GL_VERTEX_PROGRAM_PARAMETER_BUFFER_NV 0x8DA2 +#define GL_GEOMETRY_PROGRAM_PARAMETER_BUFFER_NV 0x8DA3 +#define GL_FRAGMENT_PROGRAM_PARAMETER_BUFFER_NV 0x8DA4 + +typedef void (GLAPIENTRY * PFNGLPROGRAMBUFFERPARAMETERSIIVNVPROC) (GLenum target, GLuint buffer, GLuint index, GLsizei count, const GLint *params); +typedef void (GLAPIENTRY * PFNGLPROGRAMBUFFERPARAMETERSIUIVNVPROC) (GLenum target, GLuint buffer, GLuint index, GLsizei count, const GLuint *params); +typedef void (GLAPIENTRY * PFNGLPROGRAMBUFFERPARAMETERSFVNVPROC) (GLenum target, GLuint buffer, GLuint index, GLsizei count, const GLfloat *params); + +#define glProgramBufferParametersIivNV GLEW_GET_FUN(__glewProgramBufferParametersIivNV) +#define glProgramBufferParametersIuivNV GLEW_GET_FUN(__glewProgramBufferParametersIuivNV) +#define glProgramBufferParametersfvNV GLEW_GET_FUN(__glewProgramBufferParametersfvNV) + +#define GLEW_NV_parameter_buffer_object GLEW_GET_VAR(__GLEW_NV_parameter_buffer_object) + +#endif /* GL_NV_parameter_buffer_object */ + +/* ------------------------- GL_NV_pixel_data_range ------------------------ */ + +#ifndef GL_NV_pixel_data_range +#define GL_NV_pixel_data_range 1 + +#define GL_WRITE_PIXEL_DATA_RANGE_NV 0x8878 +#define GL_READ_PIXEL_DATA_RANGE_NV 0x8879 +#define GL_WRITE_PIXEL_DATA_RANGE_LENGTH_NV 0x887A +#define GL_READ_PIXEL_DATA_RANGE_LENGTH_NV 0x887B +#define GL_WRITE_PIXEL_DATA_RANGE_POINTER_NV 0x887C +#define GL_READ_PIXEL_DATA_RANGE_POINTER_NV 0x887D + +typedef void (GLAPIENTRY * PFNGLFLUSHPIXELDATARANGENVPROC) (GLenum target); +typedef void (GLAPIENTRY * PFNGLPIXELDATARANGENVPROC) (GLenum target, GLsizei length, void* pointer); + +#define glFlushPixelDataRangeNV GLEW_GET_FUN(__glewFlushPixelDataRangeNV) +#define glPixelDataRangeNV GLEW_GET_FUN(__glewPixelDataRangeNV) + +#define GLEW_NV_pixel_data_range GLEW_GET_VAR(__GLEW_NV_pixel_data_range) + +#endif /* GL_NV_pixel_data_range */ + +/* --------------------------- GL_NV_point_sprite -------------------------- */ + +#ifndef GL_NV_point_sprite +#define GL_NV_point_sprite 1 + +#define GL_POINT_SPRITE_NV 0x8861 +#define GL_COORD_REPLACE_NV 0x8862 +#define GL_POINT_SPRITE_R_MODE_NV 0x8863 + +typedef void (GLAPIENTRY * PFNGLPOINTPARAMETERINVPROC) (GLenum pname, GLint param); +typedef void (GLAPIENTRY * PFNGLPOINTPARAMETERIVNVPROC) (GLenum pname, const GLint* params); + +#define glPointParameteriNV GLEW_GET_FUN(__glewPointParameteriNV) +#define glPointParameterivNV GLEW_GET_FUN(__glewPointParameterivNV) + +#define GLEW_NV_point_sprite GLEW_GET_VAR(__GLEW_NV_point_sprite) + +#endif /* GL_NV_point_sprite */ + +/* -------------------------- GL_NV_present_video -------------------------- */ + +#ifndef GL_NV_present_video +#define GL_NV_present_video 1 + +#define GL_FRAME_NV 0x8E26 +#define GL_FIELDS_NV 0x8E27 +#define GL_CURRENT_TIME_NV 0x8E28 +#define GL_NUM_FILL_STREAMS_NV 0x8E29 +#define GL_PRESENT_TIME_NV 0x8E2A +#define GL_PRESENT_DURATION_NV 0x8E2B + +//typedef void (GLAPIENTRY * PFNGLGETVIDEOI64VNVPROC) (GLuint video_slot, GLenum pname, GLint64EXT* params); +typedef void (GLAPIENTRY * PFNGLGETVIDEOIVNVPROC) (GLuint video_slot, GLenum pname, GLint* params); +//typedef void (GLAPIENTRY * PFNGLGETVIDEOUI64VNVPROC) (GLuint video_slot, GLenum pname, GLuint64EXT* params); +typedef void (GLAPIENTRY * PFNGLGETVIDEOUIVNVPROC) (GLuint video_slot, GLenum pname, GLuint* params); +//typedef void (GLAPIENTRY * PFNGLPRESENTFRAMEDUALFILLNVPROC) (GLuint video_slot, GLuint64EXT minPresentTime, GLuint beginPresentTimeId, GLuint presentDurationId, GLenum type, GLenum target0, GLuint fill0, GLenum target1, GLuint fill1, GLenum target2, GLuint fill2, GLenum target3, GLuint fill3); +//typedef void (GLAPIENTRY * PFNGLPRESENTFRAMEKEYEDNVPROC) (GLuint video_slot, GLuint64EXT minPresentTime, GLuint beginPresentTimeId, GLuint presentDurationId, GLenum type, GLenum target0, GLuint fill0, GLuint key0, GLenum target1, GLuint fill1, GLuint key1); +typedef void (GLAPIENTRY * PFNGLVIDEOPARAMETERIVNVPROC) (GLuint video_slot, GLenum pname, const GLint* params); + +#define glGetVideoi64vNV GLEW_GET_FUN(__glewGetVideoi64vNV) +#define glGetVideoivNV GLEW_GET_FUN(__glewGetVideoivNV) +#define glGetVideoui64vNV GLEW_GET_FUN(__glewGetVideoui64vNV) +#define glGetVideouivNV GLEW_GET_FUN(__glewGetVideouivNV) +#define glPresentFrameDualFillNV GLEW_GET_FUN(__glewPresentFrameDualFillNV) +#define glPresentFrameKeyedNV GLEW_GET_FUN(__glewPresentFrameKeyedNV) +#define glVideoParameterivNV GLEW_GET_FUN(__glewVideoParameterivNV) + +#define GLEW_NV_present_video GLEW_GET_VAR(__GLEW_NV_present_video) + +#endif /* GL_NV_present_video */ + +/* ------------------------ GL_NV_primitive_restart ------------------------ */ + +#ifndef GL_NV_primitive_restart +#define GL_NV_primitive_restart 1 + +#define GL_PRIMITIVE_RESTART_NV 0x8558 +#define GL_PRIMITIVE_RESTART_INDEX_NV 0x8559 + +typedef void (GLAPIENTRY * PFNGLPRIMITIVERESTARTINDEXNVPROC) (GLuint index); +typedef void (GLAPIENTRY * PFNGLPRIMITIVERESTARTNVPROC) (void); + +#define glPrimitiveRestartIndexNV GLEW_GET_FUN(__glewPrimitiveRestartIndexNV) +#define glPrimitiveRestartNV GLEW_GET_FUN(__glewPrimitiveRestartNV) + +#define GLEW_NV_primitive_restart GLEW_GET_VAR(__GLEW_NV_primitive_restart) + +#endif /* GL_NV_primitive_restart */ + +/* ------------------------ GL_NV_register_combiners ----------------------- */ + +#ifndef GL_NV_register_combiners +#define GL_NV_register_combiners 1 + +#define GL_REGISTER_COMBINERS_NV 0x8522 +#define GL_VARIABLE_A_NV 0x8523 +#define GL_VARIABLE_B_NV 0x8524 +#define GL_VARIABLE_C_NV 0x8525 +#define GL_VARIABLE_D_NV 0x8526 +#define GL_VARIABLE_E_NV 0x8527 +#define GL_VARIABLE_F_NV 0x8528 +#define GL_VARIABLE_G_NV 0x8529 +#define GL_CONSTANT_COLOR0_NV 0x852A +#define GL_CONSTANT_COLOR1_NV 0x852B +#define GL_PRIMARY_COLOR_NV 0x852C +#define GL_SECONDARY_COLOR_NV 0x852D +#define GL_SPARE0_NV 0x852E +#define GL_SPARE1_NV 0x852F +#define GL_DISCARD_NV 0x8530 +#define GL_E_TIMES_F_NV 0x8531 +#define GL_SPARE0_PLUS_SECONDARY_COLOR_NV 0x8532 +#define GL_UNSIGNED_IDENTITY_NV 0x8536 +#define GL_UNSIGNED_INVERT_NV 0x8537 +#define GL_EXPAND_NORMAL_NV 0x8538 +#define GL_EXPAND_NEGATE_NV 0x8539 +#define GL_HALF_BIAS_NORMAL_NV 0x853A +#define GL_HALF_BIAS_NEGATE_NV 0x853B +#define GL_SIGNED_IDENTITY_NV 0x853C +#define GL_SIGNED_NEGATE_NV 0x853D +#define GL_SCALE_BY_TWO_NV 0x853E +#define GL_SCALE_BY_FOUR_NV 0x853F +#define GL_SCALE_BY_ONE_HALF_NV 0x8540 +#define GL_BIAS_BY_NEGATIVE_ONE_HALF_NV 0x8541 +#define GL_COMBINER_INPUT_NV 0x8542 +#define GL_COMBINER_MAPPING_NV 0x8543 +#define GL_COMBINER_COMPONENT_USAGE_NV 0x8544 +#define GL_COMBINER_AB_DOT_PRODUCT_NV 0x8545 +#define GL_COMBINER_CD_DOT_PRODUCT_NV 0x8546 +#define GL_COMBINER_MUX_SUM_NV 0x8547 +#define GL_COMBINER_SCALE_NV 0x8548 +#define GL_COMBINER_BIAS_NV 0x8549 +#define GL_COMBINER_AB_OUTPUT_NV 0x854A +#define GL_COMBINER_CD_OUTPUT_NV 0x854B +#define GL_COMBINER_SUM_OUTPUT_NV 0x854C +#define GL_MAX_GENERAL_COMBINERS_NV 0x854D +#define GL_NUM_GENERAL_COMBINERS_NV 0x854E +#define GL_COLOR_SUM_CLAMP_NV 0x854F +#define GL_COMBINER0_NV 0x8550 +#define GL_COMBINER1_NV 0x8551 +#define GL_COMBINER2_NV 0x8552 +#define GL_COMBINER3_NV 0x8553 +#define GL_COMBINER4_NV 0x8554 +#define GL_COMBINER5_NV 0x8555 +#define GL_COMBINER6_NV 0x8556 +#define GL_COMBINER7_NV 0x8557 + +typedef void (GLAPIENTRY * PFNGLCOMBINERINPUTNVPROC) (GLenum stage, GLenum portion, GLenum variable, GLenum input, GLenum mapping, GLenum componentUsage); +typedef void (GLAPIENTRY * PFNGLCOMBINEROUTPUTNVPROC) (GLenum stage, GLenum portion, GLenum abOutput, GLenum cdOutput, GLenum sumOutput, GLenum scale, GLenum bias, GLboolean abDotProduct, GLboolean cdDotProduct, GLboolean muxSum); +typedef void (GLAPIENTRY * PFNGLCOMBINERPARAMETERFNVPROC) (GLenum pname, GLfloat param); +typedef void (GLAPIENTRY * PFNGLCOMBINERPARAMETERFVNVPROC) (GLenum pname, const GLfloat* params); +typedef void (GLAPIENTRY * PFNGLCOMBINERPARAMETERINVPROC) (GLenum pname, GLint param); +typedef void (GLAPIENTRY * PFNGLCOMBINERPARAMETERIVNVPROC) (GLenum pname, const GLint* params); +typedef void (GLAPIENTRY * PFNGLFINALCOMBINERINPUTNVPROC) (GLenum variable, GLenum input, GLenum mapping, GLenum componentUsage); +typedef void (GLAPIENTRY * PFNGLGETCOMBINERINPUTPARAMETERFVNVPROC) (GLenum stage, GLenum portion, GLenum variable, GLenum pname, GLfloat* params); +typedef void (GLAPIENTRY * PFNGLGETCOMBINERINPUTPARAMETERIVNVPROC) (GLenum stage, GLenum portion, GLenum variable, GLenum pname, GLint* params); +typedef void (GLAPIENTRY * PFNGLGETCOMBINEROUTPUTPARAMETERFVNVPROC) (GLenum stage, GLenum portion, GLenum pname, GLfloat* params); +typedef void (GLAPIENTRY * PFNGLGETCOMBINEROUTPUTPARAMETERIVNVPROC) (GLenum stage, GLenum portion, GLenum pname, GLint* params); +typedef void (GLAPIENTRY * PFNGLGETFINALCOMBINERINPUTPARAMETERFVNVPROC) (GLenum variable, GLenum pname, GLfloat* params); +typedef void (GLAPIENTRY * PFNGLGETFINALCOMBINERINPUTPARAMETERIVNVPROC) (GLenum variable, GLenum pname, GLint* params); + +#define glCombinerInputNV GLEW_GET_FUN(__glewCombinerInputNV) +#define glCombinerOutputNV GLEW_GET_FUN(__glewCombinerOutputNV) +#define glCombinerParameterfNV GLEW_GET_FUN(__glewCombinerParameterfNV) +#define glCombinerParameterfvNV GLEW_GET_FUN(__glewCombinerParameterfvNV) +#define glCombinerParameteriNV GLEW_GET_FUN(__glewCombinerParameteriNV) +#define glCombinerParameterivNV GLEW_GET_FUN(__glewCombinerParameterivNV) +#define glFinalCombinerInputNV GLEW_GET_FUN(__glewFinalCombinerInputNV) +#define glGetCombinerInputParameterfvNV GLEW_GET_FUN(__glewGetCombinerInputParameterfvNV) +#define glGetCombinerInputParameterivNV GLEW_GET_FUN(__glewGetCombinerInputParameterivNV) +#define glGetCombinerOutputParameterfvNV GLEW_GET_FUN(__glewGetCombinerOutputParameterfvNV) +#define glGetCombinerOutputParameterivNV GLEW_GET_FUN(__glewGetCombinerOutputParameterivNV) +#define glGetFinalCombinerInputParameterfvNV GLEW_GET_FUN(__glewGetFinalCombinerInputParameterfvNV) +#define glGetFinalCombinerInputParameterivNV GLEW_GET_FUN(__glewGetFinalCombinerInputParameterivNV) + +#define GLEW_NV_register_combiners GLEW_GET_VAR(__GLEW_NV_register_combiners) + +#endif /* GL_NV_register_combiners */ + +/* ----------------------- GL_NV_register_combiners2 ----------------------- */ + +#ifndef GL_NV_register_combiners2 +#define GL_NV_register_combiners2 1 + +#define GL_PER_STAGE_CONSTANTS_NV 0x8535 + +typedef void (GLAPIENTRY * PFNGLCOMBINERSTAGEPARAMETERFVNVPROC) (GLenum stage, GLenum pname, const GLfloat* params); +typedef void (GLAPIENTRY * PFNGLGETCOMBINERSTAGEPARAMETERFVNVPROC) (GLenum stage, GLenum pname, GLfloat* params); + +#define glCombinerStageParameterfvNV GLEW_GET_FUN(__glewCombinerStageParameterfvNV) +#define glGetCombinerStageParameterfvNV GLEW_GET_FUN(__glewGetCombinerStageParameterfvNV) + +#define GLEW_NV_register_combiners2 GLEW_GET_VAR(__GLEW_NV_register_combiners2) + +#endif /* GL_NV_register_combiners2 */ + +/* -------------------------- GL_NV_texgen_emboss -------------------------- */ + +#ifndef GL_NV_texgen_emboss +#define GL_NV_texgen_emboss 1 + +#define GL_EMBOSS_LIGHT_NV 0x855D +#define GL_EMBOSS_CONSTANT_NV 0x855E +#define GL_EMBOSS_MAP_NV 0x855F + +#define GLEW_NV_texgen_emboss GLEW_GET_VAR(__GLEW_NV_texgen_emboss) + +#endif /* GL_NV_texgen_emboss */ + +/* ------------------------ GL_NV_texgen_reflection ------------------------ */ + +#ifndef GL_NV_texgen_reflection +#define GL_NV_texgen_reflection 1 + +#define GL_NORMAL_MAP_NV 0x8511 +#define GL_REFLECTION_MAP_NV 0x8512 + +#define GLEW_NV_texgen_reflection GLEW_GET_VAR(__GLEW_NV_texgen_reflection) + +#endif /* GL_NV_texgen_reflection */ + +/* --------------------- GL_NV_texture_compression_vtc --------------------- */ + +#ifndef GL_NV_texture_compression_vtc +#define GL_NV_texture_compression_vtc 1 + +#define GLEW_NV_texture_compression_vtc GLEW_GET_VAR(__GLEW_NV_texture_compression_vtc) + +#endif /* GL_NV_texture_compression_vtc */ + +/* ----------------------- GL_NV_texture_env_combine4 ---------------------- */ + +#ifndef GL_NV_texture_env_combine4 +#define GL_NV_texture_env_combine4 1 + +#define GL_COMBINE4_NV 0x8503 +#define GL_SOURCE3_RGB_NV 0x8583 +#define GL_SOURCE3_ALPHA_NV 0x858B +#define GL_OPERAND3_RGB_NV 0x8593 +#define GL_OPERAND3_ALPHA_NV 0x859B + +#define GLEW_NV_texture_env_combine4 GLEW_GET_VAR(__GLEW_NV_texture_env_combine4) + +#endif /* GL_NV_texture_env_combine4 */ + +/* ---------------------- GL_NV_texture_expand_normal ---------------------- */ + +#ifndef GL_NV_texture_expand_normal +#define GL_NV_texture_expand_normal 1 + +#define GL_TEXTURE_UNSIGNED_REMAP_MODE_NV 0x888F + +#define GLEW_NV_texture_expand_normal GLEW_GET_VAR(__GLEW_NV_texture_expand_normal) + +#endif /* GL_NV_texture_expand_normal */ + +/* ------------------------ GL_NV_texture_rectangle ------------------------ */ + +#ifndef GL_NV_texture_rectangle +#define GL_NV_texture_rectangle 1 + +#define GL_TEXTURE_RECTANGLE_NV 0x84F5 +#define GL_TEXTURE_BINDING_RECTANGLE_NV 0x84F6 +#define GL_PROXY_TEXTURE_RECTANGLE_NV 0x84F7 +#define GL_MAX_RECTANGLE_TEXTURE_SIZE_NV 0x84F8 + +#define GLEW_NV_texture_rectangle GLEW_GET_VAR(__GLEW_NV_texture_rectangle) + +#endif /* GL_NV_texture_rectangle */ + +/* -------------------------- GL_NV_texture_shader ------------------------- */ + +#ifndef GL_NV_texture_shader +#define GL_NV_texture_shader 1 + +#define GL_OFFSET_TEXTURE_RECTANGLE_NV 0x864C +#define GL_OFFSET_TEXTURE_RECTANGLE_SCALE_NV 0x864D +#define GL_DOT_PRODUCT_TEXTURE_RECTANGLE_NV 0x864E +#define GL_RGBA_UNSIGNED_DOT_PRODUCT_MAPPING_NV 0x86D9 +#define GL_UNSIGNED_INT_S8_S8_8_8_NV 0x86DA +#define GL_UNSIGNED_INT_8_8_S8_S8_REV_NV 0x86DB +#define GL_DSDT_MAG_INTENSITY_NV 0x86DC +#define GL_SHADER_CONSISTENT_NV 0x86DD +#define GL_TEXTURE_SHADER_NV 0x86DE +#define GL_SHADER_OPERATION_NV 0x86DF +#define GL_CULL_MODES_NV 0x86E0 +#define GL_OFFSET_TEXTURE_2D_MATRIX_NV 0x86E1 +#define GL_OFFSET_TEXTURE_MATRIX_NV 0x86E1 +#define GL_OFFSET_TEXTURE_2D_SCALE_NV 0x86E2 +#define GL_OFFSET_TEXTURE_SCALE_NV 0x86E2 +#define GL_OFFSET_TEXTURE_BIAS_NV 0x86E3 +#define GL_OFFSET_TEXTURE_2D_BIAS_NV 0x86E3 +#define GL_PREVIOUS_TEXTURE_INPUT_NV 0x86E4 +#define GL_CONST_EYE_NV 0x86E5 +#define GL_PASS_THROUGH_NV 0x86E6 +#define GL_CULL_FRAGMENT_NV 0x86E7 +#define GL_OFFSET_TEXTURE_2D_NV 0x86E8 +#define GL_DEPENDENT_AR_TEXTURE_2D_NV 0x86E9 +#define GL_DEPENDENT_GB_TEXTURE_2D_NV 0x86EA +#define GL_DOT_PRODUCT_NV 0x86EC +#define GL_DOT_PRODUCT_DEPTH_REPLACE_NV 0x86ED +#define GL_DOT_PRODUCT_TEXTURE_2D_NV 0x86EE +#define GL_DOT_PRODUCT_TEXTURE_CUBE_MAP_NV 0x86F0 +#define GL_DOT_PRODUCT_DIFFUSE_CUBE_MAP_NV 0x86F1 +#define GL_DOT_PRODUCT_REFLECT_CUBE_MAP_NV 0x86F2 +#define GL_DOT_PRODUCT_CONST_EYE_REFLECT_CUBE_MAP_NV 0x86F3 +#define GL_HILO_NV 0x86F4 +#define GL_DSDT_NV 0x86F5 +#define GL_DSDT_MAG_NV 0x86F6 +#define GL_DSDT_MAG_VIB_NV 0x86F7 +#define GL_HILO16_NV 0x86F8 +#define GL_SIGNED_HILO_NV 0x86F9 +#define GL_SIGNED_HILO16_NV 0x86FA +#define GL_SIGNED_RGBA_NV 0x86FB +#define GL_SIGNED_RGBA8_NV 0x86FC +#define GL_SIGNED_RGB_NV 0x86FE +#define GL_SIGNED_RGB8_NV 0x86FF +#define GL_SIGNED_LUMINANCE_NV 0x8701 +#define GL_SIGNED_LUMINANCE8_NV 0x8702 +#define GL_SIGNED_LUMINANCE_ALPHA_NV 0x8703 +#define GL_SIGNED_LUMINANCE8_ALPHA8_NV 0x8704 +#define GL_SIGNED_ALPHA_NV 0x8705 +#define GL_SIGNED_ALPHA8_NV 0x8706 +#define GL_SIGNED_INTENSITY_NV 0x8707 +#define GL_SIGNED_INTENSITY8_NV 0x8708 +#define GL_DSDT8_NV 0x8709 +#define GL_DSDT8_MAG8_NV 0x870A +#define GL_DSDT8_MAG8_INTENSITY8_NV 0x870B +#define GL_SIGNED_RGB_UNSIGNED_ALPHA_NV 0x870C +#define GL_SIGNED_RGB8_UNSIGNED_ALPHA8_NV 0x870D +#define GL_HI_SCALE_NV 0x870E +#define GL_LO_SCALE_NV 0x870F +#define GL_DS_SCALE_NV 0x8710 +#define GL_DT_SCALE_NV 0x8711 +#define GL_MAGNITUDE_SCALE_NV 0x8712 +#define GL_VIBRANCE_SCALE_NV 0x8713 +#define GL_HI_BIAS_NV 0x8714 +#define GL_LO_BIAS_NV 0x8715 +#define GL_DS_BIAS_NV 0x8716 +#define GL_DT_BIAS_NV 0x8717 +#define GL_MAGNITUDE_BIAS_NV 0x8718 +#define GL_VIBRANCE_BIAS_NV 0x8719 +#define GL_TEXTURE_BORDER_VALUES_NV 0x871A +#define GL_TEXTURE_HI_SIZE_NV 0x871B +#define GL_TEXTURE_LO_SIZE_NV 0x871C +#define GL_TEXTURE_DS_SIZE_NV 0x871D +#define GL_TEXTURE_DT_SIZE_NV 0x871E +#define GL_TEXTURE_MAG_SIZE_NV 0x871F + +#define GLEW_NV_texture_shader GLEW_GET_VAR(__GLEW_NV_texture_shader) + +#endif /* GL_NV_texture_shader */ + +/* ------------------------- GL_NV_texture_shader2 ------------------------- */ + +#ifndef GL_NV_texture_shader2 +#define GL_NV_texture_shader2 1 + +#define GL_UNSIGNED_INT_S8_S8_8_8_NV 0x86DA +#define GL_UNSIGNED_INT_8_8_S8_S8_REV_NV 0x86DB +#define GL_DSDT_MAG_INTENSITY_NV 0x86DC +#define GL_DOT_PRODUCT_TEXTURE_3D_NV 0x86EF +#define GL_HILO_NV 0x86F4 +#define GL_DSDT_NV 0x86F5 +#define GL_DSDT_MAG_NV 0x86F6 +#define GL_DSDT_MAG_VIB_NV 0x86F7 +#define GL_HILO16_NV 0x86F8 +#define GL_SIGNED_HILO_NV 0x86F9 +#define GL_SIGNED_HILO16_NV 0x86FA +#define GL_SIGNED_RGBA_NV 0x86FB +#define GL_SIGNED_RGBA8_NV 0x86FC +#define GL_SIGNED_RGB_NV 0x86FE +#define GL_SIGNED_RGB8_NV 0x86FF +#define GL_SIGNED_LUMINANCE_NV 0x8701 +#define GL_SIGNED_LUMINANCE8_NV 0x8702 +#define GL_SIGNED_LUMINANCE_ALPHA_NV 0x8703 +#define GL_SIGNED_LUMINANCE8_ALPHA8_NV 0x8704 +#define GL_SIGNED_ALPHA_NV 0x8705 +#define GL_SIGNED_ALPHA8_NV 0x8706 +#define GL_SIGNED_INTENSITY_NV 0x8707 +#define GL_SIGNED_INTENSITY8_NV 0x8708 +#define GL_DSDT8_NV 0x8709 +#define GL_DSDT8_MAG8_NV 0x870A +#define GL_DSDT8_MAG8_INTENSITY8_NV 0x870B +#define GL_SIGNED_RGB_UNSIGNED_ALPHA_NV 0x870C +#define GL_SIGNED_RGB8_UNSIGNED_ALPHA8_NV 0x870D + +#define GLEW_NV_texture_shader2 GLEW_GET_VAR(__GLEW_NV_texture_shader2) + +#endif /* GL_NV_texture_shader2 */ + +/* ------------------------- GL_NV_texture_shader3 ------------------------- */ + +#ifndef GL_NV_texture_shader3 +#define GL_NV_texture_shader3 1 + +#define GL_OFFSET_PROJECTIVE_TEXTURE_2D_NV 0x8850 +#define GL_OFFSET_PROJECTIVE_TEXTURE_2D_SCALE_NV 0x8851 +#define GL_OFFSET_PROJECTIVE_TEXTURE_RECTANGLE_NV 0x8852 +#define GL_OFFSET_PROJECTIVE_TEXTURE_RECTANGLE_SCALE_NV 0x8853 +#define GL_OFFSET_HILO_TEXTURE_2D_NV 0x8854 +#define GL_OFFSET_HILO_TEXTURE_RECTANGLE_NV 0x8855 +#define GL_OFFSET_HILO_PROJECTIVE_TEXTURE_2D_NV 0x8856 +#define GL_OFFSET_HILO_PROJECTIVE_TEXTURE_RECTANGLE_NV 0x8857 +#define GL_DEPENDENT_HILO_TEXTURE_2D_NV 0x8858 +#define GL_DEPENDENT_RGB_TEXTURE_3D_NV 0x8859 +#define GL_DEPENDENT_RGB_TEXTURE_CUBE_MAP_NV 0x885A +#define GL_DOT_PRODUCT_PASS_THROUGH_NV 0x885B +#define GL_DOT_PRODUCT_TEXTURE_1D_NV 0x885C +#define GL_DOT_PRODUCT_AFFINE_DEPTH_REPLACE_NV 0x885D +#define GL_HILO8_NV 0x885E +#define GL_SIGNED_HILO8_NV 0x885F +#define GL_FORCE_BLUE_TO_ONE_NV 0x8860 + +#define GLEW_NV_texture_shader3 GLEW_GET_VAR(__GLEW_NV_texture_shader3) + +#endif /* GL_NV_texture_shader3 */ + +/* ------------------------ GL_NV_transform_feedback ----------------------- */ + +#ifndef GL_NV_transform_feedback +#define GL_NV_transform_feedback 1 + +#define GL_BACK_PRIMARY_COLOR_NV 0x8C77 +#define GL_BACK_SECONDARY_COLOR_NV 0x8C78 +#define GL_TEXTURE_COORD_NV 0x8C79 +#define GL_CLIP_DISTANCE_NV 0x8C7A +#define GL_VERTEX_ID_NV 0x8C7B +#define GL_PRIMITIVE_ID_NV 0x8C7C +#define GL_GENERIC_ATTRIB_NV 0x8C7D +#define GL_TRANSFORM_FEEDBACK_ATTRIBS_NV 0x8C7E +#define GL_TRANSFORM_FEEDBACK_BUFFER_MODE_NV 0x8C7F +#define GL_MAX_TRANSFORM_FEEDBACK_SEPARATE_COMPONENTS_NV 0x8C80 +#define GL_ACTIVE_VARYINGS_NV 0x8C81 +#define GL_ACTIVE_VARYING_MAX_LENGTH_NV 0x8C82 +#define GL_TRANSFORM_FEEDBACK_VARYINGS_NV 0x8C83 +#define GL_TRANSFORM_FEEDBACK_BUFFER_START_NV 0x8C84 +#define GL_TRANSFORM_FEEDBACK_BUFFER_SIZE_NV 0x8C85 +#define GL_TRANSFORM_FEEDBACK_RECORD_NV 0x8C86 +#define GL_PRIMITIVES_GENERATED_NV 0x8C87 +#define GL_TRANSFORM_FEEDBACK_PRIMITIVES_WRITTEN_NV 0x8C88 +#define GL_RASTERIZER_DISCARD_NV 0x8C89 +#define GL_MAX_TRANSFORM_FEEDBACK_INTERLEAVED_COMPONENTS_NV 0x8C8A +#define GL_MAX_TRANSFORM_FEEDBACK_SEPARATE_ATTRIBS_NV 0x8C8B +#define GL_INTERLEAVED_ATTRIBS_NV 0x8C8C +#define GL_SEPARATE_ATTRIBS_NV 0x8C8D +#define GL_TRANSFORM_FEEDBACK_BUFFER_NV 0x8C8E +#define GL_TRANSFORM_FEEDBACK_BUFFER_BINDING_NV 0x8C8F + +typedef void (GLAPIENTRY * PFNGLACTIVEVARYINGNVPROC) (GLuint program, const GLchar *name); +typedef void (GLAPIENTRY * PFNGLBEGINTRANSFORMFEEDBACKNVPROC) (GLenum primitiveMode); +typedef void (GLAPIENTRY * PFNGLBINDBUFFERBASENVPROC) (GLenum target, GLuint index, GLuint buffer); +typedef void (GLAPIENTRY * PFNGLBINDBUFFEROFFSETNVPROC) (GLenum target, GLuint index, GLuint buffer, GLintptr offset); +typedef void (GLAPIENTRY * PFNGLBINDBUFFERRANGENVPROC) (GLenum target, GLuint index, GLuint buffer, GLintptr offset, GLsizeiptr size); +typedef void (GLAPIENTRY * PFNGLENDTRANSFORMFEEDBACKNVPROC) (void); +typedef void (GLAPIENTRY * PFNGLGETACTIVEVARYINGNVPROC) (GLuint program, GLuint index, GLsizei bufSize, GLsizei *length, GLsizei *size, GLenum *type, GLchar *name); +typedef void (GLAPIENTRY * PFNGLGETTRANSFORMFEEDBACKVARYINGNVPROC) (GLuint program, GLuint index, GLint *location); +typedef GLint (GLAPIENTRY * PFNGLGETVARYINGLOCATIONNVPROC) (GLuint program, const GLchar *name); +typedef void (GLAPIENTRY * PFNGLTRANSFORMFEEDBACKATTRIBSNVPROC) (GLuint count, const GLint *attribs, GLenum bufferMode); +typedef void (GLAPIENTRY * PFNGLTRANSFORMFEEDBACKVARYINGSNVPROC) (GLuint program, GLsizei count, const GLint *locations, GLenum bufferMode); + +#define glActiveVaryingNV GLEW_GET_FUN(__glewActiveVaryingNV) +#define glBeginTransformFeedbackNV GLEW_GET_FUN(__glewBeginTransformFeedbackNV) +#define glBindBufferBaseNV GLEW_GET_FUN(__glewBindBufferBaseNV) +#define glBindBufferOffsetNV GLEW_GET_FUN(__glewBindBufferOffsetNV) +#define glBindBufferRangeNV GLEW_GET_FUN(__glewBindBufferRangeNV) +#define glEndTransformFeedbackNV GLEW_GET_FUN(__glewEndTransformFeedbackNV) +#define glGetActiveVaryingNV GLEW_GET_FUN(__glewGetActiveVaryingNV) +#define glGetTransformFeedbackVaryingNV GLEW_GET_FUN(__glewGetTransformFeedbackVaryingNV) +#define glGetVaryingLocationNV GLEW_GET_FUN(__glewGetVaryingLocationNV) +#define glTransformFeedbackAttribsNV GLEW_GET_FUN(__glewTransformFeedbackAttribsNV) +#define glTransformFeedbackVaryingsNV GLEW_GET_FUN(__glewTransformFeedbackVaryingsNV) + +#define GLEW_NV_transform_feedback GLEW_GET_VAR(__GLEW_NV_transform_feedback) + +#endif /* GL_NV_transform_feedback */ + +/* ------------------------ GL_NV_vertex_array_range ----------------------- */ + +#ifndef GL_NV_vertex_array_range +#define GL_NV_vertex_array_range 1 + +#define GL_VERTEX_ARRAY_RANGE_NV 0x851D +#define GL_VERTEX_ARRAY_RANGE_LENGTH_NV 0x851E +#define GL_VERTEX_ARRAY_RANGE_VALID_NV 0x851F +#define GL_MAX_VERTEX_ARRAY_RANGE_ELEMENT_NV 0x8520 +#define GL_VERTEX_ARRAY_RANGE_POINTER_NV 0x8521 + +typedef void (GLAPIENTRY * PFNGLFLUSHVERTEXARRAYRANGENVPROC) (void); +typedef void (GLAPIENTRY * PFNGLVERTEXARRAYRANGENVPROC) (GLsizei length, void* pointer); + +#define glFlushVertexArrayRangeNV GLEW_GET_FUN(__glewFlushVertexArrayRangeNV) +#define glVertexArrayRangeNV GLEW_GET_FUN(__glewVertexArrayRangeNV) + +#define GLEW_NV_vertex_array_range GLEW_GET_VAR(__GLEW_NV_vertex_array_range) + +#endif /* GL_NV_vertex_array_range */ + +/* ----------------------- GL_NV_vertex_array_range2 ----------------------- */ + +#ifndef GL_NV_vertex_array_range2 +#define GL_NV_vertex_array_range2 1 + +#define GL_VERTEX_ARRAY_RANGE_WITHOUT_FLUSH_NV 0x8533 + +#define GLEW_NV_vertex_array_range2 GLEW_GET_VAR(__GLEW_NV_vertex_array_range2) + +#endif /* GL_NV_vertex_array_range2 */ + +/* -------------------------- GL_NV_vertex_program ------------------------- */ + +#ifndef GL_NV_vertex_program +#define GL_NV_vertex_program 1 + +#define GL_VERTEX_PROGRAM_NV 0x8620 +#define GL_VERTEX_STATE_PROGRAM_NV 0x8621 +#define GL_ATTRIB_ARRAY_SIZE_NV 0x8623 +#define GL_ATTRIB_ARRAY_STRIDE_NV 0x8624 +#define GL_ATTRIB_ARRAY_TYPE_NV 0x8625 +#define GL_CURRENT_ATTRIB_NV 0x8626 +#define GL_PROGRAM_LENGTH_NV 0x8627 +#define GL_PROGRAM_STRING_NV 0x8628 +#define GL_MODELVIEW_PROJECTION_NV 0x8629 +#define GL_IDENTITY_NV 0x862A +#define GL_INVERSE_NV 0x862B +#define GL_TRANSPOSE_NV 0x862C +#define GL_INVERSE_TRANSPOSE_NV 0x862D +#define GL_MAX_TRACK_MATRIX_STACK_DEPTH_NV 0x862E +#define GL_MAX_TRACK_MATRICES_NV 0x862F +#define GL_MATRIX0_NV 0x8630 +#define GL_MATRIX1_NV 0x8631 +#define GL_MATRIX2_NV 0x8632 +#define GL_MATRIX3_NV 0x8633 +#define GL_MATRIX4_NV 0x8634 +#define GL_MATRIX5_NV 0x8635 +#define GL_MATRIX6_NV 0x8636 +#define GL_MATRIX7_NV 0x8637 +#define GL_CURRENT_MATRIX_STACK_DEPTH_NV 0x8640 +#define GL_CURRENT_MATRIX_NV 0x8641 +#define GL_VERTEX_PROGRAM_POINT_SIZE_NV 0x8642 +#define GL_VERTEX_PROGRAM_TWO_SIDE_NV 0x8643 +#define GL_PROGRAM_PARAMETER_NV 0x8644 +#define GL_ATTRIB_ARRAY_POINTER_NV 0x8645 +#define GL_PROGRAM_TARGET_NV 0x8646 +#define GL_PROGRAM_RESIDENT_NV 0x8647 +#define GL_TRACK_MATRIX_NV 0x8648 +#define GL_TRACK_MATRIX_TRANSFORM_NV 0x8649 +#define GL_VERTEX_PROGRAM_BINDING_NV 0x864A +#define GL_PROGRAM_ERROR_POSITION_NV 0x864B +#define GL_VERTEX_ATTRIB_ARRAY0_NV 0x8650 +#define GL_VERTEX_ATTRIB_ARRAY1_NV 0x8651 +#define GL_VERTEX_ATTRIB_ARRAY2_NV 0x8652 +#define GL_VERTEX_ATTRIB_ARRAY3_NV 0x8653 +#define GL_VERTEX_ATTRIB_ARRAY4_NV 0x8654 +#define GL_VERTEX_ATTRIB_ARRAY5_NV 0x8655 +#define GL_VERTEX_ATTRIB_ARRAY6_NV 0x8656 +#define GL_VERTEX_ATTRIB_ARRAY7_NV 0x8657 +#define GL_VERTEX_ATTRIB_ARRAY8_NV 0x8658 +#define GL_VERTEX_ATTRIB_ARRAY9_NV 0x8659 +#define GL_VERTEX_ATTRIB_ARRAY10_NV 0x865A +#define GL_VERTEX_ATTRIB_ARRAY11_NV 0x865B +#define GL_VERTEX_ATTRIB_ARRAY12_NV 0x865C +#define GL_VERTEX_ATTRIB_ARRAY13_NV 0x865D +#define GL_VERTEX_ATTRIB_ARRAY14_NV 0x865E +#define GL_VERTEX_ATTRIB_ARRAY15_NV 0x865F +#define GL_MAP1_VERTEX_ATTRIB0_4_NV 0x8660 +#define GL_MAP1_VERTEX_ATTRIB1_4_NV 0x8661 +#define GL_MAP1_VERTEX_ATTRIB2_4_NV 0x8662 +#define GL_MAP1_VERTEX_ATTRIB3_4_NV 0x8663 +#define GL_MAP1_VERTEX_ATTRIB4_4_NV 0x8664 +#define GL_MAP1_VERTEX_ATTRIB5_4_NV 0x8665 +#define GL_MAP1_VERTEX_ATTRIB6_4_NV 0x8666 +#define GL_MAP1_VERTEX_ATTRIB7_4_NV 0x8667 +#define GL_MAP1_VERTEX_ATTRIB8_4_NV 0x8668 +#define GL_MAP1_VERTEX_ATTRIB9_4_NV 0x8669 +#define GL_MAP1_VERTEX_ATTRIB10_4_NV 0x866A +#define GL_MAP1_VERTEX_ATTRIB11_4_NV 0x866B +#define GL_MAP1_VERTEX_ATTRIB12_4_NV 0x866C +#define GL_MAP1_VERTEX_ATTRIB13_4_NV 0x866D +#define GL_MAP1_VERTEX_ATTRIB14_4_NV 0x866E +#define GL_MAP1_VERTEX_ATTRIB15_4_NV 0x866F +#define GL_MAP2_VERTEX_ATTRIB0_4_NV 0x8670 +#define GL_MAP2_VERTEX_ATTRIB1_4_NV 0x8671 +#define GL_MAP2_VERTEX_ATTRIB2_4_NV 0x8672 +#define GL_MAP2_VERTEX_ATTRIB3_4_NV 0x8673 +#define GL_MAP2_VERTEX_ATTRIB4_4_NV 0x8674 +#define GL_MAP2_VERTEX_ATTRIB5_4_NV 0x8675 +#define GL_MAP2_VERTEX_ATTRIB6_4_NV 0x8676 +#define GL_MAP2_VERTEX_ATTRIB7_4_NV 0x8677 +#define GL_MAP2_VERTEX_ATTRIB8_4_NV 0x8678 +#define GL_MAP2_VERTEX_ATTRIB9_4_NV 0x8679 +#define GL_MAP2_VERTEX_ATTRIB10_4_NV 0x867A +#define GL_MAP2_VERTEX_ATTRIB11_4_NV 0x867B +#define GL_MAP2_VERTEX_ATTRIB12_4_NV 0x867C +#define GL_MAP2_VERTEX_ATTRIB13_4_NV 0x867D +#define GL_MAP2_VERTEX_ATTRIB14_4_NV 0x867E +#define GL_MAP2_VERTEX_ATTRIB15_4_NV 0x867F + +typedef GLboolean (GLAPIENTRY * PFNGLAREPROGRAMSRESIDENTNVPROC) (GLsizei n, const GLuint* ids, GLboolean *residences); +typedef void (GLAPIENTRY * PFNGLBINDPROGRAMNVPROC) (GLenum target, GLuint id); +typedef void (GLAPIENTRY * PFNGLDELETEPROGRAMSNVPROC) (GLsizei n, const GLuint* ids); +typedef void (GLAPIENTRY * PFNGLEXECUTEPROGRAMNVPROC) (GLenum target, GLuint id, const GLfloat* params); +typedef void (GLAPIENTRY * PFNGLGENPROGRAMSNVPROC) (GLsizei n, GLuint* ids); +typedef void (GLAPIENTRY * PFNGLGETPROGRAMPARAMETERDVNVPROC) (GLenum target, GLuint index, GLenum pname, GLdouble* params); +typedef void (GLAPIENTRY * PFNGLGETPROGRAMPARAMETERFVNVPROC) (GLenum target, GLuint index, GLenum pname, GLfloat* params); +typedef void (GLAPIENTRY * PFNGLGETPROGRAMSTRINGNVPROC) (GLuint id, GLenum pname, GLubyte* program); +typedef void (GLAPIENTRY * PFNGLGETPROGRAMIVNVPROC) (GLuint id, GLenum pname, GLint* params); +typedef void (GLAPIENTRY * PFNGLGETTRACKMATRIXIVNVPROC) (GLenum target, GLuint address, GLenum pname, GLint* params); +typedef void (GLAPIENTRY * PFNGLGETVERTEXATTRIBPOINTERVNVPROC) (GLuint index, GLenum pname, GLvoid** pointer); +typedef void (GLAPIENTRY * PFNGLGETVERTEXATTRIBDVNVPROC) (GLuint index, GLenum pname, GLdouble* params); +typedef void (GLAPIENTRY * PFNGLGETVERTEXATTRIBFVNVPROC) (GLuint index, GLenum pname, GLfloat* params); +typedef void (GLAPIENTRY * PFNGLGETVERTEXATTRIBIVNVPROC) (GLuint index, GLenum pname, GLint* params); +typedef GLboolean (GLAPIENTRY * PFNGLISPROGRAMNVPROC) (GLuint id); +typedef void (GLAPIENTRY * PFNGLLOADPROGRAMNVPROC) (GLenum target, GLuint id, GLsizei len, const GLubyte* program); +typedef void (GLAPIENTRY * PFNGLPROGRAMPARAMETER4DNVPROC) (GLenum target, GLuint index, GLdouble x, GLdouble y, GLdouble z, GLdouble w); +typedef void (GLAPIENTRY * PFNGLPROGRAMPARAMETER4DVNVPROC) (GLenum target, GLuint index, const GLdouble* params); +typedef void (GLAPIENTRY * PFNGLPROGRAMPARAMETER4FNVPROC) (GLenum target, GLuint index, GLfloat x, GLfloat y, GLfloat z, GLfloat w); +typedef void (GLAPIENTRY * PFNGLPROGRAMPARAMETER4FVNVPROC) (GLenum target, GLuint index, const GLfloat* params); +typedef void (GLAPIENTRY * PFNGLPROGRAMPARAMETERS4DVNVPROC) (GLenum target, GLuint index, GLuint num, const GLdouble* params); +typedef void (GLAPIENTRY * PFNGLPROGRAMPARAMETERS4FVNVPROC) (GLenum target, GLuint index, GLuint num, const GLfloat* params); +typedef void (GLAPIENTRY * PFNGLREQUESTRESIDENTPROGRAMSNVPROC) (GLsizei n, GLuint* ids); +typedef void (GLAPIENTRY * PFNGLTRACKMATRIXNVPROC) (GLenum target, GLuint address, GLenum matrix, GLenum transform); +typedef void (GLAPIENTRY * PFNGLVERTEXATTRIB1DNVPROC) (GLuint index, GLdouble x); +typedef void (GLAPIENTRY * PFNGLVERTEXATTRIB1DVNVPROC) (GLuint index, const GLdouble* v); +typedef void (GLAPIENTRY * PFNGLVERTEXATTRIB1FNVPROC) (GLuint index, GLfloat x); +typedef void (GLAPIENTRY * PFNGLVERTEXATTRIB1FVNVPROC) (GLuint index, const GLfloat* v); +typedef void (GLAPIENTRY * PFNGLVERTEXATTRIB1SNVPROC) (GLuint index, GLshort x); +typedef void (GLAPIENTRY * PFNGLVERTEXATTRIB1SVNVPROC) (GLuint index, const GLshort* v); +typedef void (GLAPIENTRY * PFNGLVERTEXATTRIB2DNVPROC) (GLuint index, GLdouble x, GLdouble y); +typedef void (GLAPIENTRY * PFNGLVERTEXATTRIB2DVNVPROC) (GLuint index, const GLdouble* v); +typedef void (GLAPIENTRY * PFNGLVERTEXATTRIB2FNVPROC) (GLuint index, GLfloat x, GLfloat y); +typedef void (GLAPIENTRY * PFNGLVERTEXATTRIB2FVNVPROC) (GLuint index, const GLfloat* v); +typedef void (GLAPIENTRY * PFNGLVERTEXATTRIB2SNVPROC) (GLuint index, GLshort x, GLshort y); +typedef void (GLAPIENTRY * PFNGLVERTEXATTRIB2SVNVPROC) (GLuint index, const GLshort* v); +typedef void (GLAPIENTRY * PFNGLVERTEXATTRIB3DNVPROC) (GLuint index, GLdouble x, GLdouble y, GLdouble z); +typedef void (GLAPIENTRY * PFNGLVERTEXATTRIB3DVNVPROC) (GLuint index, const GLdouble* v); +typedef void (GLAPIENTRY * PFNGLVERTEXATTRIB3FNVPROC) (GLuint index, GLfloat x, GLfloat y, GLfloat z); +typedef void (GLAPIENTRY * PFNGLVERTEXATTRIB3FVNVPROC) (GLuint index, const GLfloat* v); +typedef void (GLAPIENTRY * PFNGLVERTEXATTRIB3SNVPROC) (GLuint index, GLshort x, GLshort y, GLshort z); +typedef void (GLAPIENTRY * PFNGLVERTEXATTRIB3SVNVPROC) (GLuint index, const GLshort* v); +typedef void (GLAPIENTRY * PFNGLVERTEXATTRIB4DNVPROC) (GLuint index, GLdouble x, GLdouble y, GLdouble z, GLdouble w); +typedef void (GLAPIENTRY * PFNGLVERTEXATTRIB4DVNVPROC) (GLuint index, const GLdouble* v); +typedef void (GLAPIENTRY * PFNGLVERTEXATTRIB4FNVPROC) (GLuint index, GLfloat x, GLfloat y, GLfloat z, GLfloat w); +typedef void (GLAPIENTRY * PFNGLVERTEXATTRIB4FVNVPROC) (GLuint index, const GLfloat* v); +typedef void (GLAPIENTRY * PFNGLVERTEXATTRIB4SNVPROC) (GLuint index, GLshort x, GLshort y, GLshort z, GLshort w); +typedef void (GLAPIENTRY * PFNGLVERTEXATTRIB4SVNVPROC) (GLuint index, const GLshort* v); +typedef void (GLAPIENTRY * PFNGLVERTEXATTRIB4UBNVPROC) (GLuint index, GLubyte x, GLubyte y, GLubyte z, GLubyte w); +typedef void (GLAPIENTRY * PFNGLVERTEXATTRIB4UBVNVPROC) (GLuint index, const GLubyte* v); +typedef void (GLAPIENTRY * PFNGLVERTEXATTRIBPOINTERNVPROC) (GLuint index, GLint size, GLenum type, GLsizei stride, const void* pointer); +typedef void (GLAPIENTRY * PFNGLVERTEXATTRIBS1DVNVPROC) (GLuint index, GLsizei n, const GLdouble* v); +typedef void (GLAPIENTRY * PFNGLVERTEXATTRIBS1FVNVPROC) (GLuint index, GLsizei n, const GLfloat* v); +typedef void (GLAPIENTRY * PFNGLVERTEXATTRIBS1SVNVPROC) (GLuint index, GLsizei n, const GLshort* v); +typedef void (GLAPIENTRY * PFNGLVERTEXATTRIBS2DVNVPROC) (GLuint index, GLsizei n, const GLdouble* v); +typedef void (GLAPIENTRY * PFNGLVERTEXATTRIBS2FVNVPROC) (GLuint index, GLsizei n, const GLfloat* v); +typedef void (GLAPIENTRY * PFNGLVERTEXATTRIBS2SVNVPROC) (GLuint index, GLsizei n, const GLshort* v); +typedef void (GLAPIENTRY * PFNGLVERTEXATTRIBS3DVNVPROC) (GLuint index, GLsizei n, const GLdouble* v); +typedef void (GLAPIENTRY * PFNGLVERTEXATTRIBS3FVNVPROC) (GLuint index, GLsizei n, const GLfloat* v); +typedef void (GLAPIENTRY * PFNGLVERTEXATTRIBS3SVNVPROC) (GLuint index, GLsizei n, const GLshort* v); +typedef void (GLAPIENTRY * PFNGLVERTEXATTRIBS4DVNVPROC) (GLuint index, GLsizei n, const GLdouble* v); +typedef void (GLAPIENTRY * PFNGLVERTEXATTRIBS4FVNVPROC) (GLuint index, GLsizei n, const GLfloat* v); +typedef void (GLAPIENTRY * PFNGLVERTEXATTRIBS4SVNVPROC) (GLuint index, GLsizei n, const GLshort* v); +typedef void (GLAPIENTRY * PFNGLVERTEXATTRIBS4UBVNVPROC) (GLuint index, GLsizei n, const GLubyte* v); + +#define glAreProgramsResidentNV GLEW_GET_FUN(__glewAreProgramsResidentNV) +#define glBindProgramNV GLEW_GET_FUN(__glewBindProgramNV) +#define glDeleteProgramsNV GLEW_GET_FUN(__glewDeleteProgramsNV) +#define glExecuteProgramNV GLEW_GET_FUN(__glewExecuteProgramNV) +#define glGenProgramsNV GLEW_GET_FUN(__glewGenProgramsNV) +#define glGetProgramParameterdvNV GLEW_GET_FUN(__glewGetProgramParameterdvNV) +#define glGetProgramParameterfvNV GLEW_GET_FUN(__glewGetProgramParameterfvNV) +#define glGetProgramStringNV GLEW_GET_FUN(__glewGetProgramStringNV) +#define glGetProgramivNV GLEW_GET_FUN(__glewGetProgramivNV) +#define glGetTrackMatrixivNV GLEW_GET_FUN(__glewGetTrackMatrixivNV) +#define glGetVertexAttribPointervNV GLEW_GET_FUN(__glewGetVertexAttribPointervNV) +#define glGetVertexAttribdvNV GLEW_GET_FUN(__glewGetVertexAttribdvNV) +#define glGetVertexAttribfvNV GLEW_GET_FUN(__glewGetVertexAttribfvNV) +#define glGetVertexAttribivNV GLEW_GET_FUN(__glewGetVertexAttribivNV) +#define glIsProgramNV GLEW_GET_FUN(__glewIsProgramNV) +#define glLoadProgramNV GLEW_GET_FUN(__glewLoadProgramNV) +#define glProgramParameter4dNV GLEW_GET_FUN(__glewProgramParameter4dNV) +#define glProgramParameter4dvNV GLEW_GET_FUN(__glewProgramParameter4dvNV) +#define glProgramParameter4fNV GLEW_GET_FUN(__glewProgramParameter4fNV) +#define glProgramParameter4fvNV GLEW_GET_FUN(__glewProgramParameter4fvNV) +#define glProgramParameters4dvNV GLEW_GET_FUN(__glewProgramParameters4dvNV) +#define glProgramParameters4fvNV GLEW_GET_FUN(__glewProgramParameters4fvNV) +#define glRequestResidentProgramsNV GLEW_GET_FUN(__glewRequestResidentProgramsNV) +#define glTrackMatrixNV GLEW_GET_FUN(__glewTrackMatrixNV) +#define glVertexAttrib1dNV GLEW_GET_FUN(__glewVertexAttrib1dNV) +#define glVertexAttrib1dvNV GLEW_GET_FUN(__glewVertexAttrib1dvNV) +#define glVertexAttrib1fNV GLEW_GET_FUN(__glewVertexAttrib1fNV) +#define glVertexAttrib1fvNV GLEW_GET_FUN(__glewVertexAttrib1fvNV) +#define glVertexAttrib1sNV GLEW_GET_FUN(__glewVertexAttrib1sNV) +#define glVertexAttrib1svNV GLEW_GET_FUN(__glewVertexAttrib1svNV) +#define glVertexAttrib2dNV GLEW_GET_FUN(__glewVertexAttrib2dNV) +#define glVertexAttrib2dvNV GLEW_GET_FUN(__glewVertexAttrib2dvNV) +#define glVertexAttrib2fNV GLEW_GET_FUN(__glewVertexAttrib2fNV) +#define glVertexAttrib2fvNV GLEW_GET_FUN(__glewVertexAttrib2fvNV) +#define glVertexAttrib2sNV GLEW_GET_FUN(__glewVertexAttrib2sNV) +#define glVertexAttrib2svNV GLEW_GET_FUN(__glewVertexAttrib2svNV) +#define glVertexAttrib3dNV GLEW_GET_FUN(__glewVertexAttrib3dNV) +#define glVertexAttrib3dvNV GLEW_GET_FUN(__glewVertexAttrib3dvNV) +#define glVertexAttrib3fNV GLEW_GET_FUN(__glewVertexAttrib3fNV) +#define glVertexAttrib3fvNV GLEW_GET_FUN(__glewVertexAttrib3fvNV) +#define glVertexAttrib3sNV GLEW_GET_FUN(__glewVertexAttrib3sNV) +#define glVertexAttrib3svNV GLEW_GET_FUN(__glewVertexAttrib3svNV) +#define glVertexAttrib4dNV GLEW_GET_FUN(__glewVertexAttrib4dNV) +#define glVertexAttrib4dvNV GLEW_GET_FUN(__glewVertexAttrib4dvNV) +#define glVertexAttrib4fNV GLEW_GET_FUN(__glewVertexAttrib4fNV) +#define glVertexAttrib4fvNV GLEW_GET_FUN(__glewVertexAttrib4fvNV) +#define glVertexAttrib4sNV GLEW_GET_FUN(__glewVertexAttrib4sNV) +#define glVertexAttrib4svNV GLEW_GET_FUN(__glewVertexAttrib4svNV) +#define glVertexAttrib4ubNV GLEW_GET_FUN(__glewVertexAttrib4ubNV) +#define glVertexAttrib4ubvNV GLEW_GET_FUN(__glewVertexAttrib4ubvNV) +#define glVertexAttribPointerNV GLEW_GET_FUN(__glewVertexAttribPointerNV) +#define glVertexAttribs1dvNV GLEW_GET_FUN(__glewVertexAttribs1dvNV) +#define glVertexAttribs1fvNV GLEW_GET_FUN(__glewVertexAttribs1fvNV) +#define glVertexAttribs1svNV GLEW_GET_FUN(__glewVertexAttribs1svNV) +#define glVertexAttribs2dvNV GLEW_GET_FUN(__glewVertexAttribs2dvNV) +#define glVertexAttribs2fvNV GLEW_GET_FUN(__glewVertexAttribs2fvNV) +#define glVertexAttribs2svNV GLEW_GET_FUN(__glewVertexAttribs2svNV) +#define glVertexAttribs3dvNV GLEW_GET_FUN(__glewVertexAttribs3dvNV) +#define glVertexAttribs3fvNV GLEW_GET_FUN(__glewVertexAttribs3fvNV) +#define glVertexAttribs3svNV GLEW_GET_FUN(__glewVertexAttribs3svNV) +#define glVertexAttribs4dvNV GLEW_GET_FUN(__glewVertexAttribs4dvNV) +#define glVertexAttribs4fvNV GLEW_GET_FUN(__glewVertexAttribs4fvNV) +#define glVertexAttribs4svNV GLEW_GET_FUN(__glewVertexAttribs4svNV) +#define glVertexAttribs4ubvNV GLEW_GET_FUN(__glewVertexAttribs4ubvNV) + +#define GLEW_NV_vertex_program GLEW_GET_VAR(__GLEW_NV_vertex_program) + +#endif /* GL_NV_vertex_program */ + +/* ------------------------ GL_NV_vertex_program1_1 ------------------------ */ + +#ifndef GL_NV_vertex_program1_1 +#define GL_NV_vertex_program1_1 1 + +#define GLEW_NV_vertex_program1_1 GLEW_GET_VAR(__GLEW_NV_vertex_program1_1) + +#endif /* GL_NV_vertex_program1_1 */ + +/* ------------------------- GL_NV_vertex_program2 ------------------------- */ + +#ifndef GL_NV_vertex_program2 +#define GL_NV_vertex_program2 1 + +#define GLEW_NV_vertex_program2 GLEW_GET_VAR(__GLEW_NV_vertex_program2) + +#endif /* GL_NV_vertex_program2 */ + +/* ---------------------- GL_NV_vertex_program2_option --------------------- */ + +#ifndef GL_NV_vertex_program2_option +#define GL_NV_vertex_program2_option 1 + +#define GL_MAX_PROGRAM_EXEC_INSTRUCTIONS_NV 0x88F4 +#define GL_MAX_PROGRAM_CALL_DEPTH_NV 0x88F5 + +#define GLEW_NV_vertex_program2_option GLEW_GET_VAR(__GLEW_NV_vertex_program2_option) + +#endif /* GL_NV_vertex_program2_option */ + +/* ------------------------- GL_NV_vertex_program3 ------------------------- */ + +#ifndef GL_NV_vertex_program3 +#define GL_NV_vertex_program3 1 + +#define MAX_VERTEX_TEXTURE_IMAGE_UNITS_ARB 0x8B4C + +#define GLEW_NV_vertex_program3 GLEW_GET_VAR(__GLEW_NV_vertex_program3) + +#endif /* GL_NV_vertex_program3 */ + +/* ------------------------- GL_NV_vertex_program4 ------------------------- */ + +#ifndef GL_NV_vertex_program4 +#define GL_NV_vertex_program4 1 + +#define GLEW_NV_vertex_program4 GLEW_GET_VAR(__GLEW_NV_vertex_program4) + +#endif /* GL_NV_vertex_program4 */ + +/* ------------------------ GL_OES_byte_coordinates ------------------------ */ + +#ifndef GL_OES_byte_coordinates +#define GL_OES_byte_coordinates 1 + +#define GL_BYTE 0x1400 + +#define GLEW_OES_byte_coordinates GLEW_GET_VAR(__GLEW_OES_byte_coordinates) + +#endif /* GL_OES_byte_coordinates */ + +/* ------------------- GL_OES_compressed_paletted_texture ------------------ */ + +#ifndef GL_OES_compressed_paletted_texture +#define GL_OES_compressed_paletted_texture 1 + +#define GL_PALETTE4_RGB8_OES 0x8B90 +#define GL_PALETTE4_RGBA8_OES 0x8B91 +#define GL_PALETTE4_R5_G6_B5_OES 0x8B92 +#define GL_PALETTE4_RGBA4_OES 0x8B93 +#define GL_PALETTE4_RGB5_A1_OES 0x8B94 +#define GL_PALETTE8_RGB8_OES 0x8B95 +#define GL_PALETTE8_RGBA8_OES 0x8B96 +#define GL_PALETTE8_R5_G6_B5_OES 0x8B97 +#define GL_PALETTE8_RGBA4_OES 0x8B98 +#define GL_PALETTE8_RGB5_A1_OES 0x8B99 + +#define GLEW_OES_compressed_paletted_texture GLEW_GET_VAR(__GLEW_OES_compressed_paletted_texture) + +#endif /* GL_OES_compressed_paletted_texture */ + +/* --------------------------- GL_OES_read_format -------------------------- */ + +#ifndef GL_OES_read_format +#define GL_OES_read_format 1 + +#define GL_IMPLEMENTATION_COLOR_READ_TYPE_OES 0x8B9A +#define GL_IMPLEMENTATION_COLOR_READ_FORMAT_OES 0x8B9B + +#define GLEW_OES_read_format GLEW_GET_VAR(__GLEW_OES_read_format) + +#endif /* GL_OES_read_format */ + +/* ------------------------ GL_OES_single_precision ------------------------ */ + +#ifndef GL_OES_single_precision +#define GL_OES_single_precision 1 + +typedef void (GLAPIENTRY * PFNGLCLEARDEPTHFOESPROC) (GLclampd depth); +typedef void (GLAPIENTRY * PFNGLCLIPPLANEFOESPROC) (GLenum plane, const GLfloat* equation); +typedef void (GLAPIENTRY * PFNGLDEPTHRANGEFOESPROC) (GLclampf n, GLclampf f); +typedef void (GLAPIENTRY * PFNGLFRUSTUMFOESPROC) (GLfloat l, GLfloat r, GLfloat b, GLfloat t, GLfloat n, GLfloat f); +typedef void (GLAPIENTRY * PFNGLGETCLIPPLANEFOESPROC) (GLenum plane, GLfloat* equation); +typedef void (GLAPIENTRY * PFNGLORTHOFOESPROC) (GLfloat l, GLfloat r, GLfloat b, GLfloat t, GLfloat n, GLfloat f); + +#define glClearDepthfOES GLEW_GET_FUN(__glewClearDepthfOES) +#define glClipPlanefOES GLEW_GET_FUN(__glewClipPlanefOES) +#define glDepthRangefOES GLEW_GET_FUN(__glewDepthRangefOES) +#define glFrustumfOES GLEW_GET_FUN(__glewFrustumfOES) +#define glGetClipPlanefOES GLEW_GET_FUN(__glewGetClipPlanefOES) +#define glOrthofOES GLEW_GET_FUN(__glewOrthofOES) + +#define GLEW_OES_single_precision GLEW_GET_VAR(__GLEW_OES_single_precision) + +#endif /* GL_OES_single_precision */ + +/* ---------------------------- GL_OML_interlace --------------------------- */ + +#ifndef GL_OML_interlace +#define GL_OML_interlace 1 + +#define GL_INTERLACE_OML 0x8980 +#define GL_INTERLACE_READ_OML 0x8981 + +#define GLEW_OML_interlace GLEW_GET_VAR(__GLEW_OML_interlace) + +#endif /* GL_OML_interlace */ + +/* ---------------------------- GL_OML_resample ---------------------------- */ + +#ifndef GL_OML_resample +#define GL_OML_resample 1 + +#define GL_PACK_RESAMPLE_OML 0x8984 +#define GL_UNPACK_RESAMPLE_OML 0x8985 +#define GL_RESAMPLE_REPLICATE_OML 0x8986 +#define GL_RESAMPLE_ZERO_FILL_OML 0x8987 +#define GL_RESAMPLE_AVERAGE_OML 0x8988 +#define GL_RESAMPLE_DECIMATE_OML 0x8989 + +#define GLEW_OML_resample GLEW_GET_VAR(__GLEW_OML_resample) + +#endif /* GL_OML_resample */ + +/* ---------------------------- GL_OML_subsample --------------------------- */ + +#ifndef GL_OML_subsample +#define GL_OML_subsample 1 + +#define GL_FORMAT_SUBSAMPLE_24_24_OML 0x8982 +#define GL_FORMAT_SUBSAMPLE_244_244_OML 0x8983 + +#define GLEW_OML_subsample GLEW_GET_VAR(__GLEW_OML_subsample) + +#endif /* GL_OML_subsample */ + +/* --------------------------- GL_PGI_misc_hints --------------------------- */ + +#ifndef GL_PGI_misc_hints +#define GL_PGI_misc_hints 1 + +#define GL_PREFER_DOUBLEBUFFER_HINT_PGI 107000 +#define GL_CONSERVE_MEMORY_HINT_PGI 107005 +#define GL_RECLAIM_MEMORY_HINT_PGI 107006 +#define GL_NATIVE_GRAPHICS_HANDLE_PGI 107010 +#define GL_NATIVE_GRAPHICS_BEGIN_HINT_PGI 107011 +#define GL_NATIVE_GRAPHICS_END_HINT_PGI 107012 +#define GL_ALWAYS_FAST_HINT_PGI 107020 +#define GL_ALWAYS_SOFT_HINT_PGI 107021 +#define GL_ALLOW_DRAW_OBJ_HINT_PGI 107022 +#define GL_ALLOW_DRAW_WIN_HINT_PGI 107023 +#define GL_ALLOW_DRAW_FRG_HINT_PGI 107024 +#define GL_ALLOW_DRAW_MEM_HINT_PGI 107025 +#define GL_STRICT_DEPTHFUNC_HINT_PGI 107030 +#define GL_STRICT_LIGHTING_HINT_PGI 107031 +#define GL_STRICT_SCISSOR_HINT_PGI 107032 +#define GL_FULL_STIPPLE_HINT_PGI 107033 +#define GL_CLIP_NEAR_HINT_PGI 107040 +#define GL_CLIP_FAR_HINT_PGI 107041 +#define GL_WIDE_LINE_HINT_PGI 107042 +#define GL_BACK_NORMALS_HINT_PGI 107043 + +#define GLEW_PGI_misc_hints GLEW_GET_VAR(__GLEW_PGI_misc_hints) + +#endif /* GL_PGI_misc_hints */ + +/* -------------------------- GL_PGI_vertex_hints -------------------------- */ + +#ifndef GL_PGI_vertex_hints +#define GL_PGI_vertex_hints 1 + +#define GL_VERTEX23_BIT_PGI 0x00000004 +#define GL_VERTEX4_BIT_PGI 0x00000008 +#define GL_COLOR3_BIT_PGI 0x00010000 +#define GL_COLOR4_BIT_PGI 0x00020000 +#define GL_EDGEFLAG_BIT_PGI 0x00040000 +#define GL_INDEX_BIT_PGI 0x00080000 +#define GL_MAT_AMBIENT_BIT_PGI 0x00100000 +#define GL_VERTEX_DATA_HINT_PGI 107050 +#define GL_VERTEX_CONSISTENT_HINT_PGI 107051 +#define GL_MATERIAL_SIDE_HINT_PGI 107052 +#define GL_MAX_VERTEX_HINT_PGI 107053 +#define GL_MAT_AMBIENT_AND_DIFFUSE_BIT_PGI 0x00200000 +#define GL_MAT_DIFFUSE_BIT_PGI 0x00400000 +#define GL_MAT_EMISSION_BIT_PGI 0x00800000 +#define GL_MAT_COLOR_INDEXES_BIT_PGI 0x01000000 +#define GL_MAT_SHININESS_BIT_PGI 0x02000000 +#define GL_MAT_SPECULAR_BIT_PGI 0x04000000 +#define GL_NORMAL_BIT_PGI 0x08000000 +#define GL_TEXCOORD1_BIT_PGI 0x10000000 +#define GL_TEXCOORD2_BIT_PGI 0x20000000 +#define GL_TEXCOORD3_BIT_PGI 0x40000000 +#define GL_TEXCOORD4_BIT_PGI 0x80000000 + +#define GLEW_PGI_vertex_hints GLEW_GET_VAR(__GLEW_PGI_vertex_hints) + +#endif /* GL_PGI_vertex_hints */ + +/* ----------------------- GL_REND_screen_coordinates ---------------------- */ + +#ifndef GL_REND_screen_coordinates +#define GL_REND_screen_coordinates 1 + +#define GL_SCREEN_COORDINATES_REND 0x8490 +#define GL_INVERTED_SCREEN_W_REND 0x8491 + +#define GLEW_REND_screen_coordinates GLEW_GET_VAR(__GLEW_REND_screen_coordinates) + +#endif /* GL_REND_screen_coordinates */ + +/* ------------------------------- GL_S3_s3tc ------------------------------ */ + +#ifndef GL_S3_s3tc +#define GL_S3_s3tc 1 + +#define GL_RGB_S3TC 0x83A0 +#define GL_RGB4_S3TC 0x83A1 +#define GL_RGBA_S3TC 0x83A2 +#define GL_RGBA4_S3TC 0x83A3 +#define GL_RGBA_DXT5_S3TC 0x83A4 +#define GL_RGBA4_DXT5_S3TC 0x83A5 + +#define GLEW_S3_s3tc GLEW_GET_VAR(__GLEW_S3_s3tc) + +#endif /* GL_S3_s3tc */ + +/* -------------------------- GL_SGIS_color_range -------------------------- */ + +#ifndef GL_SGIS_color_range +#define GL_SGIS_color_range 1 + +#define GL_EXTENDED_RANGE_SGIS 0x85A5 +#define GL_MIN_RED_SGIS 0x85A6 +#define GL_MAX_RED_SGIS 0x85A7 +#define GL_MIN_GREEN_SGIS 0x85A8 +#define GL_MAX_GREEN_SGIS 0x85A9 +#define GL_MIN_BLUE_SGIS 0x85AA +#define GL_MAX_BLUE_SGIS 0x85AB +#define GL_MIN_ALPHA_SGIS 0x85AC +#define GL_MAX_ALPHA_SGIS 0x85AD + +#define GLEW_SGIS_color_range GLEW_GET_VAR(__GLEW_SGIS_color_range) + +#endif /* GL_SGIS_color_range */ + +/* ------------------------- GL_SGIS_detail_texture ------------------------ */ + +#ifndef GL_SGIS_detail_texture +#define GL_SGIS_detail_texture 1 + +typedef void (GLAPIENTRY * PFNGLDETAILTEXFUNCSGISPROC) (GLenum target, GLsizei n, const GLfloat* points); +typedef void (GLAPIENTRY * PFNGLGETDETAILTEXFUNCSGISPROC) (GLenum target, GLfloat* points); + +#define glDetailTexFuncSGIS GLEW_GET_FUN(__glewDetailTexFuncSGIS) +#define glGetDetailTexFuncSGIS GLEW_GET_FUN(__glewGetDetailTexFuncSGIS) + +#define GLEW_SGIS_detail_texture GLEW_GET_VAR(__GLEW_SGIS_detail_texture) + +#endif /* GL_SGIS_detail_texture */ + +/* -------------------------- GL_SGIS_fog_function ------------------------- */ + +#ifndef GL_SGIS_fog_function +#define GL_SGIS_fog_function 1 + +typedef void (GLAPIENTRY * PFNGLFOGFUNCSGISPROC) (GLsizei n, const GLfloat* points); +typedef void (GLAPIENTRY * PFNGLGETFOGFUNCSGISPROC) (GLfloat* points); + +#define glFogFuncSGIS GLEW_GET_FUN(__glewFogFuncSGIS) +#define glGetFogFuncSGIS GLEW_GET_FUN(__glewGetFogFuncSGIS) + +#define GLEW_SGIS_fog_function GLEW_GET_VAR(__GLEW_SGIS_fog_function) + +#endif /* GL_SGIS_fog_function */ + +/* ------------------------ GL_SGIS_generate_mipmap ------------------------ */ + +#ifndef GL_SGIS_generate_mipmap +#define GL_SGIS_generate_mipmap 1 + +#define GL_GENERATE_MIPMAP_SGIS 0x8191 +#define GL_GENERATE_MIPMAP_HINT_SGIS 0x8192 + +#define GLEW_SGIS_generate_mipmap GLEW_GET_VAR(__GLEW_SGIS_generate_mipmap) + +#endif /* GL_SGIS_generate_mipmap */ + +/* -------------------------- GL_SGIS_multisample -------------------------- */ + +#ifndef GL_SGIS_multisample +#define GL_SGIS_multisample 1 + +#define GL_MULTISAMPLE_SGIS 0x809D +#define GL_SAMPLE_ALPHA_TO_MASK_SGIS 0x809E +#define GL_SAMPLE_ALPHA_TO_ONE_SGIS 0x809F +#define GL_SAMPLE_MASK_SGIS 0x80A0 +#define GL_1PASS_SGIS 0x80A1 +#define GL_2PASS_0_SGIS 0x80A2 +#define GL_2PASS_1_SGIS 0x80A3 +#define GL_4PASS_0_SGIS 0x80A4 +#define GL_4PASS_1_SGIS 0x80A5 +#define GL_4PASS_2_SGIS 0x80A6 +#define GL_4PASS_3_SGIS 0x80A7 +#define GL_SAMPLE_BUFFERS_SGIS 0x80A8 +#define GL_SAMPLES_SGIS 0x80A9 +#define GL_SAMPLE_MASK_VALUE_SGIS 0x80AA +#define GL_SAMPLE_MASK_INVERT_SGIS 0x80AB +#define GL_SAMPLE_PATTERN_SGIS 0x80AC +#define GL_MULTISAMPLE_BIT_EXT 0x20000000 + +typedef void (GLAPIENTRY * PFNGLSAMPLEMASKSGISPROC) (GLclampf value, GLboolean invert); +typedef void (GLAPIENTRY * PFNGLSAMPLEPATTERNSGISPROC) (GLenum pattern); + +#define glSampleMaskSGIS GLEW_GET_FUN(__glewSampleMaskSGIS) +#define glSamplePatternSGIS GLEW_GET_FUN(__glewSamplePatternSGIS) + +#define GLEW_SGIS_multisample GLEW_GET_VAR(__GLEW_SGIS_multisample) + +#endif /* GL_SGIS_multisample */ + +/* ------------------------- GL_SGIS_pixel_texture ------------------------- */ + +#ifndef GL_SGIS_pixel_texture +#define GL_SGIS_pixel_texture 1 + +#define GLEW_SGIS_pixel_texture GLEW_GET_VAR(__GLEW_SGIS_pixel_texture) + +#endif /* GL_SGIS_pixel_texture */ + +/* ----------------------- GL_SGIS_point_line_texgen ----------------------- */ + +#ifndef GL_SGIS_point_line_texgen +#define GL_SGIS_point_line_texgen 1 + +#define GL_EYE_DISTANCE_TO_POINT_SGIS 0x81F0 +#define GL_OBJECT_DISTANCE_TO_POINT_SGIS 0x81F1 +#define GL_EYE_DISTANCE_TO_LINE_SGIS 0x81F2 +#define GL_OBJECT_DISTANCE_TO_LINE_SGIS 0x81F3 +#define GL_EYE_POINT_SGIS 0x81F4 +#define GL_OBJECT_POINT_SGIS 0x81F5 +#define GL_EYE_LINE_SGIS 0x81F6 +#define GL_OBJECT_LINE_SGIS 0x81F7 + +#define GLEW_SGIS_point_line_texgen GLEW_GET_VAR(__GLEW_SGIS_point_line_texgen) + +#endif /* GL_SGIS_point_line_texgen */ + +/* ------------------------ GL_SGIS_sharpen_texture ------------------------ */ + +#ifndef GL_SGIS_sharpen_texture +#define GL_SGIS_sharpen_texture 1 + +typedef void (GLAPIENTRY * PFNGLGETSHARPENTEXFUNCSGISPROC) (GLenum target, GLfloat* points); +typedef void (GLAPIENTRY * PFNGLSHARPENTEXFUNCSGISPROC) (GLenum target, GLsizei n, const GLfloat* points); + +#define glGetSharpenTexFuncSGIS GLEW_GET_FUN(__glewGetSharpenTexFuncSGIS) +#define glSharpenTexFuncSGIS GLEW_GET_FUN(__glewSharpenTexFuncSGIS) + +#define GLEW_SGIS_sharpen_texture GLEW_GET_VAR(__GLEW_SGIS_sharpen_texture) + +#endif /* GL_SGIS_sharpen_texture */ + +/* --------------------------- GL_SGIS_texture4D --------------------------- */ + +#ifndef GL_SGIS_texture4D +#define GL_SGIS_texture4D 1 + +typedef void (GLAPIENTRY * PFNGLTEXIMAGE4DSGISPROC) (GLenum target, GLint level, GLenum internalformat, GLsizei width, GLsizei height, GLsizei depth, GLsizei extent, GLint border, GLenum format, GLenum type, const void* pixels); +typedef void (GLAPIENTRY * PFNGLTEXSUBIMAGE4DSGISPROC) (GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLint woffset, GLsizei width, GLsizei height, GLsizei depth, GLsizei extent, GLenum format, GLenum type, const void* pixels); + +#define glTexImage4DSGIS GLEW_GET_FUN(__glewTexImage4DSGIS) +#define glTexSubImage4DSGIS GLEW_GET_FUN(__glewTexSubImage4DSGIS) + +#define GLEW_SGIS_texture4D GLEW_GET_VAR(__GLEW_SGIS_texture4D) + +#endif /* GL_SGIS_texture4D */ + +/* ---------------------- GL_SGIS_texture_border_clamp --------------------- */ + +#ifndef GL_SGIS_texture_border_clamp +#define GL_SGIS_texture_border_clamp 1 + +#define GL_CLAMP_TO_BORDER_SGIS 0x812D + +#define GLEW_SGIS_texture_border_clamp GLEW_GET_VAR(__GLEW_SGIS_texture_border_clamp) + +#endif /* GL_SGIS_texture_border_clamp */ + +/* ----------------------- GL_SGIS_texture_edge_clamp ---------------------- */ + +#ifndef GL_SGIS_texture_edge_clamp +#define GL_SGIS_texture_edge_clamp 1 + +#define GL_CLAMP_TO_EDGE_SGIS 0x812F + +#define GLEW_SGIS_texture_edge_clamp GLEW_GET_VAR(__GLEW_SGIS_texture_edge_clamp) + +#endif /* GL_SGIS_texture_edge_clamp */ + +/* ------------------------ GL_SGIS_texture_filter4 ------------------------ */ + +#ifndef GL_SGIS_texture_filter4 +#define GL_SGIS_texture_filter4 1 + +typedef void (GLAPIENTRY * PFNGLGETTEXFILTERFUNCSGISPROC) (GLenum target, GLenum filter, GLfloat* weights); +typedef void (GLAPIENTRY * PFNGLTEXFILTERFUNCSGISPROC) (GLenum target, GLenum filter, GLsizei n, const GLfloat* weights); + +#define glGetTexFilterFuncSGIS GLEW_GET_FUN(__glewGetTexFilterFuncSGIS) +#define glTexFilterFuncSGIS GLEW_GET_FUN(__glewTexFilterFuncSGIS) + +#define GLEW_SGIS_texture_filter4 GLEW_GET_VAR(__GLEW_SGIS_texture_filter4) + +#endif /* GL_SGIS_texture_filter4 */ + +/* -------------------------- GL_SGIS_texture_lod -------------------------- */ + +#ifndef GL_SGIS_texture_lod +#define GL_SGIS_texture_lod 1 + +#define GL_TEXTURE_MIN_LOD_SGIS 0x813A +#define GL_TEXTURE_MAX_LOD_SGIS 0x813B +#define GL_TEXTURE_BASE_LEVEL_SGIS 0x813C +#define GL_TEXTURE_MAX_LEVEL_SGIS 0x813D + +#define GLEW_SGIS_texture_lod GLEW_GET_VAR(__GLEW_SGIS_texture_lod) + +#endif /* GL_SGIS_texture_lod */ + +/* ------------------------- GL_SGIS_texture_select ------------------------ */ + +#ifndef GL_SGIS_texture_select +#define GL_SGIS_texture_select 1 + +#define GLEW_SGIS_texture_select GLEW_GET_VAR(__GLEW_SGIS_texture_select) + +#endif /* GL_SGIS_texture_select */ + +/* ----------------------------- GL_SGIX_async ----------------------------- */ + +#ifndef GL_SGIX_async +#define GL_SGIX_async 1 + +#define GL_ASYNC_MARKER_SGIX 0x8329 + +typedef void (GLAPIENTRY * PFNGLASYNCMARKERSGIXPROC) (GLuint marker); +typedef void (GLAPIENTRY * PFNGLDELETEASYNCMARKERSSGIXPROC) (GLuint marker, GLsizei range); +typedef GLint (GLAPIENTRY * PFNGLFINISHASYNCSGIXPROC) (GLuint* markerp); +typedef GLuint (GLAPIENTRY * PFNGLGENASYNCMARKERSSGIXPROC) (GLsizei range); +typedef GLboolean (GLAPIENTRY * PFNGLISASYNCMARKERSGIXPROC) (GLuint marker); +typedef GLint (GLAPIENTRY * PFNGLPOLLASYNCSGIXPROC) (GLuint* markerp); + +#define glAsyncMarkerSGIX GLEW_GET_FUN(__glewAsyncMarkerSGIX) +#define glDeleteAsyncMarkersSGIX GLEW_GET_FUN(__glewDeleteAsyncMarkersSGIX) +#define glFinishAsyncSGIX GLEW_GET_FUN(__glewFinishAsyncSGIX) +#define glGenAsyncMarkersSGIX GLEW_GET_FUN(__glewGenAsyncMarkersSGIX) +#define glIsAsyncMarkerSGIX GLEW_GET_FUN(__glewIsAsyncMarkerSGIX) +#define glPollAsyncSGIX GLEW_GET_FUN(__glewPollAsyncSGIX) + +#define GLEW_SGIX_async GLEW_GET_VAR(__GLEW_SGIX_async) + +#endif /* GL_SGIX_async */ + +/* ------------------------ GL_SGIX_async_histogram ------------------------ */ + +#ifndef GL_SGIX_async_histogram +#define GL_SGIX_async_histogram 1 + +#define GL_ASYNC_HISTOGRAM_SGIX 0x832C +#define GL_MAX_ASYNC_HISTOGRAM_SGIX 0x832D + +#define GLEW_SGIX_async_histogram GLEW_GET_VAR(__GLEW_SGIX_async_histogram) + +#endif /* GL_SGIX_async_histogram */ + +/* -------------------------- GL_SGIX_async_pixel -------------------------- */ + +#ifndef GL_SGIX_async_pixel +#define GL_SGIX_async_pixel 1 + +#define GL_ASYNC_TEX_IMAGE_SGIX 0x835C +#define GL_ASYNC_DRAW_PIXELS_SGIX 0x835D +#define GL_ASYNC_READ_PIXELS_SGIX 0x835E +#define GL_MAX_ASYNC_TEX_IMAGE_SGIX 0x835F +#define GL_MAX_ASYNC_DRAW_PIXELS_SGIX 0x8360 +#define GL_MAX_ASYNC_READ_PIXELS_SGIX 0x8361 + +#define GLEW_SGIX_async_pixel GLEW_GET_VAR(__GLEW_SGIX_async_pixel) + +#endif /* GL_SGIX_async_pixel */ + +/* ----------------------- GL_SGIX_blend_alpha_minmax ---------------------- */ + +#ifndef GL_SGIX_blend_alpha_minmax +#define GL_SGIX_blend_alpha_minmax 1 + +#define GL_ALPHA_MIN_SGIX 0x8320 +#define GL_ALPHA_MAX_SGIX 0x8321 + +#define GLEW_SGIX_blend_alpha_minmax GLEW_GET_VAR(__GLEW_SGIX_blend_alpha_minmax) + +#endif /* GL_SGIX_blend_alpha_minmax */ + +/* ---------------------------- GL_SGIX_clipmap ---------------------------- */ + +#ifndef GL_SGIX_clipmap +#define GL_SGIX_clipmap 1 + +#define GLEW_SGIX_clipmap GLEW_GET_VAR(__GLEW_SGIX_clipmap) + +#endif /* GL_SGIX_clipmap */ + +/* ---------------------- GL_SGIX_convolution_accuracy --------------------- */ + +#ifndef GL_SGIX_convolution_accuracy +#define GL_SGIX_convolution_accuracy 1 + +#define GL_CONVOLUTION_HINT_SGIX 0x8316 + +#define GLEW_SGIX_convolution_accuracy GLEW_GET_VAR(__GLEW_SGIX_convolution_accuracy) + +#endif /* GL_SGIX_convolution_accuracy */ + +/* ------------------------- GL_SGIX_depth_texture ------------------------- */ + +#ifndef GL_SGIX_depth_texture +#define GL_SGIX_depth_texture 1 + +#define GL_DEPTH_COMPONENT16_SGIX 0x81A5 +#define GL_DEPTH_COMPONENT24_SGIX 0x81A6 +#define GL_DEPTH_COMPONENT32_SGIX 0x81A7 + +#define GLEW_SGIX_depth_texture GLEW_GET_VAR(__GLEW_SGIX_depth_texture) + +#endif /* GL_SGIX_depth_texture */ + +/* -------------------------- GL_SGIX_flush_raster ------------------------- */ + +#ifndef GL_SGIX_flush_raster +#define GL_SGIX_flush_raster 1 + +typedef void (GLAPIENTRY * PFNGLFLUSHRASTERSGIXPROC) (void); + +#define glFlushRasterSGIX GLEW_GET_FUN(__glewFlushRasterSGIX) + +#define GLEW_SGIX_flush_raster GLEW_GET_VAR(__GLEW_SGIX_flush_raster) + +#endif /* GL_SGIX_flush_raster */ + +/* --------------------------- GL_SGIX_fog_offset -------------------------- */ + +#ifndef GL_SGIX_fog_offset +#define GL_SGIX_fog_offset 1 + +#define GL_FOG_OFFSET_SGIX 0x8198 +#define GL_FOG_OFFSET_VALUE_SGIX 0x8199 + +#define GLEW_SGIX_fog_offset GLEW_GET_VAR(__GLEW_SGIX_fog_offset) + +#endif /* GL_SGIX_fog_offset */ + +/* -------------------------- GL_SGIX_fog_texture -------------------------- */ + +#ifndef GL_SGIX_fog_texture +#define GL_SGIX_fog_texture 1 + +#define GL_TEXTURE_FOG_SGIX 0 +#define GL_FOG_PATCHY_FACTOR_SGIX 0 +#define GL_FRAGMENT_FOG_SGIX 0 + +typedef void (GLAPIENTRY * PFNGLTEXTUREFOGSGIXPROC) (GLenum pname); + +#define glTextureFogSGIX GLEW_GET_FUN(__glewTextureFogSGIX) + +#define GLEW_SGIX_fog_texture GLEW_GET_VAR(__GLEW_SGIX_fog_texture) + +#endif /* GL_SGIX_fog_texture */ + +/* ------------------- GL_SGIX_fragment_specular_lighting ------------------ */ + +#ifndef GL_SGIX_fragment_specular_lighting +#define GL_SGIX_fragment_specular_lighting 1 + +typedef void (GLAPIENTRY * PFNGLFRAGMENTCOLORMATERIALSGIXPROC) (GLenum face, GLenum mode); +typedef void (GLAPIENTRY * PFNGLFRAGMENTLIGHTMODELFSGIXPROC) (GLenum pname, GLfloat param); +typedef void (GLAPIENTRY * PFNGLFRAGMENTLIGHTMODELFVSGIXPROC) (GLenum pname, GLfloat* params); +typedef void (GLAPIENTRY * PFNGLFRAGMENTLIGHTMODELISGIXPROC) (GLenum pname, GLint param); +typedef void (GLAPIENTRY * PFNGLFRAGMENTLIGHTMODELIVSGIXPROC) (GLenum pname, GLint* params); +typedef void (GLAPIENTRY * PFNGLFRAGMENTLIGHTFSGIXPROC) (GLenum light, GLenum pname, GLfloat param); +typedef void (GLAPIENTRY * PFNGLFRAGMENTLIGHTFVSGIXPROC) (GLenum light, GLenum pname, GLfloat* params); +typedef void (GLAPIENTRY * PFNGLFRAGMENTLIGHTISGIXPROC) (GLenum light, GLenum pname, GLint param); +typedef void (GLAPIENTRY * PFNGLFRAGMENTLIGHTIVSGIXPROC) (GLenum light, GLenum pname, GLint* params); +typedef void (GLAPIENTRY * PFNGLFRAGMENTMATERIALFSGIXPROC) (GLenum face, GLenum pname, const GLfloat param); +typedef void (GLAPIENTRY * PFNGLFRAGMENTMATERIALFVSGIXPROC) (GLenum face, GLenum pname, const GLfloat* params); +typedef void (GLAPIENTRY * PFNGLFRAGMENTMATERIALISGIXPROC) (GLenum face, GLenum pname, const GLint param); +typedef void (GLAPIENTRY * PFNGLFRAGMENTMATERIALIVSGIXPROC) (GLenum face, GLenum pname, const GLint* params); +typedef void (GLAPIENTRY * PFNGLGETFRAGMENTLIGHTFVSGIXPROC) (GLenum light, GLenum value, GLfloat* data); +typedef void (GLAPIENTRY * PFNGLGETFRAGMENTLIGHTIVSGIXPROC) (GLenum light, GLenum value, GLint* data); +typedef void (GLAPIENTRY * PFNGLGETFRAGMENTMATERIALFVSGIXPROC) (GLenum face, GLenum pname, const GLfloat* data); +typedef void (GLAPIENTRY * PFNGLGETFRAGMENTMATERIALIVSGIXPROC) (GLenum face, GLenum pname, const GLint* data); + +#define glFragmentColorMaterialSGIX GLEW_GET_FUN(__glewFragmentColorMaterialSGIX) +#define glFragmentLightModelfSGIX GLEW_GET_FUN(__glewFragmentLightModelfSGIX) +#define glFragmentLightModelfvSGIX GLEW_GET_FUN(__glewFragmentLightModelfvSGIX) +#define glFragmentLightModeliSGIX GLEW_GET_FUN(__glewFragmentLightModeliSGIX) +#define glFragmentLightModelivSGIX GLEW_GET_FUN(__glewFragmentLightModelivSGIX) +#define glFragmentLightfSGIX GLEW_GET_FUN(__glewFragmentLightfSGIX) +#define glFragmentLightfvSGIX GLEW_GET_FUN(__glewFragmentLightfvSGIX) +#define glFragmentLightiSGIX GLEW_GET_FUN(__glewFragmentLightiSGIX) +#define glFragmentLightivSGIX GLEW_GET_FUN(__glewFragmentLightivSGIX) +#define glFragmentMaterialfSGIX GLEW_GET_FUN(__glewFragmentMaterialfSGIX) +#define glFragmentMaterialfvSGIX GLEW_GET_FUN(__glewFragmentMaterialfvSGIX) +#define glFragmentMaterialiSGIX GLEW_GET_FUN(__glewFragmentMaterialiSGIX) +#define glFragmentMaterialivSGIX GLEW_GET_FUN(__glewFragmentMaterialivSGIX) +#define glGetFragmentLightfvSGIX GLEW_GET_FUN(__glewGetFragmentLightfvSGIX) +#define glGetFragmentLightivSGIX GLEW_GET_FUN(__glewGetFragmentLightivSGIX) +#define glGetFragmentMaterialfvSGIX GLEW_GET_FUN(__glewGetFragmentMaterialfvSGIX) +#define glGetFragmentMaterialivSGIX GLEW_GET_FUN(__glewGetFragmentMaterialivSGIX) + +#define GLEW_SGIX_fragment_specular_lighting GLEW_GET_VAR(__GLEW_SGIX_fragment_specular_lighting) + +#endif /* GL_SGIX_fragment_specular_lighting */ + +/* --------------------------- GL_SGIX_framezoom --------------------------- */ + +#ifndef GL_SGIX_framezoom +#define GL_SGIX_framezoom 1 + +typedef void (GLAPIENTRY * PFNGLFRAMEZOOMSGIXPROC) (GLint factor); + +#define glFrameZoomSGIX GLEW_GET_FUN(__glewFrameZoomSGIX) + +#define GLEW_SGIX_framezoom GLEW_GET_VAR(__GLEW_SGIX_framezoom) + +#endif /* GL_SGIX_framezoom */ + +/* --------------------------- GL_SGIX_interlace --------------------------- */ + +#ifndef GL_SGIX_interlace +#define GL_SGIX_interlace 1 + +#define GL_INTERLACE_SGIX 0x8094 + +#define GLEW_SGIX_interlace GLEW_GET_VAR(__GLEW_SGIX_interlace) + +#endif /* GL_SGIX_interlace */ + +/* ------------------------- GL_SGIX_ir_instrument1 ------------------------ */ + +#ifndef GL_SGIX_ir_instrument1 +#define GL_SGIX_ir_instrument1 1 + +#define GLEW_SGIX_ir_instrument1 GLEW_GET_VAR(__GLEW_SGIX_ir_instrument1) + +#endif /* GL_SGIX_ir_instrument1 */ + +/* ------------------------- GL_SGIX_list_priority ------------------------- */ + +#ifndef GL_SGIX_list_priority +#define GL_SGIX_list_priority 1 + +#define GLEW_SGIX_list_priority GLEW_GET_VAR(__GLEW_SGIX_list_priority) + +#endif /* GL_SGIX_list_priority */ + +/* ------------------------- GL_SGIX_pixel_texture ------------------------- */ + +#ifndef GL_SGIX_pixel_texture +#define GL_SGIX_pixel_texture 1 + +typedef void (GLAPIENTRY * PFNGLPIXELTEXGENSGIXPROC) (GLenum mode); + +#define glPixelTexGenSGIX GLEW_GET_FUN(__glewPixelTexGenSGIX) + +#define GLEW_SGIX_pixel_texture GLEW_GET_VAR(__GLEW_SGIX_pixel_texture) + +#endif /* GL_SGIX_pixel_texture */ + +/* ----------------------- GL_SGIX_pixel_texture_bits ---------------------- */ + +#ifndef GL_SGIX_pixel_texture_bits +#define GL_SGIX_pixel_texture_bits 1 + +#define GLEW_SGIX_pixel_texture_bits GLEW_GET_VAR(__GLEW_SGIX_pixel_texture_bits) + +#endif /* GL_SGIX_pixel_texture_bits */ + +/* ------------------------ GL_SGIX_reference_plane ------------------------ */ + +#ifndef GL_SGIX_reference_plane +#define GL_SGIX_reference_plane 1 + +typedef void (GLAPIENTRY * PFNGLREFERENCEPLANESGIXPROC) (const GLdouble* equation); + +#define glReferencePlaneSGIX GLEW_GET_FUN(__glewReferencePlaneSGIX) + +#define GLEW_SGIX_reference_plane GLEW_GET_VAR(__GLEW_SGIX_reference_plane) + +#endif /* GL_SGIX_reference_plane */ + +/* ---------------------------- GL_SGIX_resample --------------------------- */ + +#ifndef GL_SGIX_resample +#define GL_SGIX_resample 1 + +#define GL_PACK_RESAMPLE_SGIX 0x842E +#define GL_UNPACK_RESAMPLE_SGIX 0x842F +#define GL_RESAMPLE_DECIMATE_SGIX 0x8430 +#define GL_RESAMPLE_REPLICATE_SGIX 0x8433 +#define GL_RESAMPLE_ZERO_FILL_SGIX 0x8434 + +#define GLEW_SGIX_resample GLEW_GET_VAR(__GLEW_SGIX_resample) + +#endif /* GL_SGIX_resample */ + +/* ----------------------------- GL_SGIX_shadow ---------------------------- */ + +#ifndef GL_SGIX_shadow +#define GL_SGIX_shadow 1 + +#define GL_TEXTURE_COMPARE_SGIX 0x819A +#define GL_TEXTURE_COMPARE_OPERATOR_SGIX 0x819B +#define GL_TEXTURE_LEQUAL_R_SGIX 0x819C +#define GL_TEXTURE_GEQUAL_R_SGIX 0x819D + +#define GLEW_SGIX_shadow GLEW_GET_VAR(__GLEW_SGIX_shadow) + +#endif /* GL_SGIX_shadow */ + +/* ------------------------- GL_SGIX_shadow_ambient ------------------------ */ + +#ifndef GL_SGIX_shadow_ambient +#define GL_SGIX_shadow_ambient 1 + +#define GL_SHADOW_AMBIENT_SGIX 0x80BF + +#define GLEW_SGIX_shadow_ambient GLEW_GET_VAR(__GLEW_SGIX_shadow_ambient) + +#endif /* GL_SGIX_shadow_ambient */ + +/* ----------------------------- GL_SGIX_sprite ---------------------------- */ + +#ifndef GL_SGIX_sprite +#define GL_SGIX_sprite 1 + +typedef void (GLAPIENTRY * PFNGLSPRITEPARAMETERFSGIXPROC) (GLenum pname, GLfloat param); +typedef void (GLAPIENTRY * PFNGLSPRITEPARAMETERFVSGIXPROC) (GLenum pname, GLfloat* params); +typedef void (GLAPIENTRY * PFNGLSPRITEPARAMETERISGIXPROC) (GLenum pname, GLint param); +typedef void (GLAPIENTRY * PFNGLSPRITEPARAMETERIVSGIXPROC) (GLenum pname, GLint* params); + +#define glSpriteParameterfSGIX GLEW_GET_FUN(__glewSpriteParameterfSGIX) +#define glSpriteParameterfvSGIX GLEW_GET_FUN(__glewSpriteParameterfvSGIX) +#define glSpriteParameteriSGIX GLEW_GET_FUN(__glewSpriteParameteriSGIX) +#define glSpriteParameterivSGIX GLEW_GET_FUN(__glewSpriteParameterivSGIX) + +#define GLEW_SGIX_sprite GLEW_GET_VAR(__GLEW_SGIX_sprite) + +#endif /* GL_SGIX_sprite */ + +/* ----------------------- GL_SGIX_tag_sample_buffer ----------------------- */ + +#ifndef GL_SGIX_tag_sample_buffer +#define GL_SGIX_tag_sample_buffer 1 + +typedef void (GLAPIENTRY * PFNGLTAGSAMPLEBUFFERSGIXPROC) (void); + +#define glTagSampleBufferSGIX GLEW_GET_FUN(__glewTagSampleBufferSGIX) + +#define GLEW_SGIX_tag_sample_buffer GLEW_GET_VAR(__GLEW_SGIX_tag_sample_buffer) + +#endif /* GL_SGIX_tag_sample_buffer */ + +/* ------------------------ GL_SGIX_texture_add_env ------------------------ */ + +#ifndef GL_SGIX_texture_add_env +#define GL_SGIX_texture_add_env 1 + +#define GLEW_SGIX_texture_add_env GLEW_GET_VAR(__GLEW_SGIX_texture_add_env) + +#endif /* GL_SGIX_texture_add_env */ + +/* -------------------- GL_SGIX_texture_coordinate_clamp ------------------- */ + +#ifndef GL_SGIX_texture_coordinate_clamp +#define GL_SGIX_texture_coordinate_clamp 1 + +#define GL_TEXTURE_MAX_CLAMP_S_SGIX 0x8369 +#define GL_TEXTURE_MAX_CLAMP_T_SGIX 0x836A +#define GL_TEXTURE_MAX_CLAMP_R_SGIX 0x836B + +#define GLEW_SGIX_texture_coordinate_clamp GLEW_GET_VAR(__GLEW_SGIX_texture_coordinate_clamp) + +#endif /* GL_SGIX_texture_coordinate_clamp */ + +/* ------------------------ GL_SGIX_texture_lod_bias ----------------------- */ + +#ifndef GL_SGIX_texture_lod_bias +#define GL_SGIX_texture_lod_bias 1 + +#define GLEW_SGIX_texture_lod_bias GLEW_GET_VAR(__GLEW_SGIX_texture_lod_bias) + +#endif /* GL_SGIX_texture_lod_bias */ + +/* ---------------------- GL_SGIX_texture_multi_buffer --------------------- */ + +#ifndef GL_SGIX_texture_multi_buffer +#define GL_SGIX_texture_multi_buffer 1 + +#define GL_TEXTURE_MULTI_BUFFER_HINT_SGIX 0x812E + +#define GLEW_SGIX_texture_multi_buffer GLEW_GET_VAR(__GLEW_SGIX_texture_multi_buffer) + +#endif /* GL_SGIX_texture_multi_buffer */ + +/* ------------------------- GL_SGIX_texture_range ------------------------- */ + +#ifndef GL_SGIX_texture_range +#define GL_SGIX_texture_range 1 + +#define GL_RGB_SIGNED_SGIX 0x85E0 +#define GL_RGBA_SIGNED_SGIX 0x85E1 +#define GL_ALPHA_SIGNED_SGIX 0x85E2 +#define GL_LUMINANCE_SIGNED_SGIX 0x85E3 +#define GL_INTENSITY_SIGNED_SGIX 0x85E4 +#define GL_LUMINANCE_ALPHA_SIGNED_SGIX 0x85E5 +#define GL_RGB16_SIGNED_SGIX 0x85E6 +#define GL_RGBA16_SIGNED_SGIX 0x85E7 +#define GL_ALPHA16_SIGNED_SGIX 0x85E8 +#define GL_LUMINANCE16_SIGNED_SGIX 0x85E9 +#define GL_INTENSITY16_SIGNED_SGIX 0x85EA +#define GL_LUMINANCE16_ALPHA16_SIGNED_SGIX 0x85EB +#define GL_RGB_EXTENDED_RANGE_SGIX 0x85EC +#define GL_RGBA_EXTENDED_RANGE_SGIX 0x85ED +#define GL_ALPHA_EXTENDED_RANGE_SGIX 0x85EE +#define GL_LUMINANCE_EXTENDED_RANGE_SGIX 0x85EF +#define GL_INTENSITY_EXTENDED_RANGE_SGIX 0x85F0 +#define GL_LUMINANCE_ALPHA_EXTENDED_RANGE_SGIX 0x85F1 +#define GL_RGB16_EXTENDED_RANGE_SGIX 0x85F2 +#define GL_RGBA16_EXTENDED_RANGE_SGIX 0x85F3 +#define GL_ALPHA16_EXTENDED_RANGE_SGIX 0x85F4 +#define GL_LUMINANCE16_EXTENDED_RANGE_SGIX 0x85F5 +#define GL_INTENSITY16_EXTENDED_RANGE_SGIX 0x85F6 +#define GL_LUMINANCE16_ALPHA16_EXTENDED_RANGE_SGIX 0x85F7 +#define GL_MIN_LUMINANCE_SGIS 0x85F8 +#define GL_MAX_LUMINANCE_SGIS 0x85F9 +#define GL_MIN_INTENSITY_SGIS 0x85FA +#define GL_MAX_INTENSITY_SGIS 0x85FB + +#define GLEW_SGIX_texture_range GLEW_GET_VAR(__GLEW_SGIX_texture_range) + +#endif /* GL_SGIX_texture_range */ + +/* ----------------------- GL_SGIX_texture_scale_bias ---------------------- */ + +#ifndef GL_SGIX_texture_scale_bias +#define GL_SGIX_texture_scale_bias 1 + +#define GL_POST_TEXTURE_FILTER_BIAS_SGIX 0x8179 +#define GL_POST_TEXTURE_FILTER_SCALE_SGIX 0x817A +#define GL_POST_TEXTURE_FILTER_BIAS_RANGE_SGIX 0x817B +#define GL_POST_TEXTURE_FILTER_SCALE_RANGE_SGIX 0x817C + +#define GLEW_SGIX_texture_scale_bias GLEW_GET_VAR(__GLEW_SGIX_texture_scale_bias) + +#endif /* GL_SGIX_texture_scale_bias */ + +/* ------------------------- GL_SGIX_vertex_preclip ------------------------ */ + +#ifndef GL_SGIX_vertex_preclip +#define GL_SGIX_vertex_preclip 1 + +#define GL_VERTEX_PRECLIP_SGIX 0x83EE +#define GL_VERTEX_PRECLIP_HINT_SGIX 0x83EF + +#define GLEW_SGIX_vertex_preclip GLEW_GET_VAR(__GLEW_SGIX_vertex_preclip) + +#endif /* GL_SGIX_vertex_preclip */ + +/* ---------------------- GL_SGIX_vertex_preclip_hint ---------------------- */ + +#ifndef GL_SGIX_vertex_preclip_hint +#define GL_SGIX_vertex_preclip_hint 1 + +#define GL_VERTEX_PRECLIP_SGIX 0x83EE +#define GL_VERTEX_PRECLIP_HINT_SGIX 0x83EF + +#define GLEW_SGIX_vertex_preclip_hint GLEW_GET_VAR(__GLEW_SGIX_vertex_preclip_hint) + +#endif /* GL_SGIX_vertex_preclip_hint */ + +/* ----------------------------- GL_SGIX_ycrcb ----------------------------- */ + +#ifndef GL_SGIX_ycrcb +#define GL_SGIX_ycrcb 1 + +#define GLEW_SGIX_ycrcb GLEW_GET_VAR(__GLEW_SGIX_ycrcb) + +#endif /* GL_SGIX_ycrcb */ + +/* -------------------------- GL_SGI_color_matrix -------------------------- */ + +#ifndef GL_SGI_color_matrix +#define GL_SGI_color_matrix 1 + +#define GL_COLOR_MATRIX_SGI 0x80B1 +#define GL_COLOR_MATRIX_STACK_DEPTH_SGI 0x80B2 +#define GL_MAX_COLOR_MATRIX_STACK_DEPTH_SGI 0x80B3 +#define GL_POST_COLOR_MATRIX_RED_SCALE_SGI 0x80B4 +#define GL_POST_COLOR_MATRIX_GREEN_SCALE_SGI 0x80B5 +#define GL_POST_COLOR_MATRIX_BLUE_SCALE_SGI 0x80B6 +#define GL_POST_COLOR_MATRIX_ALPHA_SCALE_SGI 0x80B7 +#define GL_POST_COLOR_MATRIX_RED_BIAS_SGI 0x80B8 +#define GL_POST_COLOR_MATRIX_GREEN_BIAS_SGI 0x80B9 +#define GL_POST_COLOR_MATRIX_BLUE_BIAS_SGI 0x80BA +#define GL_POST_COLOR_MATRIX_ALPHA_BIAS_SGI 0x80BB + +#define GLEW_SGI_color_matrix GLEW_GET_VAR(__GLEW_SGI_color_matrix) + +#endif /* GL_SGI_color_matrix */ + +/* --------------------------- GL_SGI_color_table -------------------------- */ + +#ifndef GL_SGI_color_table +#define GL_SGI_color_table 1 + +#define GL_COLOR_TABLE_SGI 0x80D0 +#define GL_POST_CONVOLUTION_COLOR_TABLE_SGI 0x80D1 +#define GL_POST_COLOR_MATRIX_COLOR_TABLE_SGI 0x80D2 +#define GL_PROXY_COLOR_TABLE_SGI 0x80D3 +#define GL_PROXY_POST_CONVOLUTION_COLOR_TABLE_SGI 0x80D4 +#define GL_PROXY_POST_COLOR_MATRIX_COLOR_TABLE_SGI 0x80D5 +#define GL_COLOR_TABLE_SCALE_SGI 0x80D6 +#define GL_COLOR_TABLE_BIAS_SGI 0x80D7 +#define GL_COLOR_TABLE_FORMAT_SGI 0x80D8 +#define GL_COLOR_TABLE_WIDTH_SGI 0x80D9 +#define GL_COLOR_TABLE_RED_SIZE_SGI 0x80DA +#define GL_COLOR_TABLE_GREEN_SIZE_SGI 0x80DB +#define GL_COLOR_TABLE_BLUE_SIZE_SGI 0x80DC +#define GL_COLOR_TABLE_ALPHA_SIZE_SGI 0x80DD +#define GL_COLOR_TABLE_LUMINANCE_SIZE_SGI 0x80DE +#define GL_COLOR_TABLE_INTENSITY_SIZE_SGI 0x80DF + +typedef void (GLAPIENTRY * PFNGLCOLORTABLEPARAMETERFVSGIPROC) (GLenum target, GLenum pname, const GLfloat* params); +typedef void (GLAPIENTRY * PFNGLCOLORTABLEPARAMETERIVSGIPROC) (GLenum target, GLenum pname, const GLint* params); +typedef void (GLAPIENTRY * PFNGLCOLORTABLESGIPROC) (GLenum target, GLenum internalformat, GLsizei width, GLenum format, GLenum type, const void* table); +typedef void (GLAPIENTRY * PFNGLCOPYCOLORTABLESGIPROC) (GLenum target, GLenum internalformat, GLint x, GLint y, GLsizei width); +typedef void (GLAPIENTRY * PFNGLGETCOLORTABLEPARAMETERFVSGIPROC) (GLenum target, GLenum pname, GLfloat* params); +typedef void (GLAPIENTRY * PFNGLGETCOLORTABLEPARAMETERIVSGIPROC) (GLenum target, GLenum pname, GLint* params); +typedef void (GLAPIENTRY * PFNGLGETCOLORTABLESGIPROC) (GLenum target, GLenum format, GLenum type, void* table); + +#define glColorTableParameterfvSGI GLEW_GET_FUN(__glewColorTableParameterfvSGI) +#define glColorTableParameterivSGI GLEW_GET_FUN(__glewColorTableParameterivSGI) +#define glColorTableSGI GLEW_GET_FUN(__glewColorTableSGI) +#define glCopyColorTableSGI GLEW_GET_FUN(__glewCopyColorTableSGI) +#define glGetColorTableParameterfvSGI GLEW_GET_FUN(__glewGetColorTableParameterfvSGI) +#define glGetColorTableParameterivSGI GLEW_GET_FUN(__glewGetColorTableParameterivSGI) +#define glGetColorTableSGI GLEW_GET_FUN(__glewGetColorTableSGI) + +#define GLEW_SGI_color_table GLEW_GET_VAR(__GLEW_SGI_color_table) + +#endif /* GL_SGI_color_table */ + +/* ----------------------- GL_SGI_texture_color_table ---------------------- */ + +#ifndef GL_SGI_texture_color_table +#define GL_SGI_texture_color_table 1 + +#define GL_TEXTURE_COLOR_TABLE_SGI 0x80BC +#define GL_PROXY_TEXTURE_COLOR_TABLE_SGI 0x80BD + +#define GLEW_SGI_texture_color_table GLEW_GET_VAR(__GLEW_SGI_texture_color_table) + +#endif /* GL_SGI_texture_color_table */ + +/* ------------------------- GL_SUNX_constant_data ------------------------- */ + +#ifndef GL_SUNX_constant_data +#define GL_SUNX_constant_data 1 + +#define GL_UNPACK_CONSTANT_DATA_SUNX 0x81D5 +#define GL_TEXTURE_CONSTANT_DATA_SUNX 0x81D6 + +typedef void (GLAPIENTRY * PFNGLFINISHTEXTURESUNXPROC) (void); + +#define glFinishTextureSUNX GLEW_GET_FUN(__glewFinishTextureSUNX) + +#define GLEW_SUNX_constant_data GLEW_GET_VAR(__GLEW_SUNX_constant_data) + +#endif /* GL_SUNX_constant_data */ + +/* -------------------- GL_SUN_convolution_border_modes -------------------- */ + +#ifndef GL_SUN_convolution_border_modes +#define GL_SUN_convolution_border_modes 1 + +#define GL_WRAP_BORDER_SUN 0x81D4 + +#define GLEW_SUN_convolution_border_modes GLEW_GET_VAR(__GLEW_SUN_convolution_border_modes) + +#endif /* GL_SUN_convolution_border_modes */ + +/* -------------------------- GL_SUN_global_alpha -------------------------- */ + +#ifndef GL_SUN_global_alpha +#define GL_SUN_global_alpha 1 + +#define GL_GLOBAL_ALPHA_SUN 0x81D9 +#define GL_GLOBAL_ALPHA_FACTOR_SUN 0x81DA + +typedef void (GLAPIENTRY * PFNGLGLOBALALPHAFACTORBSUNPROC) (GLbyte factor); +typedef void (GLAPIENTRY * PFNGLGLOBALALPHAFACTORDSUNPROC) (GLdouble factor); +typedef void (GLAPIENTRY * PFNGLGLOBALALPHAFACTORFSUNPROC) (GLfloat factor); +typedef void (GLAPIENTRY * PFNGLGLOBALALPHAFACTORISUNPROC) (GLint factor); +typedef void (GLAPIENTRY * PFNGLGLOBALALPHAFACTORSSUNPROC) (GLshort factor); +typedef void (GLAPIENTRY * PFNGLGLOBALALPHAFACTORUBSUNPROC) (GLubyte factor); +typedef void (GLAPIENTRY * PFNGLGLOBALALPHAFACTORUISUNPROC) (GLuint factor); +typedef void (GLAPIENTRY * PFNGLGLOBALALPHAFACTORUSSUNPROC) (GLushort factor); + +#define glGlobalAlphaFactorbSUN GLEW_GET_FUN(__glewGlobalAlphaFactorbSUN) +#define glGlobalAlphaFactordSUN GLEW_GET_FUN(__glewGlobalAlphaFactordSUN) +#define glGlobalAlphaFactorfSUN GLEW_GET_FUN(__glewGlobalAlphaFactorfSUN) +#define glGlobalAlphaFactoriSUN GLEW_GET_FUN(__glewGlobalAlphaFactoriSUN) +#define glGlobalAlphaFactorsSUN GLEW_GET_FUN(__glewGlobalAlphaFactorsSUN) +#define glGlobalAlphaFactorubSUN GLEW_GET_FUN(__glewGlobalAlphaFactorubSUN) +#define glGlobalAlphaFactoruiSUN GLEW_GET_FUN(__glewGlobalAlphaFactoruiSUN) +#define glGlobalAlphaFactorusSUN GLEW_GET_FUN(__glewGlobalAlphaFactorusSUN) + +#define GLEW_SUN_global_alpha GLEW_GET_VAR(__GLEW_SUN_global_alpha) + +#endif /* GL_SUN_global_alpha */ + +/* --------------------------- GL_SUN_mesh_array --------------------------- */ + +#ifndef GL_SUN_mesh_array +#define GL_SUN_mesh_array 1 + +#define GL_QUAD_MESH_SUN 0x8614 +#define GL_TRIANGLE_MESH_SUN 0x8615 + +#define GLEW_SUN_mesh_array GLEW_GET_VAR(__GLEW_SUN_mesh_array) + +#endif /* GL_SUN_mesh_array */ + +/* ------------------------ GL_SUN_read_video_pixels ----------------------- */ + +#ifndef GL_SUN_read_video_pixels +#define GL_SUN_read_video_pixels 1 + +typedef void (GLAPIENTRY * PFNGLREADVIDEOPIXELSSUNPROC) (GLint x, GLint y, GLsizei width, GLsizei height, GLenum format, GLenum type, GLvoid* pixels); + +#define glReadVideoPixelsSUN GLEW_GET_FUN(__glewReadVideoPixelsSUN) + +#define GLEW_SUN_read_video_pixels GLEW_GET_VAR(__GLEW_SUN_read_video_pixels) + +#endif /* GL_SUN_read_video_pixels */ + +/* --------------------------- GL_SUN_slice_accum -------------------------- */ + +#ifndef GL_SUN_slice_accum +#define GL_SUN_slice_accum 1 + +#define GL_SLICE_ACCUM_SUN 0x85CC + +#define GLEW_SUN_slice_accum GLEW_GET_VAR(__GLEW_SUN_slice_accum) + +#endif /* GL_SUN_slice_accum */ + +/* -------------------------- GL_SUN_triangle_list ------------------------- */ + +#ifndef GL_SUN_triangle_list +#define GL_SUN_triangle_list 1 + +#define GL_RESTART_SUN 0x01 +#define GL_REPLACE_MIDDLE_SUN 0x02 +#define GL_REPLACE_OLDEST_SUN 0x03 +#define GL_TRIANGLE_LIST_SUN 0x81D7 +#define GL_REPLACEMENT_CODE_SUN 0x81D8 +#define GL_REPLACEMENT_CODE_ARRAY_SUN 0x85C0 +#define GL_REPLACEMENT_CODE_ARRAY_TYPE_SUN 0x85C1 +#define GL_REPLACEMENT_CODE_ARRAY_STRIDE_SUN 0x85C2 +#define GL_REPLACEMENT_CODE_ARRAY_POINTER_SUN 0x85C3 +#define GL_R1UI_V3F_SUN 0x85C4 +#define GL_R1UI_C4UB_V3F_SUN 0x85C5 +#define GL_R1UI_C3F_V3F_SUN 0x85C6 +#define GL_R1UI_N3F_V3F_SUN 0x85C7 +#define GL_R1UI_C4F_N3F_V3F_SUN 0x85C8 +#define GL_R1UI_T2F_V3F_SUN 0x85C9 +#define GL_R1UI_T2F_N3F_V3F_SUN 0x85CA +#define GL_R1UI_T2F_C4F_N3F_V3F_SUN 0x85CB + +typedef void (GLAPIENTRY * PFNGLREPLACEMENTCODEPOINTERSUNPROC) (GLenum type, GLsizei stride, const void* pointer); +typedef void (GLAPIENTRY * PFNGLREPLACEMENTCODEUBSUNPROC) (GLubyte code); +typedef void (GLAPIENTRY * PFNGLREPLACEMENTCODEUBVSUNPROC) (const GLubyte* code); +typedef void (GLAPIENTRY * PFNGLREPLACEMENTCODEUISUNPROC) (GLuint code); +typedef void (GLAPIENTRY * PFNGLREPLACEMENTCODEUIVSUNPROC) (const GLuint* code); +typedef void (GLAPIENTRY * PFNGLREPLACEMENTCODEUSSUNPROC) (GLushort code); +typedef void (GLAPIENTRY * PFNGLREPLACEMENTCODEUSVSUNPROC) (const GLushort* code); + +#define glReplacementCodePointerSUN GLEW_GET_FUN(__glewReplacementCodePointerSUN) +#define glReplacementCodeubSUN GLEW_GET_FUN(__glewReplacementCodeubSUN) +#define glReplacementCodeubvSUN GLEW_GET_FUN(__glewReplacementCodeubvSUN) +#define glReplacementCodeuiSUN GLEW_GET_FUN(__glewReplacementCodeuiSUN) +#define glReplacementCodeuivSUN GLEW_GET_FUN(__glewReplacementCodeuivSUN) +#define glReplacementCodeusSUN GLEW_GET_FUN(__glewReplacementCodeusSUN) +#define glReplacementCodeusvSUN GLEW_GET_FUN(__glewReplacementCodeusvSUN) + +#define GLEW_SUN_triangle_list GLEW_GET_VAR(__GLEW_SUN_triangle_list) + +#endif /* GL_SUN_triangle_list */ + +/* ----------------------------- GL_SUN_vertex ----------------------------- */ + +#ifndef GL_SUN_vertex +#define GL_SUN_vertex 1 + +typedef void (GLAPIENTRY * PFNGLCOLOR3FVERTEX3FSUNPROC) (GLfloat r, GLfloat g, GLfloat b, GLfloat x, GLfloat y, GLfloat z); +typedef void (GLAPIENTRY * PFNGLCOLOR3FVERTEX3FVSUNPROC) (const GLfloat* c, const GLfloat *v); +typedef void (GLAPIENTRY * PFNGLCOLOR4FNORMAL3FVERTEX3FSUNPROC) (GLfloat r, GLfloat g, GLfloat b, GLfloat a, GLfloat nx, GLfloat ny, GLfloat nz, GLfloat x, GLfloat y, GLfloat z); +typedef void (GLAPIENTRY * PFNGLCOLOR4FNORMAL3FVERTEX3FVSUNPROC) (const GLfloat* c, const GLfloat *n, const GLfloat *v); +typedef void (GLAPIENTRY * PFNGLCOLOR4UBVERTEX2FSUNPROC) (GLubyte r, GLubyte g, GLubyte b, GLubyte a, GLfloat x, GLfloat y); +typedef void (GLAPIENTRY * PFNGLCOLOR4UBVERTEX2FVSUNPROC) (const GLubyte* c, const GLfloat *v); +typedef void (GLAPIENTRY * PFNGLCOLOR4UBVERTEX3FSUNPROC) (GLubyte r, GLubyte g, GLubyte b, GLubyte a, GLfloat x, GLfloat y, GLfloat z); +typedef void (GLAPIENTRY * PFNGLCOLOR4UBVERTEX3FVSUNPROC) (const GLubyte* c, const GLfloat *v); +typedef void (GLAPIENTRY * PFNGLNORMAL3FVERTEX3FSUNPROC) (GLfloat nx, GLfloat ny, GLfloat nz, GLfloat x, GLfloat y, GLfloat z); +typedef void (GLAPIENTRY * PFNGLNORMAL3FVERTEX3FVSUNPROC) (const GLfloat* n, const GLfloat *v); +typedef void (GLAPIENTRY * PFNGLREPLACEMENTCODEUICOLOR3FVERTEX3FSUNPROC) (GLuint rc, GLfloat r, GLfloat g, GLfloat b, GLfloat x, GLfloat y, GLfloat z); +typedef void (GLAPIENTRY * PFNGLREPLACEMENTCODEUICOLOR3FVERTEX3FVSUNPROC) (const GLuint* rc, const GLfloat *c, const GLfloat *v); +typedef void (GLAPIENTRY * PFNGLREPLACEMENTCODEUICOLOR4FNORMAL3FVERTEX3FSUNPROC) (GLuint rc, GLfloat r, GLfloat g, GLfloat b, GLfloat a, GLfloat nx, GLfloat ny, GLfloat nz, GLfloat x, GLfloat y, GLfloat z); +typedef void (GLAPIENTRY * PFNGLREPLACEMENTCODEUICOLOR4FNORMAL3FVERTEX3FVSUNPROC) (const GLuint* rc, const GLfloat *c, const GLfloat *n, const GLfloat *v); +typedef void (GLAPIENTRY * PFNGLREPLACEMENTCODEUICOLOR4UBVERTEX3FSUNPROC) (GLuint rc, GLubyte r, GLubyte g, GLubyte b, GLubyte a, GLfloat x, GLfloat y, GLfloat z); +typedef void (GLAPIENTRY * PFNGLREPLACEMENTCODEUICOLOR4UBVERTEX3FVSUNPROC) (const GLuint* rc, const GLubyte *c, const GLfloat *v); +typedef void (GLAPIENTRY * PFNGLREPLACEMENTCODEUINORMAL3FVERTEX3FSUNPROC) (GLuint rc, GLfloat nx, GLfloat ny, GLfloat nz, GLfloat x, GLfloat y, GLfloat z); +typedef void (GLAPIENTRY * PFNGLREPLACEMENTCODEUINORMAL3FVERTEX3FVSUNPROC) (const GLuint* rc, const GLfloat *n, const GLfloat *v); +typedef void (GLAPIENTRY * PFNGLREPLACEMENTCODEUITEXCOORD2FCOLOR4FNORMAL3FVERTEX3FSUNPROC) (GLuint rc, GLfloat s, GLfloat t, GLfloat r, GLfloat g, GLfloat b, GLfloat a, GLfloat nx, GLfloat ny, GLfloat nz, GLfloat x, GLfloat y, GLfloat z); +typedef void (GLAPIENTRY * PFNGLREPLACEMENTCODEUITEXCOORD2FCOLOR4FNORMAL3FVERTEX3FVSUNPROC) (const GLuint* rc, const GLfloat *tc, const GLfloat *c, const GLfloat *n, const GLfloat *v); +typedef void (GLAPIENTRY * PFNGLREPLACEMENTCODEUITEXCOORD2FNORMAL3FVERTEX3FSUNPROC) (GLuint rc, GLfloat s, GLfloat t, GLfloat nx, GLfloat ny, GLfloat nz, GLfloat x, GLfloat y, GLfloat z); +typedef void (GLAPIENTRY * PFNGLREPLACEMENTCODEUITEXCOORD2FNORMAL3FVERTEX3FVSUNPROC) (const GLuint* rc, const GLfloat *tc, const GLfloat *n, const GLfloat *v); +typedef void (GLAPIENTRY * PFNGLREPLACEMENTCODEUITEXCOORD2FVERTEX3FSUNPROC) (GLuint rc, GLfloat s, GLfloat t, GLfloat x, GLfloat y, GLfloat z); +typedef void (GLAPIENTRY * PFNGLREPLACEMENTCODEUITEXCOORD2FVERTEX3FVSUNPROC) (const GLuint* rc, const GLfloat *tc, const GLfloat *v); +typedef void (GLAPIENTRY * PFNGLREPLACEMENTCODEUIVERTEX3FSUNPROC) (GLuint rc, GLfloat x, GLfloat y, GLfloat z); +typedef void (GLAPIENTRY * PFNGLREPLACEMENTCODEUIVERTEX3FVSUNPROC) (const GLuint* rc, const GLfloat *v); +typedef void (GLAPIENTRY * PFNGLTEXCOORD2FCOLOR3FVERTEX3FSUNPROC) (GLfloat s, GLfloat t, GLfloat r, GLfloat g, GLfloat b, GLfloat x, GLfloat y, GLfloat z); +typedef void (GLAPIENTRY * PFNGLTEXCOORD2FCOLOR3FVERTEX3FVSUNPROC) (const GLfloat* tc, const GLfloat *c, const GLfloat *v); +typedef void (GLAPIENTRY * PFNGLTEXCOORD2FCOLOR4FNORMAL3FVERTEX3FSUNPROC) (GLfloat s, GLfloat t, GLfloat r, GLfloat g, GLfloat b, GLfloat a, GLfloat nx, GLfloat ny, GLfloat nz, GLfloat x, GLfloat y, GLfloat z); +typedef void (GLAPIENTRY * PFNGLTEXCOORD2FCOLOR4FNORMAL3FVERTEX3FVSUNPROC) (const GLfloat* tc, const GLfloat *c, const GLfloat *n, const GLfloat *v); +typedef void (GLAPIENTRY * PFNGLTEXCOORD2FCOLOR4UBVERTEX3FSUNPROC) (GLfloat s, GLfloat t, GLubyte r, GLubyte g, GLubyte b, GLubyte a, GLfloat x, GLfloat y, GLfloat z); +typedef void (GLAPIENTRY * PFNGLTEXCOORD2FCOLOR4UBVERTEX3FVSUNPROC) (const GLfloat* tc, const GLubyte *c, const GLfloat *v); +typedef void (GLAPIENTRY * PFNGLTEXCOORD2FNORMAL3FVERTEX3FSUNPROC) (GLfloat s, GLfloat t, GLfloat nx, GLfloat ny, GLfloat nz, GLfloat x, GLfloat y, GLfloat z); +typedef void (GLAPIENTRY * PFNGLTEXCOORD2FNORMAL3FVERTEX3FVSUNPROC) (const GLfloat* tc, const GLfloat *n, const GLfloat *v); +typedef void (GLAPIENTRY * PFNGLTEXCOORD2FVERTEX3FSUNPROC) (GLfloat s, GLfloat t, GLfloat x, GLfloat y, GLfloat z); +typedef void (GLAPIENTRY * PFNGLTEXCOORD2FVERTEX3FVSUNPROC) (const GLfloat* tc, const GLfloat *v); +typedef void (GLAPIENTRY * PFNGLTEXCOORD4FCOLOR4FNORMAL3FVERTEX4FSUNPROC) (GLfloat s, GLfloat t, GLfloat p, GLfloat q, GLfloat r, GLfloat g, GLfloat b, GLfloat a, GLfloat nx, GLfloat ny, GLfloat nz, GLfloat x, GLfloat y, GLfloat z, GLfloat w); +typedef void (GLAPIENTRY * PFNGLTEXCOORD4FCOLOR4FNORMAL3FVERTEX4FVSUNPROC) (const GLfloat* tc, const GLfloat *c, const GLfloat *n, const GLfloat *v); +typedef void (GLAPIENTRY * PFNGLTEXCOORD4FVERTEX4FSUNPROC) (GLfloat s, GLfloat t, GLfloat p, GLfloat q, GLfloat x, GLfloat y, GLfloat z, GLfloat w); +typedef void (GLAPIENTRY * PFNGLTEXCOORD4FVERTEX4FVSUNPROC) (const GLfloat* tc, const GLfloat *v); + +#define glColor3fVertex3fSUN GLEW_GET_FUN(__glewColor3fVertex3fSUN) +#define glColor3fVertex3fvSUN GLEW_GET_FUN(__glewColor3fVertex3fvSUN) +#define glColor4fNormal3fVertex3fSUN GLEW_GET_FUN(__glewColor4fNormal3fVertex3fSUN) +#define glColor4fNormal3fVertex3fvSUN GLEW_GET_FUN(__glewColor4fNormal3fVertex3fvSUN) +#define glColor4ubVertex2fSUN GLEW_GET_FUN(__glewColor4ubVertex2fSUN) +#define glColor4ubVertex2fvSUN GLEW_GET_FUN(__glewColor4ubVertex2fvSUN) +#define glColor4ubVertex3fSUN GLEW_GET_FUN(__glewColor4ubVertex3fSUN) +#define glColor4ubVertex3fvSUN GLEW_GET_FUN(__glewColor4ubVertex3fvSUN) +#define glNormal3fVertex3fSUN GLEW_GET_FUN(__glewNormal3fVertex3fSUN) +#define glNormal3fVertex3fvSUN GLEW_GET_FUN(__glewNormal3fVertex3fvSUN) +#define glReplacementCodeuiColor3fVertex3fSUN GLEW_GET_FUN(__glewReplacementCodeuiColor3fVertex3fSUN) +#define glReplacementCodeuiColor3fVertex3fvSUN GLEW_GET_FUN(__glewReplacementCodeuiColor3fVertex3fvSUN) +#define glReplacementCodeuiColor4fNormal3fVertex3fSUN GLEW_GET_FUN(__glewReplacementCodeuiColor4fNormal3fVertex3fSUN) +#define glReplacementCodeuiColor4fNormal3fVertex3fvSUN GLEW_GET_FUN(__glewReplacementCodeuiColor4fNormal3fVertex3fvSUN) +#define glReplacementCodeuiColor4ubVertex3fSUN GLEW_GET_FUN(__glewReplacementCodeuiColor4ubVertex3fSUN) +#define glReplacementCodeuiColor4ubVertex3fvSUN GLEW_GET_FUN(__glewReplacementCodeuiColor4ubVertex3fvSUN) +#define glReplacementCodeuiNormal3fVertex3fSUN GLEW_GET_FUN(__glewReplacementCodeuiNormal3fVertex3fSUN) +#define glReplacementCodeuiNormal3fVertex3fvSUN GLEW_GET_FUN(__glewReplacementCodeuiNormal3fVertex3fvSUN) +#define glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fSUN GLEW_GET_FUN(__glewReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fSUN) +#define glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN GLEW_GET_FUN(__glewReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN) +#define glReplacementCodeuiTexCoord2fNormal3fVertex3fSUN GLEW_GET_FUN(__glewReplacementCodeuiTexCoord2fNormal3fVertex3fSUN) +#define glReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN GLEW_GET_FUN(__glewReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN) +#define glReplacementCodeuiTexCoord2fVertex3fSUN GLEW_GET_FUN(__glewReplacementCodeuiTexCoord2fVertex3fSUN) +#define glReplacementCodeuiTexCoord2fVertex3fvSUN GLEW_GET_FUN(__glewReplacementCodeuiTexCoord2fVertex3fvSUN) +#define glReplacementCodeuiVertex3fSUN GLEW_GET_FUN(__glewReplacementCodeuiVertex3fSUN) +#define glReplacementCodeuiVertex3fvSUN GLEW_GET_FUN(__glewReplacementCodeuiVertex3fvSUN) +#define glTexCoord2fColor3fVertex3fSUN GLEW_GET_FUN(__glewTexCoord2fColor3fVertex3fSUN) +#define glTexCoord2fColor3fVertex3fvSUN GLEW_GET_FUN(__glewTexCoord2fColor3fVertex3fvSUN) +#define glTexCoord2fColor4fNormal3fVertex3fSUN GLEW_GET_FUN(__glewTexCoord2fColor4fNormal3fVertex3fSUN) +#define glTexCoord2fColor4fNormal3fVertex3fvSUN GLEW_GET_FUN(__glewTexCoord2fColor4fNormal3fVertex3fvSUN) +#define glTexCoord2fColor4ubVertex3fSUN GLEW_GET_FUN(__glewTexCoord2fColor4ubVertex3fSUN) +#define glTexCoord2fColor4ubVertex3fvSUN GLEW_GET_FUN(__glewTexCoord2fColor4ubVertex3fvSUN) +#define glTexCoord2fNormal3fVertex3fSUN GLEW_GET_FUN(__glewTexCoord2fNormal3fVertex3fSUN) +#define glTexCoord2fNormal3fVertex3fvSUN GLEW_GET_FUN(__glewTexCoord2fNormal3fVertex3fvSUN) +#define glTexCoord2fVertex3fSUN GLEW_GET_FUN(__glewTexCoord2fVertex3fSUN) +#define glTexCoord2fVertex3fvSUN GLEW_GET_FUN(__glewTexCoord2fVertex3fvSUN) +#define glTexCoord4fColor4fNormal3fVertex4fSUN GLEW_GET_FUN(__glewTexCoord4fColor4fNormal3fVertex4fSUN) +#define glTexCoord4fColor4fNormal3fVertex4fvSUN GLEW_GET_FUN(__glewTexCoord4fColor4fNormal3fVertex4fvSUN) +#define glTexCoord4fVertex4fSUN GLEW_GET_FUN(__glewTexCoord4fVertex4fSUN) +#define glTexCoord4fVertex4fvSUN GLEW_GET_FUN(__glewTexCoord4fVertex4fvSUN) + +#define GLEW_SUN_vertex GLEW_GET_VAR(__GLEW_SUN_vertex) + +#endif /* GL_SUN_vertex */ + +/* -------------------------- GL_WIN_phong_shading ------------------------- */ + +#ifndef GL_WIN_phong_shading +#define GL_WIN_phong_shading 1 + +#define GL_PHONG_WIN 0x80EA +#define GL_PHONG_HINT_WIN 0x80EB + +#define GLEW_WIN_phong_shading GLEW_GET_VAR(__GLEW_WIN_phong_shading) + +#endif /* GL_WIN_phong_shading */ + +/* -------------------------- GL_WIN_specular_fog -------------------------- */ + +#ifndef GL_WIN_specular_fog +#define GL_WIN_specular_fog 1 + +#define GL_FOG_SPECULAR_TEXTURE_WIN 0x80EC + +#define GLEW_WIN_specular_fog GLEW_GET_VAR(__GLEW_WIN_specular_fog) + +#endif /* GL_WIN_specular_fog */ + +/* ---------------------------- GL_WIN_swap_hint --------------------------- */ + +#ifndef GL_WIN_swap_hint +#define GL_WIN_swap_hint 1 + +typedef void (GLAPIENTRY * PFNGLADDSWAPHINTRECTWINPROC) (GLint x, GLint y, GLsizei width, GLsizei height); + +#define glAddSwapHintRectWIN GLEW_GET_FUN(__glewAddSwapHintRectWIN) + +#define GLEW_WIN_swap_hint GLEW_GET_VAR(__GLEW_WIN_swap_hint) + +#endif /* GL_WIN_swap_hint */ + +/* ------------------------------------------------------------------------- */ + +#if defined(GLEW_MX) && defined(_WIN32) +#define GLEW_FUN_EXPORT +#else +#define GLEW_FUN_EXPORT GLEWAPI +#endif /* GLEW_MX */ + +#if defined(GLEW_MX) +#define GLEW_VAR_EXPORT +#else +#define GLEW_VAR_EXPORT GLEWAPI +#endif /* GLEW_MX */ + +#if defined(GLEW_MX) && defined(_WIN32) +struct GLEWContextStruct +{ +#endif /* GLEW_MX */ + +GLEW_FUN_EXPORT PFNGLCOPYTEXSUBIMAGE3DPROC __glewCopyTexSubImage3D; +GLEW_FUN_EXPORT PFNGLDRAWRANGEELEMENTSPROC __glewDrawRangeElements; +GLEW_FUN_EXPORT PFNGLTEXIMAGE3DPROC __glewTexImage3D; +GLEW_FUN_EXPORT PFNGLTEXSUBIMAGE3DPROC __glewTexSubImage3D; + +GLEW_FUN_EXPORT PFNGLACTIVETEXTUREPROC __glewActiveTexture; +GLEW_FUN_EXPORT PFNGLCLIENTACTIVETEXTUREPROC __glewClientActiveTexture; +GLEW_FUN_EXPORT PFNGLCOMPRESSEDTEXIMAGE1DPROC __glewCompressedTexImage1D; +GLEW_FUN_EXPORT PFNGLCOMPRESSEDTEXIMAGE2DPROC __glewCompressedTexImage2D; +GLEW_FUN_EXPORT PFNGLCOMPRESSEDTEXIMAGE3DPROC __glewCompressedTexImage3D; +GLEW_FUN_EXPORT PFNGLCOMPRESSEDTEXSUBIMAGE1DPROC __glewCompressedTexSubImage1D; +GLEW_FUN_EXPORT PFNGLCOMPRESSEDTEXSUBIMAGE2DPROC __glewCompressedTexSubImage2D; +GLEW_FUN_EXPORT PFNGLCOMPRESSEDTEXSUBIMAGE3DPROC __glewCompressedTexSubImage3D; +GLEW_FUN_EXPORT PFNGLGETCOMPRESSEDTEXIMAGEPROC __glewGetCompressedTexImage; +GLEW_FUN_EXPORT PFNGLLOADTRANSPOSEMATRIXDPROC __glewLoadTransposeMatrixd; +GLEW_FUN_EXPORT PFNGLLOADTRANSPOSEMATRIXFPROC __glewLoadTransposeMatrixf; +GLEW_FUN_EXPORT PFNGLMULTTRANSPOSEMATRIXDPROC __glewMultTransposeMatrixd; +GLEW_FUN_EXPORT PFNGLMULTTRANSPOSEMATRIXFPROC __glewMultTransposeMatrixf; +GLEW_FUN_EXPORT PFNGLMULTITEXCOORD1DPROC __glewMultiTexCoord1d; +GLEW_FUN_EXPORT PFNGLMULTITEXCOORD1DVPROC __glewMultiTexCoord1dv; +GLEW_FUN_EXPORT PFNGLMULTITEXCOORD1FPROC __glewMultiTexCoord1f; +GLEW_FUN_EXPORT PFNGLMULTITEXCOORD1FVPROC __glewMultiTexCoord1fv; +GLEW_FUN_EXPORT PFNGLMULTITEXCOORD1IPROC __glewMultiTexCoord1i; +GLEW_FUN_EXPORT PFNGLMULTITEXCOORD1IVPROC __glewMultiTexCoord1iv; +GLEW_FUN_EXPORT PFNGLMULTITEXCOORD1SPROC __glewMultiTexCoord1s; +GLEW_FUN_EXPORT PFNGLMULTITEXCOORD1SVPROC __glewMultiTexCoord1sv; +GLEW_FUN_EXPORT PFNGLMULTITEXCOORD2DPROC __glewMultiTexCoord2d; +GLEW_FUN_EXPORT PFNGLMULTITEXCOORD2DVPROC __glewMultiTexCoord2dv; +GLEW_FUN_EXPORT PFNGLMULTITEXCOORD2FPROC __glewMultiTexCoord2f; +GLEW_FUN_EXPORT PFNGLMULTITEXCOORD2FVPROC __glewMultiTexCoord2fv; +GLEW_FUN_EXPORT PFNGLMULTITEXCOORD2IPROC __glewMultiTexCoord2i; +GLEW_FUN_EXPORT PFNGLMULTITEXCOORD2IVPROC __glewMultiTexCoord2iv; +GLEW_FUN_EXPORT PFNGLMULTITEXCOORD2SPROC __glewMultiTexCoord2s; +GLEW_FUN_EXPORT PFNGLMULTITEXCOORD2SVPROC __glewMultiTexCoord2sv; +GLEW_FUN_EXPORT PFNGLMULTITEXCOORD3DPROC __glewMultiTexCoord3d; +GLEW_FUN_EXPORT PFNGLMULTITEXCOORD3DVPROC __glewMultiTexCoord3dv; +GLEW_FUN_EXPORT PFNGLMULTITEXCOORD3FPROC __glewMultiTexCoord3f; +GLEW_FUN_EXPORT PFNGLMULTITEXCOORD3FVPROC __glewMultiTexCoord3fv; +GLEW_FUN_EXPORT PFNGLMULTITEXCOORD3IPROC __glewMultiTexCoord3i; +GLEW_FUN_EXPORT PFNGLMULTITEXCOORD3IVPROC __glewMultiTexCoord3iv; +GLEW_FUN_EXPORT PFNGLMULTITEXCOORD3SPROC __glewMultiTexCoord3s; +GLEW_FUN_EXPORT PFNGLMULTITEXCOORD3SVPROC __glewMultiTexCoord3sv; +GLEW_FUN_EXPORT PFNGLMULTITEXCOORD4DPROC __glewMultiTexCoord4d; +GLEW_FUN_EXPORT PFNGLMULTITEXCOORD4DVPROC __glewMultiTexCoord4dv; +GLEW_FUN_EXPORT PFNGLMULTITEXCOORD4FPROC __glewMultiTexCoord4f; +GLEW_FUN_EXPORT PFNGLMULTITEXCOORD4FVPROC __glewMultiTexCoord4fv; +GLEW_FUN_EXPORT PFNGLMULTITEXCOORD4IPROC __glewMultiTexCoord4i; +GLEW_FUN_EXPORT PFNGLMULTITEXCOORD4IVPROC __glewMultiTexCoord4iv; +GLEW_FUN_EXPORT PFNGLMULTITEXCOORD4SPROC __glewMultiTexCoord4s; +GLEW_FUN_EXPORT PFNGLMULTITEXCOORD4SVPROC __glewMultiTexCoord4sv; +GLEW_FUN_EXPORT PFNGLSAMPLECOVERAGEPROC __glewSampleCoverage; + +GLEW_FUN_EXPORT PFNGLBLENDCOLORPROC __glewBlendColor; +GLEW_FUN_EXPORT PFNGLBLENDEQUATIONPROC __glewBlendEquation; +GLEW_FUN_EXPORT PFNGLBLENDFUNCSEPARATEPROC __glewBlendFuncSeparate; +GLEW_FUN_EXPORT PFNGLFOGCOORDPOINTERPROC __glewFogCoordPointer; +GLEW_FUN_EXPORT PFNGLFOGCOORDDPROC __glewFogCoordd; +GLEW_FUN_EXPORT PFNGLFOGCOORDDVPROC __glewFogCoorddv; +GLEW_FUN_EXPORT PFNGLFOGCOORDFPROC __glewFogCoordf; +GLEW_FUN_EXPORT PFNGLFOGCOORDFVPROC __glewFogCoordfv; +GLEW_FUN_EXPORT PFNGLMULTIDRAWARRAYSPROC __glewMultiDrawArrays; +GLEW_FUN_EXPORT PFNGLMULTIDRAWELEMENTSPROC __glewMultiDrawElements; +GLEW_FUN_EXPORT PFNGLPOINTPARAMETERFPROC __glewPointParameterf; +GLEW_FUN_EXPORT PFNGLPOINTPARAMETERFVPROC __glewPointParameterfv; +GLEW_FUN_EXPORT PFNGLPOINTPARAMETERIPROC __glewPointParameteri; +GLEW_FUN_EXPORT PFNGLPOINTPARAMETERIVPROC __glewPointParameteriv; +GLEW_FUN_EXPORT PFNGLSECONDARYCOLOR3BPROC __glewSecondaryColor3b; +GLEW_FUN_EXPORT PFNGLSECONDARYCOLOR3BVPROC __glewSecondaryColor3bv; +GLEW_FUN_EXPORT PFNGLSECONDARYCOLOR3DPROC __glewSecondaryColor3d; +GLEW_FUN_EXPORT PFNGLSECONDARYCOLOR3DVPROC __glewSecondaryColor3dv; +GLEW_FUN_EXPORT PFNGLSECONDARYCOLOR3FPROC __glewSecondaryColor3f; +GLEW_FUN_EXPORT PFNGLSECONDARYCOLOR3FVPROC __glewSecondaryColor3fv; +GLEW_FUN_EXPORT PFNGLSECONDARYCOLOR3IPROC __glewSecondaryColor3i; +GLEW_FUN_EXPORT PFNGLSECONDARYCOLOR3IVPROC __glewSecondaryColor3iv; +GLEW_FUN_EXPORT PFNGLSECONDARYCOLOR3SPROC __glewSecondaryColor3s; +GLEW_FUN_EXPORT PFNGLSECONDARYCOLOR3SVPROC __glewSecondaryColor3sv; +GLEW_FUN_EXPORT PFNGLSECONDARYCOLOR3UBPROC __glewSecondaryColor3ub; +GLEW_FUN_EXPORT PFNGLSECONDARYCOLOR3UBVPROC __glewSecondaryColor3ubv; +GLEW_FUN_EXPORT PFNGLSECONDARYCOLOR3UIPROC __glewSecondaryColor3ui; +GLEW_FUN_EXPORT PFNGLSECONDARYCOLOR3UIVPROC __glewSecondaryColor3uiv; +GLEW_FUN_EXPORT PFNGLSECONDARYCOLOR3USPROC __glewSecondaryColor3us; +GLEW_FUN_EXPORT PFNGLSECONDARYCOLOR3USVPROC __glewSecondaryColor3usv; +GLEW_FUN_EXPORT PFNGLSECONDARYCOLORPOINTERPROC __glewSecondaryColorPointer; +GLEW_FUN_EXPORT PFNGLWINDOWPOS2DPROC __glewWindowPos2d; +GLEW_FUN_EXPORT PFNGLWINDOWPOS2DVPROC __glewWindowPos2dv; +GLEW_FUN_EXPORT PFNGLWINDOWPOS2FPROC __glewWindowPos2f; +GLEW_FUN_EXPORT PFNGLWINDOWPOS2FVPROC __glewWindowPos2fv; +GLEW_FUN_EXPORT PFNGLWINDOWPOS2IPROC __glewWindowPos2i; +GLEW_FUN_EXPORT PFNGLWINDOWPOS2IVPROC __glewWindowPos2iv; +GLEW_FUN_EXPORT PFNGLWINDOWPOS2SPROC __glewWindowPos2s; +GLEW_FUN_EXPORT PFNGLWINDOWPOS2SVPROC __glewWindowPos2sv; +GLEW_FUN_EXPORT PFNGLWINDOWPOS3DPROC __glewWindowPos3d; +GLEW_FUN_EXPORT PFNGLWINDOWPOS3DVPROC __glewWindowPos3dv; +GLEW_FUN_EXPORT PFNGLWINDOWPOS3FPROC __glewWindowPos3f; +GLEW_FUN_EXPORT PFNGLWINDOWPOS3FVPROC __glewWindowPos3fv; +GLEW_FUN_EXPORT PFNGLWINDOWPOS3IPROC __glewWindowPos3i; +GLEW_FUN_EXPORT PFNGLWINDOWPOS3IVPROC __glewWindowPos3iv; +GLEW_FUN_EXPORT PFNGLWINDOWPOS3SPROC __glewWindowPos3s; +GLEW_FUN_EXPORT PFNGLWINDOWPOS3SVPROC __glewWindowPos3sv; + +GLEW_FUN_EXPORT PFNGLBEGINQUERYPROC __glewBeginQuery; +GLEW_FUN_EXPORT PFNGLBINDBUFFERPROC __glewBindBuffer; +GLEW_FUN_EXPORT PFNGLBUFFERDATAPROC __glewBufferData; +GLEW_FUN_EXPORT PFNGLBUFFERSUBDATAPROC __glewBufferSubData; +GLEW_FUN_EXPORT PFNGLDELETEBUFFERSPROC __glewDeleteBuffers; +GLEW_FUN_EXPORT PFNGLDELETEQUERIESPROC __glewDeleteQueries; +GLEW_FUN_EXPORT PFNGLENDQUERYPROC __glewEndQuery; +GLEW_FUN_EXPORT PFNGLGENBUFFERSPROC __glewGenBuffers; +GLEW_FUN_EXPORT PFNGLGENQUERIESPROC __glewGenQueries; +GLEW_FUN_EXPORT PFNGLGETBUFFERPARAMETERIVPROC __glewGetBufferParameteriv; +GLEW_FUN_EXPORT PFNGLGETBUFFERPOINTERVPROC __glewGetBufferPointerv; +GLEW_FUN_EXPORT PFNGLGETBUFFERSUBDATAPROC __glewGetBufferSubData; +GLEW_FUN_EXPORT PFNGLGETQUERYOBJECTIVPROC __glewGetQueryObjectiv; +GLEW_FUN_EXPORT PFNGLGETQUERYOBJECTUIVPROC __glewGetQueryObjectuiv; +GLEW_FUN_EXPORT PFNGLGETQUERYIVPROC __glewGetQueryiv; +GLEW_FUN_EXPORT PFNGLISBUFFERPROC __glewIsBuffer; +GLEW_FUN_EXPORT PFNGLISQUERYPROC __glewIsQuery; +GLEW_FUN_EXPORT PFNGLMAPBUFFERPROC __glewMapBuffer; +GLEW_FUN_EXPORT PFNGLUNMAPBUFFERPROC __glewUnmapBuffer; + +GLEW_FUN_EXPORT PFNGLATTACHSHADERPROC __glewAttachShader; +GLEW_FUN_EXPORT PFNGLBINDATTRIBLOCATIONPROC __glewBindAttribLocation; +GLEW_FUN_EXPORT PFNGLBLENDEQUATIONSEPARATEPROC __glewBlendEquationSeparate; +GLEW_FUN_EXPORT PFNGLCOMPILESHADERPROC __glewCompileShader; +GLEW_FUN_EXPORT PFNGLCREATEPROGRAMPROC __glewCreateProgram; +GLEW_FUN_EXPORT PFNGLCREATESHADERPROC __glewCreateShader; +GLEW_FUN_EXPORT PFNGLDELETEPROGRAMPROC __glewDeleteProgram; +GLEW_FUN_EXPORT PFNGLDELETESHADERPROC __glewDeleteShader; +GLEW_FUN_EXPORT PFNGLDETACHSHADERPROC __glewDetachShader; +GLEW_FUN_EXPORT PFNGLDISABLEVERTEXATTRIBARRAYPROC __glewDisableVertexAttribArray; +GLEW_FUN_EXPORT PFNGLDRAWBUFFERSPROC __glewDrawBuffers; +GLEW_FUN_EXPORT PFNGLENABLEVERTEXATTRIBARRAYPROC __glewEnableVertexAttribArray; +GLEW_FUN_EXPORT PFNGLGETACTIVEATTRIBPROC __glewGetActiveAttrib; +GLEW_FUN_EXPORT PFNGLGETACTIVEUNIFORMPROC __glewGetActiveUniform; +GLEW_FUN_EXPORT PFNGLGETATTACHEDSHADERSPROC __glewGetAttachedShaders; +GLEW_FUN_EXPORT PFNGLGETATTRIBLOCATIONPROC __glewGetAttribLocation; +GLEW_FUN_EXPORT PFNGLGETPROGRAMINFOLOGPROC __glewGetProgramInfoLog; +GLEW_FUN_EXPORT PFNGLGETPROGRAMIVPROC __glewGetProgramiv; +GLEW_FUN_EXPORT PFNGLGETSHADERINFOLOGPROC __glewGetShaderInfoLog; +GLEW_FUN_EXPORT PFNGLGETSHADERSOURCEPROC __glewGetShaderSource; +GLEW_FUN_EXPORT PFNGLGETSHADERIVPROC __glewGetShaderiv; +GLEW_FUN_EXPORT PFNGLGETUNIFORMLOCATIONPROC __glewGetUniformLocation; +GLEW_FUN_EXPORT PFNGLGETUNIFORMFVPROC __glewGetUniformfv; +GLEW_FUN_EXPORT PFNGLGETUNIFORMIVPROC __glewGetUniformiv; +GLEW_FUN_EXPORT PFNGLGETVERTEXATTRIBPOINTERVPROC __glewGetVertexAttribPointerv; +GLEW_FUN_EXPORT PFNGLGETVERTEXATTRIBDVPROC __glewGetVertexAttribdv; +GLEW_FUN_EXPORT PFNGLGETVERTEXATTRIBFVPROC __glewGetVertexAttribfv; +GLEW_FUN_EXPORT PFNGLGETVERTEXATTRIBIVPROC __glewGetVertexAttribiv; +GLEW_FUN_EXPORT PFNGLISPROGRAMPROC __glewIsProgram; +GLEW_FUN_EXPORT PFNGLISSHADERPROC __glewIsShader; +GLEW_FUN_EXPORT PFNGLLINKPROGRAMPROC __glewLinkProgram; +GLEW_FUN_EXPORT PFNGLSHADERSOURCEPROC __glewShaderSource; +GLEW_FUN_EXPORT PFNGLSTENCILFUNCSEPARATEPROC __glewStencilFuncSeparate; +GLEW_FUN_EXPORT PFNGLSTENCILMASKSEPARATEPROC __glewStencilMaskSeparate; +GLEW_FUN_EXPORT PFNGLSTENCILOPSEPARATEPROC __glewStencilOpSeparate; +GLEW_FUN_EXPORT PFNGLUNIFORM1FPROC __glewUniform1f; +GLEW_FUN_EXPORT PFNGLUNIFORM1FVPROC __glewUniform1fv; +GLEW_FUN_EXPORT PFNGLUNIFORM1IPROC __glewUniform1i; +GLEW_FUN_EXPORT PFNGLUNIFORM1IVPROC __glewUniform1iv; +GLEW_FUN_EXPORT PFNGLUNIFORM2FPROC __glewUniform2f; +GLEW_FUN_EXPORT PFNGLUNIFORM2FVPROC __glewUniform2fv; +GLEW_FUN_EXPORT PFNGLUNIFORM2IPROC __glewUniform2i; +GLEW_FUN_EXPORT PFNGLUNIFORM2IVPROC __glewUniform2iv; +GLEW_FUN_EXPORT PFNGLUNIFORM3FPROC __glewUniform3f; +GLEW_FUN_EXPORT PFNGLUNIFORM3FVPROC __glewUniform3fv; +GLEW_FUN_EXPORT PFNGLUNIFORM3IPROC __glewUniform3i; +GLEW_FUN_EXPORT PFNGLUNIFORM3IVPROC __glewUniform3iv; +GLEW_FUN_EXPORT PFNGLUNIFORM4FPROC __glewUniform4f; +GLEW_FUN_EXPORT PFNGLUNIFORM4FVPROC __glewUniform4fv; +GLEW_FUN_EXPORT PFNGLUNIFORM4IPROC __glewUniform4i; +GLEW_FUN_EXPORT PFNGLUNIFORM4IVPROC __glewUniform4iv; +GLEW_FUN_EXPORT PFNGLUNIFORMMATRIX2FVPROC __glewUniformMatrix2fv; +GLEW_FUN_EXPORT PFNGLUNIFORMMATRIX3FVPROC __glewUniformMatrix3fv; +GLEW_FUN_EXPORT PFNGLUNIFORMMATRIX4FVPROC __glewUniformMatrix4fv; +GLEW_FUN_EXPORT PFNGLUSEPROGRAMPROC __glewUseProgram; +GLEW_FUN_EXPORT PFNGLVALIDATEPROGRAMPROC __glewValidateProgram; +GLEW_FUN_EXPORT PFNGLVERTEXATTRIB1DPROC __glewVertexAttrib1d; +GLEW_FUN_EXPORT PFNGLVERTEXATTRIB1DVPROC __glewVertexAttrib1dv; +GLEW_FUN_EXPORT PFNGLVERTEXATTRIB1FPROC __glewVertexAttrib1f; +GLEW_FUN_EXPORT PFNGLVERTEXATTRIB1FVPROC __glewVertexAttrib1fv; +GLEW_FUN_EXPORT PFNGLVERTEXATTRIB1SPROC __glewVertexAttrib1s; +GLEW_FUN_EXPORT PFNGLVERTEXATTRIB1SVPROC __glewVertexAttrib1sv; +GLEW_FUN_EXPORT PFNGLVERTEXATTRIB2DPROC __glewVertexAttrib2d; +GLEW_FUN_EXPORT PFNGLVERTEXATTRIB2DVPROC __glewVertexAttrib2dv; +GLEW_FUN_EXPORT PFNGLVERTEXATTRIB2FPROC __glewVertexAttrib2f; +GLEW_FUN_EXPORT PFNGLVERTEXATTRIB2FVPROC __glewVertexAttrib2fv; +GLEW_FUN_EXPORT PFNGLVERTEXATTRIB2SPROC __glewVertexAttrib2s; +GLEW_FUN_EXPORT PFNGLVERTEXATTRIB2SVPROC __glewVertexAttrib2sv; +GLEW_FUN_EXPORT PFNGLVERTEXATTRIB3DPROC __glewVertexAttrib3d; +GLEW_FUN_EXPORT PFNGLVERTEXATTRIB3DVPROC __glewVertexAttrib3dv; +GLEW_FUN_EXPORT PFNGLVERTEXATTRIB3FPROC __glewVertexAttrib3f; +GLEW_FUN_EXPORT PFNGLVERTEXATTRIB3FVPROC __glewVertexAttrib3fv; +GLEW_FUN_EXPORT PFNGLVERTEXATTRIB3SPROC __glewVertexAttrib3s; +GLEW_FUN_EXPORT PFNGLVERTEXATTRIB3SVPROC __glewVertexAttrib3sv; +GLEW_FUN_EXPORT PFNGLVERTEXATTRIB4NBVPROC __glewVertexAttrib4Nbv; +GLEW_FUN_EXPORT PFNGLVERTEXATTRIB4NIVPROC __glewVertexAttrib4Niv; +GLEW_FUN_EXPORT PFNGLVERTEXATTRIB4NSVPROC __glewVertexAttrib4Nsv; +GLEW_FUN_EXPORT PFNGLVERTEXATTRIB4NUBPROC __glewVertexAttrib4Nub; +GLEW_FUN_EXPORT PFNGLVERTEXATTRIB4NUBVPROC __glewVertexAttrib4Nubv; +GLEW_FUN_EXPORT PFNGLVERTEXATTRIB4NUIVPROC __glewVertexAttrib4Nuiv; +GLEW_FUN_EXPORT PFNGLVERTEXATTRIB4NUSVPROC __glewVertexAttrib4Nusv; +GLEW_FUN_EXPORT PFNGLVERTEXATTRIB4BVPROC __glewVertexAttrib4bv; +GLEW_FUN_EXPORT PFNGLVERTEXATTRIB4DPROC __glewVertexAttrib4d; +GLEW_FUN_EXPORT PFNGLVERTEXATTRIB4DVPROC __glewVertexAttrib4dv; +GLEW_FUN_EXPORT PFNGLVERTEXATTRIB4FPROC __glewVertexAttrib4f; +GLEW_FUN_EXPORT PFNGLVERTEXATTRIB4FVPROC __glewVertexAttrib4fv; +GLEW_FUN_EXPORT PFNGLVERTEXATTRIB4IVPROC __glewVertexAttrib4iv; +GLEW_FUN_EXPORT PFNGLVERTEXATTRIB4SPROC __glewVertexAttrib4s; +GLEW_FUN_EXPORT PFNGLVERTEXATTRIB4SVPROC __glewVertexAttrib4sv; +GLEW_FUN_EXPORT PFNGLVERTEXATTRIB4UBVPROC __glewVertexAttrib4ubv; +GLEW_FUN_EXPORT PFNGLVERTEXATTRIB4UIVPROC __glewVertexAttrib4uiv; +GLEW_FUN_EXPORT PFNGLVERTEXATTRIB4USVPROC __glewVertexAttrib4usv; +GLEW_FUN_EXPORT PFNGLVERTEXATTRIBPOINTERPROC __glewVertexAttribPointer; + +GLEW_FUN_EXPORT PFNGLUNIFORMMATRIX2X3FVPROC __glewUniformMatrix2x3fv; +GLEW_FUN_EXPORT PFNGLUNIFORMMATRIX2X4FVPROC __glewUniformMatrix2x4fv; +GLEW_FUN_EXPORT PFNGLUNIFORMMATRIX3X2FVPROC __glewUniformMatrix3x2fv; +GLEW_FUN_EXPORT PFNGLUNIFORMMATRIX3X4FVPROC __glewUniformMatrix3x4fv; +GLEW_FUN_EXPORT PFNGLUNIFORMMATRIX4X2FVPROC __glewUniformMatrix4x2fv; +GLEW_FUN_EXPORT PFNGLUNIFORMMATRIX4X3FVPROC __glewUniformMatrix4x3fv; + +GLEW_FUN_EXPORT PFNGLBEGINCONDITIONALRENDERPROC __glewBeginConditionalRender; +GLEW_FUN_EXPORT PFNGLBEGINTRANSFORMFEEDBACKPROC __glewBeginTransformFeedback; +GLEW_FUN_EXPORT PFNGLBINDBUFFERBASEPROC __glewBindBufferBase; +GLEW_FUN_EXPORT PFNGLBINDBUFFERRANGEPROC __glewBindBufferRange; +GLEW_FUN_EXPORT PFNGLBINDFRAGDATALOCATIONPROC __glewBindFragDataLocation; +GLEW_FUN_EXPORT PFNGLCLAMPCOLORPROC __glewClampColor; +GLEW_FUN_EXPORT PFNGLCLEARBUFFERFIPROC __glewClearBufferfi; +GLEW_FUN_EXPORT PFNGLCLEARBUFFERFVPROC __glewClearBufferfv; +GLEW_FUN_EXPORT PFNGLCLEARBUFFERIVPROC __glewClearBufferiv; +GLEW_FUN_EXPORT PFNGLCLEARBUFFERUIVPROC __glewClearBufferuiv; +GLEW_FUN_EXPORT PFNGLCOLORMASKIPROC __glewColorMaski; +GLEW_FUN_EXPORT PFNGLDISABLEIPROC __glewDisablei; +GLEW_FUN_EXPORT PFNGLENABLEIPROC __glewEnablei; +GLEW_FUN_EXPORT PFNGLENDCONDITIONALRENDERPROC __glewEndConditionalRender; +GLEW_FUN_EXPORT PFNGLENDTRANSFORMFEEDBACKPROC __glewEndTransformFeedback; +GLEW_FUN_EXPORT PFNGLGETBOOLEANI_VPROC __glewGetBooleani_v; +GLEW_FUN_EXPORT PFNGLGETFRAGDATALOCATIONPROC __glewGetFragDataLocation; +GLEW_FUN_EXPORT PFNGLGETINTEGERI_VPROC __glewGetIntegeri_v; +GLEW_FUN_EXPORT PFNGLGETSTRINGIPROC __glewGetStringi; +GLEW_FUN_EXPORT PFNGLGETTEXPARAMETERIIVPROC __glewGetTexParameterIiv; +GLEW_FUN_EXPORT PFNGLGETTEXPARAMETERIUIVPROC __glewGetTexParameterIuiv; +GLEW_FUN_EXPORT PFNGLGETTRANSFORMFEEDBACKVARYINGPROC __glewGetTransformFeedbackVarying; +GLEW_FUN_EXPORT PFNGLGETUNIFORMUIVPROC __glewGetUniformuiv; +GLEW_FUN_EXPORT PFNGLGETVERTEXATTRIBIIVPROC __glewGetVertexAttribIiv; +GLEW_FUN_EXPORT PFNGLGETVERTEXATTRIBIUIVPROC __glewGetVertexAttribIuiv; +GLEW_FUN_EXPORT PFNGLISENABLEDIPROC __glewIsEnabledi; +GLEW_FUN_EXPORT PFNGLTEXPARAMETERIIVPROC __glewTexParameterIiv; +GLEW_FUN_EXPORT PFNGLTEXPARAMETERIUIVPROC __glewTexParameterIuiv; +GLEW_FUN_EXPORT PFNGLTRANSFORMFEEDBACKVARYINGSPROC __glewTransformFeedbackVaryings; +GLEW_FUN_EXPORT PFNGLUNIFORM1UIPROC __glewUniform1ui; +GLEW_FUN_EXPORT PFNGLUNIFORM1UIVPROC __glewUniform1uiv; +GLEW_FUN_EXPORT PFNGLUNIFORM2UIPROC __glewUniform2ui; +GLEW_FUN_EXPORT PFNGLUNIFORM2UIVPROC __glewUniform2uiv; +GLEW_FUN_EXPORT PFNGLUNIFORM3UIPROC __glewUniform3ui; +GLEW_FUN_EXPORT PFNGLUNIFORM3UIVPROC __glewUniform3uiv; +GLEW_FUN_EXPORT PFNGLUNIFORM4UIPROC __glewUniform4ui; +GLEW_FUN_EXPORT PFNGLUNIFORM4UIVPROC __glewUniform4uiv; +GLEW_FUN_EXPORT PFNGLVERTEXATTRIBI1IPROC __glewVertexAttribI1i; +GLEW_FUN_EXPORT PFNGLVERTEXATTRIBI1IVPROC __glewVertexAttribI1iv; +GLEW_FUN_EXPORT PFNGLVERTEXATTRIBI1UIPROC __glewVertexAttribI1ui; +GLEW_FUN_EXPORT PFNGLVERTEXATTRIBI1UIVPROC __glewVertexAttribI1uiv; +GLEW_FUN_EXPORT PFNGLVERTEXATTRIBI2IPROC __glewVertexAttribI2i; +GLEW_FUN_EXPORT PFNGLVERTEXATTRIBI2IVPROC __glewVertexAttribI2iv; +GLEW_FUN_EXPORT PFNGLVERTEXATTRIBI2UIPROC __glewVertexAttribI2ui; +GLEW_FUN_EXPORT PFNGLVERTEXATTRIBI2UIVPROC __glewVertexAttribI2uiv; +GLEW_FUN_EXPORT PFNGLVERTEXATTRIBI3IPROC __glewVertexAttribI3i; +GLEW_FUN_EXPORT PFNGLVERTEXATTRIBI3IVPROC __glewVertexAttribI3iv; +GLEW_FUN_EXPORT PFNGLVERTEXATTRIBI3UIPROC __glewVertexAttribI3ui; +GLEW_FUN_EXPORT PFNGLVERTEXATTRIBI3UIVPROC __glewVertexAttribI3uiv; +GLEW_FUN_EXPORT PFNGLVERTEXATTRIBI4BVPROC __glewVertexAttribI4bv; +GLEW_FUN_EXPORT PFNGLVERTEXATTRIBI4IPROC __glewVertexAttribI4i; +GLEW_FUN_EXPORT PFNGLVERTEXATTRIBI4IVPROC __glewVertexAttribI4iv; +GLEW_FUN_EXPORT PFNGLVERTEXATTRIBI4SVPROC __glewVertexAttribI4sv; +GLEW_FUN_EXPORT PFNGLVERTEXATTRIBI4UBVPROC __glewVertexAttribI4ubv; +GLEW_FUN_EXPORT PFNGLVERTEXATTRIBI4UIPROC __glewVertexAttribI4ui; +GLEW_FUN_EXPORT PFNGLVERTEXATTRIBI4UIVPROC __glewVertexAttribI4uiv; +GLEW_FUN_EXPORT PFNGLVERTEXATTRIBI4USVPROC __glewVertexAttribI4usv; +GLEW_FUN_EXPORT PFNGLVERTEXATTRIBIPOINTERPROC __glewVertexAttribIPointer; + +GLEW_FUN_EXPORT PFNGLTBUFFERMASK3DFXPROC __glewTbufferMask3DFX; + +GLEW_FUN_EXPORT PFNGLDRAWELEMENTARRAYAPPLEPROC __glewDrawElementArrayAPPLE; +GLEW_FUN_EXPORT PFNGLDRAWRANGEELEMENTARRAYAPPLEPROC __glewDrawRangeElementArrayAPPLE; +GLEW_FUN_EXPORT PFNGLELEMENTPOINTERAPPLEPROC __glewElementPointerAPPLE; +GLEW_FUN_EXPORT PFNGLMULTIDRAWELEMENTARRAYAPPLEPROC __glewMultiDrawElementArrayAPPLE; +GLEW_FUN_EXPORT PFNGLMULTIDRAWRANGEELEMENTARRAYAPPLEPROC __glewMultiDrawRangeElementArrayAPPLE; + +GLEW_FUN_EXPORT PFNGLDELETEFENCESAPPLEPROC __glewDeleteFencesAPPLE; +GLEW_FUN_EXPORT PFNGLFINISHFENCEAPPLEPROC __glewFinishFenceAPPLE; +GLEW_FUN_EXPORT PFNGLFINISHOBJECTAPPLEPROC __glewFinishObjectAPPLE; +GLEW_FUN_EXPORT PFNGLGENFENCESAPPLEPROC __glewGenFencesAPPLE; +GLEW_FUN_EXPORT PFNGLISFENCEAPPLEPROC __glewIsFenceAPPLE; +GLEW_FUN_EXPORT PFNGLSETFENCEAPPLEPROC __glewSetFenceAPPLE; +GLEW_FUN_EXPORT PFNGLTESTFENCEAPPLEPROC __glewTestFenceAPPLE; +GLEW_FUN_EXPORT PFNGLTESTOBJECTAPPLEPROC __glewTestObjectAPPLE; + +GLEW_FUN_EXPORT PFNGLBUFFERPARAMETERIAPPLEPROC __glewBufferParameteriAPPLE; +GLEW_FUN_EXPORT PFNGLFLUSHMAPPEDBUFFERRANGEAPPLEPROC __glewFlushMappedBufferRangeAPPLE; + +GLEW_FUN_EXPORT PFNGLGETTEXPARAMETERPOINTERVAPPLEPROC __glewGetTexParameterPointervAPPLE; +GLEW_FUN_EXPORT PFNGLTEXTURERANGEAPPLEPROC __glewTextureRangeAPPLE; + +GLEW_FUN_EXPORT PFNGLBINDVERTEXARRAYAPPLEPROC __glewBindVertexArrayAPPLE; +GLEW_FUN_EXPORT PFNGLDELETEVERTEXARRAYSAPPLEPROC __glewDeleteVertexArraysAPPLE; +GLEW_FUN_EXPORT PFNGLGENVERTEXARRAYSAPPLEPROC __glewGenVertexArraysAPPLE; +GLEW_FUN_EXPORT PFNGLISVERTEXARRAYAPPLEPROC __glewIsVertexArrayAPPLE; + +GLEW_FUN_EXPORT PFNGLFLUSHVERTEXARRAYRANGEAPPLEPROC __glewFlushVertexArrayRangeAPPLE; +GLEW_FUN_EXPORT PFNGLVERTEXARRAYPARAMETERIAPPLEPROC __glewVertexArrayParameteriAPPLE; +GLEW_FUN_EXPORT PFNGLVERTEXARRAYRANGEAPPLEPROC __glewVertexArrayRangeAPPLE; + +GLEW_FUN_EXPORT PFNGLCLAMPCOLORARBPROC __glewClampColorARB; + +GLEW_FUN_EXPORT PFNGLDRAWBUFFERSARBPROC __glewDrawBuffersARB; + +GLEW_FUN_EXPORT PFNGLDRAWARRAYSINSTANCEDARBPROC __glewDrawArraysInstancedARB; +GLEW_FUN_EXPORT PFNGLDRAWELEMENTSINSTANCEDARBPROC __glewDrawElementsInstancedARB; + +GLEW_FUN_EXPORT PFNGLBINDFRAMEBUFFERPROC __glewBindFramebuffer; +GLEW_FUN_EXPORT PFNGLBINDRENDERBUFFERPROC __glewBindRenderbuffer; +GLEW_FUN_EXPORT PFNGLBLITFRAMEBUFFERPROC __glewBlitFramebuffer; +GLEW_FUN_EXPORT PFNGLCHECKFRAMEBUFFERSTATUSPROC __glewCheckFramebufferStatus; +GLEW_FUN_EXPORT PFNGLDELETEFRAMEBUFFERSPROC __glewDeleteFramebuffers; +GLEW_FUN_EXPORT PFNGLDELETERENDERBUFFERSPROC __glewDeleteRenderbuffers; +GLEW_FUN_EXPORT PFNGLFRAMEBUFFERRENDERBUFFERPROC __glewFramebufferRenderbuffer; +GLEW_FUN_EXPORT PFNGLFRAMEBUFFERTEXTURLAYERPROC __glewFramebufferTexturLayer; +GLEW_FUN_EXPORT PFNGLFRAMEBUFFERTEXTURE1DPROC __glewFramebufferTexture1D; +GLEW_FUN_EXPORT PFNGLFRAMEBUFFERTEXTURE2DPROC __glewFramebufferTexture2D; +GLEW_FUN_EXPORT PFNGLFRAMEBUFFERTEXTURE3DPROC __glewFramebufferTexture3D; +GLEW_FUN_EXPORT PFNGLGENFRAMEBUFFERSPROC __glewGenFramebuffers; +GLEW_FUN_EXPORT PFNGLGENRENDERBUFFERSPROC __glewGenRenderbuffers; +GLEW_FUN_EXPORT PFNGLGENERATEMIPMAPPROC __glewGenerateMipmap; +GLEW_FUN_EXPORT PFNGLGETFRAMEBUFFERATTACHMENTPARAMETERIVPROC __glewGetFramebufferAttachmentParameteriv; +GLEW_FUN_EXPORT PFNGLGETRENDERBUFFERPARAMETERIVPROC __glewGetRenderbufferParameteriv; +GLEW_FUN_EXPORT PFNGLISFRAMEBUFFERPROC __glewIsFramebuffer; +GLEW_FUN_EXPORT PFNGLISRENDERBUFFERPROC __glewIsRenderbuffer; +GLEW_FUN_EXPORT PFNGLRENDERBUFFERSTORAGEPROC __glewRenderbufferStorage; +GLEW_FUN_EXPORT PFNGLRENDERBUFFERSTORAGEMULTISAMPLEPROC __glewRenderbufferStorageMultisample; + +GLEW_FUN_EXPORT PFNGLFRAMEBUFFERTEXTUREARBPROC __glewFramebufferTextureARB; +GLEW_FUN_EXPORT PFNGLFRAMEBUFFERTEXTUREFACEARBPROC __glewFramebufferTextureFaceARB; +GLEW_FUN_EXPORT PFNGLFRAMEBUFFERTEXTURELAYERARBPROC __glewFramebufferTextureLayerARB; +GLEW_FUN_EXPORT PFNGLPROGRAMPARAMETERIARBPROC __glewProgramParameteriARB; + +GLEW_FUN_EXPORT PFNGLCOLORSUBTABLEPROC __glewColorSubTable; +GLEW_FUN_EXPORT PFNGLCOLORTABLEPROC __glewColorTable; +GLEW_FUN_EXPORT PFNGLCOLORTABLEPARAMETERFVPROC __glewColorTableParameterfv; +GLEW_FUN_EXPORT PFNGLCOLORTABLEPARAMETERIVPROC __glewColorTableParameteriv; +GLEW_FUN_EXPORT PFNGLCONVOLUTIONFILTER1DPROC __glewConvolutionFilter1D; +GLEW_FUN_EXPORT PFNGLCONVOLUTIONFILTER2DPROC __glewConvolutionFilter2D; +GLEW_FUN_EXPORT PFNGLCONVOLUTIONPARAMETERFPROC __glewConvolutionParameterf; +GLEW_FUN_EXPORT PFNGLCONVOLUTIONPARAMETERFVPROC __glewConvolutionParameterfv; +GLEW_FUN_EXPORT PFNGLCONVOLUTIONPARAMETERIPROC __glewConvolutionParameteri; +GLEW_FUN_EXPORT PFNGLCONVOLUTIONPARAMETERIVPROC __glewConvolutionParameteriv; +GLEW_FUN_EXPORT PFNGLCOPYCOLORSUBTABLEPROC __glewCopyColorSubTable; +GLEW_FUN_EXPORT PFNGLCOPYCOLORTABLEPROC __glewCopyColorTable; +GLEW_FUN_EXPORT PFNGLCOPYCONVOLUTIONFILTER1DPROC __glewCopyConvolutionFilter1D; +GLEW_FUN_EXPORT PFNGLCOPYCONVOLUTIONFILTER2DPROC __glewCopyConvolutionFilter2D; +GLEW_FUN_EXPORT PFNGLGETCOLORTABLEPROC __glewGetColorTable; +GLEW_FUN_EXPORT PFNGLGETCOLORTABLEPARAMETERFVPROC __glewGetColorTableParameterfv; +GLEW_FUN_EXPORT PFNGLGETCOLORTABLEPARAMETERIVPROC __glewGetColorTableParameteriv; +GLEW_FUN_EXPORT PFNGLGETCONVOLUTIONFILTERPROC __glewGetConvolutionFilter; +GLEW_FUN_EXPORT PFNGLGETCONVOLUTIONPARAMETERFVPROC __glewGetConvolutionParameterfv; +GLEW_FUN_EXPORT PFNGLGETCONVOLUTIONPARAMETERIVPROC __glewGetConvolutionParameteriv; +GLEW_FUN_EXPORT PFNGLGETHISTOGRAMPROC __glewGetHistogram; +GLEW_FUN_EXPORT PFNGLGETHISTOGRAMPARAMETERFVPROC __glewGetHistogramParameterfv; +GLEW_FUN_EXPORT PFNGLGETHISTOGRAMPARAMETERIVPROC __glewGetHistogramParameteriv; +GLEW_FUN_EXPORT PFNGLGETMINMAXPROC __glewGetMinmax; +GLEW_FUN_EXPORT PFNGLGETMINMAXPARAMETERFVPROC __glewGetMinmaxParameterfv; +GLEW_FUN_EXPORT PFNGLGETMINMAXPARAMETERIVPROC __glewGetMinmaxParameteriv; +GLEW_FUN_EXPORT PFNGLGETSEPARABLEFILTERPROC __glewGetSeparableFilter; +GLEW_FUN_EXPORT PFNGLHISTOGRAMPROC __glewHistogram; +GLEW_FUN_EXPORT PFNGLMINMAXPROC __glewMinmax; +GLEW_FUN_EXPORT PFNGLRESETHISTOGRAMPROC __glewResetHistogram; +GLEW_FUN_EXPORT PFNGLRESETMINMAXPROC __glewResetMinmax; +GLEW_FUN_EXPORT PFNGLSEPARABLEFILTER2DPROC __glewSeparableFilter2D; + +GLEW_FUN_EXPORT PFNGLVERTEXATTRIBDIVISORARBPROC __glewVertexAttribDivisorARB; + +GLEW_FUN_EXPORT PFNGLFLUSHMAPPEDBUFFERRANGEPROC __glewFlushMappedBufferRange; +GLEW_FUN_EXPORT PFNGLMAPBUFFERRANGEPROC __glewMapBufferRange; + +GLEW_FUN_EXPORT PFNGLCURRENTPALETTEMATRIXARBPROC __glewCurrentPaletteMatrixARB; +GLEW_FUN_EXPORT PFNGLMATRIXINDEXPOINTERARBPROC __glewMatrixIndexPointerARB; +GLEW_FUN_EXPORT PFNGLMATRIXINDEXUBVARBPROC __glewMatrixIndexubvARB; +GLEW_FUN_EXPORT PFNGLMATRIXINDEXUIVARBPROC __glewMatrixIndexuivARB; +GLEW_FUN_EXPORT PFNGLMATRIXINDEXUSVARBPROC __glewMatrixIndexusvARB; + +GLEW_FUN_EXPORT PFNGLSAMPLECOVERAGEARBPROC __glewSampleCoverageARB; + +GLEW_FUN_EXPORT PFNGLACTIVETEXTUREARBPROC __glewActiveTextureARB; +GLEW_FUN_EXPORT PFNGLCLIENTACTIVETEXTUREARBPROC __glewClientActiveTextureARB; +GLEW_FUN_EXPORT PFNGLMULTITEXCOORD1DARBPROC __glewMultiTexCoord1dARB; +GLEW_FUN_EXPORT PFNGLMULTITEXCOORD1DVARBPROC __glewMultiTexCoord1dvARB; +GLEW_FUN_EXPORT PFNGLMULTITEXCOORD1FARBPROC __glewMultiTexCoord1fARB; +GLEW_FUN_EXPORT PFNGLMULTITEXCOORD1FVARBPROC __glewMultiTexCoord1fvARB; +GLEW_FUN_EXPORT PFNGLMULTITEXCOORD1IARBPROC __glewMultiTexCoord1iARB; +GLEW_FUN_EXPORT PFNGLMULTITEXCOORD1IVARBPROC __glewMultiTexCoord1ivARB; +GLEW_FUN_EXPORT PFNGLMULTITEXCOORD1SARBPROC __glewMultiTexCoord1sARB; +GLEW_FUN_EXPORT PFNGLMULTITEXCOORD1SVARBPROC __glewMultiTexCoord1svARB; +GLEW_FUN_EXPORT PFNGLMULTITEXCOORD2DARBPROC __glewMultiTexCoord2dARB; +GLEW_FUN_EXPORT PFNGLMULTITEXCOORD2DVARBPROC __glewMultiTexCoord2dvARB; +GLEW_FUN_EXPORT PFNGLMULTITEXCOORD2FARBPROC __glewMultiTexCoord2fARB; +GLEW_FUN_EXPORT PFNGLMULTITEXCOORD2FVARBPROC __glewMultiTexCoord2fvARB; +GLEW_FUN_EXPORT PFNGLMULTITEXCOORD2IARBPROC __glewMultiTexCoord2iARB; +GLEW_FUN_EXPORT PFNGLMULTITEXCOORD2IVARBPROC __glewMultiTexCoord2ivARB; +GLEW_FUN_EXPORT PFNGLMULTITEXCOORD2SARBPROC __glewMultiTexCoord2sARB; +GLEW_FUN_EXPORT PFNGLMULTITEXCOORD2SVARBPROC __glewMultiTexCoord2svARB; +GLEW_FUN_EXPORT PFNGLMULTITEXCOORD3DARBPROC __glewMultiTexCoord3dARB; +GLEW_FUN_EXPORT PFNGLMULTITEXCOORD3DVARBPROC __glewMultiTexCoord3dvARB; +GLEW_FUN_EXPORT PFNGLMULTITEXCOORD3FARBPROC __glewMultiTexCoord3fARB; +GLEW_FUN_EXPORT PFNGLMULTITEXCOORD3FVARBPROC __glewMultiTexCoord3fvARB; +GLEW_FUN_EXPORT PFNGLMULTITEXCOORD3IARBPROC __glewMultiTexCoord3iARB; +GLEW_FUN_EXPORT PFNGLMULTITEXCOORD3IVARBPROC __glewMultiTexCoord3ivARB; +GLEW_FUN_EXPORT PFNGLMULTITEXCOORD3SARBPROC __glewMultiTexCoord3sARB; +GLEW_FUN_EXPORT PFNGLMULTITEXCOORD3SVARBPROC __glewMultiTexCoord3svARB; +GLEW_FUN_EXPORT PFNGLMULTITEXCOORD4DARBPROC __glewMultiTexCoord4dARB; +GLEW_FUN_EXPORT PFNGLMULTITEXCOORD4DVARBPROC __glewMultiTexCoord4dvARB; +GLEW_FUN_EXPORT PFNGLMULTITEXCOORD4FARBPROC __glewMultiTexCoord4fARB; +GLEW_FUN_EXPORT PFNGLMULTITEXCOORD4FVARBPROC __glewMultiTexCoord4fvARB; +GLEW_FUN_EXPORT PFNGLMULTITEXCOORD4IARBPROC __glewMultiTexCoord4iARB; +GLEW_FUN_EXPORT PFNGLMULTITEXCOORD4IVARBPROC __glewMultiTexCoord4ivARB; +GLEW_FUN_EXPORT PFNGLMULTITEXCOORD4SARBPROC __glewMultiTexCoord4sARB; +GLEW_FUN_EXPORT PFNGLMULTITEXCOORD4SVARBPROC __glewMultiTexCoord4svARB; + +GLEW_FUN_EXPORT PFNGLBEGINQUERYARBPROC __glewBeginQueryARB; +GLEW_FUN_EXPORT PFNGLDELETEQUERIESARBPROC __glewDeleteQueriesARB; +GLEW_FUN_EXPORT PFNGLENDQUERYARBPROC __glewEndQueryARB; +GLEW_FUN_EXPORT PFNGLGENQUERIESARBPROC __glewGenQueriesARB; +GLEW_FUN_EXPORT PFNGLGETQUERYOBJECTIVARBPROC __glewGetQueryObjectivARB; +GLEW_FUN_EXPORT PFNGLGETQUERYOBJECTUIVARBPROC __glewGetQueryObjectuivARB; +GLEW_FUN_EXPORT PFNGLGETQUERYIVARBPROC __glewGetQueryivARB; +GLEW_FUN_EXPORT PFNGLISQUERYARBPROC __glewIsQueryARB; + +GLEW_FUN_EXPORT PFNGLPOINTPARAMETERFARBPROC __glewPointParameterfARB; +GLEW_FUN_EXPORT PFNGLPOINTPARAMETERFVARBPROC __glewPointParameterfvARB; + +GLEW_FUN_EXPORT PFNGLATTACHOBJECTARBPROC __glewAttachObjectARB; +GLEW_FUN_EXPORT PFNGLCOMPILESHADERARBPROC __glewCompileShaderARB; +GLEW_FUN_EXPORT PFNGLCREATEPROGRAMOBJECTARBPROC __glewCreateProgramObjectARB; +GLEW_FUN_EXPORT PFNGLCREATESHADEROBJECTARBPROC __glewCreateShaderObjectARB; +GLEW_FUN_EXPORT PFNGLDELETEOBJECTARBPROC __glewDeleteObjectARB; +GLEW_FUN_EXPORT PFNGLDETACHOBJECTARBPROC __glewDetachObjectARB; +GLEW_FUN_EXPORT PFNGLGETACTIVEUNIFORMARBPROC __glewGetActiveUniformARB; +GLEW_FUN_EXPORT PFNGLGETATTACHEDOBJECTSARBPROC __glewGetAttachedObjectsARB; +GLEW_FUN_EXPORT PFNGLGETHANDLEARBPROC __glewGetHandleARB; +GLEW_FUN_EXPORT PFNGLGETINFOLOGARBPROC __glewGetInfoLogARB; +GLEW_FUN_EXPORT PFNGLGETOBJECTPARAMETERFVARBPROC __glewGetObjectParameterfvARB; +GLEW_FUN_EXPORT PFNGLGETOBJECTPARAMETERIVARBPROC __glewGetObjectParameterivARB; +GLEW_FUN_EXPORT PFNGLGETSHADERSOURCEARBPROC __glewGetShaderSourceARB; +GLEW_FUN_EXPORT PFNGLGETUNIFORMLOCATIONARBPROC __glewGetUniformLocationARB; +GLEW_FUN_EXPORT PFNGLGETUNIFORMFVARBPROC __glewGetUniformfvARB; +GLEW_FUN_EXPORT PFNGLGETUNIFORMIVARBPROC __glewGetUniformivARB; +GLEW_FUN_EXPORT PFNGLLINKPROGRAMARBPROC __glewLinkProgramARB; +GLEW_FUN_EXPORT PFNGLSHADERSOURCEARBPROC __glewShaderSourceARB; +GLEW_FUN_EXPORT PFNGLUNIFORM1FARBPROC __glewUniform1fARB; +GLEW_FUN_EXPORT PFNGLUNIFORM1FVARBPROC __glewUniform1fvARB; +GLEW_FUN_EXPORT PFNGLUNIFORM1IARBPROC __glewUniform1iARB; +GLEW_FUN_EXPORT PFNGLUNIFORM1IVARBPROC __glewUniform1ivARB; +GLEW_FUN_EXPORT PFNGLUNIFORM2FARBPROC __glewUniform2fARB; +GLEW_FUN_EXPORT PFNGLUNIFORM2FVARBPROC __glewUniform2fvARB; +GLEW_FUN_EXPORT PFNGLUNIFORM2IARBPROC __glewUniform2iARB; +GLEW_FUN_EXPORT PFNGLUNIFORM2IVARBPROC __glewUniform2ivARB; +GLEW_FUN_EXPORT PFNGLUNIFORM3FARBPROC __glewUniform3fARB; +GLEW_FUN_EXPORT PFNGLUNIFORM3FVARBPROC __glewUniform3fvARB; +GLEW_FUN_EXPORT PFNGLUNIFORM3IARBPROC __glewUniform3iARB; +GLEW_FUN_EXPORT PFNGLUNIFORM3IVARBPROC __glewUniform3ivARB; +GLEW_FUN_EXPORT PFNGLUNIFORM4FARBPROC __glewUniform4fARB; +GLEW_FUN_EXPORT PFNGLUNIFORM4FVARBPROC __glewUniform4fvARB; +GLEW_FUN_EXPORT PFNGLUNIFORM4IARBPROC __glewUniform4iARB; +GLEW_FUN_EXPORT PFNGLUNIFORM4IVARBPROC __glewUniform4ivARB; +GLEW_FUN_EXPORT PFNGLUNIFORMMATRIX2FVARBPROC __glewUniformMatrix2fvARB; +GLEW_FUN_EXPORT PFNGLUNIFORMMATRIX3FVARBPROC __glewUniformMatrix3fvARB; +GLEW_FUN_EXPORT PFNGLUNIFORMMATRIX4FVARBPROC __glewUniformMatrix4fvARB; +GLEW_FUN_EXPORT PFNGLUSEPROGRAMOBJECTARBPROC __glewUseProgramObjectARB; +GLEW_FUN_EXPORT PFNGLVALIDATEPROGRAMARBPROC __glewValidateProgramARB; + +GLEW_FUN_EXPORT PFNGLTEXBUFFERARBPROC __glewTexBufferARB; + +GLEW_FUN_EXPORT PFNGLCOMPRESSEDTEXIMAGE1DARBPROC __glewCompressedTexImage1DARB; +GLEW_FUN_EXPORT PFNGLCOMPRESSEDTEXIMAGE2DARBPROC __glewCompressedTexImage2DARB; +GLEW_FUN_EXPORT PFNGLCOMPRESSEDTEXIMAGE3DARBPROC __glewCompressedTexImage3DARB; +GLEW_FUN_EXPORT PFNGLCOMPRESSEDTEXSUBIMAGE1DARBPROC __glewCompressedTexSubImage1DARB; +GLEW_FUN_EXPORT PFNGLCOMPRESSEDTEXSUBIMAGE2DARBPROC __glewCompressedTexSubImage2DARB; +GLEW_FUN_EXPORT PFNGLCOMPRESSEDTEXSUBIMAGE3DARBPROC __glewCompressedTexSubImage3DARB; +GLEW_FUN_EXPORT PFNGLGETCOMPRESSEDTEXIMAGEARBPROC __glewGetCompressedTexImageARB; + +GLEW_FUN_EXPORT PFNGLLOADTRANSPOSEMATRIXDARBPROC __glewLoadTransposeMatrixdARB; +GLEW_FUN_EXPORT PFNGLLOADTRANSPOSEMATRIXFARBPROC __glewLoadTransposeMatrixfARB; +GLEW_FUN_EXPORT PFNGLMULTTRANSPOSEMATRIXDARBPROC __glewMultTransposeMatrixdARB; +GLEW_FUN_EXPORT PFNGLMULTTRANSPOSEMATRIXFARBPROC __glewMultTransposeMatrixfARB; + +GLEW_FUN_EXPORT PFNGLBINDVERTEXARRAYPROC __glewBindVertexArray; +GLEW_FUN_EXPORT PFNGLDELETEVERTEXARRAYSPROC __glewDeleteVertexArrays; +GLEW_FUN_EXPORT PFNGLGENVERTEXARRAYSPROC __glewGenVertexArrays; +GLEW_FUN_EXPORT PFNGLISVERTEXARRAYPROC __glewIsVertexArray; + +GLEW_FUN_EXPORT PFNGLVERTEXBLENDARBPROC __glewVertexBlendARB; +GLEW_FUN_EXPORT PFNGLWEIGHTPOINTERARBPROC __glewWeightPointerARB; +GLEW_FUN_EXPORT PFNGLWEIGHTBVARBPROC __glewWeightbvARB; +GLEW_FUN_EXPORT PFNGLWEIGHTDVARBPROC __glewWeightdvARB; +GLEW_FUN_EXPORT PFNGLWEIGHTFVARBPROC __glewWeightfvARB; +GLEW_FUN_EXPORT PFNGLWEIGHTIVARBPROC __glewWeightivARB; +GLEW_FUN_EXPORT PFNGLWEIGHTSVARBPROC __glewWeightsvARB; +GLEW_FUN_EXPORT PFNGLWEIGHTUBVARBPROC __glewWeightubvARB; +GLEW_FUN_EXPORT PFNGLWEIGHTUIVARBPROC __glewWeightuivARB; +GLEW_FUN_EXPORT PFNGLWEIGHTUSVARBPROC __glewWeightusvARB; + +GLEW_FUN_EXPORT PFNGLBINDBUFFERARBPROC __glewBindBufferARB; +GLEW_FUN_EXPORT PFNGLBUFFERDATAARBPROC __glewBufferDataARB; +GLEW_FUN_EXPORT PFNGLBUFFERSUBDATAARBPROC __glewBufferSubDataARB; +GLEW_FUN_EXPORT PFNGLDELETEBUFFERSARBPROC __glewDeleteBuffersARB; +GLEW_FUN_EXPORT PFNGLGENBUFFERSARBPROC __glewGenBuffersARB; +GLEW_FUN_EXPORT PFNGLGETBUFFERPARAMETERIVARBPROC __glewGetBufferParameterivARB; +GLEW_FUN_EXPORT PFNGLGETBUFFERPOINTERVARBPROC __glewGetBufferPointervARB; +GLEW_FUN_EXPORT PFNGLGETBUFFERSUBDATAARBPROC __glewGetBufferSubDataARB; +GLEW_FUN_EXPORT PFNGLISBUFFERARBPROC __glewIsBufferARB; +GLEW_FUN_EXPORT PFNGLMAPBUFFERARBPROC __glewMapBufferARB; +GLEW_FUN_EXPORT PFNGLUNMAPBUFFERARBPROC __glewUnmapBufferARB; + +GLEW_FUN_EXPORT PFNGLBINDPROGRAMARBPROC __glewBindProgramARB; +GLEW_FUN_EXPORT PFNGLDELETEPROGRAMSARBPROC __glewDeleteProgramsARB; +GLEW_FUN_EXPORT PFNGLDISABLEVERTEXATTRIBARRAYARBPROC __glewDisableVertexAttribArrayARB; +GLEW_FUN_EXPORT PFNGLENABLEVERTEXATTRIBARRAYARBPROC __glewEnableVertexAttribArrayARB; +GLEW_FUN_EXPORT PFNGLGENPROGRAMSARBPROC __glewGenProgramsARB; +GLEW_FUN_EXPORT PFNGLGETPROGRAMENVPARAMETERDVARBPROC __glewGetProgramEnvParameterdvARB; +GLEW_FUN_EXPORT PFNGLGETPROGRAMENVPARAMETERFVARBPROC __glewGetProgramEnvParameterfvARB; +GLEW_FUN_EXPORT PFNGLGETPROGRAMLOCALPARAMETERDVARBPROC __glewGetProgramLocalParameterdvARB; +GLEW_FUN_EXPORT PFNGLGETPROGRAMLOCALPARAMETERFVARBPROC __glewGetProgramLocalParameterfvARB; +GLEW_FUN_EXPORT PFNGLGETPROGRAMSTRINGARBPROC __glewGetProgramStringARB; +GLEW_FUN_EXPORT PFNGLGETPROGRAMIVARBPROC __glewGetProgramivARB; +GLEW_FUN_EXPORT PFNGLGETVERTEXATTRIBPOINTERVARBPROC __glewGetVertexAttribPointervARB; +GLEW_FUN_EXPORT PFNGLGETVERTEXATTRIBDVARBPROC __glewGetVertexAttribdvARB; +GLEW_FUN_EXPORT PFNGLGETVERTEXATTRIBFVARBPROC __glewGetVertexAttribfvARB; +GLEW_FUN_EXPORT PFNGLGETVERTEXATTRIBIVARBPROC __glewGetVertexAttribivARB; +GLEW_FUN_EXPORT PFNGLISPROGRAMARBPROC __glewIsProgramARB; +GLEW_FUN_EXPORT PFNGLPROGRAMENVPARAMETER4DARBPROC __glewProgramEnvParameter4dARB; +GLEW_FUN_EXPORT PFNGLPROGRAMENVPARAMETER4DVARBPROC __glewProgramEnvParameter4dvARB; +GLEW_FUN_EXPORT PFNGLPROGRAMENVPARAMETER4FARBPROC __glewProgramEnvParameter4fARB; +GLEW_FUN_EXPORT PFNGLPROGRAMENVPARAMETER4FVARBPROC __glewProgramEnvParameter4fvARB; +GLEW_FUN_EXPORT PFNGLPROGRAMLOCALPARAMETER4DARBPROC __glewProgramLocalParameter4dARB; +GLEW_FUN_EXPORT PFNGLPROGRAMLOCALPARAMETER4DVARBPROC __glewProgramLocalParameter4dvARB; +GLEW_FUN_EXPORT PFNGLPROGRAMLOCALPARAMETER4FARBPROC __glewProgramLocalParameter4fARB; +GLEW_FUN_EXPORT PFNGLPROGRAMLOCALPARAMETER4FVARBPROC __glewProgramLocalParameter4fvARB; +GLEW_FUN_EXPORT PFNGLPROGRAMSTRINGARBPROC __glewProgramStringARB; +GLEW_FUN_EXPORT PFNGLVERTEXATTRIB1DARBPROC __glewVertexAttrib1dARB; +GLEW_FUN_EXPORT PFNGLVERTEXATTRIB1DVARBPROC __glewVertexAttrib1dvARB; +GLEW_FUN_EXPORT PFNGLVERTEXATTRIB1FARBPROC __glewVertexAttrib1fARB; +GLEW_FUN_EXPORT PFNGLVERTEXATTRIB1FVARBPROC __glewVertexAttrib1fvARB; +GLEW_FUN_EXPORT PFNGLVERTEXATTRIB1SARBPROC __glewVertexAttrib1sARB; +GLEW_FUN_EXPORT PFNGLVERTEXATTRIB1SVARBPROC __glewVertexAttrib1svARB; +GLEW_FUN_EXPORT PFNGLVERTEXATTRIB2DARBPROC __glewVertexAttrib2dARB; +GLEW_FUN_EXPORT PFNGLVERTEXATTRIB2DVARBPROC __glewVertexAttrib2dvARB; +GLEW_FUN_EXPORT PFNGLVERTEXATTRIB2FARBPROC __glewVertexAttrib2fARB; +GLEW_FUN_EXPORT PFNGLVERTEXATTRIB2FVARBPROC __glewVertexAttrib2fvARB; +GLEW_FUN_EXPORT PFNGLVERTEXATTRIB2SARBPROC __glewVertexAttrib2sARB; +GLEW_FUN_EXPORT PFNGLVERTEXATTRIB2SVARBPROC __glewVertexAttrib2svARB; +GLEW_FUN_EXPORT PFNGLVERTEXATTRIB3DARBPROC __glewVertexAttrib3dARB; +GLEW_FUN_EXPORT PFNGLVERTEXATTRIB3DVARBPROC __glewVertexAttrib3dvARB; +GLEW_FUN_EXPORT PFNGLVERTEXATTRIB3FARBPROC __glewVertexAttrib3fARB; +GLEW_FUN_EXPORT PFNGLVERTEXATTRIB3FVARBPROC __glewVertexAttrib3fvARB; +GLEW_FUN_EXPORT PFNGLVERTEXATTRIB3SARBPROC __glewVertexAttrib3sARB; +GLEW_FUN_EXPORT PFNGLVERTEXATTRIB3SVARBPROC __glewVertexAttrib3svARB; +GLEW_FUN_EXPORT PFNGLVERTEXATTRIB4NBVARBPROC __glewVertexAttrib4NbvARB; +GLEW_FUN_EXPORT PFNGLVERTEXATTRIB4NIVARBPROC __glewVertexAttrib4NivARB; +GLEW_FUN_EXPORT PFNGLVERTEXATTRIB4NSVARBPROC __glewVertexAttrib4NsvARB; +GLEW_FUN_EXPORT PFNGLVERTEXATTRIB4NUBARBPROC __glewVertexAttrib4NubARB; +GLEW_FUN_EXPORT PFNGLVERTEXATTRIB4NUBVARBPROC __glewVertexAttrib4NubvARB; +GLEW_FUN_EXPORT PFNGLVERTEXATTRIB4NUIVARBPROC __glewVertexAttrib4NuivARB; +GLEW_FUN_EXPORT PFNGLVERTEXATTRIB4NUSVARBPROC __glewVertexAttrib4NusvARB; +GLEW_FUN_EXPORT PFNGLVERTEXATTRIB4BVARBPROC __glewVertexAttrib4bvARB; +GLEW_FUN_EXPORT PFNGLVERTEXATTRIB4DARBPROC __glewVertexAttrib4dARB; +GLEW_FUN_EXPORT PFNGLVERTEXATTRIB4DVARBPROC __glewVertexAttrib4dvARB; +GLEW_FUN_EXPORT PFNGLVERTEXATTRIB4FARBPROC __glewVertexAttrib4fARB; +GLEW_FUN_EXPORT PFNGLVERTEXATTRIB4FVARBPROC __glewVertexAttrib4fvARB; +GLEW_FUN_EXPORT PFNGLVERTEXATTRIB4IVARBPROC __glewVertexAttrib4ivARB; +GLEW_FUN_EXPORT PFNGLVERTEXATTRIB4SARBPROC __glewVertexAttrib4sARB; +GLEW_FUN_EXPORT PFNGLVERTEXATTRIB4SVARBPROC __glewVertexAttrib4svARB; +GLEW_FUN_EXPORT PFNGLVERTEXATTRIB4UBVARBPROC __glewVertexAttrib4ubvARB; +GLEW_FUN_EXPORT PFNGLVERTEXATTRIB4UIVARBPROC __glewVertexAttrib4uivARB; +GLEW_FUN_EXPORT PFNGLVERTEXATTRIB4USVARBPROC __glewVertexAttrib4usvARB; +GLEW_FUN_EXPORT PFNGLVERTEXATTRIBPOINTERARBPROC __glewVertexAttribPointerARB; + +GLEW_FUN_EXPORT PFNGLBINDATTRIBLOCATIONARBPROC __glewBindAttribLocationARB; +GLEW_FUN_EXPORT PFNGLGETACTIVEATTRIBARBPROC __glewGetActiveAttribARB; +GLEW_FUN_EXPORT PFNGLGETATTRIBLOCATIONARBPROC __glewGetAttribLocationARB; + +GLEW_FUN_EXPORT PFNGLWINDOWPOS2DARBPROC __glewWindowPos2dARB; +GLEW_FUN_EXPORT PFNGLWINDOWPOS2DVARBPROC __glewWindowPos2dvARB; +GLEW_FUN_EXPORT PFNGLWINDOWPOS2FARBPROC __glewWindowPos2fARB; +GLEW_FUN_EXPORT PFNGLWINDOWPOS2FVARBPROC __glewWindowPos2fvARB; +GLEW_FUN_EXPORT PFNGLWINDOWPOS2IARBPROC __glewWindowPos2iARB; +GLEW_FUN_EXPORT PFNGLWINDOWPOS2IVARBPROC __glewWindowPos2ivARB; +GLEW_FUN_EXPORT PFNGLWINDOWPOS2SARBPROC __glewWindowPos2sARB; +GLEW_FUN_EXPORT PFNGLWINDOWPOS2SVARBPROC __glewWindowPos2svARB; +GLEW_FUN_EXPORT PFNGLWINDOWPOS3DARBPROC __glewWindowPos3dARB; +GLEW_FUN_EXPORT PFNGLWINDOWPOS3DVARBPROC __glewWindowPos3dvARB; +GLEW_FUN_EXPORT PFNGLWINDOWPOS3FARBPROC __glewWindowPos3fARB; +GLEW_FUN_EXPORT PFNGLWINDOWPOS3FVARBPROC __glewWindowPos3fvARB; +GLEW_FUN_EXPORT PFNGLWINDOWPOS3IARBPROC __glewWindowPos3iARB; +GLEW_FUN_EXPORT PFNGLWINDOWPOS3IVARBPROC __glewWindowPos3ivARB; +GLEW_FUN_EXPORT PFNGLWINDOWPOS3SARBPROC __glewWindowPos3sARB; +GLEW_FUN_EXPORT PFNGLWINDOWPOS3SVARBPROC __glewWindowPos3svARB; + +GLEW_FUN_EXPORT PFNGLDRAWBUFFERSATIPROC __glewDrawBuffersATI; + +GLEW_FUN_EXPORT PFNGLDRAWELEMENTARRAYATIPROC __glewDrawElementArrayATI; +GLEW_FUN_EXPORT PFNGLDRAWRANGEELEMENTARRAYATIPROC __glewDrawRangeElementArrayATI; +GLEW_FUN_EXPORT PFNGLELEMENTPOINTERATIPROC __glewElementPointerATI; + +GLEW_FUN_EXPORT PFNGLGETTEXBUMPPARAMETERFVATIPROC __glewGetTexBumpParameterfvATI; +GLEW_FUN_EXPORT PFNGLGETTEXBUMPPARAMETERIVATIPROC __glewGetTexBumpParameterivATI; +GLEW_FUN_EXPORT PFNGLTEXBUMPPARAMETERFVATIPROC __glewTexBumpParameterfvATI; +GLEW_FUN_EXPORT PFNGLTEXBUMPPARAMETERIVATIPROC __glewTexBumpParameterivATI; + +GLEW_FUN_EXPORT PFNGLALPHAFRAGMENTOP1ATIPROC __glewAlphaFragmentOp1ATI; +GLEW_FUN_EXPORT PFNGLALPHAFRAGMENTOP2ATIPROC __glewAlphaFragmentOp2ATI; +GLEW_FUN_EXPORT PFNGLALPHAFRAGMENTOP3ATIPROC __glewAlphaFragmentOp3ATI; +GLEW_FUN_EXPORT PFNGLBEGINFRAGMENTSHADERATIPROC __glewBeginFragmentShaderATI; +GLEW_FUN_EXPORT PFNGLBINDFRAGMENTSHADERATIPROC __glewBindFragmentShaderATI; +GLEW_FUN_EXPORT PFNGLCOLORFRAGMENTOP1ATIPROC __glewColorFragmentOp1ATI; +GLEW_FUN_EXPORT PFNGLCOLORFRAGMENTOP2ATIPROC __glewColorFragmentOp2ATI; +GLEW_FUN_EXPORT PFNGLCOLORFRAGMENTOP3ATIPROC __glewColorFragmentOp3ATI; +GLEW_FUN_EXPORT PFNGLDELETEFRAGMENTSHADERATIPROC __glewDeleteFragmentShaderATI; +GLEW_FUN_EXPORT PFNGLENDFRAGMENTSHADERATIPROC __glewEndFragmentShaderATI; +GLEW_FUN_EXPORT PFNGLGENFRAGMENTSHADERSATIPROC __glewGenFragmentShadersATI; +GLEW_FUN_EXPORT PFNGLPASSTEXCOORDATIPROC __glewPassTexCoordATI; +GLEW_FUN_EXPORT PFNGLSAMPLEMAPATIPROC __glewSampleMapATI; +GLEW_FUN_EXPORT PFNGLSETFRAGMENTSHADERCONSTANTATIPROC __glewSetFragmentShaderConstantATI; + +GLEW_FUN_EXPORT PFNGLMAPOBJECTBUFFERATIPROC __glewMapObjectBufferATI; +GLEW_FUN_EXPORT PFNGLUNMAPOBJECTBUFFERATIPROC __glewUnmapObjectBufferATI; + +GLEW_FUN_EXPORT PFNGLPNTRIANGLESFATIPROC __glPNTrianglewesfATI; +GLEW_FUN_EXPORT PFNGLPNTRIANGLESIATIPROC __glPNTrianglewesiATI; + +GLEW_FUN_EXPORT PFNGLSTENCILFUNCSEPARATEATIPROC __glewStencilFuncSeparateATI; +GLEW_FUN_EXPORT PFNGLSTENCILOPSEPARATEATIPROC __glewStencilOpSeparateATI; + +GLEW_FUN_EXPORT PFNGLARRAYOBJECTATIPROC __glewArrayObjectATI; +GLEW_FUN_EXPORT PFNGLFREEOBJECTBUFFERATIPROC __glewFreeObjectBufferATI; +GLEW_FUN_EXPORT PFNGLGETARRAYOBJECTFVATIPROC __glewGetArrayObjectfvATI; +GLEW_FUN_EXPORT PFNGLGETARRAYOBJECTIVATIPROC __glewGetArrayObjectivATI; +GLEW_FUN_EXPORT PFNGLGETOBJECTBUFFERFVATIPROC __glewGetObjectBufferfvATI; +GLEW_FUN_EXPORT PFNGLGETOBJECTBUFFERIVATIPROC __glewGetObjectBufferivATI; +GLEW_FUN_EXPORT PFNGLGETVARIANTARRAYOBJECTFVATIPROC __glewGetVariantArrayObjectfvATI; +GLEW_FUN_EXPORT PFNGLGETVARIANTARRAYOBJECTIVATIPROC __glewGetVariantArrayObjectivATI; +GLEW_FUN_EXPORT PFNGLISOBJECTBUFFERATIPROC __glewIsObjectBufferATI; +GLEW_FUN_EXPORT PFNGLNEWOBJECTBUFFERATIPROC __glewNewObjectBufferATI; +GLEW_FUN_EXPORT PFNGLUPDATEOBJECTBUFFERATIPROC __glewUpdateObjectBufferATI; +GLEW_FUN_EXPORT PFNGLVARIANTARRAYOBJECTATIPROC __glewVariantArrayObjectATI; + +GLEW_FUN_EXPORT PFNGLGETVERTEXATTRIBARRAYOBJECTFVATIPROC __glewGetVertexAttribArrayObjectfvATI; +GLEW_FUN_EXPORT PFNGLGETVERTEXATTRIBARRAYOBJECTIVATIPROC __glewGetVertexAttribArrayObjectivATI; +GLEW_FUN_EXPORT PFNGLVERTEXATTRIBARRAYOBJECTATIPROC __glewVertexAttribArrayObjectATI; + +GLEW_FUN_EXPORT PFNGLCLIENTACTIVEVERTEXSTREAMATIPROC __glewClientActiveVertexStreamATI; +GLEW_FUN_EXPORT PFNGLNORMALSTREAM3BATIPROC __glewNormalStream3bATI; +GLEW_FUN_EXPORT PFNGLNORMALSTREAM3BVATIPROC __glewNormalStream3bvATI; +GLEW_FUN_EXPORT PFNGLNORMALSTREAM3DATIPROC __glewNormalStream3dATI; +GLEW_FUN_EXPORT PFNGLNORMALSTREAM3DVATIPROC __glewNormalStream3dvATI; +GLEW_FUN_EXPORT PFNGLNORMALSTREAM3FATIPROC __glewNormalStream3fATI; +GLEW_FUN_EXPORT PFNGLNORMALSTREAM3FVATIPROC __glewNormalStream3fvATI; +GLEW_FUN_EXPORT PFNGLNORMALSTREAM3IATIPROC __glewNormalStream3iATI; +GLEW_FUN_EXPORT PFNGLNORMALSTREAM3IVATIPROC __glewNormalStream3ivATI; +GLEW_FUN_EXPORT PFNGLNORMALSTREAM3SATIPROC __glewNormalStream3sATI; +GLEW_FUN_EXPORT PFNGLNORMALSTREAM3SVATIPROC __glewNormalStream3svATI; +GLEW_FUN_EXPORT PFNGLVERTEXBLENDENVFATIPROC __glewVertexBlendEnvfATI; +GLEW_FUN_EXPORT PFNGLVERTEXBLENDENVIATIPROC __glewVertexBlendEnviATI; +GLEW_FUN_EXPORT PFNGLVERTEXSTREAM2DATIPROC __glewVertexStream2dATI; +GLEW_FUN_EXPORT PFNGLVERTEXSTREAM2DVATIPROC __glewVertexStream2dvATI; +GLEW_FUN_EXPORT PFNGLVERTEXSTREAM2FATIPROC __glewVertexStream2fATI; +GLEW_FUN_EXPORT PFNGLVERTEXSTREAM2FVATIPROC __glewVertexStream2fvATI; +GLEW_FUN_EXPORT PFNGLVERTEXSTREAM2IATIPROC __glewVertexStream2iATI; +GLEW_FUN_EXPORT PFNGLVERTEXSTREAM2IVATIPROC __glewVertexStream2ivATI; +GLEW_FUN_EXPORT PFNGLVERTEXSTREAM2SATIPROC __glewVertexStream2sATI; +GLEW_FUN_EXPORT PFNGLVERTEXSTREAM2SVATIPROC __glewVertexStream2svATI; +GLEW_FUN_EXPORT PFNGLVERTEXSTREAM3DATIPROC __glewVertexStream3dATI; +GLEW_FUN_EXPORT PFNGLVERTEXSTREAM3DVATIPROC __glewVertexStream3dvATI; +GLEW_FUN_EXPORT PFNGLVERTEXSTREAM3FATIPROC __glewVertexStream3fATI; +GLEW_FUN_EXPORT PFNGLVERTEXSTREAM3FVATIPROC __glewVertexStream3fvATI; +GLEW_FUN_EXPORT PFNGLVERTEXSTREAM3IATIPROC __glewVertexStream3iATI; +GLEW_FUN_EXPORT PFNGLVERTEXSTREAM3IVATIPROC __glewVertexStream3ivATI; +GLEW_FUN_EXPORT PFNGLVERTEXSTREAM3SATIPROC __glewVertexStream3sATI; +GLEW_FUN_EXPORT PFNGLVERTEXSTREAM3SVATIPROC __glewVertexStream3svATI; +GLEW_FUN_EXPORT PFNGLVERTEXSTREAM4DATIPROC __glewVertexStream4dATI; +GLEW_FUN_EXPORT PFNGLVERTEXSTREAM4DVATIPROC __glewVertexStream4dvATI; +GLEW_FUN_EXPORT PFNGLVERTEXSTREAM4FATIPROC __glewVertexStream4fATI; +GLEW_FUN_EXPORT PFNGLVERTEXSTREAM4FVATIPROC __glewVertexStream4fvATI; +GLEW_FUN_EXPORT PFNGLVERTEXSTREAM4IATIPROC __glewVertexStream4iATI; +GLEW_FUN_EXPORT PFNGLVERTEXSTREAM4IVATIPROC __glewVertexStream4ivATI; +GLEW_FUN_EXPORT PFNGLVERTEXSTREAM4SATIPROC __glewVertexStream4sATI; +GLEW_FUN_EXPORT PFNGLVERTEXSTREAM4SVATIPROC __glewVertexStream4svATI; + +GLEW_FUN_EXPORT PFNGLGETUNIFORMBUFFERSIZEEXTPROC __glewGetUniformBufferSizeEXT; +GLEW_FUN_EXPORT PFNGLGETUNIFORMOFFSETEXTPROC __glewGetUniformOffsetEXT; +GLEW_FUN_EXPORT PFNGLUNIFORMBUFFEREXTPROC __glewUniformBufferEXT; + +GLEW_FUN_EXPORT PFNGLBLENDCOLOREXTPROC __glewBlendColorEXT; + +GLEW_FUN_EXPORT PFNGLBLENDEQUATIONSEPARATEEXTPROC __glewBlendEquationSeparateEXT; + +GLEW_FUN_EXPORT PFNGLBLENDFUNCSEPARATEEXTPROC __glewBlendFuncSeparateEXT; + +GLEW_FUN_EXPORT PFNGLBLENDEQUATIONEXTPROC __glewBlendEquationEXT; + +GLEW_FUN_EXPORT PFNGLCOLORSUBTABLEEXTPROC __glewColorSubTableEXT; +GLEW_FUN_EXPORT PFNGLCOPYCOLORSUBTABLEEXTPROC __glewCopyColorSubTableEXT; + +GLEW_FUN_EXPORT PFNGLLOCKARRAYSEXTPROC __glewLockArraysEXT; +GLEW_FUN_EXPORT PFNGLUNLOCKARRAYSEXTPROC __glewUnlockArraysEXT; + +GLEW_FUN_EXPORT PFNGLCONVOLUTIONFILTER1DEXTPROC __glewConvolutionFilter1DEXT; +GLEW_FUN_EXPORT PFNGLCONVOLUTIONFILTER2DEXTPROC __glewConvolutionFilter2DEXT; +GLEW_FUN_EXPORT PFNGLCONVOLUTIONPARAMETERFEXTPROC __glewConvolutionParameterfEXT; +GLEW_FUN_EXPORT PFNGLCONVOLUTIONPARAMETERFVEXTPROC __glewConvolutionParameterfvEXT; +GLEW_FUN_EXPORT PFNGLCONVOLUTIONPARAMETERIEXTPROC __glewConvolutionParameteriEXT; +GLEW_FUN_EXPORT PFNGLCONVOLUTIONPARAMETERIVEXTPROC __glewConvolutionParameterivEXT; +GLEW_FUN_EXPORT PFNGLCOPYCONVOLUTIONFILTER1DEXTPROC __glewCopyConvolutionFilter1DEXT; +GLEW_FUN_EXPORT PFNGLCOPYCONVOLUTIONFILTER2DEXTPROC __glewCopyConvolutionFilter2DEXT; +GLEW_FUN_EXPORT PFNGLGETCONVOLUTIONFILTEREXTPROC __glewGetConvolutionFilterEXT; +GLEW_FUN_EXPORT PFNGLGETCONVOLUTIONPARAMETERFVEXTPROC __glewGetConvolutionParameterfvEXT; +GLEW_FUN_EXPORT PFNGLGETCONVOLUTIONPARAMETERIVEXTPROC __glewGetConvolutionParameterivEXT; +GLEW_FUN_EXPORT PFNGLGETSEPARABLEFILTEREXTPROC __glewGetSeparableFilterEXT; +GLEW_FUN_EXPORT PFNGLSEPARABLEFILTER2DEXTPROC __glewSeparableFilter2DEXT; + +GLEW_FUN_EXPORT PFNGLBINORMALPOINTEREXTPROC __glewBinormalPointerEXT; +GLEW_FUN_EXPORT PFNGLTANGENTPOINTEREXTPROC __glewTangentPointerEXT; + +GLEW_FUN_EXPORT PFNGLCOPYTEXIMAGE1DEXTPROC __glewCopyTexImage1DEXT; +GLEW_FUN_EXPORT PFNGLCOPYTEXIMAGE2DEXTPROC __glewCopyTexImage2DEXT; +GLEW_FUN_EXPORT PFNGLCOPYTEXSUBIMAGE1DEXTPROC __glewCopyTexSubImage1DEXT; +GLEW_FUN_EXPORT PFNGLCOPYTEXSUBIMAGE2DEXTPROC __glewCopyTexSubImage2DEXT; +GLEW_FUN_EXPORT PFNGLCOPYTEXSUBIMAGE3DEXTPROC __glewCopyTexSubImage3DEXT; + +GLEW_FUN_EXPORT PFNGLCULLPARAMETERDVEXTPROC __glewCullParameterdvEXT; +GLEW_FUN_EXPORT PFNGLCULLPARAMETERFVEXTPROC __glewCullParameterfvEXT; + +GLEW_FUN_EXPORT PFNGLDEPTHBOUNDSEXTPROC __glewDepthBoundsEXT; + +GLEW_FUN_EXPORT PFNGLBINDMULTITEXTUREEXTPROC __glewBindMultiTextureEXT; +GLEW_FUN_EXPORT PFNGLCHECKNAMEDFRAMEBUFFERSTATUSEXTPROC __glewCheckNamedFramebufferStatusEXT; +GLEW_FUN_EXPORT PFNGLCLIENTATTRIBDEFAULTEXTPROC __glewClientAttribDefaultEXT; +GLEW_FUN_EXPORT PFNGLCOMPRESSEDMULTITEXIMAGE1DEXTPROC __glewCompressedMultiTexImage1DEXT; +GLEW_FUN_EXPORT PFNGLCOMPRESSEDMULTITEXIMAGE2DEXTPROC __glewCompressedMultiTexImage2DEXT; +GLEW_FUN_EXPORT PFNGLCOMPRESSEDMULTITEXIMAGE3DEXTPROC __glewCompressedMultiTexImage3DEXT; +GLEW_FUN_EXPORT PFNGLCOMPRESSEDMULTITEXSUBIMAGE1DEXTPROC __glewCompressedMultiTexSubImage1DEXT; +GLEW_FUN_EXPORT PFNGLCOMPRESSEDMULTITEXSUBIMAGE2DEXTPROC __glewCompressedMultiTexSubImage2DEXT; +GLEW_FUN_EXPORT PFNGLCOMPRESSEDMULTITEXSUBIMAGE3DEXTPROC __glewCompressedMultiTexSubImage3DEXT; +GLEW_FUN_EXPORT PFNGLCOMPRESSEDTEXTUREIMAGE1DEXTPROC __glewCompressedTextureImage1DEXT; +GLEW_FUN_EXPORT PFNGLCOMPRESSEDTEXTUREIMAGE2DEXTPROC __glewCompressedTextureImage2DEXT; +GLEW_FUN_EXPORT PFNGLCOMPRESSEDTEXTUREIMAGE3DEXTPROC __glewCompressedTextureImage3DEXT; +GLEW_FUN_EXPORT PFNGLCOMPRESSEDTEXTURESUBIMAGE1DEXTPROC __glewCompressedTextureSubImage1DEXT; +GLEW_FUN_EXPORT PFNGLCOMPRESSEDTEXTURESUBIMAGE2DEXTPROC __glewCompressedTextureSubImage2DEXT; +GLEW_FUN_EXPORT PFNGLCOMPRESSEDTEXTURESUBIMAGE3DEXTPROC __glewCompressedTextureSubImage3DEXT; +GLEW_FUN_EXPORT PFNGLCOPYMULTITEXIMAGE1DEXTPROC __glewCopyMultiTexImage1DEXT; +GLEW_FUN_EXPORT PFNGLCOPYMULTITEXIMAGE2DEXTPROC __glewCopyMultiTexImage2DEXT; +GLEW_FUN_EXPORT PFNGLCOPYMULTITEXSUBIMAGE1DEXTPROC __glewCopyMultiTexSubImage1DEXT; +GLEW_FUN_EXPORT PFNGLCOPYMULTITEXSUBIMAGE2DEXTPROC __glewCopyMultiTexSubImage2DEXT; +GLEW_FUN_EXPORT PFNGLCOPYMULTITEXSUBIMAGE3DEXTPROC __glewCopyMultiTexSubImage3DEXT; +GLEW_FUN_EXPORT PFNGLCOPYTEXTUREIMAGE1DEXTPROC __glewCopyTextureImage1DEXT; +GLEW_FUN_EXPORT PFNGLCOPYTEXTUREIMAGE2DEXTPROC __glewCopyTextureImage2DEXT; +GLEW_FUN_EXPORT PFNGLCOPYTEXTURESUBIMAGE1DEXTPROC __glewCopyTextureSubImage1DEXT; +GLEW_FUN_EXPORT PFNGLCOPYTEXTURESUBIMAGE2DEXTPROC __glewCopyTextureSubImage2DEXT; +GLEW_FUN_EXPORT PFNGLCOPYTEXTURESUBIMAGE3DEXTPROC __glewCopyTextureSubImage3DEXT; +GLEW_FUN_EXPORT PFNGLDISABLECLIENTSTATEINDEXEDEXTPROC __glewDisableClientStateIndexedEXT; +GLEW_FUN_EXPORT PFNGLENABLECLIENTSTATEINDEXEDEXTPROC __glewEnableClientStateIndexedEXT; +GLEW_FUN_EXPORT PFNGLFRAMEBUFFERDRAWBUFFEREXTPROC __glewFramebufferDrawBufferEXT; +GLEW_FUN_EXPORT PFNGLFRAMEBUFFERDRAWBUFFERSEXTPROC __glewFramebufferDrawBuffersEXT; +GLEW_FUN_EXPORT PFNGLFRAMEBUFFERREADBUFFEREXTPROC __glewFramebufferReadBufferEXT; +GLEW_FUN_EXPORT PFNGLGENERATEMULTITEXMIPMAPEXTPROC __glewGenerateMultiTexMipmapEXT; +GLEW_FUN_EXPORT PFNGLGENERATETEXTUREMIPMAPEXTPROC __glewGenerateTextureMipmapEXT; +GLEW_FUN_EXPORT PFNGLGETCOMPRESSEDMULTITEXIMAGEEXTPROC __glewGetCompressedMultiTexImageEXT; +GLEW_FUN_EXPORT PFNGLGETCOMPRESSEDTEXTUREIMAGEEXTPROC __glewGetCompressedTextureImageEXT; +GLEW_FUN_EXPORT PFNGLGETDOUBLEINDEXEDVEXTPROC __glewGetDoubleIndexedvEXT; +GLEW_FUN_EXPORT PFNGLGETFLOATINDEXEDVEXTPROC __glewGetFloatIndexedvEXT; +GLEW_FUN_EXPORT PFNGLGETFRAMEBUFFERPARAMETERIVEXTPROC __glewGetFramebufferParameterivEXT; +GLEW_FUN_EXPORT PFNGLGETMULTITEXENVFVEXTPROC __glewGetMultiTexEnvfvEXT; +GLEW_FUN_EXPORT PFNGLGETMULTITEXENVIVEXTPROC __glewGetMultiTexEnvivEXT; +GLEW_FUN_EXPORT PFNGLGETMULTITEXGENDVEXTPROC __glewGetMultiTexGendvEXT; +GLEW_FUN_EXPORT PFNGLGETMULTITEXGENFVEXTPROC __glewGetMultiTexGenfvEXT; +GLEW_FUN_EXPORT PFNGLGETMULTITEXGENIVEXTPROC __glewGetMultiTexGenivEXT; +GLEW_FUN_EXPORT PFNGLGETMULTITEXIMAGEEXTPROC __glewGetMultiTexImageEXT; +GLEW_FUN_EXPORT PFNGLGETMULTITEXLEVELPARAMETERFVEXTPROC __glewGetMultiTexLevelParameterfvEXT; +GLEW_FUN_EXPORT PFNGLGETMULTITEXLEVELPARAMETERIVEXTPROC __glewGetMultiTexLevelParameterivEXT; +GLEW_FUN_EXPORT PFNGLGETMULTITEXPARAMETERIIVEXTPROC __glewGetMultiTexParameterIivEXT; +GLEW_FUN_EXPORT PFNGLGETMULTITEXPARAMETERIUIVEXTPROC __glewGetMultiTexParameterIuivEXT; +GLEW_FUN_EXPORT PFNGLGETMULTITEXPARAMETERFVEXTPROC __glewGetMultiTexParameterfvEXT; +GLEW_FUN_EXPORT PFNGLGETMULTITEXPARAMETERIVEXTPROC __glewGetMultiTexParameterivEXT; +GLEW_FUN_EXPORT PFNGLGETNAMEDBUFFERPARAMETERIVEXTPROC __glewGetNamedBufferParameterivEXT; +GLEW_FUN_EXPORT PFNGLGETNAMEDBUFFERPOINTERVEXTPROC __glewGetNamedBufferPointervEXT; +GLEW_FUN_EXPORT PFNGLGETNAMEDBUFFERSUBDATAEXTPROC __glewGetNamedBufferSubDataEXT; +GLEW_FUN_EXPORT PFNGLGETNAMEDFRAMEBUFFERATTACHMENTPARAMETERIVEXTPROC __glewGetNamedFramebufferAttachmentParameterivEXT; +GLEW_FUN_EXPORT PFNGLGETNAMEDPROGRAMLOCALPARAMETERIIVEXTPROC __glewGetNamedProgramLocalParameterIivEXT; +GLEW_FUN_EXPORT PFNGLGETNAMEDPROGRAMLOCALPARAMETERIUIVEXTPROC __glewGetNamedProgramLocalParameterIuivEXT; +GLEW_FUN_EXPORT PFNGLGETNAMEDPROGRAMLOCALPARAMETERDVEXTPROC __glewGetNamedProgramLocalParameterdvEXT; +GLEW_FUN_EXPORT PFNGLGETNAMEDPROGRAMLOCALPARAMETERFVEXTPROC __glewGetNamedProgramLocalParameterfvEXT; +GLEW_FUN_EXPORT PFNGLGETNAMEDPROGRAMSTRINGEXTPROC __glewGetNamedProgramStringEXT; +GLEW_FUN_EXPORT PFNGLGETNAMEDPROGRAMIVEXTPROC __glewGetNamedProgramivEXT; +GLEW_FUN_EXPORT PFNGLGETNAMEDRENDERBUFFERPARAMETERIVEXTPROC __glewGetNamedRenderbufferParameterivEXT; +GLEW_FUN_EXPORT PFNGLGETPOINTERINDEXEDVEXTPROC __glewGetPointerIndexedvEXT; +GLEW_FUN_EXPORT PFNGLGETTEXTUREIMAGEEXTPROC __glewGetTextureImageEXT; +GLEW_FUN_EXPORT PFNGLGETTEXTURELEVELPARAMETERFVEXTPROC __glewGetTextureLevelParameterfvEXT; +GLEW_FUN_EXPORT PFNGLGETTEXTURELEVELPARAMETERIVEXTPROC __glewGetTextureLevelParameterivEXT; +GLEW_FUN_EXPORT PFNGLGETTEXTUREPARAMETERIIVEXTPROC __glewGetTextureParameterIivEXT; +GLEW_FUN_EXPORT PFNGLGETTEXTUREPARAMETERIUIVEXTPROC __glewGetTextureParameterIuivEXT; +GLEW_FUN_EXPORT PFNGLGETTEXTUREPARAMETERFVEXTPROC __glewGetTextureParameterfvEXT; +GLEW_FUN_EXPORT PFNGLGETTEXTUREPARAMETERIVEXTPROC __glewGetTextureParameterivEXT; +GLEW_FUN_EXPORT PFNGLMAPNAMEDBUFFEREXTPROC __glewMapNamedBufferEXT; +GLEW_FUN_EXPORT PFNGLMATRIXFRUSTUMEXTPROC __glewMatrixFrustumEXT; +GLEW_FUN_EXPORT PFNGLMATRIXLOADIDENTITYEXTPROC __glewMatrixLoadIdentityEXT; +GLEW_FUN_EXPORT PFNGLMATRIXLOADTRANSPOSEDEXTPROC __glewMatrixLoadTransposedEXT; +GLEW_FUN_EXPORT PFNGLMATRIXLOADTRANSPOSEFEXTPROC __glewMatrixLoadTransposefEXT; +GLEW_FUN_EXPORT PFNGLMATRIXLOADDEXTPROC __glewMatrixLoaddEXT; +GLEW_FUN_EXPORT PFNGLMATRIXLOADFEXTPROC __glewMatrixLoadfEXT; +GLEW_FUN_EXPORT PFNGLMATRIXMULTTRANSPOSEDEXTPROC __glewMatrixMultTransposedEXT; +GLEW_FUN_EXPORT PFNGLMATRIXMULTTRANSPOSEFEXTPROC __glewMatrixMultTransposefEXT; +GLEW_FUN_EXPORT PFNGLMATRIXMULTDEXTPROC __glewMatrixMultdEXT; +GLEW_FUN_EXPORT PFNGLMATRIXMULTFEXTPROC __glewMatrixMultfEXT; +GLEW_FUN_EXPORT PFNGLMATRIXORTHOEXTPROC __glewMatrixOrthoEXT; +GLEW_FUN_EXPORT PFNGLMATRIXPOPEXTPROC __glewMatrixPopEXT; +GLEW_FUN_EXPORT PFNGLMATRIXPUSHEXTPROC __glewMatrixPushEXT; +GLEW_FUN_EXPORT PFNGLMATRIXROTATEDEXTPROC __glewMatrixRotatedEXT; +GLEW_FUN_EXPORT PFNGLMATRIXROTATEFEXTPROC __glewMatrixRotatefEXT; +GLEW_FUN_EXPORT PFNGLMATRIXSCALEDEXTPROC __glewMatrixScaledEXT; +GLEW_FUN_EXPORT PFNGLMATRIXSCALEFEXTPROC __glewMatrixScalefEXT; +GLEW_FUN_EXPORT PFNGLMATRIXTRANSLATEDEXTPROC __glewMatrixTranslatedEXT; +GLEW_FUN_EXPORT PFNGLMATRIXTRANSLATEFEXTPROC __glewMatrixTranslatefEXT; +GLEW_FUN_EXPORT PFNGLMULTITEXBUFFEREXTPROC __glewMultiTexBufferEXT; +GLEW_FUN_EXPORT PFNGLMULTITEXCOORDPOINTEREXTPROC __glewMultiTexCoordPointerEXT; +GLEW_FUN_EXPORT PFNGLMULTITEXENVFEXTPROC __glewMultiTexEnvfEXT; +GLEW_FUN_EXPORT PFNGLMULTITEXENVFVEXTPROC __glewMultiTexEnvfvEXT; +GLEW_FUN_EXPORT PFNGLMULTITEXENVIEXTPROC __glewMultiTexEnviEXT; +GLEW_FUN_EXPORT PFNGLMULTITEXENVIVEXTPROC __glewMultiTexEnvivEXT; +GLEW_FUN_EXPORT PFNGLMULTITEXGENDEXTPROC __glewMultiTexGendEXT; +GLEW_FUN_EXPORT PFNGLMULTITEXGENDVEXTPROC __glewMultiTexGendvEXT; +GLEW_FUN_EXPORT PFNGLMULTITEXGENFEXTPROC __glewMultiTexGenfEXT; +GLEW_FUN_EXPORT PFNGLMULTITEXGENFVEXTPROC __glewMultiTexGenfvEXT; +GLEW_FUN_EXPORT PFNGLMULTITEXGENIEXTPROC __glewMultiTexGeniEXT; +GLEW_FUN_EXPORT PFNGLMULTITEXGENIVEXTPROC __glewMultiTexGenivEXT; +GLEW_FUN_EXPORT PFNGLMULTITEXIMAGE1DEXTPROC __glewMultiTexImage1DEXT; +GLEW_FUN_EXPORT PFNGLMULTITEXIMAGE2DEXTPROC __glewMultiTexImage2DEXT; +GLEW_FUN_EXPORT PFNGLMULTITEXIMAGE3DEXTPROC __glewMultiTexImage3DEXT; +GLEW_FUN_EXPORT PFNGLMULTITEXPARAMETERIIVEXTPROC __glewMultiTexParameterIivEXT; +GLEW_FUN_EXPORT PFNGLMULTITEXPARAMETERIUIVEXTPROC __glewMultiTexParameterIuivEXT; +GLEW_FUN_EXPORT PFNGLMULTITEXPARAMETERFEXTPROC __glewMultiTexParameterfEXT; +GLEW_FUN_EXPORT PFNGLMULTITEXPARAMETERFVEXTPROC __glewMultiTexParameterfvEXT; +GLEW_FUN_EXPORT PFNGLMULTITEXPARAMETERIEXTPROC __glewMultiTexParameteriEXT; +GLEW_FUN_EXPORT PFNGLMULTITEXPARAMETERIVEXTPROC __glewMultiTexParameterivEXT; +GLEW_FUN_EXPORT PFNGLMULTITEXRENDERBUFFEREXTPROC __glewMultiTexRenderbufferEXT; +GLEW_FUN_EXPORT PFNGLMULTITEXSUBIMAGE1DEXTPROC __glewMultiTexSubImage1DEXT; +GLEW_FUN_EXPORT PFNGLMULTITEXSUBIMAGE2DEXTPROC __glewMultiTexSubImage2DEXT; +GLEW_FUN_EXPORT PFNGLMULTITEXSUBIMAGE3DEXTPROC __glewMultiTexSubImage3DEXT; +GLEW_FUN_EXPORT PFNGLNAMEDBUFFERDATAEXTPROC __glewNamedBufferDataEXT; +GLEW_FUN_EXPORT PFNGLNAMEDBUFFERSUBDATAEXTPROC __glewNamedBufferSubDataEXT; +GLEW_FUN_EXPORT PFNGLNAMEDFRAMEBUFFERRENDERBUFFEREXTPROC __glewNamedFramebufferRenderbufferEXT; +GLEW_FUN_EXPORT PFNGLNAMEDFRAMEBUFFERTEXTURE1DEXTPROC __glewNamedFramebufferTexture1DEXT; +GLEW_FUN_EXPORT PFNGLNAMEDFRAMEBUFFERTEXTURE2DEXTPROC __glewNamedFramebufferTexture2DEXT; +GLEW_FUN_EXPORT PFNGLNAMEDFRAMEBUFFERTEXTURE3DEXTPROC __glewNamedFramebufferTexture3DEXT; +GLEW_FUN_EXPORT PFNGLNAMEDFRAMEBUFFERTEXTUREEXTPROC __glewNamedFramebufferTextureEXT; +GLEW_FUN_EXPORT PFNGLNAMEDFRAMEBUFFERTEXTUREFACEEXTPROC __glewNamedFramebufferTextureFaceEXT; +GLEW_FUN_EXPORT PFNGLNAMEDFRAMEBUFFERTEXTURELAYEREXTPROC __glewNamedFramebufferTextureLayerEXT; +GLEW_FUN_EXPORT PFNGLNAMEDPROGRAMLOCALPARAMETER4DEXTPROC __glewNamedProgramLocalParameter4dEXT; +GLEW_FUN_EXPORT PFNGLNAMEDPROGRAMLOCALPARAMETER4DVEXTPROC __glewNamedProgramLocalParameter4dvEXT; +GLEW_FUN_EXPORT PFNGLNAMEDPROGRAMLOCALPARAMETER4FEXTPROC __glewNamedProgramLocalParameter4fEXT; +GLEW_FUN_EXPORT PFNGLNAMEDPROGRAMLOCALPARAMETER4FVEXTPROC __glewNamedProgramLocalParameter4fvEXT; +GLEW_FUN_EXPORT PFNGLNAMEDPROGRAMLOCALPARAMETERI4IEXTPROC __glewNamedProgramLocalParameterI4iEXT; +GLEW_FUN_EXPORT PFNGLNAMEDPROGRAMLOCALPARAMETERI4IVEXTPROC __glewNamedProgramLocalParameterI4ivEXT; +GLEW_FUN_EXPORT PFNGLNAMEDPROGRAMLOCALPARAMETERI4UIEXTPROC __glewNamedProgramLocalParameterI4uiEXT; +GLEW_FUN_EXPORT PFNGLNAMEDPROGRAMLOCALPARAMETERI4UIVEXTPROC __glewNamedProgramLocalParameterI4uivEXT; +GLEW_FUN_EXPORT PFNGLNAMEDPROGRAMLOCALPARAMETERS4FVEXTPROC __glewNamedProgramLocalParameters4fvEXT; +GLEW_FUN_EXPORT PFNGLNAMEDPROGRAMLOCALPARAMETERSI4IVEXTPROC __glewNamedProgramLocalParametersI4ivEXT; +GLEW_FUN_EXPORT PFNGLNAMEDPROGRAMLOCALPARAMETERSI4UIVEXTPROC __glewNamedProgramLocalParametersI4uivEXT; +GLEW_FUN_EXPORT PFNGLNAMEDPROGRAMSTRINGEXTPROC __glewNamedProgramStringEXT; +GLEW_FUN_EXPORT PFNGLNAMEDRENDERBUFFERSTORAGEEXTPROC __glewNamedRenderbufferStorageEXT; +GLEW_FUN_EXPORT PFNGLNAMEDRENDERBUFFERSTORAGEMULTISAMPLECOVERAGEEXTPROC __glewNamedRenderbufferStorageMultisampleCoverageEXT; +GLEW_FUN_EXPORT PFNGLNAMEDRENDERBUFFERSTORAGEMULTISAMPLEEXTPROC __glewNamedRenderbufferStorageMultisampleEXT; +GLEW_FUN_EXPORT PFNGLPROGRAMUNIFORM1FEXTPROC __glewProgramUniform1fEXT; +GLEW_FUN_EXPORT PFNGLPROGRAMUNIFORM1FVEXTPROC __glewProgramUniform1fvEXT; +GLEW_FUN_EXPORT PFNGLPROGRAMUNIFORM1IEXTPROC __glewProgramUniform1iEXT; +GLEW_FUN_EXPORT PFNGLPROGRAMUNIFORM1IVEXTPROC __glewProgramUniform1ivEXT; +GLEW_FUN_EXPORT PFNGLPROGRAMUNIFORM1UIEXTPROC __glewProgramUniform1uiEXT; +GLEW_FUN_EXPORT PFNGLPROGRAMUNIFORM1UIVEXTPROC __glewProgramUniform1uivEXT; +GLEW_FUN_EXPORT PFNGLPROGRAMUNIFORM2FEXTPROC __glewProgramUniform2fEXT; +GLEW_FUN_EXPORT PFNGLPROGRAMUNIFORM2FVEXTPROC __glewProgramUniform2fvEXT; +GLEW_FUN_EXPORT PFNGLPROGRAMUNIFORM2IEXTPROC __glewProgramUniform2iEXT; +GLEW_FUN_EXPORT PFNGLPROGRAMUNIFORM2IVEXTPROC __glewProgramUniform2ivEXT; +GLEW_FUN_EXPORT PFNGLPROGRAMUNIFORM2UIEXTPROC __glewProgramUniform2uiEXT; +GLEW_FUN_EXPORT PFNGLPROGRAMUNIFORM2UIVEXTPROC __glewProgramUniform2uivEXT; +GLEW_FUN_EXPORT PFNGLPROGRAMUNIFORM3FEXTPROC __glewProgramUniform3fEXT; +GLEW_FUN_EXPORT PFNGLPROGRAMUNIFORM3FVEXTPROC __glewProgramUniform3fvEXT; +GLEW_FUN_EXPORT PFNGLPROGRAMUNIFORM3IEXTPROC __glewProgramUniform3iEXT; +GLEW_FUN_EXPORT PFNGLPROGRAMUNIFORM3IVEXTPROC __glewProgramUniform3ivEXT; +GLEW_FUN_EXPORT PFNGLPROGRAMUNIFORM3UIEXTPROC __glewProgramUniform3uiEXT; +GLEW_FUN_EXPORT PFNGLPROGRAMUNIFORM3UIVEXTPROC __glewProgramUniform3uivEXT; +GLEW_FUN_EXPORT PFNGLPROGRAMUNIFORM4FEXTPROC __glewProgramUniform4fEXT; +GLEW_FUN_EXPORT PFNGLPROGRAMUNIFORM4FVEXTPROC __glewProgramUniform4fvEXT; +GLEW_FUN_EXPORT PFNGLPROGRAMUNIFORM4IEXTPROC __glewProgramUniform4iEXT; +GLEW_FUN_EXPORT PFNGLPROGRAMUNIFORM4IVEXTPROC __glewProgramUniform4ivEXT; +GLEW_FUN_EXPORT PFNGLPROGRAMUNIFORM4UIEXTPROC __glewProgramUniform4uiEXT; +GLEW_FUN_EXPORT PFNGLPROGRAMUNIFORM4UIVEXTPROC __glewProgramUniform4uivEXT; +GLEW_FUN_EXPORT PFNGLPROGRAMUNIFORMMATRIX2FVEXTPROC __glewProgramUniformMatrix2fvEXT; +GLEW_FUN_EXPORT PFNGLPROGRAMUNIFORMMATRIX2X3FVEXTPROC __glewProgramUniformMatrix2x3fvEXT; +GLEW_FUN_EXPORT PFNGLPROGRAMUNIFORMMATRIX2X4FVEXTPROC __glewProgramUniformMatrix2x4fvEXT; +GLEW_FUN_EXPORT PFNGLPROGRAMUNIFORMMATRIX3FVEXTPROC __glewProgramUniformMatrix3fvEXT; +GLEW_FUN_EXPORT PFNGLPROGRAMUNIFORMMATRIX3X2FVEXTPROC __glewProgramUniformMatrix3x2fvEXT; +GLEW_FUN_EXPORT PFNGLPROGRAMUNIFORMMATRIX3X4FVEXTPROC __glewProgramUniformMatrix3x4fvEXT; +GLEW_FUN_EXPORT PFNGLPROGRAMUNIFORMMATRIX4FVEXTPROC __glewProgramUniformMatrix4fvEXT; +GLEW_FUN_EXPORT PFNGLPROGRAMUNIFORMMATRIX4X2FVEXTPROC __glewProgramUniformMatrix4x2fvEXT; +GLEW_FUN_EXPORT PFNGLPROGRAMUNIFORMMATRIX4X3FVEXTPROC __glewProgramUniformMatrix4x3fvEXT; +GLEW_FUN_EXPORT PFNGLPUSHCLIENTATTRIBDEFAULTEXTPROC __glewPushClientAttribDefaultEXT; +GLEW_FUN_EXPORT PFNGLTEXTUREBUFFEREXTPROC __glewTextureBufferEXT; +GLEW_FUN_EXPORT PFNGLTEXTUREIMAGE1DEXTPROC __glewTextureImage1DEXT; +GLEW_FUN_EXPORT PFNGLTEXTUREIMAGE2DEXTPROC __glewTextureImage2DEXT; +GLEW_FUN_EXPORT PFNGLTEXTUREIMAGE3DEXTPROC __glewTextureImage3DEXT; +GLEW_FUN_EXPORT PFNGLTEXTUREPARAMETERIIVEXTPROC __glewTextureParameterIivEXT; +GLEW_FUN_EXPORT PFNGLTEXTUREPARAMETERIUIVEXTPROC __glewTextureParameterIuivEXT; +GLEW_FUN_EXPORT PFNGLTEXTUREPARAMETERFEXTPROC __glewTextureParameterfEXT; +GLEW_FUN_EXPORT PFNGLTEXTUREPARAMETERFVEXTPROC __glewTextureParameterfvEXT; +GLEW_FUN_EXPORT PFNGLTEXTUREPARAMETERIEXTPROC __glewTextureParameteriEXT; +GLEW_FUN_EXPORT PFNGLTEXTUREPARAMETERIVEXTPROC __glewTextureParameterivEXT; +GLEW_FUN_EXPORT PFNGLTEXTURERENDERBUFFEREXTPROC __glewTextureRenderbufferEXT; +GLEW_FUN_EXPORT PFNGLTEXTURESUBIMAGE1DEXTPROC __glewTextureSubImage1DEXT; +GLEW_FUN_EXPORT PFNGLTEXTURESUBIMAGE2DEXTPROC __glewTextureSubImage2DEXT; +GLEW_FUN_EXPORT PFNGLTEXTURESUBIMAGE3DEXTPROC __glewTextureSubImage3DEXT; +GLEW_FUN_EXPORT PFNGLUNMAPNAMEDBUFFEREXTPROC __glewUnmapNamedBufferEXT; + +GLEW_FUN_EXPORT PFNGLCOLORMASKINDEXEDEXTPROC __glewColorMaskIndexedEXT; +GLEW_FUN_EXPORT PFNGLDISABLEINDEXEDEXTPROC __glewDisableIndexedEXT; +GLEW_FUN_EXPORT PFNGLENABLEINDEXEDEXTPROC __glewEnableIndexedEXT; +GLEW_FUN_EXPORT PFNGLGETBOOLEANINDEXEDVEXTPROC __glewGetBooleanIndexedvEXT; +GLEW_FUN_EXPORT PFNGLGETINTEGERINDEXEDVEXTPROC __glewGetIntegerIndexedvEXT; +GLEW_FUN_EXPORT PFNGLISENABLEDINDEXEDEXTPROC __glewIsEnabledIndexedEXT; + +GLEW_FUN_EXPORT PFNGLDRAWARRAYSINSTANCEDEXTPROC __glewDrawArraysInstancedEXT; +GLEW_FUN_EXPORT PFNGLDRAWELEMENTSINSTANCEDEXTPROC __glewDrawElementsInstancedEXT; + +GLEW_FUN_EXPORT PFNGLDRAWRANGEELEMENTSEXTPROC __glewDrawRangeElementsEXT; + +GLEW_FUN_EXPORT PFNGLFOGCOORDPOINTEREXTPROC __glewFogCoordPointerEXT; +GLEW_FUN_EXPORT PFNGLFOGCOORDDEXTPROC __glewFogCoorddEXT; +GLEW_FUN_EXPORT PFNGLFOGCOORDDVEXTPROC __glewFogCoorddvEXT; +GLEW_FUN_EXPORT PFNGLFOGCOORDFEXTPROC __glewFogCoordfEXT; +GLEW_FUN_EXPORT PFNGLFOGCOORDFVEXTPROC __glewFogCoordfvEXT; + +GLEW_FUN_EXPORT PFNGLFRAGMENTCOLORMATERIALEXTPROC __glewFragmentColorMaterialEXT; +GLEW_FUN_EXPORT PFNGLFRAGMENTLIGHTMODELFEXTPROC __glewFragmentLightModelfEXT; +GLEW_FUN_EXPORT PFNGLFRAGMENTLIGHTMODELFVEXTPROC __glewFragmentLightModelfvEXT; +GLEW_FUN_EXPORT PFNGLFRAGMENTLIGHTMODELIEXTPROC __glewFragmentLightModeliEXT; +GLEW_FUN_EXPORT PFNGLFRAGMENTLIGHTMODELIVEXTPROC __glewFragmentLightModelivEXT; +GLEW_FUN_EXPORT PFNGLFRAGMENTLIGHTFEXTPROC __glewFragmentLightfEXT; +GLEW_FUN_EXPORT PFNGLFRAGMENTLIGHTFVEXTPROC __glewFragmentLightfvEXT; +GLEW_FUN_EXPORT PFNGLFRAGMENTLIGHTIEXTPROC __glewFragmentLightiEXT; +GLEW_FUN_EXPORT PFNGLFRAGMENTLIGHTIVEXTPROC __glewFragmentLightivEXT; +GLEW_FUN_EXPORT PFNGLFRAGMENTMATERIALFEXTPROC __glewFragmentMaterialfEXT; +GLEW_FUN_EXPORT PFNGLFRAGMENTMATERIALFVEXTPROC __glewFragmentMaterialfvEXT; +GLEW_FUN_EXPORT PFNGLFRAGMENTMATERIALIEXTPROC __glewFragmentMaterialiEXT; +GLEW_FUN_EXPORT PFNGLFRAGMENTMATERIALIVEXTPROC __glewFragmentMaterialivEXT; +GLEW_FUN_EXPORT PFNGLGETFRAGMENTLIGHTFVEXTPROC __glewGetFragmentLightfvEXT; +GLEW_FUN_EXPORT PFNGLGETFRAGMENTLIGHTIVEXTPROC __glewGetFragmentLightivEXT; +GLEW_FUN_EXPORT PFNGLGETFRAGMENTMATERIALFVEXTPROC __glewGetFragmentMaterialfvEXT; +GLEW_FUN_EXPORT PFNGLGETFRAGMENTMATERIALIVEXTPROC __glewGetFragmentMaterialivEXT; +GLEW_FUN_EXPORT PFNGLLIGHTENVIEXTPROC __glewLightEnviEXT; + +GLEW_FUN_EXPORT PFNGLBLITFRAMEBUFFEREXTPROC __glewBlitFramebufferEXT; + +GLEW_FUN_EXPORT PFNGLRENDERBUFFERSTORAGEMULTISAMPLEEXTPROC __glewRenderbufferStorageMultisampleEXT; + +GLEW_FUN_EXPORT PFNGLBINDFRAMEBUFFEREXTPROC __glewBindFramebufferEXT; +GLEW_FUN_EXPORT PFNGLBINDRENDERBUFFEREXTPROC __glewBindRenderbufferEXT; +GLEW_FUN_EXPORT PFNGLCHECKFRAMEBUFFERSTATUSEXTPROC __glewCheckFramebufferStatusEXT; +GLEW_FUN_EXPORT PFNGLDELETEFRAMEBUFFERSEXTPROC __glewDeleteFramebuffersEXT; +GLEW_FUN_EXPORT PFNGLDELETERENDERBUFFERSEXTPROC __glewDeleteRenderbuffersEXT; +GLEW_FUN_EXPORT PFNGLFRAMEBUFFERRENDERBUFFEREXTPROC __glewFramebufferRenderbufferEXT; +GLEW_FUN_EXPORT PFNGLFRAMEBUFFERTEXTURE1DEXTPROC __glewFramebufferTexture1DEXT; +GLEW_FUN_EXPORT PFNGLFRAMEBUFFERTEXTURE2DEXTPROC __glewFramebufferTexture2DEXT; +GLEW_FUN_EXPORT PFNGLFRAMEBUFFERTEXTURE3DEXTPROC __glewFramebufferTexture3DEXT; +GLEW_FUN_EXPORT PFNGLGENFRAMEBUFFERSEXTPROC __glewGenFramebuffersEXT; +GLEW_FUN_EXPORT PFNGLGENRENDERBUFFERSEXTPROC __glewGenRenderbuffersEXT; +GLEW_FUN_EXPORT PFNGLGENERATEMIPMAPEXTPROC __glewGenerateMipmapEXT; +GLEW_FUN_EXPORT PFNGLGETFRAMEBUFFERATTACHMENTPARAMETERIVEXTPROC __glewGetFramebufferAttachmentParameterivEXT; +GLEW_FUN_EXPORT PFNGLGETRENDERBUFFERPARAMETERIVEXTPROC __glewGetRenderbufferParameterivEXT; +GLEW_FUN_EXPORT PFNGLISFRAMEBUFFEREXTPROC __glewIsFramebufferEXT; +GLEW_FUN_EXPORT PFNGLISRENDERBUFFEREXTPROC __glewIsRenderbufferEXT; +GLEW_FUN_EXPORT PFNGLRENDERBUFFERSTORAGEEXTPROC __glewRenderbufferStorageEXT; + +GLEW_FUN_EXPORT PFNGLFRAMEBUFFERTEXTUREEXTPROC __glewFramebufferTextureEXT; +GLEW_FUN_EXPORT PFNGLFRAMEBUFFERTEXTUREFACEEXTPROC __glewFramebufferTextureFaceEXT; +GLEW_FUN_EXPORT PFNGLFRAMEBUFFERTEXTURELAYEREXTPROC __glewFramebufferTextureLayerEXT; +GLEW_FUN_EXPORT PFNGLPROGRAMPARAMETERIEXTPROC __glewProgramParameteriEXT; + +GLEW_FUN_EXPORT PFNGLPROGRAMENVPARAMETERS4FVEXTPROC __glewProgramEnvParameters4fvEXT; +GLEW_FUN_EXPORT PFNGLPROGRAMLOCALPARAMETERS4FVEXTPROC __glewProgramLocalParameters4fvEXT; + +GLEW_FUN_EXPORT PFNGLBINDFRAGDATALOCATIONEXTPROC __glewBindFragDataLocationEXT; +GLEW_FUN_EXPORT PFNGLGETFRAGDATALOCATIONEXTPROC __glewGetFragDataLocationEXT; +GLEW_FUN_EXPORT PFNGLGETUNIFORMUIVEXTPROC __glewGetUniformuivEXT; +GLEW_FUN_EXPORT PFNGLGETVERTEXATTRIBIIVEXTPROC __glewGetVertexAttribIivEXT; +GLEW_FUN_EXPORT PFNGLGETVERTEXATTRIBIUIVEXTPROC __glewGetVertexAttribIuivEXT; +GLEW_FUN_EXPORT PFNGLUNIFORM1UIEXTPROC __glewUniform1uiEXT; +GLEW_FUN_EXPORT PFNGLUNIFORM1UIVEXTPROC __glewUniform1uivEXT; +GLEW_FUN_EXPORT PFNGLUNIFORM2UIEXTPROC __glewUniform2uiEXT; +GLEW_FUN_EXPORT PFNGLUNIFORM2UIVEXTPROC __glewUniform2uivEXT; +GLEW_FUN_EXPORT PFNGLUNIFORM3UIEXTPROC __glewUniform3uiEXT; +GLEW_FUN_EXPORT PFNGLUNIFORM3UIVEXTPROC __glewUniform3uivEXT; +GLEW_FUN_EXPORT PFNGLUNIFORM4UIEXTPROC __glewUniform4uiEXT; +GLEW_FUN_EXPORT PFNGLUNIFORM4UIVEXTPROC __glewUniform4uivEXT; +GLEW_FUN_EXPORT PFNGLVERTEXATTRIBI1IEXTPROC __glewVertexAttribI1iEXT; +GLEW_FUN_EXPORT PFNGLVERTEXATTRIBI1IVEXTPROC __glewVertexAttribI1ivEXT; +GLEW_FUN_EXPORT PFNGLVERTEXATTRIBI1UIEXTPROC __glewVertexAttribI1uiEXT; +GLEW_FUN_EXPORT PFNGLVERTEXATTRIBI1UIVEXTPROC __glewVertexAttribI1uivEXT; +GLEW_FUN_EXPORT PFNGLVERTEXATTRIBI2IEXTPROC __glewVertexAttribI2iEXT; +GLEW_FUN_EXPORT PFNGLVERTEXATTRIBI2IVEXTPROC __glewVertexAttribI2ivEXT; +GLEW_FUN_EXPORT PFNGLVERTEXATTRIBI2UIEXTPROC __glewVertexAttribI2uiEXT; +GLEW_FUN_EXPORT PFNGLVERTEXATTRIBI2UIVEXTPROC __glewVertexAttribI2uivEXT; +GLEW_FUN_EXPORT PFNGLVERTEXATTRIBI3IEXTPROC __glewVertexAttribI3iEXT; +GLEW_FUN_EXPORT PFNGLVERTEXATTRIBI3IVEXTPROC __glewVertexAttribI3ivEXT; +GLEW_FUN_EXPORT PFNGLVERTEXATTRIBI3UIEXTPROC __glewVertexAttribI3uiEXT; +GLEW_FUN_EXPORT PFNGLVERTEXATTRIBI3UIVEXTPROC __glewVertexAttribI3uivEXT; +GLEW_FUN_EXPORT PFNGLVERTEXATTRIBI4BVEXTPROC __glewVertexAttribI4bvEXT; +GLEW_FUN_EXPORT PFNGLVERTEXATTRIBI4IEXTPROC __glewVertexAttribI4iEXT; +GLEW_FUN_EXPORT PFNGLVERTEXATTRIBI4IVEXTPROC __glewVertexAttribI4ivEXT; +GLEW_FUN_EXPORT PFNGLVERTEXATTRIBI4SVEXTPROC __glewVertexAttribI4svEXT; +GLEW_FUN_EXPORT PFNGLVERTEXATTRIBI4UBVEXTPROC __glewVertexAttribI4ubvEXT; +GLEW_FUN_EXPORT PFNGLVERTEXATTRIBI4UIEXTPROC __glewVertexAttribI4uiEXT; +GLEW_FUN_EXPORT PFNGLVERTEXATTRIBI4UIVEXTPROC __glewVertexAttribI4uivEXT; +GLEW_FUN_EXPORT PFNGLVERTEXATTRIBI4USVEXTPROC __glewVertexAttribI4usvEXT; +GLEW_FUN_EXPORT PFNGLVERTEXATTRIBIPOINTEREXTPROC __glewVertexAttribIPointerEXT; + +GLEW_FUN_EXPORT PFNGLGETHISTOGRAMEXTPROC __glewGetHistogramEXT; +GLEW_FUN_EXPORT PFNGLGETHISTOGRAMPARAMETERFVEXTPROC __glewGetHistogramParameterfvEXT; +GLEW_FUN_EXPORT PFNGLGETHISTOGRAMPARAMETERIVEXTPROC __glewGetHistogramParameterivEXT; +GLEW_FUN_EXPORT PFNGLGETMINMAXEXTPROC __glewGetMinmaxEXT; +GLEW_FUN_EXPORT PFNGLGETMINMAXPARAMETERFVEXTPROC __glewGetMinmaxParameterfvEXT; +GLEW_FUN_EXPORT PFNGLGETMINMAXPARAMETERIVEXTPROC __glewGetMinmaxParameterivEXT; +GLEW_FUN_EXPORT PFNGLHISTOGRAMEXTPROC __glewHistogramEXT; +GLEW_FUN_EXPORT PFNGLMINMAXEXTPROC __glewMinmaxEXT; +GLEW_FUN_EXPORT PFNGLRESETHISTOGRAMEXTPROC __glewResetHistogramEXT; +GLEW_FUN_EXPORT PFNGLRESETMINMAXEXTPROC __glewResetMinmaxEXT; + +GLEW_FUN_EXPORT PFNGLINDEXFUNCEXTPROC __glewIndexFuncEXT; + +GLEW_FUN_EXPORT PFNGLINDEXMATERIALEXTPROC __glewIndexMaterialEXT; + +GLEW_FUN_EXPORT PFNGLAPPLYTEXTUREEXTPROC __glewApplyTextureEXT; +GLEW_FUN_EXPORT PFNGLTEXTURELIGHTEXTPROC __glewTextureLightEXT; +GLEW_FUN_EXPORT PFNGLTEXTUREMATERIALEXTPROC __glewTextureMaterialEXT; + +GLEW_FUN_EXPORT PFNGLMULTIDRAWARRAYSEXTPROC __glewMultiDrawArraysEXT; +GLEW_FUN_EXPORT PFNGLMULTIDRAWELEMENTSEXTPROC __glewMultiDrawElementsEXT; + +GLEW_FUN_EXPORT PFNGLSAMPLEMASKEXTPROC __glewSampleMaskEXT; +GLEW_FUN_EXPORT PFNGLSAMPLEPATTERNEXTPROC __glewSamplePatternEXT; + +GLEW_FUN_EXPORT PFNGLCOLORTABLEEXTPROC __glewColorTableEXT; +GLEW_FUN_EXPORT PFNGLGETCOLORTABLEEXTPROC __glewGetColorTableEXT; +GLEW_FUN_EXPORT PFNGLGETCOLORTABLEPARAMETERFVEXTPROC __glewGetColorTableParameterfvEXT; +GLEW_FUN_EXPORT PFNGLGETCOLORTABLEPARAMETERIVEXTPROC __glewGetColorTableParameterivEXT; + +GLEW_FUN_EXPORT PFNGLGETPIXELTRANSFORMPARAMETERFVEXTPROC __glewGetPixelTransformParameterfvEXT; +GLEW_FUN_EXPORT PFNGLGETPIXELTRANSFORMPARAMETERIVEXTPROC __glewGetPixelTransformParameterivEXT; +GLEW_FUN_EXPORT PFNGLPIXELTRANSFORMPARAMETERFEXTPROC __glewPixelTransformParameterfEXT; +GLEW_FUN_EXPORT PFNGLPIXELTRANSFORMPARAMETERFVEXTPROC __glewPixelTransformParameterfvEXT; +GLEW_FUN_EXPORT PFNGLPIXELTRANSFORMPARAMETERIEXTPROC __glewPixelTransformParameteriEXT; +GLEW_FUN_EXPORT PFNGLPIXELTRANSFORMPARAMETERIVEXTPROC __glewPixelTransformParameterivEXT; + +GLEW_FUN_EXPORT PFNGLPOINTPARAMETERFEXTPROC __glewPointParameterfEXT; +GLEW_FUN_EXPORT PFNGLPOINTPARAMETERFVEXTPROC __glewPointParameterfvEXT; + +GLEW_FUN_EXPORT PFNGLPOLYGONOFFSETEXTPROC __glewPolygonOffsetEXT; + +GLEW_FUN_EXPORT PFNGLBEGINSCENEEXTPROC __glewBeginSceneEXT; +GLEW_FUN_EXPORT PFNGLENDSCENEEXTPROC __glewEndSceneEXT; + +GLEW_FUN_EXPORT PFNGLSECONDARYCOLOR3BEXTPROC __glewSecondaryColor3bEXT; +GLEW_FUN_EXPORT PFNGLSECONDARYCOLOR3BVEXTPROC __glewSecondaryColor3bvEXT; +GLEW_FUN_EXPORT PFNGLSECONDARYCOLOR3DEXTPROC __glewSecondaryColor3dEXT; +GLEW_FUN_EXPORT PFNGLSECONDARYCOLOR3DVEXTPROC __glewSecondaryColor3dvEXT; +GLEW_FUN_EXPORT PFNGLSECONDARYCOLOR3FEXTPROC __glewSecondaryColor3fEXT; +GLEW_FUN_EXPORT PFNGLSECONDARYCOLOR3FVEXTPROC __glewSecondaryColor3fvEXT; +GLEW_FUN_EXPORT PFNGLSECONDARYCOLOR3IEXTPROC __glewSecondaryColor3iEXT; +GLEW_FUN_EXPORT PFNGLSECONDARYCOLOR3IVEXTPROC __glewSecondaryColor3ivEXT; +GLEW_FUN_EXPORT PFNGLSECONDARYCOLOR3SEXTPROC __glewSecondaryColor3sEXT; +GLEW_FUN_EXPORT PFNGLSECONDARYCOLOR3SVEXTPROC __glewSecondaryColor3svEXT; +GLEW_FUN_EXPORT PFNGLSECONDARYCOLOR3UBEXTPROC __glewSecondaryColor3ubEXT; +GLEW_FUN_EXPORT PFNGLSECONDARYCOLOR3UBVEXTPROC __glewSecondaryColor3ubvEXT; +GLEW_FUN_EXPORT PFNGLSECONDARYCOLOR3UIEXTPROC __glewSecondaryColor3uiEXT; +GLEW_FUN_EXPORT PFNGLSECONDARYCOLOR3UIVEXTPROC __glewSecondaryColor3uivEXT; +GLEW_FUN_EXPORT PFNGLSECONDARYCOLOR3USEXTPROC __glewSecondaryColor3usEXT; +GLEW_FUN_EXPORT PFNGLSECONDARYCOLOR3USVEXTPROC __glewSecondaryColor3usvEXT; +GLEW_FUN_EXPORT PFNGLSECONDARYCOLORPOINTEREXTPROC __glewSecondaryColorPointerEXT; + +GLEW_FUN_EXPORT PFNGLACTIVESTENCILFACEEXTPROC __glewActiveStencilFaceEXT; + +GLEW_FUN_EXPORT PFNGLTEXSUBIMAGE1DEXTPROC __glewTexSubImage1DEXT; +GLEW_FUN_EXPORT PFNGLTEXSUBIMAGE2DEXTPROC __glewTexSubImage2DEXT; +GLEW_FUN_EXPORT PFNGLTEXSUBIMAGE3DEXTPROC __glewTexSubImage3DEXT; + +GLEW_FUN_EXPORT PFNGLTEXIMAGE3DEXTPROC __glewTexImage3DEXT; + +GLEW_FUN_EXPORT PFNGLTEXBUFFEREXTPROC __glewTexBufferEXT; + +GLEW_FUN_EXPORT PFNGLCLEARCOLORIIEXTPROC __glewClearColorIiEXT; +GLEW_FUN_EXPORT PFNGLCLEARCOLORIUIEXTPROC __glewClearColorIuiEXT; +GLEW_FUN_EXPORT PFNGLGETTEXPARAMETERIIVEXTPROC __glewGetTexParameterIivEXT; +GLEW_FUN_EXPORT PFNGLGETTEXPARAMETERIUIVEXTPROC __glewGetTexParameterIuivEXT; +GLEW_FUN_EXPORT PFNGLTEXPARAMETERIIVEXTPROC __glewTexParameterIivEXT; +GLEW_FUN_EXPORT PFNGLTEXPARAMETERIUIVEXTPROC __glewTexParameterIuivEXT; + +GLEW_FUN_EXPORT PFNGLARETEXTURESRESIDENTEXTPROC __glewAreTexturesResidentEXT; +GLEW_FUN_EXPORT PFNGLBINDTEXTUREEXTPROC __glewBindTextureEXT; +GLEW_FUN_EXPORT PFNGLDELETETEXTURESEXTPROC __glewDeleteTexturesEXT; +GLEW_FUN_EXPORT PFNGLGENTEXTURESEXTPROC __glewGenTexturesEXT; +GLEW_FUN_EXPORT PFNGLISTEXTUREEXTPROC __glewIsTextureEXT; +GLEW_FUN_EXPORT PFNGLPRIORITIZETEXTURESEXTPROC __glewPrioritizeTexturesEXT; + +GLEW_FUN_EXPORT PFNGLTEXTURENORMALEXTPROC __glewTextureNormalEXT; + +//GLEW_FUN_EXPORT PFNGLGETQUERYOBJECTI64VEXTPROC __glewGetQueryObjecti64vEXT; +//GLEW_FUN_EXPORT PFNGLGETQUERYOBJECTUI64VEXTPROC __glewGetQueryObjectui64vEXT; + +GLEW_FUN_EXPORT PFNGLBEGINTRANSFORMFEEDBACKEXTPROC __glewBeginTransformFeedbackEXT; +GLEW_FUN_EXPORT PFNGLBINDBUFFERBASEEXTPROC __glewBindBufferBaseEXT; +GLEW_FUN_EXPORT PFNGLBINDBUFFEROFFSETEXTPROC __glewBindBufferOffsetEXT; +GLEW_FUN_EXPORT PFNGLBINDBUFFERRANGEEXTPROC __glewBindBufferRangeEXT; +GLEW_FUN_EXPORT PFNGLENDTRANSFORMFEEDBACKEXTPROC __glewEndTransformFeedbackEXT; +GLEW_FUN_EXPORT PFNGLGETTRANSFORMFEEDBACKVARYINGEXTPROC __glewGetTransformFeedbackVaryingEXT; +GLEW_FUN_EXPORT PFNGLTRANSFORMFEEDBACKVARYINGSEXTPROC __glewTransformFeedbackVaryingsEXT; + +GLEW_FUN_EXPORT PFNGLARRAYELEMENTEXTPROC __glewArrayElementEXT; +GLEW_FUN_EXPORT PFNGLCOLORPOINTEREXTPROC __glewColorPointerEXT; +GLEW_FUN_EXPORT PFNGLDRAWARRAYSEXTPROC __glewDrawArraysEXT; +GLEW_FUN_EXPORT PFNGLEDGEFLAGPOINTEREXTPROC __glewEdgeFlagPointerEXT; +GLEW_FUN_EXPORT PFNGLGETPOINTERVEXTPROC __glewGetPointervEXT; +GLEW_FUN_EXPORT PFNGLINDEXPOINTEREXTPROC __glewIndexPointerEXT; +GLEW_FUN_EXPORT PFNGLNORMALPOINTEREXTPROC __glewNormalPointerEXT; +GLEW_FUN_EXPORT PFNGLTEXCOORDPOINTEREXTPROC __glewTexCoordPointerEXT; +GLEW_FUN_EXPORT PFNGLVERTEXPOINTEREXTPROC __glewVertexPointerEXT; + +GLEW_FUN_EXPORT PFNGLBEGINVERTEXSHADEREXTPROC __glewBeginVertexShaderEXT; +GLEW_FUN_EXPORT PFNGLBINDLIGHTPARAMETEREXTPROC __glewBindLightParameterEXT; +GLEW_FUN_EXPORT PFNGLBINDMATERIALPARAMETEREXTPROC __glewBindMaterialParameterEXT; +GLEW_FUN_EXPORT PFNGLBINDPARAMETEREXTPROC __glewBindParameterEXT; +GLEW_FUN_EXPORT PFNGLBINDTEXGENPARAMETEREXTPROC __glewBindTexGenParameterEXT; +GLEW_FUN_EXPORT PFNGLBINDTEXTUREUNITPARAMETEREXTPROC __glewBindTextureUnitParameterEXT; +GLEW_FUN_EXPORT PFNGLBINDVERTEXSHADEREXTPROC __glewBindVertexShaderEXT; +GLEW_FUN_EXPORT PFNGLDELETEVERTEXSHADEREXTPROC __glewDeleteVertexShaderEXT; +GLEW_FUN_EXPORT PFNGLDISABLEVARIANTCLIENTSTATEEXTPROC __glewDisableVariantClientStateEXT; +GLEW_FUN_EXPORT PFNGLENABLEVARIANTCLIENTSTATEEXTPROC __glewEnableVariantClientStateEXT; +GLEW_FUN_EXPORT PFNGLENDVERTEXSHADEREXTPROC __glewEndVertexShaderEXT; +GLEW_FUN_EXPORT PFNGLEXTRACTCOMPONENTEXTPROC __glewExtractComponentEXT; +GLEW_FUN_EXPORT PFNGLGENSYMBOLSEXTPROC __glewGenSymbolsEXT; +GLEW_FUN_EXPORT PFNGLGENVERTEXSHADERSEXTPROC __glewGenVertexShadersEXT; +GLEW_FUN_EXPORT PFNGLGETINVARIANTBOOLEANVEXTPROC __glewGetInvariantBooleanvEXT; +GLEW_FUN_EXPORT PFNGLGETINVARIANTFLOATVEXTPROC __glewGetInvariantFloatvEXT; +GLEW_FUN_EXPORT PFNGLGETINVARIANTINTEGERVEXTPROC __glewGetInvariantIntegervEXT; +GLEW_FUN_EXPORT PFNGLGETLOCALCONSTANTBOOLEANVEXTPROC __glewGetLocalConstantBooleanvEXT; +GLEW_FUN_EXPORT PFNGLGETLOCALCONSTANTFLOATVEXTPROC __glewGetLocalConstantFloatvEXT; +GLEW_FUN_EXPORT PFNGLGETLOCALCONSTANTINTEGERVEXTPROC __glewGetLocalConstantIntegervEXT; +GLEW_FUN_EXPORT PFNGLGETVARIANTBOOLEANVEXTPROC __glewGetVariantBooleanvEXT; +GLEW_FUN_EXPORT PFNGLGETVARIANTFLOATVEXTPROC __glewGetVariantFloatvEXT; +GLEW_FUN_EXPORT PFNGLGETVARIANTINTEGERVEXTPROC __glewGetVariantIntegervEXT; +GLEW_FUN_EXPORT PFNGLGETVARIANTPOINTERVEXTPROC __glewGetVariantPointervEXT; +GLEW_FUN_EXPORT PFNGLINSERTCOMPONENTEXTPROC __glewInsertComponentEXT; +GLEW_FUN_EXPORT PFNGLISVARIANTENABLEDEXTPROC __glewIsVariantEnabledEXT; +GLEW_FUN_EXPORT PFNGLSETINVARIANTEXTPROC __glewSetInvariantEXT; +GLEW_FUN_EXPORT PFNGLSETLOCALCONSTANTEXTPROC __glewSetLocalConstantEXT; +GLEW_FUN_EXPORT PFNGLSHADEROP1EXTPROC __glewShaderOp1EXT; +GLEW_FUN_EXPORT PFNGLSHADEROP2EXTPROC __glewShaderOp2EXT; +GLEW_FUN_EXPORT PFNGLSHADEROP3EXTPROC __glewShaderOp3EXT; +GLEW_FUN_EXPORT PFNGLSWIZZLEEXTPROC __glewSwizzleEXT; +GLEW_FUN_EXPORT PFNGLVARIANTPOINTEREXTPROC __glewVariantPointerEXT; +GLEW_FUN_EXPORT PFNGLVARIANTBVEXTPROC __glewVariantbvEXT; +GLEW_FUN_EXPORT PFNGLVARIANTDVEXTPROC __glewVariantdvEXT; +GLEW_FUN_EXPORT PFNGLVARIANTFVEXTPROC __glewVariantfvEXT; +GLEW_FUN_EXPORT PFNGLVARIANTIVEXTPROC __glewVariantivEXT; +GLEW_FUN_EXPORT PFNGLVARIANTSVEXTPROC __glewVariantsvEXT; +GLEW_FUN_EXPORT PFNGLVARIANTUBVEXTPROC __glewVariantubvEXT; +GLEW_FUN_EXPORT PFNGLVARIANTUIVEXTPROC __glewVariantuivEXT; +GLEW_FUN_EXPORT PFNGLVARIANTUSVEXTPROC __glewVariantusvEXT; +GLEW_FUN_EXPORT PFNGLWRITEMASKEXTPROC __glewWriteMaskEXT; + +GLEW_FUN_EXPORT PFNGLVERTEXWEIGHTPOINTEREXTPROC __glewVertexWeightPointerEXT; +GLEW_FUN_EXPORT PFNGLVERTEXWEIGHTFEXTPROC __glewVertexWeightfEXT; +GLEW_FUN_EXPORT PFNGLVERTEXWEIGHTFVEXTPROC __glewVertexWeightfvEXT; + +GLEW_FUN_EXPORT PFNGLFRAMETERMINATORGREMEDYPROC __glewFrameTerminatorGREMEDY; + +GLEW_FUN_EXPORT PFNGLSTRINGMARKERGREMEDYPROC __glewStringMarkerGREMEDY; + +GLEW_FUN_EXPORT PFNGLGETIMAGETRANSFORMPARAMETERFVHPPROC __glewGetImageTransformParameterfvHP; +GLEW_FUN_EXPORT PFNGLGETIMAGETRANSFORMPARAMETERIVHPPROC __glewGetImageTransformParameterivHP; +GLEW_FUN_EXPORT PFNGLIMAGETRANSFORMPARAMETERFHPPROC __glewImageTransformParameterfHP; +GLEW_FUN_EXPORT PFNGLIMAGETRANSFORMPARAMETERFVHPPROC __glewImageTransformParameterfvHP; +GLEW_FUN_EXPORT PFNGLIMAGETRANSFORMPARAMETERIHPPROC __glewImageTransformParameteriHP; +GLEW_FUN_EXPORT PFNGLIMAGETRANSFORMPARAMETERIVHPPROC __glewImageTransformParameterivHP; + +GLEW_FUN_EXPORT PFNGLMULTIMODEDRAWARRAYSIBMPROC __glewMultiModeDrawArraysIBM; +GLEW_FUN_EXPORT PFNGLMULTIMODEDRAWELEMENTSIBMPROC __glewMultiModeDrawElementsIBM; + +GLEW_FUN_EXPORT PFNGLCOLORPOINTERLISTIBMPROC __glewColorPointerListIBM; +GLEW_FUN_EXPORT PFNGLEDGEFLAGPOINTERLISTIBMPROC __glewEdgeFlagPointerListIBM; +GLEW_FUN_EXPORT PFNGLFOGCOORDPOINTERLISTIBMPROC __glewFogCoordPointerListIBM; +GLEW_FUN_EXPORT PFNGLINDEXPOINTERLISTIBMPROC __glewIndexPointerListIBM; +GLEW_FUN_EXPORT PFNGLNORMALPOINTERLISTIBMPROC __glewNormalPointerListIBM; +GLEW_FUN_EXPORT PFNGLSECONDARYCOLORPOINTERLISTIBMPROC __glewSecondaryColorPointerListIBM; +GLEW_FUN_EXPORT PFNGLTEXCOORDPOINTERLISTIBMPROC __glewTexCoordPointerListIBM; +GLEW_FUN_EXPORT PFNGLVERTEXPOINTERLISTIBMPROC __glewVertexPointerListIBM; + +GLEW_FUN_EXPORT PFNGLCOLORPOINTERVINTELPROC __glewColorPointervINTEL; +GLEW_FUN_EXPORT PFNGLNORMALPOINTERVINTELPROC __glewNormalPointervINTEL; +GLEW_FUN_EXPORT PFNGLTEXCOORDPOINTERVINTELPROC __glewTexCoordPointervINTEL; +GLEW_FUN_EXPORT PFNGLVERTEXPOINTERVINTELPROC __glewVertexPointervINTEL; + +GLEW_FUN_EXPORT PFNGLTEXSCISSORFUNCINTELPROC __glewTexScissorFuncINTEL; +GLEW_FUN_EXPORT PFNGLTEXSCISSORINTELPROC __glewTexScissorINTEL; + +GLEW_FUN_EXPORT PFNGLBUFFERREGIONENABLEDEXTPROC __glewBufferRegionEnabledEXT; +GLEW_FUN_EXPORT PFNGLDELETEBUFFERREGIONEXTPROC __glewDeleteBufferRegionEXT; +GLEW_FUN_EXPORT PFNGLDRAWBUFFERREGIONEXTPROC __glewDrawBufferRegionEXT; +GLEW_FUN_EXPORT PFNGLNEWBUFFERREGIONEXTPROC __glewNewBufferRegionEXT; +GLEW_FUN_EXPORT PFNGLREADBUFFERREGIONEXTPROC __glewReadBufferRegionEXT; + +GLEW_FUN_EXPORT PFNGLRESIZEBUFFERSMESAPROC __glewResizeBuffersMESA; + +GLEW_FUN_EXPORT PFNGLWINDOWPOS2DMESAPROC __glewWindowPos2dMESA; +GLEW_FUN_EXPORT PFNGLWINDOWPOS2DVMESAPROC __glewWindowPos2dvMESA; +GLEW_FUN_EXPORT PFNGLWINDOWPOS2FMESAPROC __glewWindowPos2fMESA; +GLEW_FUN_EXPORT PFNGLWINDOWPOS2FVMESAPROC __glewWindowPos2fvMESA; +GLEW_FUN_EXPORT PFNGLWINDOWPOS2IMESAPROC __glewWindowPos2iMESA; +GLEW_FUN_EXPORT PFNGLWINDOWPOS2IVMESAPROC __glewWindowPos2ivMESA; +GLEW_FUN_EXPORT PFNGLWINDOWPOS2SMESAPROC __glewWindowPos2sMESA; +GLEW_FUN_EXPORT PFNGLWINDOWPOS2SVMESAPROC __glewWindowPos2svMESA; +GLEW_FUN_EXPORT PFNGLWINDOWPOS3DMESAPROC __glewWindowPos3dMESA; +GLEW_FUN_EXPORT PFNGLWINDOWPOS3DVMESAPROC __glewWindowPos3dvMESA; +GLEW_FUN_EXPORT PFNGLWINDOWPOS3FMESAPROC __glewWindowPos3fMESA; +GLEW_FUN_EXPORT PFNGLWINDOWPOS3FVMESAPROC __glewWindowPos3fvMESA; +GLEW_FUN_EXPORT PFNGLWINDOWPOS3IMESAPROC __glewWindowPos3iMESA; +GLEW_FUN_EXPORT PFNGLWINDOWPOS3IVMESAPROC __glewWindowPos3ivMESA; +GLEW_FUN_EXPORT PFNGLWINDOWPOS3SMESAPROC __glewWindowPos3sMESA; +GLEW_FUN_EXPORT PFNGLWINDOWPOS3SVMESAPROC __glewWindowPos3svMESA; +GLEW_FUN_EXPORT PFNGLWINDOWPOS4DMESAPROC __glewWindowPos4dMESA; +GLEW_FUN_EXPORT PFNGLWINDOWPOS4DVMESAPROC __glewWindowPos4dvMESA; +GLEW_FUN_EXPORT PFNGLWINDOWPOS4FMESAPROC __glewWindowPos4fMESA; +GLEW_FUN_EXPORT PFNGLWINDOWPOS4FVMESAPROC __glewWindowPos4fvMESA; +GLEW_FUN_EXPORT PFNGLWINDOWPOS4IMESAPROC __glewWindowPos4iMESA; +GLEW_FUN_EXPORT PFNGLWINDOWPOS4IVMESAPROC __glewWindowPos4ivMESA; +GLEW_FUN_EXPORT PFNGLWINDOWPOS4SMESAPROC __glewWindowPos4sMESA; +GLEW_FUN_EXPORT PFNGLWINDOWPOS4SVMESAPROC __glewWindowPos4svMESA; + +GLEW_FUN_EXPORT PFNGLBEGINCONDITIONALRENDERNVPROC __glewBeginConditionalRenderNV; +GLEW_FUN_EXPORT PFNGLENDCONDITIONALRENDERNVPROC __glewEndConditionalRenderNV; + +GLEW_FUN_EXPORT PFNGLCLEARDEPTHDNVPROC __glewClearDepthdNV; +GLEW_FUN_EXPORT PFNGLDEPTHBOUNDSDNVPROC __glewDepthBoundsdNV; +GLEW_FUN_EXPORT PFNGLDEPTHRANGEDNVPROC __glewDepthRangedNV; + +GLEW_FUN_EXPORT PFNGLEVALMAPSNVPROC __glewEvalMapsNV; +GLEW_FUN_EXPORT PFNGLGETMAPATTRIBPARAMETERFVNVPROC __glewGetMapAttribParameterfvNV; +GLEW_FUN_EXPORT PFNGLGETMAPATTRIBPARAMETERIVNVPROC __glewGetMapAttribParameterivNV; +GLEW_FUN_EXPORT PFNGLGETMAPCONTROLPOINTSNVPROC __glewGetMapControlPointsNV; +GLEW_FUN_EXPORT PFNGLGETMAPPARAMETERFVNVPROC __glewGetMapParameterfvNV; +GLEW_FUN_EXPORT PFNGLGETMAPPARAMETERIVNVPROC __glewGetMapParameterivNV; +GLEW_FUN_EXPORT PFNGLMAPCONTROLPOINTSNVPROC __glewMapControlPointsNV; +GLEW_FUN_EXPORT PFNGLMAPPARAMETERFVNVPROC __glewMapParameterfvNV; +GLEW_FUN_EXPORT PFNGLMAPPARAMETERIVNVPROC __glewMapParameterivNV; + +GLEW_FUN_EXPORT PFNGLGETMULTISAMPLEFVNVPROC __glewGetMultisamplefvNV; +GLEW_FUN_EXPORT PFNGLSAMPLEMASKINDEXEDNVPROC __glewSampleMaskIndexedNV; +GLEW_FUN_EXPORT PFNGLTEXRENDERBUFFERNVPROC __glewTexRenderbufferNV; + +GLEW_FUN_EXPORT PFNGLDELETEFENCESNVPROC __glewDeleteFencesNV; +GLEW_FUN_EXPORT PFNGLFINISHFENCENVPROC __glewFinishFenceNV; +GLEW_FUN_EXPORT PFNGLGENFENCESNVPROC __glewGenFencesNV; +GLEW_FUN_EXPORT PFNGLGETFENCEIVNVPROC __glewGetFenceivNV; +GLEW_FUN_EXPORT PFNGLISFENCENVPROC __glewIsFenceNV; +GLEW_FUN_EXPORT PFNGLSETFENCENVPROC __glewSetFenceNV; +GLEW_FUN_EXPORT PFNGLTESTFENCENVPROC __glewTestFenceNV; + +GLEW_FUN_EXPORT PFNGLGETPROGRAMNAMEDPARAMETERDVNVPROC __glewGetProgramNamedParameterdvNV; +GLEW_FUN_EXPORT PFNGLGETPROGRAMNAMEDPARAMETERFVNVPROC __glewGetProgramNamedParameterfvNV; +GLEW_FUN_EXPORT PFNGLPROGRAMNAMEDPARAMETER4DNVPROC __glewProgramNamedParameter4dNV; +GLEW_FUN_EXPORT PFNGLPROGRAMNAMEDPARAMETER4DVNVPROC __glewProgramNamedParameter4dvNV; +GLEW_FUN_EXPORT PFNGLPROGRAMNAMEDPARAMETER4FNVPROC __glewProgramNamedParameter4fNV; +GLEW_FUN_EXPORT PFNGLPROGRAMNAMEDPARAMETER4FVNVPROC __glewProgramNamedParameter4fvNV; + +GLEW_FUN_EXPORT PFNGLRENDERBUFFERSTORAGEMULTISAMPLECOVERAGENVPROC __glewRenderbufferStorageMultisampleCoverageNV; + +GLEW_FUN_EXPORT PFNGLPROGRAMVERTEXLIMITNVPROC __glewProgramVertexLimitNV; + +GLEW_FUN_EXPORT PFNGLPROGRAMENVPARAMETERI4INVPROC __glewProgramEnvParameterI4iNV; +GLEW_FUN_EXPORT PFNGLPROGRAMENVPARAMETERI4IVNVPROC __glewProgramEnvParameterI4ivNV; +GLEW_FUN_EXPORT PFNGLPROGRAMENVPARAMETERI4UINVPROC __glewProgramEnvParameterI4uiNV; +GLEW_FUN_EXPORT PFNGLPROGRAMENVPARAMETERI4UIVNVPROC __glewProgramEnvParameterI4uivNV; +GLEW_FUN_EXPORT PFNGLPROGRAMENVPARAMETERSI4IVNVPROC __glewProgramEnvParametersI4ivNV; +GLEW_FUN_EXPORT PFNGLPROGRAMENVPARAMETERSI4UIVNVPROC __glewProgramEnvParametersI4uivNV; +GLEW_FUN_EXPORT PFNGLPROGRAMLOCALPARAMETERI4INVPROC __glewProgramLocalParameterI4iNV; +GLEW_FUN_EXPORT PFNGLPROGRAMLOCALPARAMETERI4IVNVPROC __glewProgramLocalParameterI4ivNV; +GLEW_FUN_EXPORT PFNGLPROGRAMLOCALPARAMETERI4UINVPROC __glewProgramLocalParameterI4uiNV; +GLEW_FUN_EXPORT PFNGLPROGRAMLOCALPARAMETERI4UIVNVPROC __glewProgramLocalParameterI4uivNV; +GLEW_FUN_EXPORT PFNGLPROGRAMLOCALPARAMETERSI4IVNVPROC __glewProgramLocalParametersI4ivNV; +GLEW_FUN_EXPORT PFNGLPROGRAMLOCALPARAMETERSI4UIVNVPROC __glewProgramLocalParametersI4uivNV; + +GLEW_FUN_EXPORT PFNGLCOLOR3HNVPROC __glewColor3hNV; +GLEW_FUN_EXPORT PFNGLCOLOR3HVNVPROC __glewColor3hvNV; +GLEW_FUN_EXPORT PFNGLCOLOR4HNVPROC __glewColor4hNV; +GLEW_FUN_EXPORT PFNGLCOLOR4HVNVPROC __glewColor4hvNV; +GLEW_FUN_EXPORT PFNGLFOGCOORDHNVPROC __glewFogCoordhNV; +GLEW_FUN_EXPORT PFNGLFOGCOORDHVNVPROC __glewFogCoordhvNV; +GLEW_FUN_EXPORT PFNGLMULTITEXCOORD1HNVPROC __glewMultiTexCoord1hNV; +GLEW_FUN_EXPORT PFNGLMULTITEXCOORD1HVNVPROC __glewMultiTexCoord1hvNV; +GLEW_FUN_EXPORT PFNGLMULTITEXCOORD2HNVPROC __glewMultiTexCoord2hNV; +GLEW_FUN_EXPORT PFNGLMULTITEXCOORD2HVNVPROC __glewMultiTexCoord2hvNV; +GLEW_FUN_EXPORT PFNGLMULTITEXCOORD3HNVPROC __glewMultiTexCoord3hNV; +GLEW_FUN_EXPORT PFNGLMULTITEXCOORD3HVNVPROC __glewMultiTexCoord3hvNV; +GLEW_FUN_EXPORT PFNGLMULTITEXCOORD4HNVPROC __glewMultiTexCoord4hNV; +GLEW_FUN_EXPORT PFNGLMULTITEXCOORD4HVNVPROC __glewMultiTexCoord4hvNV; +GLEW_FUN_EXPORT PFNGLNORMAL3HNVPROC __glewNormal3hNV; +GLEW_FUN_EXPORT PFNGLNORMAL3HVNVPROC __glewNormal3hvNV; +GLEW_FUN_EXPORT PFNGLSECONDARYCOLOR3HNVPROC __glewSecondaryColor3hNV; +GLEW_FUN_EXPORT PFNGLSECONDARYCOLOR3HVNVPROC __glewSecondaryColor3hvNV; +GLEW_FUN_EXPORT PFNGLTEXCOORD1HNVPROC __glewTexCoord1hNV; +GLEW_FUN_EXPORT PFNGLTEXCOORD1HVNVPROC __glewTexCoord1hvNV; +GLEW_FUN_EXPORT PFNGLTEXCOORD2HNVPROC __glewTexCoord2hNV; +GLEW_FUN_EXPORT PFNGLTEXCOORD2HVNVPROC __glewTexCoord2hvNV; +GLEW_FUN_EXPORT PFNGLTEXCOORD3HNVPROC __glewTexCoord3hNV; +GLEW_FUN_EXPORT PFNGLTEXCOORD3HVNVPROC __glewTexCoord3hvNV; +GLEW_FUN_EXPORT PFNGLTEXCOORD4HNVPROC __glewTexCoord4hNV; +GLEW_FUN_EXPORT PFNGLTEXCOORD4HVNVPROC __glewTexCoord4hvNV; +GLEW_FUN_EXPORT PFNGLVERTEX2HNVPROC __glewVertex2hNV; +GLEW_FUN_EXPORT PFNGLVERTEX2HVNVPROC __glewVertex2hvNV; +GLEW_FUN_EXPORT PFNGLVERTEX3HNVPROC __glewVertex3hNV; +GLEW_FUN_EXPORT PFNGLVERTEX3HVNVPROC __glewVertex3hvNV; +GLEW_FUN_EXPORT PFNGLVERTEX4HNVPROC __glewVertex4hNV; +GLEW_FUN_EXPORT PFNGLVERTEX4HVNVPROC __glewVertex4hvNV; +GLEW_FUN_EXPORT PFNGLVERTEXATTRIB1HNVPROC __glewVertexAttrib1hNV; +GLEW_FUN_EXPORT PFNGLVERTEXATTRIB1HVNVPROC __glewVertexAttrib1hvNV; +GLEW_FUN_EXPORT PFNGLVERTEXATTRIB2HNVPROC __glewVertexAttrib2hNV; +GLEW_FUN_EXPORT PFNGLVERTEXATTRIB2HVNVPROC __glewVertexAttrib2hvNV; +GLEW_FUN_EXPORT PFNGLVERTEXATTRIB3HNVPROC __glewVertexAttrib3hNV; +GLEW_FUN_EXPORT PFNGLVERTEXATTRIB3HVNVPROC __glewVertexAttrib3hvNV; +GLEW_FUN_EXPORT PFNGLVERTEXATTRIB4HNVPROC __glewVertexAttrib4hNV; +GLEW_FUN_EXPORT PFNGLVERTEXATTRIB4HVNVPROC __glewVertexAttrib4hvNV; +GLEW_FUN_EXPORT PFNGLVERTEXATTRIBS1HVNVPROC __glewVertexAttribs1hvNV; +GLEW_FUN_EXPORT PFNGLVERTEXATTRIBS2HVNVPROC __glewVertexAttribs2hvNV; +GLEW_FUN_EXPORT PFNGLVERTEXATTRIBS3HVNVPROC __glewVertexAttribs3hvNV; +GLEW_FUN_EXPORT PFNGLVERTEXATTRIBS4HVNVPROC __glewVertexAttribs4hvNV; +GLEW_FUN_EXPORT PFNGLVERTEXWEIGHTHNVPROC __glewVertexWeighthNV; +GLEW_FUN_EXPORT PFNGLVERTEXWEIGHTHVNVPROC __glewVertexWeighthvNV; + +GLEW_FUN_EXPORT PFNGLBEGINOCCLUSIONQUERYNVPROC __glewBeginOcclusionQueryNV; +GLEW_FUN_EXPORT PFNGLDELETEOCCLUSIONQUERIESNVPROC __glewDeleteOcclusionQueriesNV; +GLEW_FUN_EXPORT PFNGLENDOCCLUSIONQUERYNVPROC __glewEndOcclusionQueryNV; +GLEW_FUN_EXPORT PFNGLGENOCCLUSIONQUERIESNVPROC __glewGenOcclusionQueriesNV; +GLEW_FUN_EXPORT PFNGLGETOCCLUSIONQUERYIVNVPROC __glewGetOcclusionQueryivNV; +GLEW_FUN_EXPORT PFNGLGETOCCLUSIONQUERYUIVNVPROC __glewGetOcclusionQueryuivNV; +GLEW_FUN_EXPORT PFNGLISOCCLUSIONQUERYNVPROC __glewIsOcclusionQueryNV; + +GLEW_FUN_EXPORT PFNGLPROGRAMBUFFERPARAMETERSIIVNVPROC __glewProgramBufferParametersIivNV; +GLEW_FUN_EXPORT PFNGLPROGRAMBUFFERPARAMETERSIUIVNVPROC __glewProgramBufferParametersIuivNV; +GLEW_FUN_EXPORT PFNGLPROGRAMBUFFERPARAMETERSFVNVPROC __glewProgramBufferParametersfvNV; + +GLEW_FUN_EXPORT PFNGLFLUSHPIXELDATARANGENVPROC __glewFlushPixelDataRangeNV; +GLEW_FUN_EXPORT PFNGLPIXELDATARANGENVPROC __glewPixelDataRangeNV; + +GLEW_FUN_EXPORT PFNGLPOINTPARAMETERINVPROC __glewPointParameteriNV; +GLEW_FUN_EXPORT PFNGLPOINTPARAMETERIVNVPROC __glewPointParameterivNV; + +//GLEW_FUN_EXPORT PFNGLGETVIDEOI64VNVPROC __glewGetVideoi64vNV; +GLEW_FUN_EXPORT PFNGLGETVIDEOIVNVPROC __glewGetVideoivNV; +//GLEW_FUN_EXPORT PFNGLGETVIDEOUI64VNVPROC __glewGetVideoui64vNV; +GLEW_FUN_EXPORT PFNGLGETVIDEOUIVNVPROC __glewGetVideouivNV; +//GLEW_FUN_EXPORT PFNGLPRESENTFRAMEDUALFILLNVPROC __glewPresentFrameDualFillNV; +//GLEW_FUN_EXPORT PFNGLPRESENTFRAMEKEYEDNVPROC __glewPresentFrameKeyedNV; +GLEW_FUN_EXPORT PFNGLVIDEOPARAMETERIVNVPROC __glewVideoParameterivNV; + +GLEW_FUN_EXPORT PFNGLPRIMITIVERESTARTINDEXNVPROC __glewPrimitiveRestartIndexNV; +GLEW_FUN_EXPORT PFNGLPRIMITIVERESTARTNVPROC __glewPrimitiveRestartNV; + +GLEW_FUN_EXPORT PFNGLCOMBINERINPUTNVPROC __glewCombinerInputNV; +GLEW_FUN_EXPORT PFNGLCOMBINEROUTPUTNVPROC __glewCombinerOutputNV; +GLEW_FUN_EXPORT PFNGLCOMBINERPARAMETERFNVPROC __glewCombinerParameterfNV; +GLEW_FUN_EXPORT PFNGLCOMBINERPARAMETERFVNVPROC __glewCombinerParameterfvNV; +GLEW_FUN_EXPORT PFNGLCOMBINERPARAMETERINVPROC __glewCombinerParameteriNV; +GLEW_FUN_EXPORT PFNGLCOMBINERPARAMETERIVNVPROC __glewCombinerParameterivNV; +GLEW_FUN_EXPORT PFNGLFINALCOMBINERINPUTNVPROC __glewFinalCombinerInputNV; +GLEW_FUN_EXPORT PFNGLGETCOMBINERINPUTPARAMETERFVNVPROC __glewGetCombinerInputParameterfvNV; +GLEW_FUN_EXPORT PFNGLGETCOMBINERINPUTPARAMETERIVNVPROC __glewGetCombinerInputParameterivNV; +GLEW_FUN_EXPORT PFNGLGETCOMBINEROUTPUTPARAMETERFVNVPROC __glewGetCombinerOutputParameterfvNV; +GLEW_FUN_EXPORT PFNGLGETCOMBINEROUTPUTPARAMETERIVNVPROC __glewGetCombinerOutputParameterivNV; +GLEW_FUN_EXPORT PFNGLGETFINALCOMBINERINPUTPARAMETERFVNVPROC __glewGetFinalCombinerInputParameterfvNV; +GLEW_FUN_EXPORT PFNGLGETFINALCOMBINERINPUTPARAMETERIVNVPROC __glewGetFinalCombinerInputParameterivNV; + +GLEW_FUN_EXPORT PFNGLCOMBINERSTAGEPARAMETERFVNVPROC __glewCombinerStageParameterfvNV; +GLEW_FUN_EXPORT PFNGLGETCOMBINERSTAGEPARAMETERFVNVPROC __glewGetCombinerStageParameterfvNV; + +GLEW_FUN_EXPORT PFNGLACTIVEVARYINGNVPROC __glewActiveVaryingNV; +GLEW_FUN_EXPORT PFNGLBEGINTRANSFORMFEEDBACKNVPROC __glewBeginTransformFeedbackNV; +GLEW_FUN_EXPORT PFNGLBINDBUFFERBASENVPROC __glewBindBufferBaseNV; +GLEW_FUN_EXPORT PFNGLBINDBUFFEROFFSETNVPROC __glewBindBufferOffsetNV; +GLEW_FUN_EXPORT PFNGLBINDBUFFERRANGENVPROC __glewBindBufferRangeNV; +GLEW_FUN_EXPORT PFNGLENDTRANSFORMFEEDBACKNVPROC __glewEndTransformFeedbackNV; +GLEW_FUN_EXPORT PFNGLGETACTIVEVARYINGNVPROC __glewGetActiveVaryingNV; +GLEW_FUN_EXPORT PFNGLGETTRANSFORMFEEDBACKVARYINGNVPROC __glewGetTransformFeedbackVaryingNV; +GLEW_FUN_EXPORT PFNGLGETVARYINGLOCATIONNVPROC __glewGetVaryingLocationNV; +GLEW_FUN_EXPORT PFNGLTRANSFORMFEEDBACKATTRIBSNVPROC __glewTransformFeedbackAttribsNV; +GLEW_FUN_EXPORT PFNGLTRANSFORMFEEDBACKVARYINGSNVPROC __glewTransformFeedbackVaryingsNV; + +GLEW_FUN_EXPORT PFNGLFLUSHVERTEXARRAYRANGENVPROC __glewFlushVertexArrayRangeNV; +GLEW_FUN_EXPORT PFNGLVERTEXARRAYRANGENVPROC __glewVertexArrayRangeNV; + +GLEW_FUN_EXPORT PFNGLAREPROGRAMSRESIDENTNVPROC __glewAreProgramsResidentNV; +GLEW_FUN_EXPORT PFNGLBINDPROGRAMNVPROC __glewBindProgramNV; +GLEW_FUN_EXPORT PFNGLDELETEPROGRAMSNVPROC __glewDeleteProgramsNV; +GLEW_FUN_EXPORT PFNGLEXECUTEPROGRAMNVPROC __glewExecuteProgramNV; +GLEW_FUN_EXPORT PFNGLGENPROGRAMSNVPROC __glewGenProgramsNV; +GLEW_FUN_EXPORT PFNGLGETPROGRAMPARAMETERDVNVPROC __glewGetProgramParameterdvNV; +GLEW_FUN_EXPORT PFNGLGETPROGRAMPARAMETERFVNVPROC __glewGetProgramParameterfvNV; +GLEW_FUN_EXPORT PFNGLGETPROGRAMSTRINGNVPROC __glewGetProgramStringNV; +GLEW_FUN_EXPORT PFNGLGETPROGRAMIVNVPROC __glewGetProgramivNV; +GLEW_FUN_EXPORT PFNGLGETTRACKMATRIXIVNVPROC __glewGetTrackMatrixivNV; +GLEW_FUN_EXPORT PFNGLGETVERTEXATTRIBPOINTERVNVPROC __glewGetVertexAttribPointervNV; +GLEW_FUN_EXPORT PFNGLGETVERTEXATTRIBDVNVPROC __glewGetVertexAttribdvNV; +GLEW_FUN_EXPORT PFNGLGETVERTEXATTRIBFVNVPROC __glewGetVertexAttribfvNV; +GLEW_FUN_EXPORT PFNGLGETVERTEXATTRIBIVNVPROC __glewGetVertexAttribivNV; +GLEW_FUN_EXPORT PFNGLISPROGRAMNVPROC __glewIsProgramNV; +GLEW_FUN_EXPORT PFNGLLOADPROGRAMNVPROC __glewLoadProgramNV; +GLEW_FUN_EXPORT PFNGLPROGRAMPARAMETER4DNVPROC __glewProgramParameter4dNV; +GLEW_FUN_EXPORT PFNGLPROGRAMPARAMETER4DVNVPROC __glewProgramParameter4dvNV; +GLEW_FUN_EXPORT PFNGLPROGRAMPARAMETER4FNVPROC __glewProgramParameter4fNV; +GLEW_FUN_EXPORT PFNGLPROGRAMPARAMETER4FVNVPROC __glewProgramParameter4fvNV; +GLEW_FUN_EXPORT PFNGLPROGRAMPARAMETERS4DVNVPROC __glewProgramParameters4dvNV; +GLEW_FUN_EXPORT PFNGLPROGRAMPARAMETERS4FVNVPROC __glewProgramParameters4fvNV; +GLEW_FUN_EXPORT PFNGLREQUESTRESIDENTPROGRAMSNVPROC __glewRequestResidentProgramsNV; +GLEW_FUN_EXPORT PFNGLTRACKMATRIXNVPROC __glewTrackMatrixNV; +GLEW_FUN_EXPORT PFNGLVERTEXATTRIB1DNVPROC __glewVertexAttrib1dNV; +GLEW_FUN_EXPORT PFNGLVERTEXATTRIB1DVNVPROC __glewVertexAttrib1dvNV; +GLEW_FUN_EXPORT PFNGLVERTEXATTRIB1FNVPROC __glewVertexAttrib1fNV; +GLEW_FUN_EXPORT PFNGLVERTEXATTRIB1FVNVPROC __glewVertexAttrib1fvNV; +GLEW_FUN_EXPORT PFNGLVERTEXATTRIB1SNVPROC __glewVertexAttrib1sNV; +GLEW_FUN_EXPORT PFNGLVERTEXATTRIB1SVNVPROC __glewVertexAttrib1svNV; +GLEW_FUN_EXPORT PFNGLVERTEXATTRIB2DNVPROC __glewVertexAttrib2dNV; +GLEW_FUN_EXPORT PFNGLVERTEXATTRIB2DVNVPROC __glewVertexAttrib2dvNV; +GLEW_FUN_EXPORT PFNGLVERTEXATTRIB2FNVPROC __glewVertexAttrib2fNV; +GLEW_FUN_EXPORT PFNGLVERTEXATTRIB2FVNVPROC __glewVertexAttrib2fvNV; +GLEW_FUN_EXPORT PFNGLVERTEXATTRIB2SNVPROC __glewVertexAttrib2sNV; +GLEW_FUN_EXPORT PFNGLVERTEXATTRIB2SVNVPROC __glewVertexAttrib2svNV; +GLEW_FUN_EXPORT PFNGLVERTEXATTRIB3DNVPROC __glewVertexAttrib3dNV; +GLEW_FUN_EXPORT PFNGLVERTEXATTRIB3DVNVPROC __glewVertexAttrib3dvNV; +GLEW_FUN_EXPORT PFNGLVERTEXATTRIB3FNVPROC __glewVertexAttrib3fNV; +GLEW_FUN_EXPORT PFNGLVERTEXATTRIB3FVNVPROC __glewVertexAttrib3fvNV; +GLEW_FUN_EXPORT PFNGLVERTEXATTRIB3SNVPROC __glewVertexAttrib3sNV; +GLEW_FUN_EXPORT PFNGLVERTEXATTRIB3SVNVPROC __glewVertexAttrib3svNV; +GLEW_FUN_EXPORT PFNGLVERTEXATTRIB4DNVPROC __glewVertexAttrib4dNV; +GLEW_FUN_EXPORT PFNGLVERTEXATTRIB4DVNVPROC __glewVertexAttrib4dvNV; +GLEW_FUN_EXPORT PFNGLVERTEXATTRIB4FNVPROC __glewVertexAttrib4fNV; +GLEW_FUN_EXPORT PFNGLVERTEXATTRIB4FVNVPROC __glewVertexAttrib4fvNV; +GLEW_FUN_EXPORT PFNGLVERTEXATTRIB4SNVPROC __glewVertexAttrib4sNV; +GLEW_FUN_EXPORT PFNGLVERTEXATTRIB4SVNVPROC __glewVertexAttrib4svNV; +GLEW_FUN_EXPORT PFNGLVERTEXATTRIB4UBNVPROC __glewVertexAttrib4ubNV; +GLEW_FUN_EXPORT PFNGLVERTEXATTRIB4UBVNVPROC __glewVertexAttrib4ubvNV; +GLEW_FUN_EXPORT PFNGLVERTEXATTRIBPOINTERNVPROC __glewVertexAttribPointerNV; +GLEW_FUN_EXPORT PFNGLVERTEXATTRIBS1DVNVPROC __glewVertexAttribs1dvNV; +GLEW_FUN_EXPORT PFNGLVERTEXATTRIBS1FVNVPROC __glewVertexAttribs1fvNV; +GLEW_FUN_EXPORT PFNGLVERTEXATTRIBS1SVNVPROC __glewVertexAttribs1svNV; +GLEW_FUN_EXPORT PFNGLVERTEXATTRIBS2DVNVPROC __glewVertexAttribs2dvNV; +GLEW_FUN_EXPORT PFNGLVERTEXATTRIBS2FVNVPROC __glewVertexAttribs2fvNV; +GLEW_FUN_EXPORT PFNGLVERTEXATTRIBS2SVNVPROC __glewVertexAttribs2svNV; +GLEW_FUN_EXPORT PFNGLVERTEXATTRIBS3DVNVPROC __glewVertexAttribs3dvNV; +GLEW_FUN_EXPORT PFNGLVERTEXATTRIBS3FVNVPROC __glewVertexAttribs3fvNV; +GLEW_FUN_EXPORT PFNGLVERTEXATTRIBS3SVNVPROC __glewVertexAttribs3svNV; +GLEW_FUN_EXPORT PFNGLVERTEXATTRIBS4DVNVPROC __glewVertexAttribs4dvNV; +GLEW_FUN_EXPORT PFNGLVERTEXATTRIBS4FVNVPROC __glewVertexAttribs4fvNV; +GLEW_FUN_EXPORT PFNGLVERTEXATTRIBS4SVNVPROC __glewVertexAttribs4svNV; +GLEW_FUN_EXPORT PFNGLVERTEXATTRIBS4UBVNVPROC __glewVertexAttribs4ubvNV; + +GLEW_FUN_EXPORT PFNGLCLEARDEPTHFOESPROC __glewClearDepthfOES; +GLEW_FUN_EXPORT PFNGLCLIPPLANEFOESPROC __glewClipPlanefOES; +GLEW_FUN_EXPORT PFNGLDEPTHRANGEFOESPROC __glewDepthRangefOES; +GLEW_FUN_EXPORT PFNGLFRUSTUMFOESPROC __glewFrustumfOES; +GLEW_FUN_EXPORT PFNGLGETCLIPPLANEFOESPROC __glewGetClipPlanefOES; +GLEW_FUN_EXPORT PFNGLORTHOFOESPROC __glewOrthofOES; + +GLEW_FUN_EXPORT PFNGLDETAILTEXFUNCSGISPROC __glewDetailTexFuncSGIS; +GLEW_FUN_EXPORT PFNGLGETDETAILTEXFUNCSGISPROC __glewGetDetailTexFuncSGIS; + +GLEW_FUN_EXPORT PFNGLFOGFUNCSGISPROC __glewFogFuncSGIS; +GLEW_FUN_EXPORT PFNGLGETFOGFUNCSGISPROC __glewGetFogFuncSGIS; + +GLEW_FUN_EXPORT PFNGLSAMPLEMASKSGISPROC __glewSampleMaskSGIS; +GLEW_FUN_EXPORT PFNGLSAMPLEPATTERNSGISPROC __glewSamplePatternSGIS; + +GLEW_FUN_EXPORT PFNGLGETSHARPENTEXFUNCSGISPROC __glewGetSharpenTexFuncSGIS; +GLEW_FUN_EXPORT PFNGLSHARPENTEXFUNCSGISPROC __glewSharpenTexFuncSGIS; + +GLEW_FUN_EXPORT PFNGLTEXIMAGE4DSGISPROC __glewTexImage4DSGIS; +GLEW_FUN_EXPORT PFNGLTEXSUBIMAGE4DSGISPROC __glewTexSubImage4DSGIS; + +GLEW_FUN_EXPORT PFNGLGETTEXFILTERFUNCSGISPROC __glewGetTexFilterFuncSGIS; +GLEW_FUN_EXPORT PFNGLTEXFILTERFUNCSGISPROC __glewTexFilterFuncSGIS; + +GLEW_FUN_EXPORT PFNGLASYNCMARKERSGIXPROC __glewAsyncMarkerSGIX; +GLEW_FUN_EXPORT PFNGLDELETEASYNCMARKERSSGIXPROC __glewDeleteAsyncMarkersSGIX; +GLEW_FUN_EXPORT PFNGLFINISHASYNCSGIXPROC __glewFinishAsyncSGIX; +GLEW_FUN_EXPORT PFNGLGENASYNCMARKERSSGIXPROC __glewGenAsyncMarkersSGIX; +GLEW_FUN_EXPORT PFNGLISASYNCMARKERSGIXPROC __glewIsAsyncMarkerSGIX; +GLEW_FUN_EXPORT PFNGLPOLLASYNCSGIXPROC __glewPollAsyncSGIX; + +GLEW_FUN_EXPORT PFNGLFLUSHRASTERSGIXPROC __glewFlushRasterSGIX; + +GLEW_FUN_EXPORT PFNGLTEXTUREFOGSGIXPROC __glewTextureFogSGIX; + +GLEW_FUN_EXPORT PFNGLFRAGMENTCOLORMATERIALSGIXPROC __glewFragmentColorMaterialSGIX; +GLEW_FUN_EXPORT PFNGLFRAGMENTLIGHTMODELFSGIXPROC __glewFragmentLightModelfSGIX; +GLEW_FUN_EXPORT PFNGLFRAGMENTLIGHTMODELFVSGIXPROC __glewFragmentLightModelfvSGIX; +GLEW_FUN_EXPORT PFNGLFRAGMENTLIGHTMODELISGIXPROC __glewFragmentLightModeliSGIX; +GLEW_FUN_EXPORT PFNGLFRAGMENTLIGHTMODELIVSGIXPROC __glewFragmentLightModelivSGIX; +GLEW_FUN_EXPORT PFNGLFRAGMENTLIGHTFSGIXPROC __glewFragmentLightfSGIX; +GLEW_FUN_EXPORT PFNGLFRAGMENTLIGHTFVSGIXPROC __glewFragmentLightfvSGIX; +GLEW_FUN_EXPORT PFNGLFRAGMENTLIGHTISGIXPROC __glewFragmentLightiSGIX; +GLEW_FUN_EXPORT PFNGLFRAGMENTLIGHTIVSGIXPROC __glewFragmentLightivSGIX; +GLEW_FUN_EXPORT PFNGLFRAGMENTMATERIALFSGIXPROC __glewFragmentMaterialfSGIX; +GLEW_FUN_EXPORT PFNGLFRAGMENTMATERIALFVSGIXPROC __glewFragmentMaterialfvSGIX; +GLEW_FUN_EXPORT PFNGLFRAGMENTMATERIALISGIXPROC __glewFragmentMaterialiSGIX; +GLEW_FUN_EXPORT PFNGLFRAGMENTMATERIALIVSGIXPROC __glewFragmentMaterialivSGIX; +GLEW_FUN_EXPORT PFNGLGETFRAGMENTLIGHTFVSGIXPROC __glewGetFragmentLightfvSGIX; +GLEW_FUN_EXPORT PFNGLGETFRAGMENTLIGHTIVSGIXPROC __glewGetFragmentLightivSGIX; +GLEW_FUN_EXPORT PFNGLGETFRAGMENTMATERIALFVSGIXPROC __glewGetFragmentMaterialfvSGIX; +GLEW_FUN_EXPORT PFNGLGETFRAGMENTMATERIALIVSGIXPROC __glewGetFragmentMaterialivSGIX; + +GLEW_FUN_EXPORT PFNGLFRAMEZOOMSGIXPROC __glewFrameZoomSGIX; + +GLEW_FUN_EXPORT PFNGLPIXELTEXGENSGIXPROC __glewPixelTexGenSGIX; + +GLEW_FUN_EXPORT PFNGLREFERENCEPLANESGIXPROC __glewReferencePlaneSGIX; + +GLEW_FUN_EXPORT PFNGLSPRITEPARAMETERFSGIXPROC __glewSpriteParameterfSGIX; +GLEW_FUN_EXPORT PFNGLSPRITEPARAMETERFVSGIXPROC __glewSpriteParameterfvSGIX; +GLEW_FUN_EXPORT PFNGLSPRITEPARAMETERISGIXPROC __glewSpriteParameteriSGIX; +GLEW_FUN_EXPORT PFNGLSPRITEPARAMETERIVSGIXPROC __glewSpriteParameterivSGIX; + +GLEW_FUN_EXPORT PFNGLTAGSAMPLEBUFFERSGIXPROC __glewTagSampleBufferSGIX; + +GLEW_FUN_EXPORT PFNGLCOLORTABLEPARAMETERFVSGIPROC __glewColorTableParameterfvSGI; +GLEW_FUN_EXPORT PFNGLCOLORTABLEPARAMETERIVSGIPROC __glewColorTableParameterivSGI; +GLEW_FUN_EXPORT PFNGLCOLORTABLESGIPROC __glewColorTableSGI; +GLEW_FUN_EXPORT PFNGLCOPYCOLORTABLESGIPROC __glewCopyColorTableSGI; +GLEW_FUN_EXPORT PFNGLGETCOLORTABLEPARAMETERFVSGIPROC __glewGetColorTableParameterfvSGI; +GLEW_FUN_EXPORT PFNGLGETCOLORTABLEPARAMETERIVSGIPROC __glewGetColorTableParameterivSGI; +GLEW_FUN_EXPORT PFNGLGETCOLORTABLESGIPROC __glewGetColorTableSGI; + +GLEW_FUN_EXPORT PFNGLFINISHTEXTURESUNXPROC __glewFinishTextureSUNX; + +GLEW_FUN_EXPORT PFNGLGLOBALALPHAFACTORBSUNPROC __glewGlobalAlphaFactorbSUN; +GLEW_FUN_EXPORT PFNGLGLOBALALPHAFACTORDSUNPROC __glewGlobalAlphaFactordSUN; +GLEW_FUN_EXPORT PFNGLGLOBALALPHAFACTORFSUNPROC __glewGlobalAlphaFactorfSUN; +GLEW_FUN_EXPORT PFNGLGLOBALALPHAFACTORISUNPROC __glewGlobalAlphaFactoriSUN; +GLEW_FUN_EXPORT PFNGLGLOBALALPHAFACTORSSUNPROC __glewGlobalAlphaFactorsSUN; +GLEW_FUN_EXPORT PFNGLGLOBALALPHAFACTORUBSUNPROC __glewGlobalAlphaFactorubSUN; +GLEW_FUN_EXPORT PFNGLGLOBALALPHAFACTORUISUNPROC __glewGlobalAlphaFactoruiSUN; +GLEW_FUN_EXPORT PFNGLGLOBALALPHAFACTORUSSUNPROC __glewGlobalAlphaFactorusSUN; + +GLEW_FUN_EXPORT PFNGLREADVIDEOPIXELSSUNPROC __glewReadVideoPixelsSUN; + +GLEW_FUN_EXPORT PFNGLREPLACEMENTCODEPOINTERSUNPROC __glewReplacementCodePointerSUN; +GLEW_FUN_EXPORT PFNGLREPLACEMENTCODEUBSUNPROC __glewReplacementCodeubSUN; +GLEW_FUN_EXPORT PFNGLREPLACEMENTCODEUBVSUNPROC __glewReplacementCodeubvSUN; +GLEW_FUN_EXPORT PFNGLREPLACEMENTCODEUISUNPROC __glewReplacementCodeuiSUN; +GLEW_FUN_EXPORT PFNGLREPLACEMENTCODEUIVSUNPROC __glewReplacementCodeuivSUN; +GLEW_FUN_EXPORT PFNGLREPLACEMENTCODEUSSUNPROC __glewReplacementCodeusSUN; +GLEW_FUN_EXPORT PFNGLREPLACEMENTCODEUSVSUNPROC __glewReplacementCodeusvSUN; + +GLEW_FUN_EXPORT PFNGLCOLOR3FVERTEX3FSUNPROC __glewColor3fVertex3fSUN; +GLEW_FUN_EXPORT PFNGLCOLOR3FVERTEX3FVSUNPROC __glewColor3fVertex3fvSUN; +GLEW_FUN_EXPORT PFNGLCOLOR4FNORMAL3FVERTEX3FSUNPROC __glewColor4fNormal3fVertex3fSUN; +GLEW_FUN_EXPORT PFNGLCOLOR4FNORMAL3FVERTEX3FVSUNPROC __glewColor4fNormal3fVertex3fvSUN; +GLEW_FUN_EXPORT PFNGLCOLOR4UBVERTEX2FSUNPROC __glewColor4ubVertex2fSUN; +GLEW_FUN_EXPORT PFNGLCOLOR4UBVERTEX2FVSUNPROC __glewColor4ubVertex2fvSUN; +GLEW_FUN_EXPORT PFNGLCOLOR4UBVERTEX3FSUNPROC __glewColor4ubVertex3fSUN; +GLEW_FUN_EXPORT PFNGLCOLOR4UBVERTEX3FVSUNPROC __glewColor4ubVertex3fvSUN; +GLEW_FUN_EXPORT PFNGLNORMAL3FVERTEX3FSUNPROC __glewNormal3fVertex3fSUN; +GLEW_FUN_EXPORT PFNGLNORMAL3FVERTEX3FVSUNPROC __glewNormal3fVertex3fvSUN; +GLEW_FUN_EXPORT PFNGLREPLACEMENTCODEUICOLOR3FVERTEX3FSUNPROC __glewReplacementCodeuiColor3fVertex3fSUN; +GLEW_FUN_EXPORT PFNGLREPLACEMENTCODEUICOLOR3FVERTEX3FVSUNPROC __glewReplacementCodeuiColor3fVertex3fvSUN; +GLEW_FUN_EXPORT PFNGLREPLACEMENTCODEUICOLOR4FNORMAL3FVERTEX3FSUNPROC __glewReplacementCodeuiColor4fNormal3fVertex3fSUN; +GLEW_FUN_EXPORT PFNGLREPLACEMENTCODEUICOLOR4FNORMAL3FVERTEX3FVSUNPROC __glewReplacementCodeuiColor4fNormal3fVertex3fvSUN; +GLEW_FUN_EXPORT PFNGLREPLACEMENTCODEUICOLOR4UBVERTEX3FSUNPROC __glewReplacementCodeuiColor4ubVertex3fSUN; +GLEW_FUN_EXPORT PFNGLREPLACEMENTCODEUICOLOR4UBVERTEX3FVSUNPROC __glewReplacementCodeuiColor4ubVertex3fvSUN; +GLEW_FUN_EXPORT PFNGLREPLACEMENTCODEUINORMAL3FVERTEX3FSUNPROC __glewReplacementCodeuiNormal3fVertex3fSUN; +GLEW_FUN_EXPORT PFNGLREPLACEMENTCODEUINORMAL3FVERTEX3FVSUNPROC __glewReplacementCodeuiNormal3fVertex3fvSUN; +GLEW_FUN_EXPORT PFNGLREPLACEMENTCODEUITEXCOORD2FCOLOR4FNORMAL3FVERTEX3FSUNPROC __glewReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fSUN; +GLEW_FUN_EXPORT PFNGLREPLACEMENTCODEUITEXCOORD2FCOLOR4FNORMAL3FVERTEX3FVSUNPROC __glewReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN; +GLEW_FUN_EXPORT PFNGLREPLACEMENTCODEUITEXCOORD2FNORMAL3FVERTEX3FSUNPROC __glewReplacementCodeuiTexCoord2fNormal3fVertex3fSUN; +GLEW_FUN_EXPORT PFNGLREPLACEMENTCODEUITEXCOORD2FNORMAL3FVERTEX3FVSUNPROC __glewReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN; +GLEW_FUN_EXPORT PFNGLREPLACEMENTCODEUITEXCOORD2FVERTEX3FSUNPROC __glewReplacementCodeuiTexCoord2fVertex3fSUN; +GLEW_FUN_EXPORT PFNGLREPLACEMENTCODEUITEXCOORD2FVERTEX3FVSUNPROC __glewReplacementCodeuiTexCoord2fVertex3fvSUN; +GLEW_FUN_EXPORT PFNGLREPLACEMENTCODEUIVERTEX3FSUNPROC __glewReplacementCodeuiVertex3fSUN; +GLEW_FUN_EXPORT PFNGLREPLACEMENTCODEUIVERTEX3FVSUNPROC __glewReplacementCodeuiVertex3fvSUN; +GLEW_FUN_EXPORT PFNGLTEXCOORD2FCOLOR3FVERTEX3FSUNPROC __glewTexCoord2fColor3fVertex3fSUN; +GLEW_FUN_EXPORT PFNGLTEXCOORD2FCOLOR3FVERTEX3FVSUNPROC __glewTexCoord2fColor3fVertex3fvSUN; +GLEW_FUN_EXPORT PFNGLTEXCOORD2FCOLOR4FNORMAL3FVERTEX3FSUNPROC __glewTexCoord2fColor4fNormal3fVertex3fSUN; +GLEW_FUN_EXPORT PFNGLTEXCOORD2FCOLOR4FNORMAL3FVERTEX3FVSUNPROC __glewTexCoord2fColor4fNormal3fVertex3fvSUN; +GLEW_FUN_EXPORT PFNGLTEXCOORD2FCOLOR4UBVERTEX3FSUNPROC __glewTexCoord2fColor4ubVertex3fSUN; +GLEW_FUN_EXPORT PFNGLTEXCOORD2FCOLOR4UBVERTEX3FVSUNPROC __glewTexCoord2fColor4ubVertex3fvSUN; +GLEW_FUN_EXPORT PFNGLTEXCOORD2FNORMAL3FVERTEX3FSUNPROC __glewTexCoord2fNormal3fVertex3fSUN; +GLEW_FUN_EXPORT PFNGLTEXCOORD2FNORMAL3FVERTEX3FVSUNPROC __glewTexCoord2fNormal3fVertex3fvSUN; +GLEW_FUN_EXPORT PFNGLTEXCOORD2FVERTEX3FSUNPROC __glewTexCoord2fVertex3fSUN; +GLEW_FUN_EXPORT PFNGLTEXCOORD2FVERTEX3FVSUNPROC __glewTexCoord2fVertex3fvSUN; +GLEW_FUN_EXPORT PFNGLTEXCOORD4FCOLOR4FNORMAL3FVERTEX4FSUNPROC __glewTexCoord4fColor4fNormal3fVertex4fSUN; +GLEW_FUN_EXPORT PFNGLTEXCOORD4FCOLOR4FNORMAL3FVERTEX4FVSUNPROC __glewTexCoord4fColor4fNormal3fVertex4fvSUN; +GLEW_FUN_EXPORT PFNGLTEXCOORD4FVERTEX4FSUNPROC __glewTexCoord4fVertex4fSUN; +GLEW_FUN_EXPORT PFNGLTEXCOORD4FVERTEX4FVSUNPROC __glewTexCoord4fVertex4fvSUN; + +GLEW_FUN_EXPORT PFNGLADDSWAPHINTRECTWINPROC __glewAddSwapHintRectWIN; + +#if defined(GLEW_MX) && !defined(_WIN32) +struct GLEWContextStruct +{ +#endif /* GLEW_MX */ + +GLEW_VAR_EXPORT GLboolean __GLEW_VERSION_1_1; +GLEW_VAR_EXPORT GLboolean __GLEW_VERSION_1_2; +GLEW_VAR_EXPORT GLboolean __GLEW_VERSION_1_3; +GLEW_VAR_EXPORT GLboolean __GLEW_VERSION_1_4; +GLEW_VAR_EXPORT GLboolean __GLEW_VERSION_1_5; +GLEW_VAR_EXPORT GLboolean __GLEW_VERSION_2_0; +GLEW_VAR_EXPORT GLboolean __GLEW_VERSION_2_1; +GLEW_VAR_EXPORT GLboolean __GLEW_VERSION_3_0; +GLEW_VAR_EXPORT GLboolean __GLEW_3DFX_multisample; +GLEW_VAR_EXPORT GLboolean __GLEW_3DFX_tbuffer; +GLEW_VAR_EXPORT GLboolean __GLEW_3DFX_texture_compression_FXT1; +GLEW_VAR_EXPORT GLboolean __GLEW_APPLE_client_storage; +GLEW_VAR_EXPORT GLboolean __GLEW_APPLE_element_array; +GLEW_VAR_EXPORT GLboolean __GLEW_APPLE_fence; +GLEW_VAR_EXPORT GLboolean __GLEW_APPLE_float_pixels; +GLEW_VAR_EXPORT GLboolean __GLEW_APPLE_flush_buffer_range; +GLEW_VAR_EXPORT GLboolean __GLEW_APPLE_pixel_buffer; +GLEW_VAR_EXPORT GLboolean __GLEW_APPLE_specular_vector; +GLEW_VAR_EXPORT GLboolean __GLEW_APPLE_texture_range; +GLEW_VAR_EXPORT GLboolean __GLEW_APPLE_transform_hint; +GLEW_VAR_EXPORT GLboolean __GLEW_APPLE_vertex_array_object; +GLEW_VAR_EXPORT GLboolean __GLEW_APPLE_vertex_array_range; +GLEW_VAR_EXPORT GLboolean __GLEW_APPLE_ycbcr_422; +GLEW_VAR_EXPORT GLboolean __GLEW_ARB_color_buffer_float; +GLEW_VAR_EXPORT GLboolean __GLEW_ARB_depth_buffer_float; +GLEW_VAR_EXPORT GLboolean __GLEW_ARB_depth_texture; +GLEW_VAR_EXPORT GLboolean __GLEW_ARB_draw_buffers; +GLEW_VAR_EXPORT GLboolean __GLEW_ARB_draw_instanced; +GLEW_VAR_EXPORT GLboolean __GLEW_ARB_fragment_program; +GLEW_VAR_EXPORT GLboolean __GLEW_ARB_fragment_program_shadow; +GLEW_VAR_EXPORT GLboolean __GLEW_ARB_fragment_shader; +GLEW_VAR_EXPORT GLboolean __GLEW_ARB_framebuffer_object; +GLEW_VAR_EXPORT GLboolean __GLEW_ARB_framebuffer_sRGB; +GLEW_VAR_EXPORT GLboolean __GLEW_ARB_geometry_shader4; +GLEW_VAR_EXPORT GLboolean __GLEW_ARB_half_float_pixel; +GLEW_VAR_EXPORT GLboolean __GLEW_ARB_half_float_vertex; +GLEW_VAR_EXPORT GLboolean __GLEW_ARB_imaging; +GLEW_VAR_EXPORT GLboolean __GLEW_ARB_instanced_arrays; +GLEW_VAR_EXPORT GLboolean __GLEW_ARB_map_buffer_range; +GLEW_VAR_EXPORT GLboolean __GLEW_ARB_matrix_palette; +GLEW_VAR_EXPORT GLboolean __GLEW_ARB_multisample; +GLEW_VAR_EXPORT GLboolean __GLEW_ARB_multitexture; +GLEW_VAR_EXPORT GLboolean __GLEW_ARB_occlusion_query; +GLEW_VAR_EXPORT GLboolean __GLEW_ARB_pixel_buffer_object; +GLEW_VAR_EXPORT GLboolean __GLEW_ARB_point_parameters; +GLEW_VAR_EXPORT GLboolean __GLEW_ARB_point_sprite; +GLEW_VAR_EXPORT GLboolean __GLEW_ARB_shader_objects; +GLEW_VAR_EXPORT GLboolean __GLEW_ARB_shading_language_100; +GLEW_VAR_EXPORT GLboolean __GLEW_ARB_shadow; +GLEW_VAR_EXPORT GLboolean __GLEW_ARB_shadow_ambient; +GLEW_VAR_EXPORT GLboolean __GLEW_ARB_texture_border_clamp; +GLEW_VAR_EXPORT GLboolean __GLEW_ARB_texture_buffer_object; +GLEW_VAR_EXPORT GLboolean __GLEW_ARB_texture_compression; +GLEW_VAR_EXPORT GLboolean __GLEW_ARB_texture_compression_rgtc; +GLEW_VAR_EXPORT GLboolean __GLEW_ARB_texture_cube_map; +GLEW_VAR_EXPORT GLboolean __GLEW_ARB_texture_env_add; +GLEW_VAR_EXPORT GLboolean __GLEW_ARB_texture_env_combine; +GLEW_VAR_EXPORT GLboolean __GLEW_ARB_texture_env_crossbar; +GLEW_VAR_EXPORT GLboolean __GLEW_ARB_texture_env_dot3; +GLEW_VAR_EXPORT GLboolean __GLEW_ARB_texture_float; +GLEW_VAR_EXPORT GLboolean __GLEW_ARB_texture_mirrored_repeat; +GLEW_VAR_EXPORT GLboolean __GLEW_ARB_texture_non_power_of_two; +GLEW_VAR_EXPORT GLboolean __GLEW_ARB_texture_rectangle; +GLEW_VAR_EXPORT GLboolean __GLEW_ARB_texture_rg; +GLEW_VAR_EXPORT GLboolean __GLEW_ARB_transpose_matrix; +GLEW_VAR_EXPORT GLboolean __GLEW_ARB_vertex_array_object; +GLEW_VAR_EXPORT GLboolean __GLEW_ARB_vertex_blend; +GLEW_VAR_EXPORT GLboolean __GLEW_ARB_vertex_buffer_object; +GLEW_VAR_EXPORT GLboolean __GLEW_ARB_vertex_program; +GLEW_VAR_EXPORT GLboolean __GLEW_ARB_vertex_shader; +GLEW_VAR_EXPORT GLboolean __GLEW_ARB_window_pos; +GLEW_VAR_EXPORT GLboolean __GLEW_ATIX_point_sprites; +GLEW_VAR_EXPORT GLboolean __GLEW_ATIX_texture_env_combine3; +GLEW_VAR_EXPORT GLboolean __GLEW_ATIX_texture_env_route; +GLEW_VAR_EXPORT GLboolean __GLEW_ATIX_vertex_shader_output_point_size; +GLEW_VAR_EXPORT GLboolean __GLEW_ATI_draw_buffers; +GLEW_VAR_EXPORT GLboolean __GLEW_ATI_element_array; +GLEW_VAR_EXPORT GLboolean __GLEW_ATI_envmap_bumpmap; +GLEW_VAR_EXPORT GLboolean __GLEW_ATI_fragment_shader; +GLEW_VAR_EXPORT GLboolean __GLEW_ATI_map_object_buffer; +GLEW_VAR_EXPORT GLboolean __GLEW_ATI_pn_triangles; +GLEW_VAR_EXPORT GLboolean __GLEW_ATI_separate_stencil; +GLEW_VAR_EXPORT GLboolean __GLEW_ATI_shader_texture_lod; +GLEW_VAR_EXPORT GLboolean __GLEW_ATI_text_fragment_shader; +GLEW_VAR_EXPORT GLboolean __GLEW_ATI_texture_compression_3dc; +GLEW_VAR_EXPORT GLboolean __GLEW_ATI_texture_env_combine3; +GLEW_VAR_EXPORT GLboolean __GLEW_ATI_texture_float; +GLEW_VAR_EXPORT GLboolean __GLEW_ATI_texture_mirror_once; +GLEW_VAR_EXPORT GLboolean __GLEW_ATI_vertex_array_object; +GLEW_VAR_EXPORT GLboolean __GLEW_ATI_vertex_attrib_array_object; +GLEW_VAR_EXPORT GLboolean __GLEW_ATI_vertex_streams; +GLEW_VAR_EXPORT GLboolean __GLEW_EXT_422_pixels; +GLEW_VAR_EXPORT GLboolean __GLEW_EXT_Cg_shader; +GLEW_VAR_EXPORT GLboolean __GLEW_EXT_abgr; +GLEW_VAR_EXPORT GLboolean __GLEW_EXT_bgra; +GLEW_VAR_EXPORT GLboolean __GLEW_EXT_bindable_uniform; +GLEW_VAR_EXPORT GLboolean __GLEW_EXT_blend_color; +GLEW_VAR_EXPORT GLboolean __GLEW_EXT_blend_equation_separate; +GLEW_VAR_EXPORT GLboolean __GLEW_EXT_blend_func_separate; +GLEW_VAR_EXPORT GLboolean __GLEW_EXT_blend_logic_op; +GLEW_VAR_EXPORT GLboolean __GLEW_EXT_blend_minmax; +GLEW_VAR_EXPORT GLboolean __GLEW_EXT_blend_subtract; +GLEW_VAR_EXPORT GLboolean __GLEW_EXT_clip_volume_hint; +GLEW_VAR_EXPORT GLboolean __GLEW_EXT_cmyka; +GLEW_VAR_EXPORT GLboolean __GLEW_EXT_color_subtable; +GLEW_VAR_EXPORT GLboolean __GLEW_EXT_compiled_vertex_array; +GLEW_VAR_EXPORT GLboolean __GLEW_EXT_convolution; +GLEW_VAR_EXPORT GLboolean __GLEW_EXT_coordinate_frame; +GLEW_VAR_EXPORT GLboolean __GLEW_EXT_copy_texture; +GLEW_VAR_EXPORT GLboolean __GLEW_EXT_cull_vertex; +GLEW_VAR_EXPORT GLboolean __GLEW_EXT_depth_bounds_test; +GLEW_VAR_EXPORT GLboolean __GLEW_EXT_direct_state_access; +GLEW_VAR_EXPORT GLboolean __GLEW_EXT_draw_buffers2; +GLEW_VAR_EXPORT GLboolean __GLEW_EXT_draw_instanced; +GLEW_VAR_EXPORT GLboolean __GLEW_EXT_draw_range_elements; +GLEW_VAR_EXPORT GLboolean __GLEW_EXT_fog_coord; +GLEW_VAR_EXPORT GLboolean __GLEW_EXT_fragment_lighting; +GLEW_VAR_EXPORT GLboolean __GLEW_EXT_framebuffer_blit; +GLEW_VAR_EXPORT GLboolean __GLEW_EXT_framebuffer_multisample; +GLEW_VAR_EXPORT GLboolean __GLEW_EXT_framebuffer_object; +GLEW_VAR_EXPORT GLboolean __GLEW_EXT_framebuffer_sRGB; +GLEW_VAR_EXPORT GLboolean __GLEW_EXT_geometry_shader4; +GLEW_VAR_EXPORT GLboolean __GLEW_EXT_gpu_program_parameters; +GLEW_VAR_EXPORT GLboolean __GLEW_EXT_gpu_shader4; +GLEW_VAR_EXPORT GLboolean __GLEW_EXT_histogram; +GLEW_VAR_EXPORT GLboolean __GLEW_EXT_index_array_formats; +GLEW_VAR_EXPORT GLboolean __GLEW_EXT_index_func; +GLEW_VAR_EXPORT GLboolean __GLEW_EXT_index_material; +GLEW_VAR_EXPORT GLboolean __GLEW_EXT_index_texture; +GLEW_VAR_EXPORT GLboolean __GLEW_EXT_light_texture; +GLEW_VAR_EXPORT GLboolean __GLEW_EXT_misc_attribute; +GLEW_VAR_EXPORT GLboolean __GLEW_EXT_multi_draw_arrays; +GLEW_VAR_EXPORT GLboolean __GLEW_EXT_multisample; +GLEW_VAR_EXPORT GLboolean __GLEW_EXT_packed_depth_stencil; +GLEW_VAR_EXPORT GLboolean __GLEW_EXT_packed_float; +GLEW_VAR_EXPORT GLboolean __GLEW_EXT_packed_pixels; +GLEW_VAR_EXPORT GLboolean __GLEW_EXT_paletted_texture; +GLEW_VAR_EXPORT GLboolean __GLEW_EXT_pixel_buffer_object; +GLEW_VAR_EXPORT GLboolean __GLEW_EXT_pixel_transform; +GLEW_VAR_EXPORT GLboolean __GLEW_EXT_pixel_transform_color_table; +GLEW_VAR_EXPORT GLboolean __GLEW_EXT_point_parameters; +GLEW_VAR_EXPORT GLboolean __GLEW_EXT_polygon_offset; +GLEW_VAR_EXPORT GLboolean __GLEW_EXT_rescale_normal; +GLEW_VAR_EXPORT GLboolean __GLEW_EXT_scene_marker; +GLEW_VAR_EXPORT GLboolean __GLEW_EXT_secondary_color; +GLEW_VAR_EXPORT GLboolean __GLEW_EXT_separate_specular_color; +GLEW_VAR_EXPORT GLboolean __GLEW_EXT_shadow_funcs; +GLEW_VAR_EXPORT GLboolean __GLEW_EXT_shared_texture_palette; +GLEW_VAR_EXPORT GLboolean __GLEW_EXT_stencil_clear_tag; +GLEW_VAR_EXPORT GLboolean __GLEW_EXT_stencil_two_side; +GLEW_VAR_EXPORT GLboolean __GLEW_EXT_stencil_wrap; +GLEW_VAR_EXPORT GLboolean __GLEW_EXT_subtexture; +GLEW_VAR_EXPORT GLboolean __GLEW_EXT_texture; +GLEW_VAR_EXPORT GLboolean __GLEW_EXT_texture3D; +GLEW_VAR_EXPORT GLboolean __GLEW_EXT_texture_array; +GLEW_VAR_EXPORT GLboolean __GLEW_EXT_texture_buffer_object; +GLEW_VAR_EXPORT GLboolean __GLEW_EXT_texture_compression_dxt1; +GLEW_VAR_EXPORT GLboolean __GLEW_EXT_texture_compression_latc; +GLEW_VAR_EXPORT GLboolean __GLEW_EXT_texture_compression_rgtc; +GLEW_VAR_EXPORT GLboolean __GLEW_EXT_texture_compression_s3tc; +GLEW_VAR_EXPORT GLboolean __GLEW_EXT_texture_cube_map; +GLEW_VAR_EXPORT GLboolean __GLEW_EXT_texture_edge_clamp; +GLEW_VAR_EXPORT GLboolean __GLEW_EXT_texture_env; +GLEW_VAR_EXPORT GLboolean __GLEW_EXT_texture_env_add; +GLEW_VAR_EXPORT GLboolean __GLEW_EXT_texture_env_combine; +GLEW_VAR_EXPORT GLboolean __GLEW_EXT_texture_env_dot3; +GLEW_VAR_EXPORT GLboolean __GLEW_EXT_texture_filter_anisotropic; +GLEW_VAR_EXPORT GLboolean __GLEW_EXT_texture_integer; +GLEW_VAR_EXPORT GLboolean __GLEW_EXT_texture_lod_bias; +GLEW_VAR_EXPORT GLboolean __GLEW_EXT_texture_mirror_clamp; +GLEW_VAR_EXPORT GLboolean __GLEW_EXT_texture_object; +GLEW_VAR_EXPORT GLboolean __GLEW_EXT_texture_perturb_normal; +GLEW_VAR_EXPORT GLboolean __GLEW_EXT_texture_rectangle; +GLEW_VAR_EXPORT GLboolean __GLEW_EXT_texture_sRGB; +GLEW_VAR_EXPORT GLboolean __GLEW_EXT_texture_shared_exponent; +GLEW_VAR_EXPORT GLboolean __GLEW_EXT_texture_swizzle; +GLEW_VAR_EXPORT GLboolean __GLEW_EXT_timer_query; +GLEW_VAR_EXPORT GLboolean __GLEW_EXT_transform_feedback; +GLEW_VAR_EXPORT GLboolean __GLEW_EXT_vertex_array; +GLEW_VAR_EXPORT GLboolean __GLEW_EXT_vertex_array_bgra; +GLEW_VAR_EXPORT GLboolean __GLEW_EXT_vertex_shader; +GLEW_VAR_EXPORT GLboolean __GLEW_EXT_vertex_weighting; +GLEW_VAR_EXPORT GLboolean __GLEW_GREMEDY_frame_terminator; +GLEW_VAR_EXPORT GLboolean __GLEW_GREMEDY_string_marker; +GLEW_VAR_EXPORT GLboolean __GLEW_HP_convolution_border_modes; +GLEW_VAR_EXPORT GLboolean __GLEW_HP_image_transform; +GLEW_VAR_EXPORT GLboolean __GLEW_HP_occlusion_test; +GLEW_VAR_EXPORT GLboolean __GLEW_HP_texture_lighting; +GLEW_VAR_EXPORT GLboolean __GLEW_IBM_cull_vertex; +GLEW_VAR_EXPORT GLboolean __GLEW_IBM_multimode_draw_arrays; +GLEW_VAR_EXPORT GLboolean __GLEW_IBM_rasterpos_clip; +GLEW_VAR_EXPORT GLboolean __GLEW_IBM_static_data; +GLEW_VAR_EXPORT GLboolean __GLEW_IBM_texture_mirrored_repeat; +GLEW_VAR_EXPORT GLboolean __GLEW_IBM_vertex_array_lists; +GLEW_VAR_EXPORT GLboolean __GLEW_INGR_color_clamp; +GLEW_VAR_EXPORT GLboolean __GLEW_INGR_interlace_read; +GLEW_VAR_EXPORT GLboolean __GLEW_INTEL_parallel_arrays; +GLEW_VAR_EXPORT GLboolean __GLEW_INTEL_texture_scissor; +GLEW_VAR_EXPORT GLboolean __GLEW_KTX_buffer_region; +GLEW_VAR_EXPORT GLboolean __GLEW_MESAX_texture_stack; +GLEW_VAR_EXPORT GLboolean __GLEW_MESA_pack_invert; +GLEW_VAR_EXPORT GLboolean __GLEW_MESA_resize_buffers; +GLEW_VAR_EXPORT GLboolean __GLEW_MESA_window_pos; +GLEW_VAR_EXPORT GLboolean __GLEW_MESA_ycbcr_texture; +GLEW_VAR_EXPORT GLboolean __GLEW_NV_blend_square; +GLEW_VAR_EXPORT GLboolean __GLEW_NV_conditional_render; +GLEW_VAR_EXPORT GLboolean __GLEW_NV_copy_depth_to_color; +GLEW_VAR_EXPORT GLboolean __GLEW_NV_depth_buffer_float; +GLEW_VAR_EXPORT GLboolean __GLEW_NV_depth_clamp; +GLEW_VAR_EXPORT GLboolean __GLEW_NV_depth_range_unclamped; +GLEW_VAR_EXPORT GLboolean __GLEW_NV_evaluators; +GLEW_VAR_EXPORT GLboolean __GLEW_NV_explicit_multisample; +GLEW_VAR_EXPORT GLboolean __GLEW_NV_fence; +GLEW_VAR_EXPORT GLboolean __GLEW_NV_float_buffer; +GLEW_VAR_EXPORT GLboolean __GLEW_NV_fog_distance; +GLEW_VAR_EXPORT GLboolean __GLEW_NV_fragment_program; +GLEW_VAR_EXPORT GLboolean __GLEW_NV_fragment_program2; +GLEW_VAR_EXPORT GLboolean __GLEW_NV_fragment_program4; +GLEW_VAR_EXPORT GLboolean __GLEW_NV_fragment_program_option; +GLEW_VAR_EXPORT GLboolean __GLEW_NV_framebuffer_multisample_coverage; +GLEW_VAR_EXPORT GLboolean __GLEW_NV_geometry_program4; +GLEW_VAR_EXPORT GLboolean __GLEW_NV_geometry_shader4; +GLEW_VAR_EXPORT GLboolean __GLEW_NV_gpu_program4; +GLEW_VAR_EXPORT GLboolean __GLEW_NV_half_float; +GLEW_VAR_EXPORT GLboolean __GLEW_NV_light_max_exponent; +GLEW_VAR_EXPORT GLboolean __GLEW_NV_multisample_filter_hint; +GLEW_VAR_EXPORT GLboolean __GLEW_NV_occlusion_query; +GLEW_VAR_EXPORT GLboolean __GLEW_NV_packed_depth_stencil; +GLEW_VAR_EXPORT GLboolean __GLEW_NV_parameter_buffer_object; +GLEW_VAR_EXPORT GLboolean __GLEW_NV_pixel_data_range; +GLEW_VAR_EXPORT GLboolean __GLEW_NV_point_sprite; +GLEW_VAR_EXPORT GLboolean __GLEW_NV_present_video; +GLEW_VAR_EXPORT GLboolean __GLEW_NV_primitive_restart; +GLEW_VAR_EXPORT GLboolean __GLEW_NV_register_combiners; +GLEW_VAR_EXPORT GLboolean __GLEW_NV_register_combiners2; +GLEW_VAR_EXPORT GLboolean __GLEW_NV_texgen_emboss; +GLEW_VAR_EXPORT GLboolean __GLEW_NV_texgen_reflection; +GLEW_VAR_EXPORT GLboolean __GLEW_NV_texture_compression_vtc; +GLEW_VAR_EXPORT GLboolean __GLEW_NV_texture_env_combine4; +GLEW_VAR_EXPORT GLboolean __GLEW_NV_texture_expand_normal; +GLEW_VAR_EXPORT GLboolean __GLEW_NV_texture_rectangle; +GLEW_VAR_EXPORT GLboolean __GLEW_NV_texture_shader; +GLEW_VAR_EXPORT GLboolean __GLEW_NV_texture_shader2; +GLEW_VAR_EXPORT GLboolean __GLEW_NV_texture_shader3; +GLEW_VAR_EXPORT GLboolean __GLEW_NV_transform_feedback; +GLEW_VAR_EXPORT GLboolean __GLEW_NV_vertex_array_range; +GLEW_VAR_EXPORT GLboolean __GLEW_NV_vertex_array_range2; +GLEW_VAR_EXPORT GLboolean __GLEW_NV_vertex_program; +GLEW_VAR_EXPORT GLboolean __GLEW_NV_vertex_program1_1; +GLEW_VAR_EXPORT GLboolean __GLEW_NV_vertex_program2; +GLEW_VAR_EXPORT GLboolean __GLEW_NV_vertex_program2_option; +GLEW_VAR_EXPORT GLboolean __GLEW_NV_vertex_program3; +GLEW_VAR_EXPORT GLboolean __GLEW_NV_vertex_program4; +GLEW_VAR_EXPORT GLboolean __GLEW_OES_byte_coordinates; +GLEW_VAR_EXPORT GLboolean __GLEW_OES_compressed_paletted_texture; +GLEW_VAR_EXPORT GLboolean __GLEW_OES_read_format; +GLEW_VAR_EXPORT GLboolean __GLEW_OES_single_precision; +GLEW_VAR_EXPORT GLboolean __GLEW_OML_interlace; +GLEW_VAR_EXPORT GLboolean __GLEW_OML_resample; +GLEW_VAR_EXPORT GLboolean __GLEW_OML_subsample; +GLEW_VAR_EXPORT GLboolean __GLEW_PGI_misc_hints; +GLEW_VAR_EXPORT GLboolean __GLEW_PGI_vertex_hints; +GLEW_VAR_EXPORT GLboolean __GLEW_REND_screen_coordinates; +GLEW_VAR_EXPORT GLboolean __GLEW_S3_s3tc; +GLEW_VAR_EXPORT GLboolean __GLEW_SGIS_color_range; +GLEW_VAR_EXPORT GLboolean __GLEW_SGIS_detail_texture; +GLEW_VAR_EXPORT GLboolean __GLEW_SGIS_fog_function; +GLEW_VAR_EXPORT GLboolean __GLEW_SGIS_generate_mipmap; +GLEW_VAR_EXPORT GLboolean __GLEW_SGIS_multisample; +GLEW_VAR_EXPORT GLboolean __GLEW_SGIS_pixel_texture; +GLEW_VAR_EXPORT GLboolean __GLEW_SGIS_point_line_texgen; +GLEW_VAR_EXPORT GLboolean __GLEW_SGIS_sharpen_texture; +GLEW_VAR_EXPORT GLboolean __GLEW_SGIS_texture4D; +GLEW_VAR_EXPORT GLboolean __GLEW_SGIS_texture_border_clamp; +GLEW_VAR_EXPORT GLboolean __GLEW_SGIS_texture_edge_clamp; +GLEW_VAR_EXPORT GLboolean __GLEW_SGIS_texture_filter4; +GLEW_VAR_EXPORT GLboolean __GLEW_SGIS_texture_lod; +GLEW_VAR_EXPORT GLboolean __GLEW_SGIS_texture_select; +GLEW_VAR_EXPORT GLboolean __GLEW_SGIX_async; +GLEW_VAR_EXPORT GLboolean __GLEW_SGIX_async_histogram; +GLEW_VAR_EXPORT GLboolean __GLEW_SGIX_async_pixel; +GLEW_VAR_EXPORT GLboolean __GLEW_SGIX_blend_alpha_minmax; +GLEW_VAR_EXPORT GLboolean __GLEW_SGIX_clipmap; +GLEW_VAR_EXPORT GLboolean __GLEW_SGIX_convolution_accuracy; +GLEW_VAR_EXPORT GLboolean __GLEW_SGIX_depth_texture; +GLEW_VAR_EXPORT GLboolean __GLEW_SGIX_flush_raster; +GLEW_VAR_EXPORT GLboolean __GLEW_SGIX_fog_offset; +GLEW_VAR_EXPORT GLboolean __GLEW_SGIX_fog_texture; +GLEW_VAR_EXPORT GLboolean __GLEW_SGIX_fragment_specular_lighting; +GLEW_VAR_EXPORT GLboolean __GLEW_SGIX_framezoom; +GLEW_VAR_EXPORT GLboolean __GLEW_SGIX_interlace; +GLEW_VAR_EXPORT GLboolean __GLEW_SGIX_ir_instrument1; +GLEW_VAR_EXPORT GLboolean __GLEW_SGIX_list_priority; +GLEW_VAR_EXPORT GLboolean __GLEW_SGIX_pixel_texture; +GLEW_VAR_EXPORT GLboolean __GLEW_SGIX_pixel_texture_bits; +GLEW_VAR_EXPORT GLboolean __GLEW_SGIX_reference_plane; +GLEW_VAR_EXPORT GLboolean __GLEW_SGIX_resample; +GLEW_VAR_EXPORT GLboolean __GLEW_SGIX_shadow; +GLEW_VAR_EXPORT GLboolean __GLEW_SGIX_shadow_ambient; +GLEW_VAR_EXPORT GLboolean __GLEW_SGIX_sprite; +GLEW_VAR_EXPORT GLboolean __GLEW_SGIX_tag_sample_buffer; +GLEW_VAR_EXPORT GLboolean __GLEW_SGIX_texture_add_env; +GLEW_VAR_EXPORT GLboolean __GLEW_SGIX_texture_coordinate_clamp; +GLEW_VAR_EXPORT GLboolean __GLEW_SGIX_texture_lod_bias; +GLEW_VAR_EXPORT GLboolean __GLEW_SGIX_texture_multi_buffer; +GLEW_VAR_EXPORT GLboolean __GLEW_SGIX_texture_range; +GLEW_VAR_EXPORT GLboolean __GLEW_SGIX_texture_scale_bias; +GLEW_VAR_EXPORT GLboolean __GLEW_SGIX_vertex_preclip; +GLEW_VAR_EXPORT GLboolean __GLEW_SGIX_vertex_preclip_hint; +GLEW_VAR_EXPORT GLboolean __GLEW_SGIX_ycrcb; +GLEW_VAR_EXPORT GLboolean __GLEW_SGI_color_matrix; +GLEW_VAR_EXPORT GLboolean __GLEW_SGI_color_table; +GLEW_VAR_EXPORT GLboolean __GLEW_SGI_texture_color_table; +GLEW_VAR_EXPORT GLboolean __GLEW_SUNX_constant_data; +GLEW_VAR_EXPORT GLboolean __GLEW_SUN_convolution_border_modes; +GLEW_VAR_EXPORT GLboolean __GLEW_SUN_global_alpha; +GLEW_VAR_EXPORT GLboolean __GLEW_SUN_mesh_array; +GLEW_VAR_EXPORT GLboolean __GLEW_SUN_read_video_pixels; +GLEW_VAR_EXPORT GLboolean __GLEW_SUN_slice_accum; +GLEW_VAR_EXPORT GLboolean __GLEW_SUN_triangle_list; +GLEW_VAR_EXPORT GLboolean __GLEW_SUN_vertex; +GLEW_VAR_EXPORT GLboolean __GLEW_WIN_phong_shading; +GLEW_VAR_EXPORT GLboolean __GLEW_WIN_specular_fog; +GLEW_VAR_EXPORT GLboolean __GLEW_WIN_swap_hint; + +#ifdef GLEW_MX +}; /* GLEWContextStruct */ +#endif /* GLEW_MX */ + +/* ------------------------------------------------------------------------- */ + +/* error codes */ +#define GLEW_OK 0 +#define GLEW_NO_ERROR 0 +#define GLEW_ERROR_NO_GL_VERSION 1 /* missing GL version */ +#define GLEW_ERROR_GL_VERSION_10_ONLY 2 /* GL 1.1 and up are not supported */ +#define GLEW_ERROR_GLX_VERSION_11_ONLY 3 /* GLX 1.2 and up are not supported */ + +/* string codes */ +#define GLEW_VERSION 1 +#define GLEW_VERSION_MAJOR 2 +#define GLEW_VERSION_MINOR 3 +#define GLEW_VERSION_MICRO 4 + +/* API */ +#ifdef GLEW_MX + +typedef struct GLEWContextStruct GLEWContext; +GLEWAPI GLenum glewContextInit (GLEWContext* ctx); +GLEWAPI GLboolean glewContextIsSupported (GLEWContext* ctx, const char* name); + +#define glewInit() glewContextInit(glewGetContext()) +#define glewIsSupported(x) glewContextIsSupported(glewGetContext(), x) +#define glewIsExtensionSupported(x) glewIsSupported(x) + +#define GLEW_GET_VAR(x) (*(const GLboolean*)&(glewGetContext()->x)) +#ifdef _WIN32 +# define GLEW_GET_FUN(x) glewGetContext()->x +#else +# define GLEW_GET_FUN(x) x +#endif + +#else /* GLEW_MX */ + +GLEWAPI GLenum glewInit (); +GLEWAPI GLboolean glewIsSupported (const char* name); +#define glewIsExtensionSupported(x) glewIsSupported(x) + +#define GLEW_GET_VAR(x) (*(const GLboolean*)&x) +#define GLEW_GET_FUN(x) x + +#endif /* GLEW_MX */ + +GLEWAPI GLboolean glewExperimental; +GLEWAPI GLboolean glewGetExtension (const char* name); +GLEWAPI const GLubyte* glewGetErrorString (GLenum error); +GLEWAPI const GLubyte* glewGetString (GLenum name); + +#ifdef __cplusplus +} +#endif + +#ifdef GLEW_APIENTRY_DEFINED +#undef GLEW_APIENTRY_DEFINED +#undef APIENTRY +#undef GLAPIENTRY +#endif + +#ifdef GLEW_CALLBACK_DEFINED +#undef GLEW_CALLBACK_DEFINED +#undef CALLBACK +#endif + +#ifdef GLEW_WINGDIAPI_DEFINED +#undef GLEW_WINGDIAPI_DEFINED +#undef WINGDIAPI +#endif + +#undef GLAPI +/* #undef GLEWAPI */ + +#endif /* __glew_h__ */ diff --git a/opengl/glext.h b/opengl/glext.h new file mode 100644 index 00000000..7bb8e6e7 --- /dev/null +++ b/opengl/glext.h @@ -0,0 +1,6495 @@ +#ifndef __glext_h_ +#define __glext_h_ + +#ifdef __cplusplus +extern "C" { +#endif + +/* +** License Applicability. Except to the extent portions of this file are +** made subject to an alternative license as permitted in the SGI Free +** Software License B, Version 1.1 (the "License"), the contents of this +** file are subject only to the provisions of the License. You may not use +** this file except in compliance with the License. You may obtain a copy +** of the License at Silicon Graphics, Inc., attn: Legal Services, 1600 +** Amphitheatre Parkway, Mountain View, CA 94043-1351, or at: +** +** http://oss.sgi.com/projects/FreeB +** +** Note that, as provided in the License, the Software is distributed on an +** "AS IS" basis, with ALL EXPRESS AND IMPLIED WARRANTIES AND CONDITIONS +** DISCLAIMED, INCLUDING, WITHOUT LIMITATION, ANY IMPLIED WARRANTIES AND +** CONDITIONS OF MERCHANTABILITY, SATISFACTORY QUALITY, FITNESS FOR A +** PARTICULAR PURPOSE, AND NON-INFRINGEMENT. +** +** Original Code. The Original Code is: OpenGL Sample Implementation, +** Version 1.2.1, released January 26, 2000, developed by Silicon Graphics, +** Inc. The Original Code is Copyright (c) 1991-2004 Silicon Graphics, Inc. +** Copyright in any portions created by third parties is as indicated +** elsewhere herein. All Rights Reserved. +** +** Additional Notice Provisions: This software was created using the +** OpenGL(R) version 1.2.1 Sample Implementation published by SGI, but has +** not been independently verified as being compliant with the OpenGL(R) +** version 1.2.1 Specification. +*/ + +#if defined(_WIN32) && !defined(APIENTRY) && !defined(__CYGWIN__) && !defined(__SCITECH_SNAP__) +#define WIN32_LEAN_AND_MEAN 1 +#include +#endif + +#ifndef APIENTRY +#define APIENTRY +#endif +#ifndef APIENTRYP +#define APIENTRYP APIENTRY * +#endif +#ifndef GLAPI +#define GLAPI extern +#endif + +/*************************************************************/ + +/* Header file version number, required by OpenGL ABI for Linux */ +/* glext.h last updated 2005/06/20 */ +/* Current version at http://oss.sgi.com/projects/ogl-sample/registry/ */ +#define GL_GLEXT_VERSION 29 + +#ifndef GL_VERSION_1_2 +#define GL_UNSIGNED_BYTE_3_3_2 0x8032 +#define GL_UNSIGNED_SHORT_4_4_4_4 0x8033 +#define GL_UNSIGNED_SHORT_5_5_5_1 0x8034 +#define GL_UNSIGNED_INT_8_8_8_8 0x8035 +#define GL_UNSIGNED_INT_10_10_10_2 0x8036 +#define GL_RESCALE_NORMAL 0x803A +#define GL_TEXTURE_BINDING_3D 0x806A +#define GL_PACK_SKIP_IMAGES 0x806B +#define GL_PACK_IMAGE_HEIGHT 0x806C +#define GL_UNPACK_SKIP_IMAGES 0x806D +#define GL_UNPACK_IMAGE_HEIGHT 0x806E +#define GL_TEXTURE_3D 0x806F +#define GL_PROXY_TEXTURE_3D 0x8070 +#define GL_TEXTURE_DEPTH 0x8071 +#define GL_TEXTURE_WRAP_R 0x8072 +#define GL_MAX_3D_TEXTURE_SIZE 0x8073 +#define GL_UNSIGNED_BYTE_2_3_3_REV 0x8362 +#define GL_UNSIGNED_SHORT_5_6_5 0x8363 +#define GL_UNSIGNED_SHORT_5_6_5_REV 0x8364 +#define GL_UNSIGNED_SHORT_4_4_4_4_REV 0x8365 +#define GL_UNSIGNED_SHORT_1_5_5_5_REV 0x8366 +#define GL_UNSIGNED_INT_8_8_8_8_REV 0x8367 +#define GL_UNSIGNED_INT_2_10_10_10_REV 0x8368 +#define GL_BGR 0x80E0 +#define GL_BGRA 0x80E1 +#define GL_MAX_ELEMENTS_VERTICES 0x80E8 +#define GL_MAX_ELEMENTS_INDICES 0x80E9 +#define GL_CLAMP_TO_EDGE 0x812F +#define GL_TEXTURE_MIN_LOD 0x813A +#define GL_TEXTURE_MAX_LOD 0x813B +#define GL_TEXTURE_BASE_LEVEL 0x813C +#define GL_TEXTURE_MAX_LEVEL 0x813D +#define GL_LIGHT_MODEL_COLOR_CONTROL 0x81F8 +#define GL_SINGLE_COLOR 0x81F9 +#define GL_SEPARATE_SPECULAR_COLOR 0x81FA +#define GL_SMOOTH_POINT_SIZE_RANGE 0x0B12 +#define GL_SMOOTH_POINT_SIZE_GRANULARITY 0x0B13 +#define GL_SMOOTH_LINE_WIDTH_RANGE 0x0B22 +#define GL_SMOOTH_LINE_WIDTH_GRANULARITY 0x0B23 +#define GL_ALIASED_POINT_SIZE_RANGE 0x846D +#define GL_ALIASED_LINE_WIDTH_RANGE 0x846E +#endif + +#ifndef GL_ARB_imaging +#define GL_CONSTANT_COLOR 0x8001 +#define GL_ONE_MINUS_CONSTANT_COLOR 0x8002 +#define GL_CONSTANT_ALPHA 0x8003 +#define GL_ONE_MINUS_CONSTANT_ALPHA 0x8004 +#define GL_BLEND_COLOR 0x8005 +#define GL_FUNC_ADD 0x8006 +#define GL_MIN 0x8007 +#define GL_MAX 0x8008 +#define GL_BLEND_EQUATION 0x8009 +#define GL_FUNC_SUBTRACT 0x800A +#define GL_FUNC_REVERSE_SUBTRACT 0x800B +#define GL_CONVOLUTION_1D 0x8010 +#define GL_CONVOLUTION_2D 0x8011 +#define GL_SEPARABLE_2D 0x8012 +#define GL_CONVOLUTION_BORDER_MODE 0x8013 +#define GL_CONVOLUTION_FILTER_SCALE 0x8014 +#define GL_CONVOLUTION_FILTER_BIAS 0x8015 +#define GL_REDUCE 0x8016 +#define GL_CONVOLUTION_FORMAT 0x8017 +#define GL_CONVOLUTION_WIDTH 0x8018 +#define GL_CONVOLUTION_HEIGHT 0x8019 +#define GL_MAX_CONVOLUTION_WIDTH 0x801A +#define GL_MAX_CONVOLUTION_HEIGHT 0x801B +#define GL_POST_CONVOLUTION_RED_SCALE 0x801C +#define GL_POST_CONVOLUTION_GREEN_SCALE 0x801D +#define GL_POST_CONVOLUTION_BLUE_SCALE 0x801E +#define GL_POST_CONVOLUTION_ALPHA_SCALE 0x801F +#define GL_POST_CONVOLUTION_RED_BIAS 0x8020 +#define GL_POST_CONVOLUTION_GREEN_BIAS 0x8021 +#define GL_POST_CONVOLUTION_BLUE_BIAS 0x8022 +#define GL_POST_CONVOLUTION_ALPHA_BIAS 0x8023 +#define GL_HISTOGRAM 0x8024 +#define GL_PROXY_HISTOGRAM 0x8025 +#define GL_HISTOGRAM_WIDTH 0x8026 +#define GL_HISTOGRAM_FORMAT 0x8027 +#define GL_HISTOGRAM_RED_SIZE 0x8028 +#define GL_HISTOGRAM_GREEN_SIZE 0x8029 +#define GL_HISTOGRAM_BLUE_SIZE 0x802A +#define GL_HISTOGRAM_ALPHA_SIZE 0x802B +#define GL_HISTOGRAM_LUMINANCE_SIZE 0x802C +#define GL_HISTOGRAM_SINK 0x802D +#define GL_MINMAX 0x802E +#define GL_MINMAX_FORMAT 0x802F +#define GL_MINMAX_SINK 0x8030 +#define GL_TABLE_TOO_LARGE 0x8031 +#define GL_COLOR_MATRIX 0x80B1 +#define GL_COLOR_MATRIX_STACK_DEPTH 0x80B2 +#define GL_MAX_COLOR_MATRIX_STACK_DEPTH 0x80B3 +#define GL_POST_COLOR_MATRIX_RED_SCALE 0x80B4 +#define GL_POST_COLOR_MATRIX_GREEN_SCALE 0x80B5 +#define GL_POST_COLOR_MATRIX_BLUE_SCALE 0x80B6 +#define GL_POST_COLOR_MATRIX_ALPHA_SCALE 0x80B7 +#define GL_POST_COLOR_MATRIX_RED_BIAS 0x80B8 +#define GL_POST_COLOR_MATRIX_GREEN_BIAS 0x80B9 +#define GL_POST_COLOR_MATRIX_BLUE_BIAS 0x80BA +#define GL_POST_COLOR_MATRIX_ALPHA_BIAS 0x80BB +#define GL_COLOR_TABLE 0x80D0 +#define GL_POST_CONVOLUTION_COLOR_TABLE 0x80D1 +#define GL_POST_COLOR_MATRIX_COLOR_TABLE 0x80D2 +#define GL_PROXY_COLOR_TABLE 0x80D3 +#define GL_PROXY_POST_CONVOLUTION_COLOR_TABLE 0x80D4 +#define GL_PROXY_POST_COLOR_MATRIX_COLOR_TABLE 0x80D5 +#define GL_COLOR_TABLE_SCALE 0x80D6 +#define GL_COLOR_TABLE_BIAS 0x80D7 +#define GL_COLOR_TABLE_FORMAT 0x80D8 +#define GL_COLOR_TABLE_WIDTH 0x80D9 +#define GL_COLOR_TABLE_RED_SIZE 0x80DA +#define GL_COLOR_TABLE_GREEN_SIZE 0x80DB +#define GL_COLOR_TABLE_BLUE_SIZE 0x80DC +#define GL_COLOR_TABLE_ALPHA_SIZE 0x80DD +#define GL_COLOR_TABLE_LUMINANCE_SIZE 0x80DE +#define GL_COLOR_TABLE_INTENSITY_SIZE 0x80DF +#define GL_CONSTANT_BORDER 0x8151 +#define GL_REPLICATE_BORDER 0x8153 +#define GL_CONVOLUTION_BORDER_COLOR 0x8154 +#endif + +#ifndef GL_VERSION_1_3 +#define GL_TEXTURE0 0x84C0 +#define GL_TEXTURE1 0x84C1 +#define GL_TEXTURE2 0x84C2 +#define GL_TEXTURE3 0x84C3 +#define GL_TEXTURE4 0x84C4 +#define GL_TEXTURE5 0x84C5 +#define GL_TEXTURE6 0x84C6 +#define GL_TEXTURE7 0x84C7 +#define GL_TEXTURE8 0x84C8 +#define GL_TEXTURE9 0x84C9 +#define GL_TEXTURE10 0x84CA +#define GL_TEXTURE11 0x84CB +#define GL_TEXTURE12 0x84CC +#define GL_TEXTURE13 0x84CD +#define GL_TEXTURE14 0x84CE +#define GL_TEXTURE15 0x84CF +#define GL_TEXTURE16 0x84D0 +#define GL_TEXTURE17 0x84D1 +#define GL_TEXTURE18 0x84D2 +#define GL_TEXTURE19 0x84D3 +#define GL_TEXTURE20 0x84D4 +#define GL_TEXTURE21 0x84D5 +#define GL_TEXTURE22 0x84D6 +#define GL_TEXTURE23 0x84D7 +#define GL_TEXTURE24 0x84D8 +#define GL_TEXTURE25 0x84D9 +#define GL_TEXTURE26 0x84DA +#define GL_TEXTURE27 0x84DB +#define GL_TEXTURE28 0x84DC +#define GL_TEXTURE29 0x84DD +#define GL_TEXTURE30 0x84DE +#define GL_TEXTURE31 0x84DF +#define GL_ACTIVE_TEXTURE 0x84E0 +#define GL_CLIENT_ACTIVE_TEXTURE 0x84E1 +#define GL_MAX_TEXTURE_UNITS 0x84E2 +#define GL_TRANSPOSE_MODELVIEW_MATRIX 0x84E3 +#define GL_TRANSPOSE_PROJECTION_MATRIX 0x84E4 +#define GL_TRANSPOSE_TEXTURE_MATRIX 0x84E5 +#define GL_TRANSPOSE_COLOR_MATRIX 0x84E6 +#define GL_MULTISAMPLE 0x809D +#define GL_SAMPLE_ALPHA_TO_COVERAGE 0x809E +#define GL_SAMPLE_ALPHA_TO_ONE 0x809F +#define GL_SAMPLE_COVERAGE 0x80A0 +#define GL_SAMPLE_BUFFERS 0x80A8 +#define GL_SAMPLES 0x80A9 +#define GL_SAMPLE_COVERAGE_VALUE 0x80AA +#define GL_SAMPLE_COVERAGE_INVERT 0x80AB +#define GL_MULTISAMPLE_BIT 0x20000000 +#define GL_NORMAL_MAP 0x8511 +#define GL_REFLECTION_MAP 0x8512 +#define GL_TEXTURE_CUBE_MAP 0x8513 +#define GL_TEXTURE_BINDING_CUBE_MAP 0x8514 +#define GL_TEXTURE_CUBE_MAP_POSITIVE_X 0x8515 +#define GL_TEXTURE_CUBE_MAP_NEGATIVE_X 0x8516 +#define GL_TEXTURE_CUBE_MAP_POSITIVE_Y 0x8517 +#define GL_TEXTURE_CUBE_MAP_NEGATIVE_Y 0x8518 +#define GL_TEXTURE_CUBE_MAP_POSITIVE_Z 0x8519 +#define GL_TEXTURE_CUBE_MAP_NEGATIVE_Z 0x851A +#define GL_PROXY_TEXTURE_CUBE_MAP 0x851B +#define GL_MAX_CUBE_MAP_TEXTURE_SIZE 0x851C +#define GL_COMPRESSED_ALPHA 0x84E9 +#define GL_COMPRESSED_LUMINANCE 0x84EA +#define GL_COMPRESSED_LUMINANCE_ALPHA 0x84EB +#define GL_COMPRESSED_INTENSITY 0x84EC +#define GL_COMPRESSED_RGB 0x84ED +#define GL_COMPRESSED_RGBA 0x84EE +#define GL_TEXTURE_COMPRESSION_HINT 0x84EF +#define GL_TEXTURE_COMPRESSED_IMAGE_SIZE 0x86A0 +#define GL_TEXTURE_COMPRESSED 0x86A1 +#define GL_NUM_COMPRESSED_TEXTURE_FORMATS 0x86A2 +#define GL_COMPRESSED_TEXTURE_FORMATS 0x86A3 +#define GL_CLAMP_TO_BORDER 0x812D +#define GL_COMBINE 0x8570 +#define GL_COMBINE_RGB 0x8571 +#define GL_COMBINE_ALPHA 0x8572 +#define GL_SOURCE0_RGB 0x8580 +#define GL_SOURCE1_RGB 0x8581 +#define GL_SOURCE2_RGB 0x8582 +#define GL_SOURCE0_ALPHA 0x8588 +#define GL_SOURCE1_ALPHA 0x8589 +#define GL_SOURCE2_ALPHA 0x858A +#define GL_OPERAND0_RGB 0x8590 +#define GL_OPERAND1_RGB 0x8591 +#define GL_OPERAND2_RGB 0x8592 +#define GL_OPERAND0_ALPHA 0x8598 +#define GL_OPERAND1_ALPHA 0x8599 +#define GL_OPERAND2_ALPHA 0x859A +#define GL_RGB_SCALE 0x8573 +#define GL_ADD_SIGNED 0x8574 +#define GL_INTERPOLATE 0x8575 +#define GL_SUBTRACT 0x84E7 +#define GL_CONSTANT 0x8576 +#define GL_PRIMARY_COLOR 0x8577 +#define GL_PREVIOUS 0x8578 +#define GL_DOT3_RGB 0x86AE +#define GL_DOT3_RGBA 0x86AF +#endif + +#ifndef GL_VERSION_1_4 +#define GL_BLEND_DST_RGB 0x80C8 +#define GL_BLEND_SRC_RGB 0x80C9 +#define GL_BLEND_DST_ALPHA 0x80CA +#define GL_BLEND_SRC_ALPHA 0x80CB +#define GL_POINT_SIZE_MIN 0x8126 +#define GL_POINT_SIZE_MAX 0x8127 +#define GL_POINT_FADE_THRESHOLD_SIZE 0x8128 +#define GL_POINT_DISTANCE_ATTENUATION 0x8129 +#define GL_GENERATE_MIPMAP 0x8191 +#define GL_GENERATE_MIPMAP_HINT 0x8192 +#define GL_DEPTH_COMPONENT16 0x81A5 +#define GL_DEPTH_COMPONENT24 0x81A6 +#define GL_DEPTH_COMPONENT32 0x81A7 +#define GL_MIRRORED_REPEAT 0x8370 +#define GL_FOG_COORDINATE_SOURCE 0x8450 +#define GL_FOG_COORDINATE 0x8451 +#define GL_FRAGMENT_DEPTH 0x8452 +#define GL_CURRENT_FOG_COORDINATE 0x8453 +#define GL_FOG_COORDINATE_ARRAY_TYPE 0x8454 +#define GL_FOG_COORDINATE_ARRAY_STRIDE 0x8455 +#define GL_FOG_COORDINATE_ARRAY_POINTER 0x8456 +#define GL_FOG_COORDINATE_ARRAY 0x8457 +#define GL_COLOR_SUM 0x8458 +#define GL_CURRENT_SECONDARY_COLOR 0x8459 +#define GL_SECONDARY_COLOR_ARRAY_SIZE 0x845A +#define GL_SECONDARY_COLOR_ARRAY_TYPE 0x845B +#define GL_SECONDARY_COLOR_ARRAY_STRIDE 0x845C +#define GL_SECONDARY_COLOR_ARRAY_POINTER 0x845D +#define GL_SECONDARY_COLOR_ARRAY 0x845E +#define GL_MAX_TEXTURE_LOD_BIAS 0x84FD +#define GL_TEXTURE_FILTER_CONTROL 0x8500 +#define GL_TEXTURE_LOD_BIAS 0x8501 +#define GL_INCR_WRAP 0x8507 +#define GL_DECR_WRAP 0x8508 +#define GL_TEXTURE_DEPTH_SIZE 0x884A +#define GL_DEPTH_TEXTURE_MODE 0x884B +#define GL_TEXTURE_COMPARE_MODE 0x884C +#define GL_TEXTURE_COMPARE_FUNC 0x884D +#define GL_COMPARE_R_TO_TEXTURE 0x884E +#endif + +#ifndef GL_VERSION_1_5 +#define GL_BUFFER_SIZE 0x8764 +#define GL_BUFFER_USAGE 0x8765 +#define GL_QUERY_COUNTER_BITS 0x8864 +#define GL_CURRENT_QUERY 0x8865 +#define GL_QUERY_RESULT 0x8866 +#define GL_QUERY_RESULT_AVAILABLE 0x8867 +#define GL_ARRAY_BUFFER 0x8892 +#define GL_ELEMENT_ARRAY_BUFFER 0x8893 +#define GL_ARRAY_BUFFER_BINDING 0x8894 +#define GL_ELEMENT_ARRAY_BUFFER_BINDING 0x8895 +#define GL_VERTEX_ARRAY_BUFFER_BINDING 0x8896 +#define GL_NORMAL_ARRAY_BUFFER_BINDING 0x8897 +#define GL_COLOR_ARRAY_BUFFER_BINDING 0x8898 +#define GL_INDEX_ARRAY_BUFFER_BINDING 0x8899 +#define GL_TEXTURE_COORD_ARRAY_BUFFER_BINDING 0x889A +#define GL_EDGE_FLAG_ARRAY_BUFFER_BINDING 0x889B +#define GL_SECONDARY_COLOR_ARRAY_BUFFER_BINDING 0x889C +#define GL_FOG_COORDINATE_ARRAY_BUFFER_BINDING 0x889D +#define GL_WEIGHT_ARRAY_BUFFER_BINDING 0x889E +#define GL_VERTEX_ATTRIB_ARRAY_BUFFER_BINDING 0x889F +#define GL_READ_ONLY 0x88B8 +#define GL_WRITE_ONLY 0x88B9 +#define GL_READ_WRITE 0x88BA +#define GL_BUFFER_ACCESS 0x88BB +#define GL_BUFFER_MAPPED 0x88BC +#define GL_BUFFER_MAP_POINTER 0x88BD +#define GL_STREAM_DRAW 0x88E0 +#define GL_STREAM_READ 0x88E1 +#define GL_STREAM_COPY 0x88E2 +#define GL_STATIC_DRAW 0x88E4 +#define GL_STATIC_READ 0x88E5 +#define GL_STATIC_COPY 0x88E6 +#define GL_DYNAMIC_DRAW 0x88E8 +#define GL_DYNAMIC_READ 0x88E9 +#define GL_DYNAMIC_COPY 0x88EA +#define GL_SAMPLES_PASSED 0x8914 +#define GL_FOG_COORD_SRC GL_FOG_COORDINATE_SOURCE +#define GL_FOG_COORD GL_FOG_COORDINATE +#define GL_CURRENT_FOG_COORD GL_CURRENT_FOG_COORDINATE +#define GL_FOG_COORD_ARRAY_TYPE GL_FOG_COORDINATE_ARRAY_TYPE +#define GL_FOG_COORD_ARRAY_STRIDE GL_FOG_COORDINATE_ARRAY_STRIDE +#define GL_FOG_COORD_ARRAY_POINTER GL_FOG_COORDINATE_ARRAY_POINTER +#define GL_FOG_COORD_ARRAY GL_FOG_COORDINATE_ARRAY +#define GL_FOG_COORD_ARRAY_BUFFER_BINDING GL_FOG_COORDINATE_ARRAY_BUFFER_BINDING +#define GL_SRC0_RGB GL_SOURCE0_RGB +#define GL_SRC1_RGB GL_SOURCE1_RGB +#define GL_SRC2_RGB GL_SOURCE2_RGB +#define GL_SRC0_ALPHA GL_SOURCE0_ALPHA +#define GL_SRC1_ALPHA GL_SOURCE1_ALPHA +#define GL_SRC2_ALPHA GL_SOURCE2_ALPHA +#endif + +#ifndef GL_VERSION_2_0 +#define GL_BLEND_EQUATION_RGB GL_BLEND_EQUATION +#define GL_VERTEX_ATTRIB_ARRAY_ENABLED 0x8622 +#define GL_VERTEX_ATTRIB_ARRAY_SIZE 0x8623 +#define GL_VERTEX_ATTRIB_ARRAY_STRIDE 0x8624 +#define GL_VERTEX_ATTRIB_ARRAY_TYPE 0x8625 +#define GL_CURRENT_VERTEX_ATTRIB 0x8626 +#define GL_VERTEX_PROGRAM_POINT_SIZE 0x8642 +#define GL_VERTEX_PROGRAM_TWO_SIDE 0x8643 +#define GL_VERTEX_ATTRIB_ARRAY_POINTER 0x8645 +#define GL_STENCIL_BACK_FUNC 0x8800 +#define GL_STENCIL_BACK_FAIL 0x8801 +#define GL_STENCIL_BACK_PASS_DEPTH_FAIL 0x8802 +#define GL_STENCIL_BACK_PASS_DEPTH_PASS 0x8803 +#define GL_MAX_DRAW_BUFFERS 0x8824 +#define GL_DRAW_BUFFER0 0x8825 +#define GL_DRAW_BUFFER1 0x8826 +#define GL_DRAW_BUFFER2 0x8827 +#define GL_DRAW_BUFFER3 0x8828 +#define GL_DRAW_BUFFER4 0x8829 +#define GL_DRAW_BUFFER5 0x882A +#define GL_DRAW_BUFFER6 0x882B +#define GL_DRAW_BUFFER7 0x882C +#define GL_DRAW_BUFFER8 0x882D +#define GL_DRAW_BUFFER9 0x882E +#define GL_DRAW_BUFFER10 0x882F +#define GL_DRAW_BUFFER11 0x8830 +#define GL_DRAW_BUFFER12 0x8831 +#define GL_DRAW_BUFFER13 0x8832 +#define GL_DRAW_BUFFER14 0x8833 +#define GL_DRAW_BUFFER15 0x8834 +#define GL_BLEND_EQUATION_ALPHA 0x883D +#define GL_POINT_SPRITE 0x8861 +#define GL_COORD_REPLACE 0x8862 +#define GL_MAX_VERTEX_ATTRIBS 0x8869 +#define GL_VERTEX_ATTRIB_ARRAY_NORMALIZED 0x886A +#define GL_MAX_TEXTURE_COORDS 0x8871 +#define GL_MAX_TEXTURE_IMAGE_UNITS 0x8872 +#define GL_FRAGMENT_SHADER 0x8B30 +#define GL_VERTEX_SHADER 0x8B31 +#define GL_MAX_FRAGMENT_UNIFORM_COMPONENTS 0x8B49 +#define GL_MAX_VERTEX_UNIFORM_COMPONENTS 0x8B4A +#define GL_MAX_VARYING_FLOATS 0x8B4B +#define GL_MAX_VERTEX_TEXTURE_IMAGE_UNITS 0x8B4C +#define GL_MAX_COMBINED_TEXTURE_IMAGE_UNITS 0x8B4D +#define GL_SHADER_TYPE 0x8B4F +#define GL_FLOAT_VEC2 0x8B50 +#define GL_FLOAT_VEC3 0x8B51 +#define GL_FLOAT_VEC4 0x8B52 +#define GL_INT_VEC2 0x8B53 +#define GL_INT_VEC3 0x8B54 +#define GL_INT_VEC4 0x8B55 +#define GL_BOOL 0x8B56 +#define GL_BOOL_VEC2 0x8B57 +#define GL_BOOL_VEC3 0x8B58 +#define GL_BOOL_VEC4 0x8B59 +#define GL_FLOAT_MAT2 0x8B5A +#define GL_FLOAT_MAT3 0x8B5B +#define GL_FLOAT_MAT4 0x8B5C +#define GL_SAMPLER_1D 0x8B5D +#define GL_SAMPLER_2D 0x8B5E +#define GL_SAMPLER_3D 0x8B5F +#define GL_SAMPLER_CUBE 0x8B60 +#define GL_SAMPLER_1D_SHADOW 0x8B61 +#define GL_SAMPLER_2D_SHADOW 0x8B62 +#define GL_DELETE_STATUS 0x8B80 +#define GL_COMPILE_STATUS 0x8B81 +#define GL_LINK_STATUS 0x8B82 +#define GL_VALIDATE_STATUS 0x8B83 +#define GL_INFO_LOG_LENGTH 0x8B84 +#define GL_ATTACHED_SHADERS 0x8B85 +#define GL_ACTIVE_UNIFORMS 0x8B86 +#define GL_ACTIVE_UNIFORM_MAX_LENGTH 0x8B87 +#define GL_SHADER_SOURCE_LENGTH 0x8B88 +#define GL_ACTIVE_ATTRIBUTES 0x8B89 +#define GL_ACTIVE_ATTRIBUTE_MAX_LENGTH 0x8B8A +#define GL_FRAGMENT_SHADER_DERIVATIVE_HINT 0x8B8B +#define GL_SHADING_LANGUAGE_VERSION 0x8B8C +#define GL_CURRENT_PROGRAM 0x8B8D +#define GL_POINT_SPRITE_COORD_ORIGIN 0x8CA0 +#define GL_LOWER_LEFT 0x8CA1 +#define GL_UPPER_LEFT 0x8CA2 +#define GL_STENCIL_BACK_REF 0x8CA3 +#define GL_STENCIL_BACK_VALUE_MASK 0x8CA4 +#define GL_STENCIL_BACK_WRITEMASK 0x8CA5 +#endif + +#ifndef GL_ARB_multitexture +#define GL_TEXTURE0_ARB 0x84C0 +#define GL_TEXTURE1_ARB 0x84C1 +#define GL_TEXTURE2_ARB 0x84C2 +#define GL_TEXTURE3_ARB 0x84C3 +#define GL_TEXTURE4_ARB 0x84C4 +#define GL_TEXTURE5_ARB 0x84C5 +#define GL_TEXTURE6_ARB 0x84C6 +#define GL_TEXTURE7_ARB 0x84C7 +#define GL_TEXTURE8_ARB 0x84C8 +#define GL_TEXTURE9_ARB 0x84C9 +#define GL_TEXTURE10_ARB 0x84CA +#define GL_TEXTURE11_ARB 0x84CB +#define GL_TEXTURE12_ARB 0x84CC +#define GL_TEXTURE13_ARB 0x84CD +#define GL_TEXTURE14_ARB 0x84CE +#define GL_TEXTURE15_ARB 0x84CF +#define GL_TEXTURE16_ARB 0x84D0 +#define GL_TEXTURE17_ARB 0x84D1 +#define GL_TEXTURE18_ARB 0x84D2 +#define GL_TEXTURE19_ARB 0x84D3 +#define GL_TEXTURE20_ARB 0x84D4 +#define GL_TEXTURE21_ARB 0x84D5 +#define GL_TEXTURE22_ARB 0x84D6 +#define GL_TEXTURE23_ARB 0x84D7 +#define GL_TEXTURE24_ARB 0x84D8 +#define GL_TEXTURE25_ARB 0x84D9 +#define GL_TEXTURE26_ARB 0x84DA +#define GL_TEXTURE27_ARB 0x84DB +#define GL_TEXTURE28_ARB 0x84DC +#define GL_TEXTURE29_ARB 0x84DD +#define GL_TEXTURE30_ARB 0x84DE +#define GL_TEXTURE31_ARB 0x84DF +#define GL_ACTIVE_TEXTURE_ARB 0x84E0 +#define GL_CLIENT_ACTIVE_TEXTURE_ARB 0x84E1 +#define GL_MAX_TEXTURE_UNITS_ARB 0x84E2 +#endif + +#ifndef GL_ARB_transpose_matrix +#define GL_TRANSPOSE_MODELVIEW_MATRIX_ARB 0x84E3 +#define GL_TRANSPOSE_PROJECTION_MATRIX_ARB 0x84E4 +#define GL_TRANSPOSE_TEXTURE_MATRIX_ARB 0x84E5 +#define GL_TRANSPOSE_COLOR_MATRIX_ARB 0x84E6 +#endif + +#ifndef GL_ARB_multisample +#define GL_MULTISAMPLE_ARB 0x809D +#define GL_SAMPLE_ALPHA_TO_COVERAGE_ARB 0x809E +#define GL_SAMPLE_ALPHA_TO_ONE_ARB 0x809F +#define GL_SAMPLE_COVERAGE_ARB 0x80A0 +#define GL_SAMPLE_BUFFERS_ARB 0x80A8 +#define GL_SAMPLES_ARB 0x80A9 +#define GL_SAMPLE_COVERAGE_VALUE_ARB 0x80AA +#define GL_SAMPLE_COVERAGE_INVERT_ARB 0x80AB +#define GL_MULTISAMPLE_BIT_ARB 0x20000000 +#endif + +#ifndef GL_ARB_texture_env_add +#endif + +#ifndef GL_ARB_texture_cube_map +#define GL_NORMAL_MAP_ARB 0x8511 +#define GL_REFLECTION_MAP_ARB 0x8512 +#define GL_TEXTURE_CUBE_MAP_ARB 0x8513 +#define GL_TEXTURE_BINDING_CUBE_MAP_ARB 0x8514 +#define GL_TEXTURE_CUBE_MAP_POSITIVE_X_ARB 0x8515 +#define GL_TEXTURE_CUBE_MAP_NEGATIVE_X_ARB 0x8516 +#define GL_TEXTURE_CUBE_MAP_POSITIVE_Y_ARB 0x8517 +#define GL_TEXTURE_CUBE_MAP_NEGATIVE_Y_ARB 0x8518 +#define GL_TEXTURE_CUBE_MAP_POSITIVE_Z_ARB 0x8519 +#define GL_TEXTURE_CUBE_MAP_NEGATIVE_Z_ARB 0x851A +#define GL_PROXY_TEXTURE_CUBE_MAP_ARB 0x851B +#define GL_MAX_CUBE_MAP_TEXTURE_SIZE_ARB 0x851C +#endif + +#ifndef GL_ARB_texture_compression +#define GL_COMPRESSED_ALPHA_ARB 0x84E9 +#define GL_COMPRESSED_LUMINANCE_ARB 0x84EA +#define GL_COMPRESSED_LUMINANCE_ALPHA_ARB 0x84EB +#define GL_COMPRESSED_INTENSITY_ARB 0x84EC +#define GL_COMPRESSED_RGB_ARB 0x84ED +#define GL_COMPRESSED_RGBA_ARB 0x84EE +#define GL_TEXTURE_COMPRESSION_HINT_ARB 0x84EF +#define GL_TEXTURE_COMPRESSED_IMAGE_SIZE_ARB 0x86A0 +#define GL_TEXTURE_COMPRESSED_ARB 0x86A1 +#define GL_NUM_COMPRESSED_TEXTURE_FORMATS_ARB 0x86A2 +#define GL_COMPRESSED_TEXTURE_FORMATS_ARB 0x86A3 +#endif + +#ifndef GL_ARB_texture_border_clamp +#define GL_CLAMP_TO_BORDER_ARB 0x812D +#endif + +#ifndef GL_ARB_point_parameters +#define GL_POINT_SIZE_MIN_ARB 0x8126 +#define GL_POINT_SIZE_MAX_ARB 0x8127 +#define GL_POINT_FADE_THRESHOLD_SIZE_ARB 0x8128 +#define GL_POINT_DISTANCE_ATTENUATION_ARB 0x8129 +#endif + +#ifndef GL_ARB_vertex_blend +#define GL_MAX_VERTEX_UNITS_ARB 0x86A4 +#define GL_ACTIVE_VERTEX_UNITS_ARB 0x86A5 +#define GL_WEIGHT_SUM_UNITY_ARB 0x86A6 +#define GL_VERTEX_BLEND_ARB 0x86A7 +#define GL_CURRENT_WEIGHT_ARB 0x86A8 +#define GL_WEIGHT_ARRAY_TYPE_ARB 0x86A9 +#define GL_WEIGHT_ARRAY_STRIDE_ARB 0x86AA +#define GL_WEIGHT_ARRAY_SIZE_ARB 0x86AB +#define GL_WEIGHT_ARRAY_POINTER_ARB 0x86AC +#define GL_WEIGHT_ARRAY_ARB 0x86AD +#define GL_MODELVIEW0_ARB 0x1700 +#define GL_MODELVIEW1_ARB 0x850A +#define GL_MODELVIEW2_ARB 0x8722 +#define GL_MODELVIEW3_ARB 0x8723 +#define GL_MODELVIEW4_ARB 0x8724 +#define GL_MODELVIEW5_ARB 0x8725 +#define GL_MODELVIEW6_ARB 0x8726 +#define GL_MODELVIEW7_ARB 0x8727 +#define GL_MODELVIEW8_ARB 0x8728 +#define GL_MODELVIEW9_ARB 0x8729 +#define GL_MODELVIEW10_ARB 0x872A +#define GL_MODELVIEW11_ARB 0x872B +#define GL_MODELVIEW12_ARB 0x872C +#define GL_MODELVIEW13_ARB 0x872D +#define GL_MODELVIEW14_ARB 0x872E +#define GL_MODELVIEW15_ARB 0x872F +#define GL_MODELVIEW16_ARB 0x8730 +#define GL_MODELVIEW17_ARB 0x8731 +#define GL_MODELVIEW18_ARB 0x8732 +#define GL_MODELVIEW19_ARB 0x8733 +#define GL_MODELVIEW20_ARB 0x8734 +#define GL_MODELVIEW21_ARB 0x8735 +#define GL_MODELVIEW22_ARB 0x8736 +#define GL_MODELVIEW23_ARB 0x8737 +#define GL_MODELVIEW24_ARB 0x8738 +#define GL_MODELVIEW25_ARB 0x8739 +#define GL_MODELVIEW26_ARB 0x873A +#define GL_MODELVIEW27_ARB 0x873B +#define GL_MODELVIEW28_ARB 0x873C +#define GL_MODELVIEW29_ARB 0x873D +#define GL_MODELVIEW30_ARB 0x873E +#define GL_MODELVIEW31_ARB 0x873F +#endif + +#ifndef GL_ARB_matrix_palette +#define GL_MATRIX_PALETTE_ARB 0x8840 +#define GL_MAX_MATRIX_PALETTE_STACK_DEPTH_ARB 0x8841 +#define GL_MAX_PALETTE_MATRICES_ARB 0x8842 +#define GL_CURRENT_PALETTE_MATRIX_ARB 0x8843 +#define GL_MATRIX_INDEX_ARRAY_ARB 0x8844 +#define GL_CURRENT_MATRIX_INDEX_ARB 0x8845 +#define GL_MATRIX_INDEX_ARRAY_SIZE_ARB 0x8846 +#define GL_MATRIX_INDEX_ARRAY_TYPE_ARB 0x8847 +#define GL_MATRIX_INDEX_ARRAY_STRIDE_ARB 0x8848 +#define GL_MATRIX_INDEX_ARRAY_POINTER_ARB 0x8849 +#endif + +#ifndef GL_ARB_texture_env_combine +#define GL_COMBINE_ARB 0x8570 +#define GL_COMBINE_RGB_ARB 0x8571 +#define GL_COMBINE_ALPHA_ARB 0x8572 +#define GL_SOURCE0_RGB_ARB 0x8580 +#define GL_SOURCE1_RGB_ARB 0x8581 +#define GL_SOURCE2_RGB_ARB 0x8582 +#define GL_SOURCE0_ALPHA_ARB 0x8588 +#define GL_SOURCE1_ALPHA_ARB 0x8589 +#define GL_SOURCE2_ALPHA_ARB 0x858A +#define GL_OPERAND0_RGB_ARB 0x8590 +#define GL_OPERAND1_RGB_ARB 0x8591 +#define GL_OPERAND2_RGB_ARB 0x8592 +#define GL_OPERAND0_ALPHA_ARB 0x8598 +#define GL_OPERAND1_ALPHA_ARB 0x8599 +#define GL_OPERAND2_ALPHA_ARB 0x859A +#define GL_RGB_SCALE_ARB 0x8573 +#define GL_ADD_SIGNED_ARB 0x8574 +#define GL_INTERPOLATE_ARB 0x8575 +#define GL_SUBTRACT_ARB 0x84E7 +#define GL_CONSTANT_ARB 0x8576 +#define GL_PRIMARY_COLOR_ARB 0x8577 +#define GL_PREVIOUS_ARB 0x8578 +#endif + +#ifndef GL_ARB_texture_env_crossbar +#endif + +#ifndef GL_ARB_texture_env_dot3 +#define GL_DOT3_RGB_ARB 0x86AE +#define GL_DOT3_RGBA_ARB 0x86AF +#endif + +#ifndef GL_ARB_texture_mirrored_repeat +#define GL_MIRRORED_REPEAT_ARB 0x8370 +#endif + +#ifndef GL_ARB_depth_texture +#define GL_DEPTH_COMPONENT16_ARB 0x81A5 +#define GL_DEPTH_COMPONENT24_ARB 0x81A6 +#define GL_DEPTH_COMPONENT32_ARB 0x81A7 +#define GL_TEXTURE_DEPTH_SIZE_ARB 0x884A +#define GL_DEPTH_TEXTURE_MODE_ARB 0x884B +#endif + +#ifndef GL_ARB_shadow +#define GL_TEXTURE_COMPARE_MODE_ARB 0x884C +#define GL_TEXTURE_COMPARE_FUNC_ARB 0x884D +#define GL_COMPARE_R_TO_TEXTURE_ARB 0x884E +#endif + +#ifndef GL_ARB_shadow_ambient +#define GL_TEXTURE_COMPARE_FAIL_VALUE_ARB 0x80BF +#endif + +#ifndef GL_ARB_window_pos +#endif + +#ifndef GL_ARB_vertex_program +#define GL_COLOR_SUM_ARB 0x8458 +#define GL_VERTEX_PROGRAM_ARB 0x8620 +#define GL_VERTEX_ATTRIB_ARRAY_ENABLED_ARB 0x8622 +#define GL_VERTEX_ATTRIB_ARRAY_SIZE_ARB 0x8623 +#define GL_VERTEX_ATTRIB_ARRAY_STRIDE_ARB 0x8624 +#define GL_VERTEX_ATTRIB_ARRAY_TYPE_ARB 0x8625 +#define GL_CURRENT_VERTEX_ATTRIB_ARB 0x8626 +#define GL_PROGRAM_LENGTH_ARB 0x8627 +#define GL_PROGRAM_STRING_ARB 0x8628 +#define GL_MAX_PROGRAM_MATRIX_STACK_DEPTH_ARB 0x862E +#define GL_MAX_PROGRAM_MATRICES_ARB 0x862F +#define GL_CURRENT_MATRIX_STACK_DEPTH_ARB 0x8640 +#define GL_CURRENT_MATRIX_ARB 0x8641 +#define GL_VERTEX_PROGRAM_POINT_SIZE_ARB 0x8642 +#define GL_VERTEX_PROGRAM_TWO_SIDE_ARB 0x8643 +#define GL_VERTEX_ATTRIB_ARRAY_POINTER_ARB 0x8645 +#define GL_PROGRAM_ERROR_POSITION_ARB 0x864B +#define GL_PROGRAM_BINDING_ARB 0x8677 +#define GL_MAX_VERTEX_ATTRIBS_ARB 0x8869 +#define GL_VERTEX_ATTRIB_ARRAY_NORMALIZED_ARB 0x886A +#define GL_PROGRAM_ERROR_STRING_ARB 0x8874 +#define GL_PROGRAM_FORMAT_ASCII_ARB 0x8875 +#define GL_PROGRAM_FORMAT_ARB 0x8876 +#define GL_PROGRAM_INSTRUCTIONS_ARB 0x88A0 +#define GL_MAX_PROGRAM_INSTRUCTIONS_ARB 0x88A1 +#define GL_PROGRAM_NATIVE_INSTRUCTIONS_ARB 0x88A2 +#define GL_MAX_PROGRAM_NATIVE_INSTRUCTIONS_ARB 0x88A3 +#define GL_PROGRAM_TEMPORARIES_ARB 0x88A4 +#define GL_MAX_PROGRAM_TEMPORARIES_ARB 0x88A5 +#define GL_PROGRAM_NATIVE_TEMPORARIES_ARB 0x88A6 +#define GL_MAX_PROGRAM_NATIVE_TEMPORARIES_ARB 0x88A7 +#define GL_PROGRAM_PARAMETERS_ARB 0x88A8 +#define GL_MAX_PROGRAM_PARAMETERS_ARB 0x88A9 +#define GL_PROGRAM_NATIVE_PARAMETERS_ARB 0x88AA +#define GL_MAX_PROGRAM_NATIVE_PARAMETERS_ARB 0x88AB +#define GL_PROGRAM_ATTRIBS_ARB 0x88AC +#define GL_MAX_PROGRAM_ATTRIBS_ARB 0x88AD +#define GL_PROGRAM_NATIVE_ATTRIBS_ARB 0x88AE +#define GL_MAX_PROGRAM_NATIVE_ATTRIBS_ARB 0x88AF +#define GL_PROGRAM_ADDRESS_REGISTERS_ARB 0x88B0 +#define GL_MAX_PROGRAM_ADDRESS_REGISTERS_ARB 0x88B1 +#define GL_PROGRAM_NATIVE_ADDRESS_REGISTERS_ARB 0x88B2 +#define GL_MAX_PROGRAM_NATIVE_ADDRESS_REGISTERS_ARB 0x88B3 +#define GL_MAX_PROGRAM_LOCAL_PARAMETERS_ARB 0x88B4 +#define GL_MAX_PROGRAM_ENV_PARAMETERS_ARB 0x88B5 +#define GL_PROGRAM_UNDER_NATIVE_LIMITS_ARB 0x88B6 +#define GL_TRANSPOSE_CURRENT_MATRIX_ARB 0x88B7 +#define GL_MATRIX0_ARB 0x88C0 +#define GL_MATRIX1_ARB 0x88C1 +#define GL_MATRIX2_ARB 0x88C2 +#define GL_MATRIX3_ARB 0x88C3 +#define GL_MATRIX4_ARB 0x88C4 +#define GL_MATRIX5_ARB 0x88C5 +#define GL_MATRIX6_ARB 0x88C6 +#define GL_MATRIX7_ARB 0x88C7 +#define GL_MATRIX8_ARB 0x88C8 +#define GL_MATRIX9_ARB 0x88C9 +#define GL_MATRIX10_ARB 0x88CA +#define GL_MATRIX11_ARB 0x88CB +#define GL_MATRIX12_ARB 0x88CC +#define GL_MATRIX13_ARB 0x88CD +#define GL_MATRIX14_ARB 0x88CE +#define GL_MATRIX15_ARB 0x88CF +#define GL_MATRIX16_ARB 0x88D0 +#define GL_MATRIX17_ARB 0x88D1 +#define GL_MATRIX18_ARB 0x88D2 +#define GL_MATRIX19_ARB 0x88D3 +#define GL_MATRIX20_ARB 0x88D4 +#define GL_MATRIX21_ARB 0x88D5 +#define GL_MATRIX22_ARB 0x88D6 +#define GL_MATRIX23_ARB 0x88D7 +#define GL_MATRIX24_ARB 0x88D8 +#define GL_MATRIX25_ARB 0x88D9 +#define GL_MATRIX26_ARB 0x88DA +#define GL_MATRIX27_ARB 0x88DB +#define GL_MATRIX28_ARB 0x88DC +#define GL_MATRIX29_ARB 0x88DD +#define GL_MATRIX30_ARB 0x88DE +#define GL_MATRIX31_ARB 0x88DF +#endif + +#ifndef GL_ARB_fragment_program +#define GL_FRAGMENT_PROGRAM_ARB 0x8804 +#define GL_PROGRAM_ALU_INSTRUCTIONS_ARB 0x8805 +#define GL_PROGRAM_TEX_INSTRUCTIONS_ARB 0x8806 +#define GL_PROGRAM_TEX_INDIRECTIONS_ARB 0x8807 +#define GL_PROGRAM_NATIVE_ALU_INSTRUCTIONS_ARB 0x8808 +#define GL_PROGRAM_NATIVE_TEX_INSTRUCTIONS_ARB 0x8809 +#define GL_PROGRAM_NATIVE_TEX_INDIRECTIONS_ARB 0x880A +#define GL_MAX_PROGRAM_ALU_INSTRUCTIONS_ARB 0x880B +#define GL_MAX_PROGRAM_TEX_INSTRUCTIONS_ARB 0x880C +#define GL_MAX_PROGRAM_TEX_INDIRECTIONS_ARB 0x880D +#define GL_MAX_PROGRAM_NATIVE_ALU_INSTRUCTIONS_ARB 0x880E +#define GL_MAX_PROGRAM_NATIVE_TEX_INSTRUCTIONS_ARB 0x880F +#define GL_MAX_PROGRAM_NATIVE_TEX_INDIRECTIONS_ARB 0x8810 +#define GL_MAX_TEXTURE_COORDS_ARB 0x8871 +#define GL_MAX_TEXTURE_IMAGE_UNITS_ARB 0x8872 +#endif + +#ifndef GL_ARB_vertex_buffer_object +#define GL_BUFFER_SIZE_ARB 0x8764 +#define GL_BUFFER_USAGE_ARB 0x8765 +#define GL_ARRAY_BUFFER_ARB 0x8892 +#define GL_ELEMENT_ARRAY_BUFFER_ARB 0x8893 +#define GL_ARRAY_BUFFER_BINDING_ARB 0x8894 +#define GL_ELEMENT_ARRAY_BUFFER_BINDING_ARB 0x8895 +#define GL_VERTEX_ARRAY_BUFFER_BINDING_ARB 0x8896 +#define GL_NORMAL_ARRAY_BUFFER_BINDING_ARB 0x8897 +#define GL_COLOR_ARRAY_BUFFER_BINDING_ARB 0x8898 +#define GL_INDEX_ARRAY_BUFFER_BINDING_ARB 0x8899 +#define GL_TEXTURE_COORD_ARRAY_BUFFER_BINDING_ARB 0x889A +#define GL_EDGE_FLAG_ARRAY_BUFFER_BINDING_ARB 0x889B +#define GL_SECONDARY_COLOR_ARRAY_BUFFER_BINDING_ARB 0x889C +#define GL_FOG_COORDINATE_ARRAY_BUFFER_BINDING_ARB 0x889D +#define GL_WEIGHT_ARRAY_BUFFER_BINDING_ARB 0x889E +#define GL_VERTEX_ATTRIB_ARRAY_BUFFER_BINDING_ARB 0x889F +#define GL_READ_ONLY_ARB 0x88B8 +#define GL_WRITE_ONLY_ARB 0x88B9 +#define GL_READ_WRITE_ARB 0x88BA +#define GL_BUFFER_ACCESS_ARB 0x88BB +#define GL_BUFFER_MAPPED_ARB 0x88BC +#define GL_BUFFER_MAP_POINTER_ARB 0x88BD +#define GL_STREAM_DRAW_ARB 0x88E0 +#define GL_STREAM_READ_ARB 0x88E1 +#define GL_STREAM_COPY_ARB 0x88E2 +#define GL_STATIC_DRAW_ARB 0x88E4 +#define GL_STATIC_READ_ARB 0x88E5 +#define GL_STATIC_COPY_ARB 0x88E6 +#define GL_DYNAMIC_DRAW_ARB 0x88E8 +#define GL_DYNAMIC_READ_ARB 0x88E9 +#define GL_DYNAMIC_COPY_ARB 0x88EA +#endif + +#ifndef GL_ARB_occlusion_query +#define GL_QUERY_COUNTER_BITS_ARB 0x8864 +#define GL_CURRENT_QUERY_ARB 0x8865 +#define GL_QUERY_RESULT_ARB 0x8866 +#define GL_QUERY_RESULT_AVAILABLE_ARB 0x8867 +#define GL_SAMPLES_PASSED_ARB 0x8914 +#endif + +#ifndef GL_ARB_shader_objects +#define GL_PROGRAM_OBJECT_ARB 0x8B40 +#define GL_SHADER_OBJECT_ARB 0x8B48 +#define GL_OBJECT_TYPE_ARB 0x8B4E +#define GL_OBJECT_SUBTYPE_ARB 0x8B4F +#define GL_FLOAT_VEC2_ARB 0x8B50 +#define GL_FLOAT_VEC3_ARB 0x8B51 +#define GL_FLOAT_VEC4_ARB 0x8B52 +#define GL_INT_VEC2_ARB 0x8B53 +#define GL_INT_VEC3_ARB 0x8B54 +#define GL_INT_VEC4_ARB 0x8B55 +#define GL_BOOL_ARB 0x8B56 +#define GL_BOOL_VEC2_ARB 0x8B57 +#define GL_BOOL_VEC3_ARB 0x8B58 +#define GL_BOOL_VEC4_ARB 0x8B59 +#define GL_FLOAT_MAT2_ARB 0x8B5A +#define GL_FLOAT_MAT3_ARB 0x8B5B +#define GL_FLOAT_MAT4_ARB 0x8B5C +#define GL_SAMPLER_1D_ARB 0x8B5D +#define GL_SAMPLER_2D_ARB 0x8B5E +#define GL_SAMPLER_3D_ARB 0x8B5F +#define GL_SAMPLER_CUBE_ARB 0x8B60 +#define GL_SAMPLER_1D_SHADOW_ARB 0x8B61 +#define GL_SAMPLER_2D_SHADOW_ARB 0x8B62 +#define GL_SAMPLER_2D_RECT_ARB 0x8B63 +#define GL_SAMPLER_2D_RECT_SHADOW_ARB 0x8B64 +#define GL_OBJECT_DELETE_STATUS_ARB 0x8B80 +#define GL_OBJECT_COMPILE_STATUS_ARB 0x8B81 +#define GL_OBJECT_LINK_STATUS_ARB 0x8B82 +#define GL_OBJECT_VALIDATE_STATUS_ARB 0x8B83 +#define GL_OBJECT_INFO_LOG_LENGTH_ARB 0x8B84 +#define GL_OBJECT_ATTACHED_OBJECTS_ARB 0x8B85 +#define GL_OBJECT_ACTIVE_UNIFORMS_ARB 0x8B86 +#define GL_OBJECT_ACTIVE_UNIFORM_MAX_LENGTH_ARB 0x8B87 +#define GL_OBJECT_SHADER_SOURCE_LENGTH_ARB 0x8B88 +#endif + +#ifndef GL_ARB_vertex_shader +#define GL_VERTEX_SHADER_ARB 0x8B31 +#define GL_MAX_VERTEX_UNIFORM_COMPONENTS_ARB 0x8B4A +#define GL_MAX_VARYING_FLOATS_ARB 0x8B4B +#define GL_MAX_VERTEX_TEXTURE_IMAGE_UNITS_ARB 0x8B4C +#define GL_MAX_COMBINED_TEXTURE_IMAGE_UNITS_ARB 0x8B4D +#define GL_OBJECT_ACTIVE_ATTRIBUTES_ARB 0x8B89 +#define GL_OBJECT_ACTIVE_ATTRIBUTE_MAX_LENGTH_ARB 0x8B8A +#endif + +#ifndef GL_ARB_fragment_shader +#define GL_FRAGMENT_SHADER_ARB 0x8B30 +#define GL_MAX_FRAGMENT_UNIFORM_COMPONENTS_ARB 0x8B49 +#define GL_FRAGMENT_SHADER_DERIVATIVE_HINT_ARB 0x8B8B +#endif + +#ifndef GL_ARB_shading_language_100 +#define GL_SHADING_LANGUAGE_VERSION_ARB 0x8B8C +#endif + +#ifndef GL_ARB_texture_non_power_of_two +#endif + +#ifndef GL_ARB_point_sprite +#define GL_POINT_SPRITE_ARB 0x8861 +#define GL_COORD_REPLACE_ARB 0x8862 +#endif + +#ifndef GL_ARB_fragment_program_shadow +#endif + +#ifndef GL_ARB_draw_buffers +#define GL_MAX_DRAW_BUFFERS_ARB 0x8824 +#define GL_DRAW_BUFFER0_ARB 0x8825 +#define GL_DRAW_BUFFER1_ARB 0x8826 +#define GL_DRAW_BUFFER2_ARB 0x8827 +#define GL_DRAW_BUFFER3_ARB 0x8828 +#define GL_DRAW_BUFFER4_ARB 0x8829 +#define GL_DRAW_BUFFER5_ARB 0x882A +#define GL_DRAW_BUFFER6_ARB 0x882B +#define GL_DRAW_BUFFER7_ARB 0x882C +#define GL_DRAW_BUFFER8_ARB 0x882D +#define GL_DRAW_BUFFER9_ARB 0x882E +#define GL_DRAW_BUFFER10_ARB 0x882F +#define GL_DRAW_BUFFER11_ARB 0x8830 +#define GL_DRAW_BUFFER12_ARB 0x8831 +#define GL_DRAW_BUFFER13_ARB 0x8832 +#define GL_DRAW_BUFFER14_ARB 0x8833 +#define GL_DRAW_BUFFER15_ARB 0x8834 +#endif + +#ifndef GL_ARB_texture_rectangle +#define GL_TEXTURE_RECTANGLE_ARB 0x84F5 +#define GL_TEXTURE_BINDING_RECTANGLE_ARB 0x84F6 +#define GL_PROXY_TEXTURE_RECTANGLE_ARB 0x84F7 +#define GL_MAX_RECTANGLE_TEXTURE_SIZE_ARB 0x84F8 +#endif + +#ifndef GL_ARB_color_buffer_float +#define GL_RGBA_FLOAT_MODE_ARB 0x8820 +#define GL_CLAMP_VERTEX_COLOR_ARB 0x891A +#define GL_CLAMP_FRAGMENT_COLOR_ARB 0x891B +#define GL_CLAMP_READ_COLOR_ARB 0x891C +#define GL_FIXED_ONLY_ARB 0x891D +#endif + +#ifndef GL_ARB_half_float_pixel +#define GL_HALF_FLOAT_ARB 0x140B +#endif + +#ifndef GL_ARB_texture_float +#define GL_TEXTURE_RED_TYPE_ARB 0x8C10 +#define GL_TEXTURE_GREEN_TYPE_ARB 0x8C11 +#define GL_TEXTURE_BLUE_TYPE_ARB 0x8C12 +#define GL_TEXTURE_ALPHA_TYPE_ARB 0x8C13 +#define GL_TEXTURE_LUMINANCE_TYPE_ARB 0x8C14 +#define GL_TEXTURE_INTENSITY_TYPE_ARB 0x8C15 +#define GL_TEXTURE_DEPTH_TYPE_ARB 0x8C16 +#define GL_UNSIGNED_NORMALIZED_ARB 0x8C17 +#define GL_RGBA32F_ARB 0x8814 +#define GL_RGB32F_ARB 0x8815 +#define GL_ALPHA32F_ARB 0x8816 +#define GL_INTENSITY32F_ARB 0x8817 +#define GL_LUMINANCE32F_ARB 0x8818 +#define GL_LUMINANCE_ALPHA32F_ARB 0x8819 +#define GL_RGBA16F_ARB 0x881A +#define GL_RGB16F_ARB 0x881B +#define GL_ALPHA16F_ARB 0x881C +#define GL_INTENSITY16F_ARB 0x881D +#define GL_LUMINANCE16F_ARB 0x881E +#define GL_LUMINANCE_ALPHA16F_ARB 0x881F +#endif + +#ifndef GL_ARB_pixel_buffer_object +#define GL_PIXEL_PACK_BUFFER_ARB 0x88EB +#define GL_PIXEL_UNPACK_BUFFER_ARB 0x88EC +#define GL_PIXEL_PACK_BUFFER_BINDING_ARB 0x88ED +#define GL_PIXEL_UNPACK_BUFFER_BINDING_ARB 0x88EF +#endif + +#ifndef GL_EXT_abgr +#define GL_ABGR_EXT 0x8000 +#endif + +#ifndef GL_EXT_blend_color +#define GL_CONSTANT_COLOR_EXT 0x8001 +#define GL_ONE_MINUS_CONSTANT_COLOR_EXT 0x8002 +#define GL_CONSTANT_ALPHA_EXT 0x8003 +#define GL_ONE_MINUS_CONSTANT_ALPHA_EXT 0x8004 +#define GL_BLEND_COLOR_EXT 0x8005 +#endif + +#ifndef GL_EXT_polygon_offset +#define GL_POLYGON_OFFSET_EXT 0x8037 +#define GL_POLYGON_OFFSET_FACTOR_EXT 0x8038 +#define GL_POLYGON_OFFSET_BIAS_EXT 0x8039 +#endif + +#ifndef GL_EXT_texture +#define GL_ALPHA4_EXT 0x803B +#define GL_ALPHA8_EXT 0x803C +#define GL_ALPHA12_EXT 0x803D +#define GL_ALPHA16_EXT 0x803E +#define GL_LUMINANCE4_EXT 0x803F +#define GL_LUMINANCE8_EXT 0x8040 +#define GL_LUMINANCE12_EXT 0x8041 +#define GL_LUMINANCE16_EXT 0x8042 +#define GL_LUMINANCE4_ALPHA4_EXT 0x8043 +#define GL_LUMINANCE6_ALPHA2_EXT 0x8044 +#define GL_LUMINANCE8_ALPHA8_EXT 0x8045 +#define GL_LUMINANCE12_ALPHA4_EXT 0x8046 +#define GL_LUMINANCE12_ALPHA12_EXT 0x8047 +#define GL_LUMINANCE16_ALPHA16_EXT 0x8048 +#define GL_INTENSITY_EXT 0x8049 +#define GL_INTENSITY4_EXT 0x804A +#define GL_INTENSITY8_EXT 0x804B +#define GL_INTENSITY12_EXT 0x804C +#define GL_INTENSITY16_EXT 0x804D +#define GL_RGB2_EXT 0x804E +#define GL_RGB4_EXT 0x804F +#define GL_RGB5_EXT 0x8050 +#define GL_RGB8_EXT 0x8051 +#define GL_RGB10_EXT 0x8052 +#define GL_RGB12_EXT 0x8053 +#define GL_RGB16_EXT 0x8054 +#define GL_RGBA2_EXT 0x8055 +#define GL_RGBA4_EXT 0x8056 +#define GL_RGB5_A1_EXT 0x8057 +#define GL_RGBA8_EXT 0x8058 +#define GL_RGB10_A2_EXT 0x8059 +#define GL_RGBA12_EXT 0x805A +#define GL_RGBA16_EXT 0x805B +#define GL_TEXTURE_RED_SIZE_EXT 0x805C +#define GL_TEXTURE_GREEN_SIZE_EXT 0x805D +#define GL_TEXTURE_BLUE_SIZE_EXT 0x805E +#define GL_TEXTURE_ALPHA_SIZE_EXT 0x805F +#define GL_TEXTURE_LUMINANCE_SIZE_EXT 0x8060 +#define GL_TEXTURE_INTENSITY_SIZE_EXT 0x8061 +#define GL_REPLACE_EXT 0x8062 +#define GL_PROXY_TEXTURE_1D_EXT 0x8063 +#define GL_PROXY_TEXTURE_2D_EXT 0x8064 +#define GL_TEXTURE_TOO_LARGE_EXT 0x8065 +#endif + +#ifndef GL_EXT_texture3D +#define GL_PACK_SKIP_IMAGES_EXT 0x806B +#define GL_PACK_IMAGE_HEIGHT_EXT 0x806C +#define GL_UNPACK_SKIP_IMAGES_EXT 0x806D +#define GL_UNPACK_IMAGE_HEIGHT_EXT 0x806E +#define GL_TEXTURE_3D_EXT 0x806F +#define GL_PROXY_TEXTURE_3D_EXT 0x8070 +#define GL_TEXTURE_DEPTH_EXT 0x8071 +#define GL_TEXTURE_WRAP_R_EXT 0x8072 +#define GL_MAX_3D_TEXTURE_SIZE_EXT 0x8073 +#endif + +#ifndef GL_SGIS_texture_filter4 +#define GL_FILTER4_SGIS 0x8146 +#define GL_TEXTURE_FILTER4_SIZE_SGIS 0x8147 +#endif + +#ifndef GL_EXT_subtexture +#endif + +#ifndef GL_EXT_copy_texture +#endif + +#ifndef GL_EXT_histogram +#define GL_HISTOGRAM_EXT 0x8024 +#define GL_PROXY_HISTOGRAM_EXT 0x8025 +#define GL_HISTOGRAM_WIDTH_EXT 0x8026 +#define GL_HISTOGRAM_FORMAT_EXT 0x8027 +#define GL_HISTOGRAM_RED_SIZE_EXT 0x8028 +#define GL_HISTOGRAM_GREEN_SIZE_EXT 0x8029 +#define GL_HISTOGRAM_BLUE_SIZE_EXT 0x802A +#define GL_HISTOGRAM_ALPHA_SIZE_EXT 0x802B +#define GL_HISTOGRAM_LUMINANCE_SIZE_EXT 0x802C +#define GL_HISTOGRAM_SINK_EXT 0x802D +#define GL_MINMAX_EXT 0x802E +#define GL_MINMAX_FORMAT_EXT 0x802F +#define GL_MINMAX_SINK_EXT 0x8030 +#define GL_TABLE_TOO_LARGE_EXT 0x8031 +#endif + +#ifndef GL_EXT_convolution +#define GL_CONVOLUTION_1D_EXT 0x8010 +#define GL_CONVOLUTION_2D_EXT 0x8011 +#define GL_SEPARABLE_2D_EXT 0x8012 +#define GL_CONVOLUTION_BORDER_MODE_EXT 0x8013 +#define GL_CONVOLUTION_FILTER_SCALE_EXT 0x8014 +#define GL_CONVOLUTION_FILTER_BIAS_EXT 0x8015 +#define GL_REDUCE_EXT 0x8016 +#define GL_CONVOLUTION_FORMAT_EXT 0x8017 +#define GL_CONVOLUTION_WIDTH_EXT 0x8018 +#define GL_CONVOLUTION_HEIGHT_EXT 0x8019 +#define GL_MAX_CONVOLUTION_WIDTH_EXT 0x801A +#define GL_MAX_CONVOLUTION_HEIGHT_EXT 0x801B +#define GL_POST_CONVOLUTION_RED_SCALE_EXT 0x801C +#define GL_POST_CONVOLUTION_GREEN_SCALE_EXT 0x801D +#define GL_POST_CONVOLUTION_BLUE_SCALE_EXT 0x801E +#define GL_POST_CONVOLUTION_ALPHA_SCALE_EXT 0x801F +#define GL_POST_CONVOLUTION_RED_BIAS_EXT 0x8020 +#define GL_POST_CONVOLUTION_GREEN_BIAS_EXT 0x8021 +#define GL_POST_CONVOLUTION_BLUE_BIAS_EXT 0x8022 +#define GL_POST_CONVOLUTION_ALPHA_BIAS_EXT 0x8023 +#endif + +#ifndef GL_SGI_color_matrix +#define GL_COLOR_MATRIX_SGI 0x80B1 +#define GL_COLOR_MATRIX_STACK_DEPTH_SGI 0x80B2 +#define GL_MAX_COLOR_MATRIX_STACK_DEPTH_SGI 0x80B3 +#define GL_POST_COLOR_MATRIX_RED_SCALE_SGI 0x80B4 +#define GL_POST_COLOR_MATRIX_GREEN_SCALE_SGI 0x80B5 +#define GL_POST_COLOR_MATRIX_BLUE_SCALE_SGI 0x80B6 +#define GL_POST_COLOR_MATRIX_ALPHA_SCALE_SGI 0x80B7 +#define GL_POST_COLOR_MATRIX_RED_BIAS_SGI 0x80B8 +#define GL_POST_COLOR_MATRIX_GREEN_BIAS_SGI 0x80B9 +#define GL_POST_COLOR_MATRIX_BLUE_BIAS_SGI 0x80BA +#define GL_POST_COLOR_MATRIX_ALPHA_BIAS_SGI 0x80BB +#endif + +#ifndef GL_SGI_color_table +#define GL_COLOR_TABLE_SGI 0x80D0 +#define GL_POST_CONVOLUTION_COLOR_TABLE_SGI 0x80D1 +#define GL_POST_COLOR_MATRIX_COLOR_TABLE_SGI 0x80D2 +#define GL_PROXY_COLOR_TABLE_SGI 0x80D3 +#define GL_PROXY_POST_CONVOLUTION_COLOR_TABLE_SGI 0x80D4 +#define GL_PROXY_POST_COLOR_MATRIX_COLOR_TABLE_SGI 0x80D5 +#define GL_COLOR_TABLE_SCALE_SGI 0x80D6 +#define GL_COLOR_TABLE_BIAS_SGI 0x80D7 +#define GL_COLOR_TABLE_FORMAT_SGI 0x80D8 +#define GL_COLOR_TABLE_WIDTH_SGI 0x80D9 +#define GL_COLOR_TABLE_RED_SIZE_SGI 0x80DA +#define GL_COLOR_TABLE_GREEN_SIZE_SGI 0x80DB +#define GL_COLOR_TABLE_BLUE_SIZE_SGI 0x80DC +#define GL_COLOR_TABLE_ALPHA_SIZE_SGI 0x80DD +#define GL_COLOR_TABLE_LUMINANCE_SIZE_SGI 0x80DE +#define GL_COLOR_TABLE_INTENSITY_SIZE_SGI 0x80DF +#endif + +#ifndef GL_SGIS_pixel_texture +#define GL_PIXEL_TEXTURE_SGIS 0x8353 +#define GL_PIXEL_FRAGMENT_RGB_SOURCE_SGIS 0x8354 +#define GL_PIXEL_FRAGMENT_ALPHA_SOURCE_SGIS 0x8355 +#define GL_PIXEL_GROUP_COLOR_SGIS 0x8356 +#endif + +#ifndef GL_SGIX_pixel_texture +#define GL_PIXEL_TEX_GEN_SGIX 0x8139 +#define GL_PIXEL_TEX_GEN_MODE_SGIX 0x832B +#endif + +#ifndef GL_SGIS_texture4D +#define GL_PACK_SKIP_VOLUMES_SGIS 0x8130 +#define GL_PACK_IMAGE_DEPTH_SGIS 0x8131 +#define GL_UNPACK_SKIP_VOLUMES_SGIS 0x8132 +#define GL_UNPACK_IMAGE_DEPTH_SGIS 0x8133 +#define GL_TEXTURE_4D_SGIS 0x8134 +#define GL_PROXY_TEXTURE_4D_SGIS 0x8135 +#define GL_TEXTURE_4DSIZE_SGIS 0x8136 +#define GL_TEXTURE_WRAP_Q_SGIS 0x8137 +#define GL_MAX_4D_TEXTURE_SIZE_SGIS 0x8138 +#define GL_TEXTURE_4D_BINDING_SGIS 0x814F +#endif + +#ifndef GL_SGI_texture_color_table +#define GL_TEXTURE_COLOR_TABLE_SGI 0x80BC +#define GL_PROXY_TEXTURE_COLOR_TABLE_SGI 0x80BD +#endif + +#ifndef GL_EXT_cmyka +#define GL_CMYK_EXT 0x800C +#define GL_CMYKA_EXT 0x800D +#define GL_PACK_CMYK_HINT_EXT 0x800E +#define GL_UNPACK_CMYK_HINT_EXT 0x800F +#endif + +#ifndef GL_EXT_texture_object +#define GL_TEXTURE_PRIORITY_EXT 0x8066 +#define GL_TEXTURE_RESIDENT_EXT 0x8067 +#define GL_TEXTURE_1D_BINDING_EXT 0x8068 +#define GL_TEXTURE_2D_BINDING_EXT 0x8069 +#define GL_TEXTURE_3D_BINDING_EXT 0x806A +#endif + +#ifndef GL_SGIS_detail_texture +#define GL_DETAIL_TEXTURE_2D_SGIS 0x8095 +#define GL_DETAIL_TEXTURE_2D_BINDING_SGIS 0x8096 +#define GL_LINEAR_DETAIL_SGIS 0x8097 +#define GL_LINEAR_DETAIL_ALPHA_SGIS 0x8098 +#define GL_LINEAR_DETAIL_COLOR_SGIS 0x8099 +#define GL_DETAIL_TEXTURE_LEVEL_SGIS 0x809A +#define GL_DETAIL_TEXTURE_MODE_SGIS 0x809B +#define GL_DETAIL_TEXTURE_FUNC_POINTS_SGIS 0x809C +#endif + +#ifndef GL_SGIS_sharpen_texture +#define GL_LINEAR_SHARPEN_SGIS 0x80AD +#define GL_LINEAR_SHARPEN_ALPHA_SGIS 0x80AE +#define GL_LINEAR_SHARPEN_COLOR_SGIS 0x80AF +#define GL_SHARPEN_TEXTURE_FUNC_POINTS_SGIS 0x80B0 +#endif + +#ifndef GL_EXT_packed_pixels +#define GL_UNSIGNED_BYTE_3_3_2_EXT 0x8032 +#define GL_UNSIGNED_SHORT_4_4_4_4_EXT 0x8033 +#define GL_UNSIGNED_SHORT_5_5_5_1_EXT 0x8034 +#define GL_UNSIGNED_INT_8_8_8_8_EXT 0x8035 +#define GL_UNSIGNED_INT_10_10_10_2_EXT 0x8036 +#endif + +#ifndef GL_SGIS_texture_lod +#define GL_TEXTURE_MIN_LOD_SGIS 0x813A +#define GL_TEXTURE_MAX_LOD_SGIS 0x813B +#define GL_TEXTURE_BASE_LEVEL_SGIS 0x813C +#define GL_TEXTURE_MAX_LEVEL_SGIS 0x813D +#endif + +#ifndef GL_SGIS_multisample +#define GL_MULTISAMPLE_SGIS 0x809D +#define GL_SAMPLE_ALPHA_TO_MASK_SGIS 0x809E +#define GL_SAMPLE_ALPHA_TO_ONE_SGIS 0x809F +#define GL_SAMPLE_MASK_SGIS 0x80A0 +#define GL_1PASS_SGIS 0x80A1 +#define GL_2PASS_0_SGIS 0x80A2 +#define GL_2PASS_1_SGIS 0x80A3 +#define GL_4PASS_0_SGIS 0x80A4 +#define GL_4PASS_1_SGIS 0x80A5 +#define GL_4PASS_2_SGIS 0x80A6 +#define GL_4PASS_3_SGIS 0x80A7 +#define GL_SAMPLE_BUFFERS_SGIS 0x80A8 +#define GL_SAMPLES_SGIS 0x80A9 +#define GL_SAMPLE_MASK_VALUE_SGIS 0x80AA +#define GL_SAMPLE_MASK_INVERT_SGIS 0x80AB +#define GL_SAMPLE_PATTERN_SGIS 0x80AC +#endif + +#ifndef GL_EXT_rescale_normal +#define GL_RESCALE_NORMAL_EXT 0x803A +#endif + +#ifndef GL_EXT_vertex_array +#define GL_VERTEX_ARRAY_EXT 0x8074 +#define GL_NORMAL_ARRAY_EXT 0x8075 +#define GL_COLOR_ARRAY_EXT 0x8076 +#define GL_INDEX_ARRAY_EXT 0x8077 +#define GL_TEXTURE_COORD_ARRAY_EXT 0x8078 +#define GL_EDGE_FLAG_ARRAY_EXT 0x8079 +#define GL_VERTEX_ARRAY_SIZE_EXT 0x807A +#define GL_VERTEX_ARRAY_TYPE_EXT 0x807B +#define GL_VERTEX_ARRAY_STRIDE_EXT 0x807C +#define GL_VERTEX_ARRAY_COUNT_EXT 0x807D +#define GL_NORMAL_ARRAY_TYPE_EXT 0x807E +#define GL_NORMAL_ARRAY_STRIDE_EXT 0x807F +#define GL_NORMAL_ARRAY_COUNT_EXT 0x8080 +#define GL_COLOR_ARRAY_SIZE_EXT 0x8081 +#define GL_COLOR_ARRAY_TYPE_EXT 0x8082 +#define GL_COLOR_ARRAY_STRIDE_EXT 0x8083 +#define GL_COLOR_ARRAY_COUNT_EXT 0x8084 +#define GL_INDEX_ARRAY_TYPE_EXT 0x8085 +#define GL_INDEX_ARRAY_STRIDE_EXT 0x8086 +#define GL_INDEX_ARRAY_COUNT_EXT 0x8087 +#define GL_TEXTURE_COORD_ARRAY_SIZE_EXT 0x8088 +#define GL_TEXTURE_COORD_ARRAY_TYPE_EXT 0x8089 +#define GL_TEXTURE_COORD_ARRAY_STRIDE_EXT 0x808A +#define GL_TEXTURE_COORD_ARRAY_COUNT_EXT 0x808B +#define GL_EDGE_FLAG_ARRAY_STRIDE_EXT 0x808C +#define GL_EDGE_FLAG_ARRAY_COUNT_EXT 0x808D +#define GL_VERTEX_ARRAY_POINTER_EXT 0x808E +#define GL_NORMAL_ARRAY_POINTER_EXT 0x808F +#define GL_COLOR_ARRAY_POINTER_EXT 0x8090 +#define GL_INDEX_ARRAY_POINTER_EXT 0x8091 +#define GL_TEXTURE_COORD_ARRAY_POINTER_EXT 0x8092 +#define GL_EDGE_FLAG_ARRAY_POINTER_EXT 0x8093 +#endif + +#ifndef GL_EXT_misc_attribute +#endif + +#ifndef GL_SGIS_generate_mipmap +#define GL_GENERATE_MIPMAP_SGIS 0x8191 +#define GL_GENERATE_MIPMAP_HINT_SGIS 0x8192 +#endif + +#ifndef GL_SGIX_clipmap +#define GL_LINEAR_CLIPMAP_LINEAR_SGIX 0x8170 +#define GL_TEXTURE_CLIPMAP_CENTER_SGIX 0x8171 +#define GL_TEXTURE_CLIPMAP_FRAME_SGIX 0x8172 +#define GL_TEXTURE_CLIPMAP_OFFSET_SGIX 0x8173 +#define GL_TEXTURE_CLIPMAP_VIRTUAL_DEPTH_SGIX 0x8174 +#define GL_TEXTURE_CLIPMAP_LOD_OFFSET_SGIX 0x8175 +#define GL_TEXTURE_CLIPMAP_DEPTH_SGIX 0x8176 +#define GL_MAX_CLIPMAP_DEPTH_SGIX 0x8177 +#define GL_MAX_CLIPMAP_VIRTUAL_DEPTH_SGIX 0x8178 +#define GL_NEAREST_CLIPMAP_NEAREST_SGIX 0x844D +#define GL_NEAREST_CLIPMAP_LINEAR_SGIX 0x844E +#define GL_LINEAR_CLIPMAP_NEAREST_SGIX 0x844F +#endif + +#ifndef GL_SGIX_shadow +#define GL_TEXTURE_COMPARE_SGIX 0x819A +#define GL_TEXTURE_COMPARE_OPERATOR_SGIX 0x819B +#define GL_TEXTURE_LEQUAL_R_SGIX 0x819C +#define GL_TEXTURE_GEQUAL_R_SGIX 0x819D +#endif + +#ifndef GL_SGIS_texture_edge_clamp +#define GL_CLAMP_TO_EDGE_SGIS 0x812F +#endif + +#ifndef GL_SGIS_texture_border_clamp +#define GL_CLAMP_TO_BORDER_SGIS 0x812D +#endif + +#ifndef GL_EXT_blend_minmax +#define GL_FUNC_ADD_EXT 0x8006 +#define GL_MIN_EXT 0x8007 +#define GL_MAX_EXT 0x8008 +#define GL_BLEND_EQUATION_EXT 0x8009 +#endif + +#ifndef GL_EXT_blend_subtract +#define GL_FUNC_SUBTRACT_EXT 0x800A +#define GL_FUNC_REVERSE_SUBTRACT_EXT 0x800B +#endif + +#ifndef GL_EXT_blend_logic_op +#endif + +#ifndef GL_SGIX_interlace +#define GL_INTERLACE_SGIX 0x8094 +#endif + +#ifndef GL_SGIX_pixel_tiles +#define GL_PIXEL_TILE_BEST_ALIGNMENT_SGIX 0x813E +#define GL_PIXEL_TILE_CACHE_INCREMENT_SGIX 0x813F +#define GL_PIXEL_TILE_WIDTH_SGIX 0x8140 +#define GL_PIXEL_TILE_HEIGHT_SGIX 0x8141 +#define GL_PIXEL_TILE_GRID_WIDTH_SGIX 0x8142 +#define GL_PIXEL_TILE_GRID_HEIGHT_SGIX 0x8143 +#define GL_PIXEL_TILE_GRID_DEPTH_SGIX 0x8144 +#define GL_PIXEL_TILE_CACHE_SIZE_SGIX 0x8145 +#endif + +#ifndef GL_SGIS_texture_select +#define GL_DUAL_ALPHA4_SGIS 0x8110 +#define GL_DUAL_ALPHA8_SGIS 0x8111 +#define GL_DUAL_ALPHA12_SGIS 0x8112 +#define GL_DUAL_ALPHA16_SGIS 0x8113 +#define GL_DUAL_LUMINANCE4_SGIS 0x8114 +#define GL_DUAL_LUMINANCE8_SGIS 0x8115 +#define GL_DUAL_LUMINANCE12_SGIS 0x8116 +#define GL_DUAL_LUMINANCE16_SGIS 0x8117 +#define GL_DUAL_INTENSITY4_SGIS 0x8118 +#define GL_DUAL_INTENSITY8_SGIS 0x8119 +#define GL_DUAL_INTENSITY12_SGIS 0x811A +#define GL_DUAL_INTENSITY16_SGIS 0x811B +#define GL_DUAL_LUMINANCE_ALPHA4_SGIS 0x811C +#define GL_DUAL_LUMINANCE_ALPHA8_SGIS 0x811D +#define GL_QUAD_ALPHA4_SGIS 0x811E +#define GL_QUAD_ALPHA8_SGIS 0x811F +#define GL_QUAD_LUMINANCE4_SGIS 0x8120 +#define GL_QUAD_LUMINANCE8_SGIS 0x8121 +#define GL_QUAD_INTENSITY4_SGIS 0x8122 +#define GL_QUAD_INTENSITY8_SGIS 0x8123 +#define GL_DUAL_TEXTURE_SELECT_SGIS 0x8124 +#define GL_QUAD_TEXTURE_SELECT_SGIS 0x8125 +#endif + +#ifndef GL_SGIX_sprite +#define GL_SPRITE_SGIX 0x8148 +#define GL_SPRITE_MODE_SGIX 0x8149 +#define GL_SPRITE_AXIS_SGIX 0x814A +#define GL_SPRITE_TRANSLATION_SGIX 0x814B +#define GL_SPRITE_AXIAL_SGIX 0x814C +#define GL_SPRITE_OBJECT_ALIGNED_SGIX 0x814D +#define GL_SPRITE_EYE_ALIGNED_SGIX 0x814E +#endif + +#ifndef GL_SGIX_texture_multi_buffer +#define GL_TEXTURE_MULTI_BUFFER_HINT_SGIX 0x812E +#endif + +#ifndef GL_EXT_point_parameters +#define GL_POINT_SIZE_MIN_EXT 0x8126 +#define GL_POINT_SIZE_MAX_EXT 0x8127 +#define GL_POINT_FADE_THRESHOLD_SIZE_EXT 0x8128 +#define GL_DISTANCE_ATTENUATION_EXT 0x8129 +#endif + +#ifndef GL_SGIS_point_parameters +#define GL_POINT_SIZE_MIN_SGIS 0x8126 +#define GL_POINT_SIZE_MAX_SGIS 0x8127 +#define GL_POINT_FADE_THRESHOLD_SIZE_SGIS 0x8128 +#define GL_DISTANCE_ATTENUATION_SGIS 0x8129 +#endif + +#ifndef GL_SGIX_instruments +#define GL_INSTRUMENT_BUFFER_POINTER_SGIX 0x8180 +#define GL_INSTRUMENT_MEASUREMENTS_SGIX 0x8181 +#endif + +#ifndef GL_SGIX_texture_scale_bias +#define GL_POST_TEXTURE_FILTER_BIAS_SGIX 0x8179 +#define GL_POST_TEXTURE_FILTER_SCALE_SGIX 0x817A +#define GL_POST_TEXTURE_FILTER_BIAS_RANGE_SGIX 0x817B +#define GL_POST_TEXTURE_FILTER_SCALE_RANGE_SGIX 0x817C +#endif + +#ifndef GL_SGIX_framezoom +#define GL_FRAMEZOOM_SGIX 0x818B +#define GL_FRAMEZOOM_FACTOR_SGIX 0x818C +#define GL_MAX_FRAMEZOOM_FACTOR_SGIX 0x818D +#endif + +#ifndef GL_SGIX_tag_sample_buffer +#endif + +#ifndef GL_FfdMaskSGIX +#define GL_TEXTURE_DEFORMATION_BIT_SGIX 0x00000001 +#define GL_GEOMETRY_DEFORMATION_BIT_SGIX 0x00000002 +#endif + +#ifndef GL_SGIX_polynomial_ffd +#define GL_GEOMETRY_DEFORMATION_SGIX 0x8194 +#define GL_TEXTURE_DEFORMATION_SGIX 0x8195 +#define GL_DEFORMATIONS_MASK_SGIX 0x8196 +#define GL_MAX_DEFORMATION_ORDER_SGIX 0x8197 +#endif + +#ifndef GL_SGIX_reference_plane +#define GL_REFERENCE_PLANE_SGIX 0x817D +#define GL_REFERENCE_PLANE_EQUATION_SGIX 0x817E +#endif + +#ifndef GL_SGIX_flush_raster +#endif + +#ifndef GL_SGIX_depth_texture +#define GL_DEPTH_COMPONENT16_SGIX 0x81A5 +#define GL_DEPTH_COMPONENT24_SGIX 0x81A6 +#define GL_DEPTH_COMPONENT32_SGIX 0x81A7 +#endif + +#ifndef GL_SGIS_fog_function +#define GL_FOG_FUNC_SGIS 0x812A +#define GL_FOG_FUNC_POINTS_SGIS 0x812B +#define GL_MAX_FOG_FUNC_POINTS_SGIS 0x812C +#endif + +#ifndef GL_SGIX_fog_offset +#define GL_FOG_OFFSET_SGIX 0x8198 +#define GL_FOG_OFFSET_VALUE_SGIX 0x8199 +#endif + +#ifndef GL_HP_image_transform +#define GL_IMAGE_SCALE_X_HP 0x8155 +#define GL_IMAGE_SCALE_Y_HP 0x8156 +#define GL_IMAGE_TRANSLATE_X_HP 0x8157 +#define GL_IMAGE_TRANSLATE_Y_HP 0x8158 +#define GL_IMAGE_ROTATE_ANGLE_HP 0x8159 +#define GL_IMAGE_ROTATE_ORIGIN_X_HP 0x815A +#define GL_IMAGE_ROTATE_ORIGIN_Y_HP 0x815B +#define GL_IMAGE_MAG_FILTER_HP 0x815C +#define GL_IMAGE_MIN_FILTER_HP 0x815D +#define GL_IMAGE_CUBIC_WEIGHT_HP 0x815E +#define GL_CUBIC_HP 0x815F +#define GL_AVERAGE_HP 0x8160 +#define GL_IMAGE_TRANSFORM_2D_HP 0x8161 +#define GL_POST_IMAGE_TRANSFORM_COLOR_TABLE_HP 0x8162 +#define GL_PROXY_POST_IMAGE_TRANSFORM_COLOR_TABLE_HP 0x8163 +#endif + +#ifndef GL_HP_convolution_border_modes +#define GL_IGNORE_BORDER_HP 0x8150 +#define GL_CONSTANT_BORDER_HP 0x8151 +#define GL_REPLICATE_BORDER_HP 0x8153 +#define GL_CONVOLUTION_BORDER_COLOR_HP 0x8154 +#endif + +#ifndef GL_INGR_palette_buffer +#endif + +#ifndef GL_SGIX_texture_add_env +#define GL_TEXTURE_ENV_BIAS_SGIX 0x80BE +#endif + +#ifndef GL_EXT_color_subtable +#endif + +#ifndef GL_PGI_vertex_hints +#define GL_VERTEX_DATA_HINT_PGI 0x1A22A +#define GL_VERTEX_CONSISTENT_HINT_PGI 0x1A22B +#define GL_MATERIAL_SIDE_HINT_PGI 0x1A22C +#define GL_MAX_VERTEX_HINT_PGI 0x1A22D +#define GL_COLOR3_BIT_PGI 0x00010000 +#define GL_COLOR4_BIT_PGI 0x00020000 +#define GL_EDGEFLAG_BIT_PGI 0x00040000 +#define GL_INDEX_BIT_PGI 0x00080000 +#define GL_MAT_AMBIENT_BIT_PGI 0x00100000 +#define GL_MAT_AMBIENT_AND_DIFFUSE_BIT_PGI 0x00200000 +#define GL_MAT_DIFFUSE_BIT_PGI 0x00400000 +#define GL_MAT_EMISSION_BIT_PGI 0x00800000 +#define GL_MAT_COLOR_INDEXES_BIT_PGI 0x01000000 +#define GL_MAT_SHININESS_BIT_PGI 0x02000000 +#define GL_MAT_SPECULAR_BIT_PGI 0x04000000 +#define GL_NORMAL_BIT_PGI 0x08000000 +#define GL_TEXCOORD1_BIT_PGI 0x10000000 +#define GL_TEXCOORD2_BIT_PGI 0x20000000 +#define GL_TEXCOORD3_BIT_PGI 0x40000000 +#define GL_TEXCOORD4_BIT_PGI 0x80000000 +#define GL_VERTEX23_BIT_PGI 0x00000004 +#define GL_VERTEX4_BIT_PGI 0x00000008 +#endif + +#ifndef GL_PGI_misc_hints +#define GL_PREFER_DOUBLEBUFFER_HINT_PGI 0x1A1F8 +#define GL_CONSERVE_MEMORY_HINT_PGI 0x1A1FD +#define GL_RECLAIM_MEMORY_HINT_PGI 0x1A1FE +#define GL_NATIVE_GRAPHICS_HANDLE_PGI 0x1A202 +#define GL_NATIVE_GRAPHICS_BEGIN_HINT_PGI 0x1A203 +#define GL_NATIVE_GRAPHICS_END_HINT_PGI 0x1A204 +#define GL_ALWAYS_FAST_HINT_PGI 0x1A20C +#define GL_ALWAYS_SOFT_HINT_PGI 0x1A20D +#define GL_ALLOW_DRAW_OBJ_HINT_PGI 0x1A20E +#define GL_ALLOW_DRAW_WIN_HINT_PGI 0x1A20F +#define GL_ALLOW_DRAW_FRG_HINT_PGI 0x1A210 +#define GL_ALLOW_DRAW_MEM_HINT_PGI 0x1A211 +#define GL_STRICT_DEPTHFUNC_HINT_PGI 0x1A216 +#define GL_STRICT_LIGHTING_HINT_PGI 0x1A217 +#define GL_STRICT_SCISSOR_HINT_PGI 0x1A218 +#define GL_FULL_STIPPLE_HINT_PGI 0x1A219 +#define GL_CLIP_NEAR_HINT_PGI 0x1A220 +#define GL_CLIP_FAR_HINT_PGI 0x1A221 +#define GL_WIDE_LINE_HINT_PGI 0x1A222 +#define GL_BACK_NORMALS_HINT_PGI 0x1A223 +#endif + +#ifndef GL_EXT_paletted_texture +#define GL_COLOR_INDEX1_EXT 0x80E2 +#define GL_COLOR_INDEX2_EXT 0x80E3 +#define GL_COLOR_INDEX4_EXT 0x80E4 +#define GL_COLOR_INDEX8_EXT 0x80E5 +#define GL_COLOR_INDEX12_EXT 0x80E6 +#define GL_COLOR_INDEX16_EXT 0x80E7 +#define GL_TEXTURE_INDEX_SIZE_EXT 0x80ED +#endif + +#ifndef GL_EXT_clip_volume_hint +#define GL_CLIP_VOLUME_CLIPPING_HINT_EXT 0x80F0 +#endif + +#ifndef GL_SGIX_list_priority +#define GL_LIST_PRIORITY_SGIX 0x8182 +#endif + +#ifndef GL_SGIX_ir_instrument1 +#define GL_IR_INSTRUMENT1_SGIX 0x817F +#endif + +#ifndef GL_SGIX_calligraphic_fragment +#define GL_CALLIGRAPHIC_FRAGMENT_SGIX 0x8183 +#endif + +#ifndef GL_SGIX_texture_lod_bias +#define GL_TEXTURE_LOD_BIAS_S_SGIX 0x818E +#define GL_TEXTURE_LOD_BIAS_T_SGIX 0x818F +#define GL_TEXTURE_LOD_BIAS_R_SGIX 0x8190 +#endif + +#ifndef GL_SGIX_shadow_ambient +#define GL_SHADOW_AMBIENT_SGIX 0x80BF +#endif + +#ifndef GL_EXT_index_texture +#endif + +#ifndef GL_EXT_index_material +#define GL_INDEX_MATERIAL_EXT 0x81B8 +#define GL_INDEX_MATERIAL_PARAMETER_EXT 0x81B9 +#define GL_INDEX_MATERIAL_FACE_EXT 0x81BA +#endif + +#ifndef GL_EXT_index_func +#define GL_INDEX_TEST_EXT 0x81B5 +#define GL_INDEX_TEST_FUNC_EXT 0x81B6 +#define GL_INDEX_TEST_REF_EXT 0x81B7 +#endif + +#ifndef GL_EXT_index_array_formats +#define GL_IUI_V2F_EXT 0x81AD +#define GL_IUI_V3F_EXT 0x81AE +#define GL_IUI_N3F_V2F_EXT 0x81AF +#define GL_IUI_N3F_V3F_EXT 0x81B0 +#define GL_T2F_IUI_V2F_EXT 0x81B1 +#define GL_T2F_IUI_V3F_EXT 0x81B2 +#define GL_T2F_IUI_N3F_V2F_EXT 0x81B3 +#define GL_T2F_IUI_N3F_V3F_EXT 0x81B4 +#endif + +#ifndef GL_EXT_compiled_vertex_array +#define GL_ARRAY_ELEMENT_LOCK_FIRST_EXT 0x81A8 +#define GL_ARRAY_ELEMENT_LOCK_COUNT_EXT 0x81A9 +#endif + +#ifndef GL_EXT_cull_vertex +#define GL_CULL_VERTEX_EXT 0x81AA +#define GL_CULL_VERTEX_EYE_POSITION_EXT 0x81AB +#define GL_CULL_VERTEX_OBJECT_POSITION_EXT 0x81AC +#endif + +#ifndef GL_SGIX_ycrcb +#define GL_YCRCB_422_SGIX 0x81BB +#define GL_YCRCB_444_SGIX 0x81BC +#endif + +#ifndef GL_SGIX_fragment_lighting +#define GL_FRAGMENT_LIGHTING_SGIX 0x8400 +#define GL_FRAGMENT_COLOR_MATERIAL_SGIX 0x8401 +#define GL_FRAGMENT_COLOR_MATERIAL_FACE_SGIX 0x8402 +#define GL_FRAGMENT_COLOR_MATERIAL_PARAMETER_SGIX 0x8403 +#define GL_MAX_FRAGMENT_LIGHTS_SGIX 0x8404 +#define GL_MAX_ACTIVE_LIGHTS_SGIX 0x8405 +#define GL_CURRENT_RASTER_NORMAL_SGIX 0x8406 +#define GL_LIGHT_ENV_MODE_SGIX 0x8407 +#define GL_FRAGMENT_LIGHT_MODEL_LOCAL_VIEWER_SGIX 0x8408 +#define GL_FRAGMENT_LIGHT_MODEL_TWO_SIDE_SGIX 0x8409 +#define GL_FRAGMENT_LIGHT_MODEL_AMBIENT_SGIX 0x840A +#define GL_FRAGMENT_LIGHT_MODEL_NORMAL_INTERPOLATION_SGIX 0x840B +#define GL_FRAGMENT_LIGHT0_SGIX 0x840C +#define GL_FRAGMENT_LIGHT1_SGIX 0x840D +#define GL_FRAGMENT_LIGHT2_SGIX 0x840E +#define GL_FRAGMENT_LIGHT3_SGIX 0x840F +#define GL_FRAGMENT_LIGHT4_SGIX 0x8410 +#define GL_FRAGMENT_LIGHT5_SGIX 0x8411 +#define GL_FRAGMENT_LIGHT6_SGIX 0x8412 +#define GL_FRAGMENT_LIGHT7_SGIX 0x8413 +#endif + +#ifndef GL_IBM_rasterpos_clip +#define GL_RASTER_POSITION_UNCLIPPED_IBM 0x19262 +#endif + +#ifndef GL_HP_texture_lighting +#define GL_TEXTURE_LIGHTING_MODE_HP 0x8167 +#define GL_TEXTURE_POST_SPECULAR_HP 0x8168 +#define GL_TEXTURE_PRE_SPECULAR_HP 0x8169 +#endif + +#ifndef GL_EXT_draw_range_elements +#define GL_MAX_ELEMENTS_VERTICES_EXT 0x80E8 +#define GL_MAX_ELEMENTS_INDICES_EXT 0x80E9 +#endif + +#ifndef GL_WIN_phong_shading +#define GL_PHONG_WIN 0x80EA +#define GL_PHONG_HINT_WIN 0x80EB +#endif + +#ifndef GL_WIN_specular_fog +#define GL_FOG_SPECULAR_TEXTURE_WIN 0x80EC +#endif + +#ifndef GL_EXT_light_texture +#define GL_FRAGMENT_MATERIAL_EXT 0x8349 +#define GL_FRAGMENT_NORMAL_EXT 0x834A +#define GL_FRAGMENT_COLOR_EXT 0x834C +#define GL_ATTENUATION_EXT 0x834D +#define GL_SHADOW_ATTENUATION_EXT 0x834E +#define GL_TEXTURE_APPLICATION_MODE_EXT 0x834F +#define GL_TEXTURE_LIGHT_EXT 0x8350 +#define GL_TEXTURE_MATERIAL_FACE_EXT 0x8351 +#define GL_TEXTURE_MATERIAL_PARAMETER_EXT 0x8352 +/* reuse GL_FRAGMENT_DEPTH_EXT */ +#endif + +#ifndef GL_SGIX_blend_alpha_minmax +#define GL_ALPHA_MIN_SGIX 0x8320 +#define GL_ALPHA_MAX_SGIX 0x8321 +#endif + +#ifndef GL_SGIX_impact_pixel_texture +#define GL_PIXEL_TEX_GEN_Q_CEILING_SGIX 0x8184 +#define GL_PIXEL_TEX_GEN_Q_ROUND_SGIX 0x8185 +#define GL_PIXEL_TEX_GEN_Q_FLOOR_SGIX 0x8186 +#define GL_PIXEL_TEX_GEN_ALPHA_REPLACE_SGIX 0x8187 +#define GL_PIXEL_TEX_GEN_ALPHA_NO_REPLACE_SGIX 0x8188 +#define GL_PIXEL_TEX_GEN_ALPHA_LS_SGIX 0x8189 +#define GL_PIXEL_TEX_GEN_ALPHA_MS_SGIX 0x818A +#endif + +#ifndef GL_EXT_bgra +#define GL_BGR_EXT 0x80E0 +#define GL_BGRA_EXT 0x80E1 +#endif + +#ifndef GL_SGIX_async +#define GL_ASYNC_MARKER_SGIX 0x8329 +#endif + +#ifndef GL_SGIX_async_pixel +#define GL_ASYNC_TEX_IMAGE_SGIX 0x835C +#define GL_ASYNC_DRAW_PIXELS_SGIX 0x835D +#define GL_ASYNC_READ_PIXELS_SGIX 0x835E +#define GL_MAX_ASYNC_TEX_IMAGE_SGIX 0x835F +#define GL_MAX_ASYNC_DRAW_PIXELS_SGIX 0x8360 +#define GL_MAX_ASYNC_READ_PIXELS_SGIX 0x8361 +#endif + +#ifndef GL_SGIX_async_histogram +#define GL_ASYNC_HISTOGRAM_SGIX 0x832C +#define GL_MAX_ASYNC_HISTOGRAM_SGIX 0x832D +#endif + +#ifndef GL_INTEL_texture_scissor +#endif + +#ifndef GL_INTEL_parallel_arrays +#define GL_PARALLEL_ARRAYS_INTEL 0x83F4 +#define GL_VERTEX_ARRAY_PARALLEL_POINTERS_INTEL 0x83F5 +#define GL_NORMAL_ARRAY_PARALLEL_POINTERS_INTEL 0x83F6 +#define GL_COLOR_ARRAY_PARALLEL_POINTERS_INTEL 0x83F7 +#define GL_TEXTURE_COORD_ARRAY_PARALLEL_POINTERS_INTEL 0x83F8 +#endif + +#ifndef GL_HP_occlusion_test +#define GL_OCCLUSION_TEST_HP 0x8165 +#define GL_OCCLUSION_TEST_RESULT_HP 0x8166 +#endif + +#ifndef GL_EXT_pixel_transform +#define GL_PIXEL_TRANSFORM_2D_EXT 0x8330 +#define GL_PIXEL_MAG_FILTER_EXT 0x8331 +#define GL_PIXEL_MIN_FILTER_EXT 0x8332 +#define GL_PIXEL_CUBIC_WEIGHT_EXT 0x8333 +#define GL_CUBIC_EXT 0x8334 +#define GL_AVERAGE_EXT 0x8335 +#define GL_PIXEL_TRANSFORM_2D_STACK_DEPTH_EXT 0x8336 +#define GL_MAX_PIXEL_TRANSFORM_2D_STACK_DEPTH_EXT 0x8337 +#define GL_PIXEL_TRANSFORM_2D_MATRIX_EXT 0x8338 +#endif + +#ifndef GL_EXT_pixel_transform_color_table +#endif + +#ifndef GL_EXT_shared_texture_palette +#define GL_SHARED_TEXTURE_PALETTE_EXT 0x81FB +#endif + +#ifndef GL_EXT_separate_specular_color +#define GL_LIGHT_MODEL_COLOR_CONTROL_EXT 0x81F8 +#define GL_SINGLE_COLOR_EXT 0x81F9 +#define GL_SEPARATE_SPECULAR_COLOR_EXT 0x81FA +#endif + +#ifndef GL_EXT_secondary_color +#define GL_COLOR_SUM_EXT 0x8458 +#define GL_CURRENT_SECONDARY_COLOR_EXT 0x8459 +#define GL_SECONDARY_COLOR_ARRAY_SIZE_EXT 0x845A +#define GL_SECONDARY_COLOR_ARRAY_TYPE_EXT 0x845B +#define GL_SECONDARY_COLOR_ARRAY_STRIDE_EXT 0x845C +#define GL_SECONDARY_COLOR_ARRAY_POINTER_EXT 0x845D +#define GL_SECONDARY_COLOR_ARRAY_EXT 0x845E +#endif + +#ifndef GL_EXT_texture_perturb_normal +#define GL_PERTURB_EXT 0x85AE +#define GL_TEXTURE_NORMAL_EXT 0x85AF +#endif + +#ifndef GL_EXT_multi_draw_arrays +#endif + +#ifndef GL_EXT_fog_coord +#define GL_FOG_COORDINATE_SOURCE_EXT 0x8450 +#define GL_FOG_COORDINATE_EXT 0x8451 +#define GL_FRAGMENT_DEPTH_EXT 0x8452 +#define GL_CURRENT_FOG_COORDINATE_EXT 0x8453 +#define GL_FOG_COORDINATE_ARRAY_TYPE_EXT 0x8454 +#define GL_FOG_COORDINATE_ARRAY_STRIDE_EXT 0x8455 +#define GL_FOG_COORDINATE_ARRAY_POINTER_EXT 0x8456 +#define GL_FOG_COORDINATE_ARRAY_EXT 0x8457 +#endif + +#ifndef GL_REND_screen_coordinates +#define GL_SCREEN_COORDINATES_REND 0x8490 +#define GL_INVERTED_SCREEN_W_REND 0x8491 +#endif + +#ifndef GL_EXT_coordinate_frame +#define GL_TANGENT_ARRAY_EXT 0x8439 +#define GL_BINORMAL_ARRAY_EXT 0x843A +#define GL_CURRENT_TANGENT_EXT 0x843B +#define GL_CURRENT_BINORMAL_EXT 0x843C +#define GL_TANGENT_ARRAY_TYPE_EXT 0x843E +#define GL_TANGENT_ARRAY_STRIDE_EXT 0x843F +#define GL_BINORMAL_ARRAY_TYPE_EXT 0x8440 +#define GL_BINORMAL_ARRAY_STRIDE_EXT 0x8441 +#define GL_TANGENT_ARRAY_POINTER_EXT 0x8442 +#define GL_BINORMAL_ARRAY_POINTER_EXT 0x8443 +#define GL_MAP1_TANGENT_EXT 0x8444 +#define GL_MAP2_TANGENT_EXT 0x8445 +#define GL_MAP1_BINORMAL_EXT 0x8446 +#define GL_MAP2_BINORMAL_EXT 0x8447 +#endif + +#ifndef GL_EXT_texture_env_combine +#define GL_COMBINE_EXT 0x8570 +#define GL_COMBINE_RGB_EXT 0x8571 +#define GL_COMBINE_ALPHA_EXT 0x8572 +#define GL_RGB_SCALE_EXT 0x8573 +#define GL_ADD_SIGNED_EXT 0x8574 +#define GL_INTERPOLATE_EXT 0x8575 +#define GL_CONSTANT_EXT 0x8576 +#define GL_PRIMARY_COLOR_EXT 0x8577 +#define GL_PREVIOUS_EXT 0x8578 +#define GL_SOURCE0_RGB_EXT 0x8580 +#define GL_SOURCE1_RGB_EXT 0x8581 +#define GL_SOURCE2_RGB_EXT 0x8582 +#define GL_SOURCE0_ALPHA_EXT 0x8588 +#define GL_SOURCE1_ALPHA_EXT 0x8589 +#define GL_SOURCE2_ALPHA_EXT 0x858A +#define GL_OPERAND0_RGB_EXT 0x8590 +#define GL_OPERAND1_RGB_EXT 0x8591 +#define GL_OPERAND2_RGB_EXT 0x8592 +#define GL_OPERAND0_ALPHA_EXT 0x8598 +#define GL_OPERAND1_ALPHA_EXT 0x8599 +#define GL_OPERAND2_ALPHA_EXT 0x859A +#endif + +#ifndef GL_APPLE_specular_vector +#define GL_LIGHT_MODEL_SPECULAR_VECTOR_APPLE 0x85B0 +#endif + +#ifndef GL_APPLE_transform_hint +#define GL_TRANSFORM_HINT_APPLE 0x85B1 +#endif + +#ifndef GL_SGIX_fog_scale +#define GL_FOG_SCALE_SGIX 0x81FC +#define GL_FOG_SCALE_VALUE_SGIX 0x81FD +#endif + +#ifndef GL_SUNX_constant_data +#define GL_UNPACK_CONSTANT_DATA_SUNX 0x81D5 +#define GL_TEXTURE_CONSTANT_DATA_SUNX 0x81D6 +#endif + +#ifndef GL_SUN_global_alpha +#define GL_GLOBAL_ALPHA_SUN 0x81D9 +#define GL_GLOBAL_ALPHA_FACTOR_SUN 0x81DA +#endif + +#ifndef GL_SUN_triangle_list +#define GL_RESTART_SUN 0x0001 +#define GL_REPLACE_MIDDLE_SUN 0x0002 +#define GL_REPLACE_OLDEST_SUN 0x0003 +#define GL_TRIANGLE_LIST_SUN 0x81D7 +#define GL_REPLACEMENT_CODE_SUN 0x81D8 +#define GL_REPLACEMENT_CODE_ARRAY_SUN 0x85C0 +#define GL_REPLACEMENT_CODE_ARRAY_TYPE_SUN 0x85C1 +#define GL_REPLACEMENT_CODE_ARRAY_STRIDE_SUN 0x85C2 +#define GL_REPLACEMENT_CODE_ARRAY_POINTER_SUN 0x85C3 +#define GL_R1UI_V3F_SUN 0x85C4 +#define GL_R1UI_C4UB_V3F_SUN 0x85C5 +#define GL_R1UI_C3F_V3F_SUN 0x85C6 +#define GL_R1UI_N3F_V3F_SUN 0x85C7 +#define GL_R1UI_C4F_N3F_V3F_SUN 0x85C8 +#define GL_R1UI_T2F_V3F_SUN 0x85C9 +#define GL_R1UI_T2F_N3F_V3F_SUN 0x85CA +#define GL_R1UI_T2F_C4F_N3F_V3F_SUN 0x85CB +#endif + +#ifndef GL_SUN_vertex +#endif + +#ifndef GL_EXT_blend_func_separate +#define GL_BLEND_DST_RGB_EXT 0x80C8 +#define GL_BLEND_SRC_RGB_EXT 0x80C9 +#define GL_BLEND_DST_ALPHA_EXT 0x80CA +#define GL_BLEND_SRC_ALPHA_EXT 0x80CB +#endif + +#ifndef GL_INGR_color_clamp +#define GL_RED_MIN_CLAMP_INGR 0x8560 +#define GL_GREEN_MIN_CLAMP_INGR 0x8561 +#define GL_BLUE_MIN_CLAMP_INGR 0x8562 +#define GL_ALPHA_MIN_CLAMP_INGR 0x8563 +#define GL_RED_MAX_CLAMP_INGR 0x8564 +#define GL_GREEN_MAX_CLAMP_INGR 0x8565 +#define GL_BLUE_MAX_CLAMP_INGR 0x8566 +#define GL_ALPHA_MAX_CLAMP_INGR 0x8567 +#endif + +#ifndef GL_INGR_interlace_read +#define GL_INTERLACE_READ_INGR 0x8568 +#endif + +#ifndef GL_EXT_stencil_wrap +#define GL_INCR_WRAP_EXT 0x8507 +#define GL_DECR_WRAP_EXT 0x8508 +#endif + +#ifndef GL_EXT_422_pixels +#define GL_422_EXT 0x80CC +#define GL_422_REV_EXT 0x80CD +#define GL_422_AVERAGE_EXT 0x80CE +#define GL_422_REV_AVERAGE_EXT 0x80CF +#endif + +#ifndef GL_NV_texgen_reflection +#define GL_NORMAL_MAP_NV 0x8511 +#define GL_REFLECTION_MAP_NV 0x8512 +#endif + +#ifndef GL_EXT_texture_cube_map +#define GL_NORMAL_MAP_EXT 0x8511 +#define GL_REFLECTION_MAP_EXT 0x8512 +#define GL_TEXTURE_CUBE_MAP_EXT 0x8513 +#define GL_TEXTURE_BINDING_CUBE_MAP_EXT 0x8514 +#define GL_TEXTURE_CUBE_MAP_POSITIVE_X_EXT 0x8515 +#define GL_TEXTURE_CUBE_MAP_NEGATIVE_X_EXT 0x8516 +#define GL_TEXTURE_CUBE_MAP_POSITIVE_Y_EXT 0x8517 +#define GL_TEXTURE_CUBE_MAP_NEGATIVE_Y_EXT 0x8518 +#define GL_TEXTURE_CUBE_MAP_POSITIVE_Z_EXT 0x8519 +#define GL_TEXTURE_CUBE_MAP_NEGATIVE_Z_EXT 0x851A +#define GL_PROXY_TEXTURE_CUBE_MAP_EXT 0x851B +#define GL_MAX_CUBE_MAP_TEXTURE_SIZE_EXT 0x851C +#endif + +#ifndef GL_SUN_convolution_border_modes +#define GL_WRAP_BORDER_SUN 0x81D4 +#endif + +#ifndef GL_EXT_texture_env_add +#endif + +#ifndef GL_EXT_texture_lod_bias +#define GL_MAX_TEXTURE_LOD_BIAS_EXT 0x84FD +#define GL_TEXTURE_FILTER_CONTROL_EXT 0x8500 +#define GL_TEXTURE_LOD_BIAS_EXT 0x8501 +#endif + +#ifndef GL_EXT_texture_filter_anisotropic +#define GL_TEXTURE_MAX_ANISOTROPY_EXT 0x84FE +#define GL_MAX_TEXTURE_MAX_ANISOTROPY_EXT 0x84FF +#endif + +#ifndef GL_EXT_vertex_weighting +#define GL_MODELVIEW0_STACK_DEPTH_EXT GL_MODELVIEW_STACK_DEPTH +#define GL_MODELVIEW1_STACK_DEPTH_EXT 0x8502 +#define GL_MODELVIEW0_MATRIX_EXT GL_MODELVIEW_MATRIX +#define GL_MODELVIEW1_MATRIX_EXT 0x8506 +#define GL_VERTEX_WEIGHTING_EXT 0x8509 +#define GL_MODELVIEW0_EXT GL_MODELVIEW +#define GL_MODELVIEW1_EXT 0x850A +#define GL_CURRENT_VERTEX_WEIGHT_EXT 0x850B +#define GL_VERTEX_WEIGHT_ARRAY_EXT 0x850C +#define GL_VERTEX_WEIGHT_ARRAY_SIZE_EXT 0x850D +#define GL_VERTEX_WEIGHT_ARRAY_TYPE_EXT 0x850E +#define GL_VERTEX_WEIGHT_ARRAY_STRIDE_EXT 0x850F +#define GL_VERTEX_WEIGHT_ARRAY_POINTER_EXT 0x8510 +#endif + +#ifndef GL_NV_light_max_exponent +#define GL_MAX_SHININESS_NV 0x8504 +#define GL_MAX_SPOT_EXPONENT_NV 0x8505 +#endif + +#ifndef GL_NV_vertex_array_range +#define GL_VERTEX_ARRAY_RANGE_NV 0x851D +#define GL_VERTEX_ARRAY_RANGE_LENGTH_NV 0x851E +#define GL_VERTEX_ARRAY_RANGE_VALID_NV 0x851F +#define GL_MAX_VERTEX_ARRAY_RANGE_ELEMENT_NV 0x8520 +#define GL_VERTEX_ARRAY_RANGE_POINTER_NV 0x8521 +#endif + +#ifndef GL_NV_register_combiners +#define GL_REGISTER_COMBINERS_NV 0x8522 +#define GL_VARIABLE_A_NV 0x8523 +#define GL_VARIABLE_B_NV 0x8524 +#define GL_VARIABLE_C_NV 0x8525 +#define GL_VARIABLE_D_NV 0x8526 +#define GL_VARIABLE_E_NV 0x8527 +#define GL_VARIABLE_F_NV 0x8528 +#define GL_VARIABLE_G_NV 0x8529 +#define GL_CONSTANT_COLOR0_NV 0x852A +#define GL_CONSTANT_COLOR1_NV 0x852B +#define GL_PRIMARY_COLOR_NV 0x852C +#define GL_SECONDARY_COLOR_NV 0x852D +#define GL_SPARE0_NV 0x852E +#define GL_SPARE1_NV 0x852F +#define GL_DISCARD_NV 0x8530 +#define GL_E_TIMES_F_NV 0x8531 +#define GL_SPARE0_PLUS_SECONDARY_COLOR_NV 0x8532 +#define GL_UNSIGNED_IDENTITY_NV 0x8536 +#define GL_UNSIGNED_INVERT_NV 0x8537 +#define GL_EXPAND_NORMAL_NV 0x8538 +#define GL_EXPAND_NEGATE_NV 0x8539 +#define GL_HALF_BIAS_NORMAL_NV 0x853A +#define GL_HALF_BIAS_NEGATE_NV 0x853B +#define GL_SIGNED_IDENTITY_NV 0x853C +#define GL_SIGNED_NEGATE_NV 0x853D +#define GL_SCALE_BY_TWO_NV 0x853E +#define GL_SCALE_BY_FOUR_NV 0x853F +#define GL_SCALE_BY_ONE_HALF_NV 0x8540 +#define GL_BIAS_BY_NEGATIVE_ONE_HALF_NV 0x8541 +#define GL_COMBINER_INPUT_NV 0x8542 +#define GL_COMBINER_MAPPING_NV 0x8543 +#define GL_COMBINER_COMPONENT_USAGE_NV 0x8544 +#define GL_COMBINER_AB_DOT_PRODUCT_NV 0x8545 +#define GL_COMBINER_CD_DOT_PRODUCT_NV 0x8546 +#define GL_COMBINER_MUX_SUM_NV 0x8547 +#define GL_COMBINER_SCALE_NV 0x8548 +#define GL_COMBINER_BIAS_NV 0x8549 +#define GL_COMBINER_AB_OUTPUT_NV 0x854A +#define GL_COMBINER_CD_OUTPUT_NV 0x854B +#define GL_COMBINER_SUM_OUTPUT_NV 0x854C +#define GL_MAX_GENERAL_COMBINERS_NV 0x854D +#define GL_NUM_GENERAL_COMBINERS_NV 0x854E +#define GL_COLOR_SUM_CLAMP_NV 0x854F +#define GL_COMBINER0_NV 0x8550 +#define GL_COMBINER1_NV 0x8551 +#define GL_COMBINER2_NV 0x8552 +#define GL_COMBINER3_NV 0x8553 +#define GL_COMBINER4_NV 0x8554 +#define GL_COMBINER5_NV 0x8555 +#define GL_COMBINER6_NV 0x8556 +#define GL_COMBINER7_NV 0x8557 +/* reuse GL_TEXTURE0_ARB */ +/* reuse GL_TEXTURE1_ARB */ +/* reuse GL_ZERO */ +/* reuse GL_NONE */ +/* reuse GL_FOG */ +#endif + +#ifndef GL_NV_fog_distance +#define GL_FOG_DISTANCE_MODE_NV 0x855A +#define GL_EYE_RADIAL_NV 0x855B +#define GL_EYE_PLANE_ABSOLUTE_NV 0x855C +/* reuse GL_EYE_PLANE */ +#endif + +#ifndef GL_NV_texgen_emboss +#define GL_EMBOSS_LIGHT_NV 0x855D +#define GL_EMBOSS_CONSTANT_NV 0x855E +#define GL_EMBOSS_MAP_NV 0x855F +#endif + +#ifndef GL_NV_blend_square +#endif + +#ifndef GL_NV_texture_env_combine4 +#define GL_COMBINE4_NV 0x8503 +#define GL_SOURCE3_RGB_NV 0x8583 +#define GL_SOURCE3_ALPHA_NV 0x858B +#define GL_OPERAND3_RGB_NV 0x8593 +#define GL_OPERAND3_ALPHA_NV 0x859B +#endif + +#ifndef GL_MESA_resize_buffers +#endif + +#ifndef GL_MESA_window_pos +#endif + +#ifndef GL_EXT_texture_compression_s3tc +#define GL_COMPRESSED_RGB_S3TC_DXT1_EXT 0x83F0 +#define GL_COMPRESSED_RGBA_S3TC_DXT1_EXT 0x83F1 +#define GL_COMPRESSED_RGBA_S3TC_DXT3_EXT 0x83F2 +#define GL_COMPRESSED_RGBA_S3TC_DXT5_EXT 0x83F3 +#endif + +#ifndef GL_IBM_cull_vertex +#define GL_CULL_VERTEX_IBM 103050 +#endif + +#ifndef GL_IBM_multimode_draw_arrays +#endif + +#ifndef GL_IBM_vertex_array_lists +#define GL_VERTEX_ARRAY_LIST_IBM 103070 +#define GL_NORMAL_ARRAY_LIST_IBM 103071 +#define GL_COLOR_ARRAY_LIST_IBM 103072 +#define GL_INDEX_ARRAY_LIST_IBM 103073 +#define GL_TEXTURE_COORD_ARRAY_LIST_IBM 103074 +#define GL_EDGE_FLAG_ARRAY_LIST_IBM 103075 +#define GL_FOG_COORDINATE_ARRAY_LIST_IBM 103076 +#define GL_SECONDARY_COLOR_ARRAY_LIST_IBM 103077 +#define GL_VERTEX_ARRAY_LIST_STRIDE_IBM 103080 +#define GL_NORMAL_ARRAY_LIST_STRIDE_IBM 103081 +#define GL_COLOR_ARRAY_LIST_STRIDE_IBM 103082 +#define GL_INDEX_ARRAY_LIST_STRIDE_IBM 103083 +#define GL_TEXTURE_COORD_ARRAY_LIST_STRIDE_IBM 103084 +#define GL_EDGE_FLAG_ARRAY_LIST_STRIDE_IBM 103085 +#define GL_FOG_COORDINATE_ARRAY_LIST_STRIDE_IBM 103086 +#define GL_SECONDARY_COLOR_ARRAY_LIST_STRIDE_IBM 103087 +#endif + +#ifndef GL_SGIX_subsample +#define GL_PACK_SUBSAMPLE_RATE_SGIX 0x85A0 +#define GL_UNPACK_SUBSAMPLE_RATE_SGIX 0x85A1 +#define GL_PIXEL_SUBSAMPLE_4444_SGIX 0x85A2 +#define GL_PIXEL_SUBSAMPLE_2424_SGIX 0x85A3 +#define GL_PIXEL_SUBSAMPLE_4242_SGIX 0x85A4 +#endif + +#ifndef GL_SGIX_ycrcb_subsample +#endif + +#ifndef GL_SGIX_ycrcba +#define GL_YCRCB_SGIX 0x8318 +#define GL_YCRCBA_SGIX 0x8319 +#endif + +#ifndef GL_SGI_depth_pass_instrument +#define GL_DEPTH_PASS_INSTRUMENT_SGIX 0x8310 +#define GL_DEPTH_PASS_INSTRUMENT_COUNTERS_SGIX 0x8311 +#define GL_DEPTH_PASS_INSTRUMENT_MAX_SGIX 0x8312 +#endif + +#ifndef GL_3DFX_texture_compression_FXT1 +#define GL_COMPRESSED_RGB_FXT1_3DFX 0x86B0 +#define GL_COMPRESSED_RGBA_FXT1_3DFX 0x86B1 +#endif + +#ifndef GL_3DFX_multisample +#define GL_MULTISAMPLE_3DFX 0x86B2 +#define GL_SAMPLE_BUFFERS_3DFX 0x86B3 +#define GL_SAMPLES_3DFX 0x86B4 +#define GL_MULTISAMPLE_BIT_3DFX 0x20000000 +#endif + +#ifndef GL_3DFX_tbuffer +#endif + +#ifndef GL_EXT_multisample +#define GL_MULTISAMPLE_EXT 0x809D +#define GL_SAMPLE_ALPHA_TO_MASK_EXT 0x809E +#define GL_SAMPLE_ALPHA_TO_ONE_EXT 0x809F +#define GL_SAMPLE_MASK_EXT 0x80A0 +#define GL_1PASS_EXT 0x80A1 +#define GL_2PASS_0_EXT 0x80A2 +#define GL_2PASS_1_EXT 0x80A3 +#define GL_4PASS_0_EXT 0x80A4 +#define GL_4PASS_1_EXT 0x80A5 +#define GL_4PASS_2_EXT 0x80A6 +#define GL_4PASS_3_EXT 0x80A7 +#define GL_SAMPLE_BUFFERS_EXT 0x80A8 +#define GL_SAMPLES_EXT 0x80A9 +#define GL_SAMPLE_MASK_VALUE_EXT 0x80AA +#define GL_SAMPLE_MASK_INVERT_EXT 0x80AB +#define GL_SAMPLE_PATTERN_EXT 0x80AC +#define GL_MULTISAMPLE_BIT_EXT 0x20000000 +#endif + +#ifndef GL_SGIX_vertex_preclip +#define GL_VERTEX_PRECLIP_SGIX 0x83EE +#define GL_VERTEX_PRECLIP_HINT_SGIX 0x83EF +#endif + +#ifndef GL_SGIX_convolution_accuracy +#define GL_CONVOLUTION_HINT_SGIX 0x8316 +#endif + +#ifndef GL_SGIX_resample +#define GL_PACK_RESAMPLE_SGIX 0x842C +#define GL_UNPACK_RESAMPLE_SGIX 0x842D +#define GL_RESAMPLE_REPLICATE_SGIX 0x842E +#define GL_RESAMPLE_ZERO_FILL_SGIX 0x842F +#define GL_RESAMPLE_DECIMATE_SGIX 0x8430 +#endif + +#ifndef GL_SGIS_point_line_texgen +#define GL_EYE_DISTANCE_TO_POINT_SGIS 0x81F0 +#define GL_OBJECT_DISTANCE_TO_POINT_SGIS 0x81F1 +#define GL_EYE_DISTANCE_TO_LINE_SGIS 0x81F2 +#define GL_OBJECT_DISTANCE_TO_LINE_SGIS 0x81F3 +#define GL_EYE_POINT_SGIS 0x81F4 +#define GL_OBJECT_POINT_SGIS 0x81F5 +#define GL_EYE_LINE_SGIS 0x81F6 +#define GL_OBJECT_LINE_SGIS 0x81F7 +#endif + +#ifndef GL_SGIS_texture_color_mask +#define GL_TEXTURE_COLOR_WRITEMASK_SGIS 0x81EF +#endif + +#ifndef GL_EXT_texture_env_dot3 +#define GL_DOT3_RGB_EXT 0x8740 +#define GL_DOT3_RGBA_EXT 0x8741 +#endif + +#ifndef GL_ATI_texture_mirror_once +#define GL_MIRROR_CLAMP_ATI 0x8742 +#define GL_MIRROR_CLAMP_TO_EDGE_ATI 0x8743 +#endif + +#ifndef GL_NV_fence +#define GL_ALL_COMPLETED_NV 0x84F2 +#define GL_FENCE_STATUS_NV 0x84F3 +#define GL_FENCE_CONDITION_NV 0x84F4 +#endif + +#ifndef GL_IBM_texture_mirrored_repeat +#define GL_MIRRORED_REPEAT_IBM 0x8370 +#endif + +#ifndef GL_NV_evaluators +#define GL_EVAL_2D_NV 0x86C0 +#define GL_EVAL_TRIANGULAR_2D_NV 0x86C1 +#define GL_MAP_TESSELLATION_NV 0x86C2 +#define GL_MAP_ATTRIB_U_ORDER_NV 0x86C3 +#define GL_MAP_ATTRIB_V_ORDER_NV 0x86C4 +#define GL_EVAL_FRACTIONAL_TESSELLATION_NV 0x86C5 +#define GL_EVAL_VERTEX_ATTRIB0_NV 0x86C6 +#define GL_EVAL_VERTEX_ATTRIB1_NV 0x86C7 +#define GL_EVAL_VERTEX_ATTRIB2_NV 0x86C8 +#define GL_EVAL_VERTEX_ATTRIB3_NV 0x86C9 +#define GL_EVAL_VERTEX_ATTRIB4_NV 0x86CA +#define GL_EVAL_VERTEX_ATTRIB5_NV 0x86CB +#define GL_EVAL_VERTEX_ATTRIB6_NV 0x86CC +#define GL_EVAL_VERTEX_ATTRIB7_NV 0x86CD +#define GL_EVAL_VERTEX_ATTRIB8_NV 0x86CE +#define GL_EVAL_VERTEX_ATTRIB9_NV 0x86CF +#define GL_EVAL_VERTEX_ATTRIB10_NV 0x86D0 +#define GL_EVAL_VERTEX_ATTRIB11_NV 0x86D1 +#define GL_EVAL_VERTEX_ATTRIB12_NV 0x86D2 +#define GL_EVAL_VERTEX_ATTRIB13_NV 0x86D3 +#define GL_EVAL_VERTEX_ATTRIB14_NV 0x86D4 +#define GL_EVAL_VERTEX_ATTRIB15_NV 0x86D5 +#define GL_MAX_MAP_TESSELLATION_NV 0x86D6 +#define GL_MAX_RATIONAL_EVAL_ORDER_NV 0x86D7 +#endif + +#ifndef GL_NV_packed_depth_stencil +#define GL_DEPTH_STENCIL_NV 0x84F9 +#define GL_UNSIGNED_INT_24_8_NV 0x84FA +#endif + +#ifndef GL_NV_register_combiners2 +#define GL_PER_STAGE_CONSTANTS_NV 0x8535 +#endif + +#ifndef GL_NV_texture_compression_vtc +#endif + +#ifndef GL_NV_texture_rectangle +#define GL_TEXTURE_RECTANGLE_NV 0x84F5 +#define GL_TEXTURE_BINDING_RECTANGLE_NV 0x84F6 +#define GL_PROXY_TEXTURE_RECTANGLE_NV 0x84F7 +#define GL_MAX_RECTANGLE_TEXTURE_SIZE_NV 0x84F8 +#endif + +#ifndef GL_NV_texture_shader +#define GL_OFFSET_TEXTURE_RECTANGLE_NV 0x864C +#define GL_OFFSET_TEXTURE_RECTANGLE_SCALE_NV 0x864D +#define GL_DOT_PRODUCT_TEXTURE_RECTANGLE_NV 0x864E +#define GL_RGBA_UNSIGNED_DOT_PRODUCT_MAPPING_NV 0x86D9 +#define GL_UNSIGNED_INT_S8_S8_8_8_NV 0x86DA +#define GL_UNSIGNED_INT_8_8_S8_S8_REV_NV 0x86DB +#define GL_DSDT_MAG_INTENSITY_NV 0x86DC +#define GL_SHADER_CONSISTENT_NV 0x86DD +#define GL_TEXTURE_SHADER_NV 0x86DE +#define GL_SHADER_OPERATION_NV 0x86DF +#define GL_CULL_MODES_NV 0x86E0 +#define GL_OFFSET_TEXTURE_MATRIX_NV 0x86E1 +#define GL_OFFSET_TEXTURE_SCALE_NV 0x86E2 +#define GL_OFFSET_TEXTURE_BIAS_NV 0x86E3 +#define GL_OFFSET_TEXTURE_2D_MATRIX_NV GL_OFFSET_TEXTURE_MATRIX_NV +#define GL_OFFSET_TEXTURE_2D_SCALE_NV GL_OFFSET_TEXTURE_SCALE_NV +#define GL_OFFSET_TEXTURE_2D_BIAS_NV GL_OFFSET_TEXTURE_BIAS_NV +#define GL_PREVIOUS_TEXTURE_INPUT_NV 0x86E4 +#define GL_CONST_EYE_NV 0x86E5 +#define GL_PASS_THROUGH_NV 0x86E6 +#define GL_CULL_FRAGMENT_NV 0x86E7 +#define GL_OFFSET_TEXTURE_2D_NV 0x86E8 +#define GL_DEPENDENT_AR_TEXTURE_2D_NV 0x86E9 +#define GL_DEPENDENT_GB_TEXTURE_2D_NV 0x86EA +#define GL_DOT_PRODUCT_NV 0x86EC +#define GL_DOT_PRODUCT_DEPTH_REPLACE_NV 0x86ED +#define GL_DOT_PRODUCT_TEXTURE_2D_NV 0x86EE +#define GL_DOT_PRODUCT_TEXTURE_CUBE_MAP_NV 0x86F0 +#define GL_DOT_PRODUCT_DIFFUSE_CUBE_MAP_NV 0x86F1 +#define GL_DOT_PRODUCT_REFLECT_CUBE_MAP_NV 0x86F2 +#define GL_DOT_PRODUCT_CONST_EYE_REFLECT_CUBE_MAP_NV 0x86F3 +#define GL_HILO_NV 0x86F4 +#define GL_DSDT_NV 0x86F5 +#define GL_DSDT_MAG_NV 0x86F6 +#define GL_DSDT_MAG_VIB_NV 0x86F7 +#define GL_HILO16_NV 0x86F8 +#define GL_SIGNED_HILO_NV 0x86F9 +#define GL_SIGNED_HILO16_NV 0x86FA +#define GL_SIGNED_RGBA_NV 0x86FB +#define GL_SIGNED_RGBA8_NV 0x86FC +#define GL_SIGNED_RGB_NV 0x86FE +#define GL_SIGNED_RGB8_NV 0x86FF +#define GL_SIGNED_LUMINANCE_NV 0x8701 +#define GL_SIGNED_LUMINANCE8_NV 0x8702 +#define GL_SIGNED_LUMINANCE_ALPHA_NV 0x8703 +#define GL_SIGNED_LUMINANCE8_ALPHA8_NV 0x8704 +#define GL_SIGNED_ALPHA_NV 0x8705 +#define GL_SIGNED_ALPHA8_NV 0x8706 +#define GL_SIGNED_INTENSITY_NV 0x8707 +#define GL_SIGNED_INTENSITY8_NV 0x8708 +#define GL_DSDT8_NV 0x8709 +#define GL_DSDT8_MAG8_NV 0x870A +#define GL_DSDT8_MAG8_INTENSITY8_NV 0x870B +#define GL_SIGNED_RGB_UNSIGNED_ALPHA_NV 0x870C +#define GL_SIGNED_RGB8_UNSIGNED_ALPHA8_NV 0x870D +#define GL_HI_SCALE_NV 0x870E +#define GL_LO_SCALE_NV 0x870F +#define GL_DS_SCALE_NV 0x8710 +#define GL_DT_SCALE_NV 0x8711 +#define GL_MAGNITUDE_SCALE_NV 0x8712 +#define GL_VIBRANCE_SCALE_NV 0x8713 +#define GL_HI_BIAS_NV 0x8714 +#define GL_LO_BIAS_NV 0x8715 +#define GL_DS_BIAS_NV 0x8716 +#define GL_DT_BIAS_NV 0x8717 +#define GL_MAGNITUDE_BIAS_NV 0x8718 +#define GL_VIBRANCE_BIAS_NV 0x8719 +#define GL_TEXTURE_BORDER_VALUES_NV 0x871A +#define GL_TEXTURE_HI_SIZE_NV 0x871B +#define GL_TEXTURE_LO_SIZE_NV 0x871C +#define GL_TEXTURE_DS_SIZE_NV 0x871D +#define GL_TEXTURE_DT_SIZE_NV 0x871E +#define GL_TEXTURE_MAG_SIZE_NV 0x871F +#endif + +#ifndef GL_NV_texture_shader2 +#define GL_DOT_PRODUCT_TEXTURE_3D_NV 0x86EF +#endif + +#ifndef GL_NV_vertex_array_range2 +#define GL_VERTEX_ARRAY_RANGE_WITHOUT_FLUSH_NV 0x8533 +#endif + +#ifndef GL_NV_vertex_program +#define GL_VERTEX_PROGRAM_NV 0x8620 +#define GL_VERTEX_STATE_PROGRAM_NV 0x8621 +#define GL_ATTRIB_ARRAY_SIZE_NV 0x8623 +#define GL_ATTRIB_ARRAY_STRIDE_NV 0x8624 +#define GL_ATTRIB_ARRAY_TYPE_NV 0x8625 +#define GL_CURRENT_ATTRIB_NV 0x8626 +#define GL_PROGRAM_LENGTH_NV 0x8627 +#define GL_PROGRAM_STRING_NV 0x8628 +#define GL_MODELVIEW_PROJECTION_NV 0x8629 +#define GL_IDENTITY_NV 0x862A +#define GL_INVERSE_NV 0x862B +#define GL_TRANSPOSE_NV 0x862C +#define GL_INVERSE_TRANSPOSE_NV 0x862D +#define GL_MAX_TRACK_MATRIX_STACK_DEPTH_NV 0x862E +#define GL_MAX_TRACK_MATRICES_NV 0x862F +#define GL_MATRIX0_NV 0x8630 +#define GL_MATRIX1_NV 0x8631 +#define GL_MATRIX2_NV 0x8632 +#define GL_MATRIX3_NV 0x8633 +#define GL_MATRIX4_NV 0x8634 +#define GL_MATRIX5_NV 0x8635 +#define GL_MATRIX6_NV 0x8636 +#define GL_MATRIX7_NV 0x8637 +#define GL_CURRENT_MATRIX_STACK_DEPTH_NV 0x8640 +#define GL_CURRENT_MATRIX_NV 0x8641 +#define GL_VERTEX_PROGRAM_POINT_SIZE_NV 0x8642 +#define GL_VERTEX_PROGRAM_TWO_SIDE_NV 0x8643 +#define GL_PROGRAM_PARAMETER_NV 0x8644 +#define GL_ATTRIB_ARRAY_POINTER_NV 0x8645 +#define GL_PROGRAM_TARGET_NV 0x8646 +#define GL_PROGRAM_RESIDENT_NV 0x8647 +#define GL_TRACK_MATRIX_NV 0x8648 +#define GL_TRACK_MATRIX_TRANSFORM_NV 0x8649 +#define GL_VERTEX_PROGRAM_BINDING_NV 0x864A +#define GL_PROGRAM_ERROR_POSITION_NV 0x864B +#define GL_VERTEX_ATTRIB_ARRAY0_NV 0x8650 +#define GL_VERTEX_ATTRIB_ARRAY1_NV 0x8651 +#define GL_VERTEX_ATTRIB_ARRAY2_NV 0x8652 +#define GL_VERTEX_ATTRIB_ARRAY3_NV 0x8653 +#define GL_VERTEX_ATTRIB_ARRAY4_NV 0x8654 +#define GL_VERTEX_ATTRIB_ARRAY5_NV 0x8655 +#define GL_VERTEX_ATTRIB_ARRAY6_NV 0x8656 +#define GL_VERTEX_ATTRIB_ARRAY7_NV 0x8657 +#define GL_VERTEX_ATTRIB_ARRAY8_NV 0x8658 +#define GL_VERTEX_ATTRIB_ARRAY9_NV 0x8659 +#define GL_VERTEX_ATTRIB_ARRAY10_NV 0x865A +#define GL_VERTEX_ATTRIB_ARRAY11_NV 0x865B +#define GL_VERTEX_ATTRIB_ARRAY12_NV 0x865C +#define GL_VERTEX_ATTRIB_ARRAY13_NV 0x865D +#define GL_VERTEX_ATTRIB_ARRAY14_NV 0x865E +#define GL_VERTEX_ATTRIB_ARRAY15_NV 0x865F +#define GL_MAP1_VERTEX_ATTRIB0_4_NV 0x8660 +#define GL_MAP1_VERTEX_ATTRIB1_4_NV 0x8661 +#define GL_MAP1_VERTEX_ATTRIB2_4_NV 0x8662 +#define GL_MAP1_VERTEX_ATTRIB3_4_NV 0x8663 +#define GL_MAP1_VERTEX_ATTRIB4_4_NV 0x8664 +#define GL_MAP1_VERTEX_ATTRIB5_4_NV 0x8665 +#define GL_MAP1_VERTEX_ATTRIB6_4_NV 0x8666 +#define GL_MAP1_VERTEX_ATTRIB7_4_NV 0x8667 +#define GL_MAP1_VERTEX_ATTRIB8_4_NV 0x8668 +#define GL_MAP1_VERTEX_ATTRIB9_4_NV 0x8669 +#define GL_MAP1_VERTEX_ATTRIB10_4_NV 0x866A +#define GL_MAP1_VERTEX_ATTRIB11_4_NV 0x866B +#define GL_MAP1_VERTEX_ATTRIB12_4_NV 0x866C +#define GL_MAP1_VERTEX_ATTRIB13_4_NV 0x866D +#define GL_MAP1_VERTEX_ATTRIB14_4_NV 0x866E +#define GL_MAP1_VERTEX_ATTRIB15_4_NV 0x866F +#define GL_MAP2_VERTEX_ATTRIB0_4_NV 0x8670 +#define GL_MAP2_VERTEX_ATTRIB1_4_NV 0x8671 +#define GL_MAP2_VERTEX_ATTRIB2_4_NV 0x8672 +#define GL_MAP2_VERTEX_ATTRIB3_4_NV 0x8673 +#define GL_MAP2_VERTEX_ATTRIB4_4_NV 0x8674 +#define GL_MAP2_VERTEX_ATTRIB5_4_NV 0x8675 +#define GL_MAP2_VERTEX_ATTRIB6_4_NV 0x8676 +#define GL_MAP2_VERTEX_ATTRIB7_4_NV 0x8677 +#define GL_MAP2_VERTEX_ATTRIB8_4_NV 0x8678 +#define GL_MAP2_VERTEX_ATTRIB9_4_NV 0x8679 +#define GL_MAP2_VERTEX_ATTRIB10_4_NV 0x867A +#define GL_MAP2_VERTEX_ATTRIB11_4_NV 0x867B +#define GL_MAP2_VERTEX_ATTRIB12_4_NV 0x867C +#define GL_MAP2_VERTEX_ATTRIB13_4_NV 0x867D +#define GL_MAP2_VERTEX_ATTRIB14_4_NV 0x867E +#define GL_MAP2_VERTEX_ATTRIB15_4_NV 0x867F +#endif + +#ifndef GL_SGIX_texture_coordinate_clamp +#define GL_TEXTURE_MAX_CLAMP_S_SGIX 0x8369 +#define GL_TEXTURE_MAX_CLAMP_T_SGIX 0x836A +#define GL_TEXTURE_MAX_CLAMP_R_SGIX 0x836B +#endif + +#ifndef GL_SGIX_scalebias_hint +#define GL_SCALEBIAS_HINT_SGIX 0x8322 +#endif + +#ifndef GL_OML_interlace +#define GL_INTERLACE_OML 0x8980 +#define GL_INTERLACE_READ_OML 0x8981 +#endif + +#ifndef GL_OML_subsample +#define GL_FORMAT_SUBSAMPLE_24_24_OML 0x8982 +#define GL_FORMAT_SUBSAMPLE_244_244_OML 0x8983 +#endif + +#ifndef GL_OML_resample +#define GL_PACK_RESAMPLE_OML 0x8984 +#define GL_UNPACK_RESAMPLE_OML 0x8985 +#define GL_RESAMPLE_REPLICATE_OML 0x8986 +#define GL_RESAMPLE_ZERO_FILL_OML 0x8987 +#define GL_RESAMPLE_AVERAGE_OML 0x8988 +#define GL_RESAMPLE_DECIMATE_OML 0x8989 +#endif + +#ifndef GL_NV_copy_depth_to_color +#define GL_DEPTH_STENCIL_TO_RGBA_NV 0x886E +#define GL_DEPTH_STENCIL_TO_BGRA_NV 0x886F +#endif + +#ifndef GL_ATI_envmap_bumpmap +#define GL_BUMP_ROT_MATRIX_ATI 0x8775 +#define GL_BUMP_ROT_MATRIX_SIZE_ATI 0x8776 +#define GL_BUMP_NUM_TEX_UNITS_ATI 0x8777 +#define GL_BUMP_TEX_UNITS_ATI 0x8778 +#define GL_DUDV_ATI 0x8779 +#define GL_DU8DV8_ATI 0x877A +#define GL_BUMP_ENVMAP_ATI 0x877B +#define GL_BUMP_TARGET_ATI 0x877C +#endif + +#ifndef GL_ATI_fragment_shader +#define GL_FRAGMENT_SHADER_ATI 0x8920 +#define GL_REG_0_ATI 0x8921 +#define GL_REG_1_ATI 0x8922 +#define GL_REG_2_ATI 0x8923 +#define GL_REG_3_ATI 0x8924 +#define GL_REG_4_ATI 0x8925 +#define GL_REG_5_ATI 0x8926 +#define GL_REG_6_ATI 0x8927 +#define GL_REG_7_ATI 0x8928 +#define GL_REG_8_ATI 0x8929 +#define GL_REG_9_ATI 0x892A +#define GL_REG_10_ATI 0x892B +#define GL_REG_11_ATI 0x892C +#define GL_REG_12_ATI 0x892D +#define GL_REG_13_ATI 0x892E +#define GL_REG_14_ATI 0x892F +#define GL_REG_15_ATI 0x8930 +#define GL_REG_16_ATI 0x8931 +#define GL_REG_17_ATI 0x8932 +#define GL_REG_18_ATI 0x8933 +#define GL_REG_19_ATI 0x8934 +#define GL_REG_20_ATI 0x8935 +#define GL_REG_21_ATI 0x8936 +#define GL_REG_22_ATI 0x8937 +#define GL_REG_23_ATI 0x8938 +#define GL_REG_24_ATI 0x8939 +#define GL_REG_25_ATI 0x893A +#define GL_REG_26_ATI 0x893B +#define GL_REG_27_ATI 0x893C +#define GL_REG_28_ATI 0x893D +#define GL_REG_29_ATI 0x893E +#define GL_REG_30_ATI 0x893F +#define GL_REG_31_ATI 0x8940 +#define GL_CON_0_ATI 0x8941 +#define GL_CON_1_ATI 0x8942 +#define GL_CON_2_ATI 0x8943 +#define GL_CON_3_ATI 0x8944 +#define GL_CON_4_ATI 0x8945 +#define GL_CON_5_ATI 0x8946 +#define GL_CON_6_ATI 0x8947 +#define GL_CON_7_ATI 0x8948 +#define GL_CON_8_ATI 0x8949 +#define GL_CON_9_ATI 0x894A +#define GL_CON_10_ATI 0x894B +#define GL_CON_11_ATI 0x894C +#define GL_CON_12_ATI 0x894D +#define GL_CON_13_ATI 0x894E +#define GL_CON_14_ATI 0x894F +#define GL_CON_15_ATI 0x8950 +#define GL_CON_16_ATI 0x8951 +#define GL_CON_17_ATI 0x8952 +#define GL_CON_18_ATI 0x8953 +#define GL_CON_19_ATI 0x8954 +#define GL_CON_20_ATI 0x8955 +#define GL_CON_21_ATI 0x8956 +#define GL_CON_22_ATI 0x8957 +#define GL_CON_23_ATI 0x8958 +#define GL_CON_24_ATI 0x8959 +#define GL_CON_25_ATI 0x895A +#define GL_CON_26_ATI 0x895B +#define GL_CON_27_ATI 0x895C +#define GL_CON_28_ATI 0x895D +#define GL_CON_29_ATI 0x895E +#define GL_CON_30_ATI 0x895F +#define GL_CON_31_ATI 0x8960 +#define GL_MOV_ATI 0x8961 +#define GL_ADD_ATI 0x8963 +#define GL_MUL_ATI 0x8964 +#define GL_SUB_ATI 0x8965 +#define GL_DOT3_ATI 0x8966 +#define GL_DOT4_ATI 0x8967 +#define GL_MAD_ATI 0x8968 +#define GL_LERP_ATI 0x8969 +#define GL_CND_ATI 0x896A +#define GL_CND0_ATI 0x896B +#define GL_DOT2_ADD_ATI 0x896C +#define GL_SECONDARY_INTERPOLATOR_ATI 0x896D +#define GL_NUM_FRAGMENT_REGISTERS_ATI 0x896E +#define GL_NUM_FRAGMENT_CONSTANTS_ATI 0x896F +#define GL_NUM_PASSES_ATI 0x8970 +#define GL_NUM_INSTRUCTIONS_PER_PASS_ATI 0x8971 +#define GL_NUM_INSTRUCTIONS_TOTAL_ATI 0x8972 +#define GL_NUM_INPUT_INTERPOLATOR_COMPONENTS_ATI 0x8973 +#define GL_NUM_LOOPBACK_COMPONENTS_ATI 0x8974 +#define GL_COLOR_ALPHA_PAIRING_ATI 0x8975 +#define GL_SWIZZLE_STR_ATI 0x8976 +#define GL_SWIZZLE_STQ_ATI 0x8977 +#define GL_SWIZZLE_STR_DR_ATI 0x8978 +#define GL_SWIZZLE_STQ_DQ_ATI 0x8979 +#define GL_SWIZZLE_STRQ_ATI 0x897A +#define GL_SWIZZLE_STRQ_DQ_ATI 0x897B +#define GL_RED_BIT_ATI 0x00000001 +#define GL_GREEN_BIT_ATI 0x00000002 +#define GL_BLUE_BIT_ATI 0x00000004 +#define GL_2X_BIT_ATI 0x00000001 +#define GL_4X_BIT_ATI 0x00000002 +#define GL_8X_BIT_ATI 0x00000004 +#define GL_HALF_BIT_ATI 0x00000008 +#define GL_QUARTER_BIT_ATI 0x00000010 +#define GL_EIGHTH_BIT_ATI 0x00000020 +#define GL_SATURATE_BIT_ATI 0x00000040 +#define GL_COMP_BIT_ATI 0x00000002 +#define GL_NEGATE_BIT_ATI 0x00000004 +#define GL_BIAS_BIT_ATI 0x00000008 +#endif + +#ifndef GL_ATI_pn_triangles +#define GL_PN_TRIANGLES_ATI 0x87F0 +#define GL_MAX_PN_TRIANGLES_TESSELATION_LEVEL_ATI 0x87F1 +#define GL_PN_TRIANGLES_POINT_MODE_ATI 0x87F2 +#define GL_PN_TRIANGLES_NORMAL_MODE_ATI 0x87F3 +#define GL_PN_TRIANGLES_TESSELATION_LEVEL_ATI 0x87F4 +#define GL_PN_TRIANGLES_POINT_MODE_LINEAR_ATI 0x87F5 +#define GL_PN_TRIANGLES_POINT_MODE_CUBIC_ATI 0x87F6 +#define GL_PN_TRIANGLES_NORMAL_MODE_LINEAR_ATI 0x87F7 +#define GL_PN_TRIANGLES_NORMAL_MODE_QUADRATIC_ATI 0x87F8 +#endif + +#ifndef GL_ATI_vertex_array_object +#define GL_STATIC_ATI 0x8760 +#define GL_DYNAMIC_ATI 0x8761 +#define GL_PRESERVE_ATI 0x8762 +#define GL_DISCARD_ATI 0x8763 +#define GL_OBJECT_BUFFER_SIZE_ATI 0x8764 +#define GL_OBJECT_BUFFER_USAGE_ATI 0x8765 +#define GL_ARRAY_OBJECT_BUFFER_ATI 0x8766 +#define GL_ARRAY_OBJECT_OFFSET_ATI 0x8767 +#endif + +#ifndef GL_EXT_vertex_shader +#define GL_VERTEX_SHADER_EXT 0x8780 +#define GL_VERTEX_SHADER_BINDING_EXT 0x8781 +#define GL_OP_INDEX_EXT 0x8782 +#define GL_OP_NEGATE_EXT 0x8783 +#define GL_OP_DOT3_EXT 0x8784 +#define GL_OP_DOT4_EXT 0x8785 +#define GL_OP_MUL_EXT 0x8786 +#define GL_OP_ADD_EXT 0x8787 +#define GL_OP_MADD_EXT 0x8788 +#define GL_OP_FRAC_EXT 0x8789 +#define GL_OP_MAX_EXT 0x878A +#define GL_OP_MIN_EXT 0x878B +#define GL_OP_SET_GE_EXT 0x878C +#define GL_OP_SET_LT_EXT 0x878D +#define GL_OP_CLAMP_EXT 0x878E +#define GL_OP_FLOOR_EXT 0x878F +#define GL_OP_ROUND_EXT 0x8790 +#define GL_OP_EXP_BASE_2_EXT 0x8791 +#define GL_OP_LOG_BASE_2_EXT 0x8792 +#define GL_OP_POWER_EXT 0x8793 +#define GL_OP_RECIP_EXT 0x8794 +#define GL_OP_RECIP_SQRT_EXT 0x8795 +#define GL_OP_SUB_EXT 0x8796 +#define GL_OP_CROSS_PRODUCT_EXT 0x8797 +#define GL_OP_MULTIPLY_MATRIX_EXT 0x8798 +#define GL_OP_MOV_EXT 0x8799 +#define GL_OUTPUT_VERTEX_EXT 0x879A +#define GL_OUTPUT_COLOR0_EXT 0x879B +#define GL_OUTPUT_COLOR1_EXT 0x879C +#define GL_OUTPUT_TEXTURE_COORD0_EXT 0x879D +#define GL_OUTPUT_TEXTURE_COORD1_EXT 0x879E +#define GL_OUTPUT_TEXTURE_COORD2_EXT 0x879F +#define GL_OUTPUT_TEXTURE_COORD3_EXT 0x87A0 +#define GL_OUTPUT_TEXTURE_COORD4_EXT 0x87A1 +#define GL_OUTPUT_TEXTURE_COORD5_EXT 0x87A2 +#define GL_OUTPUT_TEXTURE_COORD6_EXT 0x87A3 +#define GL_OUTPUT_TEXTURE_COORD7_EXT 0x87A4 +#define GL_OUTPUT_TEXTURE_COORD8_EXT 0x87A5 +#define GL_OUTPUT_TEXTURE_COORD9_EXT 0x87A6 +#define GL_OUTPUT_TEXTURE_COORD10_EXT 0x87A7 +#define GL_OUTPUT_TEXTURE_COORD11_EXT 0x87A8 +#define GL_OUTPUT_TEXTURE_COORD12_EXT 0x87A9 +#define GL_OUTPUT_TEXTURE_COORD13_EXT 0x87AA +#define GL_OUTPUT_TEXTURE_COORD14_EXT 0x87AB +#define GL_OUTPUT_TEXTURE_COORD15_EXT 0x87AC +#define GL_OUTPUT_TEXTURE_COORD16_EXT 0x87AD +#define GL_OUTPUT_TEXTURE_COORD17_EXT 0x87AE +#define GL_OUTPUT_TEXTURE_COORD18_EXT 0x87AF +#define GL_OUTPUT_TEXTURE_COORD19_EXT 0x87B0 +#define GL_OUTPUT_TEXTURE_COORD20_EXT 0x87B1 +#define GL_OUTPUT_TEXTURE_COORD21_EXT 0x87B2 +#define GL_OUTPUT_TEXTURE_COORD22_EXT 0x87B3 +#define GL_OUTPUT_TEXTURE_COORD23_EXT 0x87B4 +#define GL_OUTPUT_TEXTURE_COORD24_EXT 0x87B5 +#define GL_OUTPUT_TEXTURE_COORD25_EXT 0x87B6 +#define GL_OUTPUT_TEXTURE_COORD26_EXT 0x87B7 +#define GL_OUTPUT_TEXTURE_COORD27_EXT 0x87B8 +#define GL_OUTPUT_TEXTURE_COORD28_EXT 0x87B9 +#define GL_OUTPUT_TEXTURE_COORD29_EXT 0x87BA +#define GL_OUTPUT_TEXTURE_COORD30_EXT 0x87BB +#define GL_OUTPUT_TEXTURE_COORD31_EXT 0x87BC +#define GL_OUTPUT_FOG_EXT 0x87BD +#define GL_SCALAR_EXT 0x87BE +#define GL_VECTOR_EXT 0x87BF +#define GL_MATRIX_EXT 0x87C0 +#define GL_VARIANT_EXT 0x87C1 +#define GL_INVARIANT_EXT 0x87C2 +#define GL_LOCAL_CONSTANT_EXT 0x87C3 +#define GL_LOCAL_EXT 0x87C4 +#define GL_MAX_VERTEX_SHADER_INSTRUCTIONS_EXT 0x87C5 +#define GL_MAX_VERTEX_SHADER_VARIANTS_EXT 0x87C6 +#define GL_MAX_VERTEX_SHADER_INVARIANTS_EXT 0x87C7 +#define GL_MAX_VERTEX_SHADER_LOCAL_CONSTANTS_EXT 0x87C8 +#define GL_MAX_VERTEX_SHADER_LOCALS_EXT 0x87C9 +#define GL_MAX_OPTIMIZED_VERTEX_SHADER_INSTRUCTIONS_EXT 0x87CA +#define GL_MAX_OPTIMIZED_VERTEX_SHADER_VARIANTS_EXT 0x87CB +#define GL_MAX_OPTIMIZED_VERTEX_SHADER_LOCAL_CONSTANTS_EXT 0x87CC +#define GL_MAX_OPTIMIZED_VERTEX_SHADER_INVARIANTS_EXT 0x87CD +#define GL_MAX_OPTIMIZED_VERTEX_SHADER_LOCALS_EXT 0x87CE +#define GL_VERTEX_SHADER_INSTRUCTIONS_EXT 0x87CF +#define GL_VERTEX_SHADER_VARIANTS_EXT 0x87D0 +#define GL_VERTEX_SHADER_INVARIANTS_EXT 0x87D1 +#define GL_VERTEX_SHADER_LOCAL_CONSTANTS_EXT 0x87D2 +#define GL_VERTEX_SHADER_LOCALS_EXT 0x87D3 +#define GL_VERTEX_SHADER_OPTIMIZED_EXT 0x87D4 +#define GL_X_EXT 0x87D5 +#define GL_Y_EXT 0x87D6 +#define GL_Z_EXT 0x87D7 +#define GL_W_EXT 0x87D8 +#define GL_NEGATIVE_X_EXT 0x87D9 +#define GL_NEGATIVE_Y_EXT 0x87DA +#define GL_NEGATIVE_Z_EXT 0x87DB +#define GL_NEGATIVE_W_EXT 0x87DC +#define GL_ZERO_EXT 0x87DD +#define GL_ONE_EXT 0x87DE +#define GL_NEGATIVE_ONE_EXT 0x87DF +#define GL_NORMALIZED_RANGE_EXT 0x87E0 +#define GL_FULL_RANGE_EXT 0x87E1 +#define GL_CURRENT_VERTEX_EXT 0x87E2 +#define GL_MVP_MATRIX_EXT 0x87E3 +#define GL_VARIANT_VALUE_EXT 0x87E4 +#define GL_VARIANT_DATATYPE_EXT 0x87E5 +#define GL_VARIANT_ARRAY_STRIDE_EXT 0x87E6 +#define GL_VARIANT_ARRAY_TYPE_EXT 0x87E7 +#define GL_VARIANT_ARRAY_EXT 0x87E8 +#define GL_VARIANT_ARRAY_POINTER_EXT 0x87E9 +#define GL_INVARIANT_VALUE_EXT 0x87EA +#define GL_INVARIANT_DATATYPE_EXT 0x87EB +#define GL_LOCAL_CONSTANT_VALUE_EXT 0x87EC +#define GL_LOCAL_CONSTANT_DATATYPE_EXT 0x87ED +#endif + +#ifndef GL_ATI_vertex_streams +#define GL_MAX_VERTEX_STREAMS_ATI 0x876B +#define GL_VERTEX_STREAM0_ATI 0x876C +#define GL_VERTEX_STREAM1_ATI 0x876D +#define GL_VERTEX_STREAM2_ATI 0x876E +#define GL_VERTEX_STREAM3_ATI 0x876F +#define GL_VERTEX_STREAM4_ATI 0x8770 +#define GL_VERTEX_STREAM5_ATI 0x8771 +#define GL_VERTEX_STREAM6_ATI 0x8772 +#define GL_VERTEX_STREAM7_ATI 0x8773 +#define GL_VERTEX_SOURCE_ATI 0x8774 +#endif + +#ifndef GL_ATI_element_array +#define GL_ELEMENT_ARRAY_ATI 0x8768 +#define GL_ELEMENT_ARRAY_TYPE_ATI 0x8769 +#define GL_ELEMENT_ARRAY_POINTER_ATI 0x876A +#endif + +#ifndef GL_SUN_mesh_array +#define GL_QUAD_MESH_SUN 0x8614 +#define GL_TRIANGLE_MESH_SUN 0x8615 +#endif + +#ifndef GL_SUN_slice_accum +#define GL_SLICE_ACCUM_SUN 0x85CC +#endif + +#ifndef GL_NV_multisample_filter_hint +#define GL_MULTISAMPLE_FILTER_HINT_NV 0x8534 +#endif + +#ifndef GL_NV_depth_clamp +#define GL_DEPTH_CLAMP_NV 0x864F +#endif + +#ifndef GL_NV_occlusion_query +#define GL_PIXEL_COUNTER_BITS_NV 0x8864 +#define GL_CURRENT_OCCLUSION_QUERY_ID_NV 0x8865 +#define GL_PIXEL_COUNT_NV 0x8866 +#define GL_PIXEL_COUNT_AVAILABLE_NV 0x8867 +#endif + +#ifndef GL_NV_point_sprite +#define GL_POINT_SPRITE_NV 0x8861 +#define GL_COORD_REPLACE_NV 0x8862 +#define GL_POINT_SPRITE_R_MODE_NV 0x8863 +#endif + +#ifndef GL_NV_texture_shader3 +#define GL_OFFSET_PROJECTIVE_TEXTURE_2D_NV 0x8850 +#define GL_OFFSET_PROJECTIVE_TEXTURE_2D_SCALE_NV 0x8851 +#define GL_OFFSET_PROJECTIVE_TEXTURE_RECTANGLE_NV 0x8852 +#define GL_OFFSET_PROJECTIVE_TEXTURE_RECTANGLE_SCALE_NV 0x8853 +#define GL_OFFSET_HILO_TEXTURE_2D_NV 0x8854 +#define GL_OFFSET_HILO_TEXTURE_RECTANGLE_NV 0x8855 +#define GL_OFFSET_HILO_PROJECTIVE_TEXTURE_2D_NV 0x8856 +#define GL_OFFSET_HILO_PROJECTIVE_TEXTURE_RECTANGLE_NV 0x8857 +#define GL_DEPENDENT_HILO_TEXTURE_2D_NV 0x8858 +#define GL_DEPENDENT_RGB_TEXTURE_3D_NV 0x8859 +#define GL_DEPENDENT_RGB_TEXTURE_CUBE_MAP_NV 0x885A +#define GL_DOT_PRODUCT_PASS_THROUGH_NV 0x885B +#define GL_DOT_PRODUCT_TEXTURE_1D_NV 0x885C +#define GL_DOT_PRODUCT_AFFINE_DEPTH_REPLACE_NV 0x885D +#define GL_HILO8_NV 0x885E +#define GL_SIGNED_HILO8_NV 0x885F +#define GL_FORCE_BLUE_TO_ONE_NV 0x8860 +#endif + +#ifndef GL_NV_vertex_program1_1 +#endif + +#ifndef GL_EXT_shadow_funcs +#endif + +#ifndef GL_EXT_stencil_two_side +#define GL_STENCIL_TEST_TWO_SIDE_EXT 0x8910 +#define GL_ACTIVE_STENCIL_FACE_EXT 0x8911 +#endif + +#ifndef GL_ATI_text_fragment_shader +#define GL_TEXT_FRAGMENT_SHADER_ATI 0x8200 +#endif + +#ifndef GL_APPLE_client_storage +#define GL_UNPACK_CLIENT_STORAGE_APPLE 0x85B2 +#endif + +#ifndef GL_APPLE_element_array +#define GL_ELEMENT_ARRAY_APPLE 0x8768 +#define GL_ELEMENT_ARRAY_TYPE_APPLE 0x8769 +#define GL_ELEMENT_ARRAY_POINTER_APPLE 0x876A +#endif + +#ifndef GL_APPLE_fence +#define GL_DRAW_PIXELS_APPLE 0x8A0A +#define GL_FENCE_APPLE 0x8A0B +#endif + +#ifndef GL_APPLE_vertex_array_object +#define GL_VERTEX_ARRAY_BINDING_APPLE 0x85B5 +#endif + +#ifndef GL_APPLE_vertex_array_range +#define GL_VERTEX_ARRAY_RANGE_APPLE 0x851D +#define GL_VERTEX_ARRAY_RANGE_LENGTH_APPLE 0x851E +#define GL_VERTEX_ARRAY_STORAGE_HINT_APPLE 0x851F +#define GL_VERTEX_ARRAY_RANGE_POINTER_APPLE 0x8521 +#define GL_STORAGE_CACHED_APPLE 0x85BE +#define GL_STORAGE_SHARED_APPLE 0x85BF +#endif + +#ifndef GL_APPLE_ycbcr_422 +#define GL_YCBCR_422_APPLE 0x85B9 +#define GL_UNSIGNED_SHORT_8_8_APPLE 0x85BA +#define GL_UNSIGNED_SHORT_8_8_REV_APPLE 0x85BB +#endif + +#ifndef GL_S3_s3tc +#define GL_RGB_S3TC 0x83A0 +#define GL_RGB4_S3TC 0x83A1 +#define GL_RGBA_S3TC 0x83A2 +#define GL_RGBA4_S3TC 0x83A3 +#endif + +#ifndef GL_ATI_draw_buffers +#define GL_MAX_DRAW_BUFFERS_ATI 0x8824 +#define GL_DRAW_BUFFER0_ATI 0x8825 +#define GL_DRAW_BUFFER1_ATI 0x8826 +#define GL_DRAW_BUFFER2_ATI 0x8827 +#define GL_DRAW_BUFFER3_ATI 0x8828 +#define GL_DRAW_BUFFER4_ATI 0x8829 +#define GL_DRAW_BUFFER5_ATI 0x882A +#define GL_DRAW_BUFFER6_ATI 0x882B +#define GL_DRAW_BUFFER7_ATI 0x882C +#define GL_DRAW_BUFFER8_ATI 0x882D +#define GL_DRAW_BUFFER9_ATI 0x882E +#define GL_DRAW_BUFFER10_ATI 0x882F +#define GL_DRAW_BUFFER11_ATI 0x8830 +#define GL_DRAW_BUFFER12_ATI 0x8831 +#define GL_DRAW_BUFFER13_ATI 0x8832 +#define GL_DRAW_BUFFER14_ATI 0x8833 +#define GL_DRAW_BUFFER15_ATI 0x8834 +#endif + +#ifndef GL_ATI_pixel_format_float +#define GL_TYPE_RGBA_FLOAT_ATI 0x8820 +#define GL_COLOR_CLEAR_UNCLAMPED_VALUE_ATI 0x8835 +#endif + +#ifndef GL_ATI_texture_env_combine3 +#define GL_MODULATE_ADD_ATI 0x8744 +#define GL_MODULATE_SIGNED_ADD_ATI 0x8745 +#define GL_MODULATE_SUBTRACT_ATI 0x8746 +#endif + +#ifndef GL_ATI_texture_float +#define GL_RGBA_FLOAT32_ATI 0x8814 +#define GL_RGB_FLOAT32_ATI 0x8815 +#define GL_ALPHA_FLOAT32_ATI 0x8816 +#define GL_INTENSITY_FLOAT32_ATI 0x8817 +#define GL_LUMINANCE_FLOAT32_ATI 0x8818 +#define GL_LUMINANCE_ALPHA_FLOAT32_ATI 0x8819 +#define GL_RGBA_FLOAT16_ATI 0x881A +#define GL_RGB_FLOAT16_ATI 0x881B +#define GL_ALPHA_FLOAT16_ATI 0x881C +#define GL_INTENSITY_FLOAT16_ATI 0x881D +#define GL_LUMINANCE_FLOAT16_ATI 0x881E +#define GL_LUMINANCE_ALPHA_FLOAT16_ATI 0x881F +#endif + +#ifndef GL_NV_float_buffer +#define GL_FLOAT_R_NV 0x8880 +#define GL_FLOAT_RG_NV 0x8881 +#define GL_FLOAT_RGB_NV 0x8882 +#define GL_FLOAT_RGBA_NV 0x8883 +#define GL_FLOAT_R16_NV 0x8884 +#define GL_FLOAT_R32_NV 0x8885 +#define GL_FLOAT_RG16_NV 0x8886 +#define GL_FLOAT_RG32_NV 0x8887 +#define GL_FLOAT_RGB16_NV 0x8888 +#define GL_FLOAT_RGB32_NV 0x8889 +#define GL_FLOAT_RGBA16_NV 0x888A +#define GL_FLOAT_RGBA32_NV 0x888B +#define GL_TEXTURE_FLOAT_COMPONENTS_NV 0x888C +#define GL_FLOAT_CLEAR_COLOR_VALUE_NV 0x888D +#define GL_FLOAT_RGBA_MODE_NV 0x888E +#endif + +#ifndef GL_NV_fragment_program +#define GL_MAX_FRAGMENT_PROGRAM_LOCAL_PARAMETERS_NV 0x8868 +#define GL_FRAGMENT_PROGRAM_NV 0x8870 +#define GL_MAX_TEXTURE_COORDS_NV 0x8871 +#define GL_MAX_TEXTURE_IMAGE_UNITS_NV 0x8872 +#define GL_FRAGMENT_PROGRAM_BINDING_NV 0x8873 +#define GL_PROGRAM_ERROR_STRING_NV 0x8874 +#endif + +#ifndef GL_NV_half_float +#define GL_HALF_FLOAT_NV 0x140B +#endif + +#ifndef GL_NV_pixel_data_range +#define GL_WRITE_PIXEL_DATA_RANGE_NV 0x8878 +#define GL_READ_PIXEL_DATA_RANGE_NV 0x8879 +#define GL_WRITE_PIXEL_DATA_RANGE_LENGTH_NV 0x887A +#define GL_READ_PIXEL_DATA_RANGE_LENGTH_NV 0x887B +#define GL_WRITE_PIXEL_DATA_RANGE_POINTER_NV 0x887C +#define GL_READ_PIXEL_DATA_RANGE_POINTER_NV 0x887D +#endif + +#ifndef GL_NV_primitive_restart +#define GL_PRIMITIVE_RESTART_NV 0x8558 +#define GL_PRIMITIVE_RESTART_INDEX_NV 0x8559 +#endif + +#ifndef GL_NV_texture_expand_normal +#define GL_TEXTURE_UNSIGNED_REMAP_MODE_NV 0x888F +#endif + +#ifndef GL_NV_vertex_program2 +#endif + +#ifndef GL_ATI_map_object_buffer +#endif + +#ifndef GL_ATI_separate_stencil +#define GL_STENCIL_BACK_FUNC_ATI 0x8800 +#define GL_STENCIL_BACK_FAIL_ATI 0x8801 +#define GL_STENCIL_BACK_PASS_DEPTH_FAIL_ATI 0x8802 +#define GL_STENCIL_BACK_PASS_DEPTH_PASS_ATI 0x8803 +#endif + +#ifndef GL_ATI_vertex_attrib_array_object +#endif + +#ifndef GL_OES_read_format +#define GL_IMPLEMENTATION_COLOR_READ_TYPE_OES 0x8B9A +#define GL_IMPLEMENTATION_COLOR_READ_FORMAT_OES 0x8B9B +#endif + +#ifndef GL_EXT_depth_bounds_test +#define GL_DEPTH_BOUNDS_TEST_EXT 0x8890 +#define GL_DEPTH_BOUNDS_EXT 0x8891 +#endif + +#ifndef GL_EXT_texture_mirror_clamp +#define GL_MIRROR_CLAMP_EXT 0x8742 +#define GL_MIRROR_CLAMP_TO_EDGE_EXT 0x8743 +#define GL_MIRROR_CLAMP_TO_BORDER_EXT 0x8912 +#endif + +#ifndef GL_EXT_blend_equation_separate +#define GL_BLEND_EQUATION_RGB_EXT GL_BLEND_EQUATION +#define GL_BLEND_EQUATION_ALPHA_EXT 0x883D +#endif + +#ifndef GL_MESA_pack_invert +#define GL_PACK_INVERT_MESA 0x8758 +#endif + +#ifndef GL_MESA_ycbcr_texture +#define GL_UNSIGNED_SHORT_8_8_MESA 0x85BA +#define GL_UNSIGNED_SHORT_8_8_REV_MESA 0x85BB +#define GL_YCBCR_MESA 0x8757 +#endif + +#ifndef GL_EXT_pixel_buffer_object +#define GL_PIXEL_PACK_BUFFER_EXT 0x88EB +#define GL_PIXEL_UNPACK_BUFFER_EXT 0x88EC +#define GL_PIXEL_PACK_BUFFER_BINDING_EXT 0x88ED +#define GL_PIXEL_UNPACK_BUFFER_BINDING_EXT 0x88EF +#endif + +#ifndef GL_NV_fragment_program_option +#endif + +#ifndef GL_NV_fragment_program2 +#define GL_MAX_PROGRAM_EXEC_INSTRUCTIONS_NV 0x88F4 +#define GL_MAX_PROGRAM_CALL_DEPTH_NV 0x88F5 +#define GL_MAX_PROGRAM_IF_DEPTH_NV 0x88F6 +#define GL_MAX_PROGRAM_LOOP_DEPTH_NV 0x88F7 +#define GL_MAX_PROGRAM_LOOP_COUNT_NV 0x88F8 +#endif + +#ifndef GL_NV_vertex_program2_option +/* reuse GL_MAX_PROGRAM_EXEC_INSTRUCTIONS_NV */ +/* reuse GL_MAX_PROGRAM_CALL_DEPTH_NV */ +#endif + +#ifndef GL_NV_vertex_program3 +/* reuse GL_MAX_VERTEX_TEXTURE_IMAGE_UNITS_ARB */ +#endif + +#ifndef GL_EXT_framebuffer_object +#define GL_INVALID_FRAMEBUFFER_OPERATION_EXT 0x0506 +#define GL_MAX_RENDERBUFFER_SIZE_EXT 0x84E8 +#define GL_FRAMEBUFFER_BINDING_EXT 0x8CA6 +#define GL_RENDERBUFFER_BINDING_EXT 0x8CA7 +#define GL_FRAMEBUFFER_ATTACHMENT_OBJECT_TYPE_EXT 0x8CD0 +#define GL_FRAMEBUFFER_ATTACHMENT_OBJECT_NAME_EXT 0x8CD1 +#define GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_LEVEL_EXT 0x8CD2 +#define GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_CUBE_MAP_FACE_EXT 0x8CD3 +#define GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_3D_ZOFFSET_EXT 0x8CD4 +#define GL_FRAMEBUFFER_COMPLETE_EXT 0x8CD5 +#define GL_FRAMEBUFFER_INCOMPLETE_ATTACHMENT_EXT 0x8CD6 +#define GL_FRAMEBUFFER_INCOMPLETE_MISSING_ATTACHMENT_EXT 0x8CD7 +#define GL_FRAMEBUFFER_INCOMPLETE_DUPLICATE_ATTACHMENT_EXT 0x8CD8 +#define GL_FRAMEBUFFER_INCOMPLETE_DIMENSIONS_EXT 0x8CD9 +#define GL_FRAMEBUFFER_INCOMPLETE_FORMATS_EXT 0x8CDA +#define GL_FRAMEBUFFER_INCOMPLETE_DRAW_BUFFER_EXT 0x8CDB +#define GL_FRAMEBUFFER_INCOMPLETE_READ_BUFFER_EXT 0x8CDC +#define GL_FRAMEBUFFER_UNSUPPORTED_EXT 0x8CDD +#define GL_MAX_COLOR_ATTACHMENTS_EXT 0x8CDF +#define GL_COLOR_ATTACHMENT0_EXT 0x8CE0 +#define GL_COLOR_ATTACHMENT1_EXT 0x8CE1 +#define GL_COLOR_ATTACHMENT2_EXT 0x8CE2 +#define GL_COLOR_ATTACHMENT3_EXT 0x8CE3 +#define GL_COLOR_ATTACHMENT4_EXT 0x8CE4 +#define GL_COLOR_ATTACHMENT5_EXT 0x8CE5 +#define GL_COLOR_ATTACHMENT6_EXT 0x8CE6 +#define GL_COLOR_ATTACHMENT7_EXT 0x8CE7 +#define GL_COLOR_ATTACHMENT8_EXT 0x8CE8 +#define GL_COLOR_ATTACHMENT9_EXT 0x8CE9 +#define GL_COLOR_ATTACHMENT10_EXT 0x8CEA +#define GL_COLOR_ATTACHMENT11_EXT 0x8CEB +#define GL_COLOR_ATTACHMENT12_EXT 0x8CEC +#define GL_COLOR_ATTACHMENT13_EXT 0x8CED +#define GL_COLOR_ATTACHMENT14_EXT 0x8CEE +#define GL_COLOR_ATTACHMENT15_EXT 0x8CEF +#define GL_DEPTH_ATTACHMENT_EXT 0x8D00 +#define GL_STENCIL_ATTACHMENT_EXT 0x8D20 +#define GL_FRAMEBUFFER_EXT 0x8D40 +#define GL_RENDERBUFFER_EXT 0x8D41 +#define GL_RENDERBUFFER_WIDTH_EXT 0x8D42 +#define GL_RENDERBUFFER_HEIGHT_EXT 0x8D43 +#define GL_RENDERBUFFER_INTERNAL_FORMAT_EXT 0x8D44 +#define GL_STENCIL_INDEX1_EXT 0x8D46 +#define GL_STENCIL_INDEX4_EXT 0x8D47 +#define GL_STENCIL_INDEX8_EXT 0x8D48 +#define GL_STENCIL_INDEX16_EXT 0x8D49 +#define GL_RENDERBUFFER_RED_SIZE_EXT 0x8D50 +#define GL_RENDERBUFFER_GREEN_SIZE_EXT 0x8D51 +#define GL_RENDERBUFFER_BLUE_SIZE_EXT 0x8D52 +#define GL_RENDERBUFFER_ALPHA_SIZE_EXT 0x8D53 +#define GL_RENDERBUFFER_DEPTH_SIZE_EXT 0x8D54 +#define GL_RENDERBUFFER_STENCIL_SIZE_EXT 0x8D55 +#endif + +#ifndef GL_GREMEDY_string_marker +#endif + + +/*************************************************************/ + +#include +#ifndef GL_VERSION_2_0 +/* GL type for program/shader text */ +typedef char GLchar; /* native character */ +#endif + +#ifndef GL_VERSION_1_5 +/* GL types for handling large vertex buffer objects */ +typedef ptrdiff_t GLintptr; +typedef ptrdiff_t GLsizeiptr; +#endif + +#ifndef GL_ARB_vertex_buffer_object +/* GL types for handling large vertex buffer objects */ +typedef ptrdiff_t GLintptrARB; +typedef ptrdiff_t GLsizeiptrARB; +#endif + +#ifndef GL_ARB_shader_objects +/* GL types for handling shader object handles and program/shader text */ +typedef char GLcharARB; /* native character */ +typedef unsigned int GLhandleARB; /* shader object handle */ +#endif + +/* GL types for "half" precision (s10e5) float data in host memory */ +#ifndef GL_ARB_half_float_pixel +typedef unsigned short GLhalfARB; +#endif + +#ifndef GL_NV_half_float +typedef unsigned short GLhalfNV; +#endif + +#ifndef GL_VERSION_1_2 +#define GL_VERSION_1_2 1 +#ifdef GL_GLEXT_PROTOTYPES +GLAPI void APIENTRY glBlendColor (GLclampf, GLclampf, GLclampf, GLclampf); +GLAPI void APIENTRY glBlendEquation (GLenum); +GLAPI void APIENTRY glDrawRangeElements (GLenum, GLuint, GLuint, GLsizei, GLenum, const GLvoid *); +GLAPI void APIENTRY glColorTable (GLenum, GLenum, GLsizei, GLenum, GLenum, const GLvoid *); +GLAPI void APIENTRY glColorTableParameterfv (GLenum, GLenum, const GLfloat *); +GLAPI void APIENTRY glColorTableParameteriv (GLenum, GLenum, const GLint *); +GLAPI void APIENTRY glCopyColorTable (GLenum, GLenum, GLint, GLint, GLsizei); +GLAPI void APIENTRY glGetColorTable (GLenum, GLenum, GLenum, GLvoid *); +GLAPI void APIENTRY glGetColorTableParameterfv (GLenum, GLenum, GLfloat *); +GLAPI void APIENTRY glGetColorTableParameteriv (GLenum, GLenum, GLint *); +GLAPI void APIENTRY glColorSubTable (GLenum, GLsizei, GLsizei, GLenum, GLenum, const GLvoid *); +GLAPI void APIENTRY glCopyColorSubTable (GLenum, GLsizei, GLint, GLint, GLsizei); +GLAPI void APIENTRY glConvolutionFilter1D (GLenum, GLenum, GLsizei, GLenum, GLenum, const GLvoid *); +GLAPI void APIENTRY glConvolutionFilter2D (GLenum, GLenum, GLsizei, GLsizei, GLenum, GLenum, const GLvoid *); +GLAPI void APIENTRY glConvolutionParameterf (GLenum, GLenum, GLfloat); +GLAPI void APIENTRY glConvolutionParameterfv (GLenum, GLenum, const GLfloat *); +GLAPI void APIENTRY glConvolutionParameteri (GLenum, GLenum, GLint); +GLAPI void APIENTRY glConvolutionParameteriv (GLenum, GLenum, const GLint *); +GLAPI void APIENTRY glCopyConvolutionFilter1D (GLenum, GLenum, GLint, GLint, GLsizei); +GLAPI void APIENTRY glCopyConvolutionFilter2D (GLenum, GLenum, GLint, GLint, GLsizei, GLsizei); +GLAPI void APIENTRY glGetConvolutionFilter (GLenum, GLenum, GLenum, GLvoid *); +GLAPI void APIENTRY glGetConvolutionParameterfv (GLenum, GLenum, GLfloat *); +GLAPI void APIENTRY glGetConvolutionParameteriv (GLenum, GLenum, GLint *); +GLAPI void APIENTRY glGetSeparableFilter (GLenum, GLenum, GLenum, GLvoid *, GLvoid *, GLvoid *); +GLAPI void APIENTRY glSeparableFilter2D (GLenum, GLenum, GLsizei, GLsizei, GLenum, GLenum, const GLvoid *, const GLvoid *); +GLAPI void APIENTRY glGetHistogram (GLenum, GLboolean, GLenum, GLenum, GLvoid *); +GLAPI void APIENTRY glGetHistogramParameterfv (GLenum, GLenum, GLfloat *); +GLAPI void APIENTRY glGetHistogramParameteriv (GLenum, GLenum, GLint *); +GLAPI void APIENTRY glGetMinmax (GLenum, GLboolean, GLenum, GLenum, GLvoid *); +GLAPI void APIENTRY glGetMinmaxParameterfv (GLenum, GLenum, GLfloat *); +GLAPI void APIENTRY glGetMinmaxParameteriv (GLenum, GLenum, GLint *); +GLAPI void APIENTRY glHistogram (GLenum, GLsizei, GLenum, GLboolean); +GLAPI void APIENTRY glMinmax (GLenum, GLenum, GLboolean); +GLAPI void APIENTRY glResetHistogram (GLenum); +GLAPI void APIENTRY glResetMinmax (GLenum); +GLAPI void APIENTRY glTexImage3D (GLenum, GLint, GLint, GLsizei, GLsizei, GLsizei, GLint, GLenum, GLenum, const GLvoid *); +GLAPI void APIENTRY glTexSubImage3D (GLenum, GLint, GLint, GLint, GLint, GLsizei, GLsizei, GLsizei, GLenum, GLenum, const GLvoid *); +GLAPI void APIENTRY glCopyTexSubImage3D (GLenum, GLint, GLint, GLint, GLint, GLint, GLint, GLsizei, GLsizei); +#endif /* GL_GLEXT_PROTOTYPES */ +typedef void (APIENTRYP PFNGLBLENDCOLORPROC) (GLclampf red, GLclampf green, GLclampf blue, GLclampf alpha); +typedef void (APIENTRYP PFNGLBLENDEQUATIONPROC) (GLenum mode); +typedef void (APIENTRYP PFNGLDRAWRANGEELEMENTSPROC) (GLenum mode, GLuint start, GLuint end, GLsizei count, GLenum type, const GLvoid *indices); +typedef void (APIENTRYP PFNGLCOLORTABLEPROC) (GLenum target, GLenum internalformat, GLsizei width, GLenum format, GLenum type, const GLvoid *table); +typedef void (APIENTRYP PFNGLCOLORTABLEPARAMETERFVPROC) (GLenum target, GLenum pname, const GLfloat *params); +typedef void (APIENTRYP PFNGLCOLORTABLEPARAMETERIVPROC) (GLenum target, GLenum pname, const GLint *params); +typedef void (APIENTRYP PFNGLCOPYCOLORTABLEPROC) (GLenum target, GLenum internalformat, GLint x, GLint y, GLsizei width); +typedef void (APIENTRYP PFNGLGETCOLORTABLEPROC) (GLenum target, GLenum format, GLenum type, GLvoid *table); +typedef void (APIENTRYP PFNGLGETCOLORTABLEPARAMETERFVPROC) (GLenum target, GLenum pname, GLfloat *params); +typedef void (APIENTRYP PFNGLGETCOLORTABLEPARAMETERIVPROC) (GLenum target, GLenum pname, GLint *params); +typedef void (APIENTRYP PFNGLCOLORSUBTABLEPROC) (GLenum target, GLsizei start, GLsizei count, GLenum format, GLenum type, const GLvoid *data); +typedef void (APIENTRYP PFNGLCOPYCOLORSUBTABLEPROC) (GLenum target, GLsizei start, GLint x, GLint y, GLsizei width); +typedef void (APIENTRYP PFNGLCONVOLUTIONFILTER1DPROC) (GLenum target, GLenum internalformat, GLsizei width, GLenum format, GLenum type, const GLvoid *image); +typedef void (APIENTRYP PFNGLCONVOLUTIONFILTER2DPROC) (GLenum target, GLenum internalformat, GLsizei width, GLsizei height, GLenum format, GLenum type, const GLvoid *image); +typedef void (APIENTRYP PFNGLCONVOLUTIONPARAMETERFPROC) (GLenum target, GLenum pname, GLfloat params); +typedef void (APIENTRYP PFNGLCONVOLUTIONPARAMETERFVPROC) (GLenum target, GLenum pname, const GLfloat *params); +typedef void (APIENTRYP PFNGLCONVOLUTIONPARAMETERIPROC) (GLenum target, GLenum pname, GLint params); +typedef void (APIENTRYP PFNGLCONVOLUTIONPARAMETERIVPROC) (GLenum target, GLenum pname, const GLint *params); +typedef void (APIENTRYP PFNGLCOPYCONVOLUTIONFILTER1DPROC) (GLenum target, GLenum internalformat, GLint x, GLint y, GLsizei width); +typedef void (APIENTRYP PFNGLCOPYCONVOLUTIONFILTER2DPROC) (GLenum target, GLenum internalformat, GLint x, GLint y, GLsizei width, GLsizei height); +typedef void (APIENTRYP PFNGLGETCONVOLUTIONFILTERPROC) (GLenum target, GLenum format, GLenum type, GLvoid *image); +typedef void (APIENTRYP PFNGLGETCONVOLUTIONPARAMETERFVPROC) (GLenum target, GLenum pname, GLfloat *params); +typedef void (APIENTRYP PFNGLGETCONVOLUTIONPARAMETERIVPROC) (GLenum target, GLenum pname, GLint *params); +typedef void (APIENTRYP PFNGLGETSEPARABLEFILTERPROC) (GLenum target, GLenum format, GLenum type, GLvoid *row, GLvoid *column, GLvoid *span); +typedef void (APIENTRYP PFNGLSEPARABLEFILTER2DPROC) (GLenum target, GLenum internalformat, GLsizei width, GLsizei height, GLenum format, GLenum type, const GLvoid *row, const GLvoid *column); +typedef void (APIENTRYP PFNGLGETHISTOGRAMPROC) (GLenum target, GLboolean reset, GLenum format, GLenum type, GLvoid *values); +typedef void (APIENTRYP PFNGLGETHISTOGRAMPARAMETERFVPROC) (GLenum target, GLenum pname, GLfloat *params); +typedef void (APIENTRYP PFNGLGETHISTOGRAMPARAMETERIVPROC) (GLenum target, GLenum pname, GLint *params); +typedef void (APIENTRYP PFNGLGETMINMAXPROC) (GLenum target, GLboolean reset, GLenum format, GLenum type, GLvoid *values); +typedef void (APIENTRYP PFNGLGETMINMAXPARAMETERFVPROC) (GLenum target, GLenum pname, GLfloat *params); +typedef void (APIENTRYP PFNGLGETMINMAXPARAMETERIVPROC) (GLenum target, GLenum pname, GLint *params); +typedef void (APIENTRYP PFNGLHISTOGRAMPROC) (GLenum target, GLsizei width, GLenum internalformat, GLboolean sink); +typedef void (APIENTRYP PFNGLMINMAXPROC) (GLenum target, GLenum internalformat, GLboolean sink); +typedef void (APIENTRYP PFNGLRESETHISTOGRAMPROC) (GLenum target); +typedef void (APIENTRYP PFNGLRESETMINMAXPROC) (GLenum target); +typedef void (APIENTRYP PFNGLTEXIMAGE3DPROC) (GLenum target, GLint level, GLint internalformat, GLsizei width, GLsizei height, GLsizei depth, GLint border, GLenum format, GLenum type, const GLvoid *pixels); +typedef void (APIENTRYP PFNGLTEXSUBIMAGE3DPROC) (GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLenum type, const GLvoid *pixels); +typedef void (APIENTRYP PFNGLCOPYTEXSUBIMAGE3DPROC) (GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLint x, GLint y, GLsizei width, GLsizei height); +#endif + +#ifndef GL_VERSION_1_3 +#define GL_VERSION_1_3 1 +#ifdef GL_GLEXT_PROTOTYPES +GLAPI void APIENTRY glActiveTexture (GLenum); +GLAPI void APIENTRY glClientActiveTexture (GLenum); +GLAPI void APIENTRY glMultiTexCoord1d (GLenum, GLdouble); +GLAPI void APIENTRY glMultiTexCoord1dv (GLenum, const GLdouble *); +GLAPI void APIENTRY glMultiTexCoord1f (GLenum, GLfloat); +GLAPI void APIENTRY glMultiTexCoord1fv (GLenum, const GLfloat *); +GLAPI void APIENTRY glMultiTexCoord1i (GLenum, GLint); +GLAPI void APIENTRY glMultiTexCoord1iv (GLenum, const GLint *); +GLAPI void APIENTRY glMultiTexCoord1s (GLenum, GLshort); +GLAPI void APIENTRY glMultiTexCoord1sv (GLenum, const GLshort *); +GLAPI void APIENTRY glMultiTexCoord2d (GLenum, GLdouble, GLdouble); +GLAPI void APIENTRY glMultiTexCoord2dv (GLenum, const GLdouble *); +GLAPI void APIENTRY glMultiTexCoord2f (GLenum, GLfloat, GLfloat); +GLAPI void APIENTRY glMultiTexCoord2fv (GLenum, const GLfloat *); +GLAPI void APIENTRY glMultiTexCoord2i (GLenum, GLint, GLint); +GLAPI void APIENTRY glMultiTexCoord2iv (GLenum, const GLint *); +GLAPI void APIENTRY glMultiTexCoord2s (GLenum, GLshort, GLshort); +GLAPI void APIENTRY glMultiTexCoord2sv (GLenum, const GLshort *); +GLAPI void APIENTRY glMultiTexCoord3d (GLenum, GLdouble, GLdouble, GLdouble); +GLAPI void APIENTRY glMultiTexCoord3dv (GLenum, const GLdouble *); +GLAPI void APIENTRY glMultiTexCoord3f (GLenum, GLfloat, GLfloat, GLfloat); +GLAPI void APIENTRY glMultiTexCoord3fv (GLenum, const GLfloat *); +GLAPI void APIENTRY glMultiTexCoord3i (GLenum, GLint, GLint, GLint); +GLAPI void APIENTRY glMultiTexCoord3iv (GLenum, const GLint *); +GLAPI void APIENTRY glMultiTexCoord3s (GLenum, GLshort, GLshort, GLshort); +GLAPI void APIENTRY glMultiTexCoord3sv (GLenum, const GLshort *); +GLAPI void APIENTRY glMultiTexCoord4d (GLenum, GLdouble, GLdouble, GLdouble, GLdouble); +GLAPI void APIENTRY glMultiTexCoord4dv (GLenum, const GLdouble *); +GLAPI void APIENTRY glMultiTexCoord4f (GLenum, GLfloat, GLfloat, GLfloat, GLfloat); +GLAPI void APIENTRY glMultiTexCoord4fv (GLenum, const GLfloat *); +GLAPI void APIENTRY glMultiTexCoord4i (GLenum, GLint, GLint, GLint, GLint); +GLAPI void APIENTRY glMultiTexCoord4iv (GLenum, const GLint *); +GLAPI void APIENTRY glMultiTexCoord4s (GLenum, GLshort, GLshort, GLshort, GLshort); +GLAPI void APIENTRY glMultiTexCoord4sv (GLenum, const GLshort *); +GLAPI void APIENTRY glLoadTransposeMatrixf (const GLfloat *); +GLAPI void APIENTRY glLoadTransposeMatrixd (const GLdouble *); +GLAPI void APIENTRY glMultTransposeMatrixf (const GLfloat *); +GLAPI void APIENTRY glMultTransposeMatrixd (const GLdouble *); +GLAPI void APIENTRY glSampleCoverage (GLclampf, GLboolean); +GLAPI void APIENTRY glCompressedTexImage3D (GLenum, GLint, GLenum, GLsizei, GLsizei, GLsizei, GLint, GLsizei, const GLvoid *); +GLAPI void APIENTRY glCompressedTexImage2D (GLenum, GLint, GLenum, GLsizei, GLsizei, GLint, GLsizei, const GLvoid *); +GLAPI void APIENTRY glCompressedTexImage1D (GLenum, GLint, GLenum, GLsizei, GLint, GLsizei, const GLvoid *); +GLAPI void APIENTRY glCompressedTexSubImage3D (GLenum, GLint, GLint, GLint, GLint, GLsizei, GLsizei, GLsizei, GLenum, GLsizei, const GLvoid *); +GLAPI void APIENTRY glCompressedTexSubImage2D (GLenum, GLint, GLint, GLint, GLsizei, GLsizei, GLenum, GLsizei, const GLvoid *); +GLAPI void APIENTRY glCompressedTexSubImage1D (GLenum, GLint, GLint, GLsizei, GLenum, GLsizei, const GLvoid *); +GLAPI void APIENTRY glGetCompressedTexImage (GLenum, GLint, GLvoid *); +#endif /* GL_GLEXT_PROTOTYPES */ +typedef void (APIENTRYP PFNGLACTIVETEXTUREPROC) (GLenum texture); +typedef void (APIENTRYP PFNGLCLIENTACTIVETEXTUREPROC) (GLenum texture); +typedef void (APIENTRYP PFNGLMULTITEXCOORD1DPROC) (GLenum target, GLdouble s); +typedef void (APIENTRYP PFNGLMULTITEXCOORD1DVPROC) (GLenum target, const GLdouble *v); +typedef void (APIENTRYP PFNGLMULTITEXCOORD1FPROC) (GLenum target, GLfloat s); +typedef void (APIENTRYP PFNGLMULTITEXCOORD1FVPROC) (GLenum target, const GLfloat *v); +typedef void (APIENTRYP PFNGLMULTITEXCOORD1IPROC) (GLenum target, GLint s); +typedef void (APIENTRYP PFNGLMULTITEXCOORD1IVPROC) (GLenum target, const GLint *v); +typedef void (APIENTRYP PFNGLMULTITEXCOORD1SPROC) (GLenum target, GLshort s); +typedef void (APIENTRYP PFNGLMULTITEXCOORD1SVPROC) (GLenum target, const GLshort *v); +typedef void (APIENTRYP PFNGLMULTITEXCOORD2DPROC) (GLenum target, GLdouble s, GLdouble t); +typedef void (APIENTRYP PFNGLMULTITEXCOORD2DVPROC) (GLenum target, const GLdouble *v); +typedef void (APIENTRYP PFNGLMULTITEXCOORD2FPROC) (GLenum target, GLfloat s, GLfloat t); +typedef void (APIENTRYP PFNGLMULTITEXCOORD2FVPROC) (GLenum target, const GLfloat *v); +typedef void (APIENTRYP PFNGLMULTITEXCOORD2IPROC) (GLenum target, GLint s, GLint t); +typedef void (APIENTRYP PFNGLMULTITEXCOORD2IVPROC) (GLenum target, const GLint *v); +typedef void (APIENTRYP PFNGLMULTITEXCOORD2SPROC) (GLenum target, GLshort s, GLshort t); +typedef void (APIENTRYP PFNGLMULTITEXCOORD2SVPROC) (GLenum target, const GLshort *v); +typedef void (APIENTRYP PFNGLMULTITEXCOORD3DPROC) (GLenum target, GLdouble s, GLdouble t, GLdouble r); +typedef void (APIENTRYP PFNGLMULTITEXCOORD3DVPROC) (GLenum target, const GLdouble *v); +typedef void (APIENTRYP PFNGLMULTITEXCOORD3FPROC) (GLenum target, GLfloat s, GLfloat t, GLfloat r); +typedef void (APIENTRYP PFNGLMULTITEXCOORD3FVPROC) (GLenum target, const GLfloat *v); +typedef void (APIENTRYP PFNGLMULTITEXCOORD3IPROC) (GLenum target, GLint s, GLint t, GLint r); +typedef void (APIENTRYP PFNGLMULTITEXCOORD3IVPROC) (GLenum target, const GLint *v); +typedef void (APIENTRYP PFNGLMULTITEXCOORD3SPROC) (GLenum target, GLshort s, GLshort t, GLshort r); +typedef void (APIENTRYP PFNGLMULTITEXCOORD3SVPROC) (GLenum target, const GLshort *v); +typedef void (APIENTRYP PFNGLMULTITEXCOORD4DPROC) (GLenum target, GLdouble s, GLdouble t, GLdouble r, GLdouble q); +typedef void (APIENTRYP PFNGLMULTITEXCOORD4DVPROC) (GLenum target, const GLdouble *v); +typedef void (APIENTRYP PFNGLMULTITEXCOORD4FPROC) (GLenum target, GLfloat s, GLfloat t, GLfloat r, GLfloat q); +typedef void (APIENTRYP PFNGLMULTITEXCOORD4FVPROC) (GLenum target, const GLfloat *v); +typedef void (APIENTRYP PFNGLMULTITEXCOORD4IPROC) (GLenum target, GLint s, GLint t, GLint r, GLint q); +typedef void (APIENTRYP PFNGLMULTITEXCOORD4IVPROC) (GLenum target, const GLint *v); +typedef void (APIENTRYP PFNGLMULTITEXCOORD4SPROC) (GLenum target, GLshort s, GLshort t, GLshort r, GLshort q); +typedef void (APIENTRYP PFNGLMULTITEXCOORD4SVPROC) (GLenum target, const GLshort *v); +typedef void (APIENTRYP PFNGLLOADTRANSPOSEMATRIXFPROC) (const GLfloat *m); +typedef void (APIENTRYP PFNGLLOADTRANSPOSEMATRIXDPROC) (const GLdouble *m); +typedef void (APIENTRYP PFNGLMULTTRANSPOSEMATRIXFPROC) (const GLfloat *m); +typedef void (APIENTRYP PFNGLMULTTRANSPOSEMATRIXDPROC) (const GLdouble *m); +typedef void (APIENTRYP PFNGLSAMPLECOVERAGEPROC) (GLclampf value, GLboolean invert); +typedef void (APIENTRYP PFNGLCOMPRESSEDTEXIMAGE3DPROC) (GLenum target, GLint level, GLenum internalformat, GLsizei width, GLsizei height, GLsizei depth, GLint border, GLsizei imageSize, const GLvoid *data); +typedef void (APIENTRYP PFNGLCOMPRESSEDTEXIMAGE2DPROC) (GLenum target, GLint level, GLenum internalformat, GLsizei width, GLsizei height, GLint border, GLsizei imageSize, const GLvoid *data); +typedef void (APIENTRYP PFNGLCOMPRESSEDTEXIMAGE1DPROC) (GLenum target, GLint level, GLenum internalformat, GLsizei width, GLint border, GLsizei imageSize, const GLvoid *data); +typedef void (APIENTRYP PFNGLCOMPRESSEDTEXSUBIMAGE3DPROC) (GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLsizei imageSize, const GLvoid *data); +typedef void (APIENTRYP PFNGLCOMPRESSEDTEXSUBIMAGE2DPROC) (GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLsizei imageSize, const GLvoid *data); +typedef void (APIENTRYP PFNGLCOMPRESSEDTEXSUBIMAGE1DPROC) (GLenum target, GLint level, GLint xoffset, GLsizei width, GLenum format, GLsizei imageSize, const GLvoid *data); +typedef void (APIENTRYP PFNGLGETCOMPRESSEDTEXIMAGEPROC) (GLenum target, GLint level, GLvoid *img); +#endif + +#ifndef GL_VERSION_1_4 +#define GL_VERSION_1_4 1 +#ifdef GL_GLEXT_PROTOTYPES +GLAPI void APIENTRY glBlendFuncSeparate (GLenum, GLenum, GLenum, GLenum); +GLAPI void APIENTRY glFogCoordf (GLfloat); +GLAPI void APIENTRY glFogCoordfv (const GLfloat *); +GLAPI void APIENTRY glFogCoordd (GLdouble); +GLAPI void APIENTRY glFogCoorddv (const GLdouble *); +GLAPI void APIENTRY glFogCoordPointer (GLenum, GLsizei, const GLvoid *); +GLAPI void APIENTRY glMultiDrawArrays (GLenum, GLint *, GLsizei *, GLsizei); +GLAPI void APIENTRY glMultiDrawElements (GLenum, const GLsizei *, GLenum, const GLvoid* *, GLsizei); +GLAPI void APIENTRY glPointParameterf (GLenum, GLfloat); +GLAPI void APIENTRY glPointParameterfv (GLenum, const GLfloat *); +GLAPI void APIENTRY glPointParameteri (GLenum, GLint); +GLAPI void APIENTRY glPointParameteriv (GLenum, const GLint *); +GLAPI void APIENTRY glSecondaryColor3b (GLbyte, GLbyte, GLbyte); +GLAPI void APIENTRY glSecondaryColor3bv (const GLbyte *); +GLAPI void APIENTRY glSecondaryColor3d (GLdouble, GLdouble, GLdouble); +GLAPI void APIENTRY glSecondaryColor3dv (const GLdouble *); +GLAPI void APIENTRY glSecondaryColor3f (GLfloat, GLfloat, GLfloat); +GLAPI void APIENTRY glSecondaryColor3fv (const GLfloat *); +GLAPI void APIENTRY glSecondaryColor3i (GLint, GLint, GLint); +GLAPI void APIENTRY glSecondaryColor3iv (const GLint *); +GLAPI void APIENTRY glSecondaryColor3s (GLshort, GLshort, GLshort); +GLAPI void APIENTRY glSecondaryColor3sv (const GLshort *); +GLAPI void APIENTRY glSecondaryColor3ub (GLubyte, GLubyte, GLubyte); +GLAPI void APIENTRY glSecondaryColor3ubv (const GLubyte *); +GLAPI void APIENTRY glSecondaryColor3ui (GLuint, GLuint, GLuint); +GLAPI void APIENTRY glSecondaryColor3uiv (const GLuint *); +GLAPI void APIENTRY glSecondaryColor3us (GLushort, GLushort, GLushort); +GLAPI void APIENTRY glSecondaryColor3usv (const GLushort *); +GLAPI void APIENTRY glSecondaryColorPointer (GLint, GLenum, GLsizei, const GLvoid *); +GLAPI void APIENTRY glWindowPos2d (GLdouble, GLdouble); +GLAPI void APIENTRY glWindowPos2dv (const GLdouble *); +GLAPI void APIENTRY glWindowPos2f (GLfloat, GLfloat); +GLAPI void APIENTRY glWindowPos2fv (const GLfloat *); +GLAPI void APIENTRY glWindowPos2i (GLint, GLint); +GLAPI void APIENTRY glWindowPos2iv (const GLint *); +GLAPI void APIENTRY glWindowPos2s (GLshort, GLshort); +GLAPI void APIENTRY glWindowPos2sv (const GLshort *); +GLAPI void APIENTRY glWindowPos3d (GLdouble, GLdouble, GLdouble); +GLAPI void APIENTRY glWindowPos3dv (const GLdouble *); +GLAPI void APIENTRY glWindowPos3f (GLfloat, GLfloat, GLfloat); +GLAPI void APIENTRY glWindowPos3fv (const GLfloat *); +GLAPI void APIENTRY glWindowPos3i (GLint, GLint, GLint); +GLAPI void APIENTRY glWindowPos3iv (const GLint *); +GLAPI void APIENTRY glWindowPos3s (GLshort, GLshort, GLshort); +GLAPI void APIENTRY glWindowPos3sv (const GLshort *); +#endif /* GL_GLEXT_PROTOTYPES */ +typedef void (APIENTRYP PFNGLBLENDFUNCSEPARATEPROC) (GLenum sfactorRGB, GLenum dfactorRGB, GLenum sfactorAlpha, GLenum dfactorAlpha); +typedef void (APIENTRYP PFNGLFOGCOORDFPROC) (GLfloat coord); +typedef void (APIENTRYP PFNGLFOGCOORDFVPROC) (const GLfloat *coord); +typedef void (APIENTRYP PFNGLFOGCOORDDPROC) (GLdouble coord); +typedef void (APIENTRYP PFNGLFOGCOORDDVPROC) (const GLdouble *coord); +typedef void (APIENTRYP PFNGLFOGCOORDPOINTERPROC) (GLenum type, GLsizei stride, const GLvoid *pointer); +typedef void (APIENTRYP PFNGLMULTIDRAWARRAYSPROC) (GLenum mode, GLint *first, GLsizei *count, GLsizei primcount); +typedef void (APIENTRYP PFNGLMULTIDRAWELEMENTSPROC) (GLenum mode, const GLsizei *count, GLenum type, const GLvoid* *indices, GLsizei primcount); +typedef void (APIENTRYP PFNGLPOINTPARAMETERFPROC) (GLenum pname, GLfloat param); +typedef void (APIENTRYP PFNGLPOINTPARAMETERFVPROC) (GLenum pname, const GLfloat *params); +typedef void (APIENTRYP PFNGLPOINTPARAMETERIPROC) (GLenum pname, GLint param); +typedef void (APIENTRYP PFNGLPOINTPARAMETERIVPROC) (GLenum pname, const GLint *params); +typedef void (APIENTRYP PFNGLSECONDARYCOLOR3BPROC) (GLbyte red, GLbyte green, GLbyte blue); +typedef void (APIENTRYP PFNGLSECONDARYCOLOR3BVPROC) (const GLbyte *v); +typedef void (APIENTRYP PFNGLSECONDARYCOLOR3DPROC) (GLdouble red, GLdouble green, GLdouble blue); +typedef void (APIENTRYP PFNGLSECONDARYCOLOR3DVPROC) (const GLdouble *v); +typedef void (APIENTRYP PFNGLSECONDARYCOLOR3FPROC) (GLfloat red, GLfloat green, GLfloat blue); +typedef void (APIENTRYP PFNGLSECONDARYCOLOR3FVPROC) (const GLfloat *v); +typedef void (APIENTRYP PFNGLSECONDARYCOLOR3IPROC) (GLint red, GLint green, GLint blue); +typedef void (APIENTRYP PFNGLSECONDARYCOLOR3IVPROC) (const GLint *v); +typedef void (APIENTRYP PFNGLSECONDARYCOLOR3SPROC) (GLshort red, GLshort green, GLshort blue); +typedef void (APIENTRYP PFNGLSECONDARYCOLOR3SVPROC) (const GLshort *v); +typedef void (APIENTRYP PFNGLSECONDARYCOLOR3UBPROC) (GLubyte red, GLubyte green, GLubyte blue); +typedef void (APIENTRYP PFNGLSECONDARYCOLOR3UBVPROC) (const GLubyte *v); +typedef void (APIENTRYP PFNGLSECONDARYCOLOR3UIPROC) (GLuint red, GLuint green, GLuint blue); +typedef void (APIENTRYP PFNGLSECONDARYCOLOR3UIVPROC) (const GLuint *v); +typedef void (APIENTRYP PFNGLSECONDARYCOLOR3USPROC) (GLushort red, GLushort green, GLushort blue); +typedef void (APIENTRYP PFNGLSECONDARYCOLOR3USVPROC) (const GLushort *v); +typedef void (APIENTRYP PFNGLSECONDARYCOLORPOINTERPROC) (GLint size, GLenum type, GLsizei stride, const GLvoid *pointer); +typedef void (APIENTRYP PFNGLWINDOWPOS2DPROC) (GLdouble x, GLdouble y); +typedef void (APIENTRYP PFNGLWINDOWPOS2DVPROC) (const GLdouble *v); +typedef void (APIENTRYP PFNGLWINDOWPOS2FPROC) (GLfloat x, GLfloat y); +typedef void (APIENTRYP PFNGLWINDOWPOS2FVPROC) (const GLfloat *v); +typedef void (APIENTRYP PFNGLWINDOWPOS2IPROC) (GLint x, GLint y); +typedef void (APIENTRYP PFNGLWINDOWPOS2IVPROC) (const GLint *v); +typedef void (APIENTRYP PFNGLWINDOWPOS2SPROC) (GLshort x, GLshort y); +typedef void (APIENTRYP PFNGLWINDOWPOS2SVPROC) (const GLshort *v); +typedef void (APIENTRYP PFNGLWINDOWPOS3DPROC) (GLdouble x, GLdouble y, GLdouble z); +typedef void (APIENTRYP PFNGLWINDOWPOS3DVPROC) (const GLdouble *v); +typedef void (APIENTRYP PFNGLWINDOWPOS3FPROC) (GLfloat x, GLfloat y, GLfloat z); +typedef void (APIENTRYP PFNGLWINDOWPOS3FVPROC) (const GLfloat *v); +typedef void (APIENTRYP PFNGLWINDOWPOS3IPROC) (GLint x, GLint y, GLint z); +typedef void (APIENTRYP PFNGLWINDOWPOS3IVPROC) (const GLint *v); +typedef void (APIENTRYP PFNGLWINDOWPOS3SPROC) (GLshort x, GLshort y, GLshort z); +typedef void (APIENTRYP PFNGLWINDOWPOS3SVPROC) (const GLshort *v); +#endif + +#ifndef GL_VERSION_1_5 +#define GL_VERSION_1_5 1 +#ifdef GL_GLEXT_PROTOTYPES +GLAPI void APIENTRY glGenQueries (GLsizei, GLuint *); +GLAPI void APIENTRY glDeleteQueries (GLsizei, const GLuint *); +GLAPI GLboolean APIENTRY glIsQuery (GLuint); +GLAPI void APIENTRY glBeginQuery (GLenum, GLuint); +GLAPI void APIENTRY glEndQuery (GLenum); +GLAPI void APIENTRY glGetQueryiv (GLenum, GLenum, GLint *); +GLAPI void APIENTRY glGetQueryObjectiv (GLuint, GLenum, GLint *); +GLAPI void APIENTRY glGetQueryObjectuiv (GLuint, GLenum, GLuint *); +GLAPI void APIENTRY glBindBuffer (GLenum, GLuint); +GLAPI void APIENTRY glDeleteBuffers (GLsizei, const GLuint *); +GLAPI void APIENTRY glGenBuffers (GLsizei, GLuint *); +GLAPI GLboolean APIENTRY glIsBuffer (GLuint); +GLAPI void APIENTRY glBufferData (GLenum, GLsizeiptr, const GLvoid *, GLenum); +GLAPI void APIENTRY glBufferSubData (GLenum, GLintptr, GLsizeiptr, const GLvoid *); +GLAPI void APIENTRY glGetBufferSubData (GLenum, GLintptr, GLsizeiptr, GLvoid *); +GLAPI GLvoid* APIENTRY glMapBuffer (GLenum, GLenum); +GLAPI GLboolean APIENTRY glUnmapBuffer (GLenum); +GLAPI void APIENTRY glGetBufferParameteriv (GLenum, GLenum, GLint *); +GLAPI void APIENTRY glGetBufferPointerv (GLenum, GLenum, GLvoid* *); +#endif /* GL_GLEXT_PROTOTYPES */ +typedef void (APIENTRYP PFNGLGENQUERIESPROC) (GLsizei n, GLuint *ids); +typedef void (APIENTRYP PFNGLDELETEQUERIESPROC) (GLsizei n, const GLuint *ids); +typedef GLboolean (APIENTRYP PFNGLISQUERYPROC) (GLuint id); +typedef void (APIENTRYP PFNGLBEGINQUERYPROC) (GLenum target, GLuint id); +typedef void (APIENTRYP PFNGLENDQUERYPROC) (GLenum target); +typedef void (APIENTRYP PFNGLGETQUERYIVPROC) (GLenum target, GLenum pname, GLint *params); +typedef void (APIENTRYP PFNGLGETQUERYOBJECTIVPROC) (GLuint id, GLenum pname, GLint *params); +typedef void (APIENTRYP PFNGLGETQUERYOBJECTUIVPROC) (GLuint id, GLenum pname, GLuint *params); +typedef void (APIENTRYP PFNGLBINDBUFFERPROC) (GLenum target, GLuint buffer); +typedef void (APIENTRYP PFNGLDELETEBUFFERSPROC) (GLsizei n, const GLuint *buffers); +typedef void (APIENTRYP PFNGLGENBUFFERSPROC) (GLsizei n, GLuint *buffers); +typedef GLboolean (APIENTRYP PFNGLISBUFFERPROC) (GLuint buffer); +typedef void (APIENTRYP PFNGLBUFFERDATAPROC) (GLenum target, GLsizeiptr size, const GLvoid *data, GLenum usage); +typedef void (APIENTRYP PFNGLBUFFERSUBDATAPROC) (GLenum target, GLintptr offset, GLsizeiptr size, const GLvoid *data); +typedef void (APIENTRYP PFNGLGETBUFFERSUBDATAPROC) (GLenum target, GLintptr offset, GLsizeiptr size, GLvoid *data); +typedef GLvoid* (APIENTRYP PFNGLMAPBUFFERPROC) (GLenum target, GLenum access); +typedef GLboolean (APIENTRYP PFNGLUNMAPBUFFERPROC) (GLenum target); +typedef void (APIENTRYP PFNGLGETBUFFERPARAMETERIVPROC) (GLenum target, GLenum pname, GLint *params); +typedef void (APIENTRYP PFNGLGETBUFFERPOINTERVPROC) (GLenum target, GLenum pname, GLvoid* *params); +#endif + +#ifndef GL_VERSION_2_0 +#define GL_VERSION_2_0 1 +#ifdef GL_GLEXT_PROTOTYPES +GLAPI void APIENTRY glBlendEquationSeparate (GLenum, GLenum); +GLAPI void APIENTRY glDrawBuffers (GLsizei, const GLenum *); +GLAPI void APIENTRY glStencilOpSeparate (GLenum, GLenum, GLenum, GLenum); +GLAPI void APIENTRY glStencilFuncSeparate (GLenum, GLenum, GLint, GLuint); +GLAPI void APIENTRY glStencilMaskSeparate (GLenum, GLuint); +GLAPI void APIENTRY glAttachShader (GLuint, GLuint); +GLAPI void APIENTRY glBindAttribLocation (GLuint, GLuint, const GLchar *); +GLAPI void APIENTRY glCompileShader (GLuint); +GLAPI GLuint APIENTRY glCreateProgram (void); +GLAPI GLuint APIENTRY glCreateShader (GLenum); +GLAPI void APIENTRY glDeleteProgram (GLuint); +GLAPI void APIENTRY glDeleteShader (GLuint); +GLAPI void APIENTRY glDetachShader (GLuint, GLuint); +GLAPI void APIENTRY glDisableVertexAttribArray (GLuint); +GLAPI void APIENTRY glEnableVertexAttribArray (GLuint); +GLAPI void APIENTRY glGetActiveAttrib (GLuint, GLuint, GLsizei, GLsizei *, GLint *, GLenum *, GLchar *); +GLAPI void APIENTRY glGetActiveUniform (GLuint, GLuint, GLsizei, GLsizei *, GLint *, GLenum *, GLchar *); +GLAPI void APIENTRY glGetAttachedShaders (GLuint, GLsizei, GLsizei *, GLuint *); +GLAPI GLint APIENTRY glGetAttribLocation (GLuint, const GLchar *); +GLAPI void APIENTRY glGetProgramiv (GLuint, GLenum, GLint *); +GLAPI void APIENTRY glGetProgramInfoLog (GLuint, GLsizei, GLsizei *, GLchar *); +GLAPI void APIENTRY glGetShaderiv (GLuint, GLenum, GLint *); +GLAPI void APIENTRY glGetShaderInfoLog (GLuint, GLsizei, GLsizei *, GLchar *); +GLAPI void APIENTRY glGetShaderSource (GLuint, GLsizei, GLsizei *, GLchar *); +GLAPI GLint APIENTRY glGetUniformLocation (GLuint, const GLchar *); +GLAPI void APIENTRY glGetUniformfv (GLuint, GLint, GLfloat *); +GLAPI void APIENTRY glGetUniformiv (GLuint, GLint, GLint *); +GLAPI void APIENTRY glGetVertexAttribdv (GLuint, GLenum, GLdouble *); +GLAPI void APIENTRY glGetVertexAttribfv (GLuint, GLenum, GLfloat *); +GLAPI void APIENTRY glGetVertexAttribiv (GLuint, GLenum, GLint *); +GLAPI void APIENTRY glGetVertexAttribPointerv (GLuint, GLenum, GLvoid* *); +GLAPI GLboolean APIENTRY glIsProgram (GLuint); +GLAPI GLboolean APIENTRY glIsShader (GLuint); +GLAPI void APIENTRY glLinkProgram (GLuint); +GLAPI void APIENTRY glShaderSource (GLuint, GLsizei, const GLchar* *, const GLint *); +GLAPI void APIENTRY glUseProgram (GLuint); +GLAPI void APIENTRY glUniform1f (GLint, GLfloat); +GLAPI void APIENTRY glUniform2f (GLint, GLfloat, GLfloat); +GLAPI void APIENTRY glUniform3f (GLint, GLfloat, GLfloat, GLfloat); +GLAPI void APIENTRY glUniform4f (GLint, GLfloat, GLfloat, GLfloat, GLfloat); +GLAPI void APIENTRY glUniform1i (GLint, GLint); +GLAPI void APIENTRY glUniform2i (GLint, GLint, GLint); +GLAPI void APIENTRY glUniform3i (GLint, GLint, GLint, GLint); +GLAPI void APIENTRY glUniform4i (GLint, GLint, GLint, GLint, GLint); +GLAPI void APIENTRY glUniform1fv (GLint, GLsizei, const GLfloat *); +GLAPI void APIENTRY glUniform2fv (GLint, GLsizei, const GLfloat *); +GLAPI void APIENTRY glUniform3fv (GLint, GLsizei, const GLfloat *); +GLAPI void APIENTRY glUniform4fv (GLint, GLsizei, const GLfloat *); +GLAPI void APIENTRY glUniform1iv (GLint, GLsizei, const GLint *); +GLAPI void APIENTRY glUniform2iv (GLint, GLsizei, const GLint *); +GLAPI void APIENTRY glUniform3iv (GLint, GLsizei, const GLint *); +GLAPI void APIENTRY glUniform4iv (GLint, GLsizei, const GLint *); +GLAPI void APIENTRY glUniformMatrix2fv (GLint, GLsizei, GLboolean, const GLfloat *); +GLAPI void APIENTRY glUniformMatrix3fv (GLint, GLsizei, GLboolean, const GLfloat *); +GLAPI void APIENTRY glUniformMatrix4fv (GLint, GLsizei, GLboolean, const GLfloat *); +GLAPI void APIENTRY glValidateProgram (GLuint); +GLAPI void APIENTRY glVertexAttrib1d (GLuint, GLdouble); +GLAPI void APIENTRY glVertexAttrib1dv (GLuint, const GLdouble *); +GLAPI void APIENTRY glVertexAttrib1f (GLuint, GLfloat); +GLAPI void APIENTRY glVertexAttrib1fv (GLuint, const GLfloat *); +GLAPI void APIENTRY glVertexAttrib1s (GLuint, GLshort); +GLAPI void APIENTRY glVertexAttrib1sv (GLuint, const GLshort *); +GLAPI void APIENTRY glVertexAttrib2d (GLuint, GLdouble, GLdouble); +GLAPI void APIENTRY glVertexAttrib2dv (GLuint, const GLdouble *); +GLAPI void APIENTRY glVertexAttrib2f (GLuint, GLfloat, GLfloat); +GLAPI void APIENTRY glVertexAttrib2fv (GLuint, const GLfloat *); +GLAPI void APIENTRY glVertexAttrib2s (GLuint, GLshort, GLshort); +GLAPI void APIENTRY glVertexAttrib2sv (GLuint, const GLshort *); +GLAPI void APIENTRY glVertexAttrib3d (GLuint, GLdouble, GLdouble, GLdouble); +GLAPI void APIENTRY glVertexAttrib3dv (GLuint, const GLdouble *); +GLAPI void APIENTRY glVertexAttrib3f (GLuint, GLfloat, GLfloat, GLfloat); +GLAPI void APIENTRY glVertexAttrib3fv (GLuint, const GLfloat *); +GLAPI void APIENTRY glVertexAttrib3s (GLuint, GLshort, GLshort, GLshort); +GLAPI void APIENTRY glVertexAttrib3sv (GLuint, const GLshort *); +GLAPI void APIENTRY glVertexAttrib4Nbv (GLuint, const GLbyte *); +GLAPI void APIENTRY glVertexAttrib4Niv (GLuint, const GLint *); +GLAPI void APIENTRY glVertexAttrib4Nsv (GLuint, const GLshort *); +GLAPI void APIENTRY glVertexAttrib4Nub (GLuint, GLubyte, GLubyte, GLubyte, GLubyte); +GLAPI void APIENTRY glVertexAttrib4Nubv (GLuint, const GLubyte *); +GLAPI void APIENTRY glVertexAttrib4Nuiv (GLuint, const GLuint *); +GLAPI void APIENTRY glVertexAttrib4Nusv (GLuint, const GLushort *); +GLAPI void APIENTRY glVertexAttrib4bv (GLuint, const GLbyte *); +GLAPI void APIENTRY glVertexAttrib4d (GLuint, GLdouble, GLdouble, GLdouble, GLdouble); +GLAPI void APIENTRY glVertexAttrib4dv (GLuint, const GLdouble *); +GLAPI void APIENTRY glVertexAttrib4f (GLuint, GLfloat, GLfloat, GLfloat, GLfloat); +GLAPI void APIENTRY glVertexAttrib4fv (GLuint, const GLfloat *); +GLAPI void APIENTRY glVertexAttrib4iv (GLuint, const GLint *); +GLAPI void APIENTRY glVertexAttrib4s (GLuint, GLshort, GLshort, GLshort, GLshort); +GLAPI void APIENTRY glVertexAttrib4sv (GLuint, const GLshort *); +GLAPI void APIENTRY glVertexAttrib4ubv (GLuint, const GLubyte *); +GLAPI void APIENTRY glVertexAttrib4uiv (GLuint, const GLuint *); +GLAPI void APIENTRY glVertexAttrib4usv (GLuint, const GLushort *); +GLAPI void APIENTRY glVertexAttribPointer (GLuint, GLint, GLenum, GLboolean, GLsizei, const GLvoid *); +#endif /* GL_GLEXT_PROTOTYPES */ +typedef void (APIENTRYP PFNGLBLENDEQUATIONSEPARATEPROC) (GLenum modeRGB, GLenum modeAlpha); +typedef void (APIENTRYP PFNGLDRAWBUFFERSPROC) (GLsizei n, const GLenum *bufs); +typedef void (APIENTRYP PFNGLSTENCILOPSEPARATEPROC) (GLenum face, GLenum sfail, GLenum dpfail, GLenum dppass); +typedef void (APIENTRYP PFNGLSTENCILFUNCSEPARATEPROC) (GLenum frontfunc, GLenum backfunc, GLint ref, GLuint mask); +typedef void (APIENTRYP PFNGLSTENCILMASKSEPARATEPROC) (GLenum face, GLuint mask); +typedef void (APIENTRYP PFNGLATTACHSHADERPROC) (GLuint program, GLuint shader); +typedef void (APIENTRYP PFNGLBINDATTRIBLOCATIONPROC) (GLuint program, GLuint index, const GLchar *name); +typedef void (APIENTRYP PFNGLCOMPILESHADERPROC) (GLuint shader); +typedef GLuint (APIENTRYP PFNGLCREATEPROGRAMPROC) (void); +typedef GLuint (APIENTRYP PFNGLCREATESHADERPROC) (GLenum type); +typedef void (APIENTRYP PFNGLDELETEPROGRAMPROC) (GLuint program); +typedef void (APIENTRYP PFNGLDELETESHADERPROC) (GLuint shader); +typedef void (APIENTRYP PFNGLDETACHSHADERPROC) (GLuint program, GLuint shader); +typedef void (APIENTRYP PFNGLDISABLEVERTEXATTRIBARRAYPROC) (GLuint index); +typedef void (APIENTRYP PFNGLENABLEVERTEXATTRIBARRAYPROC) (GLuint index); +typedef void (APIENTRYP PFNGLGETACTIVEATTRIBPROC) (GLuint program, GLuint index, GLsizei bufSize, GLsizei *length, GLint *size, GLenum *type, GLchar *name); +typedef void (APIENTRYP PFNGLGETACTIVEUNIFORMPROC) (GLuint program, GLuint index, GLsizei bufSize, GLsizei *length, GLint *size, GLenum *type, GLchar *name); +typedef void (APIENTRYP PFNGLGETATTACHEDSHADERSPROC) (GLuint program, GLsizei maxCount, GLsizei *count, GLuint *obj); +typedef GLint (APIENTRYP PFNGLGETATTRIBLOCATIONPROC) (GLuint program, const GLchar *name); +typedef void (APIENTRYP PFNGLGETPROGRAMIVPROC) (GLuint program, GLenum pname, GLint *params); +typedef void (APIENTRYP PFNGLGETPROGRAMINFOLOGPROC) (GLuint program, GLsizei bufSize, GLsizei *length, GLchar *infoLog); +typedef void (APIENTRYP PFNGLGETSHADERIVPROC) (GLuint shader, GLenum pname, GLint *params); +typedef void (APIENTRYP PFNGLGETSHADERINFOLOGPROC) (GLuint shader, GLsizei bufSize, GLsizei *length, GLchar *infoLog); +typedef void (APIENTRYP PFNGLGETSHADERSOURCEPROC) (GLuint shader, GLsizei bufSize, GLsizei *length, GLchar *source); +typedef GLint (APIENTRYP PFNGLGETUNIFORMLOCATIONPROC) (GLuint program, const GLchar *name); +typedef void (APIENTRYP PFNGLGETUNIFORMFVPROC) (GLuint program, GLint location, GLfloat *params); +typedef void (APIENTRYP PFNGLGETUNIFORMIVPROC) (GLuint program, GLint location, GLint *params); +typedef void (APIENTRYP PFNGLGETVERTEXATTRIBDVPROC) (GLuint index, GLenum pname, GLdouble *params); +typedef void (APIENTRYP PFNGLGETVERTEXATTRIBFVPROC) (GLuint index, GLenum pname, GLfloat *params); +typedef void (APIENTRYP PFNGLGETVERTEXATTRIBIVPROC) (GLuint index, GLenum pname, GLint *params); +typedef void (APIENTRYP PFNGLGETVERTEXATTRIBPOINTERVPROC) (GLuint index, GLenum pname, GLvoid* *pointer); +typedef GLboolean (APIENTRYP PFNGLISPROGRAMPROC) (GLuint program); +typedef GLboolean (APIENTRYP PFNGLISSHADERPROC) (GLuint shader); +typedef void (APIENTRYP PFNGLLINKPROGRAMPROC) (GLuint program); +typedef void (APIENTRYP PFNGLSHADERSOURCEPROC) (GLuint shader, GLsizei count, const GLchar* *string, const GLint *length); +typedef void (APIENTRYP PFNGLUSEPROGRAMPROC) (GLuint program); +typedef void (APIENTRYP PFNGLUNIFORM1FPROC) (GLint location, GLfloat v0); +typedef void (APIENTRYP PFNGLUNIFORM2FPROC) (GLint location, GLfloat v0, GLfloat v1); +typedef void (APIENTRYP PFNGLUNIFORM3FPROC) (GLint location, GLfloat v0, GLfloat v1, GLfloat v2); +typedef void (APIENTRYP PFNGLUNIFORM4FPROC) (GLint location, GLfloat v0, GLfloat v1, GLfloat v2, GLfloat v3); +typedef void (APIENTRYP PFNGLUNIFORM1IPROC) (GLint location, GLint v0); +typedef void (APIENTRYP PFNGLUNIFORM2IPROC) (GLint location, GLint v0, GLint v1); +typedef void (APIENTRYP PFNGLUNIFORM3IPROC) (GLint location, GLint v0, GLint v1, GLint v2); +typedef void (APIENTRYP PFNGLUNIFORM4IPROC) (GLint location, GLint v0, GLint v1, GLint v2, GLint v3); +typedef void (APIENTRYP PFNGLUNIFORM1FVPROC) (GLint location, GLsizei count, const GLfloat *value); +typedef void (APIENTRYP PFNGLUNIFORM2FVPROC) (GLint location, GLsizei count, const GLfloat *value); +typedef void (APIENTRYP PFNGLUNIFORM3FVPROC) (GLint location, GLsizei count, const GLfloat *value); +typedef void (APIENTRYP PFNGLUNIFORM4FVPROC) (GLint location, GLsizei count, const GLfloat *value); +typedef void (APIENTRYP PFNGLUNIFORM1IVPROC) (GLint location, GLsizei count, const GLint *value); +typedef void (APIENTRYP PFNGLUNIFORM2IVPROC) (GLint location, GLsizei count, const GLint *value); +typedef void (APIENTRYP PFNGLUNIFORM3IVPROC) (GLint location, GLsizei count, const GLint *value); +typedef void (APIENTRYP PFNGLUNIFORM4IVPROC) (GLint location, GLsizei count, const GLint *value); +typedef void (APIENTRYP PFNGLUNIFORMMATRIX2FVPROC) (GLint location, GLsizei count, GLboolean transpose, const GLfloat *value); +typedef void (APIENTRYP PFNGLUNIFORMMATRIX3FVPROC) (GLint location, GLsizei count, GLboolean transpose, const GLfloat *value); +typedef void (APIENTRYP PFNGLUNIFORMMATRIX4FVPROC) (GLint location, GLsizei count, GLboolean transpose, const GLfloat *value); +typedef void (APIENTRYP PFNGLVALIDATEPROGRAMPROC) (GLuint program); +typedef void (APIENTRYP PFNGLVERTEXATTRIB1DPROC) (GLuint index, GLdouble x); +typedef void (APIENTRYP PFNGLVERTEXATTRIB1DVPROC) (GLuint index, const GLdouble *v); +typedef void (APIENTRYP PFNGLVERTEXATTRIB1FPROC) (GLuint index, GLfloat x); +typedef void (APIENTRYP PFNGLVERTEXATTRIB1FVPROC) (GLuint index, const GLfloat *v); +typedef void (APIENTRYP PFNGLVERTEXATTRIB1SPROC) (GLuint index, GLshort x); +typedef void (APIENTRYP PFNGLVERTEXATTRIB1SVPROC) (GLuint index, const GLshort *v); +typedef void (APIENTRYP PFNGLVERTEXATTRIB2DPROC) (GLuint index, GLdouble x, GLdouble y); +typedef void (APIENTRYP PFNGLVERTEXATTRIB2DVPROC) (GLuint index, const GLdouble *v); +typedef void (APIENTRYP PFNGLVERTEXATTRIB2FPROC) (GLuint index, GLfloat x, GLfloat y); +typedef void (APIENTRYP PFNGLVERTEXATTRIB2FVPROC) (GLuint index, const GLfloat *v); +typedef void (APIENTRYP PFNGLVERTEXATTRIB2SPROC) (GLuint index, GLshort x, GLshort y); +typedef void (APIENTRYP PFNGLVERTEXATTRIB2SVPROC) (GLuint index, const GLshort *v); +typedef void (APIENTRYP PFNGLVERTEXATTRIB3DPROC) (GLuint index, GLdouble x, GLdouble y, GLdouble z); +typedef void (APIENTRYP PFNGLVERTEXATTRIB3DVPROC) (GLuint index, const GLdouble *v); +typedef void (APIENTRYP PFNGLVERTEXATTRIB3FPROC) (GLuint index, GLfloat x, GLfloat y, GLfloat z); +typedef void (APIENTRYP PFNGLVERTEXATTRIB3FVPROC) (GLuint index, const GLfloat *v); +typedef void (APIENTRYP PFNGLVERTEXATTRIB3SPROC) (GLuint index, GLshort x, GLshort y, GLshort z); +typedef void (APIENTRYP PFNGLVERTEXATTRIB3SVPROC) (GLuint index, const GLshort *v); +typedef void (APIENTRYP PFNGLVERTEXATTRIB4NBVPROC) (GLuint index, const GLbyte *v); +typedef void (APIENTRYP PFNGLVERTEXATTRIB4NIVPROC) (GLuint index, const GLint *v); +typedef void (APIENTRYP PFNGLVERTEXATTRIB4NSVPROC) (GLuint index, const GLshort *v); +typedef void (APIENTRYP PFNGLVERTEXATTRIB4NUBPROC) (GLuint index, GLubyte x, GLubyte y, GLubyte z, GLubyte w); +typedef void (APIENTRYP PFNGLVERTEXATTRIB4NUBVPROC) (GLuint index, const GLubyte *v); +typedef void (APIENTRYP PFNGLVERTEXATTRIB4NUIVPROC) (GLuint index, const GLuint *v); +typedef void (APIENTRYP PFNGLVERTEXATTRIB4NUSVPROC) (GLuint index, const GLushort *v); +typedef void (APIENTRYP PFNGLVERTEXATTRIB4BVPROC) (GLuint index, const GLbyte *v); +typedef void (APIENTRYP PFNGLVERTEXATTRIB4DPROC) (GLuint index, GLdouble x, GLdouble y, GLdouble z, GLdouble w); +typedef void (APIENTRYP PFNGLVERTEXATTRIB4DVPROC) (GLuint index, const GLdouble *v); +typedef void (APIENTRYP PFNGLVERTEXATTRIB4FPROC) (GLuint index, GLfloat x, GLfloat y, GLfloat z, GLfloat w); +typedef void (APIENTRYP PFNGLVERTEXATTRIB4FVPROC) (GLuint index, const GLfloat *v); +typedef void (APIENTRYP PFNGLVERTEXATTRIB4IVPROC) (GLuint index, const GLint *v); +typedef void (APIENTRYP PFNGLVERTEXATTRIB4SPROC) (GLuint index, GLshort x, GLshort y, GLshort z, GLshort w); +typedef void (APIENTRYP PFNGLVERTEXATTRIB4SVPROC) (GLuint index, const GLshort *v); +typedef void (APIENTRYP PFNGLVERTEXATTRIB4UBVPROC) (GLuint index, const GLubyte *v); +typedef void (APIENTRYP PFNGLVERTEXATTRIB4UIVPROC) (GLuint index, const GLuint *v); +typedef void (APIENTRYP PFNGLVERTEXATTRIB4USVPROC) (GLuint index, const GLushort *v); +typedef void (APIENTRYP PFNGLVERTEXATTRIBPOINTERPROC) (GLuint index, GLint size, GLenum type, GLboolean normalized, GLsizei stride, const GLvoid *pointer); +#endif + +#ifndef GL_ARB_multitexture +#define GL_ARB_multitexture 1 +#ifdef GL_GLEXT_PROTOTYPES +GLAPI void APIENTRY glActiveTextureARB (GLenum); +GLAPI void APIENTRY glClientActiveTextureARB (GLenum); +GLAPI void APIENTRY glMultiTexCoord1dARB (GLenum, GLdouble); +GLAPI void APIENTRY glMultiTexCoord1dvARB (GLenum, const GLdouble *); +GLAPI void APIENTRY glMultiTexCoord1fARB (GLenum, GLfloat); +GLAPI void APIENTRY glMultiTexCoord1fvARB (GLenum, const GLfloat *); +GLAPI void APIENTRY glMultiTexCoord1iARB (GLenum, GLint); +GLAPI void APIENTRY glMultiTexCoord1ivARB (GLenum, const GLint *); +GLAPI void APIENTRY glMultiTexCoord1sARB (GLenum, GLshort); +GLAPI void APIENTRY glMultiTexCoord1svARB (GLenum, const GLshort *); +GLAPI void APIENTRY glMultiTexCoord2dARB (GLenum, GLdouble, GLdouble); +GLAPI void APIENTRY glMultiTexCoord2dvARB (GLenum, const GLdouble *); +GLAPI void APIENTRY glMultiTexCoord2fARB (GLenum, GLfloat, GLfloat); +GLAPI void APIENTRY glMultiTexCoord2fvARB (GLenum, const GLfloat *); +GLAPI void APIENTRY glMultiTexCoord2iARB (GLenum, GLint, GLint); +GLAPI void APIENTRY glMultiTexCoord2ivARB (GLenum, const GLint *); +GLAPI void APIENTRY glMultiTexCoord2sARB (GLenum, GLshort, GLshort); +GLAPI void APIENTRY glMultiTexCoord2svARB (GLenum, const GLshort *); +GLAPI void APIENTRY glMultiTexCoord3dARB (GLenum, GLdouble, GLdouble, GLdouble); +GLAPI void APIENTRY glMultiTexCoord3dvARB (GLenum, const GLdouble *); +GLAPI void APIENTRY glMultiTexCoord3fARB (GLenum, GLfloat, GLfloat, GLfloat); +GLAPI void APIENTRY glMultiTexCoord3fvARB (GLenum, const GLfloat *); +GLAPI void APIENTRY glMultiTexCoord3iARB (GLenum, GLint, GLint, GLint); +GLAPI void APIENTRY glMultiTexCoord3ivARB (GLenum, const GLint *); +GLAPI void APIENTRY glMultiTexCoord3sARB (GLenum, GLshort, GLshort, GLshort); +GLAPI void APIENTRY glMultiTexCoord3svARB (GLenum, const GLshort *); +GLAPI void APIENTRY glMultiTexCoord4dARB (GLenum, GLdouble, GLdouble, GLdouble, GLdouble); +GLAPI void APIENTRY glMultiTexCoord4dvARB (GLenum, const GLdouble *); +GLAPI void APIENTRY glMultiTexCoord4fARB (GLenum, GLfloat, GLfloat, GLfloat, GLfloat); +GLAPI void APIENTRY glMultiTexCoord4fvARB (GLenum, const GLfloat *); +GLAPI void APIENTRY glMultiTexCoord4iARB (GLenum, GLint, GLint, GLint, GLint); +GLAPI void APIENTRY glMultiTexCoord4ivARB (GLenum, const GLint *); +GLAPI void APIENTRY glMultiTexCoord4sARB (GLenum, GLshort, GLshort, GLshort, GLshort); +GLAPI void APIENTRY glMultiTexCoord4svARB (GLenum, const GLshort *); +#endif /* GL_GLEXT_PROTOTYPES */ +typedef void (APIENTRYP PFNGLACTIVETEXTUREARBPROC) (GLenum texture); +typedef void (APIENTRYP PFNGLCLIENTACTIVETEXTUREARBPROC) (GLenum texture); +typedef void (APIENTRYP PFNGLMULTITEXCOORD1DARBPROC) (GLenum target, GLdouble s); +typedef void (APIENTRYP PFNGLMULTITEXCOORD1DVARBPROC) (GLenum target, const GLdouble *v); +typedef void (APIENTRYP PFNGLMULTITEXCOORD1FARBPROC) (GLenum target, GLfloat s); +typedef void (APIENTRYP PFNGLMULTITEXCOORD1FVARBPROC) (GLenum target, const GLfloat *v); +typedef void (APIENTRYP PFNGLMULTITEXCOORD1IARBPROC) (GLenum target, GLint s); +typedef void (APIENTRYP PFNGLMULTITEXCOORD1IVARBPROC) (GLenum target, const GLint *v); +typedef void (APIENTRYP PFNGLMULTITEXCOORD1SARBPROC) (GLenum target, GLshort s); +typedef void (APIENTRYP PFNGLMULTITEXCOORD1SVARBPROC) (GLenum target, const GLshort *v); +typedef void (APIENTRYP PFNGLMULTITEXCOORD2DARBPROC) (GLenum target, GLdouble s, GLdouble t); +typedef void (APIENTRYP PFNGLMULTITEXCOORD2DVARBPROC) (GLenum target, const GLdouble *v); +typedef void (APIENTRYP PFNGLMULTITEXCOORD2FARBPROC) (GLenum target, GLfloat s, GLfloat t); +typedef void (APIENTRYP PFNGLMULTITEXCOORD2FVARBPROC) (GLenum target, const GLfloat *v); +typedef void (APIENTRYP PFNGLMULTITEXCOORD2IARBPROC) (GLenum target, GLint s, GLint t); +typedef void (APIENTRYP PFNGLMULTITEXCOORD2IVARBPROC) (GLenum target, const GLint *v); +typedef void (APIENTRYP PFNGLMULTITEXCOORD2SARBPROC) (GLenum target, GLshort s, GLshort t); +typedef void (APIENTRYP PFNGLMULTITEXCOORD2SVARBPROC) (GLenum target, const GLshort *v); +typedef void (APIENTRYP PFNGLMULTITEXCOORD3DARBPROC) (GLenum target, GLdouble s, GLdouble t, GLdouble r); +typedef void (APIENTRYP PFNGLMULTITEXCOORD3DVARBPROC) (GLenum target, const GLdouble *v); +typedef void (APIENTRYP PFNGLMULTITEXCOORD3FARBPROC) (GLenum target, GLfloat s, GLfloat t, GLfloat r); +typedef void (APIENTRYP PFNGLMULTITEXCOORD3FVARBPROC) (GLenum target, const GLfloat *v); +typedef void (APIENTRYP PFNGLMULTITEXCOORD3IARBPROC) (GLenum target, GLint s, GLint t, GLint r); +typedef void (APIENTRYP PFNGLMULTITEXCOORD3IVARBPROC) (GLenum target, const GLint *v); +typedef void (APIENTRYP PFNGLMULTITEXCOORD3SARBPROC) (GLenum target, GLshort s, GLshort t, GLshort r); +typedef void (APIENTRYP PFNGLMULTITEXCOORD3SVARBPROC) (GLenum target, const GLshort *v); +typedef void (APIENTRYP PFNGLMULTITEXCOORD4DARBPROC) (GLenum target, GLdouble s, GLdouble t, GLdouble r, GLdouble q); +typedef void (APIENTRYP PFNGLMULTITEXCOORD4DVARBPROC) (GLenum target, const GLdouble *v); +typedef void (APIENTRYP PFNGLMULTITEXCOORD4FARBPROC) (GLenum target, GLfloat s, GLfloat t, GLfloat r, GLfloat q); +typedef void (APIENTRYP PFNGLMULTITEXCOORD4FVARBPROC) (GLenum target, const GLfloat *v); +typedef void (APIENTRYP PFNGLMULTITEXCOORD4IARBPROC) (GLenum target, GLint s, GLint t, GLint r, GLint q); +typedef void (APIENTRYP PFNGLMULTITEXCOORD4IVARBPROC) (GLenum target, const GLint *v); +typedef void (APIENTRYP PFNGLMULTITEXCOORD4SARBPROC) (GLenum target, GLshort s, GLshort t, GLshort r, GLshort q); +typedef void (APIENTRYP PFNGLMULTITEXCOORD4SVARBPROC) (GLenum target, const GLshort *v); +#endif + +#ifndef GL_ARB_transpose_matrix +#define GL_ARB_transpose_matrix 1 +#ifdef GL_GLEXT_PROTOTYPES +GLAPI void APIENTRY glLoadTransposeMatrixfARB (const GLfloat *); +GLAPI void APIENTRY glLoadTransposeMatrixdARB (const GLdouble *); +GLAPI void APIENTRY glMultTransposeMatrixfARB (const GLfloat *); +GLAPI void APIENTRY glMultTransposeMatrixdARB (const GLdouble *); +#endif /* GL_GLEXT_PROTOTYPES */ +typedef void (APIENTRYP PFNGLLOADTRANSPOSEMATRIXFARBPROC) (const GLfloat *m); +typedef void (APIENTRYP PFNGLLOADTRANSPOSEMATRIXDARBPROC) (const GLdouble *m); +typedef void (APIENTRYP PFNGLMULTTRANSPOSEMATRIXFARBPROC) (const GLfloat *m); +typedef void (APIENTRYP PFNGLMULTTRANSPOSEMATRIXDARBPROC) (const GLdouble *m); +#endif + +#ifndef GL_ARB_multisample +#define GL_ARB_multisample 1 +#ifdef GL_GLEXT_PROTOTYPES +GLAPI void APIENTRY glSampleCoverageARB (GLclampf, GLboolean); +#endif /* GL_GLEXT_PROTOTYPES */ +typedef void (APIENTRYP PFNGLSAMPLECOVERAGEARBPROC) (GLclampf value, GLboolean invert); +#endif + +#ifndef GL_ARB_texture_env_add +#define GL_ARB_texture_env_add 1 +#endif + +#ifndef GL_ARB_texture_cube_map +#define GL_ARB_texture_cube_map 1 +#endif + +#ifndef GL_ARB_texture_compression +#define GL_ARB_texture_compression 1 +#ifdef GL_GLEXT_PROTOTYPES +GLAPI void APIENTRY glCompressedTexImage3DARB (GLenum, GLint, GLenum, GLsizei, GLsizei, GLsizei, GLint, GLsizei, const GLvoid *); +GLAPI void APIENTRY glCompressedTexImage2DARB (GLenum, GLint, GLenum, GLsizei, GLsizei, GLint, GLsizei, const GLvoid *); +GLAPI void APIENTRY glCompressedTexImage1DARB (GLenum, GLint, GLenum, GLsizei, GLint, GLsizei, const GLvoid *); +GLAPI void APIENTRY glCompressedTexSubImage3DARB (GLenum, GLint, GLint, GLint, GLint, GLsizei, GLsizei, GLsizei, GLenum, GLsizei, const GLvoid *); +GLAPI void APIENTRY glCompressedTexSubImage2DARB (GLenum, GLint, GLint, GLint, GLsizei, GLsizei, GLenum, GLsizei, const GLvoid *); +GLAPI void APIENTRY glCompressedTexSubImage1DARB (GLenum, GLint, GLint, GLsizei, GLenum, GLsizei, const GLvoid *); +GLAPI void APIENTRY glGetCompressedTexImageARB (GLenum, GLint, GLvoid *); +#endif /* GL_GLEXT_PROTOTYPES */ +typedef void (APIENTRYP PFNGLCOMPRESSEDTEXIMAGE3DARBPROC) (GLenum target, GLint level, GLenum internalformat, GLsizei width, GLsizei height, GLsizei depth, GLint border, GLsizei imageSize, const GLvoid *data); +typedef void (APIENTRYP PFNGLCOMPRESSEDTEXIMAGE2DARBPROC) (GLenum target, GLint level, GLenum internalformat, GLsizei width, GLsizei height, GLint border, GLsizei imageSize, const GLvoid *data); +typedef void (APIENTRYP PFNGLCOMPRESSEDTEXIMAGE1DARBPROC) (GLenum target, GLint level, GLenum internalformat, GLsizei width, GLint border, GLsizei imageSize, const GLvoid *data); +typedef void (APIENTRYP PFNGLCOMPRESSEDTEXSUBIMAGE3DARBPROC) (GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLsizei imageSize, const GLvoid *data); +typedef void (APIENTRYP PFNGLCOMPRESSEDTEXSUBIMAGE2DARBPROC) (GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLsizei imageSize, const GLvoid *data); +typedef void (APIENTRYP PFNGLCOMPRESSEDTEXSUBIMAGE1DARBPROC) (GLenum target, GLint level, GLint xoffset, GLsizei width, GLenum format, GLsizei imageSize, const GLvoid *data); +typedef void (APIENTRYP PFNGLGETCOMPRESSEDTEXIMAGEARBPROC) (GLenum target, GLint level, GLvoid *img); +#endif + +#ifndef GL_ARB_texture_border_clamp +#define GL_ARB_texture_border_clamp 1 +#endif + +#ifndef GL_ARB_point_parameters +#define GL_ARB_point_parameters 1 +#ifdef GL_GLEXT_PROTOTYPES +GLAPI void APIENTRY glPointParameterfARB (GLenum, GLfloat); +GLAPI void APIENTRY glPointParameterfvARB (GLenum, const GLfloat *); +#endif /* GL_GLEXT_PROTOTYPES */ +typedef void (APIENTRYP PFNGLPOINTPARAMETERFARBPROC) (GLenum pname, GLfloat param); +typedef void (APIENTRYP PFNGLPOINTPARAMETERFVARBPROC) (GLenum pname, const GLfloat *params); +#endif + +#ifndef GL_ARB_vertex_blend +#define GL_ARB_vertex_blend 1 +#ifdef GL_GLEXT_PROTOTYPES +GLAPI void APIENTRY glWeightbvARB (GLint, const GLbyte *); +GLAPI void APIENTRY glWeightsvARB (GLint, const GLshort *); +GLAPI void APIENTRY glWeightivARB (GLint, const GLint *); +GLAPI void APIENTRY glWeightfvARB (GLint, const GLfloat *); +GLAPI void APIENTRY glWeightdvARB (GLint, const GLdouble *); +GLAPI void APIENTRY glWeightubvARB (GLint, const GLubyte *); +GLAPI void APIENTRY glWeightusvARB (GLint, const GLushort *); +GLAPI void APIENTRY glWeightuivARB (GLint, const GLuint *); +GLAPI void APIENTRY glWeightPointerARB (GLint, GLenum, GLsizei, const GLvoid *); +GLAPI void APIENTRY glVertexBlendARB (GLint); +#endif /* GL_GLEXT_PROTOTYPES */ +typedef void (APIENTRYP PFNGLWEIGHTBVARBPROC) (GLint size, const GLbyte *weights); +typedef void (APIENTRYP PFNGLWEIGHTSVARBPROC) (GLint size, const GLshort *weights); +typedef void (APIENTRYP PFNGLWEIGHTIVARBPROC) (GLint size, const GLint *weights); +typedef void (APIENTRYP PFNGLWEIGHTFVARBPROC) (GLint size, const GLfloat *weights); +typedef void (APIENTRYP PFNGLWEIGHTDVARBPROC) (GLint size, const GLdouble *weights); +typedef void (APIENTRYP PFNGLWEIGHTUBVARBPROC) (GLint size, const GLubyte *weights); +typedef void (APIENTRYP PFNGLWEIGHTUSVARBPROC) (GLint size, const GLushort *weights); +typedef void (APIENTRYP PFNGLWEIGHTUIVARBPROC) (GLint size, const GLuint *weights); +typedef void (APIENTRYP PFNGLWEIGHTPOINTERARBPROC) (GLint size, GLenum type, GLsizei stride, const GLvoid *pointer); +typedef void (APIENTRYP PFNGLVERTEXBLENDARBPROC) (GLint count); +#endif + +#ifndef GL_ARB_matrix_palette +#define GL_ARB_matrix_palette 1 +#ifdef GL_GLEXT_PROTOTYPES +GLAPI void APIENTRY glCurrentPaletteMatrixARB (GLint); +GLAPI void APIENTRY glMatrixIndexubvARB (GLint, const GLubyte *); +GLAPI void APIENTRY glMatrixIndexusvARB (GLint, const GLushort *); +GLAPI void APIENTRY glMatrixIndexuivARB (GLint, const GLuint *); +GLAPI void APIENTRY glMatrixIndexPointerARB (GLint, GLenum, GLsizei, const GLvoid *); +#endif /* GL_GLEXT_PROTOTYPES */ +typedef void (APIENTRYP PFNGLCURRENTPALETTEMATRIXARBPROC) (GLint index); +typedef void (APIENTRYP PFNGLMATRIXINDEXUBVARBPROC) (GLint size, const GLubyte *indices); +typedef void (APIENTRYP PFNGLMATRIXINDEXUSVARBPROC) (GLint size, const GLushort *indices); +typedef void (APIENTRYP PFNGLMATRIXINDEXUIVARBPROC) (GLint size, const GLuint *indices); +typedef void (APIENTRYP PFNGLMATRIXINDEXPOINTERARBPROC) (GLint size, GLenum type, GLsizei stride, const GLvoid *pointer); +#endif + +#ifndef GL_ARB_texture_env_combine +#define GL_ARB_texture_env_combine 1 +#endif + +#ifndef GL_ARB_texture_env_crossbar +#define GL_ARB_texture_env_crossbar 1 +#endif + +#ifndef GL_ARB_texture_env_dot3 +#define GL_ARB_texture_env_dot3 1 +#endif + +#ifndef GL_ARB_texture_mirrored_repeat +#define GL_ARB_texture_mirrored_repeat 1 +#endif + +#ifndef GL_ARB_depth_texture +#define GL_ARB_depth_texture 1 +#endif + +#ifndef GL_ARB_shadow +#define GL_ARB_shadow 1 +#endif + +#ifndef GL_ARB_shadow_ambient +#define GL_ARB_shadow_ambient 1 +#endif + +#ifndef GL_ARB_window_pos +#define GL_ARB_window_pos 1 +#ifdef GL_GLEXT_PROTOTYPES +GLAPI void APIENTRY glWindowPos2dARB (GLdouble, GLdouble); +GLAPI void APIENTRY glWindowPos2dvARB (const GLdouble *); +GLAPI void APIENTRY glWindowPos2fARB (GLfloat, GLfloat); +GLAPI void APIENTRY glWindowPos2fvARB (const GLfloat *); +GLAPI void APIENTRY glWindowPos2iARB (GLint, GLint); +GLAPI void APIENTRY glWindowPos2ivARB (const GLint *); +GLAPI void APIENTRY glWindowPos2sARB (GLshort, GLshort); +GLAPI void APIENTRY glWindowPos2svARB (const GLshort *); +GLAPI void APIENTRY glWindowPos3dARB (GLdouble, GLdouble, GLdouble); +GLAPI void APIENTRY glWindowPos3dvARB (const GLdouble *); +GLAPI void APIENTRY glWindowPos3fARB (GLfloat, GLfloat, GLfloat); +GLAPI void APIENTRY glWindowPos3fvARB (const GLfloat *); +GLAPI void APIENTRY glWindowPos3iARB (GLint, GLint, GLint); +GLAPI void APIENTRY glWindowPos3ivARB (const GLint *); +GLAPI void APIENTRY glWindowPos3sARB (GLshort, GLshort, GLshort); +GLAPI void APIENTRY glWindowPos3svARB (const GLshort *); +#endif /* GL_GLEXT_PROTOTYPES */ +typedef void (APIENTRYP PFNGLWINDOWPOS2DARBPROC) (GLdouble x, GLdouble y); +typedef void (APIENTRYP PFNGLWINDOWPOS2DVARBPROC) (const GLdouble *v); +typedef void (APIENTRYP PFNGLWINDOWPOS2FARBPROC) (GLfloat x, GLfloat y); +typedef void (APIENTRYP PFNGLWINDOWPOS2FVARBPROC) (const GLfloat *v); +typedef void (APIENTRYP PFNGLWINDOWPOS2IARBPROC) (GLint x, GLint y); +typedef void (APIENTRYP PFNGLWINDOWPOS2IVARBPROC) (const GLint *v); +typedef void (APIENTRYP PFNGLWINDOWPOS2SARBPROC) (GLshort x, GLshort y); +typedef void (APIENTRYP PFNGLWINDOWPOS2SVARBPROC) (const GLshort *v); +typedef void (APIENTRYP PFNGLWINDOWPOS3DARBPROC) (GLdouble x, GLdouble y, GLdouble z); +typedef void (APIENTRYP PFNGLWINDOWPOS3DVARBPROC) (const GLdouble *v); +typedef void (APIENTRYP PFNGLWINDOWPOS3FARBPROC) (GLfloat x, GLfloat y, GLfloat z); +typedef void (APIENTRYP PFNGLWINDOWPOS3FVARBPROC) (const GLfloat *v); +typedef void (APIENTRYP PFNGLWINDOWPOS3IARBPROC) (GLint x, GLint y, GLint z); +typedef void (APIENTRYP PFNGLWINDOWPOS3IVARBPROC) (const GLint *v); +typedef void (APIENTRYP PFNGLWINDOWPOS3SARBPROC) (GLshort x, GLshort y, GLshort z); +typedef void (APIENTRYP PFNGLWINDOWPOS3SVARBPROC) (const GLshort *v); +#endif + +#ifndef GL_ARB_vertex_program +#define GL_ARB_vertex_program 1 +#ifdef GL_GLEXT_PROTOTYPES +GLAPI void APIENTRY glVertexAttrib1dARB (GLuint, GLdouble); +GLAPI void APIENTRY glVertexAttrib1dvARB (GLuint, const GLdouble *); +GLAPI void APIENTRY glVertexAttrib1fARB (GLuint, GLfloat); +GLAPI void APIENTRY glVertexAttrib1fvARB (GLuint, const GLfloat *); +GLAPI void APIENTRY glVertexAttrib1sARB (GLuint, GLshort); +GLAPI void APIENTRY glVertexAttrib1svARB (GLuint, const GLshort *); +GLAPI void APIENTRY glVertexAttrib2dARB (GLuint, GLdouble, GLdouble); +GLAPI void APIENTRY glVertexAttrib2dvARB (GLuint, const GLdouble *); +GLAPI void APIENTRY glVertexAttrib2fARB (GLuint, GLfloat, GLfloat); +GLAPI void APIENTRY glVertexAttrib2fvARB (GLuint, const GLfloat *); +GLAPI void APIENTRY glVertexAttrib2sARB (GLuint, GLshort, GLshort); +GLAPI void APIENTRY glVertexAttrib2svARB (GLuint, const GLshort *); +GLAPI void APIENTRY glVertexAttrib3dARB (GLuint, GLdouble, GLdouble, GLdouble); +GLAPI void APIENTRY glVertexAttrib3dvARB (GLuint, const GLdouble *); +GLAPI void APIENTRY glVertexAttrib3fARB (GLuint, GLfloat, GLfloat, GLfloat); +GLAPI void APIENTRY glVertexAttrib3fvARB (GLuint, const GLfloat *); +GLAPI void APIENTRY glVertexAttrib3sARB (GLuint, GLshort, GLshort, GLshort); +GLAPI void APIENTRY glVertexAttrib3svARB (GLuint, const GLshort *); +GLAPI void APIENTRY glVertexAttrib4NbvARB (GLuint, const GLbyte *); +GLAPI void APIENTRY glVertexAttrib4NivARB (GLuint, const GLint *); +GLAPI void APIENTRY glVertexAttrib4NsvARB (GLuint, const GLshort *); +GLAPI void APIENTRY glVertexAttrib4NubARB (GLuint, GLubyte, GLubyte, GLubyte, GLubyte); +GLAPI void APIENTRY glVertexAttrib4NubvARB (GLuint, const GLubyte *); +GLAPI void APIENTRY glVertexAttrib4NuivARB (GLuint, const GLuint *); +GLAPI void APIENTRY glVertexAttrib4NusvARB (GLuint, const GLushort *); +GLAPI void APIENTRY glVertexAttrib4bvARB (GLuint, const GLbyte *); +GLAPI void APIENTRY glVertexAttrib4dARB (GLuint, GLdouble, GLdouble, GLdouble, GLdouble); +GLAPI void APIENTRY glVertexAttrib4dvARB (GLuint, const GLdouble *); +GLAPI void APIENTRY glVertexAttrib4fARB (GLuint, GLfloat, GLfloat, GLfloat, GLfloat); +GLAPI void APIENTRY glVertexAttrib4fvARB (GLuint, const GLfloat *); +GLAPI void APIENTRY glVertexAttrib4ivARB (GLuint, const GLint *); +GLAPI void APIENTRY glVertexAttrib4sARB (GLuint, GLshort, GLshort, GLshort, GLshort); +GLAPI void APIENTRY glVertexAttrib4svARB (GLuint, const GLshort *); +GLAPI void APIENTRY glVertexAttrib4ubvARB (GLuint, const GLubyte *); +GLAPI void APIENTRY glVertexAttrib4uivARB (GLuint, const GLuint *); +GLAPI void APIENTRY glVertexAttrib4usvARB (GLuint, const GLushort *); +GLAPI void APIENTRY glVertexAttribPointerARB (GLuint, GLint, GLenum, GLboolean, GLsizei, const GLvoid *); +GLAPI void APIENTRY glEnableVertexAttribArrayARB (GLuint); +GLAPI void APIENTRY glDisableVertexAttribArrayARB (GLuint); +GLAPI void APIENTRY glProgramStringARB (GLenum, GLenum, GLsizei, const GLvoid *); +GLAPI void APIENTRY glBindProgramARB (GLenum, GLuint); +GLAPI void APIENTRY glDeleteProgramsARB (GLsizei, const GLuint *); +GLAPI void APIENTRY glGenProgramsARB (GLsizei, GLuint *); +GLAPI void APIENTRY glProgramEnvParameter4dARB (GLenum, GLuint, GLdouble, GLdouble, GLdouble, GLdouble); +GLAPI void APIENTRY glProgramEnvParameter4dvARB (GLenum, GLuint, const GLdouble *); +GLAPI void APIENTRY glProgramEnvParameter4fARB (GLenum, GLuint, GLfloat, GLfloat, GLfloat, GLfloat); +GLAPI void APIENTRY glProgramEnvParameter4fvARB (GLenum, GLuint, const GLfloat *); +GLAPI void APIENTRY glProgramLocalParameter4dARB (GLenum, GLuint, GLdouble, GLdouble, GLdouble, GLdouble); +GLAPI void APIENTRY glProgramLocalParameter4dvARB (GLenum, GLuint, const GLdouble *); +GLAPI void APIENTRY glProgramLocalParameter4fARB (GLenum, GLuint, GLfloat, GLfloat, GLfloat, GLfloat); +GLAPI void APIENTRY glProgramLocalParameter4fvARB (GLenum, GLuint, const GLfloat *); +GLAPI void APIENTRY glGetProgramEnvParameterdvARB (GLenum, GLuint, GLdouble *); +GLAPI void APIENTRY glGetProgramEnvParameterfvARB (GLenum, GLuint, GLfloat *); +GLAPI void APIENTRY glGetProgramLocalParameterdvARB (GLenum, GLuint, GLdouble *); +GLAPI void APIENTRY glGetProgramLocalParameterfvARB (GLenum, GLuint, GLfloat *); +GLAPI void APIENTRY glGetProgramivARB (GLenum, GLenum, GLint *); +GLAPI void APIENTRY glGetProgramStringARB (GLenum, GLenum, GLvoid *); +GLAPI void APIENTRY glGetVertexAttribdvARB (GLuint, GLenum, GLdouble *); +GLAPI void APIENTRY glGetVertexAttribfvARB (GLuint, GLenum, GLfloat *); +GLAPI void APIENTRY glGetVertexAttribivARB (GLuint, GLenum, GLint *); +GLAPI void APIENTRY glGetVertexAttribPointervARB (GLuint, GLenum, GLvoid* *); +GLAPI GLboolean APIENTRY glIsProgramARB (GLuint); +#endif /* GL_GLEXT_PROTOTYPES */ +typedef void (APIENTRYP PFNGLVERTEXATTRIB1DARBPROC) (GLuint index, GLdouble x); +typedef void (APIENTRYP PFNGLVERTEXATTRIB1DVARBPROC) (GLuint index, const GLdouble *v); +typedef void (APIENTRYP PFNGLVERTEXATTRIB1FARBPROC) (GLuint index, GLfloat x); +typedef void (APIENTRYP PFNGLVERTEXATTRIB1FVARBPROC) (GLuint index, const GLfloat *v); +typedef void (APIENTRYP PFNGLVERTEXATTRIB1SARBPROC) (GLuint index, GLshort x); +typedef void (APIENTRYP PFNGLVERTEXATTRIB1SVARBPROC) (GLuint index, const GLshort *v); +typedef void (APIENTRYP PFNGLVERTEXATTRIB2DARBPROC) (GLuint index, GLdouble x, GLdouble y); +typedef void (APIENTRYP PFNGLVERTEXATTRIB2DVARBPROC) (GLuint index, const GLdouble *v); +typedef void (APIENTRYP PFNGLVERTEXATTRIB2FARBPROC) (GLuint index, GLfloat x, GLfloat y); +typedef void (APIENTRYP PFNGLVERTEXATTRIB2FVARBPROC) (GLuint index, const GLfloat *v); +typedef void (APIENTRYP PFNGLVERTEXATTRIB2SARBPROC) (GLuint index, GLshort x, GLshort y); +typedef void (APIENTRYP PFNGLVERTEXATTRIB2SVARBPROC) (GLuint index, const GLshort *v); +typedef void (APIENTRYP PFNGLVERTEXATTRIB3DARBPROC) (GLuint index, GLdouble x, GLdouble y, GLdouble z); +typedef void (APIENTRYP PFNGLVERTEXATTRIB3DVARBPROC) (GLuint index, const GLdouble *v); +typedef void (APIENTRYP PFNGLVERTEXATTRIB3FARBPROC) (GLuint index, GLfloat x, GLfloat y, GLfloat z); +typedef void (APIENTRYP PFNGLVERTEXATTRIB3FVARBPROC) (GLuint index, const GLfloat *v); +typedef void (APIENTRYP PFNGLVERTEXATTRIB3SARBPROC) (GLuint index, GLshort x, GLshort y, GLshort z); +typedef void (APIENTRYP PFNGLVERTEXATTRIB3SVARBPROC) (GLuint index, const GLshort *v); +typedef void (APIENTRYP PFNGLVERTEXATTRIB4NBVARBPROC) (GLuint index, const GLbyte *v); +typedef void (APIENTRYP PFNGLVERTEXATTRIB4NIVARBPROC) (GLuint index, const GLint *v); +typedef void (APIENTRYP PFNGLVERTEXATTRIB4NSVARBPROC) (GLuint index, const GLshort *v); +typedef void (APIENTRYP PFNGLVERTEXATTRIB4NUBARBPROC) (GLuint index, GLubyte x, GLubyte y, GLubyte z, GLubyte w); +typedef void (APIENTRYP PFNGLVERTEXATTRIB4NUBVARBPROC) (GLuint index, const GLubyte *v); +typedef void (APIENTRYP PFNGLVERTEXATTRIB4NUIVARBPROC) (GLuint index, const GLuint *v); +typedef void (APIENTRYP PFNGLVERTEXATTRIB4NUSVARBPROC) (GLuint index, const GLushort *v); +typedef void (APIENTRYP PFNGLVERTEXATTRIB4BVARBPROC) (GLuint index, const GLbyte *v); +typedef void (APIENTRYP PFNGLVERTEXATTRIB4DARBPROC) (GLuint index, GLdouble x, GLdouble y, GLdouble z, GLdouble w); +typedef void (APIENTRYP PFNGLVERTEXATTRIB4DVARBPROC) (GLuint index, const GLdouble *v); +typedef void (APIENTRYP PFNGLVERTEXATTRIB4FARBPROC) (GLuint index, GLfloat x, GLfloat y, GLfloat z, GLfloat w); +typedef void (APIENTRYP PFNGLVERTEXATTRIB4FVARBPROC) (GLuint index, const GLfloat *v); +typedef void (APIENTRYP PFNGLVERTEXATTRIB4IVARBPROC) (GLuint index, const GLint *v); +typedef void (APIENTRYP PFNGLVERTEXATTRIB4SARBPROC) (GLuint index, GLshort x, GLshort y, GLshort z, GLshort w); +typedef void (APIENTRYP PFNGLVERTEXATTRIB4SVARBPROC) (GLuint index, const GLshort *v); +typedef void (APIENTRYP PFNGLVERTEXATTRIB4UBVARBPROC) (GLuint index, const GLubyte *v); +typedef void (APIENTRYP PFNGLVERTEXATTRIB4UIVARBPROC) (GLuint index, const GLuint *v); +typedef void (APIENTRYP PFNGLVERTEXATTRIB4USVARBPROC) (GLuint index, const GLushort *v); +typedef void (APIENTRYP PFNGLVERTEXATTRIBPOINTERARBPROC) (GLuint index, GLint size, GLenum type, GLboolean normalized, GLsizei stride, const GLvoid *pointer); +typedef void (APIENTRYP PFNGLENABLEVERTEXATTRIBARRAYARBPROC) (GLuint index); +typedef void (APIENTRYP PFNGLDISABLEVERTEXATTRIBARRAYARBPROC) (GLuint index); +typedef void (APIENTRYP PFNGLPROGRAMSTRINGARBPROC) (GLenum target, GLenum format, GLsizei len, const GLvoid *string); +typedef void (APIENTRYP PFNGLBINDPROGRAMARBPROC) (GLenum target, GLuint program); +typedef void (APIENTRYP PFNGLDELETEPROGRAMSARBPROC) (GLsizei n, const GLuint *programs); +typedef void (APIENTRYP PFNGLGENPROGRAMSARBPROC) (GLsizei n, GLuint *programs); +typedef void (APIENTRYP PFNGLPROGRAMENVPARAMETER4DARBPROC) (GLenum target, GLuint index, GLdouble x, GLdouble y, GLdouble z, GLdouble w); +typedef void (APIENTRYP PFNGLPROGRAMENVPARAMETER4DVARBPROC) (GLenum target, GLuint index, const GLdouble *params); +typedef void (APIENTRYP PFNGLPROGRAMENVPARAMETER4FARBPROC) (GLenum target, GLuint index, GLfloat x, GLfloat y, GLfloat z, GLfloat w); +typedef void (APIENTRYP PFNGLPROGRAMENVPARAMETER4FVARBPROC) (GLenum target, GLuint index, const GLfloat *params); +typedef void (APIENTRYP PFNGLPROGRAMLOCALPARAMETER4DARBPROC) (GLenum target, GLuint index, GLdouble x, GLdouble y, GLdouble z, GLdouble w); +typedef void (APIENTRYP PFNGLPROGRAMLOCALPARAMETER4DVARBPROC) (GLenum target, GLuint index, const GLdouble *params); +typedef void (APIENTRYP PFNGLPROGRAMLOCALPARAMETER4FARBPROC) (GLenum target, GLuint index, GLfloat x, GLfloat y, GLfloat z, GLfloat w); +typedef void (APIENTRYP PFNGLPROGRAMLOCALPARAMETER4FVARBPROC) (GLenum target, GLuint index, const GLfloat *params); +typedef void (APIENTRYP PFNGLGETPROGRAMENVPARAMETERDVARBPROC) (GLenum target, GLuint index, GLdouble *params); +typedef void (APIENTRYP PFNGLGETPROGRAMENVPARAMETERFVARBPROC) (GLenum target, GLuint index, GLfloat *params); +typedef void (APIENTRYP PFNGLGETPROGRAMLOCALPARAMETERDVARBPROC) (GLenum target, GLuint index, GLdouble *params); +typedef void (APIENTRYP PFNGLGETPROGRAMLOCALPARAMETERFVARBPROC) (GLenum target, GLuint index, GLfloat *params); +typedef void (APIENTRYP PFNGLGETPROGRAMIVARBPROC) (GLenum target, GLenum pname, GLint *params); +typedef void (APIENTRYP PFNGLGETPROGRAMSTRINGARBPROC) (GLenum target, GLenum pname, GLvoid *string); +typedef void (APIENTRYP PFNGLGETVERTEXATTRIBDVARBPROC) (GLuint index, GLenum pname, GLdouble *params); +typedef void (APIENTRYP PFNGLGETVERTEXATTRIBFVARBPROC) (GLuint index, GLenum pname, GLfloat *params); +typedef void (APIENTRYP PFNGLGETVERTEXATTRIBIVARBPROC) (GLuint index, GLenum pname, GLint *params); +typedef void (APIENTRYP PFNGLGETVERTEXATTRIBPOINTERVARBPROC) (GLuint index, GLenum pname, GLvoid* *pointer); +typedef GLboolean (APIENTRYP PFNGLISPROGRAMARBPROC) (GLuint program); +#endif + +#ifndef GL_ARB_fragment_program +#define GL_ARB_fragment_program 1 +/* All ARB_fragment_program entry points are shared with ARB_vertex_program. */ +#endif + +#ifndef GL_ARB_vertex_buffer_object +#define GL_ARB_vertex_buffer_object 1 +#ifdef GL_GLEXT_PROTOTYPES +GLAPI void APIENTRY glBindBufferARB (GLenum, GLuint); +GLAPI void APIENTRY glDeleteBuffersARB (GLsizei, const GLuint *); +GLAPI void APIENTRY glGenBuffersARB (GLsizei, GLuint *); +GLAPI GLboolean APIENTRY glIsBufferARB (GLuint); +GLAPI void APIENTRY glBufferDataARB (GLenum, GLsizeiptrARB, const GLvoid *, GLenum); +GLAPI void APIENTRY glBufferSubDataARB (GLenum, GLintptrARB, GLsizeiptrARB, const GLvoid *); +GLAPI void APIENTRY glGetBufferSubDataARB (GLenum, GLintptrARB, GLsizeiptrARB, GLvoid *); +GLAPI GLvoid* APIENTRY glMapBufferARB (GLenum, GLenum); +GLAPI GLboolean APIENTRY glUnmapBufferARB (GLenum); +GLAPI void APIENTRY glGetBufferParameterivARB (GLenum, GLenum, GLint *); +GLAPI void APIENTRY glGetBufferPointervARB (GLenum, GLenum, GLvoid* *); +#endif /* GL_GLEXT_PROTOTYPES */ +typedef void (APIENTRYP PFNGLBINDBUFFERARBPROC) (GLenum target, GLuint buffer); +typedef void (APIENTRYP PFNGLDELETEBUFFERSARBPROC) (GLsizei n, const GLuint *buffers); +typedef void (APIENTRYP PFNGLGENBUFFERSARBPROC) (GLsizei n, GLuint *buffers); +typedef GLboolean (APIENTRYP PFNGLISBUFFERARBPROC) (GLuint buffer); +typedef void (APIENTRYP PFNGLBUFFERDATAARBPROC) (GLenum target, GLsizeiptrARB size, const GLvoid *data, GLenum usage); +typedef void (APIENTRYP PFNGLBUFFERSUBDATAARBPROC) (GLenum target, GLintptrARB offset, GLsizeiptrARB size, const GLvoid *data); +typedef void (APIENTRYP PFNGLGETBUFFERSUBDATAARBPROC) (GLenum target, GLintptrARB offset, GLsizeiptrARB size, GLvoid *data); +typedef GLvoid* (APIENTRYP PFNGLMAPBUFFERARBPROC) (GLenum target, GLenum access); +typedef GLboolean (APIENTRYP PFNGLUNMAPBUFFERARBPROC) (GLenum target); +typedef void (APIENTRYP PFNGLGETBUFFERPARAMETERIVARBPROC) (GLenum target, GLenum pname, GLint *params); +typedef void (APIENTRYP PFNGLGETBUFFERPOINTERVARBPROC) (GLenum target, GLenum pname, GLvoid* *params); +#endif + +#ifndef GL_ARB_occlusion_query +#define GL_ARB_occlusion_query 1 +#ifdef GL_GLEXT_PROTOTYPES +GLAPI void APIENTRY glGenQueriesARB (GLsizei, GLuint *); +GLAPI void APIENTRY glDeleteQueriesARB (GLsizei, const GLuint *); +GLAPI GLboolean APIENTRY glIsQueryARB (GLuint); +GLAPI void APIENTRY glBeginQueryARB (GLenum, GLuint); +GLAPI void APIENTRY glEndQueryARB (GLenum); +GLAPI void APIENTRY glGetQueryivARB (GLenum, GLenum, GLint *); +GLAPI void APIENTRY glGetQueryObjectivARB (GLuint, GLenum, GLint *); +GLAPI void APIENTRY glGetQueryObjectuivARB (GLuint, GLenum, GLuint *); +#endif /* GL_GLEXT_PROTOTYPES */ +typedef void (APIENTRYP PFNGLGENQUERIESARBPROC) (GLsizei n, GLuint *ids); +typedef void (APIENTRYP PFNGLDELETEQUERIESARBPROC) (GLsizei n, const GLuint *ids); +typedef GLboolean (APIENTRYP PFNGLISQUERYARBPROC) (GLuint id); +typedef void (APIENTRYP PFNGLBEGINQUERYARBPROC) (GLenum target, GLuint id); +typedef void (APIENTRYP PFNGLENDQUERYARBPROC) (GLenum target); +typedef void (APIENTRYP PFNGLGETQUERYIVARBPROC) (GLenum target, GLenum pname, GLint *params); +typedef void (APIENTRYP PFNGLGETQUERYOBJECTIVARBPROC) (GLuint id, GLenum pname, GLint *params); +typedef void (APIENTRYP PFNGLGETQUERYOBJECTUIVARBPROC) (GLuint id, GLenum pname, GLuint *params); +#endif + +#ifndef GL_ARB_shader_objects +#define GL_ARB_shader_objects 1 +#ifdef GL_GLEXT_PROTOTYPES +GLAPI void APIENTRY glDeleteObjectARB (GLhandleARB); +GLAPI GLhandleARB APIENTRY glGetHandleARB (GLenum); +GLAPI void APIENTRY glDetachObjectARB (GLhandleARB, GLhandleARB); +GLAPI GLhandleARB APIENTRY glCreateShaderObjectARB (GLenum); +GLAPI void APIENTRY glShaderSourceARB (GLhandleARB, GLsizei, const GLcharARB* *, const GLint *); +GLAPI void APIENTRY glCompileShaderARB (GLhandleARB); +GLAPI GLhandleARB APIENTRY glCreateProgramObjectARB (void); +GLAPI void APIENTRY glAttachObjectARB (GLhandleARB, GLhandleARB); +GLAPI void APIENTRY glLinkProgramARB (GLhandleARB); +GLAPI void APIENTRY glUseProgramObjectARB (GLhandleARB); +GLAPI void APIENTRY glValidateProgramARB (GLhandleARB); +GLAPI void APIENTRY glUniform1fARB (GLint, GLfloat); +GLAPI void APIENTRY glUniform2fARB (GLint, GLfloat, GLfloat); +GLAPI void APIENTRY glUniform3fARB (GLint, GLfloat, GLfloat, GLfloat); +GLAPI void APIENTRY glUniform4fARB (GLint, GLfloat, GLfloat, GLfloat, GLfloat); +GLAPI void APIENTRY glUniform1iARB (GLint, GLint); +GLAPI void APIENTRY glUniform2iARB (GLint, GLint, GLint); +GLAPI void APIENTRY glUniform3iARB (GLint, GLint, GLint, GLint); +GLAPI void APIENTRY glUniform4iARB (GLint, GLint, GLint, GLint, GLint); +GLAPI void APIENTRY glUniform1fvARB (GLint, GLsizei, const GLfloat *); +GLAPI void APIENTRY glUniform2fvARB (GLint, GLsizei, const GLfloat *); +GLAPI void APIENTRY glUniform3fvARB (GLint, GLsizei, const GLfloat *); +GLAPI void APIENTRY glUniform4fvARB (GLint, GLsizei, const GLfloat *); +GLAPI void APIENTRY glUniform1ivARB (GLint, GLsizei, const GLint *); +GLAPI void APIENTRY glUniform2ivARB (GLint, GLsizei, const GLint *); +GLAPI void APIENTRY glUniform3ivARB (GLint, GLsizei, const GLint *); +GLAPI void APIENTRY glUniform4ivARB (GLint, GLsizei, const GLint *); +GLAPI void APIENTRY glUniformMatrix2fvARB (GLint, GLsizei, GLboolean, const GLfloat *); +GLAPI void APIENTRY glUniformMatrix3fvARB (GLint, GLsizei, GLboolean, const GLfloat *); +GLAPI void APIENTRY glUniformMatrix4fvARB (GLint, GLsizei, GLboolean, const GLfloat *); +GLAPI void APIENTRY glGetObjectParameterfvARB (GLhandleARB, GLenum, GLfloat *); +GLAPI void APIENTRY glGetObjectParameterivARB (GLhandleARB, GLenum, GLint *); +GLAPI void APIENTRY glGetInfoLogARB (GLhandleARB, GLsizei, GLsizei *, GLcharARB *); +GLAPI void APIENTRY glGetAttachedObjectsARB (GLhandleARB, GLsizei, GLsizei *, GLhandleARB *); +GLAPI GLint APIENTRY glGetUniformLocationARB (GLhandleARB, const GLcharARB *); +GLAPI void APIENTRY glGetActiveUniformARB (GLhandleARB, GLuint, GLsizei, GLsizei *, GLint *, GLenum *, GLcharARB *); +GLAPI void APIENTRY glGetUniformfvARB (GLhandleARB, GLint, GLfloat *); +GLAPI void APIENTRY glGetUniformivARB (GLhandleARB, GLint, GLint *); +GLAPI void APIENTRY glGetShaderSourceARB (GLhandleARB, GLsizei, GLsizei *, GLcharARB *); +#endif /* GL_GLEXT_PROTOTYPES */ +typedef void (APIENTRYP PFNGLDELETEOBJECTARBPROC) (GLhandleARB obj); +typedef GLhandleARB (APIENTRYP PFNGLGETHANDLEARBPROC) (GLenum pname); +typedef void (APIENTRYP PFNGLDETACHOBJECTARBPROC) (GLhandleARB containerObj, GLhandleARB attachedObj); +typedef GLhandleARB (APIENTRYP PFNGLCREATESHADEROBJECTARBPROC) (GLenum shaderType); +typedef void (APIENTRYP PFNGLSHADERSOURCEARBPROC) (GLhandleARB shaderObj, GLsizei count, const GLcharARB* *string, const GLint *length); +typedef void (APIENTRYP PFNGLCOMPILESHADERARBPROC) (GLhandleARB shaderObj); +typedef GLhandleARB (APIENTRYP PFNGLCREATEPROGRAMOBJECTARBPROC) (void); +typedef void (APIENTRYP PFNGLATTACHOBJECTARBPROC) (GLhandleARB containerObj, GLhandleARB obj); +typedef void (APIENTRYP PFNGLLINKPROGRAMARBPROC) (GLhandleARB programObj); +typedef void (APIENTRYP PFNGLUSEPROGRAMOBJECTARBPROC) (GLhandleARB programObj); +typedef void (APIENTRYP PFNGLVALIDATEPROGRAMARBPROC) (GLhandleARB programObj); +typedef void (APIENTRYP PFNGLUNIFORM1FARBPROC) (GLint location, GLfloat v0); +typedef void (APIENTRYP PFNGLUNIFORM2FARBPROC) (GLint location, GLfloat v0, GLfloat v1); +typedef void (APIENTRYP PFNGLUNIFORM3FARBPROC) (GLint location, GLfloat v0, GLfloat v1, GLfloat v2); +typedef void (APIENTRYP PFNGLUNIFORM4FARBPROC) (GLint location, GLfloat v0, GLfloat v1, GLfloat v2, GLfloat v3); +typedef void (APIENTRYP PFNGLUNIFORM1IARBPROC) (GLint location, GLint v0); +typedef void (APIENTRYP PFNGLUNIFORM2IARBPROC) (GLint location, GLint v0, GLint v1); +typedef void (APIENTRYP PFNGLUNIFORM3IARBPROC) (GLint location, GLint v0, GLint v1, GLint v2); +typedef void (APIENTRYP PFNGLUNIFORM4IARBPROC) (GLint location, GLint v0, GLint v1, GLint v2, GLint v3); +typedef void (APIENTRYP PFNGLUNIFORM1FVARBPROC) (GLint location, GLsizei count, const GLfloat *value); +typedef void (APIENTRYP PFNGLUNIFORM2FVARBPROC) (GLint location, GLsizei count, const GLfloat *value); +typedef void (APIENTRYP PFNGLUNIFORM3FVARBPROC) (GLint location, GLsizei count, const GLfloat *value); +typedef void (APIENTRYP PFNGLUNIFORM4FVARBPROC) (GLint location, GLsizei count, const GLfloat *value); +typedef void (APIENTRYP PFNGLUNIFORM1IVARBPROC) (GLint location, GLsizei count, const GLint *value); +typedef void (APIENTRYP PFNGLUNIFORM2IVARBPROC) (GLint location, GLsizei count, const GLint *value); +typedef void (APIENTRYP PFNGLUNIFORM3IVARBPROC) (GLint location, GLsizei count, const GLint *value); +typedef void (APIENTRYP PFNGLUNIFORM4IVARBPROC) (GLint location, GLsizei count, const GLint *value); +typedef void (APIENTRYP PFNGLUNIFORMMATRIX2FVARBPROC) (GLint location, GLsizei count, GLboolean transpose, const GLfloat *value); +typedef void (APIENTRYP PFNGLUNIFORMMATRIX3FVARBPROC) (GLint location, GLsizei count, GLboolean transpose, const GLfloat *value); +typedef void (APIENTRYP PFNGLUNIFORMMATRIX4FVARBPROC) (GLint location, GLsizei count, GLboolean transpose, const GLfloat *value); +typedef void (APIENTRYP PFNGLGETOBJECTPARAMETERFVARBPROC) (GLhandleARB obj, GLenum pname, GLfloat *params); +typedef void (APIENTRYP PFNGLGETOBJECTPARAMETERIVARBPROC) (GLhandleARB obj, GLenum pname, GLint *params); +typedef void (APIENTRYP PFNGLGETINFOLOGARBPROC) (GLhandleARB obj, GLsizei maxLength, GLsizei *length, GLcharARB *infoLog); +typedef void (APIENTRYP PFNGLGETATTACHEDOBJECTSARBPROC) (GLhandleARB containerObj, GLsizei maxCount, GLsizei *count, GLhandleARB *obj); +typedef GLint (APIENTRYP PFNGLGETUNIFORMLOCATIONARBPROC) (GLhandleARB programObj, const GLcharARB *name); +typedef void (APIENTRYP PFNGLGETACTIVEUNIFORMARBPROC) (GLhandleARB programObj, GLuint index, GLsizei maxLength, GLsizei *length, GLint *size, GLenum *type, GLcharARB *name); +typedef void (APIENTRYP PFNGLGETUNIFORMFVARBPROC) (GLhandleARB programObj, GLint location, GLfloat *params); +typedef void (APIENTRYP PFNGLGETUNIFORMIVARBPROC) (GLhandleARB programObj, GLint location, GLint *params); +typedef void (APIENTRYP PFNGLGETSHADERSOURCEARBPROC) (GLhandleARB obj, GLsizei maxLength, GLsizei *length, GLcharARB *source); +#endif + +#ifndef GL_ARB_vertex_shader +#define GL_ARB_vertex_shader 1 +#ifdef GL_GLEXT_PROTOTYPES +GLAPI void APIENTRY glBindAttribLocationARB (GLhandleARB, GLuint, const GLcharARB *); +GLAPI void APIENTRY glGetActiveAttribARB (GLhandleARB, GLuint, GLsizei, GLsizei *, GLint *, GLenum *, GLcharARB *); +GLAPI GLint APIENTRY glGetAttribLocationARB (GLhandleARB, const GLcharARB *); +#endif /* GL_GLEXT_PROTOTYPES */ +typedef void (APIENTRYP PFNGLBINDATTRIBLOCATIONARBPROC) (GLhandleARB programObj, GLuint index, const GLcharARB *name); +typedef void (APIENTRYP PFNGLGETACTIVEATTRIBARBPROC) (GLhandleARB programObj, GLuint index, GLsizei maxLength, GLsizei *length, GLint *size, GLenum *type, GLcharARB *name); +typedef GLint (APIENTRYP PFNGLGETATTRIBLOCATIONARBPROC) (GLhandleARB programObj, const GLcharARB *name); +#endif + +#ifndef GL_ARB_fragment_shader +#define GL_ARB_fragment_shader 1 +#endif + +#ifndef GL_ARB_shading_language_100 +#define GL_ARB_shading_language_100 1 +#endif + +#ifndef GL_ARB_texture_non_power_of_two +#define GL_ARB_texture_non_power_of_two 1 +#endif + +#ifndef GL_ARB_point_sprite +#define GL_ARB_point_sprite 1 +#endif + +#ifndef GL_ARB_fragment_program_shadow +#define GL_ARB_fragment_program_shadow 1 +#endif + +#ifndef GL_ARB_draw_buffers +#define GL_ARB_draw_buffers 1 +#ifdef GL_GLEXT_PROTOTYPES +GLAPI void APIENTRY glDrawBuffersARB (GLsizei, const GLenum *); +#endif /* GL_GLEXT_PROTOTYPES */ +typedef void (APIENTRYP PFNGLDRAWBUFFERSARBPROC) (GLsizei n, const GLenum *bufs); +#endif + +#ifndef GL_ARB_texture_rectangle +#define GL_ARB_texture_rectangle 1 +#endif + +#ifndef GL_ARB_color_buffer_float +#define GL_ARB_color_buffer_float 1 +#ifdef GL_GLEXT_PROTOTYPES +GLAPI void APIENTRY glClampColorARB (GLenum, GLenum); +#endif /* GL_GLEXT_PROTOTYPES */ +typedef void (APIENTRYP PFNGLCLAMPCOLORARBPROC) (GLenum target, GLenum clamp); +#endif + +#ifndef GL_ARB_half_float_pixel +#define GL_ARB_half_float_pixel 1 +#endif + +#ifndef GL_ARB_texture_float +#define GL_ARB_texture_float 1 +#endif + +#ifndef GL_ARB_pixel_buffer_object +#define GL_ARB_pixel_buffer_object 1 +#endif + +#ifndef GL_EXT_abgr +#define GL_EXT_abgr 1 +#endif + +#ifndef GL_EXT_blend_color +#define GL_EXT_blend_color 1 +#ifdef GL_GLEXT_PROTOTYPES +GLAPI void APIENTRY glBlendColorEXT (GLclampf, GLclampf, GLclampf, GLclampf); +#endif /* GL_GLEXT_PROTOTYPES */ +typedef void (APIENTRYP PFNGLBLENDCOLOREXTPROC) (GLclampf red, GLclampf green, GLclampf blue, GLclampf alpha); +#endif + +#ifndef GL_EXT_polygon_offset +#define GL_EXT_polygon_offset 1 +#ifdef GL_GLEXT_PROTOTYPES +GLAPI void APIENTRY glPolygonOffsetEXT (GLfloat, GLfloat); +#endif /* GL_GLEXT_PROTOTYPES */ +typedef void (APIENTRYP PFNGLPOLYGONOFFSETEXTPROC) (GLfloat factor, GLfloat bias); +#endif + +#ifndef GL_EXT_texture +#define GL_EXT_texture 1 +#endif + +#ifndef GL_EXT_texture3D +#define GL_EXT_texture3D 1 +#ifdef GL_GLEXT_PROTOTYPES +GLAPI void APIENTRY glTexImage3DEXT (GLenum, GLint, GLenum, GLsizei, GLsizei, GLsizei, GLint, GLenum, GLenum, const GLvoid *); +GLAPI void APIENTRY glTexSubImage3DEXT (GLenum, GLint, GLint, GLint, GLint, GLsizei, GLsizei, GLsizei, GLenum, GLenum, const GLvoid *); +#endif /* GL_GLEXT_PROTOTYPES */ +typedef void (APIENTRYP PFNGLTEXIMAGE3DEXTPROC) (GLenum target, GLint level, GLenum internalformat, GLsizei width, GLsizei height, GLsizei depth, GLint border, GLenum format, GLenum type, const GLvoid *pixels); +typedef void (APIENTRYP PFNGLTEXSUBIMAGE3DEXTPROC) (GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLenum type, const GLvoid *pixels); +#endif + +#ifndef GL_SGIS_texture_filter4 +#define GL_SGIS_texture_filter4 1 +#ifdef GL_GLEXT_PROTOTYPES +GLAPI void APIENTRY glGetTexFilterFuncSGIS (GLenum, GLenum, GLfloat *); +GLAPI void APIENTRY glTexFilterFuncSGIS (GLenum, GLenum, GLsizei, const GLfloat *); +#endif /* GL_GLEXT_PROTOTYPES */ +typedef void (APIENTRYP PFNGLGETTEXFILTERFUNCSGISPROC) (GLenum target, GLenum filter, GLfloat *weights); +typedef void (APIENTRYP PFNGLTEXFILTERFUNCSGISPROC) (GLenum target, GLenum filter, GLsizei n, const GLfloat *weights); +#endif + +#ifndef GL_EXT_subtexture +#define GL_EXT_subtexture 1 +#ifdef GL_GLEXT_PROTOTYPES +GLAPI void APIENTRY glTexSubImage1DEXT (GLenum, GLint, GLint, GLsizei, GLenum, GLenum, const GLvoid *); +GLAPI void APIENTRY glTexSubImage2DEXT (GLenum, GLint, GLint, GLint, GLsizei, GLsizei, GLenum, GLenum, const GLvoid *); +#endif /* GL_GLEXT_PROTOTYPES */ +typedef void (APIENTRYP PFNGLTEXSUBIMAGE1DEXTPROC) (GLenum target, GLint level, GLint xoffset, GLsizei width, GLenum format, GLenum type, const GLvoid *pixels); +typedef void (APIENTRYP PFNGLTEXSUBIMAGE2DEXTPROC) (GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLenum type, const GLvoid *pixels); +#endif + +#ifndef GL_EXT_copy_texture +#define GL_EXT_copy_texture 1 +#ifdef GL_GLEXT_PROTOTYPES +GLAPI void APIENTRY glCopyTexImage1DEXT (GLenum, GLint, GLenum, GLint, GLint, GLsizei, GLint); +GLAPI void APIENTRY glCopyTexImage2DEXT (GLenum, GLint, GLenum, GLint, GLint, GLsizei, GLsizei, GLint); +GLAPI void APIENTRY glCopyTexSubImage1DEXT (GLenum, GLint, GLint, GLint, GLint, GLsizei); +GLAPI void APIENTRY glCopyTexSubImage2DEXT (GLenum, GLint, GLint, GLint, GLint, GLint, GLsizei, GLsizei); +GLAPI void APIENTRY glCopyTexSubImage3DEXT (GLenum, GLint, GLint, GLint, GLint, GLint, GLint, GLsizei, GLsizei); +#endif /* GL_GLEXT_PROTOTYPES */ +typedef void (APIENTRYP PFNGLCOPYTEXIMAGE1DEXTPROC) (GLenum target, GLint level, GLenum internalformat, GLint x, GLint y, GLsizei width, GLint border); +typedef void (APIENTRYP PFNGLCOPYTEXIMAGE2DEXTPROC) (GLenum target, GLint level, GLenum internalformat, GLint x, GLint y, GLsizei width, GLsizei height, GLint border); +typedef void (APIENTRYP PFNGLCOPYTEXSUBIMAGE1DEXTPROC) (GLenum target, GLint level, GLint xoffset, GLint x, GLint y, GLsizei width); +typedef void (APIENTRYP PFNGLCOPYTEXSUBIMAGE2DEXTPROC) (GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint x, GLint y, GLsizei width, GLsizei height); +typedef void (APIENTRYP PFNGLCOPYTEXSUBIMAGE3DEXTPROC) (GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLint x, GLint y, GLsizei width, GLsizei height); +#endif + +#ifndef GL_EXT_histogram +#define GL_EXT_histogram 1 +#ifdef GL_GLEXT_PROTOTYPES +GLAPI void APIENTRY glGetHistogramEXT (GLenum, GLboolean, GLenum, GLenum, GLvoid *); +GLAPI void APIENTRY glGetHistogramParameterfvEXT (GLenum, GLenum, GLfloat *); +GLAPI void APIENTRY glGetHistogramParameterivEXT (GLenum, GLenum, GLint *); +GLAPI void APIENTRY glGetMinmaxEXT (GLenum, GLboolean, GLenum, GLenum, GLvoid *); +GLAPI void APIENTRY glGetMinmaxParameterfvEXT (GLenum, GLenum, GLfloat *); +GLAPI void APIENTRY glGetMinmaxParameterivEXT (GLenum, GLenum, GLint *); +GLAPI void APIENTRY glHistogramEXT (GLenum, GLsizei, GLenum, GLboolean); +GLAPI void APIENTRY glMinmaxEXT (GLenum, GLenum, GLboolean); +GLAPI void APIENTRY glResetHistogramEXT (GLenum); +GLAPI void APIENTRY glResetMinmaxEXT (GLenum); +#endif /* GL_GLEXT_PROTOTYPES */ +typedef void (APIENTRYP PFNGLGETHISTOGRAMEXTPROC) (GLenum target, GLboolean reset, GLenum format, GLenum type, GLvoid *values); +typedef void (APIENTRYP PFNGLGETHISTOGRAMPARAMETERFVEXTPROC) (GLenum target, GLenum pname, GLfloat *params); +typedef void (APIENTRYP PFNGLGETHISTOGRAMPARAMETERIVEXTPROC) (GLenum target, GLenum pname, GLint *params); +typedef void (APIENTRYP PFNGLGETMINMAXEXTPROC) (GLenum target, GLboolean reset, GLenum format, GLenum type, GLvoid *values); +typedef void (APIENTRYP PFNGLGETMINMAXPARAMETERFVEXTPROC) (GLenum target, GLenum pname, GLfloat *params); +typedef void (APIENTRYP PFNGLGETMINMAXPARAMETERIVEXTPROC) (GLenum target, GLenum pname, GLint *params); +typedef void (APIENTRYP PFNGLHISTOGRAMEXTPROC) (GLenum target, GLsizei width, GLenum internalformat, GLboolean sink); +typedef void (APIENTRYP PFNGLMINMAXEXTPROC) (GLenum target, GLenum internalformat, GLboolean sink); +typedef void (APIENTRYP PFNGLRESETHISTOGRAMEXTPROC) (GLenum target); +typedef void (APIENTRYP PFNGLRESETMINMAXEXTPROC) (GLenum target); +#endif + +#ifndef GL_EXT_convolution +#define GL_EXT_convolution 1 +#ifdef GL_GLEXT_PROTOTYPES +GLAPI void APIENTRY glConvolutionFilter1DEXT (GLenum, GLenum, GLsizei, GLenum, GLenum, const GLvoid *); +GLAPI void APIENTRY glConvolutionFilter2DEXT (GLenum, GLenum, GLsizei, GLsizei, GLenum, GLenum, const GLvoid *); +GLAPI void APIENTRY glConvolutionParameterfEXT (GLenum, GLenum, GLfloat); +GLAPI void APIENTRY glConvolutionParameterfvEXT (GLenum, GLenum, const GLfloat *); +GLAPI void APIENTRY glConvolutionParameteriEXT (GLenum, GLenum, GLint); +GLAPI void APIENTRY glConvolutionParameterivEXT (GLenum, GLenum, const GLint *); +GLAPI void APIENTRY glCopyConvolutionFilter1DEXT (GLenum, GLenum, GLint, GLint, GLsizei); +GLAPI void APIENTRY glCopyConvolutionFilter2DEXT (GLenum, GLenum, GLint, GLint, GLsizei, GLsizei); +GLAPI void APIENTRY glGetConvolutionFilterEXT (GLenum, GLenum, GLenum, GLvoid *); +GLAPI void APIENTRY glGetConvolutionParameterfvEXT (GLenum, GLenum, GLfloat *); +GLAPI void APIENTRY glGetConvolutionParameterivEXT (GLenum, GLenum, GLint *); +GLAPI void APIENTRY glGetSeparableFilterEXT (GLenum, GLenum, GLenum, GLvoid *, GLvoid *, GLvoid *); +GLAPI void APIENTRY glSeparableFilter2DEXT (GLenum, GLenum, GLsizei, GLsizei, GLenum, GLenum, const GLvoid *, const GLvoid *); +#endif /* GL_GLEXT_PROTOTYPES */ +typedef void (APIENTRYP PFNGLCONVOLUTIONFILTER1DEXTPROC) (GLenum target, GLenum internalformat, GLsizei width, GLenum format, GLenum type, const GLvoid *image); +typedef void (APIENTRYP PFNGLCONVOLUTIONFILTER2DEXTPROC) (GLenum target, GLenum internalformat, GLsizei width, GLsizei height, GLenum format, GLenum type, const GLvoid *image); +typedef void (APIENTRYP PFNGLCONVOLUTIONPARAMETERFEXTPROC) (GLenum target, GLenum pname, GLfloat params); +typedef void (APIENTRYP PFNGLCONVOLUTIONPARAMETERFVEXTPROC) (GLenum target, GLenum pname, const GLfloat *params); +typedef void (APIENTRYP PFNGLCONVOLUTIONPARAMETERIEXTPROC) (GLenum target, GLenum pname, GLint params); +typedef void (APIENTRYP PFNGLCONVOLUTIONPARAMETERIVEXTPROC) (GLenum target, GLenum pname, const GLint *params); +typedef void (APIENTRYP PFNGLCOPYCONVOLUTIONFILTER1DEXTPROC) (GLenum target, GLenum internalformat, GLint x, GLint y, GLsizei width); +typedef void (APIENTRYP PFNGLCOPYCONVOLUTIONFILTER2DEXTPROC) (GLenum target, GLenum internalformat, GLint x, GLint y, GLsizei width, GLsizei height); +typedef void (APIENTRYP PFNGLGETCONVOLUTIONFILTEREXTPROC) (GLenum target, GLenum format, GLenum type, GLvoid *image); +typedef void (APIENTRYP PFNGLGETCONVOLUTIONPARAMETERFVEXTPROC) (GLenum target, GLenum pname, GLfloat *params); +typedef void (APIENTRYP PFNGLGETCONVOLUTIONPARAMETERIVEXTPROC) (GLenum target, GLenum pname, GLint *params); +typedef void (APIENTRYP PFNGLGETSEPARABLEFILTEREXTPROC) (GLenum target, GLenum format, GLenum type, GLvoid *row, GLvoid *column, GLvoid *span); +typedef void (APIENTRYP PFNGLSEPARABLEFILTER2DEXTPROC) (GLenum target, GLenum internalformat, GLsizei width, GLsizei height, GLenum format, GLenum type, const GLvoid *row, const GLvoid *column); +#endif + +#ifndef GL_EXT_color_matrix +#define GL_EXT_color_matrix 1 +#endif + +#ifndef GL_SGI_color_table +#define GL_SGI_color_table 1 +#ifdef GL_GLEXT_PROTOTYPES +GLAPI void APIENTRY glColorTableSGI (GLenum, GLenum, GLsizei, GLenum, GLenum, const GLvoid *); +GLAPI void APIENTRY glColorTableParameterfvSGI (GLenum, GLenum, const GLfloat *); +GLAPI void APIENTRY glColorTableParameterivSGI (GLenum, GLenum, const GLint *); +GLAPI void APIENTRY glCopyColorTableSGI (GLenum, GLenum, GLint, GLint, GLsizei); +GLAPI void APIENTRY glGetColorTableSGI (GLenum, GLenum, GLenum, GLvoid *); +GLAPI void APIENTRY glGetColorTableParameterfvSGI (GLenum, GLenum, GLfloat *); +GLAPI void APIENTRY glGetColorTableParameterivSGI (GLenum, GLenum, GLint *); +#endif /* GL_GLEXT_PROTOTYPES */ +typedef void (APIENTRYP PFNGLCOLORTABLESGIPROC) (GLenum target, GLenum internalformat, GLsizei width, GLenum format, GLenum type, const GLvoid *table); +typedef void (APIENTRYP PFNGLCOLORTABLEPARAMETERFVSGIPROC) (GLenum target, GLenum pname, const GLfloat *params); +typedef void (APIENTRYP PFNGLCOLORTABLEPARAMETERIVSGIPROC) (GLenum target, GLenum pname, const GLint *params); +typedef void (APIENTRYP PFNGLCOPYCOLORTABLESGIPROC) (GLenum target, GLenum internalformat, GLint x, GLint y, GLsizei width); +typedef void (APIENTRYP PFNGLGETCOLORTABLESGIPROC) (GLenum target, GLenum format, GLenum type, GLvoid *table); +typedef void (APIENTRYP PFNGLGETCOLORTABLEPARAMETERFVSGIPROC) (GLenum target, GLenum pname, GLfloat *params); +typedef void (APIENTRYP PFNGLGETCOLORTABLEPARAMETERIVSGIPROC) (GLenum target, GLenum pname, GLint *params); +#endif + +#ifndef GL_SGIX_pixel_texture +#define GL_SGIX_pixel_texture 1 +#ifdef GL_GLEXT_PROTOTYPES +GLAPI void APIENTRY glPixelTexGenSGIX (GLenum); +#endif /* GL_GLEXT_PROTOTYPES */ +typedef void (APIENTRYP PFNGLPIXELTEXGENSGIXPROC) (GLenum mode); +#endif + +#ifndef GL_SGIS_pixel_texture +#define GL_SGIS_pixel_texture 1 +#ifdef GL_GLEXT_PROTOTYPES +GLAPI void APIENTRY glPixelTexGenParameteriSGIS (GLenum, GLint); +GLAPI void APIENTRY glPixelTexGenParameterivSGIS (GLenum, const GLint *); +GLAPI void APIENTRY glPixelTexGenParameterfSGIS (GLenum, GLfloat); +GLAPI void APIENTRY glPixelTexGenParameterfvSGIS (GLenum, const GLfloat *); +GLAPI void APIENTRY glGetPixelTexGenParameterivSGIS (GLenum, GLint *); +GLAPI void APIENTRY glGetPixelTexGenParameterfvSGIS (GLenum, GLfloat *); +#endif /* GL_GLEXT_PROTOTYPES */ +typedef void (APIENTRYP PFNGLPIXELTEXGENPARAMETERISGISPROC) (GLenum pname, GLint param); +typedef void (APIENTRYP PFNGLPIXELTEXGENPARAMETERIVSGISPROC) (GLenum pname, const GLint *params); +typedef void (APIENTRYP PFNGLPIXELTEXGENPARAMETERFSGISPROC) (GLenum pname, GLfloat param); +typedef void (APIENTRYP PFNGLPIXELTEXGENPARAMETERFVSGISPROC) (GLenum pname, const GLfloat *params); +typedef void (APIENTRYP PFNGLGETPIXELTEXGENPARAMETERIVSGISPROC) (GLenum pname, GLint *params); +typedef void (APIENTRYP PFNGLGETPIXELTEXGENPARAMETERFVSGISPROC) (GLenum pname, GLfloat *params); +#endif + +#ifndef GL_SGIS_texture4D +#define GL_SGIS_texture4D 1 +#ifdef GL_GLEXT_PROTOTYPES +GLAPI void APIENTRY glTexImage4DSGIS (GLenum, GLint, GLenum, GLsizei, GLsizei, GLsizei, GLsizei, GLint, GLenum, GLenum, const GLvoid *); +GLAPI void APIENTRY glTexSubImage4DSGIS (GLenum, GLint, GLint, GLint, GLint, GLint, GLsizei, GLsizei, GLsizei, GLsizei, GLenum, GLenum, const GLvoid *); +#endif /* GL_GLEXT_PROTOTYPES */ +typedef void (APIENTRYP PFNGLTEXIMAGE4DSGISPROC) (GLenum target, GLint level, GLenum internalformat, GLsizei width, GLsizei height, GLsizei depth, GLsizei size4d, GLint border, GLenum format, GLenum type, const GLvoid *pixels); +typedef void (APIENTRYP PFNGLTEXSUBIMAGE4DSGISPROC) (GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLint woffset, GLsizei width, GLsizei height, GLsizei depth, GLsizei size4d, GLenum format, GLenum type, const GLvoid *pixels); +#endif + +#ifndef GL_SGI_texture_color_table +#define GL_SGI_texture_color_table 1 +#endif + +#ifndef GL_EXT_cmyka +#define GL_EXT_cmyka 1 +#endif + +#ifndef GL_EXT_texture_object +#define GL_EXT_texture_object 1 +#ifdef GL_GLEXT_PROTOTYPES +GLAPI GLboolean APIENTRY glAreTexturesResidentEXT (GLsizei, const GLuint *, GLboolean *); +GLAPI void APIENTRY glBindTextureEXT (GLenum, GLuint); +GLAPI void APIENTRY glDeleteTexturesEXT (GLsizei, const GLuint *); +GLAPI void APIENTRY glGenTexturesEXT (GLsizei, GLuint *); +GLAPI GLboolean APIENTRY glIsTextureEXT (GLuint); +GLAPI void APIENTRY glPrioritizeTexturesEXT (GLsizei, const GLuint *, const GLclampf *); +#endif /* GL_GLEXT_PROTOTYPES */ +typedef GLboolean (APIENTRYP PFNGLARETEXTURESRESIDENTEXTPROC) (GLsizei n, const GLuint *textures, GLboolean *residences); +typedef void (APIENTRYP PFNGLBINDTEXTUREEXTPROC) (GLenum target, GLuint texture); +typedef void (APIENTRYP PFNGLDELETETEXTURESEXTPROC) (GLsizei n, const GLuint *textures); +typedef void (APIENTRYP PFNGLGENTEXTURESEXTPROC) (GLsizei n, GLuint *textures); +typedef GLboolean (APIENTRYP PFNGLISTEXTUREEXTPROC) (GLuint texture); +typedef void (APIENTRYP PFNGLPRIORITIZETEXTURESEXTPROC) (GLsizei n, const GLuint *textures, const GLclampf *priorities); +#endif + +#ifndef GL_SGIS_detail_texture +#define GL_SGIS_detail_texture 1 +#ifdef GL_GLEXT_PROTOTYPES +GLAPI void APIENTRY glDetailTexFuncSGIS (GLenum, GLsizei, const GLfloat *); +GLAPI void APIENTRY glGetDetailTexFuncSGIS (GLenum, GLfloat *); +#endif /* GL_GLEXT_PROTOTYPES */ +typedef void (APIENTRYP PFNGLDETAILTEXFUNCSGISPROC) (GLenum target, GLsizei n, const GLfloat *points); +typedef void (APIENTRYP PFNGLGETDETAILTEXFUNCSGISPROC) (GLenum target, GLfloat *points); +#endif + +#ifndef GL_SGIS_sharpen_texture +#define GL_SGIS_sharpen_texture 1 +#ifdef GL_GLEXT_PROTOTYPES +GLAPI void APIENTRY glSharpenTexFuncSGIS (GLenum, GLsizei, const GLfloat *); +GLAPI void APIENTRY glGetSharpenTexFuncSGIS (GLenum, GLfloat *); +#endif /* GL_GLEXT_PROTOTYPES */ +typedef void (APIENTRYP PFNGLSHARPENTEXFUNCSGISPROC) (GLenum target, GLsizei n, const GLfloat *points); +typedef void (APIENTRYP PFNGLGETSHARPENTEXFUNCSGISPROC) (GLenum target, GLfloat *points); +#endif + +#ifndef GL_EXT_packed_pixels +#define GL_EXT_packed_pixels 1 +#endif + +#ifndef GL_SGIS_texture_lod +#define GL_SGIS_texture_lod 1 +#endif + +#ifndef GL_SGIS_multisample +#define GL_SGIS_multisample 1 +#ifdef GL_GLEXT_PROTOTYPES +GLAPI void APIENTRY glSampleMaskSGIS (GLclampf, GLboolean); +GLAPI void APIENTRY glSamplePatternSGIS (GLenum); +#endif /* GL_GLEXT_PROTOTYPES */ +typedef void (APIENTRYP PFNGLSAMPLEMASKSGISPROC) (GLclampf value, GLboolean invert); +typedef void (APIENTRYP PFNGLSAMPLEPATTERNSGISPROC) (GLenum pattern); +#endif + +#ifndef GL_EXT_rescale_normal +#define GL_EXT_rescale_normal 1 +#endif + +#ifndef GL_EXT_vertex_array +#define GL_EXT_vertex_array 1 +#ifdef GL_GLEXT_PROTOTYPES +GLAPI void APIENTRY glArrayElementEXT (GLint); +GLAPI void APIENTRY glColorPointerEXT (GLint, GLenum, GLsizei, GLsizei, const GLvoid *); +GLAPI void APIENTRY glDrawArraysEXT (GLenum, GLint, GLsizei); +GLAPI void APIENTRY glEdgeFlagPointerEXT (GLsizei, GLsizei, const GLboolean *); +GLAPI void APIENTRY glGetPointervEXT (GLenum, GLvoid* *); +GLAPI void APIENTRY glIndexPointerEXT (GLenum, GLsizei, GLsizei, const GLvoid *); +GLAPI void APIENTRY glNormalPointerEXT (GLenum, GLsizei, GLsizei, const GLvoid *); +GLAPI void APIENTRY glTexCoordPointerEXT (GLint, GLenum, GLsizei, GLsizei, const GLvoid *); +GLAPI void APIENTRY glVertexPointerEXT (GLint, GLenum, GLsizei, GLsizei, const GLvoid *); +#endif /* GL_GLEXT_PROTOTYPES */ +typedef void (APIENTRYP PFNGLARRAYELEMENTEXTPROC) (GLint i); +typedef void (APIENTRYP PFNGLCOLORPOINTEREXTPROC) (GLint size, GLenum type, GLsizei stride, GLsizei count, const GLvoid *pointer); +typedef void (APIENTRYP PFNGLDRAWARRAYSEXTPROC) (GLenum mode, GLint first, GLsizei count); +typedef void (APIENTRYP PFNGLEDGEFLAGPOINTEREXTPROC) (GLsizei stride, GLsizei count, const GLboolean *pointer); +typedef void (APIENTRYP PFNGLGETPOINTERVEXTPROC) (GLenum pname, GLvoid* *params); +typedef void (APIENTRYP PFNGLINDEXPOINTEREXTPROC) (GLenum type, GLsizei stride, GLsizei count, const GLvoid *pointer); +typedef void (APIENTRYP PFNGLNORMALPOINTEREXTPROC) (GLenum type, GLsizei stride, GLsizei count, const GLvoid *pointer); +typedef void (APIENTRYP PFNGLTEXCOORDPOINTEREXTPROC) (GLint size, GLenum type, GLsizei stride, GLsizei count, const GLvoid *pointer); +typedef void (APIENTRYP PFNGLVERTEXPOINTEREXTPROC) (GLint size, GLenum type, GLsizei stride, GLsizei count, const GLvoid *pointer); +#endif + +#ifndef GL_EXT_misc_attribute +#define GL_EXT_misc_attribute 1 +#endif + +#ifndef GL_SGIS_generate_mipmap +#define GL_SGIS_generate_mipmap 1 +#endif + +#ifndef GL_SGIX_clipmap +#define GL_SGIX_clipmap 1 +#endif + +#ifndef GL_SGIX_shadow +#define GL_SGIX_shadow 1 +#endif + +#ifndef GL_SGIS_texture_edge_clamp +#define GL_SGIS_texture_edge_clamp 1 +#endif + +#ifndef GL_SGIS_texture_border_clamp +#define GL_SGIS_texture_border_clamp 1 +#endif + +#ifndef GL_EXT_blend_minmax +#define GL_EXT_blend_minmax 1 +#ifdef GL_GLEXT_PROTOTYPES +GLAPI void APIENTRY glBlendEquationEXT (GLenum); +#endif /* GL_GLEXT_PROTOTYPES */ +typedef void (APIENTRYP PFNGLBLENDEQUATIONEXTPROC) (GLenum mode); +#endif + +#ifndef GL_EXT_blend_subtract +#define GL_EXT_blend_subtract 1 +#endif + +#ifndef GL_EXT_blend_logic_op +#define GL_EXT_blend_logic_op 1 +#endif + +#ifndef GL_SGIX_interlace +#define GL_SGIX_interlace 1 +#endif + +#ifndef GL_SGIX_pixel_tiles +#define GL_SGIX_pixel_tiles 1 +#endif + +#ifndef GL_SGIX_texture_select +#define GL_SGIX_texture_select 1 +#endif + +#ifndef GL_SGIX_sprite +#define GL_SGIX_sprite 1 +#ifdef GL_GLEXT_PROTOTYPES +GLAPI void APIENTRY glSpriteParameterfSGIX (GLenum, GLfloat); +GLAPI void APIENTRY glSpriteParameterfvSGIX (GLenum, const GLfloat *); +GLAPI void APIENTRY glSpriteParameteriSGIX (GLenum, GLint); +GLAPI void APIENTRY glSpriteParameterivSGIX (GLenum, const GLint *); +#endif /* GL_GLEXT_PROTOTYPES */ +typedef void (APIENTRYP PFNGLSPRITEPARAMETERFSGIXPROC) (GLenum pname, GLfloat param); +typedef void (APIENTRYP PFNGLSPRITEPARAMETERFVSGIXPROC) (GLenum pname, const GLfloat *params); +typedef void (APIENTRYP PFNGLSPRITEPARAMETERISGIXPROC) (GLenum pname, GLint param); +typedef void (APIENTRYP PFNGLSPRITEPARAMETERIVSGIXPROC) (GLenum pname, const GLint *params); +#endif + +#ifndef GL_SGIX_texture_multi_buffer +#define GL_SGIX_texture_multi_buffer 1 +#endif + +#ifndef GL_EXT_point_parameters +#define GL_EXT_point_parameters 1 +#ifdef GL_GLEXT_PROTOTYPES +GLAPI void APIENTRY glPointParameterfEXT (GLenum, GLfloat); +GLAPI void APIENTRY glPointParameterfvEXT (GLenum, const GLfloat *); +#endif /* GL_GLEXT_PROTOTYPES */ +typedef void (APIENTRYP PFNGLPOINTPARAMETERFEXTPROC) (GLenum pname, GLfloat param); +typedef void (APIENTRYP PFNGLPOINTPARAMETERFVEXTPROC) (GLenum pname, const GLfloat *params); +#endif + +#ifndef GL_SGIS_point_parameters +#define GL_SGIS_point_parameters 1 +#ifdef GL_GLEXT_PROTOTYPES +GLAPI void APIENTRY glPointParameterfSGIS (GLenum, GLfloat); +GLAPI void APIENTRY glPointParameterfvSGIS (GLenum, const GLfloat *); +#endif /* GL_GLEXT_PROTOTYPES */ +typedef void (APIENTRYP PFNGLPOINTPARAMETERFSGISPROC) (GLenum pname, GLfloat param); +typedef void (APIENTRYP PFNGLPOINTPARAMETERFVSGISPROC) (GLenum pname, const GLfloat *params); +#endif + +#ifndef GL_SGIX_instruments +#define GL_SGIX_instruments 1 +#ifdef GL_GLEXT_PROTOTYPES +GLAPI GLint APIENTRY glGetInstrumentsSGIX (void); +GLAPI void APIENTRY glInstrumentsBufferSGIX (GLsizei, GLint *); +GLAPI GLint APIENTRY glPollInstrumentsSGIX (GLint *); +GLAPI void APIENTRY glReadInstrumentsSGIX (GLint); +GLAPI void APIENTRY glStartInstrumentsSGIX (void); +GLAPI void APIENTRY glStopInstrumentsSGIX (GLint); +#endif /* GL_GLEXT_PROTOTYPES */ +typedef GLint (APIENTRYP PFNGLGETINSTRUMENTSSGIXPROC) (void); +typedef void (APIENTRYP PFNGLINSTRUMENTSBUFFERSGIXPROC) (GLsizei size, GLint *buffer); +typedef GLint (APIENTRYP PFNGLPOLLINSTRUMENTSSGIXPROC) (GLint *marker_p); +typedef void (APIENTRYP PFNGLREADINSTRUMENTSSGIXPROC) (GLint marker); +typedef void (APIENTRYP PFNGLSTARTINSTRUMENTSSGIXPROC) (void); +typedef void (APIENTRYP PFNGLSTOPINSTRUMENTSSGIXPROC) (GLint marker); +#endif + +#ifndef GL_SGIX_texture_scale_bias +#define GL_SGIX_texture_scale_bias 1 +#endif + +#ifndef GL_SGIX_framezoom +#define GL_SGIX_framezoom 1 +#ifdef GL_GLEXT_PROTOTYPES +GLAPI void APIENTRY glFrameZoomSGIX (GLint); +#endif /* GL_GLEXT_PROTOTYPES */ +typedef void (APIENTRYP PFNGLFRAMEZOOMSGIXPROC) (GLint factor); +#endif + +#ifndef GL_SGIX_tag_sample_buffer +#define GL_SGIX_tag_sample_buffer 1 +#ifdef GL_GLEXT_PROTOTYPES +GLAPI void APIENTRY glTagSampleBufferSGIX (void); +#endif /* GL_GLEXT_PROTOTYPES */ +typedef void (APIENTRYP PFNGLTAGSAMPLEBUFFERSGIXPROC) (void); +#endif + +#ifndef GL_SGIX_polynomial_ffd +#define GL_SGIX_polynomial_ffd 1 +#ifdef GL_GLEXT_PROTOTYPES +GLAPI void APIENTRY glDeformationMap3dSGIX (GLenum, GLdouble, GLdouble, GLint, GLint, GLdouble, GLdouble, GLint, GLint, GLdouble, GLdouble, GLint, GLint, const GLdouble *); +GLAPI void APIENTRY glDeformationMap3fSGIX (GLenum, GLfloat, GLfloat, GLint, GLint, GLfloat, GLfloat, GLint, GLint, GLfloat, GLfloat, GLint, GLint, const GLfloat *); +GLAPI void APIENTRY glDeformSGIX (GLbitfield); +GLAPI void APIENTRY glLoadIdentityDeformationMapSGIX (GLbitfield); +#endif /* GL_GLEXT_PROTOTYPES */ +typedef void (APIENTRYP PFNGLDEFORMATIONMAP3DSGIXPROC) (GLenum target, GLdouble u1, GLdouble u2, GLint ustride, GLint uorder, GLdouble v1, GLdouble v2, GLint vstride, GLint vorder, GLdouble w1, GLdouble w2, GLint wstride, GLint worder, const GLdouble *points); +typedef void (APIENTRYP PFNGLDEFORMATIONMAP3FSGIXPROC) (GLenum target, GLfloat u1, GLfloat u2, GLint ustride, GLint uorder, GLfloat v1, GLfloat v2, GLint vstride, GLint vorder, GLfloat w1, GLfloat w2, GLint wstride, GLint worder, const GLfloat *points); +typedef void (APIENTRYP PFNGLDEFORMSGIXPROC) (GLbitfield mask); +typedef void (APIENTRYP PFNGLLOADIDENTITYDEFORMATIONMAPSGIXPROC) (GLbitfield mask); +#endif + +#ifndef GL_SGIX_reference_plane +#define GL_SGIX_reference_plane 1 +#ifdef GL_GLEXT_PROTOTYPES +GLAPI void APIENTRY glReferencePlaneSGIX (const GLdouble *); +#endif /* GL_GLEXT_PROTOTYPES */ +typedef void (APIENTRYP PFNGLREFERENCEPLANESGIXPROC) (const GLdouble *equation); +#endif + +#ifndef GL_SGIX_flush_raster +#define GL_SGIX_flush_raster 1 +#ifdef GL_GLEXT_PROTOTYPES +GLAPI void APIENTRY glFlushRasterSGIX (void); +#endif /* GL_GLEXT_PROTOTYPES */ +typedef void (APIENTRYP PFNGLFLUSHRASTERSGIXPROC) (void); +#endif + +#ifndef GL_SGIX_depth_texture +#define GL_SGIX_depth_texture 1 +#endif + +#ifndef GL_SGIS_fog_function +#define GL_SGIS_fog_function 1 +#ifdef GL_GLEXT_PROTOTYPES +GLAPI void APIENTRY glFogFuncSGIS (GLsizei, const GLfloat *); +GLAPI void APIENTRY glGetFogFuncSGIS (GLfloat *); +#endif /* GL_GLEXT_PROTOTYPES */ +typedef void (APIENTRYP PFNGLFOGFUNCSGISPROC) (GLsizei n, const GLfloat *points); +typedef void (APIENTRYP PFNGLGETFOGFUNCSGISPROC) (GLfloat *points); +#endif + +#ifndef GL_SGIX_fog_offset +#define GL_SGIX_fog_offset 1 +#endif + +#ifndef GL_HP_image_transform +#define GL_HP_image_transform 1 +#ifdef GL_GLEXT_PROTOTYPES +GLAPI void APIENTRY glImageTransformParameteriHP (GLenum, GLenum, GLint); +GLAPI void APIENTRY glImageTransformParameterfHP (GLenum, GLenum, GLfloat); +GLAPI void APIENTRY glImageTransformParameterivHP (GLenum, GLenum, const GLint *); +GLAPI void APIENTRY glImageTransformParameterfvHP (GLenum, GLenum, const GLfloat *); +GLAPI void APIENTRY glGetImageTransformParameterivHP (GLenum, GLenum, GLint *); +GLAPI void APIENTRY glGetImageTransformParameterfvHP (GLenum, GLenum, GLfloat *); +#endif /* GL_GLEXT_PROTOTYPES */ +typedef void (APIENTRYP PFNGLIMAGETRANSFORMPARAMETERIHPPROC) (GLenum target, GLenum pname, GLint param); +typedef void (APIENTRYP PFNGLIMAGETRANSFORMPARAMETERFHPPROC) (GLenum target, GLenum pname, GLfloat param); +typedef void (APIENTRYP PFNGLIMAGETRANSFORMPARAMETERIVHPPROC) (GLenum target, GLenum pname, const GLint *params); +typedef void (APIENTRYP PFNGLIMAGETRANSFORMPARAMETERFVHPPROC) (GLenum target, GLenum pname, const GLfloat *params); +typedef void (APIENTRYP PFNGLGETIMAGETRANSFORMPARAMETERIVHPPROC) (GLenum target, GLenum pname, GLint *params); +typedef void (APIENTRYP PFNGLGETIMAGETRANSFORMPARAMETERFVHPPROC) (GLenum target, GLenum pname, GLfloat *params); +#endif + +#ifndef GL_HP_convolution_border_modes +#define GL_HP_convolution_border_modes 1 +#endif + +#ifndef GL_SGIX_texture_add_env +#define GL_SGIX_texture_add_env 1 +#endif + +#ifndef GL_EXT_color_subtable +#define GL_EXT_color_subtable 1 +#ifdef GL_GLEXT_PROTOTYPES +GLAPI void APIENTRY glColorSubTableEXT (GLenum, GLsizei, GLsizei, GLenum, GLenum, const GLvoid *); +GLAPI void APIENTRY glCopyColorSubTableEXT (GLenum, GLsizei, GLint, GLint, GLsizei); +#endif /* GL_GLEXT_PROTOTYPES */ +typedef void (APIENTRYP PFNGLCOLORSUBTABLEEXTPROC) (GLenum target, GLsizei start, GLsizei count, GLenum format, GLenum type, const GLvoid *data); +typedef void (APIENTRYP PFNGLCOPYCOLORSUBTABLEEXTPROC) (GLenum target, GLsizei start, GLint x, GLint y, GLsizei width); +#endif + +#ifndef GL_PGI_vertex_hints +#define GL_PGI_vertex_hints 1 +#endif + +#ifndef GL_PGI_misc_hints +#define GL_PGI_misc_hints 1 +#ifdef GL_GLEXT_PROTOTYPES +GLAPI void APIENTRY glHintPGI (GLenum, GLint); +#endif /* GL_GLEXT_PROTOTYPES */ +typedef void (APIENTRYP PFNGLHINTPGIPROC) (GLenum target, GLint mode); +#endif + +#ifndef GL_EXT_paletted_texture +#define GL_EXT_paletted_texture 1 +#ifdef GL_GLEXT_PROTOTYPES +GLAPI void APIENTRY glColorTableEXT (GLenum, GLenum, GLsizei, GLenum, GLenum, const GLvoid *); +GLAPI void APIENTRY glGetColorTableEXT (GLenum, GLenum, GLenum, GLvoid *); +GLAPI void APIENTRY glGetColorTableParameterivEXT (GLenum, GLenum, GLint *); +GLAPI void APIENTRY glGetColorTableParameterfvEXT (GLenum, GLenum, GLfloat *); +#endif /* GL_GLEXT_PROTOTYPES */ +typedef void (APIENTRYP PFNGLCOLORTABLEEXTPROC) (GLenum target, GLenum internalFormat, GLsizei width, GLenum format, GLenum type, const GLvoid *table); +typedef void (APIENTRYP PFNGLGETCOLORTABLEEXTPROC) (GLenum target, GLenum format, GLenum type, GLvoid *data); +typedef void (APIENTRYP PFNGLGETCOLORTABLEPARAMETERIVEXTPROC) (GLenum target, GLenum pname, GLint *params); +typedef void (APIENTRYP PFNGLGETCOLORTABLEPARAMETERFVEXTPROC) (GLenum target, GLenum pname, GLfloat *params); +#endif + +#ifndef GL_EXT_clip_volume_hint +#define GL_EXT_clip_volume_hint 1 +#endif + +#ifndef GL_SGIX_list_priority +#define GL_SGIX_list_priority 1 +#ifdef GL_GLEXT_PROTOTYPES +GLAPI void APIENTRY glGetListParameterfvSGIX (GLuint, GLenum, GLfloat *); +GLAPI void APIENTRY glGetListParameterivSGIX (GLuint, GLenum, GLint *); +GLAPI void APIENTRY glListParameterfSGIX (GLuint, GLenum, GLfloat); +GLAPI void APIENTRY glListParameterfvSGIX (GLuint, GLenum, const GLfloat *); +GLAPI void APIENTRY glListParameteriSGIX (GLuint, GLenum, GLint); +GLAPI void APIENTRY glListParameterivSGIX (GLuint, GLenum, const GLint *); +#endif /* GL_GLEXT_PROTOTYPES */ +typedef void (APIENTRYP PFNGLGETLISTPARAMETERFVSGIXPROC) (GLuint list, GLenum pname, GLfloat *params); +typedef void (APIENTRYP PFNGLGETLISTPARAMETERIVSGIXPROC) (GLuint list, GLenum pname, GLint *params); +typedef void (APIENTRYP PFNGLLISTPARAMETERFSGIXPROC) (GLuint list, GLenum pname, GLfloat param); +typedef void (APIENTRYP PFNGLLISTPARAMETERFVSGIXPROC) (GLuint list, GLenum pname, const GLfloat *params); +typedef void (APIENTRYP PFNGLLISTPARAMETERISGIXPROC) (GLuint list, GLenum pname, GLint param); +typedef void (APIENTRYP PFNGLLISTPARAMETERIVSGIXPROC) (GLuint list, GLenum pname, const GLint *params); +#endif + +#ifndef GL_SGIX_ir_instrument1 +#define GL_SGIX_ir_instrument1 1 +#endif + +#ifndef GL_SGIX_calligraphic_fragment +#define GL_SGIX_calligraphic_fragment 1 +#endif + +#ifndef GL_SGIX_texture_lod_bias +#define GL_SGIX_texture_lod_bias 1 +#endif + +#ifndef GL_SGIX_shadow_ambient +#define GL_SGIX_shadow_ambient 1 +#endif + +#ifndef GL_EXT_index_texture +#define GL_EXT_index_texture 1 +#endif + +#ifndef GL_EXT_index_material +#define GL_EXT_index_material 1 +#ifdef GL_GLEXT_PROTOTYPES +GLAPI void APIENTRY glIndexMaterialEXT (GLenum, GLenum); +#endif /* GL_GLEXT_PROTOTYPES */ +typedef void (APIENTRYP PFNGLINDEXMATERIALEXTPROC) (GLenum face, GLenum mode); +#endif + +#ifndef GL_EXT_index_func +#define GL_EXT_index_func 1 +#ifdef GL_GLEXT_PROTOTYPES +GLAPI void APIENTRY glIndexFuncEXT (GLenum, GLclampf); +#endif /* GL_GLEXT_PROTOTYPES */ +typedef void (APIENTRYP PFNGLINDEXFUNCEXTPROC) (GLenum func, GLclampf ref); +#endif + +#ifndef GL_EXT_index_array_formats +#define GL_EXT_index_array_formats 1 +#endif + +#ifndef GL_EXT_compiled_vertex_array +#define GL_EXT_compiled_vertex_array 1 +#ifdef GL_GLEXT_PROTOTYPES +GLAPI void APIENTRY glLockArraysEXT (GLint, GLsizei); +GLAPI void APIENTRY glUnlockArraysEXT (void); +#endif /* GL_GLEXT_PROTOTYPES */ +typedef void (APIENTRYP PFNGLLOCKARRAYSEXTPROC) (GLint first, GLsizei count); +typedef void (APIENTRYP PFNGLUNLOCKARRAYSEXTPROC) (void); +#endif + +#ifndef GL_EXT_cull_vertex +#define GL_EXT_cull_vertex 1 +#ifdef GL_GLEXT_PROTOTYPES +GLAPI void APIENTRY glCullParameterdvEXT (GLenum, GLdouble *); +GLAPI void APIENTRY glCullParameterfvEXT (GLenum, GLfloat *); +#endif /* GL_GLEXT_PROTOTYPES */ +typedef void (APIENTRYP PFNGLCULLPARAMETERDVEXTPROC) (GLenum pname, GLdouble *params); +typedef void (APIENTRYP PFNGLCULLPARAMETERFVEXTPROC) (GLenum pname, GLfloat *params); +#endif + +#ifndef GL_SGIX_ycrcb +#define GL_SGIX_ycrcb 1 +#endif + +#ifndef GL_SGIX_fragment_lighting +#define GL_SGIX_fragment_lighting 1 +#ifdef GL_GLEXT_PROTOTYPES +GLAPI void APIENTRY glFragmentColorMaterialSGIX (GLenum, GLenum); +GLAPI void APIENTRY glFragmentLightfSGIX (GLenum, GLenum, GLfloat); +GLAPI void APIENTRY glFragmentLightfvSGIX (GLenum, GLenum, const GLfloat *); +GLAPI void APIENTRY glFragmentLightiSGIX (GLenum, GLenum, GLint); +GLAPI void APIENTRY glFragmentLightivSGIX (GLenum, GLenum, const GLint *); +GLAPI void APIENTRY glFragmentLightModelfSGIX (GLenum, GLfloat); +GLAPI void APIENTRY glFragmentLightModelfvSGIX (GLenum, const GLfloat *); +GLAPI void APIENTRY glFragmentLightModeliSGIX (GLenum, GLint); +GLAPI void APIENTRY glFragmentLightModelivSGIX (GLenum, const GLint *); +GLAPI void APIENTRY glFragmentMaterialfSGIX (GLenum, GLenum, GLfloat); +GLAPI void APIENTRY glFragmentMaterialfvSGIX (GLenum, GLenum, const GLfloat *); +GLAPI void APIENTRY glFragmentMaterialiSGIX (GLenum, GLenum, GLint); +GLAPI void APIENTRY glFragmentMaterialivSGIX (GLenum, GLenum, const GLint *); +GLAPI void APIENTRY glGetFragmentLightfvSGIX (GLenum, GLenum, GLfloat *); +GLAPI void APIENTRY glGetFragmentLightivSGIX (GLenum, GLenum, GLint *); +GLAPI void APIENTRY glGetFragmentMaterialfvSGIX (GLenum, GLenum, GLfloat *); +GLAPI void APIENTRY glGetFragmentMaterialivSGIX (GLenum, GLenum, GLint *); +GLAPI void APIENTRY glLightEnviSGIX (GLenum, GLint); +#endif /* GL_GLEXT_PROTOTYPES */ +typedef void (APIENTRYP PFNGLFRAGMENTCOLORMATERIALSGIXPROC) (GLenum face, GLenum mode); +typedef void (APIENTRYP PFNGLFRAGMENTLIGHTFSGIXPROC) (GLenum light, GLenum pname, GLfloat param); +typedef void (APIENTRYP PFNGLFRAGMENTLIGHTFVSGIXPROC) (GLenum light, GLenum pname, const GLfloat *params); +typedef void (APIENTRYP PFNGLFRAGMENTLIGHTISGIXPROC) (GLenum light, GLenum pname, GLint param); +typedef void (APIENTRYP PFNGLFRAGMENTLIGHTIVSGIXPROC) (GLenum light, GLenum pname, const GLint *params); +typedef void (APIENTRYP PFNGLFRAGMENTLIGHTMODELFSGIXPROC) (GLenum pname, GLfloat param); +typedef void (APIENTRYP PFNGLFRAGMENTLIGHTMODELFVSGIXPROC) (GLenum pname, const GLfloat *params); +typedef void (APIENTRYP PFNGLFRAGMENTLIGHTMODELISGIXPROC) (GLenum pname, GLint param); +typedef void (APIENTRYP PFNGLFRAGMENTLIGHTMODELIVSGIXPROC) (GLenum pname, const GLint *params); +typedef void (APIENTRYP PFNGLFRAGMENTMATERIALFSGIXPROC) (GLenum face, GLenum pname, GLfloat param); +typedef void (APIENTRYP PFNGLFRAGMENTMATERIALFVSGIXPROC) (GLenum face, GLenum pname, const GLfloat *params); +typedef void (APIENTRYP PFNGLFRAGMENTMATERIALISGIXPROC) (GLenum face, GLenum pname, GLint param); +typedef void (APIENTRYP PFNGLFRAGMENTMATERIALIVSGIXPROC) (GLenum face, GLenum pname, const GLint *params); +typedef void (APIENTRYP PFNGLGETFRAGMENTLIGHTFVSGIXPROC) (GLenum light, GLenum pname, GLfloat *params); +typedef void (APIENTRYP PFNGLGETFRAGMENTLIGHTIVSGIXPROC) (GLenum light, GLenum pname, GLint *params); +typedef void (APIENTRYP PFNGLGETFRAGMENTMATERIALFVSGIXPROC) (GLenum face, GLenum pname, GLfloat *params); +typedef void (APIENTRYP PFNGLGETFRAGMENTMATERIALIVSGIXPROC) (GLenum face, GLenum pname, GLint *params); +typedef void (APIENTRYP PFNGLLIGHTENVISGIXPROC) (GLenum pname, GLint param); +#endif + +#ifndef GL_IBM_rasterpos_clip +#define GL_IBM_rasterpos_clip 1 +#endif + +#ifndef GL_HP_texture_lighting +#define GL_HP_texture_lighting 1 +#endif + +#ifndef GL_EXT_draw_range_elements +#define GL_EXT_draw_range_elements 1 +#ifdef GL_GLEXT_PROTOTYPES +GLAPI void APIENTRY glDrawRangeElementsEXT (GLenum, GLuint, GLuint, GLsizei, GLenum, const GLvoid *); +#endif /* GL_GLEXT_PROTOTYPES */ +typedef void (APIENTRYP PFNGLDRAWRANGEELEMENTSEXTPROC) (GLenum mode, GLuint start, GLuint end, GLsizei count, GLenum type, const GLvoid *indices); +#endif + +#ifndef GL_WIN_phong_shading +#define GL_WIN_phong_shading 1 +#endif + +#ifndef GL_WIN_specular_fog +#define GL_WIN_specular_fog 1 +#endif + +#ifndef GL_EXT_light_texture +#define GL_EXT_light_texture 1 +#ifdef GL_GLEXT_PROTOTYPES +GLAPI void APIENTRY glApplyTextureEXT (GLenum); +GLAPI void APIENTRY glTextureLightEXT (GLenum); +GLAPI void APIENTRY glTextureMaterialEXT (GLenum, GLenum); +#endif /* GL_GLEXT_PROTOTYPES */ +typedef void (APIENTRYP PFNGLAPPLYTEXTUREEXTPROC) (GLenum mode); +typedef void (APIENTRYP PFNGLTEXTURELIGHTEXTPROC) (GLenum pname); +typedef void (APIENTRYP PFNGLTEXTUREMATERIALEXTPROC) (GLenum face, GLenum mode); +#endif + +#ifndef GL_SGIX_blend_alpha_minmax +#define GL_SGIX_blend_alpha_minmax 1 +#endif + +#ifndef GL_EXT_bgra +#define GL_EXT_bgra 1 +#endif + +#ifndef GL_SGIX_async +#define GL_SGIX_async 1 +#ifdef GL_GLEXT_PROTOTYPES +GLAPI void APIENTRY glAsyncMarkerSGIX (GLuint); +GLAPI GLint APIENTRY glFinishAsyncSGIX (GLuint *); +GLAPI GLint APIENTRY glPollAsyncSGIX (GLuint *); +GLAPI GLuint APIENTRY glGenAsyncMarkersSGIX (GLsizei); +GLAPI void APIENTRY glDeleteAsyncMarkersSGIX (GLuint, GLsizei); +GLAPI GLboolean APIENTRY glIsAsyncMarkerSGIX (GLuint); +#endif /* GL_GLEXT_PROTOTYPES */ +typedef void (APIENTRYP PFNGLASYNCMARKERSGIXPROC) (GLuint marker); +typedef GLint (APIENTRYP PFNGLFINISHASYNCSGIXPROC) (GLuint *markerp); +typedef GLint (APIENTRYP PFNGLPOLLASYNCSGIXPROC) (GLuint *markerp); +typedef GLuint (APIENTRYP PFNGLGENASYNCMARKERSSGIXPROC) (GLsizei range); +typedef void (APIENTRYP PFNGLDELETEASYNCMARKERSSGIXPROC) (GLuint marker, GLsizei range); +typedef GLboolean (APIENTRYP PFNGLISASYNCMARKERSGIXPROC) (GLuint marker); +#endif + +#ifndef GL_SGIX_async_pixel +#define GL_SGIX_async_pixel 1 +#endif + +#ifndef GL_SGIX_async_histogram +#define GL_SGIX_async_histogram 1 +#endif + +#ifndef GL_INTEL_parallel_arrays +#define GL_INTEL_parallel_arrays 1 +#ifdef GL_GLEXT_PROTOTYPES +GLAPI void APIENTRY glVertexPointervINTEL (GLint, GLenum, const GLvoid* *); +GLAPI void APIENTRY glNormalPointervINTEL (GLenum, const GLvoid* *); +GLAPI void APIENTRY glColorPointervINTEL (GLint, GLenum, const GLvoid* *); +GLAPI void APIENTRY glTexCoordPointervINTEL (GLint, GLenum, const GLvoid* *); +#endif /* GL_GLEXT_PROTOTYPES */ +typedef void (APIENTRYP PFNGLVERTEXPOINTERVINTELPROC) (GLint size, GLenum type, const GLvoid* *pointer); +typedef void (APIENTRYP PFNGLNORMALPOINTERVINTELPROC) (GLenum type, const GLvoid* *pointer); +typedef void (APIENTRYP PFNGLCOLORPOINTERVINTELPROC) (GLint size, GLenum type, const GLvoid* *pointer); +typedef void (APIENTRYP PFNGLTEXCOORDPOINTERVINTELPROC) (GLint size, GLenum type, const GLvoid* *pointer); +#endif + +#ifndef GL_HP_occlusion_test +#define GL_HP_occlusion_test 1 +#endif + +#ifndef GL_EXT_pixel_transform +#define GL_EXT_pixel_transform 1 +#ifdef GL_GLEXT_PROTOTYPES +GLAPI void APIENTRY glPixelTransformParameteriEXT (GLenum, GLenum, GLint); +GLAPI void APIENTRY glPixelTransformParameterfEXT (GLenum, GLenum, GLfloat); +GLAPI void APIENTRY glPixelTransformParameterivEXT (GLenum, GLenum, const GLint *); +GLAPI void APIENTRY glPixelTransformParameterfvEXT (GLenum, GLenum, const GLfloat *); +#endif /* GL_GLEXT_PROTOTYPES */ +typedef void (APIENTRYP PFNGLPIXELTRANSFORMPARAMETERIEXTPROC) (GLenum target, GLenum pname, GLint param); +typedef void (APIENTRYP PFNGLPIXELTRANSFORMPARAMETERFEXTPROC) (GLenum target, GLenum pname, GLfloat param); +typedef void (APIENTRYP PFNGLPIXELTRANSFORMPARAMETERIVEXTPROC) (GLenum target, GLenum pname, const GLint *params); +typedef void (APIENTRYP PFNGLPIXELTRANSFORMPARAMETERFVEXTPROC) (GLenum target, GLenum pname, const GLfloat *params); +#endif + +#ifndef GL_EXT_pixel_transform_color_table +#define GL_EXT_pixel_transform_color_table 1 +#endif + +#ifndef GL_EXT_shared_texture_palette +#define GL_EXT_shared_texture_palette 1 +#endif + +#ifndef GL_EXT_separate_specular_color +#define GL_EXT_separate_specular_color 1 +#endif + +#ifndef GL_EXT_secondary_color +#define GL_EXT_secondary_color 1 +#ifdef GL_GLEXT_PROTOTYPES +GLAPI void APIENTRY glSecondaryColor3bEXT (GLbyte, GLbyte, GLbyte); +GLAPI void APIENTRY glSecondaryColor3bvEXT (const GLbyte *); +GLAPI void APIENTRY glSecondaryColor3dEXT (GLdouble, GLdouble, GLdouble); +GLAPI void APIENTRY glSecondaryColor3dvEXT (const GLdouble *); +GLAPI void APIENTRY glSecondaryColor3fEXT (GLfloat, GLfloat, GLfloat); +GLAPI void APIENTRY glSecondaryColor3fvEXT (const GLfloat *); +GLAPI void APIENTRY glSecondaryColor3iEXT (GLint, GLint, GLint); +GLAPI void APIENTRY glSecondaryColor3ivEXT (const GLint *); +GLAPI void APIENTRY glSecondaryColor3sEXT (GLshort, GLshort, GLshort); +GLAPI void APIENTRY glSecondaryColor3svEXT (const GLshort *); +GLAPI void APIENTRY glSecondaryColor3ubEXT (GLubyte, GLubyte, GLubyte); +GLAPI void APIENTRY glSecondaryColor3ubvEXT (const GLubyte *); +GLAPI void APIENTRY glSecondaryColor3uiEXT (GLuint, GLuint, GLuint); +GLAPI void APIENTRY glSecondaryColor3uivEXT (const GLuint *); +GLAPI void APIENTRY glSecondaryColor3usEXT (GLushort, GLushort, GLushort); +GLAPI void APIENTRY glSecondaryColor3usvEXT (const GLushort *); +GLAPI void APIENTRY glSecondaryColorPointerEXT (GLint, GLenum, GLsizei, const GLvoid *); +#endif /* GL_GLEXT_PROTOTYPES */ +typedef void (APIENTRYP PFNGLSECONDARYCOLOR3BEXTPROC) (GLbyte red, GLbyte green, GLbyte blue); +typedef void (APIENTRYP PFNGLSECONDARYCOLOR3BVEXTPROC) (const GLbyte *v); +typedef void (APIENTRYP PFNGLSECONDARYCOLOR3DEXTPROC) (GLdouble red, GLdouble green, GLdouble blue); +typedef void (APIENTRYP PFNGLSECONDARYCOLOR3DVEXTPROC) (const GLdouble *v); +typedef void (APIENTRYP PFNGLSECONDARYCOLOR3FEXTPROC) (GLfloat red, GLfloat green, GLfloat blue); +typedef void (APIENTRYP PFNGLSECONDARYCOLOR3FVEXTPROC) (const GLfloat *v); +typedef void (APIENTRYP PFNGLSECONDARYCOLOR3IEXTPROC) (GLint red, GLint green, GLint blue); +typedef void (APIENTRYP PFNGLSECONDARYCOLOR3IVEXTPROC) (const GLint *v); +typedef void (APIENTRYP PFNGLSECONDARYCOLOR3SEXTPROC) (GLshort red, GLshort green, GLshort blue); +typedef void (APIENTRYP PFNGLSECONDARYCOLOR3SVEXTPROC) (const GLshort *v); +typedef void (APIENTRYP PFNGLSECONDARYCOLOR3UBEXTPROC) (GLubyte red, GLubyte green, GLubyte blue); +typedef void (APIENTRYP PFNGLSECONDARYCOLOR3UBVEXTPROC) (const GLubyte *v); +typedef void (APIENTRYP PFNGLSECONDARYCOLOR3UIEXTPROC) (GLuint red, GLuint green, GLuint blue); +typedef void (APIENTRYP PFNGLSECONDARYCOLOR3UIVEXTPROC) (const GLuint *v); +typedef void (APIENTRYP PFNGLSECONDARYCOLOR3USEXTPROC) (GLushort red, GLushort green, GLushort blue); +typedef void (APIENTRYP PFNGLSECONDARYCOLOR3USVEXTPROC) (const GLushort *v); +typedef void (APIENTRYP PFNGLSECONDARYCOLORPOINTEREXTPROC) (GLint size, GLenum type, GLsizei stride, const GLvoid *pointer); +#endif + +#ifndef GL_EXT_texture_perturb_normal +#define GL_EXT_texture_perturb_normal 1 +#ifdef GL_GLEXT_PROTOTYPES +GLAPI void APIENTRY glTextureNormalEXT (GLenum); +#endif /* GL_GLEXT_PROTOTYPES */ +typedef void (APIENTRYP PFNGLTEXTURENORMALEXTPROC) (GLenum mode); +#endif + +#ifndef GL_EXT_multi_draw_arrays +#define GL_EXT_multi_draw_arrays 1 +#ifdef GL_GLEXT_PROTOTYPES +GLAPI void APIENTRY glMultiDrawArraysEXT (GLenum, GLint *, GLsizei *, GLsizei); +GLAPI void APIENTRY glMultiDrawElementsEXT (GLenum, const GLsizei *, GLenum, const GLvoid* *, GLsizei); +#endif /* GL_GLEXT_PROTOTYPES */ +typedef void (APIENTRYP PFNGLMULTIDRAWARRAYSEXTPROC) (GLenum mode, GLint *first, GLsizei *count, GLsizei primcount); +typedef void (APIENTRYP PFNGLMULTIDRAWELEMENTSEXTPROC) (GLenum mode, const GLsizei *count, GLenum type, const GLvoid* *indices, GLsizei primcount); +#endif + +#ifndef GL_EXT_fog_coord +#define GL_EXT_fog_coord 1 +#ifdef GL_GLEXT_PROTOTYPES +GLAPI void APIENTRY glFogCoordfEXT (GLfloat); +GLAPI void APIENTRY glFogCoordfvEXT (const GLfloat *); +GLAPI void APIENTRY glFogCoorddEXT (GLdouble); +GLAPI void APIENTRY glFogCoorddvEXT (const GLdouble *); +GLAPI void APIENTRY glFogCoordPointerEXT (GLenum, GLsizei, const GLvoid *); +#endif /* GL_GLEXT_PROTOTYPES */ +typedef void (APIENTRYP PFNGLFOGCOORDFEXTPROC) (GLfloat coord); +typedef void (APIENTRYP PFNGLFOGCOORDFVEXTPROC) (const GLfloat *coord); +typedef void (APIENTRYP PFNGLFOGCOORDDEXTPROC) (GLdouble coord); +typedef void (APIENTRYP PFNGLFOGCOORDDVEXTPROC) (const GLdouble *coord); +typedef void (APIENTRYP PFNGLFOGCOORDPOINTEREXTPROC) (GLenum type, GLsizei stride, const GLvoid *pointer); +#endif + +#ifndef GL_REND_screen_coordinates +#define GL_REND_screen_coordinates 1 +#endif + +#ifndef GL_EXT_coordinate_frame +#define GL_EXT_coordinate_frame 1 +#ifdef GL_GLEXT_PROTOTYPES +GLAPI void APIENTRY glTangent3bEXT (GLbyte, GLbyte, GLbyte); +GLAPI void APIENTRY glTangent3bvEXT (const GLbyte *); +GLAPI void APIENTRY glTangent3dEXT (GLdouble, GLdouble, GLdouble); +GLAPI void APIENTRY glTangent3dvEXT (const GLdouble *); +GLAPI void APIENTRY glTangent3fEXT (GLfloat, GLfloat, GLfloat); +GLAPI void APIENTRY glTangent3fvEXT (const GLfloat *); +GLAPI void APIENTRY glTangent3iEXT (GLint, GLint, GLint); +GLAPI void APIENTRY glTangent3ivEXT (const GLint *); +GLAPI void APIENTRY glTangent3sEXT (GLshort, GLshort, GLshort); +GLAPI void APIENTRY glTangent3svEXT (const GLshort *); +GLAPI void APIENTRY glBinormal3bEXT (GLbyte, GLbyte, GLbyte); +GLAPI void APIENTRY glBinormal3bvEXT (const GLbyte *); +GLAPI void APIENTRY glBinormal3dEXT (GLdouble, GLdouble, GLdouble); +GLAPI void APIENTRY glBinormal3dvEXT (const GLdouble *); +GLAPI void APIENTRY glBinormal3fEXT (GLfloat, GLfloat, GLfloat); +GLAPI void APIENTRY glBinormal3fvEXT (const GLfloat *); +GLAPI void APIENTRY glBinormal3iEXT (GLint, GLint, GLint); +GLAPI void APIENTRY glBinormal3ivEXT (const GLint *); +GLAPI void APIENTRY glBinormal3sEXT (GLshort, GLshort, GLshort); +GLAPI void APIENTRY glBinormal3svEXT (const GLshort *); +GLAPI void APIENTRY glTangentPointerEXT (GLenum, GLsizei, const GLvoid *); +GLAPI void APIENTRY glBinormalPointerEXT (GLenum, GLsizei, const GLvoid *); +#endif /* GL_GLEXT_PROTOTYPES */ +typedef void (APIENTRYP PFNGLTANGENT3BEXTPROC) (GLbyte tx, GLbyte ty, GLbyte tz); +typedef void (APIENTRYP PFNGLTANGENT3BVEXTPROC) (const GLbyte *v); +typedef void (APIENTRYP PFNGLTANGENT3DEXTPROC) (GLdouble tx, GLdouble ty, GLdouble tz); +typedef void (APIENTRYP PFNGLTANGENT3DVEXTPROC) (const GLdouble *v); +typedef void (APIENTRYP PFNGLTANGENT3FEXTPROC) (GLfloat tx, GLfloat ty, GLfloat tz); +typedef void (APIENTRYP PFNGLTANGENT3FVEXTPROC) (const GLfloat *v); +typedef void (APIENTRYP PFNGLTANGENT3IEXTPROC) (GLint tx, GLint ty, GLint tz); +typedef void (APIENTRYP PFNGLTANGENT3IVEXTPROC) (const GLint *v); +typedef void (APIENTRYP PFNGLTANGENT3SEXTPROC) (GLshort tx, GLshort ty, GLshort tz); +typedef void (APIENTRYP PFNGLTANGENT3SVEXTPROC) (const GLshort *v); +typedef void (APIENTRYP PFNGLBINORMAL3BEXTPROC) (GLbyte bx, GLbyte by, GLbyte bz); +typedef void (APIENTRYP PFNGLBINORMAL3BVEXTPROC) (const GLbyte *v); +typedef void (APIENTRYP PFNGLBINORMAL3DEXTPROC) (GLdouble bx, GLdouble by, GLdouble bz); +typedef void (APIENTRYP PFNGLBINORMAL3DVEXTPROC) (const GLdouble *v); +typedef void (APIENTRYP PFNGLBINORMAL3FEXTPROC) (GLfloat bx, GLfloat by, GLfloat bz); +typedef void (APIENTRYP PFNGLBINORMAL3FVEXTPROC) (const GLfloat *v); +typedef void (APIENTRYP PFNGLBINORMAL3IEXTPROC) (GLint bx, GLint by, GLint bz); +typedef void (APIENTRYP PFNGLBINORMAL3IVEXTPROC) (const GLint *v); +typedef void (APIENTRYP PFNGLBINORMAL3SEXTPROC) (GLshort bx, GLshort by, GLshort bz); +typedef void (APIENTRYP PFNGLBINORMAL3SVEXTPROC) (const GLshort *v); +typedef void (APIENTRYP PFNGLTANGENTPOINTEREXTPROC) (GLenum type, GLsizei stride, const GLvoid *pointer); +typedef void (APIENTRYP PFNGLBINORMALPOINTEREXTPROC) (GLenum type, GLsizei stride, const GLvoid *pointer); +#endif + +#ifndef GL_EXT_texture_env_combine +#define GL_EXT_texture_env_combine 1 +#endif + +#ifndef GL_APPLE_specular_vector +#define GL_APPLE_specular_vector 1 +#endif + +#ifndef GL_APPLE_transform_hint +#define GL_APPLE_transform_hint 1 +#endif + +#ifndef GL_SGIX_fog_scale +#define GL_SGIX_fog_scale 1 +#endif + +#ifndef GL_SUNX_constant_data +#define GL_SUNX_constant_data 1 +#ifdef GL_GLEXT_PROTOTYPES +GLAPI void APIENTRY glFinishTextureSUNX (void); +#endif /* GL_GLEXT_PROTOTYPES */ +typedef void (APIENTRYP PFNGLFINISHTEXTURESUNXPROC) (void); +#endif + +#ifndef GL_SUN_global_alpha +#define GL_SUN_global_alpha 1 +#ifdef GL_GLEXT_PROTOTYPES +GLAPI void APIENTRY glGlobalAlphaFactorbSUN (GLbyte); +GLAPI void APIENTRY glGlobalAlphaFactorsSUN (GLshort); +GLAPI void APIENTRY glGlobalAlphaFactoriSUN (GLint); +GLAPI void APIENTRY glGlobalAlphaFactorfSUN (GLfloat); +GLAPI void APIENTRY glGlobalAlphaFactordSUN (GLdouble); +GLAPI void APIENTRY glGlobalAlphaFactorubSUN (GLubyte); +GLAPI void APIENTRY glGlobalAlphaFactorusSUN (GLushort); +GLAPI void APIENTRY glGlobalAlphaFactoruiSUN (GLuint); +#endif /* GL_GLEXT_PROTOTYPES */ +typedef void (APIENTRYP PFNGLGLOBALALPHAFACTORBSUNPROC) (GLbyte factor); +typedef void (APIENTRYP PFNGLGLOBALALPHAFACTORSSUNPROC) (GLshort factor); +typedef void (APIENTRYP PFNGLGLOBALALPHAFACTORISUNPROC) (GLint factor); +typedef void (APIENTRYP PFNGLGLOBALALPHAFACTORFSUNPROC) (GLfloat factor); +typedef void (APIENTRYP PFNGLGLOBALALPHAFACTORDSUNPROC) (GLdouble factor); +typedef void (APIENTRYP PFNGLGLOBALALPHAFACTORUBSUNPROC) (GLubyte factor); +typedef void (APIENTRYP PFNGLGLOBALALPHAFACTORUSSUNPROC) (GLushort factor); +typedef void (APIENTRYP PFNGLGLOBALALPHAFACTORUISUNPROC) (GLuint factor); +#endif + +#ifndef GL_SUN_triangle_list +#define GL_SUN_triangle_list 1 +#ifdef GL_GLEXT_PROTOTYPES +GLAPI void APIENTRY glReplacementCodeuiSUN (GLuint); +GLAPI void APIENTRY glReplacementCodeusSUN (GLushort); +GLAPI void APIENTRY glReplacementCodeubSUN (GLubyte); +GLAPI void APIENTRY glReplacementCodeuivSUN (const GLuint *); +GLAPI void APIENTRY glReplacementCodeusvSUN (const GLushort *); +GLAPI void APIENTRY glReplacementCodeubvSUN (const GLubyte *); +GLAPI void APIENTRY glReplacementCodePointerSUN (GLenum, GLsizei, const GLvoid* *); +#endif /* GL_GLEXT_PROTOTYPES */ +typedef void (APIENTRYP PFNGLREPLACEMENTCODEUISUNPROC) (GLuint code); +typedef void (APIENTRYP PFNGLREPLACEMENTCODEUSSUNPROC) (GLushort code); +typedef void (APIENTRYP PFNGLREPLACEMENTCODEUBSUNPROC) (GLubyte code); +typedef void (APIENTRYP PFNGLREPLACEMENTCODEUIVSUNPROC) (const GLuint *code); +typedef void (APIENTRYP PFNGLREPLACEMENTCODEUSVSUNPROC) (const GLushort *code); +typedef void (APIENTRYP PFNGLREPLACEMENTCODEUBVSUNPROC) (const GLubyte *code); +typedef void (APIENTRYP PFNGLREPLACEMENTCODEPOINTERSUNPROC) (GLenum type, GLsizei stride, const GLvoid* *pointer); +#endif + +#ifndef GL_SUN_vertex +#define GL_SUN_vertex 1 +#ifdef GL_GLEXT_PROTOTYPES +GLAPI void APIENTRY glColor4ubVertex2fSUN (GLubyte, GLubyte, GLubyte, GLubyte, GLfloat, GLfloat); +GLAPI void APIENTRY glColor4ubVertex2fvSUN (const GLubyte *, const GLfloat *); +GLAPI void APIENTRY glColor4ubVertex3fSUN (GLubyte, GLubyte, GLubyte, GLubyte, GLfloat, GLfloat, GLfloat); +GLAPI void APIENTRY glColor4ubVertex3fvSUN (const GLubyte *, const GLfloat *); +GLAPI void APIENTRY glColor3fVertex3fSUN (GLfloat, GLfloat, GLfloat, GLfloat, GLfloat, GLfloat); +GLAPI void APIENTRY glColor3fVertex3fvSUN (const GLfloat *, const GLfloat *); +GLAPI void APIENTRY glNormal3fVertex3fSUN (GLfloat, GLfloat, GLfloat, GLfloat, GLfloat, GLfloat); +GLAPI void APIENTRY glNormal3fVertex3fvSUN (const GLfloat *, const GLfloat *); +GLAPI void APIENTRY glColor4fNormal3fVertex3fSUN (GLfloat, GLfloat, GLfloat, GLfloat, GLfloat, GLfloat, GLfloat, GLfloat, GLfloat, GLfloat); +GLAPI void APIENTRY glColor4fNormal3fVertex3fvSUN (const GLfloat *, const GLfloat *, const GLfloat *); +GLAPI void APIENTRY glTexCoord2fVertex3fSUN (GLfloat, GLfloat, GLfloat, GLfloat, GLfloat); +GLAPI void APIENTRY glTexCoord2fVertex3fvSUN (const GLfloat *, const GLfloat *); +GLAPI void APIENTRY glTexCoord4fVertex4fSUN (GLfloat, GLfloat, GLfloat, GLfloat, GLfloat, GLfloat, GLfloat, GLfloat); +GLAPI void APIENTRY glTexCoord4fVertex4fvSUN (const GLfloat *, const GLfloat *); +GLAPI void APIENTRY glTexCoord2fColor4ubVertex3fSUN (GLfloat, GLfloat, GLubyte, GLubyte, GLubyte, GLubyte, GLfloat, GLfloat, GLfloat); +GLAPI void APIENTRY glTexCoord2fColor4ubVertex3fvSUN (const GLfloat *, const GLubyte *, const GLfloat *); +GLAPI void APIENTRY glTexCoord2fColor3fVertex3fSUN (GLfloat, GLfloat, GLfloat, GLfloat, GLfloat, GLfloat, GLfloat, GLfloat); +GLAPI void APIENTRY glTexCoord2fColor3fVertex3fvSUN (const GLfloat *, const GLfloat *, const GLfloat *); +GLAPI void APIENTRY glTexCoord2fNormal3fVertex3fSUN (GLfloat, GLfloat, GLfloat, GLfloat, GLfloat, GLfloat, GLfloat, GLfloat); +GLAPI void APIENTRY glTexCoord2fNormal3fVertex3fvSUN (const GLfloat *, const GLfloat *, const GLfloat *); +GLAPI void APIENTRY glTexCoord2fColor4fNormal3fVertex3fSUN (GLfloat, GLfloat, GLfloat, GLfloat, GLfloat, GLfloat, GLfloat, GLfloat, GLfloat, GLfloat, GLfloat, GLfloat); +GLAPI void APIENTRY glTexCoord2fColor4fNormal3fVertex3fvSUN (const GLfloat *, const GLfloat *, const GLfloat *, const GLfloat *); +GLAPI void APIENTRY glTexCoord4fColor4fNormal3fVertex4fSUN (GLfloat, GLfloat, GLfloat, GLfloat, GLfloat, GLfloat, GLfloat, GLfloat, GLfloat, GLfloat, GLfloat, GLfloat, GLfloat, GLfloat, GLfloat); +GLAPI void APIENTRY glTexCoord4fColor4fNormal3fVertex4fvSUN (const GLfloat *, const GLfloat *, const GLfloat *, const GLfloat *); +GLAPI void APIENTRY glReplacementCodeuiVertex3fSUN (GLuint, GLfloat, GLfloat, GLfloat); +GLAPI void APIENTRY glReplacementCodeuiVertex3fvSUN (const GLuint *, const GLfloat *); +GLAPI void APIENTRY glReplacementCodeuiColor4ubVertex3fSUN (GLuint, GLubyte, GLubyte, GLubyte, GLubyte, GLfloat, GLfloat, GLfloat); +GLAPI void APIENTRY glReplacementCodeuiColor4ubVertex3fvSUN (const GLuint *, const GLubyte *, const GLfloat *); +GLAPI void APIENTRY glReplacementCodeuiColor3fVertex3fSUN (GLuint, GLfloat, GLfloat, GLfloat, GLfloat, GLfloat, GLfloat); +GLAPI void APIENTRY glReplacementCodeuiColor3fVertex3fvSUN (const GLuint *, const GLfloat *, const GLfloat *); +GLAPI void APIENTRY glReplacementCodeuiNormal3fVertex3fSUN (GLuint, GLfloat, GLfloat, GLfloat, GLfloat, GLfloat, GLfloat); +GLAPI void APIENTRY glReplacementCodeuiNormal3fVertex3fvSUN (const GLuint *, const GLfloat *, const GLfloat *); +GLAPI void APIENTRY glReplacementCodeuiColor4fNormal3fVertex3fSUN (GLuint, GLfloat, GLfloat, GLfloat, GLfloat, GLfloat, GLfloat, GLfloat, GLfloat, GLfloat, GLfloat); +GLAPI void APIENTRY glReplacementCodeuiColor4fNormal3fVertex3fvSUN (const GLuint *, const GLfloat *, const GLfloat *, const GLfloat *); +GLAPI void APIENTRY glReplacementCodeuiTexCoord2fVertex3fSUN (GLuint, GLfloat, GLfloat, GLfloat, GLfloat, GLfloat); +GLAPI void APIENTRY glReplacementCodeuiTexCoord2fVertex3fvSUN (const GLuint *, const GLfloat *, const GLfloat *); +GLAPI void APIENTRY glReplacementCodeuiTexCoord2fNormal3fVertex3fSUN (GLuint, GLfloat, GLfloat, GLfloat, GLfloat, GLfloat, GLfloat, GLfloat, GLfloat); +GLAPI void APIENTRY glReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN (const GLuint *, const GLfloat *, const GLfloat *, const GLfloat *); +GLAPI void APIENTRY glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fSUN (GLuint, GLfloat, GLfloat, GLfloat, GLfloat, GLfloat, GLfloat, GLfloat, GLfloat, GLfloat, GLfloat, GLfloat, GLfloat); +GLAPI void APIENTRY glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN (const GLuint *, const GLfloat *, const GLfloat *, const GLfloat *, const GLfloat *); +#endif /* GL_GLEXT_PROTOTYPES */ +typedef void (APIENTRYP PFNGLCOLOR4UBVERTEX2FSUNPROC) (GLubyte r, GLubyte g, GLubyte b, GLubyte a, GLfloat x, GLfloat y); +typedef void (APIENTRYP PFNGLCOLOR4UBVERTEX2FVSUNPROC) (const GLubyte *c, const GLfloat *v); +typedef void (APIENTRYP PFNGLCOLOR4UBVERTEX3FSUNPROC) (GLubyte r, GLubyte g, GLubyte b, GLubyte a, GLfloat x, GLfloat y, GLfloat z); +typedef void (APIENTRYP PFNGLCOLOR4UBVERTEX3FVSUNPROC) (const GLubyte *c, const GLfloat *v); +typedef void (APIENTRYP PFNGLCOLOR3FVERTEX3FSUNPROC) (GLfloat r, GLfloat g, GLfloat b, GLfloat x, GLfloat y, GLfloat z); +typedef void (APIENTRYP PFNGLCOLOR3FVERTEX3FVSUNPROC) (const GLfloat *c, const GLfloat *v); +typedef void (APIENTRYP PFNGLNORMAL3FVERTEX3FSUNPROC) (GLfloat nx, GLfloat ny, GLfloat nz, GLfloat x, GLfloat y, GLfloat z); +typedef void (APIENTRYP PFNGLNORMAL3FVERTEX3FVSUNPROC) (const GLfloat *n, const GLfloat *v); +typedef void (APIENTRYP PFNGLCOLOR4FNORMAL3FVERTEX3FSUNPROC) (GLfloat r, GLfloat g, GLfloat b, GLfloat a, GLfloat nx, GLfloat ny, GLfloat nz, GLfloat x, GLfloat y, GLfloat z); +typedef void (APIENTRYP PFNGLCOLOR4FNORMAL3FVERTEX3FVSUNPROC) (const GLfloat *c, const GLfloat *n, const GLfloat *v); +typedef void (APIENTRYP PFNGLTEXCOORD2FVERTEX3FSUNPROC) (GLfloat s, GLfloat t, GLfloat x, GLfloat y, GLfloat z); +typedef void (APIENTRYP PFNGLTEXCOORD2FVERTEX3FVSUNPROC) (const GLfloat *tc, const GLfloat *v); +typedef void (APIENTRYP PFNGLTEXCOORD4FVERTEX4FSUNPROC) (GLfloat s, GLfloat t, GLfloat p, GLfloat q, GLfloat x, GLfloat y, GLfloat z, GLfloat w); +typedef void (APIENTRYP PFNGLTEXCOORD4FVERTEX4FVSUNPROC) (const GLfloat *tc, const GLfloat *v); +typedef void (APIENTRYP PFNGLTEXCOORD2FCOLOR4UBVERTEX3FSUNPROC) (GLfloat s, GLfloat t, GLubyte r, GLubyte g, GLubyte b, GLubyte a, GLfloat x, GLfloat y, GLfloat z); +typedef void (APIENTRYP PFNGLTEXCOORD2FCOLOR4UBVERTEX3FVSUNPROC) (const GLfloat *tc, const GLubyte *c, const GLfloat *v); +typedef void (APIENTRYP PFNGLTEXCOORD2FCOLOR3FVERTEX3FSUNPROC) (GLfloat s, GLfloat t, GLfloat r, GLfloat g, GLfloat b, GLfloat x, GLfloat y, GLfloat z); +typedef void (APIENTRYP PFNGLTEXCOORD2FCOLOR3FVERTEX3FVSUNPROC) (const GLfloat *tc, const GLfloat *c, const GLfloat *v); +typedef void (APIENTRYP PFNGLTEXCOORD2FNORMAL3FVERTEX3FSUNPROC) (GLfloat s, GLfloat t, GLfloat nx, GLfloat ny, GLfloat nz, GLfloat x, GLfloat y, GLfloat z); +typedef void (APIENTRYP PFNGLTEXCOORD2FNORMAL3FVERTEX3FVSUNPROC) (const GLfloat *tc, const GLfloat *n, const GLfloat *v); +typedef void (APIENTRYP PFNGLTEXCOORD2FCOLOR4FNORMAL3FVERTEX3FSUNPROC) (GLfloat s, GLfloat t, GLfloat r, GLfloat g, GLfloat b, GLfloat a, GLfloat nx, GLfloat ny, GLfloat nz, GLfloat x, GLfloat y, GLfloat z); +typedef void (APIENTRYP PFNGLTEXCOORD2FCOLOR4FNORMAL3FVERTEX3FVSUNPROC) (const GLfloat *tc, const GLfloat *c, const GLfloat *n, const GLfloat *v); +typedef void (APIENTRYP PFNGLTEXCOORD4FCOLOR4FNORMAL3FVERTEX4FSUNPROC) (GLfloat s, GLfloat t, GLfloat p, GLfloat q, GLfloat r, GLfloat g, GLfloat b, GLfloat a, GLfloat nx, GLfloat ny, GLfloat nz, GLfloat x, GLfloat y, GLfloat z, GLfloat w); +typedef void (APIENTRYP PFNGLTEXCOORD4FCOLOR4FNORMAL3FVERTEX4FVSUNPROC) (const GLfloat *tc, const GLfloat *c, const GLfloat *n, const GLfloat *v); +typedef void (APIENTRYP PFNGLREPLACEMENTCODEUIVERTEX3FSUNPROC) (GLuint rc, GLfloat x, GLfloat y, GLfloat z); +typedef void (APIENTRYP PFNGLREPLACEMENTCODEUIVERTEX3FVSUNPROC) (const GLuint *rc, const GLfloat *v); +typedef void (APIENTRYP PFNGLREPLACEMENTCODEUICOLOR4UBVERTEX3FSUNPROC) (GLuint rc, GLubyte r, GLubyte g, GLubyte b, GLubyte a, GLfloat x, GLfloat y, GLfloat z); +typedef void (APIENTRYP PFNGLREPLACEMENTCODEUICOLOR4UBVERTEX3FVSUNPROC) (const GLuint *rc, const GLubyte *c, const GLfloat *v); +typedef void (APIENTRYP PFNGLREPLACEMENTCODEUICOLOR3FVERTEX3FSUNPROC) (GLuint rc, GLfloat r, GLfloat g, GLfloat b, GLfloat x, GLfloat y, GLfloat z); +typedef void (APIENTRYP PFNGLREPLACEMENTCODEUICOLOR3FVERTEX3FVSUNPROC) (const GLuint *rc, const GLfloat *c, const GLfloat *v); +typedef void (APIENTRYP PFNGLREPLACEMENTCODEUINORMAL3FVERTEX3FSUNPROC) (GLuint rc, GLfloat nx, GLfloat ny, GLfloat nz, GLfloat x, GLfloat y, GLfloat z); +typedef void (APIENTRYP PFNGLREPLACEMENTCODEUINORMAL3FVERTEX3FVSUNPROC) (const GLuint *rc, const GLfloat *n, const GLfloat *v); +typedef void (APIENTRYP PFNGLREPLACEMENTCODEUICOLOR4FNORMAL3FVERTEX3FSUNPROC) (GLuint rc, GLfloat r, GLfloat g, GLfloat b, GLfloat a, GLfloat nx, GLfloat ny, GLfloat nz, GLfloat x, GLfloat y, GLfloat z); +typedef void (APIENTRYP PFNGLREPLACEMENTCODEUICOLOR4FNORMAL3FVERTEX3FVSUNPROC) (const GLuint *rc, const GLfloat *c, const GLfloat *n, const GLfloat *v); +typedef void (APIENTRYP PFNGLREPLACEMENTCODEUITEXCOORD2FVERTEX3FSUNPROC) (GLuint rc, GLfloat s, GLfloat t, GLfloat x, GLfloat y, GLfloat z); +typedef void (APIENTRYP PFNGLREPLACEMENTCODEUITEXCOORD2FVERTEX3FVSUNPROC) (const GLuint *rc, const GLfloat *tc, const GLfloat *v); +typedef void (APIENTRYP PFNGLREPLACEMENTCODEUITEXCOORD2FNORMAL3FVERTEX3FSUNPROC) (GLuint rc, GLfloat s, GLfloat t, GLfloat nx, GLfloat ny, GLfloat nz, GLfloat x, GLfloat y, GLfloat z); +typedef void (APIENTRYP PFNGLREPLACEMENTCODEUITEXCOORD2FNORMAL3FVERTEX3FVSUNPROC) (const GLuint *rc, const GLfloat *tc, const GLfloat *n, const GLfloat *v); +typedef void (APIENTRYP PFNGLREPLACEMENTCODEUITEXCOORD2FCOLOR4FNORMAL3FVERTEX3FSUNPROC) (GLuint rc, GLfloat s, GLfloat t, GLfloat r, GLfloat g, GLfloat b, GLfloat a, GLfloat nx, GLfloat ny, GLfloat nz, GLfloat x, GLfloat y, GLfloat z); +typedef void (APIENTRYP PFNGLREPLACEMENTCODEUITEXCOORD2FCOLOR4FNORMAL3FVERTEX3FVSUNPROC) (const GLuint *rc, const GLfloat *tc, const GLfloat *c, const GLfloat *n, const GLfloat *v); +#endif + +#ifndef GL_EXT_blend_func_separate +#define GL_EXT_blend_func_separate 1 +#ifdef GL_GLEXT_PROTOTYPES +GLAPI void APIENTRY glBlendFuncSeparateEXT (GLenum, GLenum, GLenum, GLenum); +#endif /* GL_GLEXT_PROTOTYPES */ +typedef void (APIENTRYP PFNGLBLENDFUNCSEPARATEEXTPROC) (GLenum sfactorRGB, GLenum dfactorRGB, GLenum sfactorAlpha, GLenum dfactorAlpha); +#endif + +#ifndef GL_INGR_blend_func_separate +#define GL_INGR_blend_func_separate 1 +#ifdef GL_GLEXT_PROTOTYPES +GLAPI void APIENTRY glBlendFuncSeparateINGR (GLenum, GLenum, GLenum, GLenum); +#endif /* GL_GLEXT_PROTOTYPES */ +typedef void (APIENTRYP PFNGLBLENDFUNCSEPARATEINGRPROC) (GLenum sfactorRGB, GLenum dfactorRGB, GLenum sfactorAlpha, GLenum dfactorAlpha); +#endif + +#ifndef GL_INGR_color_clamp +#define GL_INGR_color_clamp 1 +#endif + +#ifndef GL_INGR_interlace_read +#define GL_INGR_interlace_read 1 +#endif + +#ifndef GL_EXT_stencil_wrap +#define GL_EXT_stencil_wrap 1 +#endif + +#ifndef GL_EXT_422_pixels +#define GL_EXT_422_pixels 1 +#endif + +#ifndef GL_NV_texgen_reflection +#define GL_NV_texgen_reflection 1 +#endif + +#ifndef GL_SUN_convolution_border_modes +#define GL_SUN_convolution_border_modes 1 +#endif + +#ifndef GL_EXT_texture_env_add +#define GL_EXT_texture_env_add 1 +#endif + +#ifndef GL_EXT_texture_lod_bias +#define GL_EXT_texture_lod_bias 1 +#endif + +#ifndef GL_EXT_texture_filter_anisotropic +#define GL_EXT_texture_filter_anisotropic 1 +#endif + +#ifndef GL_EXT_vertex_weighting +#define GL_EXT_vertex_weighting 1 +#ifdef GL_GLEXT_PROTOTYPES +GLAPI void APIENTRY glVertexWeightfEXT (GLfloat); +GLAPI void APIENTRY glVertexWeightfvEXT (const GLfloat *); +GLAPI void APIENTRY glVertexWeightPointerEXT (GLsizei, GLenum, GLsizei, const GLvoid *); +#endif /* GL_GLEXT_PROTOTYPES */ +typedef void (APIENTRYP PFNGLVERTEXWEIGHTFEXTPROC) (GLfloat weight); +typedef void (APIENTRYP PFNGLVERTEXWEIGHTFVEXTPROC) (const GLfloat *weight); +typedef void (APIENTRYP PFNGLVERTEXWEIGHTPOINTEREXTPROC) (GLsizei size, GLenum type, GLsizei stride, const GLvoid *pointer); +#endif + +#ifndef GL_NV_light_max_exponent +#define GL_NV_light_max_exponent 1 +#endif + +#ifndef GL_NV_vertex_array_range +#define GL_NV_vertex_array_range 1 +#ifdef GL_GLEXT_PROTOTYPES +GLAPI void APIENTRY glFlushVertexArrayRangeNV (void); +GLAPI void APIENTRY glVertexArrayRangeNV (GLsizei, const GLvoid *); +#endif /* GL_GLEXT_PROTOTYPES */ +typedef void (APIENTRYP PFNGLFLUSHVERTEXARRAYRANGENVPROC) (void); +typedef void (APIENTRYP PFNGLVERTEXARRAYRANGENVPROC) (GLsizei length, const GLvoid *pointer); +#endif + +#ifndef GL_NV_register_combiners +#define GL_NV_register_combiners 1 +#ifdef GL_GLEXT_PROTOTYPES +GLAPI void APIENTRY glCombinerParameterfvNV (GLenum, const GLfloat *); +GLAPI void APIENTRY glCombinerParameterfNV (GLenum, GLfloat); +GLAPI void APIENTRY glCombinerParameterivNV (GLenum, const GLint *); +GLAPI void APIENTRY glCombinerParameteriNV (GLenum, GLint); +GLAPI void APIENTRY glCombinerInputNV (GLenum, GLenum, GLenum, GLenum, GLenum, GLenum); +GLAPI void APIENTRY glCombinerOutputNV (GLenum, GLenum, GLenum, GLenum, GLenum, GLenum, GLenum, GLboolean, GLboolean, GLboolean); +GLAPI void APIENTRY glFinalCombinerInputNV (GLenum, GLenum, GLenum, GLenum); +GLAPI void APIENTRY glGetCombinerInputParameterfvNV (GLenum, GLenum, GLenum, GLenum, GLfloat *); +GLAPI void APIENTRY glGetCombinerInputParameterivNV (GLenum, GLenum, GLenum, GLenum, GLint *); +GLAPI void APIENTRY glGetCombinerOutputParameterfvNV (GLenum, GLenum, GLenum, GLfloat *); +GLAPI void APIENTRY glGetCombinerOutputParameterivNV (GLenum, GLenum, GLenum, GLint *); +GLAPI void APIENTRY glGetFinalCombinerInputParameterfvNV (GLenum, GLenum, GLfloat *); +GLAPI void APIENTRY glGetFinalCombinerInputParameterivNV (GLenum, GLenum, GLint *); +#endif /* GL_GLEXT_PROTOTYPES */ +typedef void (APIENTRYP PFNGLCOMBINERPARAMETERFVNVPROC) (GLenum pname, const GLfloat *params); +typedef void (APIENTRYP PFNGLCOMBINERPARAMETERFNVPROC) (GLenum pname, GLfloat param); +typedef void (APIENTRYP PFNGLCOMBINERPARAMETERIVNVPROC) (GLenum pname, const GLint *params); +typedef void (APIENTRYP PFNGLCOMBINERPARAMETERINVPROC) (GLenum pname, GLint param); +typedef void (APIENTRYP PFNGLCOMBINERINPUTNVPROC) (GLenum stage, GLenum portion, GLenum variable, GLenum input, GLenum mapping, GLenum componentUsage); +typedef void (APIENTRYP PFNGLCOMBINEROUTPUTNVPROC) (GLenum stage, GLenum portion, GLenum abOutput, GLenum cdOutput, GLenum sumOutput, GLenum scale, GLenum bias, GLboolean abDotProduct, GLboolean cdDotProduct, GLboolean muxSum); +typedef void (APIENTRYP PFNGLFINALCOMBINERINPUTNVPROC) (GLenum variable, GLenum input, GLenum mapping, GLenum componentUsage); +typedef void (APIENTRYP PFNGLGETCOMBINERINPUTPARAMETERFVNVPROC) (GLenum stage, GLenum portion, GLenum variable, GLenum pname, GLfloat *params); +typedef void (APIENTRYP PFNGLGETCOMBINERINPUTPARAMETERIVNVPROC) (GLenum stage, GLenum portion, GLenum variable, GLenum pname, GLint *params); +typedef void (APIENTRYP PFNGLGETCOMBINEROUTPUTPARAMETERFVNVPROC) (GLenum stage, GLenum portion, GLenum pname, GLfloat *params); +typedef void (APIENTRYP PFNGLGETCOMBINEROUTPUTPARAMETERIVNVPROC) (GLenum stage, GLenum portion, GLenum pname, GLint *params); +typedef void (APIENTRYP PFNGLGETFINALCOMBINERINPUTPARAMETERFVNVPROC) (GLenum variable, GLenum pname, GLfloat *params); +typedef void (APIENTRYP PFNGLGETFINALCOMBINERINPUTPARAMETERIVNVPROC) (GLenum variable, GLenum pname, GLint *params); +#endif + +#ifndef GL_NV_fog_distance +#define GL_NV_fog_distance 1 +#endif + +#ifndef GL_NV_texgen_emboss +#define GL_NV_texgen_emboss 1 +#endif + +#ifndef GL_NV_blend_square +#define GL_NV_blend_square 1 +#endif + +#ifndef GL_NV_texture_env_combine4 +#define GL_NV_texture_env_combine4 1 +#endif + +#ifndef GL_MESA_resize_buffers +#define GL_MESA_resize_buffers 1 +#ifdef GL_GLEXT_PROTOTYPES +GLAPI void APIENTRY glResizeBuffersMESA (void); +#endif /* GL_GLEXT_PROTOTYPES */ +typedef void (APIENTRYP PFNGLRESIZEBUFFERSMESAPROC) (void); +#endif + +#ifndef GL_MESA_window_pos +#define GL_MESA_window_pos 1 +#ifdef GL_GLEXT_PROTOTYPES +GLAPI void APIENTRY glWindowPos2dMESA (GLdouble, GLdouble); +GLAPI void APIENTRY glWindowPos2dvMESA (const GLdouble *); +GLAPI void APIENTRY glWindowPos2fMESA (GLfloat, GLfloat); +GLAPI void APIENTRY glWindowPos2fvMESA (const GLfloat *); +GLAPI void APIENTRY glWindowPos2iMESA (GLint, GLint); +GLAPI void APIENTRY glWindowPos2ivMESA (const GLint *); +GLAPI void APIENTRY glWindowPos2sMESA (GLshort, GLshort); +GLAPI void APIENTRY glWindowPos2svMESA (const GLshort *); +GLAPI void APIENTRY glWindowPos3dMESA (GLdouble, GLdouble, GLdouble); +GLAPI void APIENTRY glWindowPos3dvMESA (const GLdouble *); +GLAPI void APIENTRY glWindowPos3fMESA (GLfloat, GLfloat, GLfloat); +GLAPI void APIENTRY glWindowPos3fvMESA (const GLfloat *); +GLAPI void APIENTRY glWindowPos3iMESA (GLint, GLint, GLint); +GLAPI void APIENTRY glWindowPos3ivMESA (const GLint *); +GLAPI void APIENTRY glWindowPos3sMESA (GLshort, GLshort, GLshort); +GLAPI void APIENTRY glWindowPos3svMESA (const GLshort *); +GLAPI void APIENTRY glWindowPos4dMESA (GLdouble, GLdouble, GLdouble, GLdouble); +GLAPI void APIENTRY glWindowPos4dvMESA (const GLdouble *); +GLAPI void APIENTRY glWindowPos4fMESA (GLfloat, GLfloat, GLfloat, GLfloat); +GLAPI void APIENTRY glWindowPos4fvMESA (const GLfloat *); +GLAPI void APIENTRY glWindowPos4iMESA (GLint, GLint, GLint, GLint); +GLAPI void APIENTRY glWindowPos4ivMESA (const GLint *); +GLAPI void APIENTRY glWindowPos4sMESA (GLshort, GLshort, GLshort, GLshort); +GLAPI void APIENTRY glWindowPos4svMESA (const GLshort *); +#endif /* GL_GLEXT_PROTOTYPES */ +typedef void (APIENTRYP PFNGLWINDOWPOS2DMESAPROC) (GLdouble x, GLdouble y); +typedef void (APIENTRYP PFNGLWINDOWPOS2DVMESAPROC) (const GLdouble *v); +typedef void (APIENTRYP PFNGLWINDOWPOS2FMESAPROC) (GLfloat x, GLfloat y); +typedef void (APIENTRYP PFNGLWINDOWPOS2FVMESAPROC) (const GLfloat *v); +typedef void (APIENTRYP PFNGLWINDOWPOS2IMESAPROC) (GLint x, GLint y); +typedef void (APIENTRYP PFNGLWINDOWPOS2IVMESAPROC) (const GLint *v); +typedef void (APIENTRYP PFNGLWINDOWPOS2SMESAPROC) (GLshort x, GLshort y); +typedef void (APIENTRYP PFNGLWINDOWPOS2SVMESAPROC) (const GLshort *v); +typedef void (APIENTRYP PFNGLWINDOWPOS3DMESAPROC) (GLdouble x, GLdouble y, GLdouble z); +typedef void (APIENTRYP PFNGLWINDOWPOS3DVMESAPROC) (const GLdouble *v); +typedef void (APIENTRYP PFNGLWINDOWPOS3FMESAPROC) (GLfloat x, GLfloat y, GLfloat z); +typedef void (APIENTRYP PFNGLWINDOWPOS3FVMESAPROC) (const GLfloat *v); +typedef void (APIENTRYP PFNGLWINDOWPOS3IMESAPROC) (GLint x, GLint y, GLint z); +typedef void (APIENTRYP PFNGLWINDOWPOS3IVMESAPROC) (const GLint *v); +typedef void (APIENTRYP PFNGLWINDOWPOS3SMESAPROC) (GLshort x, GLshort y, GLshort z); +typedef void (APIENTRYP PFNGLWINDOWPOS3SVMESAPROC) (const GLshort *v); +typedef void (APIENTRYP PFNGLWINDOWPOS4DMESAPROC) (GLdouble x, GLdouble y, GLdouble z, GLdouble w); +typedef void (APIENTRYP PFNGLWINDOWPOS4DVMESAPROC) (const GLdouble *v); +typedef void (APIENTRYP PFNGLWINDOWPOS4FMESAPROC) (GLfloat x, GLfloat y, GLfloat z, GLfloat w); +typedef void (APIENTRYP PFNGLWINDOWPOS4FVMESAPROC) (const GLfloat *v); +typedef void (APIENTRYP PFNGLWINDOWPOS4IMESAPROC) (GLint x, GLint y, GLint z, GLint w); +typedef void (APIENTRYP PFNGLWINDOWPOS4IVMESAPROC) (const GLint *v); +typedef void (APIENTRYP PFNGLWINDOWPOS4SMESAPROC) (GLshort x, GLshort y, GLshort z, GLshort w); +typedef void (APIENTRYP PFNGLWINDOWPOS4SVMESAPROC) (const GLshort *v); +#endif + +#ifndef GL_IBM_cull_vertex +#define GL_IBM_cull_vertex 1 +#endif + +#ifndef GL_IBM_multimode_draw_arrays +#define GL_IBM_multimode_draw_arrays 1 +#ifdef GL_GLEXT_PROTOTYPES +GLAPI void APIENTRY glMultiModeDrawArraysIBM (const GLenum *, const GLint *, const GLsizei *, GLsizei, GLint); +GLAPI void APIENTRY glMultiModeDrawElementsIBM (const GLenum *, const GLsizei *, GLenum, const GLvoid* const *, GLsizei, GLint); +#endif /* GL_GLEXT_PROTOTYPES */ +typedef void (APIENTRYP PFNGLMULTIMODEDRAWARRAYSIBMPROC) (const GLenum *mode, const GLint *first, const GLsizei *count, GLsizei primcount, GLint modestride); +typedef void (APIENTRYP PFNGLMULTIMODEDRAWELEMENTSIBMPROC) (const GLenum *mode, const GLsizei *count, GLenum type, const GLvoid* const *indices, GLsizei primcount, GLint modestride); +#endif + +#ifndef GL_IBM_vertex_array_lists +#define GL_IBM_vertex_array_lists 1 +#ifdef GL_GLEXT_PROTOTYPES +GLAPI void APIENTRY glColorPointerListIBM (GLint, GLenum, GLint, const GLvoid* *, GLint); +GLAPI void APIENTRY glSecondaryColorPointerListIBM (GLint, GLenum, GLint, const GLvoid* *, GLint); +GLAPI void APIENTRY glEdgeFlagPointerListIBM (GLint, const GLboolean* *, GLint); +GLAPI void APIENTRY glFogCoordPointerListIBM (GLenum, GLint, const GLvoid* *, GLint); +GLAPI void APIENTRY glIndexPointerListIBM (GLenum, GLint, const GLvoid* *, GLint); +GLAPI void APIENTRY glNormalPointerListIBM (GLenum, GLint, const GLvoid* *, GLint); +GLAPI void APIENTRY glTexCoordPointerListIBM (GLint, GLenum, GLint, const GLvoid* *, GLint); +GLAPI void APIENTRY glVertexPointerListIBM (GLint, GLenum, GLint, const GLvoid* *, GLint); +#endif /* GL_GLEXT_PROTOTYPES */ +typedef void (APIENTRYP PFNGLCOLORPOINTERLISTIBMPROC) (GLint size, GLenum type, GLint stride, const GLvoid* *pointer, GLint ptrstride); +typedef void (APIENTRYP PFNGLSECONDARYCOLORPOINTERLISTIBMPROC) (GLint size, GLenum type, GLint stride, const GLvoid* *pointer, GLint ptrstride); +typedef void (APIENTRYP PFNGLEDGEFLAGPOINTERLISTIBMPROC) (GLint stride, const GLboolean* *pointer, GLint ptrstride); +typedef void (APIENTRYP PFNGLFOGCOORDPOINTERLISTIBMPROC) (GLenum type, GLint stride, const GLvoid* *pointer, GLint ptrstride); +typedef void (APIENTRYP PFNGLINDEXPOINTERLISTIBMPROC) (GLenum type, GLint stride, const GLvoid* *pointer, GLint ptrstride); +typedef void (APIENTRYP PFNGLNORMALPOINTERLISTIBMPROC) (GLenum type, GLint stride, const GLvoid* *pointer, GLint ptrstride); +typedef void (APIENTRYP PFNGLTEXCOORDPOINTERLISTIBMPROC) (GLint size, GLenum type, GLint stride, const GLvoid* *pointer, GLint ptrstride); +typedef void (APIENTRYP PFNGLVERTEXPOINTERLISTIBMPROC) (GLint size, GLenum type, GLint stride, const GLvoid* *pointer, GLint ptrstride); +#endif + +#ifndef GL_SGIX_subsample +#define GL_SGIX_subsample 1 +#endif + +#ifndef GL_SGIX_ycrcba +#define GL_SGIX_ycrcba 1 +#endif + +#ifndef GL_SGIX_ycrcb_subsample +#define GL_SGIX_ycrcb_subsample 1 +#endif + +#ifndef GL_SGIX_depth_pass_instrument +#define GL_SGIX_depth_pass_instrument 1 +#endif + +#ifndef GL_3DFX_texture_compression_FXT1 +#define GL_3DFX_texture_compression_FXT1 1 +#endif + +#ifndef GL_3DFX_multisample +#define GL_3DFX_multisample 1 +#endif + +#ifndef GL_3DFX_tbuffer +#define GL_3DFX_tbuffer 1 +#ifdef GL_GLEXT_PROTOTYPES +GLAPI void APIENTRY glTbufferMask3DFX (GLuint); +#endif /* GL_GLEXT_PROTOTYPES */ +typedef void (APIENTRYP PFNGLTBUFFERMASK3DFXPROC) (GLuint mask); +#endif + +#ifndef GL_EXT_multisample +#define GL_EXT_multisample 1 +#ifdef GL_GLEXT_PROTOTYPES +GLAPI void APIENTRY glSampleMaskEXT (GLclampf, GLboolean); +GLAPI void APIENTRY glSamplePatternEXT (GLenum); +#endif /* GL_GLEXT_PROTOTYPES */ +typedef void (APIENTRYP PFNGLSAMPLEMASKEXTPROC) (GLclampf value, GLboolean invert); +typedef void (APIENTRYP PFNGLSAMPLEPATTERNEXTPROC) (GLenum pattern); +#endif + +#ifndef GL_SGIX_vertex_preclip +#define GL_SGIX_vertex_preclip 1 +#endif + +#ifndef GL_SGIX_convolution_accuracy +#define GL_SGIX_convolution_accuracy 1 +#endif + +#ifndef GL_SGIX_resample +#define GL_SGIX_resample 1 +#endif + +#ifndef GL_SGIS_point_line_texgen +#define GL_SGIS_point_line_texgen 1 +#endif + +#ifndef GL_SGIS_texture_color_mask +#define GL_SGIS_texture_color_mask 1 +#ifdef GL_GLEXT_PROTOTYPES +GLAPI void APIENTRY glTextureColorMaskSGIS (GLboolean, GLboolean, GLboolean, GLboolean); +#endif /* GL_GLEXT_PROTOTYPES */ +typedef void (APIENTRYP PFNGLTEXTURECOLORMASKSGISPROC) (GLboolean red, GLboolean green, GLboolean blue, GLboolean alpha); +#endif + +#ifndef GL_SGIX_igloo_interface +#define GL_SGIX_igloo_interface 1 +#ifdef GL_GLEXT_PROTOTYPES +GLAPI void APIENTRY glIglooInterfaceSGIX (GLenum, const GLvoid *); +#endif /* GL_GLEXT_PROTOTYPES */ +typedef void (APIENTRYP PFNGLIGLOOINTERFACESGIXPROC) (GLenum pname, const GLvoid *params); +#endif + +#ifndef GL_EXT_texture_env_dot3 +#define GL_EXT_texture_env_dot3 1 +#endif + +#ifndef GL_ATI_texture_mirror_once +#define GL_ATI_texture_mirror_once 1 +#endif + +#ifndef GL_NV_fence +#define GL_NV_fence 1 +#ifdef GL_GLEXT_PROTOTYPES +GLAPI void APIENTRY glDeleteFencesNV (GLsizei, const GLuint *); +GLAPI void APIENTRY glGenFencesNV (GLsizei, GLuint *); +GLAPI GLboolean APIENTRY glIsFenceNV (GLuint); +GLAPI GLboolean APIENTRY glTestFenceNV (GLuint); +GLAPI void APIENTRY glGetFenceivNV (GLuint, GLenum, GLint *); +GLAPI void APIENTRY glFinishFenceNV (GLuint); +GLAPI void APIENTRY glSetFenceNV (GLuint, GLenum); +#endif /* GL_GLEXT_PROTOTYPES */ +typedef void (APIENTRYP PFNGLDELETEFENCESNVPROC) (GLsizei n, const GLuint *fences); +typedef void (APIENTRYP PFNGLGENFENCESNVPROC) (GLsizei n, GLuint *fences); +typedef GLboolean (APIENTRYP PFNGLISFENCENVPROC) (GLuint fence); +typedef GLboolean (APIENTRYP PFNGLTESTFENCENVPROC) (GLuint fence); +typedef void (APIENTRYP PFNGLGETFENCEIVNVPROC) (GLuint fence, GLenum pname, GLint *params); +typedef void (APIENTRYP PFNGLFINISHFENCENVPROC) (GLuint fence); +typedef void (APIENTRYP PFNGLSETFENCENVPROC) (GLuint fence, GLenum condition); +#endif + +#ifndef GL_NV_evaluators +#define GL_NV_evaluators 1 +#ifdef GL_GLEXT_PROTOTYPES +GLAPI void APIENTRY glMapControlPointsNV (GLenum, GLuint, GLenum, GLsizei, GLsizei, GLint, GLint, GLboolean, const GLvoid *); +GLAPI void APIENTRY glMapParameterivNV (GLenum, GLenum, const GLint *); +GLAPI void APIENTRY glMapParameterfvNV (GLenum, GLenum, const GLfloat *); +GLAPI void APIENTRY glGetMapControlPointsNV (GLenum, GLuint, GLenum, GLsizei, GLsizei, GLboolean, GLvoid *); +GLAPI void APIENTRY glGetMapParameterivNV (GLenum, GLenum, GLint *); +GLAPI void APIENTRY glGetMapParameterfvNV (GLenum, GLenum, GLfloat *); +GLAPI void APIENTRY glGetMapAttribParameterivNV (GLenum, GLuint, GLenum, GLint *); +GLAPI void APIENTRY glGetMapAttribParameterfvNV (GLenum, GLuint, GLenum, GLfloat *); +GLAPI void APIENTRY glEvalMapsNV (GLenum, GLenum); +#endif /* GL_GLEXT_PROTOTYPES */ +typedef void (APIENTRYP PFNGLMAPCONTROLPOINTSNVPROC) (GLenum target, GLuint index, GLenum type, GLsizei ustride, GLsizei vstride, GLint uorder, GLint vorder, GLboolean packed, const GLvoid *points); +typedef void (APIENTRYP PFNGLMAPPARAMETERIVNVPROC) (GLenum target, GLenum pname, const GLint *params); +typedef void (APIENTRYP PFNGLMAPPARAMETERFVNVPROC) (GLenum target, GLenum pname, const GLfloat *params); +typedef void (APIENTRYP PFNGLGETMAPCONTROLPOINTSNVPROC) (GLenum target, GLuint index, GLenum type, GLsizei ustride, GLsizei vstride, GLboolean packed, GLvoid *points); +typedef void (APIENTRYP PFNGLGETMAPPARAMETERIVNVPROC) (GLenum target, GLenum pname, GLint *params); +typedef void (APIENTRYP PFNGLGETMAPPARAMETERFVNVPROC) (GLenum target, GLenum pname, GLfloat *params); +typedef void (APIENTRYP PFNGLGETMAPATTRIBPARAMETERIVNVPROC) (GLenum target, GLuint index, GLenum pname, GLint *params); +typedef void (APIENTRYP PFNGLGETMAPATTRIBPARAMETERFVNVPROC) (GLenum target, GLuint index, GLenum pname, GLfloat *params); +typedef void (APIENTRYP PFNGLEVALMAPSNVPROC) (GLenum target, GLenum mode); +#endif + +#ifndef GL_NV_packed_depth_stencil +#define GL_NV_packed_depth_stencil 1 +#endif + +#ifndef GL_NV_register_combiners2 +#define GL_NV_register_combiners2 1 +#ifdef GL_GLEXT_PROTOTYPES +GLAPI void APIENTRY glCombinerStageParameterfvNV (GLenum, GLenum, const GLfloat *); +GLAPI void APIENTRY glGetCombinerStageParameterfvNV (GLenum, GLenum, GLfloat *); +#endif /* GL_GLEXT_PROTOTYPES */ +typedef void (APIENTRYP PFNGLCOMBINERSTAGEPARAMETERFVNVPROC) (GLenum stage, GLenum pname, const GLfloat *params); +typedef void (APIENTRYP PFNGLGETCOMBINERSTAGEPARAMETERFVNVPROC) (GLenum stage, GLenum pname, GLfloat *params); +#endif + +#ifndef GL_NV_texture_compression_vtc +#define GL_NV_texture_compression_vtc 1 +#endif + +#ifndef GL_NV_texture_rectangle +#define GL_NV_texture_rectangle 1 +#endif + +#ifndef GL_NV_texture_shader +#define GL_NV_texture_shader 1 +#endif + +#ifndef GL_NV_texture_shader2 +#define GL_NV_texture_shader2 1 +#endif + +#ifndef GL_NV_vertex_array_range2 +#define GL_NV_vertex_array_range2 1 +#endif + +#ifndef GL_NV_vertex_program +#define GL_NV_vertex_program 1 +#ifdef GL_GLEXT_PROTOTYPES +GLAPI GLboolean APIENTRY glAreProgramsResidentNV (GLsizei, const GLuint *, GLboolean *); +GLAPI void APIENTRY glBindProgramNV (GLenum, GLuint); +GLAPI void APIENTRY glDeleteProgramsNV (GLsizei, const GLuint *); +GLAPI void APIENTRY glExecuteProgramNV (GLenum, GLuint, const GLfloat *); +GLAPI void APIENTRY glGenProgramsNV (GLsizei, GLuint *); +GLAPI void APIENTRY glGetProgramParameterdvNV (GLenum, GLuint, GLenum, GLdouble *); +GLAPI void APIENTRY glGetProgramParameterfvNV (GLenum, GLuint, GLenum, GLfloat *); +GLAPI void APIENTRY glGetProgramivNV (GLuint, GLenum, GLint *); +GLAPI void APIENTRY glGetProgramStringNV (GLuint, GLenum, GLubyte *); +GLAPI void APIENTRY glGetTrackMatrixivNV (GLenum, GLuint, GLenum, GLint *); +GLAPI void APIENTRY glGetVertexAttribdvNV (GLuint, GLenum, GLdouble *); +GLAPI void APIENTRY glGetVertexAttribfvNV (GLuint, GLenum, GLfloat *); +GLAPI void APIENTRY glGetVertexAttribivNV (GLuint, GLenum, GLint *); +GLAPI void APIENTRY glGetVertexAttribPointervNV (GLuint, GLenum, GLvoid* *); +GLAPI GLboolean APIENTRY glIsProgramNV (GLuint); +GLAPI void APIENTRY glLoadProgramNV (GLenum, GLuint, GLsizei, const GLubyte *); +GLAPI void APIENTRY glProgramParameter4dNV (GLenum, GLuint, GLdouble, GLdouble, GLdouble, GLdouble); +GLAPI void APIENTRY glProgramParameter4dvNV (GLenum, GLuint, const GLdouble *); +GLAPI void APIENTRY glProgramParameter4fNV (GLenum, GLuint, GLfloat, GLfloat, GLfloat, GLfloat); +GLAPI void APIENTRY glProgramParameter4fvNV (GLenum, GLuint, const GLfloat *); +GLAPI void APIENTRY glProgramParameters4dvNV (GLenum, GLuint, GLuint, const GLdouble *); +GLAPI void APIENTRY glProgramParameters4fvNV (GLenum, GLuint, GLuint, const GLfloat *); +GLAPI void APIENTRY glRequestResidentProgramsNV (GLsizei, const GLuint *); +GLAPI void APIENTRY glTrackMatrixNV (GLenum, GLuint, GLenum, GLenum); +GLAPI void APIENTRY glVertexAttribPointerNV (GLuint, GLint, GLenum, GLsizei, const GLvoid *); +GLAPI void APIENTRY glVertexAttrib1dNV (GLuint, GLdouble); +GLAPI void APIENTRY glVertexAttrib1dvNV (GLuint, const GLdouble *); +GLAPI void APIENTRY glVertexAttrib1fNV (GLuint, GLfloat); +GLAPI void APIENTRY glVertexAttrib1fvNV (GLuint, const GLfloat *); +GLAPI void APIENTRY glVertexAttrib1sNV (GLuint, GLshort); +GLAPI void APIENTRY glVertexAttrib1svNV (GLuint, const GLshort *); +GLAPI void APIENTRY glVertexAttrib2dNV (GLuint, GLdouble, GLdouble); +GLAPI void APIENTRY glVertexAttrib2dvNV (GLuint, const GLdouble *); +GLAPI void APIENTRY glVertexAttrib2fNV (GLuint, GLfloat, GLfloat); +GLAPI void APIENTRY glVertexAttrib2fvNV (GLuint, const GLfloat *); +GLAPI void APIENTRY glVertexAttrib2sNV (GLuint, GLshort, GLshort); +GLAPI void APIENTRY glVertexAttrib2svNV (GLuint, const GLshort *); +GLAPI void APIENTRY glVertexAttrib3dNV (GLuint, GLdouble, GLdouble, GLdouble); +GLAPI void APIENTRY glVertexAttrib3dvNV (GLuint, const GLdouble *); +GLAPI void APIENTRY glVertexAttrib3fNV (GLuint, GLfloat, GLfloat, GLfloat); +GLAPI void APIENTRY glVertexAttrib3fvNV (GLuint, const GLfloat *); +GLAPI void APIENTRY glVertexAttrib3sNV (GLuint, GLshort, GLshort, GLshort); +GLAPI void APIENTRY glVertexAttrib3svNV (GLuint, const GLshort *); +GLAPI void APIENTRY glVertexAttrib4dNV (GLuint, GLdouble, GLdouble, GLdouble, GLdouble); +GLAPI void APIENTRY glVertexAttrib4dvNV (GLuint, const GLdouble *); +GLAPI void APIENTRY glVertexAttrib4fNV (GLuint, GLfloat, GLfloat, GLfloat, GLfloat); +GLAPI void APIENTRY glVertexAttrib4fvNV (GLuint, const GLfloat *); +GLAPI void APIENTRY glVertexAttrib4sNV (GLuint, GLshort, GLshort, GLshort, GLshort); +GLAPI void APIENTRY glVertexAttrib4svNV (GLuint, const GLshort *); +GLAPI void APIENTRY glVertexAttrib4ubNV (GLuint, GLubyte, GLubyte, GLubyte, GLubyte); +GLAPI void APIENTRY glVertexAttrib4ubvNV (GLuint, const GLubyte *); +GLAPI void APIENTRY glVertexAttribs1dvNV (GLuint, GLsizei, const GLdouble *); +GLAPI void APIENTRY glVertexAttribs1fvNV (GLuint, GLsizei, const GLfloat *); +GLAPI void APIENTRY glVertexAttribs1svNV (GLuint, GLsizei, const GLshort *); +GLAPI void APIENTRY glVertexAttribs2dvNV (GLuint, GLsizei, const GLdouble *); +GLAPI void APIENTRY glVertexAttribs2fvNV (GLuint, GLsizei, const GLfloat *); +GLAPI void APIENTRY glVertexAttribs2svNV (GLuint, GLsizei, const GLshort *); +GLAPI void APIENTRY glVertexAttribs3dvNV (GLuint, GLsizei, const GLdouble *); +GLAPI void APIENTRY glVertexAttribs3fvNV (GLuint, GLsizei, const GLfloat *); +GLAPI void APIENTRY glVertexAttribs3svNV (GLuint, GLsizei, const GLshort *); +GLAPI void APIENTRY glVertexAttribs4dvNV (GLuint, GLsizei, const GLdouble *); +GLAPI void APIENTRY glVertexAttribs4fvNV (GLuint, GLsizei, const GLfloat *); +GLAPI void APIENTRY glVertexAttribs4svNV (GLuint, GLsizei, const GLshort *); +GLAPI void APIENTRY glVertexAttribs4ubvNV (GLuint, GLsizei, const GLubyte *); +#endif /* GL_GLEXT_PROTOTYPES */ +typedef GLboolean (APIENTRYP PFNGLAREPROGRAMSRESIDENTNVPROC) (GLsizei n, const GLuint *programs, GLboolean *residences); +typedef void (APIENTRYP PFNGLBINDPROGRAMNVPROC) (GLenum target, GLuint id); +typedef void (APIENTRYP PFNGLDELETEPROGRAMSNVPROC) (GLsizei n, const GLuint *programs); +typedef void (APIENTRYP PFNGLEXECUTEPROGRAMNVPROC) (GLenum target, GLuint id, const GLfloat *params); +typedef void (APIENTRYP PFNGLGENPROGRAMSNVPROC) (GLsizei n, GLuint *programs); +typedef void (APIENTRYP PFNGLGETPROGRAMPARAMETERDVNVPROC) (GLenum target, GLuint index, GLenum pname, GLdouble *params); +typedef void (APIENTRYP PFNGLGETPROGRAMPARAMETERFVNVPROC) (GLenum target, GLuint index, GLenum pname, GLfloat *params); +typedef void (APIENTRYP PFNGLGETPROGRAMIVNVPROC) (GLuint id, GLenum pname, GLint *params); +typedef void (APIENTRYP PFNGLGETPROGRAMSTRINGNVPROC) (GLuint id, GLenum pname, GLubyte *program); +typedef void (APIENTRYP PFNGLGETTRACKMATRIXIVNVPROC) (GLenum target, GLuint address, GLenum pname, GLint *params); +typedef void (APIENTRYP PFNGLGETVERTEXATTRIBDVNVPROC) (GLuint index, GLenum pname, GLdouble *params); +typedef void (APIENTRYP PFNGLGETVERTEXATTRIBFVNVPROC) (GLuint index, GLenum pname, GLfloat *params); +typedef void (APIENTRYP PFNGLGETVERTEXATTRIBIVNVPROC) (GLuint index, GLenum pname, GLint *params); +typedef void (APIENTRYP PFNGLGETVERTEXATTRIBPOINTERVNVPROC) (GLuint index, GLenum pname, GLvoid* *pointer); +typedef GLboolean (APIENTRYP PFNGLISPROGRAMNVPROC) (GLuint id); +typedef void (APIENTRYP PFNGLLOADPROGRAMNVPROC) (GLenum target, GLuint id, GLsizei len, const GLubyte *program); +typedef void (APIENTRYP PFNGLPROGRAMPARAMETER4DNVPROC) (GLenum target, GLuint index, GLdouble x, GLdouble y, GLdouble z, GLdouble w); +typedef void (APIENTRYP PFNGLPROGRAMPARAMETER4DVNVPROC) (GLenum target, GLuint index, const GLdouble *v); +typedef void (APIENTRYP PFNGLPROGRAMPARAMETER4FNVPROC) (GLenum target, GLuint index, GLfloat x, GLfloat y, GLfloat z, GLfloat w); +typedef void (APIENTRYP PFNGLPROGRAMPARAMETER4FVNVPROC) (GLenum target, GLuint index, const GLfloat *v); +typedef void (APIENTRYP PFNGLPROGRAMPARAMETERS4DVNVPROC) (GLenum target, GLuint index, GLuint count, const GLdouble *v); +typedef void (APIENTRYP PFNGLPROGRAMPARAMETERS4FVNVPROC) (GLenum target, GLuint index, GLuint count, const GLfloat *v); +typedef void (APIENTRYP PFNGLREQUESTRESIDENTPROGRAMSNVPROC) (GLsizei n, const GLuint *programs); +typedef void (APIENTRYP PFNGLTRACKMATRIXNVPROC) (GLenum target, GLuint address, GLenum matrix, GLenum transform); +typedef void (APIENTRYP PFNGLVERTEXATTRIBPOINTERNVPROC) (GLuint index, GLint fsize, GLenum type, GLsizei stride, const GLvoid *pointer); +typedef void (APIENTRYP PFNGLVERTEXATTRIB1DNVPROC) (GLuint index, GLdouble x); +typedef void (APIENTRYP PFNGLVERTEXATTRIB1DVNVPROC) (GLuint index, const GLdouble *v); +typedef void (APIENTRYP PFNGLVERTEXATTRIB1FNVPROC) (GLuint index, GLfloat x); +typedef void (APIENTRYP PFNGLVERTEXATTRIB1FVNVPROC) (GLuint index, const GLfloat *v); +typedef void (APIENTRYP PFNGLVERTEXATTRIB1SNVPROC) (GLuint index, GLshort x); +typedef void (APIENTRYP PFNGLVERTEXATTRIB1SVNVPROC) (GLuint index, const GLshort *v); +typedef void (APIENTRYP PFNGLVERTEXATTRIB2DNVPROC) (GLuint index, GLdouble x, GLdouble y); +typedef void (APIENTRYP PFNGLVERTEXATTRIB2DVNVPROC) (GLuint index, const GLdouble *v); +typedef void (APIENTRYP PFNGLVERTEXATTRIB2FNVPROC) (GLuint index, GLfloat x, GLfloat y); +typedef void (APIENTRYP PFNGLVERTEXATTRIB2FVNVPROC) (GLuint index, const GLfloat *v); +typedef void (APIENTRYP PFNGLVERTEXATTRIB2SNVPROC) (GLuint index, GLshort x, GLshort y); +typedef void (APIENTRYP PFNGLVERTEXATTRIB2SVNVPROC) (GLuint index, const GLshort *v); +typedef void (APIENTRYP PFNGLVERTEXATTRIB3DNVPROC) (GLuint index, GLdouble x, GLdouble y, GLdouble z); +typedef void (APIENTRYP PFNGLVERTEXATTRIB3DVNVPROC) (GLuint index, const GLdouble *v); +typedef void (APIENTRYP PFNGLVERTEXATTRIB3FNVPROC) (GLuint index, GLfloat x, GLfloat y, GLfloat z); +typedef void (APIENTRYP PFNGLVERTEXATTRIB3FVNVPROC) (GLuint index, const GLfloat *v); +typedef void (APIENTRYP PFNGLVERTEXATTRIB3SNVPROC) (GLuint index, GLshort x, GLshort y, GLshort z); +typedef void (APIENTRYP PFNGLVERTEXATTRIB3SVNVPROC) (GLuint index, const GLshort *v); +typedef void (APIENTRYP PFNGLVERTEXATTRIB4DNVPROC) (GLuint index, GLdouble x, GLdouble y, GLdouble z, GLdouble w); +typedef void (APIENTRYP PFNGLVERTEXATTRIB4DVNVPROC) (GLuint index, const GLdouble *v); +typedef void (APIENTRYP PFNGLVERTEXATTRIB4FNVPROC) (GLuint index, GLfloat x, GLfloat y, GLfloat z, GLfloat w); +typedef void (APIENTRYP PFNGLVERTEXATTRIB4FVNVPROC) (GLuint index, const GLfloat *v); +typedef void (APIENTRYP PFNGLVERTEXATTRIB4SNVPROC) (GLuint index, GLshort x, GLshort y, GLshort z, GLshort w); +typedef void (APIENTRYP PFNGLVERTEXATTRIB4SVNVPROC) (GLuint index, const GLshort *v); +typedef void (APIENTRYP PFNGLVERTEXATTRIB4UBNVPROC) (GLuint index, GLubyte x, GLubyte y, GLubyte z, GLubyte w); +typedef void (APIENTRYP PFNGLVERTEXATTRIB4UBVNVPROC) (GLuint index, const GLubyte *v); +typedef void (APIENTRYP PFNGLVERTEXATTRIBS1DVNVPROC) (GLuint index, GLsizei count, const GLdouble *v); +typedef void (APIENTRYP PFNGLVERTEXATTRIBS1FVNVPROC) (GLuint index, GLsizei count, const GLfloat *v); +typedef void (APIENTRYP PFNGLVERTEXATTRIBS1SVNVPROC) (GLuint index, GLsizei count, const GLshort *v); +typedef void (APIENTRYP PFNGLVERTEXATTRIBS2DVNVPROC) (GLuint index, GLsizei count, const GLdouble *v); +typedef void (APIENTRYP PFNGLVERTEXATTRIBS2FVNVPROC) (GLuint index, GLsizei count, const GLfloat *v); +typedef void (APIENTRYP PFNGLVERTEXATTRIBS2SVNVPROC) (GLuint index, GLsizei count, const GLshort *v); +typedef void (APIENTRYP PFNGLVERTEXATTRIBS3DVNVPROC) (GLuint index, GLsizei count, const GLdouble *v); +typedef void (APIENTRYP PFNGLVERTEXATTRIBS3FVNVPROC) (GLuint index, GLsizei count, const GLfloat *v); +typedef void (APIENTRYP PFNGLVERTEXATTRIBS3SVNVPROC) (GLuint index, GLsizei count, const GLshort *v); +typedef void (APIENTRYP PFNGLVERTEXATTRIBS4DVNVPROC) (GLuint index, GLsizei count, const GLdouble *v); +typedef void (APIENTRYP PFNGLVERTEXATTRIBS4FVNVPROC) (GLuint index, GLsizei count, const GLfloat *v); +typedef void (APIENTRYP PFNGLVERTEXATTRIBS4SVNVPROC) (GLuint index, GLsizei count, const GLshort *v); +typedef void (APIENTRYP PFNGLVERTEXATTRIBS4UBVNVPROC) (GLuint index, GLsizei count, const GLubyte *v); +#endif + +#ifndef GL_SGIX_texture_coordinate_clamp +#define GL_SGIX_texture_coordinate_clamp 1 +#endif + +#ifndef GL_SGIX_scalebias_hint +#define GL_SGIX_scalebias_hint 1 +#endif + +#ifndef GL_OML_interlace +#define GL_OML_interlace 1 +#endif + +#ifndef GL_OML_subsample +#define GL_OML_subsample 1 +#endif + +#ifndef GL_OML_resample +#define GL_OML_resample 1 +#endif + +#ifndef GL_NV_copy_depth_to_color +#define GL_NV_copy_depth_to_color 1 +#endif + +#ifndef GL_ATI_envmap_bumpmap +#define GL_ATI_envmap_bumpmap 1 +#ifdef GL_GLEXT_PROTOTYPES +GLAPI void APIENTRY glTexBumpParameterivATI (GLenum, const GLint *); +GLAPI void APIENTRY glTexBumpParameterfvATI (GLenum, const GLfloat *); +GLAPI void APIENTRY glGetTexBumpParameterivATI (GLenum, GLint *); +GLAPI void APIENTRY glGetTexBumpParameterfvATI (GLenum, GLfloat *); +#endif /* GL_GLEXT_PROTOTYPES */ +typedef void (APIENTRYP PFNGLTEXBUMPPARAMETERIVATIPROC) (GLenum pname, const GLint *param); +typedef void (APIENTRYP PFNGLTEXBUMPPARAMETERFVATIPROC) (GLenum pname, const GLfloat *param); +typedef void (APIENTRYP PFNGLGETTEXBUMPPARAMETERIVATIPROC) (GLenum pname, GLint *param); +typedef void (APIENTRYP PFNGLGETTEXBUMPPARAMETERFVATIPROC) (GLenum pname, GLfloat *param); +#endif + +#ifndef GL_ATI_fragment_shader +#define GL_ATI_fragment_shader 1 +#ifdef GL_GLEXT_PROTOTYPES +GLAPI GLuint APIENTRY glGenFragmentShadersATI (GLuint); +GLAPI void APIENTRY glBindFragmentShaderATI (GLuint); +GLAPI void APIENTRY glDeleteFragmentShaderATI (GLuint); +GLAPI void APIENTRY glBeginFragmentShaderATI (void); +GLAPI void APIENTRY glEndFragmentShaderATI (void); +GLAPI void APIENTRY glPassTexCoordATI (GLuint, GLuint, GLenum); +GLAPI void APIENTRY glSampleMapATI (GLuint, GLuint, GLenum); +GLAPI void APIENTRY glColorFragmentOp1ATI (GLenum, GLuint, GLuint, GLuint, GLuint, GLuint, GLuint); +GLAPI void APIENTRY glColorFragmentOp2ATI (GLenum, GLuint, GLuint, GLuint, GLuint, GLuint, GLuint, GLuint, GLuint, GLuint); +GLAPI void APIENTRY glColorFragmentOp3ATI (GLenum, GLuint, GLuint, GLuint, GLuint, GLuint, GLuint, GLuint, GLuint, GLuint, GLuint, GLuint, GLuint); +GLAPI void APIENTRY glAlphaFragmentOp1ATI (GLenum, GLuint, GLuint, GLuint, GLuint, GLuint); +GLAPI void APIENTRY glAlphaFragmentOp2ATI (GLenum, GLuint, GLuint, GLuint, GLuint, GLuint, GLuint, GLuint, GLuint); +GLAPI void APIENTRY glAlphaFragmentOp3ATI (GLenum, GLuint, GLuint, GLuint, GLuint, GLuint, GLuint, GLuint, GLuint, GLuint, GLuint, GLuint); +GLAPI void APIENTRY glSetFragmentShaderConstantATI (GLuint, const GLfloat *); +#endif /* GL_GLEXT_PROTOTYPES */ +typedef GLuint (APIENTRYP PFNGLGENFRAGMENTSHADERSATIPROC) (GLuint range); +typedef void (APIENTRYP PFNGLBINDFRAGMENTSHADERATIPROC) (GLuint id); +typedef void (APIENTRYP PFNGLDELETEFRAGMENTSHADERATIPROC) (GLuint id); +typedef void (APIENTRYP PFNGLBEGINFRAGMENTSHADERATIPROC) (void); +typedef void (APIENTRYP PFNGLENDFRAGMENTSHADERATIPROC) (void); +typedef void (APIENTRYP PFNGLPASSTEXCOORDATIPROC) (GLuint dst, GLuint coord, GLenum swizzle); +typedef void (APIENTRYP PFNGLSAMPLEMAPATIPROC) (GLuint dst, GLuint interp, GLenum swizzle); +typedef void (APIENTRYP PFNGLCOLORFRAGMENTOP1ATIPROC) (GLenum op, GLuint dst, GLuint dstMask, GLuint dstMod, GLuint arg1, GLuint arg1Rep, GLuint arg1Mod); +typedef void (APIENTRYP PFNGLCOLORFRAGMENTOP2ATIPROC) (GLenum op, GLuint dst, GLuint dstMask, GLuint dstMod, GLuint arg1, GLuint arg1Rep, GLuint arg1Mod, GLuint arg2, GLuint arg2Rep, GLuint arg2Mod); +typedef void (APIENTRYP PFNGLCOLORFRAGMENTOP3ATIPROC) (GLenum op, GLuint dst, GLuint dstMask, GLuint dstMod, GLuint arg1, GLuint arg1Rep, GLuint arg1Mod, GLuint arg2, GLuint arg2Rep, GLuint arg2Mod, GLuint arg3, GLuint arg3Rep, GLuint arg3Mod); +typedef void (APIENTRYP PFNGLALPHAFRAGMENTOP1ATIPROC) (GLenum op, GLuint dst, GLuint dstMod, GLuint arg1, GLuint arg1Rep, GLuint arg1Mod); +typedef void (APIENTRYP PFNGLALPHAFRAGMENTOP2ATIPROC) (GLenum op, GLuint dst, GLuint dstMod, GLuint arg1, GLuint arg1Rep, GLuint arg1Mod, GLuint arg2, GLuint arg2Rep, GLuint arg2Mod); +typedef void (APIENTRYP PFNGLALPHAFRAGMENTOP3ATIPROC) (GLenum op, GLuint dst, GLuint dstMod, GLuint arg1, GLuint arg1Rep, GLuint arg1Mod, GLuint arg2, GLuint arg2Rep, GLuint arg2Mod, GLuint arg3, GLuint arg3Rep, GLuint arg3Mod); +typedef void (APIENTRYP PFNGLSETFRAGMENTSHADERCONSTANTATIPROC) (GLuint dst, const GLfloat *value); +#endif + +#ifndef GL_ATI_pn_triangles +#define GL_ATI_pn_triangles 1 +#ifdef GL_GLEXT_PROTOTYPES +GLAPI void APIENTRY glPNTrianglesiATI (GLenum, GLint); +GLAPI void APIENTRY glPNTrianglesfATI (GLenum, GLfloat); +#endif /* GL_GLEXT_PROTOTYPES */ +typedef void (APIENTRYP PFNGLPNTRIANGLESIATIPROC) (GLenum pname, GLint param); +typedef void (APIENTRYP PFNGLPNTRIANGLESFATIPROC) (GLenum pname, GLfloat param); +#endif + +#ifndef GL_ATI_vertex_array_object +#define GL_ATI_vertex_array_object 1 +#ifdef GL_GLEXT_PROTOTYPES +GLAPI GLuint APIENTRY glNewObjectBufferATI (GLsizei, const GLvoid *, GLenum); +GLAPI GLboolean APIENTRY glIsObjectBufferATI (GLuint); +GLAPI void APIENTRY glUpdateObjectBufferATI (GLuint, GLuint, GLsizei, const GLvoid *, GLenum); +GLAPI void APIENTRY glGetObjectBufferfvATI (GLuint, GLenum, GLfloat *); +GLAPI void APIENTRY glGetObjectBufferivATI (GLuint, GLenum, GLint *); +GLAPI void APIENTRY glFreeObjectBufferATI (GLuint); +GLAPI void APIENTRY glArrayObjectATI (GLenum, GLint, GLenum, GLsizei, GLuint, GLuint); +GLAPI void APIENTRY glGetArrayObjectfvATI (GLenum, GLenum, GLfloat *); +GLAPI void APIENTRY glGetArrayObjectivATI (GLenum, GLenum, GLint *); +GLAPI void APIENTRY glVariantArrayObjectATI (GLuint, GLenum, GLsizei, GLuint, GLuint); +GLAPI void APIENTRY glGetVariantArrayObjectfvATI (GLuint, GLenum, GLfloat *); +GLAPI void APIENTRY glGetVariantArrayObjectivATI (GLuint, GLenum, GLint *); +#endif /* GL_GLEXT_PROTOTYPES */ +typedef GLuint (APIENTRYP PFNGLNEWOBJECTBUFFERATIPROC) (GLsizei size, const GLvoid *pointer, GLenum usage); +typedef GLboolean (APIENTRYP PFNGLISOBJECTBUFFERATIPROC) (GLuint buffer); +typedef void (APIENTRYP PFNGLUPDATEOBJECTBUFFERATIPROC) (GLuint buffer, GLuint offset, GLsizei size, const GLvoid *pointer, GLenum preserve); +typedef void (APIENTRYP PFNGLGETOBJECTBUFFERFVATIPROC) (GLuint buffer, GLenum pname, GLfloat *params); +typedef void (APIENTRYP PFNGLGETOBJECTBUFFERIVATIPROC) (GLuint buffer, GLenum pname, GLint *params); +typedef void (APIENTRYP PFNGLFREEOBJECTBUFFERATIPROC) (GLuint buffer); +typedef void (APIENTRYP PFNGLARRAYOBJECTATIPROC) (GLenum array, GLint size, GLenum type, GLsizei stride, GLuint buffer, GLuint offset); +typedef void (APIENTRYP PFNGLGETARRAYOBJECTFVATIPROC) (GLenum array, GLenum pname, GLfloat *params); +typedef void (APIENTRYP PFNGLGETARRAYOBJECTIVATIPROC) (GLenum array, GLenum pname, GLint *params); +typedef void (APIENTRYP PFNGLVARIANTARRAYOBJECTATIPROC) (GLuint id, GLenum type, GLsizei stride, GLuint buffer, GLuint offset); +typedef void (APIENTRYP PFNGLGETVARIANTARRAYOBJECTFVATIPROC) (GLuint id, GLenum pname, GLfloat *params); +typedef void (APIENTRYP PFNGLGETVARIANTARRAYOBJECTIVATIPROC) (GLuint id, GLenum pname, GLint *params); +#endif + +#ifndef GL_EXT_vertex_shader +#define GL_EXT_vertex_shader 1 +#ifdef GL_GLEXT_PROTOTYPES +GLAPI void APIENTRY glBeginVertexShaderEXT (void); +GLAPI void APIENTRY glEndVertexShaderEXT (void); +GLAPI void APIENTRY glBindVertexShaderEXT (GLuint); +GLAPI GLuint APIENTRY glGenVertexShadersEXT (GLuint); +GLAPI void APIENTRY glDeleteVertexShaderEXT (GLuint); +GLAPI void APIENTRY glShaderOp1EXT (GLenum, GLuint, GLuint); +GLAPI void APIENTRY glShaderOp2EXT (GLenum, GLuint, GLuint, GLuint); +GLAPI void APIENTRY glShaderOp3EXT (GLenum, GLuint, GLuint, GLuint, GLuint); +GLAPI void APIENTRY glSwizzleEXT (GLuint, GLuint, GLenum, GLenum, GLenum, GLenum); +GLAPI void APIENTRY glWriteMaskEXT (GLuint, GLuint, GLenum, GLenum, GLenum, GLenum); +GLAPI void APIENTRY glInsertComponentEXT (GLuint, GLuint, GLuint); +GLAPI void APIENTRY glExtractComponentEXT (GLuint, GLuint, GLuint); +GLAPI GLuint APIENTRY glGenSymbolsEXT (GLenum, GLenum, GLenum, GLuint); +GLAPI void APIENTRY glSetInvariantEXT (GLuint, GLenum, const GLvoid *); +GLAPI void APIENTRY glSetLocalConstantEXT (GLuint, GLenum, const GLvoid *); +GLAPI void APIENTRY glVariantbvEXT (GLuint, const GLbyte *); +GLAPI void APIENTRY glVariantsvEXT (GLuint, const GLshort *); +GLAPI void APIENTRY glVariantivEXT (GLuint, const GLint *); +GLAPI void APIENTRY glVariantfvEXT (GLuint, const GLfloat *); +GLAPI void APIENTRY glVariantdvEXT (GLuint, const GLdouble *); +GLAPI void APIENTRY glVariantubvEXT (GLuint, const GLubyte *); +GLAPI void APIENTRY glVariantusvEXT (GLuint, const GLushort *); +GLAPI void APIENTRY glVariantuivEXT (GLuint, const GLuint *); +GLAPI void APIENTRY glVariantPointerEXT (GLuint, GLenum, GLuint, const GLvoid *); +GLAPI void APIENTRY glEnableVariantClientStateEXT (GLuint); +GLAPI void APIENTRY glDisableVariantClientStateEXT (GLuint); +GLAPI GLuint APIENTRY glBindLightParameterEXT (GLenum, GLenum); +GLAPI GLuint APIENTRY glBindMaterialParameterEXT (GLenum, GLenum); +GLAPI GLuint APIENTRY glBindTexGenParameterEXT (GLenum, GLenum, GLenum); +GLAPI GLuint APIENTRY glBindTextureUnitParameterEXT (GLenum, GLenum); +GLAPI GLuint APIENTRY glBindParameterEXT (GLenum); +GLAPI GLboolean APIENTRY glIsVariantEnabledEXT (GLuint, GLenum); +GLAPI void APIENTRY glGetVariantBooleanvEXT (GLuint, GLenum, GLboolean *); +GLAPI void APIENTRY glGetVariantIntegervEXT (GLuint, GLenum, GLint *); +GLAPI void APIENTRY glGetVariantFloatvEXT (GLuint, GLenum, GLfloat *); +GLAPI void APIENTRY glGetVariantPointervEXT (GLuint, GLenum, GLvoid* *); +GLAPI void APIENTRY glGetInvariantBooleanvEXT (GLuint, GLenum, GLboolean *); +GLAPI void APIENTRY glGetInvariantIntegervEXT (GLuint, GLenum, GLint *); +GLAPI void APIENTRY glGetInvariantFloatvEXT (GLuint, GLenum, GLfloat *); +GLAPI void APIENTRY glGetLocalConstantBooleanvEXT (GLuint, GLenum, GLboolean *); +GLAPI void APIENTRY glGetLocalConstantIntegervEXT (GLuint, GLenum, GLint *); +GLAPI void APIENTRY glGetLocalConstantFloatvEXT (GLuint, GLenum, GLfloat *); +#endif /* GL_GLEXT_PROTOTYPES */ +typedef void (APIENTRYP PFNGLBEGINVERTEXSHADEREXTPROC) (void); +typedef void (APIENTRYP PFNGLENDVERTEXSHADEREXTPROC) (void); +typedef void (APIENTRYP PFNGLBINDVERTEXSHADEREXTPROC) (GLuint id); +typedef GLuint (APIENTRYP PFNGLGENVERTEXSHADERSEXTPROC) (GLuint range); +typedef void (APIENTRYP PFNGLDELETEVERTEXSHADEREXTPROC) (GLuint id); +typedef void (APIENTRYP PFNGLSHADEROP1EXTPROC) (GLenum op, GLuint res, GLuint arg1); +typedef void (APIENTRYP PFNGLSHADEROP2EXTPROC) (GLenum op, GLuint res, GLuint arg1, GLuint arg2); +typedef void (APIENTRYP PFNGLSHADEROP3EXTPROC) (GLenum op, GLuint res, GLuint arg1, GLuint arg2, GLuint arg3); +typedef void (APIENTRYP PFNGLSWIZZLEEXTPROC) (GLuint res, GLuint in, GLenum outX, GLenum outY, GLenum outZ, GLenum outW); +typedef void (APIENTRYP PFNGLWRITEMASKEXTPROC) (GLuint res, GLuint in, GLenum outX, GLenum outY, GLenum outZ, GLenum outW); +typedef void (APIENTRYP PFNGLINSERTCOMPONENTEXTPROC) (GLuint res, GLuint src, GLuint num); +typedef void (APIENTRYP PFNGLEXTRACTCOMPONENTEXTPROC) (GLuint res, GLuint src, GLuint num); +typedef GLuint (APIENTRYP PFNGLGENSYMBOLSEXTPROC) (GLenum datatype, GLenum storagetype, GLenum range, GLuint components); +typedef void (APIENTRYP PFNGLSETINVARIANTEXTPROC) (GLuint id, GLenum type, const GLvoid *addr); +typedef void (APIENTRYP PFNGLSETLOCALCONSTANTEXTPROC) (GLuint id, GLenum type, const GLvoid *addr); +typedef void (APIENTRYP PFNGLVARIANTBVEXTPROC) (GLuint id, const GLbyte *addr); +typedef void (APIENTRYP PFNGLVARIANTSVEXTPROC) (GLuint id, const GLshort *addr); +typedef void (APIENTRYP PFNGLVARIANTIVEXTPROC) (GLuint id, const GLint *addr); +typedef void (APIENTRYP PFNGLVARIANTFVEXTPROC) (GLuint id, const GLfloat *addr); +typedef void (APIENTRYP PFNGLVARIANTDVEXTPROC) (GLuint id, const GLdouble *addr); +typedef void (APIENTRYP PFNGLVARIANTUBVEXTPROC) (GLuint id, const GLubyte *addr); +typedef void (APIENTRYP PFNGLVARIANTUSVEXTPROC) (GLuint id, const GLushort *addr); +typedef void (APIENTRYP PFNGLVARIANTUIVEXTPROC) (GLuint id, const GLuint *addr); +typedef void (APIENTRYP PFNGLVARIANTPOINTEREXTPROC) (GLuint id, GLenum type, GLuint stride, const GLvoid *addr); +typedef void (APIENTRYP PFNGLENABLEVARIANTCLIENTSTATEEXTPROC) (GLuint id); +typedef void (APIENTRYP PFNGLDISABLEVARIANTCLIENTSTATEEXTPROC) (GLuint id); +typedef GLuint (APIENTRYP PFNGLBINDLIGHTPARAMETEREXTPROC) (GLenum light, GLenum value); +typedef GLuint (APIENTRYP PFNGLBINDMATERIALPARAMETEREXTPROC) (GLenum face, GLenum value); +typedef GLuint (APIENTRYP PFNGLBINDTEXGENPARAMETEREXTPROC) (GLenum unit, GLenum coord, GLenum value); +typedef GLuint (APIENTRYP PFNGLBINDTEXTUREUNITPARAMETEREXTPROC) (GLenum unit, GLenum value); +typedef GLuint (APIENTRYP PFNGLBINDPARAMETEREXTPROC) (GLenum value); +typedef GLboolean (APIENTRYP PFNGLISVARIANTENABLEDEXTPROC) (GLuint id, GLenum cap); +typedef void (APIENTRYP PFNGLGETVARIANTBOOLEANVEXTPROC) (GLuint id, GLenum value, GLboolean *data); +typedef void (APIENTRYP PFNGLGETVARIANTINTEGERVEXTPROC) (GLuint id, GLenum value, GLint *data); +typedef void (APIENTRYP PFNGLGETVARIANTFLOATVEXTPROC) (GLuint id, GLenum value, GLfloat *data); +typedef void (APIENTRYP PFNGLGETVARIANTPOINTERVEXTPROC) (GLuint id, GLenum value, GLvoid* *data); +typedef void (APIENTRYP PFNGLGETINVARIANTBOOLEANVEXTPROC) (GLuint id, GLenum value, GLboolean *data); +typedef void (APIENTRYP PFNGLGETINVARIANTINTEGERVEXTPROC) (GLuint id, GLenum value, GLint *data); +typedef void (APIENTRYP PFNGLGETINVARIANTFLOATVEXTPROC) (GLuint id, GLenum value, GLfloat *data); +typedef void (APIENTRYP PFNGLGETLOCALCONSTANTBOOLEANVEXTPROC) (GLuint id, GLenum value, GLboolean *data); +typedef void (APIENTRYP PFNGLGETLOCALCONSTANTINTEGERVEXTPROC) (GLuint id, GLenum value, GLint *data); +typedef void (APIENTRYP PFNGLGETLOCALCONSTANTFLOATVEXTPROC) (GLuint id, GLenum value, GLfloat *data); +#endif + +#ifndef GL_ATI_vertex_streams +#define GL_ATI_vertex_streams 1 +#ifdef GL_GLEXT_PROTOTYPES +GLAPI void APIENTRY glVertexStream1sATI (GLenum, GLshort); +GLAPI void APIENTRY glVertexStream1svATI (GLenum, const GLshort *); +GLAPI void APIENTRY glVertexStream1iATI (GLenum, GLint); +GLAPI void APIENTRY glVertexStream1ivATI (GLenum, const GLint *); +GLAPI void APIENTRY glVertexStream1fATI (GLenum, GLfloat); +GLAPI void APIENTRY glVertexStream1fvATI (GLenum, const GLfloat *); +GLAPI void APIENTRY glVertexStream1dATI (GLenum, GLdouble); +GLAPI void APIENTRY glVertexStream1dvATI (GLenum, const GLdouble *); +GLAPI void APIENTRY glVertexStream2sATI (GLenum, GLshort, GLshort); +GLAPI void APIENTRY glVertexStream2svATI (GLenum, const GLshort *); +GLAPI void APIENTRY glVertexStream2iATI (GLenum, GLint, GLint); +GLAPI void APIENTRY glVertexStream2ivATI (GLenum, const GLint *); +GLAPI void APIENTRY glVertexStream2fATI (GLenum, GLfloat, GLfloat); +GLAPI void APIENTRY glVertexStream2fvATI (GLenum, const GLfloat *); +GLAPI void APIENTRY glVertexStream2dATI (GLenum, GLdouble, GLdouble); +GLAPI void APIENTRY glVertexStream2dvATI (GLenum, const GLdouble *); +GLAPI void APIENTRY glVertexStream3sATI (GLenum, GLshort, GLshort, GLshort); +GLAPI void APIENTRY glVertexStream3svATI (GLenum, const GLshort *); +GLAPI void APIENTRY glVertexStream3iATI (GLenum, GLint, GLint, GLint); +GLAPI void APIENTRY glVertexStream3ivATI (GLenum, const GLint *); +GLAPI void APIENTRY glVertexStream3fATI (GLenum, GLfloat, GLfloat, GLfloat); +GLAPI void APIENTRY glVertexStream3fvATI (GLenum, const GLfloat *); +GLAPI void APIENTRY glVertexStream3dATI (GLenum, GLdouble, GLdouble, GLdouble); +GLAPI void APIENTRY glVertexStream3dvATI (GLenum, const GLdouble *); +GLAPI void APIENTRY glVertexStream4sATI (GLenum, GLshort, GLshort, GLshort, GLshort); +GLAPI void APIENTRY glVertexStream4svATI (GLenum, const GLshort *); +GLAPI void APIENTRY glVertexStream4iATI (GLenum, GLint, GLint, GLint, GLint); +GLAPI void APIENTRY glVertexStream4ivATI (GLenum, const GLint *); +GLAPI void APIENTRY glVertexStream4fATI (GLenum, GLfloat, GLfloat, GLfloat, GLfloat); +GLAPI void APIENTRY glVertexStream4fvATI (GLenum, const GLfloat *); +GLAPI void APIENTRY glVertexStream4dATI (GLenum, GLdouble, GLdouble, GLdouble, GLdouble); +GLAPI void APIENTRY glVertexStream4dvATI (GLenum, const GLdouble *); +GLAPI void APIENTRY glNormalStream3bATI (GLenum, GLbyte, GLbyte, GLbyte); +GLAPI void APIENTRY glNormalStream3bvATI (GLenum, const GLbyte *); +GLAPI void APIENTRY glNormalStream3sATI (GLenum, GLshort, GLshort, GLshort); +GLAPI void APIENTRY glNormalStream3svATI (GLenum, const GLshort *); +GLAPI void APIENTRY glNormalStream3iATI (GLenum, GLint, GLint, GLint); +GLAPI void APIENTRY glNormalStream3ivATI (GLenum, const GLint *); +GLAPI void APIENTRY glNormalStream3fATI (GLenum, GLfloat, GLfloat, GLfloat); +GLAPI void APIENTRY glNormalStream3fvATI (GLenum, const GLfloat *); +GLAPI void APIENTRY glNormalStream3dATI (GLenum, GLdouble, GLdouble, GLdouble); +GLAPI void APIENTRY glNormalStream3dvATI (GLenum, const GLdouble *); +GLAPI void APIENTRY glClientActiveVertexStreamATI (GLenum); +GLAPI void APIENTRY glVertexBlendEnviATI (GLenum, GLint); +GLAPI void APIENTRY glVertexBlendEnvfATI (GLenum, GLfloat); +#endif /* GL_GLEXT_PROTOTYPES */ +typedef void (APIENTRYP PFNGLVERTEXSTREAM1SATIPROC) (GLenum stream, GLshort x); +typedef void (APIENTRYP PFNGLVERTEXSTREAM1SVATIPROC) (GLenum stream, const GLshort *coords); +typedef void (APIENTRYP PFNGLVERTEXSTREAM1IATIPROC) (GLenum stream, GLint x); +typedef void (APIENTRYP PFNGLVERTEXSTREAM1IVATIPROC) (GLenum stream, const GLint *coords); +typedef void (APIENTRYP PFNGLVERTEXSTREAM1FATIPROC) (GLenum stream, GLfloat x); +typedef void (APIENTRYP PFNGLVERTEXSTREAM1FVATIPROC) (GLenum stream, const GLfloat *coords); +typedef void (APIENTRYP PFNGLVERTEXSTREAM1DATIPROC) (GLenum stream, GLdouble x); +typedef void (APIENTRYP PFNGLVERTEXSTREAM1DVATIPROC) (GLenum stream, const GLdouble *coords); +typedef void (APIENTRYP PFNGLVERTEXSTREAM2SATIPROC) (GLenum stream, GLshort x, GLshort y); +typedef void (APIENTRYP PFNGLVERTEXSTREAM2SVATIPROC) (GLenum stream, const GLshort *coords); +typedef void (APIENTRYP PFNGLVERTEXSTREAM2IATIPROC) (GLenum stream, GLint x, GLint y); +typedef void (APIENTRYP PFNGLVERTEXSTREAM2IVATIPROC) (GLenum stream, const GLint *coords); +typedef void (APIENTRYP PFNGLVERTEXSTREAM2FATIPROC) (GLenum stream, GLfloat x, GLfloat y); +typedef void (APIENTRYP PFNGLVERTEXSTREAM2FVATIPROC) (GLenum stream, const GLfloat *coords); +typedef void (APIENTRYP PFNGLVERTEXSTREAM2DATIPROC) (GLenum stream, GLdouble x, GLdouble y); +typedef void (APIENTRYP PFNGLVERTEXSTREAM2DVATIPROC) (GLenum stream, const GLdouble *coords); +typedef void (APIENTRYP PFNGLVERTEXSTREAM3SATIPROC) (GLenum stream, GLshort x, GLshort y, GLshort z); +typedef void (APIENTRYP PFNGLVERTEXSTREAM3SVATIPROC) (GLenum stream, const GLshort *coords); +typedef void (APIENTRYP PFNGLVERTEXSTREAM3IATIPROC) (GLenum stream, GLint x, GLint y, GLint z); +typedef void (APIENTRYP PFNGLVERTEXSTREAM3IVATIPROC) (GLenum stream, const GLint *coords); +typedef void (APIENTRYP PFNGLVERTEXSTREAM3FATIPROC) (GLenum stream, GLfloat x, GLfloat y, GLfloat z); +typedef void (APIENTRYP PFNGLVERTEXSTREAM3FVATIPROC) (GLenum stream, const GLfloat *coords); +typedef void (APIENTRYP PFNGLVERTEXSTREAM3DATIPROC) (GLenum stream, GLdouble x, GLdouble y, GLdouble z); +typedef void (APIENTRYP PFNGLVERTEXSTREAM3DVATIPROC) (GLenum stream, const GLdouble *coords); +typedef void (APIENTRYP PFNGLVERTEXSTREAM4SATIPROC) (GLenum stream, GLshort x, GLshort y, GLshort z, GLshort w); +typedef void (APIENTRYP PFNGLVERTEXSTREAM4SVATIPROC) (GLenum stream, const GLshort *coords); +typedef void (APIENTRYP PFNGLVERTEXSTREAM4IATIPROC) (GLenum stream, GLint x, GLint y, GLint z, GLint w); +typedef void (APIENTRYP PFNGLVERTEXSTREAM4IVATIPROC) (GLenum stream, const GLint *coords); +typedef void (APIENTRYP PFNGLVERTEXSTREAM4FATIPROC) (GLenum stream, GLfloat x, GLfloat y, GLfloat z, GLfloat w); +typedef void (APIENTRYP PFNGLVERTEXSTREAM4FVATIPROC) (GLenum stream, const GLfloat *coords); +typedef void (APIENTRYP PFNGLVERTEXSTREAM4DATIPROC) (GLenum stream, GLdouble x, GLdouble y, GLdouble z, GLdouble w); +typedef void (APIENTRYP PFNGLVERTEXSTREAM4DVATIPROC) (GLenum stream, const GLdouble *coords); +typedef void (APIENTRYP PFNGLNORMALSTREAM3BATIPROC) (GLenum stream, GLbyte nx, GLbyte ny, GLbyte nz); +typedef void (APIENTRYP PFNGLNORMALSTREAM3BVATIPROC) (GLenum stream, const GLbyte *coords); +typedef void (APIENTRYP PFNGLNORMALSTREAM3SATIPROC) (GLenum stream, GLshort nx, GLshort ny, GLshort nz); +typedef void (APIENTRYP PFNGLNORMALSTREAM3SVATIPROC) (GLenum stream, const GLshort *coords); +typedef void (APIENTRYP PFNGLNORMALSTREAM3IATIPROC) (GLenum stream, GLint nx, GLint ny, GLint nz); +typedef void (APIENTRYP PFNGLNORMALSTREAM3IVATIPROC) (GLenum stream, const GLint *coords); +typedef void (APIENTRYP PFNGLNORMALSTREAM3FATIPROC) (GLenum stream, GLfloat nx, GLfloat ny, GLfloat nz); +typedef void (APIENTRYP PFNGLNORMALSTREAM3FVATIPROC) (GLenum stream, const GLfloat *coords); +typedef void (APIENTRYP PFNGLNORMALSTREAM3DATIPROC) (GLenum stream, GLdouble nx, GLdouble ny, GLdouble nz); +typedef void (APIENTRYP PFNGLNORMALSTREAM3DVATIPROC) (GLenum stream, const GLdouble *coords); +typedef void (APIENTRYP PFNGLCLIENTACTIVEVERTEXSTREAMATIPROC) (GLenum stream); +typedef void (APIENTRYP PFNGLVERTEXBLENDENVIATIPROC) (GLenum pname, GLint param); +typedef void (APIENTRYP PFNGLVERTEXBLENDENVFATIPROC) (GLenum pname, GLfloat param); +#endif + +#ifndef GL_ATI_element_array +#define GL_ATI_element_array 1 +#ifdef GL_GLEXT_PROTOTYPES +GLAPI void APIENTRY glElementPointerATI (GLenum, const GLvoid *); +GLAPI void APIENTRY glDrawElementArrayATI (GLenum, GLsizei); +GLAPI void APIENTRY glDrawRangeElementArrayATI (GLenum, GLuint, GLuint, GLsizei); +#endif /* GL_GLEXT_PROTOTYPES */ +typedef void (APIENTRYP PFNGLELEMENTPOINTERATIPROC) (GLenum type, const GLvoid *pointer); +typedef void (APIENTRYP PFNGLDRAWELEMENTARRAYATIPROC) (GLenum mode, GLsizei count); +typedef void (APIENTRYP PFNGLDRAWRANGEELEMENTARRAYATIPROC) (GLenum mode, GLuint start, GLuint end, GLsizei count); +#endif + +#ifndef GL_SUN_mesh_array +#define GL_SUN_mesh_array 1 +#ifdef GL_GLEXT_PROTOTYPES +GLAPI void APIENTRY glDrawMeshArraysSUN (GLenum, GLint, GLsizei, GLsizei); +#endif /* GL_GLEXT_PROTOTYPES */ +typedef void (APIENTRYP PFNGLDRAWMESHARRAYSSUNPROC) (GLenum mode, GLint first, GLsizei count, GLsizei width); +#endif + +#ifndef GL_SUN_slice_accum +#define GL_SUN_slice_accum 1 +#endif + +#ifndef GL_NV_multisample_filter_hint +#define GL_NV_multisample_filter_hint 1 +#endif + +#ifndef GL_NV_depth_clamp +#define GL_NV_depth_clamp 1 +#endif + +#ifndef GL_NV_occlusion_query +#define GL_NV_occlusion_query 1 +#ifdef GL_GLEXT_PROTOTYPES +GLAPI void APIENTRY glGenOcclusionQueriesNV (GLsizei, GLuint *); +GLAPI void APIENTRY glDeleteOcclusionQueriesNV (GLsizei, const GLuint *); +GLAPI GLboolean APIENTRY glIsOcclusionQueryNV (GLuint); +GLAPI void APIENTRY glBeginOcclusionQueryNV (GLuint); +GLAPI void APIENTRY glEndOcclusionQueryNV (void); +GLAPI void APIENTRY glGetOcclusionQueryivNV (GLuint, GLenum, GLint *); +GLAPI void APIENTRY glGetOcclusionQueryuivNV (GLuint, GLenum, GLuint *); +#endif /* GL_GLEXT_PROTOTYPES */ +typedef void (APIENTRYP PFNGLGENOCCLUSIONQUERIESNVPROC) (GLsizei n, GLuint *ids); +typedef void (APIENTRYP PFNGLDELETEOCCLUSIONQUERIESNVPROC) (GLsizei n, const GLuint *ids); +typedef GLboolean (APIENTRYP PFNGLISOCCLUSIONQUERYNVPROC) (GLuint id); +typedef void (APIENTRYP PFNGLBEGINOCCLUSIONQUERYNVPROC) (GLuint id); +typedef void (APIENTRYP PFNGLENDOCCLUSIONQUERYNVPROC) (void); +typedef void (APIENTRYP PFNGLGETOCCLUSIONQUERYIVNVPROC) (GLuint id, GLenum pname, GLint *params); +typedef void (APIENTRYP PFNGLGETOCCLUSIONQUERYUIVNVPROC) (GLuint id, GLenum pname, GLuint *params); +#endif + +#ifndef GL_NV_point_sprite +#define GL_NV_point_sprite 1 +#ifdef GL_GLEXT_PROTOTYPES +GLAPI void APIENTRY glPointParameteriNV (GLenum, GLint); +GLAPI void APIENTRY glPointParameterivNV (GLenum, const GLint *); +#endif /* GL_GLEXT_PROTOTYPES */ +typedef void (APIENTRYP PFNGLPOINTPARAMETERINVPROC) (GLenum pname, GLint param); +typedef void (APIENTRYP PFNGLPOINTPARAMETERIVNVPROC) (GLenum pname, const GLint *params); +#endif + +#ifndef GL_NV_texture_shader3 +#define GL_NV_texture_shader3 1 +#endif + +#ifndef GL_NV_vertex_program1_1 +#define GL_NV_vertex_program1_1 1 +#endif + +#ifndef GL_EXT_shadow_funcs +#define GL_EXT_shadow_funcs 1 +#endif + +#ifndef GL_EXT_stencil_two_side +#define GL_EXT_stencil_two_side 1 +#ifdef GL_GLEXT_PROTOTYPES +GLAPI void APIENTRY glActiveStencilFaceEXT (GLenum); +#endif /* GL_GLEXT_PROTOTYPES */ +typedef void (APIENTRYP PFNGLACTIVESTENCILFACEEXTPROC) (GLenum face); +#endif + +#ifndef GL_ATI_text_fragment_shader +#define GL_ATI_text_fragment_shader 1 +#endif + +#ifndef GL_APPLE_client_storage +#define GL_APPLE_client_storage 1 +#endif + +#ifndef GL_APPLE_element_array +#define GL_APPLE_element_array 1 +#ifdef GL_GLEXT_PROTOTYPES +GLAPI void APIENTRY glElementPointerAPPLE (GLenum, const GLvoid *); +GLAPI void APIENTRY glDrawElementArrayAPPLE (GLenum, GLint, GLsizei); +GLAPI void APIENTRY glDrawRangeElementArrayAPPLE (GLenum, GLuint, GLuint, GLint, GLsizei); +GLAPI void APIENTRY glMultiDrawElementArrayAPPLE (GLenum, const GLint *, const GLsizei *, GLsizei); +GLAPI void APIENTRY glMultiDrawRangeElementArrayAPPLE (GLenum, GLuint, GLuint, const GLint *, const GLsizei *, GLsizei); +#endif /* GL_GLEXT_PROTOTYPES */ +typedef void (APIENTRYP PFNGLELEMENTPOINTERAPPLEPROC) (GLenum type, const GLvoid *pointer); +typedef void (APIENTRYP PFNGLDRAWELEMENTARRAYAPPLEPROC) (GLenum mode, GLint first, GLsizei count); +typedef void (APIENTRYP PFNGLDRAWRANGEELEMENTARRAYAPPLEPROC) (GLenum mode, GLuint start, GLuint end, GLint first, GLsizei count); +typedef void (APIENTRYP PFNGLMULTIDRAWELEMENTARRAYAPPLEPROC) (GLenum mode, const GLint *first, const GLsizei *count, GLsizei primcount); +typedef void (APIENTRYP PFNGLMULTIDRAWRANGEELEMENTARRAYAPPLEPROC) (GLenum mode, GLuint start, GLuint end, const GLint *first, const GLsizei *count, GLsizei primcount); +#endif + +#ifndef GL_APPLE_fence +#define GL_APPLE_fence 1 +#ifdef GL_GLEXT_PROTOTYPES +GLAPI void APIENTRY glGenFencesAPPLE (GLsizei, GLuint *); +GLAPI void APIENTRY glDeleteFencesAPPLE (GLsizei, const GLuint *); +GLAPI void APIENTRY glSetFenceAPPLE (GLuint); +GLAPI GLboolean APIENTRY glIsFenceAPPLE (GLuint); +GLAPI GLboolean APIENTRY glTestFenceAPPLE (GLuint); +GLAPI void APIENTRY glFinishFenceAPPLE (GLuint); +GLAPI GLboolean APIENTRY glTestObjectAPPLE (GLenum, GLuint); +GLAPI void APIENTRY glFinishObjectAPPLE (GLenum, GLint); +#endif /* GL_GLEXT_PROTOTYPES */ +typedef void (APIENTRYP PFNGLGENFENCESAPPLEPROC) (GLsizei n, GLuint *fences); +typedef void (APIENTRYP PFNGLDELETEFENCESAPPLEPROC) (GLsizei n, const GLuint *fences); +typedef void (APIENTRYP PFNGLSETFENCEAPPLEPROC) (GLuint fence); +typedef GLboolean (APIENTRYP PFNGLISFENCEAPPLEPROC) (GLuint fence); +typedef GLboolean (APIENTRYP PFNGLTESTFENCEAPPLEPROC) (GLuint fence); +typedef void (APIENTRYP PFNGLFINISHFENCEAPPLEPROC) (GLuint fence); +typedef GLboolean (APIENTRYP PFNGLTESTOBJECTAPPLEPROC) (GLenum object, GLuint name); +typedef void (APIENTRYP PFNGLFINISHOBJECTAPPLEPROC) (GLenum object, GLint name); +#endif + +#ifndef GL_APPLE_vertex_array_object +#define GL_APPLE_vertex_array_object 1 +#ifdef GL_GLEXT_PROTOTYPES +GLAPI void APIENTRY glBindVertexArrayAPPLE (GLuint); +GLAPI void APIENTRY glDeleteVertexArraysAPPLE (GLsizei, const GLuint *); +GLAPI void APIENTRY glGenVertexArraysAPPLE (GLsizei, const GLuint *); +GLAPI GLboolean APIENTRY glIsVertexArrayAPPLE (GLuint); +#endif /* GL_GLEXT_PROTOTYPES */ +typedef void (APIENTRYP PFNGLBINDVERTEXARRAYAPPLEPROC) (GLuint array); +typedef void (APIENTRYP PFNGLDELETEVERTEXARRAYSAPPLEPROC) (GLsizei n, const GLuint *arrays); +typedef void (APIENTRYP PFNGLGENVERTEXARRAYSAPPLEPROC) (GLsizei n, const GLuint *arrays); +typedef GLboolean (APIENTRYP PFNGLISVERTEXARRAYAPPLEPROC) (GLuint array); +#endif + +#ifndef GL_APPLE_vertex_array_range +#define GL_APPLE_vertex_array_range 1 +#ifdef GL_GLEXT_PROTOTYPES +GLAPI void APIENTRY glVertexArrayRangeAPPLE (GLsizei, GLvoid *); +GLAPI void APIENTRY glFlushVertexArrayRangeAPPLE (GLsizei, GLvoid *); +GLAPI void APIENTRY glVertexArrayParameteriAPPLE (GLenum, GLint); +#endif /* GL_GLEXT_PROTOTYPES */ +typedef void (APIENTRYP PFNGLVERTEXARRAYRANGEAPPLEPROC) (GLsizei length, GLvoid *pointer); +typedef void (APIENTRYP PFNGLFLUSHVERTEXARRAYRANGEAPPLEPROC) (GLsizei length, GLvoid *pointer); +typedef void (APIENTRYP PFNGLVERTEXARRAYPARAMETERIAPPLEPROC) (GLenum pname, GLint param); +#endif + +#ifndef GL_APPLE_ycbcr_422 +#define GL_APPLE_ycbcr_422 1 +#endif + +#ifndef GL_S3_s3tc +#define GL_S3_s3tc 1 +#endif + +#ifndef GL_ATI_draw_buffers +#define GL_ATI_draw_buffers 1 +#ifdef GL_GLEXT_PROTOTYPES +GLAPI void APIENTRY glDrawBuffersATI (GLsizei, const GLenum *); +#endif /* GL_GLEXT_PROTOTYPES */ +typedef void (APIENTRYP PFNGLDRAWBUFFERSATIPROC) (GLsizei n, const GLenum *bufs); +#endif + +#ifndef GL_ATI_pixel_format_float +#define GL_ATI_pixel_format_float 1 +/* This is really a WGL extension, but defines some associated GL enums. + * ATI does not export "GL_ATI_pixel_format_float" in the GL_EXTENSIONS string. + */ +#endif + +#ifndef GL_ATI_texture_env_combine3 +#define GL_ATI_texture_env_combine3 1 +#endif + +#ifndef GL_ATI_texture_float +#define GL_ATI_texture_float 1 +#endif + +#ifndef GL_NV_float_buffer +#define GL_NV_float_buffer 1 +#endif + +#ifndef GL_NV_fragment_program +#define GL_NV_fragment_program 1 +/* Some NV_fragment_program entry points are shared with ARB_vertex_program. */ +#ifdef GL_GLEXT_PROTOTYPES +GLAPI void APIENTRY glProgramNamedParameter4fNV (GLuint, GLsizei, const GLubyte *, GLfloat, GLfloat, GLfloat, GLfloat); +GLAPI void APIENTRY glProgramNamedParameter4dNV (GLuint, GLsizei, const GLubyte *, GLdouble, GLdouble, GLdouble, GLdouble); +GLAPI void APIENTRY glProgramNamedParameter4fvNV (GLuint, GLsizei, const GLubyte *, const GLfloat *); +GLAPI void APIENTRY glProgramNamedParameter4dvNV (GLuint, GLsizei, const GLubyte *, const GLdouble *); +GLAPI void APIENTRY glGetProgramNamedParameterfvNV (GLuint, GLsizei, const GLubyte *, GLfloat *); +GLAPI void APIENTRY glGetProgramNamedParameterdvNV (GLuint, GLsizei, const GLubyte *, GLdouble *); +#endif /* GL_GLEXT_PROTOTYPES */ +typedef void (APIENTRYP PFNGLPROGRAMNAMEDPARAMETER4FNVPROC) (GLuint id, GLsizei len, const GLubyte *name, GLfloat x, GLfloat y, GLfloat z, GLfloat w); +typedef void (APIENTRYP PFNGLPROGRAMNAMEDPARAMETER4DNVPROC) (GLuint id, GLsizei len, const GLubyte *name, GLdouble x, GLdouble y, GLdouble z, GLdouble w); +typedef void (APIENTRYP PFNGLPROGRAMNAMEDPARAMETER4FVNVPROC) (GLuint id, GLsizei len, const GLubyte *name, const GLfloat *v); +typedef void (APIENTRYP PFNGLPROGRAMNAMEDPARAMETER4DVNVPROC) (GLuint id, GLsizei len, const GLubyte *name, const GLdouble *v); +typedef void (APIENTRYP PFNGLGETPROGRAMNAMEDPARAMETERFVNVPROC) (GLuint id, GLsizei len, const GLubyte *name, GLfloat *params); +typedef void (APIENTRYP PFNGLGETPROGRAMNAMEDPARAMETERDVNVPROC) (GLuint id, GLsizei len, const GLubyte *name, GLdouble *params); +#endif + +#ifndef GL_NV_half_float +#define GL_NV_half_float 1 +#ifdef GL_GLEXT_PROTOTYPES +GLAPI void APIENTRY glVertex2hNV (GLhalfNV, GLhalfNV); +GLAPI void APIENTRY glVertex2hvNV (const GLhalfNV *); +GLAPI void APIENTRY glVertex3hNV (GLhalfNV, GLhalfNV, GLhalfNV); +GLAPI void APIENTRY glVertex3hvNV (const GLhalfNV *); +GLAPI void APIENTRY glVertex4hNV (GLhalfNV, GLhalfNV, GLhalfNV, GLhalfNV); +GLAPI void APIENTRY glVertex4hvNV (const GLhalfNV *); +GLAPI void APIENTRY glNormal3hNV (GLhalfNV, GLhalfNV, GLhalfNV); +GLAPI void APIENTRY glNormal3hvNV (const GLhalfNV *); +GLAPI void APIENTRY glColor3hNV (GLhalfNV, GLhalfNV, GLhalfNV); +GLAPI void APIENTRY glColor3hvNV (const GLhalfNV *); +GLAPI void APIENTRY glColor4hNV (GLhalfNV, GLhalfNV, GLhalfNV, GLhalfNV); +GLAPI void APIENTRY glColor4hvNV (const GLhalfNV *); +GLAPI void APIENTRY glTexCoord1hNV (GLhalfNV); +GLAPI void APIENTRY glTexCoord1hvNV (const GLhalfNV *); +GLAPI void APIENTRY glTexCoord2hNV (GLhalfNV, GLhalfNV); +GLAPI void APIENTRY glTexCoord2hvNV (const GLhalfNV *); +GLAPI void APIENTRY glTexCoord3hNV (GLhalfNV, GLhalfNV, GLhalfNV); +GLAPI void APIENTRY glTexCoord3hvNV (const GLhalfNV *); +GLAPI void APIENTRY glTexCoord4hNV (GLhalfNV, GLhalfNV, GLhalfNV, GLhalfNV); +GLAPI void APIENTRY glTexCoord4hvNV (const GLhalfNV *); +GLAPI void APIENTRY glMultiTexCoord1hNV (GLenum, GLhalfNV); +GLAPI void APIENTRY glMultiTexCoord1hvNV (GLenum, const GLhalfNV *); +GLAPI void APIENTRY glMultiTexCoord2hNV (GLenum, GLhalfNV, GLhalfNV); +GLAPI void APIENTRY glMultiTexCoord2hvNV (GLenum, const GLhalfNV *); +GLAPI void APIENTRY glMultiTexCoord3hNV (GLenum, GLhalfNV, GLhalfNV, GLhalfNV); +GLAPI void APIENTRY glMultiTexCoord3hvNV (GLenum, const GLhalfNV *); +GLAPI void APIENTRY glMultiTexCoord4hNV (GLenum, GLhalfNV, GLhalfNV, GLhalfNV, GLhalfNV); +GLAPI void APIENTRY glMultiTexCoord4hvNV (GLenum, const GLhalfNV *); +GLAPI void APIENTRY glFogCoordhNV (GLhalfNV); +GLAPI void APIENTRY glFogCoordhvNV (const GLhalfNV *); +GLAPI void APIENTRY glSecondaryColor3hNV (GLhalfNV, GLhalfNV, GLhalfNV); +GLAPI void APIENTRY glSecondaryColor3hvNV (const GLhalfNV *); +GLAPI void APIENTRY glVertexWeighthNV (GLhalfNV); +GLAPI void APIENTRY glVertexWeighthvNV (const GLhalfNV *); +GLAPI void APIENTRY glVertexAttrib1hNV (GLuint, GLhalfNV); +GLAPI void APIENTRY glVertexAttrib1hvNV (GLuint, const GLhalfNV *); +GLAPI void APIENTRY glVertexAttrib2hNV (GLuint, GLhalfNV, GLhalfNV); +GLAPI void APIENTRY glVertexAttrib2hvNV (GLuint, const GLhalfNV *); +GLAPI void APIENTRY glVertexAttrib3hNV (GLuint, GLhalfNV, GLhalfNV, GLhalfNV); +GLAPI void APIENTRY glVertexAttrib3hvNV (GLuint, const GLhalfNV *); +GLAPI void APIENTRY glVertexAttrib4hNV (GLuint, GLhalfNV, GLhalfNV, GLhalfNV, GLhalfNV); +GLAPI void APIENTRY glVertexAttrib4hvNV (GLuint, const GLhalfNV *); +GLAPI void APIENTRY glVertexAttribs1hvNV (GLuint, GLsizei, const GLhalfNV *); +GLAPI void APIENTRY glVertexAttribs2hvNV (GLuint, GLsizei, const GLhalfNV *); +GLAPI void APIENTRY glVertexAttribs3hvNV (GLuint, GLsizei, const GLhalfNV *); +GLAPI void APIENTRY glVertexAttribs4hvNV (GLuint, GLsizei, const GLhalfNV *); +#endif /* GL_GLEXT_PROTOTYPES */ +typedef void (APIENTRYP PFNGLVERTEX2HNVPROC) (GLhalfNV x, GLhalfNV y); +typedef void (APIENTRYP PFNGLVERTEX2HVNVPROC) (const GLhalfNV *v); +typedef void (APIENTRYP PFNGLVERTEX3HNVPROC) (GLhalfNV x, GLhalfNV y, GLhalfNV z); +typedef void (APIENTRYP PFNGLVERTEX3HVNVPROC) (const GLhalfNV *v); +typedef void (APIENTRYP PFNGLVERTEX4HNVPROC) (GLhalfNV x, GLhalfNV y, GLhalfNV z, GLhalfNV w); +typedef void (APIENTRYP PFNGLVERTEX4HVNVPROC) (const GLhalfNV *v); +typedef void (APIENTRYP PFNGLNORMAL3HNVPROC) (GLhalfNV nx, GLhalfNV ny, GLhalfNV nz); +typedef void (APIENTRYP PFNGLNORMAL3HVNVPROC) (const GLhalfNV *v); +typedef void (APIENTRYP PFNGLCOLOR3HNVPROC) (GLhalfNV red, GLhalfNV green, GLhalfNV blue); +typedef void (APIENTRYP PFNGLCOLOR3HVNVPROC) (const GLhalfNV *v); +typedef void (APIENTRYP PFNGLCOLOR4HNVPROC) (GLhalfNV red, GLhalfNV green, GLhalfNV blue, GLhalfNV alpha); +typedef void (APIENTRYP PFNGLCOLOR4HVNVPROC) (const GLhalfNV *v); +typedef void (APIENTRYP PFNGLTEXCOORD1HNVPROC) (GLhalfNV s); +typedef void (APIENTRYP PFNGLTEXCOORD1HVNVPROC) (const GLhalfNV *v); +typedef void (APIENTRYP PFNGLTEXCOORD2HNVPROC) (GLhalfNV s, GLhalfNV t); +typedef void (APIENTRYP PFNGLTEXCOORD2HVNVPROC) (const GLhalfNV *v); +typedef void (APIENTRYP PFNGLTEXCOORD3HNVPROC) (GLhalfNV s, GLhalfNV t, GLhalfNV r); +typedef void (APIENTRYP PFNGLTEXCOORD3HVNVPROC) (const GLhalfNV *v); +typedef void (APIENTRYP PFNGLTEXCOORD4HNVPROC) (GLhalfNV s, GLhalfNV t, GLhalfNV r, GLhalfNV q); +typedef void (APIENTRYP PFNGLTEXCOORD4HVNVPROC) (const GLhalfNV *v); +typedef void (APIENTRYP PFNGLMULTITEXCOORD1HNVPROC) (GLenum target, GLhalfNV s); +typedef void (APIENTRYP PFNGLMULTITEXCOORD1HVNVPROC) (GLenum target, const GLhalfNV *v); +typedef void (APIENTRYP PFNGLMULTITEXCOORD2HNVPROC) (GLenum target, GLhalfNV s, GLhalfNV t); +typedef void (APIENTRYP PFNGLMULTITEXCOORD2HVNVPROC) (GLenum target, const GLhalfNV *v); +typedef void (APIENTRYP PFNGLMULTITEXCOORD3HNVPROC) (GLenum target, GLhalfNV s, GLhalfNV t, GLhalfNV r); +typedef void (APIENTRYP PFNGLMULTITEXCOORD3HVNVPROC) (GLenum target, const GLhalfNV *v); +typedef void (APIENTRYP PFNGLMULTITEXCOORD4HNVPROC) (GLenum target, GLhalfNV s, GLhalfNV t, GLhalfNV r, GLhalfNV q); +typedef void (APIENTRYP PFNGLMULTITEXCOORD4HVNVPROC) (GLenum target, const GLhalfNV *v); +typedef void (APIENTRYP PFNGLFOGCOORDHNVPROC) (GLhalfNV fog); +typedef void (APIENTRYP PFNGLFOGCOORDHVNVPROC) (const GLhalfNV *fog); +typedef void (APIENTRYP PFNGLSECONDARYCOLOR3HNVPROC) (GLhalfNV red, GLhalfNV green, GLhalfNV blue); +typedef void (APIENTRYP PFNGLSECONDARYCOLOR3HVNVPROC) (const GLhalfNV *v); +typedef void (APIENTRYP PFNGLVERTEXWEIGHTHNVPROC) (GLhalfNV weight); +typedef void (APIENTRYP PFNGLVERTEXWEIGHTHVNVPROC) (const GLhalfNV *weight); +typedef void (APIENTRYP PFNGLVERTEXATTRIB1HNVPROC) (GLuint index, GLhalfNV x); +typedef void (APIENTRYP PFNGLVERTEXATTRIB1HVNVPROC) (GLuint index, const GLhalfNV *v); +typedef void (APIENTRYP PFNGLVERTEXATTRIB2HNVPROC) (GLuint index, GLhalfNV x, GLhalfNV y); +typedef void (APIENTRYP PFNGLVERTEXATTRIB2HVNVPROC) (GLuint index, const GLhalfNV *v); +typedef void (APIENTRYP PFNGLVERTEXATTRIB3HNVPROC) (GLuint index, GLhalfNV x, GLhalfNV y, GLhalfNV z); +typedef void (APIENTRYP PFNGLVERTEXATTRIB3HVNVPROC) (GLuint index, const GLhalfNV *v); +typedef void (APIENTRYP PFNGLVERTEXATTRIB4HNVPROC) (GLuint index, GLhalfNV x, GLhalfNV y, GLhalfNV z, GLhalfNV w); +typedef void (APIENTRYP PFNGLVERTEXATTRIB4HVNVPROC) (GLuint index, const GLhalfNV *v); +typedef void (APIENTRYP PFNGLVERTEXATTRIBS1HVNVPROC) (GLuint index, GLsizei n, const GLhalfNV *v); +typedef void (APIENTRYP PFNGLVERTEXATTRIBS2HVNVPROC) (GLuint index, GLsizei n, const GLhalfNV *v); +typedef void (APIENTRYP PFNGLVERTEXATTRIBS3HVNVPROC) (GLuint index, GLsizei n, const GLhalfNV *v); +typedef void (APIENTRYP PFNGLVERTEXATTRIBS4HVNVPROC) (GLuint index, GLsizei n, const GLhalfNV *v); +#endif + +#ifndef GL_NV_pixel_data_range +#define GL_NV_pixel_data_range 1 +#ifdef GL_GLEXT_PROTOTYPES +GLAPI void APIENTRY glPixelDataRangeNV (GLenum, GLsizei, GLvoid *); +GLAPI void APIENTRY glFlushPixelDataRangeNV (GLenum); +#endif /* GL_GLEXT_PROTOTYPES */ +typedef void (APIENTRYP PFNGLPIXELDATARANGENVPROC) (GLenum target, GLsizei length, GLvoid *pointer); +typedef void (APIENTRYP PFNGLFLUSHPIXELDATARANGENVPROC) (GLenum target); +#endif + +#ifndef GL_NV_primitive_restart +#define GL_NV_primitive_restart 1 +#ifdef GL_GLEXT_PROTOTYPES +GLAPI void APIENTRY glPrimitiveRestartNV (void); +GLAPI void APIENTRY glPrimitiveRestartIndexNV (GLuint); +#endif /* GL_GLEXT_PROTOTYPES */ +typedef void (APIENTRYP PFNGLPRIMITIVERESTARTNVPROC) (void); +typedef void (APIENTRYP PFNGLPRIMITIVERESTARTINDEXNVPROC) (GLuint index); +#endif + +#ifndef GL_NV_texture_expand_normal +#define GL_NV_texture_expand_normal 1 +#endif + +#ifndef GL_NV_vertex_program2 +#define GL_NV_vertex_program2 1 +#endif + +#ifndef GL_ATI_map_object_buffer +#define GL_ATI_map_object_buffer 1 +#ifdef GL_GLEXT_PROTOTYPES +GLAPI GLvoid* APIENTRY glMapObjectBufferATI (GLuint); +GLAPI void APIENTRY glUnmapObjectBufferATI (GLuint); +#endif /* GL_GLEXT_PROTOTYPES */ +typedef GLvoid* (APIENTRYP PFNGLMAPOBJECTBUFFERATIPROC) (GLuint buffer); +typedef void (APIENTRYP PFNGLUNMAPOBJECTBUFFERATIPROC) (GLuint buffer); +#endif + +#ifndef GL_ATI_separate_stencil +#define GL_ATI_separate_stencil 1 +#ifdef GL_GLEXT_PROTOTYPES +GLAPI void APIENTRY glStencilOpSeparateATI (GLenum, GLenum, GLenum, GLenum); +GLAPI void APIENTRY glStencilFuncSeparateATI (GLenum, GLenum, GLint, GLuint); +#endif /* GL_GLEXT_PROTOTYPES */ +typedef void (APIENTRYP PFNGLSTENCILOPSEPARATEATIPROC) (GLenum face, GLenum sfail, GLenum dpfail, GLenum dppass); +typedef void (APIENTRYP PFNGLSTENCILFUNCSEPARATEATIPROC) (GLenum frontfunc, GLenum backfunc, GLint ref, GLuint mask); +#endif + +#ifndef GL_ATI_vertex_attrib_array_object +#define GL_ATI_vertex_attrib_array_object 1 +#ifdef GL_GLEXT_PROTOTYPES +GLAPI void APIENTRY glVertexAttribArrayObjectATI (GLuint, GLint, GLenum, GLboolean, GLsizei, GLuint, GLuint); +GLAPI void APIENTRY glGetVertexAttribArrayObjectfvATI (GLuint, GLenum, GLfloat *); +GLAPI void APIENTRY glGetVertexAttribArrayObjectivATI (GLuint, GLenum, GLint *); +#endif /* GL_GLEXT_PROTOTYPES */ +typedef void (APIENTRYP PFNGLVERTEXATTRIBARRAYOBJECTATIPROC) (GLuint index, GLint size, GLenum type, GLboolean normalized, GLsizei stride, GLuint buffer, GLuint offset); +typedef void (APIENTRYP PFNGLGETVERTEXATTRIBARRAYOBJECTFVATIPROC) (GLuint index, GLenum pname, GLfloat *params); +typedef void (APIENTRYP PFNGLGETVERTEXATTRIBARRAYOBJECTIVATIPROC) (GLuint index, GLenum pname, GLint *params); +#endif + +#ifndef GL_OES_read_format +#define GL_OES_read_format 1 +#endif + +#ifndef GL_EXT_depth_bounds_test +#define GL_EXT_depth_bounds_test 1 +#ifdef GL_GLEXT_PROTOTYPES +GLAPI void APIENTRY glDepthBoundsEXT (GLclampd, GLclampd); +#endif /* GL_GLEXT_PROTOTYPES */ +typedef void (APIENTRYP PFNGLDEPTHBOUNDSEXTPROC) (GLclampd zmin, GLclampd zmax); +#endif + +#ifndef GL_EXT_texture_mirror_clamp +#define GL_EXT_texture_mirror_clamp 1 +#endif + +#ifndef GL_EXT_blend_equation_separate +#define GL_EXT_blend_equation_separate 1 +#ifdef GL_GLEXT_PROTOTYPES +GLAPI void APIENTRY glBlendEquationSeparateEXT (GLenum, GLenum); +#endif /* GL_GLEXT_PROTOTYPES */ +typedef void (APIENTRYP PFNGLBLENDEQUATIONSEPARATEEXTPROC) (GLenum modeRGB, GLenum modeAlpha); +#endif + +#ifndef GL_MESA_pack_invert +#define GL_MESA_pack_invert 1 +#endif + +#ifndef GL_MESA_ycbcr_texture +#define GL_MESA_ycbcr_texture 1 +#endif + +#ifndef GL_EXT_pixel_buffer_object +#define GL_EXT_pixel_buffer_object 1 +#endif + +#ifndef GL_NV_fragment_program_option +#define GL_NV_fragment_program_option 1 +#endif + +#ifndef GL_NV_fragment_program2 +#define GL_NV_fragment_program2 1 +#endif + +#ifndef GL_NV_vertex_program2_option +#define GL_NV_vertex_program2_option 1 +#endif + +#ifndef GL_NV_vertex_program3 +#define GL_NV_vertex_program3 1 +#endif + +#ifndef GL_EXT_framebuffer_object +#define GL_EXT_framebuffer_object 1 +#ifdef GL_GLEXT_PROTOTYPES +GLAPI GLboolean APIENTRY glIsRenderbufferEXT (GLuint); +GLAPI void APIENTRY glBindRenderbufferEXT (GLenum, GLuint); +GLAPI void APIENTRY glDeleteRenderbuffersEXT (GLsizei, const GLuint *); +GLAPI void APIENTRY glGenRenderbuffersEXT (GLsizei, GLuint *); +GLAPI void APIENTRY glRenderbufferStorageEXT (GLenum, GLenum, GLsizei, GLsizei); +GLAPI void APIENTRY glGetRenderbufferParameterivEXT (GLenum, GLenum, GLint *); +GLAPI GLboolean APIENTRY glIsFramebufferEXT (GLuint); +GLAPI void APIENTRY glBindFramebufferEXT (GLenum, GLuint); +GLAPI void APIENTRY glDeleteFramebuffersEXT (GLsizei, const GLuint *); +GLAPI void APIENTRY glGenFramebuffersEXT (GLsizei, GLuint *); +GLAPI GLenum APIENTRY glCheckFramebufferStatusEXT (GLenum); +GLAPI void APIENTRY glFramebufferTexture1DEXT (GLenum, GLenum, GLenum, GLuint, GLint); +GLAPI void APIENTRY glFramebufferTexture2DEXT (GLenum, GLenum, GLenum, GLuint, GLint); +GLAPI void APIENTRY glFramebufferTexture3DEXT (GLenum, GLenum, GLenum, GLuint, GLint, GLint); +GLAPI void APIENTRY glFramebufferRenderbufferEXT (GLenum, GLenum, GLenum, GLuint); +GLAPI void APIENTRY glGetFramebufferAttachmentParameterivEXT (GLenum, GLenum, GLenum, GLint *); +GLAPI void APIENTRY glGenerateMipmapEXT (GLenum); +#endif /* GL_GLEXT_PROTOTYPES */ +typedef GLboolean (APIENTRYP PFNGLISRENDERBUFFEREXTPROC) (GLuint renderbuffer); +typedef void (APIENTRYP PFNGLBINDRENDERBUFFEREXTPROC) (GLenum target, GLuint renderbuffer); +typedef void (APIENTRYP PFNGLDELETERENDERBUFFERSEXTPROC) (GLsizei n, const GLuint *renderbuffers); +typedef void (APIENTRYP PFNGLGENRENDERBUFFERSEXTPROC) (GLsizei n, GLuint *renderbuffers); +typedef void (APIENTRYP PFNGLRENDERBUFFERSTORAGEEXTPROC) (GLenum target, GLenum internalformat, GLsizei width, GLsizei height); +typedef void (APIENTRYP PFNGLGETRENDERBUFFERPARAMETERIVEXTPROC) (GLenum target, GLenum pname, GLint *params); +typedef GLboolean (APIENTRYP PFNGLISFRAMEBUFFEREXTPROC) (GLuint framebuffer); +typedef void (APIENTRYP PFNGLBINDFRAMEBUFFEREXTPROC) (GLenum target, GLuint framebuffer); +typedef void (APIENTRYP PFNGLDELETEFRAMEBUFFERSEXTPROC) (GLsizei n, const GLuint *framebuffers); +typedef void (APIENTRYP PFNGLGENFRAMEBUFFERSEXTPROC) (GLsizei n, GLuint *framebuffers); +typedef GLenum (APIENTRYP PFNGLCHECKFRAMEBUFFERSTATUSEXTPROC) (GLenum target); +typedef void (APIENTRYP PFNGLFRAMEBUFFERTEXTURE1DEXTPROC) (GLenum target, GLenum attachment, GLenum textarget, GLuint texture, GLint level); +typedef void (APIENTRYP PFNGLFRAMEBUFFERTEXTURE2DEXTPROC) (GLenum target, GLenum attachment, GLenum textarget, GLuint texture, GLint level); +typedef void (APIENTRYP PFNGLFRAMEBUFFERTEXTURE3DEXTPROC) (GLenum target, GLenum attachment, GLenum textarget, GLuint texture, GLint level, GLint zoffset); +typedef void (APIENTRYP PFNGLFRAMEBUFFERRENDERBUFFEREXTPROC) (GLenum target, GLenum attachment, GLenum renderbuffertarget, GLuint renderbuffer); +typedef void (APIENTRYP PFNGLGETFRAMEBUFFERATTACHMENTPARAMETERIVEXTPROC) (GLenum target, GLenum attachment, GLenum pname, GLint *params); +typedef void (APIENTRYP PFNGLGENERATEMIPMAPEXTPROC) (GLenum target); +#endif + +#ifndef GL_GREMEDY_string_marker +#define GL_GREMEDY_string_marker 1 +#ifdef GL_GLEXT_PROTOTYPES +GLAPI void APIENTRY glStringMarkerGREMEDY (GLsizei, const GLvoid *); +#endif /* GL_GLEXT_PROTOTYPES */ +typedef void (APIENTRYP PFNGLSTRINGMARKERGREMEDYPROC) (GLsizei len, const GLvoid *string); +#endif + + +#ifdef __cplusplus +} +#endif + +#endif diff --git a/opengl/glut32.lib b/opengl/glut32.lib new file mode 100644 index 00000000..494cad96 Binary files /dev/null and b/opengl/glut32.lib differ diff --git a/opengl/wglew.h b/opengl/wglew.h new file mode 100644 index 00000000..d9dd3f25 --- /dev/null +++ b/opengl/wglew.h @@ -0,0 +1,1165 @@ +/* +** The OpenGL Extension Wrangler Library +** Copyright (C) 2002-2008, Milan Ikits +** Copyright (C) 2002-2008, Marcelo E. Magallon +** Copyright (C) 2002, Lev Povalahev +** All rights reserved. +** +** Redistribution and use in source and binary forms, with or without +** modification, are permitted provided that the following conditions are met: +** +** * Redistributions of source code must retain the above copyright notice, +** this list of conditions and the following disclaimer. +** * Redistributions in binary form must reproduce the above copyright notice, +** this list of conditions and the following disclaimer in the documentation +** and/or other materials provided with the distribution. +** * The name of the author may be used to endorse or promote products +** derived from this software without specific prior written permission. +** +** THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" +** AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE +** IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE +** ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE +** LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR +** CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF +** SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS +** INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN +** CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) +** ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF +** THE POSSIBILITY OF SUCH DAMAGE. +*/ + +/* +** Copyright (c) 2007 The Khronos Group Inc. +** +** Permission is hereby granted, free of charge, to any person obtaining a +** copy of this software and/or associated documentation files (the +** "Materials"), to deal in the Materials without restriction, including +** without limitation the rights to use, copy, modify, merge, publish, +** distribute, sublicense, and/or sell copies of the Materials, and to +** permit persons to whom the Materials are furnished to do so, subject to +** the following conditions: +** +** The above copyright notice and this permission notice shall be included +** in all copies or substantial portions of the Materials. +** +** THE MATERIALS ARE PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, +** EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF +** MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. +** IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY +** CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, +** TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE +** MATERIALS OR THE USE OR OTHER DEALINGS IN THE MATERIALS. +*/ + +#ifndef __wglew_h__ +#define __wglew_h__ +#define __WGLEW_H__ + +#ifdef __wglext_h_ +#error wglext.h included before wglew.h +#endif + +#define __wglext_h_ + +#if !defined(APIENTRY) && !defined(__CYGWIN__) +# ifndef WIN32_LEAN_AND_MEAN +# define WIN32_LEAN_AND_MEAN 1 +# endif +#include +#endif + +/* + * GLEW_STATIC needs to be set when using the static version. + * GLEW_BUILD is set when building the DLL version. + */ +#ifdef GLEW_STATIC +# define GLEWAPI extern +#else +# ifdef GLEW_BUILD +# define GLEWAPI extern __declspec(dllexport) +# else +# define GLEWAPI extern __declspec(dllimport) +# endif +#endif + +#ifdef __cplusplus +extern "C" { +#endif + +/* -------------------------- WGL_3DFX_multisample ------------------------- */ + +#ifndef WGL_3DFX_multisample +#define WGL_3DFX_multisample 1 + +#define WGL_SAMPLE_BUFFERS_3DFX 0x2060 +#define WGL_SAMPLES_3DFX 0x2061 + +#define WGLEW_3DFX_multisample WGLEW_GET_VAR(__WGLEW_3DFX_multisample) + +#endif /* WGL_3DFX_multisample */ + +/* ------------------------- WGL_3DL_stereo_control ------------------------ */ + +#ifndef WGL_3DL_stereo_control +#define WGL_3DL_stereo_control 1 + +#define WGL_STEREO_EMITTER_ENABLE_3DL 0x2055 +#define WGL_STEREO_EMITTER_DISABLE_3DL 0x2056 +#define WGL_STEREO_POLARITY_NORMAL_3DL 0x2057 +#define WGL_STEREO_POLARITY_INVERT_3DL 0x2058 + +typedef BOOL (WINAPI * PFNWGLSETSTEREOEMITTERSTATE3DLPROC) (HDC hDC, UINT uState); + +#define wglSetStereoEmitterState3DL WGLEW_GET_FUN(__wglewSetStereoEmitterState3DL) + +#define WGLEW_3DL_stereo_control WGLEW_GET_VAR(__WGLEW_3DL_stereo_control) + +#endif /* WGL_3DL_stereo_control */ + +/* ------------------------- WGL_ARB_buffer_region ------------------------- */ + +#ifndef WGL_ARB_buffer_region +#define WGL_ARB_buffer_region 1 + +#define WGL_FRONT_COLOR_BUFFER_BIT_ARB 0x00000001 +#define WGL_BACK_COLOR_BUFFER_BIT_ARB 0x00000002 +#define WGL_DEPTH_BUFFER_BIT_ARB 0x00000004 +#define WGL_STENCIL_BUFFER_BIT_ARB 0x00000008 + +typedef HANDLE (WINAPI * PFNWGLCREATEBUFFERREGIONARBPROC) (HDC hDC, int iLayerPlane, UINT uType); +typedef VOID (WINAPI * PFNWGLDELETEBUFFERREGIONARBPROC) (HANDLE hRegion); +typedef BOOL (WINAPI * PFNWGLRESTOREBUFFERREGIONARBPROC) (HANDLE hRegion, int x, int y, int width, int height, int xSrc, int ySrc); +typedef BOOL (WINAPI * PFNWGLSAVEBUFFERREGIONARBPROC) (HANDLE hRegion, int x, int y, int width, int height); + +#define wglCreateBufferRegionARB WGLEW_GET_FUN(__wglewCreateBufferRegionARB) +#define wglDeleteBufferRegionARB WGLEW_GET_FUN(__wglewDeleteBufferRegionARB) +#define wglRestoreBufferRegionARB WGLEW_GET_FUN(__wglewRestoreBufferRegionARB) +#define wglSaveBufferRegionARB WGLEW_GET_FUN(__wglewSaveBufferRegionARB) + +#define WGLEW_ARB_buffer_region WGLEW_GET_VAR(__WGLEW_ARB_buffer_region) + +#endif /* WGL_ARB_buffer_region */ + +/* ------------------------- WGL_ARB_create_context ------------------------ */ + +#ifndef WGL_ARB_create_context +#define WGL_ARB_create_context 1 + +#define WGL_CONTEXT_DEBUG_BIT_ARB 0x0001 +#define WGL_CONTEXT_FORWARD_COMPATIBLE_BIT_ARB 0x0002 +#define WGL_CONTEXT_MAJOR_VERSION_ARB 0x2091 +#define WGL_CONTEXT_MINOR_VERSION_ARB 0x2092 +#define WGL_CONTEXT_LAYER_PLANE_ARB 0x2093 +#define WGL_CONTEXT_FLAGS_ARB 0x2094 + +typedef HGLRC (WINAPI * PFNWGLCREATECONTEXTATTRIBSARBPROC) (HDC hDC, HGLRC hShareContext, const int* attribList); + +#define wglCreateContextAttribsARB WGLEW_GET_FUN(__wglewCreateContextAttribsARB) + +#define WGLEW_ARB_create_context WGLEW_GET_VAR(__WGLEW_ARB_create_context) + +#endif /* WGL_ARB_create_context */ + +/* ----------------------- WGL_ARB_extensions_string ----------------------- */ + +#ifndef WGL_ARB_extensions_string +#define WGL_ARB_extensions_string 1 + +typedef const char* (WINAPI * PFNWGLGETEXTENSIONSSTRINGARBPROC) (HDC hdc); + +#define wglGetExtensionsStringARB WGLEW_GET_FUN(__wglewGetExtensionsStringARB) + +#define WGLEW_ARB_extensions_string WGLEW_GET_VAR(__WGLEW_ARB_extensions_string) + +#endif /* WGL_ARB_extensions_string */ + +/* ------------------------ WGL_ARB_framebuffer_sRGB ----------------------- */ + +#ifndef WGL_ARB_framebuffer_sRGB +#define WGL_ARB_framebuffer_sRGB 1 + +#define WGL_FRAMEBUFFER_SRGB_CAPABLE_ARB 0x20A9 + +#define WGLEW_ARB_framebuffer_sRGB WGLEW_GET_VAR(__WGLEW_ARB_framebuffer_sRGB) + +#endif /* WGL_ARB_framebuffer_sRGB */ + +/* ----------------------- WGL_ARB_make_current_read ----------------------- */ + +#ifndef WGL_ARB_make_current_read +#define WGL_ARB_make_current_read 1 + +#define ERROR_INVALID_PIXEL_TYPE_ARB 0x2043 +#define ERROR_INCOMPATIBLE_DEVICE_CONTEXTS_ARB 0x2054 + +typedef HDC (WINAPI * PFNWGLGETCURRENTREADDCARBPROC) (VOID); +typedef BOOL (WINAPI * PFNWGLMAKECONTEXTCURRENTARBPROC) (HDC hDrawDC, HDC hReadDC, HGLRC hglrc); + +#define wglGetCurrentReadDCARB WGLEW_GET_FUN(__wglewGetCurrentReadDCARB) +#define wglMakeContextCurrentARB WGLEW_GET_FUN(__wglewMakeContextCurrentARB) + +#define WGLEW_ARB_make_current_read WGLEW_GET_VAR(__WGLEW_ARB_make_current_read) + +#endif /* WGL_ARB_make_current_read */ + +/* -------------------------- WGL_ARB_multisample -------------------------- */ + +#ifndef WGL_ARB_multisample +#define WGL_ARB_multisample 1 + +#define WGL_SAMPLE_BUFFERS_ARB 0x2041 +#define WGL_SAMPLES_ARB 0x2042 + +#define WGLEW_ARB_multisample WGLEW_GET_VAR(__WGLEW_ARB_multisample) + +#endif /* WGL_ARB_multisample */ + +/* ---------------------------- WGL_ARB_pbuffer ---------------------------- */ + +#ifndef WGL_ARB_pbuffer +#define WGL_ARB_pbuffer 1 + +#define WGL_DRAW_TO_PBUFFER_ARB 0x202D +#define WGL_MAX_PBUFFER_PIXELS_ARB 0x202E +#define WGL_MAX_PBUFFER_WIDTH_ARB 0x202F +#define WGL_MAX_PBUFFER_HEIGHT_ARB 0x2030 +#define WGL_PBUFFER_LARGEST_ARB 0x2033 +#define WGL_PBUFFER_WIDTH_ARB 0x2034 +#define WGL_PBUFFER_HEIGHT_ARB 0x2035 +#define WGL_PBUFFER_LOST_ARB 0x2036 + +DECLARE_HANDLE(HPBUFFERARB); + +typedef HPBUFFERARB (WINAPI * PFNWGLCREATEPBUFFERARBPROC) (HDC hDC, int iPixelFormat, int iWidth, int iHeight, const int* piAttribList); +typedef BOOL (WINAPI * PFNWGLDESTROYPBUFFERARBPROC) (HPBUFFERARB hPbuffer); +typedef HDC (WINAPI * PFNWGLGETPBUFFERDCARBPROC) (HPBUFFERARB hPbuffer); +typedef BOOL (WINAPI * PFNWGLQUERYPBUFFERARBPROC) (HPBUFFERARB hPbuffer, int iAttribute, int* piValue); +typedef int (WINAPI * PFNWGLRELEASEPBUFFERDCARBPROC) (HPBUFFERARB hPbuffer, HDC hDC); + +#define wglCreatePbufferARB WGLEW_GET_FUN(__wglewCreatePbufferARB) +#define wglDestroyPbufferARB WGLEW_GET_FUN(__wglewDestroyPbufferARB) +#define wglGetPbufferDCARB WGLEW_GET_FUN(__wglewGetPbufferDCARB) +#define wglQueryPbufferARB WGLEW_GET_FUN(__wglewQueryPbufferARB) +#define wglReleasePbufferDCARB WGLEW_GET_FUN(__wglewReleasePbufferDCARB) + +#define WGLEW_ARB_pbuffer WGLEW_GET_VAR(__WGLEW_ARB_pbuffer) + +#endif /* WGL_ARB_pbuffer */ + +/* -------------------------- WGL_ARB_pixel_format ------------------------- */ + +#ifndef WGL_ARB_pixel_format +#define WGL_ARB_pixel_format 1 + +#define WGL_NUMBER_PIXEL_FORMATS_ARB 0x2000 +#define WGL_DRAW_TO_WINDOW_ARB 0x2001 +#define WGL_DRAW_TO_BITMAP_ARB 0x2002 +#define WGL_ACCELERATION_ARB 0x2003 +#define WGL_NEED_PALETTE_ARB 0x2004 +#define WGL_NEED_SYSTEM_PALETTE_ARB 0x2005 +#define WGL_SWAP_LAYER_BUFFERS_ARB 0x2006 +#define WGL_SWAP_METHOD_ARB 0x2007 +#define WGL_NUMBER_OVERLAYS_ARB 0x2008 +#define WGL_NUMBER_UNDERLAYS_ARB 0x2009 +#define WGL_TRANSPARENT_ARB 0x200A +#define WGL_SHARE_DEPTH_ARB 0x200C +#define WGL_SHARE_STENCIL_ARB 0x200D +#define WGL_SHARE_ACCUM_ARB 0x200E +#define WGL_SUPPORT_GDI_ARB 0x200F +#define WGL_SUPPORT_OPENGL_ARB 0x2010 +#define WGL_DOUBLE_BUFFER_ARB 0x2011 +#define WGL_STEREO_ARB 0x2012 +#define WGL_PIXEL_TYPE_ARB 0x2013 +#define WGL_COLOR_BITS_ARB 0x2014 +#define WGL_RED_BITS_ARB 0x2015 +#define WGL_RED_SHIFT_ARB 0x2016 +#define WGL_GREEN_BITS_ARB 0x2017 +#define WGL_GREEN_SHIFT_ARB 0x2018 +#define WGL_BLUE_BITS_ARB 0x2019 +#define WGL_BLUE_SHIFT_ARB 0x201A +#define WGL_ALPHA_BITS_ARB 0x201B +#define WGL_ALPHA_SHIFT_ARB 0x201C +#define WGL_ACCUM_BITS_ARB 0x201D +#define WGL_ACCUM_RED_BITS_ARB 0x201E +#define WGL_ACCUM_GREEN_BITS_ARB 0x201F +#define WGL_ACCUM_BLUE_BITS_ARB 0x2020 +#define WGL_ACCUM_ALPHA_BITS_ARB 0x2021 +#define WGL_DEPTH_BITS_ARB 0x2022 +#define WGL_STENCIL_BITS_ARB 0x2023 +#define WGL_AUX_BUFFERS_ARB 0x2024 +#define WGL_NO_ACCELERATION_ARB 0x2025 +#define WGL_GENERIC_ACCELERATION_ARB 0x2026 +#define WGL_FULL_ACCELERATION_ARB 0x2027 +#define WGL_SWAP_EXCHANGE_ARB 0x2028 +#define WGL_SWAP_COPY_ARB 0x2029 +#define WGL_SWAP_UNDEFINED_ARB 0x202A +#define WGL_TYPE_RGBA_ARB 0x202B +#define WGL_TYPE_COLORINDEX_ARB 0x202C +#define WGL_TRANSPARENT_RED_VALUE_ARB 0x2037 +#define WGL_TRANSPARENT_GREEN_VALUE_ARB 0x2038 +#define WGL_TRANSPARENT_BLUE_VALUE_ARB 0x2039 +#define WGL_TRANSPARENT_ALPHA_VALUE_ARB 0x203A +#define WGL_TRANSPARENT_INDEX_VALUE_ARB 0x203B + +typedef BOOL (WINAPI * PFNWGLCHOOSEPIXELFORMATARBPROC) (HDC hdc, const int* piAttribIList, const FLOAT *pfAttribFList, UINT nMaxFormats, int *piFormats, UINT *nNumFormats); +typedef BOOL (WINAPI * PFNWGLGETPIXELFORMATATTRIBFVARBPROC) (HDC hdc, int iPixelFormat, int iLayerPlane, UINT nAttributes, const int* piAttributes, FLOAT *pfValues); +typedef BOOL (WINAPI * PFNWGLGETPIXELFORMATATTRIBIVARBPROC) (HDC hdc, int iPixelFormat, int iLayerPlane, UINT nAttributes, const int* piAttributes, int *piValues); + +#define wglChoosePixelFormatARB WGLEW_GET_FUN(__wglewChoosePixelFormatARB) +#define wglGetPixelFormatAttribfvARB WGLEW_GET_FUN(__wglewGetPixelFormatAttribfvARB) +#define wglGetPixelFormatAttribivARB WGLEW_GET_FUN(__wglewGetPixelFormatAttribivARB) + +#define WGLEW_ARB_pixel_format WGLEW_GET_VAR(__WGLEW_ARB_pixel_format) + +#endif /* WGL_ARB_pixel_format */ + +/* ----------------------- WGL_ARB_pixel_format_float ---------------------- */ + +#ifndef WGL_ARB_pixel_format_float +#define WGL_ARB_pixel_format_float 1 + +#define WGL_TYPE_RGBA_FLOAT_ARB 0x21A0 + +#define WGLEW_ARB_pixel_format_float WGLEW_GET_VAR(__WGLEW_ARB_pixel_format_float) + +#endif /* WGL_ARB_pixel_format_float */ + +/* ------------------------- WGL_ARB_render_texture ------------------------ */ + +#ifndef WGL_ARB_render_texture +#define WGL_ARB_render_texture 1 + +#define WGL_BIND_TO_TEXTURE_RGB_ARB 0x2070 +#define WGL_BIND_TO_TEXTURE_RGBA_ARB 0x2071 +#define WGL_TEXTURE_FORMAT_ARB 0x2072 +#define WGL_TEXTURE_TARGET_ARB 0x2073 +#define WGL_MIPMAP_TEXTURE_ARB 0x2074 +#define WGL_TEXTURE_RGB_ARB 0x2075 +#define WGL_TEXTURE_RGBA_ARB 0x2076 +#define WGL_NO_TEXTURE_ARB 0x2077 +#define WGL_TEXTURE_CUBE_MAP_ARB 0x2078 +#define WGL_TEXTURE_1D_ARB 0x2079 +#define WGL_TEXTURE_2D_ARB 0x207A +#define WGL_MIPMAP_LEVEL_ARB 0x207B +#define WGL_CUBE_MAP_FACE_ARB 0x207C +#define WGL_TEXTURE_CUBE_MAP_POSITIVE_X_ARB 0x207D +#define WGL_TEXTURE_CUBE_MAP_NEGATIVE_X_ARB 0x207E +#define WGL_TEXTURE_CUBE_MAP_POSITIVE_Y_ARB 0x207F +#define WGL_TEXTURE_CUBE_MAP_NEGATIVE_Y_ARB 0x2080 +#define WGL_TEXTURE_CUBE_MAP_POSITIVE_Z_ARB 0x2081 +#define WGL_TEXTURE_CUBE_MAP_NEGATIVE_Z_ARB 0x2082 +#define WGL_FRONT_LEFT_ARB 0x2083 +#define WGL_FRONT_RIGHT_ARB 0x2084 +#define WGL_BACK_LEFT_ARB 0x2085 +#define WGL_BACK_RIGHT_ARB 0x2086 +#define WGL_AUX0_ARB 0x2087 +#define WGL_AUX1_ARB 0x2088 +#define WGL_AUX2_ARB 0x2089 +#define WGL_AUX3_ARB 0x208A +#define WGL_AUX4_ARB 0x208B +#define WGL_AUX5_ARB 0x208C +#define WGL_AUX6_ARB 0x208D +#define WGL_AUX7_ARB 0x208E +#define WGL_AUX8_ARB 0x208F +#define WGL_AUX9_ARB 0x2090 + +typedef BOOL (WINAPI * PFNWGLBINDTEXIMAGEARBPROC) (HPBUFFERARB hPbuffer, int iBuffer); +typedef BOOL (WINAPI * PFNWGLRELEASETEXIMAGEARBPROC) (HPBUFFERARB hPbuffer, int iBuffer); +typedef BOOL (WINAPI * PFNWGLSETPBUFFERATTRIBARBPROC) (HPBUFFERARB hPbuffer, const int* piAttribList); + +#define wglBindTexImageARB WGLEW_GET_FUN(__wglewBindTexImageARB) +#define wglReleaseTexImageARB WGLEW_GET_FUN(__wglewReleaseTexImageARB) +#define wglSetPbufferAttribARB WGLEW_GET_FUN(__wglewSetPbufferAttribARB) + +#define WGLEW_ARB_render_texture WGLEW_GET_VAR(__WGLEW_ARB_render_texture) + +#endif /* WGL_ARB_render_texture */ + +/* ----------------------- WGL_ATI_pixel_format_float ---------------------- */ + +#ifndef WGL_ATI_pixel_format_float +#define WGL_ATI_pixel_format_float 1 + +#define WGL_TYPE_RGBA_FLOAT_ATI 0x21A0 +#define GL_RGBA_FLOAT_MODE_ATI 0x8820 +#define GL_COLOR_CLEAR_UNCLAMPED_VALUE_ATI 0x8835 + +#define WGLEW_ATI_pixel_format_float WGLEW_GET_VAR(__WGLEW_ATI_pixel_format_float) + +#endif /* WGL_ATI_pixel_format_float */ + +/* -------------------- WGL_ATI_render_texture_rectangle ------------------- */ + +#ifndef WGL_ATI_render_texture_rectangle +#define WGL_ATI_render_texture_rectangle 1 + +#define WGL_TEXTURE_RECTANGLE_ATI 0x21A5 + +#define WGLEW_ATI_render_texture_rectangle WGLEW_GET_VAR(__WGLEW_ATI_render_texture_rectangle) + +#endif /* WGL_ATI_render_texture_rectangle */ + +/* -------------------------- WGL_EXT_depth_float -------------------------- */ + +#ifndef WGL_EXT_depth_float +#define WGL_EXT_depth_float 1 + +#define WGL_DEPTH_FLOAT_EXT 0x2040 + +#define WGLEW_EXT_depth_float WGLEW_GET_VAR(__WGLEW_EXT_depth_float) + +#endif /* WGL_EXT_depth_float */ + +/* ---------------------- WGL_EXT_display_color_table ---------------------- */ + +#ifndef WGL_EXT_display_color_table +#define WGL_EXT_display_color_table 1 + +typedef GLboolean (WINAPI * PFNWGLBINDDISPLAYCOLORTABLEEXTPROC) (GLushort id); +typedef GLboolean (WINAPI * PFNWGLCREATEDISPLAYCOLORTABLEEXTPROC) (GLushort id); +typedef void (WINAPI * PFNWGLDESTROYDISPLAYCOLORTABLEEXTPROC) (GLushort id); +typedef GLboolean (WINAPI * PFNWGLLOADDISPLAYCOLORTABLEEXTPROC) (GLushort* table, GLuint length); + +#define wglBindDisplayColorTableEXT WGLEW_GET_FUN(__wglewBindDisplayColorTableEXT) +#define wglCreateDisplayColorTableEXT WGLEW_GET_FUN(__wglewCreateDisplayColorTableEXT) +#define wglDestroyDisplayColorTableEXT WGLEW_GET_FUN(__wglewDestroyDisplayColorTableEXT) +#define wglLoadDisplayColorTableEXT WGLEW_GET_FUN(__wglewLoadDisplayColorTableEXT) + +#define WGLEW_EXT_display_color_table WGLEW_GET_VAR(__WGLEW_EXT_display_color_table) + +#endif /* WGL_EXT_display_color_table */ + +/* ----------------------- WGL_EXT_extensions_string ----------------------- */ + +#ifndef WGL_EXT_extensions_string +#define WGL_EXT_extensions_string 1 + +typedef const char* (WINAPI * PFNWGLGETEXTENSIONSSTRINGEXTPROC) (void); + +#define wglGetExtensionsStringEXT WGLEW_GET_FUN(__wglewGetExtensionsStringEXT) + +#define WGLEW_EXT_extensions_string WGLEW_GET_VAR(__WGLEW_EXT_extensions_string) + +#endif /* WGL_EXT_extensions_string */ + +/* ------------------------ WGL_EXT_framebuffer_sRGB ----------------------- */ + +#ifndef WGL_EXT_framebuffer_sRGB +#define WGL_EXT_framebuffer_sRGB 1 + +#define WGL_FRAMEBUFFER_SRGB_CAPABLE_EXT 0x20A9 + +#define WGLEW_EXT_framebuffer_sRGB WGLEW_GET_VAR(__WGLEW_EXT_framebuffer_sRGB) + +#endif /* WGL_EXT_framebuffer_sRGB */ + +/* ----------------------- WGL_EXT_make_current_read ----------------------- */ + +#ifndef WGL_EXT_make_current_read +#define WGL_EXT_make_current_read 1 + +#define ERROR_INVALID_PIXEL_TYPE_EXT 0x2043 + +typedef HDC (WINAPI * PFNWGLGETCURRENTREADDCEXTPROC) (VOID); +typedef BOOL (WINAPI * PFNWGLMAKECONTEXTCURRENTEXTPROC) (HDC hDrawDC, HDC hReadDC, HGLRC hglrc); + +#define wglGetCurrentReadDCEXT WGLEW_GET_FUN(__wglewGetCurrentReadDCEXT) +#define wglMakeContextCurrentEXT WGLEW_GET_FUN(__wglewMakeContextCurrentEXT) + +#define WGLEW_EXT_make_current_read WGLEW_GET_VAR(__WGLEW_EXT_make_current_read) + +#endif /* WGL_EXT_make_current_read */ + +/* -------------------------- WGL_EXT_multisample -------------------------- */ + +#ifndef WGL_EXT_multisample +#define WGL_EXT_multisample 1 + +#define WGL_SAMPLE_BUFFERS_EXT 0x2041 +#define WGL_SAMPLES_EXT 0x2042 + +#define WGLEW_EXT_multisample WGLEW_GET_VAR(__WGLEW_EXT_multisample) + +#endif /* WGL_EXT_multisample */ + +/* ---------------------------- WGL_EXT_pbuffer ---------------------------- */ + +#ifndef WGL_EXT_pbuffer +#define WGL_EXT_pbuffer 1 + +#define WGL_DRAW_TO_PBUFFER_EXT 0x202D +#define WGL_MAX_PBUFFER_PIXELS_EXT 0x202E +#define WGL_MAX_PBUFFER_WIDTH_EXT 0x202F +#define WGL_MAX_PBUFFER_HEIGHT_EXT 0x2030 +#define WGL_OPTIMAL_PBUFFER_WIDTH_EXT 0x2031 +#define WGL_OPTIMAL_PBUFFER_HEIGHT_EXT 0x2032 +#define WGL_PBUFFER_LARGEST_EXT 0x2033 +#define WGL_PBUFFER_WIDTH_EXT 0x2034 +#define WGL_PBUFFER_HEIGHT_EXT 0x2035 + +DECLARE_HANDLE(HPBUFFEREXT); + +typedef HPBUFFEREXT (WINAPI * PFNWGLCREATEPBUFFEREXTPROC) (HDC hDC, int iPixelFormat, int iWidth, int iHeight, const int* piAttribList); +typedef BOOL (WINAPI * PFNWGLDESTROYPBUFFEREXTPROC) (HPBUFFEREXT hPbuffer); +typedef HDC (WINAPI * PFNWGLGETPBUFFERDCEXTPROC) (HPBUFFEREXT hPbuffer); +typedef BOOL (WINAPI * PFNWGLQUERYPBUFFEREXTPROC) (HPBUFFEREXT hPbuffer, int iAttribute, int* piValue); +typedef int (WINAPI * PFNWGLRELEASEPBUFFERDCEXTPROC) (HPBUFFEREXT hPbuffer, HDC hDC); + +#define wglCreatePbufferEXT WGLEW_GET_FUN(__wglewCreatePbufferEXT) +#define wglDestroyPbufferEXT WGLEW_GET_FUN(__wglewDestroyPbufferEXT) +#define wglGetPbufferDCEXT WGLEW_GET_FUN(__wglewGetPbufferDCEXT) +#define wglQueryPbufferEXT WGLEW_GET_FUN(__wglewQueryPbufferEXT) +#define wglReleasePbufferDCEXT WGLEW_GET_FUN(__wglewReleasePbufferDCEXT) + +#define WGLEW_EXT_pbuffer WGLEW_GET_VAR(__WGLEW_EXT_pbuffer) + +#endif /* WGL_EXT_pbuffer */ + +/* -------------------------- WGL_EXT_pixel_format ------------------------- */ + +#ifndef WGL_EXT_pixel_format +#define WGL_EXT_pixel_format 1 + +#define WGL_NUMBER_PIXEL_FORMATS_EXT 0x2000 +#define WGL_DRAW_TO_WINDOW_EXT 0x2001 +#define WGL_DRAW_TO_BITMAP_EXT 0x2002 +#define WGL_ACCELERATION_EXT 0x2003 +#define WGL_NEED_PALETTE_EXT 0x2004 +#define WGL_NEED_SYSTEM_PALETTE_EXT 0x2005 +#define WGL_SWAP_LAYER_BUFFERS_EXT 0x2006 +#define WGL_SWAP_METHOD_EXT 0x2007 +#define WGL_NUMBER_OVERLAYS_EXT 0x2008 +#define WGL_NUMBER_UNDERLAYS_EXT 0x2009 +#define WGL_TRANSPARENT_EXT 0x200A +#define WGL_TRANSPARENT_VALUE_EXT 0x200B +#define WGL_SHARE_DEPTH_EXT 0x200C +#define WGL_SHARE_STENCIL_EXT 0x200D +#define WGL_SHARE_ACCUM_EXT 0x200E +#define WGL_SUPPORT_GDI_EXT 0x200F +#define WGL_SUPPORT_OPENGL_EXT 0x2010 +#define WGL_DOUBLE_BUFFER_EXT 0x2011 +#define WGL_STEREO_EXT 0x2012 +#define WGL_PIXEL_TYPE_EXT 0x2013 +#define WGL_COLOR_BITS_EXT 0x2014 +#define WGL_RED_BITS_EXT 0x2015 +#define WGL_RED_SHIFT_EXT 0x2016 +#define WGL_GREEN_BITS_EXT 0x2017 +#define WGL_GREEN_SHIFT_EXT 0x2018 +#define WGL_BLUE_BITS_EXT 0x2019 +#define WGL_BLUE_SHIFT_EXT 0x201A +#define WGL_ALPHA_BITS_EXT 0x201B +#define WGL_ALPHA_SHIFT_EXT 0x201C +#define WGL_ACCUM_BITS_EXT 0x201D +#define WGL_ACCUM_RED_BITS_EXT 0x201E +#define WGL_ACCUM_GREEN_BITS_EXT 0x201F +#define WGL_ACCUM_BLUE_BITS_EXT 0x2020 +#define WGL_ACCUM_ALPHA_BITS_EXT 0x2021 +#define WGL_DEPTH_BITS_EXT 0x2022 +#define WGL_STENCIL_BITS_EXT 0x2023 +#define WGL_AUX_BUFFERS_EXT 0x2024 +#define WGL_NO_ACCELERATION_EXT 0x2025 +#define WGL_GENERIC_ACCELERATION_EXT 0x2026 +#define WGL_FULL_ACCELERATION_EXT 0x2027 +#define WGL_SWAP_EXCHANGE_EXT 0x2028 +#define WGL_SWAP_COPY_EXT 0x2029 +#define WGL_SWAP_UNDEFINED_EXT 0x202A +#define WGL_TYPE_RGBA_EXT 0x202B +#define WGL_TYPE_COLORINDEX_EXT 0x202C + +typedef BOOL (WINAPI * PFNWGLCHOOSEPIXELFORMATEXTPROC) (HDC hdc, const int* piAttribIList, const FLOAT *pfAttribFList, UINT nMaxFormats, int *piFormats, UINT *nNumFormats); +typedef BOOL (WINAPI * PFNWGLGETPIXELFORMATATTRIBFVEXTPROC) (HDC hdc, int iPixelFormat, int iLayerPlane, UINT nAttributes, int* piAttributes, FLOAT *pfValues); +typedef BOOL (WINAPI * PFNWGLGETPIXELFORMATATTRIBIVEXTPROC) (HDC hdc, int iPixelFormat, int iLayerPlane, UINT nAttributes, int* piAttributes, int *piValues); + +#define wglChoosePixelFormatEXT WGLEW_GET_FUN(__wglewChoosePixelFormatEXT) +#define wglGetPixelFormatAttribfvEXT WGLEW_GET_FUN(__wglewGetPixelFormatAttribfvEXT) +#define wglGetPixelFormatAttribivEXT WGLEW_GET_FUN(__wglewGetPixelFormatAttribivEXT) + +#define WGLEW_EXT_pixel_format WGLEW_GET_VAR(__WGLEW_EXT_pixel_format) + +#endif /* WGL_EXT_pixel_format */ + +/* ------------------- WGL_EXT_pixel_format_packed_float ------------------- */ + +#ifndef WGL_EXT_pixel_format_packed_float +#define WGL_EXT_pixel_format_packed_float 1 + +#define WGL_TYPE_RGBA_UNSIGNED_FLOAT_EXT 0x20A8 + +#define WGLEW_EXT_pixel_format_packed_float WGLEW_GET_VAR(__WGLEW_EXT_pixel_format_packed_float) + +#endif /* WGL_EXT_pixel_format_packed_float */ + +/* -------------------------- WGL_EXT_swap_control ------------------------- */ + +#ifndef WGL_EXT_swap_control +#define WGL_EXT_swap_control 1 + +typedef int (WINAPI * PFNWGLGETSWAPINTERVALEXTPROC) (void); +typedef BOOL (WINAPI * PFNWGLSWAPINTERVALEXTPROC) (int interval); + +#define wglGetSwapIntervalEXT WGLEW_GET_FUN(__wglewGetSwapIntervalEXT) +#define wglSwapIntervalEXT WGLEW_GET_FUN(__wglewSwapIntervalEXT) + +#define WGLEW_EXT_swap_control WGLEW_GET_VAR(__WGLEW_EXT_swap_control) + +#endif /* WGL_EXT_swap_control */ + +/* --------------------- WGL_I3D_digital_video_control --------------------- */ + +#ifndef WGL_I3D_digital_video_control +#define WGL_I3D_digital_video_control 1 + +#define WGL_DIGITAL_VIDEO_CURSOR_ALPHA_FRAMEBUFFER_I3D 0x2050 +#define WGL_DIGITAL_VIDEO_CURSOR_ALPHA_VALUE_I3D 0x2051 +#define WGL_DIGITAL_VIDEO_CURSOR_INCLUDED_I3D 0x2052 +#define WGL_DIGITAL_VIDEO_GAMMA_CORRECTED_I3D 0x2053 + +typedef BOOL (WINAPI * PFNWGLGETDIGITALVIDEOPARAMETERSI3DPROC) (HDC hDC, int iAttribute, int* piValue); +typedef BOOL (WINAPI * PFNWGLSETDIGITALVIDEOPARAMETERSI3DPROC) (HDC hDC, int iAttribute, const int* piValue); + +#define wglGetDigitalVideoParametersI3D WGLEW_GET_FUN(__wglewGetDigitalVideoParametersI3D) +#define wglSetDigitalVideoParametersI3D WGLEW_GET_FUN(__wglewSetDigitalVideoParametersI3D) + +#define WGLEW_I3D_digital_video_control WGLEW_GET_VAR(__WGLEW_I3D_digital_video_control) + +#endif /* WGL_I3D_digital_video_control */ + +/* ----------------------------- WGL_I3D_gamma ----------------------------- */ + +#ifndef WGL_I3D_gamma +#define WGL_I3D_gamma 1 + +#define WGL_GAMMA_TABLE_SIZE_I3D 0x204E +#define WGL_GAMMA_EXCLUDE_DESKTOP_I3D 0x204F + +typedef BOOL (WINAPI * PFNWGLGETGAMMATABLEI3DPROC) (HDC hDC, int iEntries, USHORT* puRed, USHORT *puGreen, USHORT *puBlue); +typedef BOOL (WINAPI * PFNWGLGETGAMMATABLEPARAMETERSI3DPROC) (HDC hDC, int iAttribute, int* piValue); +typedef BOOL (WINAPI * PFNWGLSETGAMMATABLEI3DPROC) (HDC hDC, int iEntries, const USHORT* puRed, const USHORT *puGreen, const USHORT *puBlue); +typedef BOOL (WINAPI * PFNWGLSETGAMMATABLEPARAMETERSI3DPROC) (HDC hDC, int iAttribute, const int* piValue); + +#define wglGetGammaTableI3D WGLEW_GET_FUN(__wglewGetGammaTableI3D) +#define wglGetGammaTableParametersI3D WGLEW_GET_FUN(__wglewGetGammaTableParametersI3D) +#define wglSetGammaTableI3D WGLEW_GET_FUN(__wglewSetGammaTableI3D) +#define wglSetGammaTableParametersI3D WGLEW_GET_FUN(__wglewSetGammaTableParametersI3D) + +#define WGLEW_I3D_gamma WGLEW_GET_VAR(__WGLEW_I3D_gamma) + +#endif /* WGL_I3D_gamma */ + +/* ---------------------------- WGL_I3D_genlock ---------------------------- */ + +#ifndef WGL_I3D_genlock +#define WGL_I3D_genlock 1 + +#define WGL_GENLOCK_SOURCE_MULTIVIEW_I3D 0x2044 +#define WGL_GENLOCK_SOURCE_EXTERNAL_SYNC_I3D 0x2045 +#define WGL_GENLOCK_SOURCE_EXTERNAL_FIELD_I3D 0x2046 +#define WGL_GENLOCK_SOURCE_EXTERNAL_TTL_I3D 0x2047 +#define WGL_GENLOCK_SOURCE_DIGITAL_SYNC_I3D 0x2048 +#define WGL_GENLOCK_SOURCE_DIGITAL_FIELD_I3D 0x2049 +#define WGL_GENLOCK_SOURCE_EDGE_FALLING_I3D 0x204A +#define WGL_GENLOCK_SOURCE_EDGE_RISING_I3D 0x204B +#define WGL_GENLOCK_SOURCE_EDGE_BOTH_I3D 0x204C + +typedef BOOL (WINAPI * PFNWGLDISABLEGENLOCKI3DPROC) (HDC hDC); +typedef BOOL (WINAPI * PFNWGLENABLEGENLOCKI3DPROC) (HDC hDC); +typedef BOOL (WINAPI * PFNWGLGENLOCKSAMPLERATEI3DPROC) (HDC hDC, UINT uRate); +typedef BOOL (WINAPI * PFNWGLGENLOCKSOURCEDELAYI3DPROC) (HDC hDC, UINT uDelay); +typedef BOOL (WINAPI * PFNWGLGENLOCKSOURCEEDGEI3DPROC) (HDC hDC, UINT uEdge); +typedef BOOL (WINAPI * PFNWGLGENLOCKSOURCEI3DPROC) (HDC hDC, UINT uSource); +typedef BOOL (WINAPI * PFNWGLGETGENLOCKSAMPLERATEI3DPROC) (HDC hDC, UINT* uRate); +typedef BOOL (WINAPI * PFNWGLGETGENLOCKSOURCEDELAYI3DPROC) (HDC hDC, UINT* uDelay); +typedef BOOL (WINAPI * PFNWGLGETGENLOCKSOURCEEDGEI3DPROC) (HDC hDC, UINT* uEdge); +typedef BOOL (WINAPI * PFNWGLGETGENLOCKSOURCEI3DPROC) (HDC hDC, UINT* uSource); +typedef BOOL (WINAPI * PFNWGLISENABLEDGENLOCKI3DPROC) (HDC hDC, BOOL* pFlag); +typedef BOOL (WINAPI * PFNWGLQUERYGENLOCKMAXSOURCEDELAYI3DPROC) (HDC hDC, UINT* uMaxLineDelay, UINT *uMaxPixelDelay); + +#define wglDisableGenlockI3D WGLEW_GET_FUN(__wglewDisableGenlockI3D) +#define wglEnableGenlockI3D WGLEW_GET_FUN(__wglewEnableGenlockI3D) +#define wglGenlockSampleRateI3D WGLEW_GET_FUN(__wglewGenlockSampleRateI3D) +#define wglGenlockSourceDelayI3D WGLEW_GET_FUN(__wglewGenlockSourceDelayI3D) +#define wglGenlockSourceEdgeI3D WGLEW_GET_FUN(__wglewGenlockSourceEdgeI3D) +#define wglGenlockSourceI3D WGLEW_GET_FUN(__wglewGenlockSourceI3D) +#define wglGetGenlockSampleRateI3D WGLEW_GET_FUN(__wglewGetGenlockSampleRateI3D) +#define wglGetGenlockSourceDelayI3D WGLEW_GET_FUN(__wglewGetGenlockSourceDelayI3D) +#define wglGetGenlockSourceEdgeI3D WGLEW_GET_FUN(__wglewGetGenlockSourceEdgeI3D) +#define wglGetGenlockSourceI3D WGLEW_GET_FUN(__wglewGetGenlockSourceI3D) +#define wglIsEnabledGenlockI3D WGLEW_GET_FUN(__wglewIsEnabledGenlockI3D) +#define wglQueryGenlockMaxSourceDelayI3D WGLEW_GET_FUN(__wglewQueryGenlockMaxSourceDelayI3D) + +#define WGLEW_I3D_genlock WGLEW_GET_VAR(__WGLEW_I3D_genlock) + +#endif /* WGL_I3D_genlock */ + +/* -------------------------- WGL_I3D_image_buffer ------------------------- */ + +#ifndef WGL_I3D_image_buffer +#define WGL_I3D_image_buffer 1 + +#define WGL_IMAGE_BUFFER_MIN_ACCESS_I3D 0x00000001 +#define WGL_IMAGE_BUFFER_LOCK_I3D 0x00000002 + +typedef BOOL (WINAPI * PFNWGLASSOCIATEIMAGEBUFFEREVENTSI3DPROC) (HDC hdc, HANDLE* pEvent, LPVOID *pAddress, DWORD *pSize, UINT count); +typedef LPVOID (WINAPI * PFNWGLCREATEIMAGEBUFFERI3DPROC) (HDC hDC, DWORD dwSize, UINT uFlags); +typedef BOOL (WINAPI * PFNWGLDESTROYIMAGEBUFFERI3DPROC) (HDC hDC, LPVOID pAddress); +typedef BOOL (WINAPI * PFNWGLRELEASEIMAGEBUFFEREVENTSI3DPROC) (HDC hdc, LPVOID* pAddress, UINT count); + +#define wglAssociateImageBufferEventsI3D WGLEW_GET_FUN(__wglewAssociateImageBufferEventsI3D) +#define wglCreateImageBufferI3D WGLEW_GET_FUN(__wglewCreateImageBufferI3D) +#define wglDestroyImageBufferI3D WGLEW_GET_FUN(__wglewDestroyImageBufferI3D) +#define wglReleaseImageBufferEventsI3D WGLEW_GET_FUN(__wglewReleaseImageBufferEventsI3D) + +#define WGLEW_I3D_image_buffer WGLEW_GET_VAR(__WGLEW_I3D_image_buffer) + +#endif /* WGL_I3D_image_buffer */ + +/* ------------------------ WGL_I3D_swap_frame_lock ------------------------ */ + +#ifndef WGL_I3D_swap_frame_lock +#define WGL_I3D_swap_frame_lock 1 + +typedef BOOL (WINAPI * PFNWGLDISABLEFRAMELOCKI3DPROC) (VOID); +typedef BOOL (WINAPI * PFNWGLENABLEFRAMELOCKI3DPROC) (VOID); +typedef BOOL (WINAPI * PFNWGLISENABLEDFRAMELOCKI3DPROC) (BOOL* pFlag); +typedef BOOL (WINAPI * PFNWGLQUERYFRAMELOCKMASTERI3DPROC) (BOOL* pFlag); + +#define wglDisableFrameLockI3D WGLEW_GET_FUN(__wglewDisableFrameLockI3D) +#define wglEnableFrameLockI3D WGLEW_GET_FUN(__wglewEnableFrameLockI3D) +#define wglIsEnabledFrameLockI3D WGLEW_GET_FUN(__wglewIsEnabledFrameLockI3D) +#define wglQueryFrameLockMasterI3D WGLEW_GET_FUN(__wglewQueryFrameLockMasterI3D) + +#define WGLEW_I3D_swap_frame_lock WGLEW_GET_VAR(__WGLEW_I3D_swap_frame_lock) + +#endif /* WGL_I3D_swap_frame_lock */ + +/* ------------------------ WGL_I3D_swap_frame_usage ----------------------- */ + +#ifndef WGL_I3D_swap_frame_usage +#define WGL_I3D_swap_frame_usage 1 + +typedef BOOL (WINAPI * PFNWGLBEGINFRAMETRACKINGI3DPROC) (void); +typedef BOOL (WINAPI * PFNWGLENDFRAMETRACKINGI3DPROC) (void); +typedef BOOL (WINAPI * PFNWGLGETFRAMEUSAGEI3DPROC) (float* pUsage); +typedef BOOL (WINAPI * PFNWGLQUERYFRAMETRACKINGI3DPROC) (DWORD* pFrameCount, DWORD *pMissedFrames, float *pLastMissedUsage); + +#define wglBeginFrameTrackingI3D WGLEW_GET_FUN(__wglewBeginFrameTrackingI3D) +#define wglEndFrameTrackingI3D WGLEW_GET_FUN(__wglewEndFrameTrackingI3D) +#define wglGetFrameUsageI3D WGLEW_GET_FUN(__wglewGetFrameUsageI3D) +#define wglQueryFrameTrackingI3D WGLEW_GET_FUN(__wglewQueryFrameTrackingI3D) + +#define WGLEW_I3D_swap_frame_usage WGLEW_GET_VAR(__WGLEW_I3D_swap_frame_usage) + +#endif /* WGL_I3D_swap_frame_usage */ + +/* -------------------------- WGL_NV_float_buffer -------------------------- */ + +#ifndef WGL_NV_float_buffer +#define WGL_NV_float_buffer 1 + +#define WGL_FLOAT_COMPONENTS_NV 0x20B0 +#define WGL_BIND_TO_TEXTURE_RECTANGLE_FLOAT_R_NV 0x20B1 +#define WGL_BIND_TO_TEXTURE_RECTANGLE_FLOAT_RG_NV 0x20B2 +#define WGL_BIND_TO_TEXTURE_RECTANGLE_FLOAT_RGB_NV 0x20B3 +#define WGL_BIND_TO_TEXTURE_RECTANGLE_FLOAT_RGBA_NV 0x20B4 +#define WGL_TEXTURE_FLOAT_R_NV 0x20B5 +#define WGL_TEXTURE_FLOAT_RG_NV 0x20B6 +#define WGL_TEXTURE_FLOAT_RGB_NV 0x20B7 +#define WGL_TEXTURE_FLOAT_RGBA_NV 0x20B8 + +#define WGLEW_NV_float_buffer WGLEW_GET_VAR(__WGLEW_NV_float_buffer) + +#endif /* WGL_NV_float_buffer */ + +/* -------------------------- WGL_NV_gpu_affinity -------------------------- */ + +#ifndef WGL_NV_gpu_affinity +#define WGL_NV_gpu_affinity 1 + +#define WGL_ERROR_INCOMPATIBLE_AFFINITY_MASKS_NV 0x20D0 +#define WGL_ERROR_MISSING_AFFINITY_MASK_NV 0x20D1 + +DECLARE_HANDLE(HGPUNV); +typedef struct _GPU_DEVICE { + DWORD cb; + CHAR DeviceName[32]; + CHAR DeviceString[128]; + DWORD Flags; + RECT rcVirtualScreen; +} GPU_DEVICE, *PGPU_DEVICE; + +typedef HDC (WINAPI * PFNWGLCREATEAFFINITYDCNVPROC) (const HGPUNV *phGpuList); +typedef BOOL (WINAPI * PFNWGLDELETEDCNVPROC) (HDC hdc); +typedef BOOL (WINAPI * PFNWGLENUMGPUDEVICESNVPROC) (HGPUNV hGpu, UINT iDeviceIndex, PGPU_DEVICE lpGpuDevice); +typedef BOOL (WINAPI * PFNWGLENUMGPUSFROMAFFINITYDCNVPROC) (HDC hAffinityDC, UINT iGpuIndex, HGPUNV *hGpu); +typedef BOOL (WINAPI * PFNWGLENUMGPUSNVPROC) (UINT iGpuIndex, HGPUNV *phGpu); + +#define wglCreateAffinityDCNV WGLEW_GET_FUN(__wglewCreateAffinityDCNV) +#define wglDeleteDCNV WGLEW_GET_FUN(__wglewDeleteDCNV) +#define wglEnumGpuDevicesNV WGLEW_GET_FUN(__wglewEnumGpuDevicesNV) +#define wglEnumGpusFromAffinityDCNV WGLEW_GET_FUN(__wglewEnumGpusFromAffinityDCNV) +#define wglEnumGpusNV WGLEW_GET_FUN(__wglewEnumGpusNV) + +#define WGLEW_NV_gpu_affinity WGLEW_GET_VAR(__WGLEW_NV_gpu_affinity) + +#endif /* WGL_NV_gpu_affinity */ + +/* -------------------------- WGL_NV_present_video ------------------------- */ + +#ifndef WGL_NV_present_video +#define WGL_NV_present_video 1 + +#define WGL_NUM_VIDEO_SLOTS_NV 0x20F0 + +DECLARE_HANDLE(HVIDEOOUTPUTDEVICENV); + +typedef BOOL (WINAPI * PFNWGLBINDVIDEODEVICENVPROC) (HDC hDc, unsigned int uVideoSlot, HVIDEOOUTPUTDEVICENV hVideoDevice, const int* piAttribList); +typedef int (WINAPI * PFNWGLENUMERATEVIDEODEVICESNVPROC) (HDC hDc, HVIDEOOUTPUTDEVICENV* phDeviceList); +typedef BOOL (WINAPI * PFNWGLQUERYCURRENTCONTEXTNVPROC) (int iAttribute, int* piValue); + +#define wglBindVideoDeviceNV WGLEW_GET_FUN(__wglewBindVideoDeviceNV) +#define wglEnumerateVideoDevicesNV WGLEW_GET_FUN(__wglewEnumerateVideoDevicesNV) +#define wglQueryCurrentContextNV WGLEW_GET_FUN(__wglewQueryCurrentContextNV) + +#define WGLEW_NV_present_video WGLEW_GET_VAR(__WGLEW_NV_present_video) + +#endif /* WGL_NV_present_video */ + +/* ---------------------- WGL_NV_render_depth_texture ---------------------- */ + +#ifndef WGL_NV_render_depth_texture +#define WGL_NV_render_depth_texture 1 + +#define WGL_NO_TEXTURE_ARB 0x2077 +#define WGL_BIND_TO_TEXTURE_DEPTH_NV 0x20A3 +#define WGL_BIND_TO_TEXTURE_RECTANGLE_DEPTH_NV 0x20A4 +#define WGL_DEPTH_TEXTURE_FORMAT_NV 0x20A5 +#define WGL_TEXTURE_DEPTH_COMPONENT_NV 0x20A6 +#define WGL_DEPTH_COMPONENT_NV 0x20A7 + +#define WGLEW_NV_render_depth_texture WGLEW_GET_VAR(__WGLEW_NV_render_depth_texture) + +#endif /* WGL_NV_render_depth_texture */ + +/* -------------------- WGL_NV_render_texture_rectangle -------------------- */ + +#ifndef WGL_NV_render_texture_rectangle +#define WGL_NV_render_texture_rectangle 1 + +#define WGL_BIND_TO_TEXTURE_RECTANGLE_RGB_NV 0x20A0 +#define WGL_BIND_TO_TEXTURE_RECTANGLE_RGBA_NV 0x20A1 +#define WGL_TEXTURE_RECTANGLE_NV 0x20A2 + +#define WGLEW_NV_render_texture_rectangle WGLEW_GET_VAR(__WGLEW_NV_render_texture_rectangle) + +#endif /* WGL_NV_render_texture_rectangle */ + +/* --------------------------- WGL_NV_swap_group --------------------------- */ + +#ifndef WGL_NV_swap_group +#define WGL_NV_swap_group 1 + +typedef BOOL (WINAPI * PFNWGLBINDSWAPBARRIERNVPROC) (GLuint group, GLuint barrier); +typedef BOOL (WINAPI * PFNWGLJOINSWAPGROUPNVPROC) (HDC hDC, GLuint group); +typedef BOOL (WINAPI * PFNWGLQUERYFRAMECOUNTNVPROC) (HDC hDC, GLuint* count); +typedef BOOL (WINAPI * PFNWGLQUERYMAXSWAPGROUPSNVPROC) (HDC hDC, GLuint* maxGroups, GLuint *maxBarriers); +typedef BOOL (WINAPI * PFNWGLQUERYSWAPGROUPNVPROC) (HDC hDC, GLuint* group); +typedef BOOL (WINAPI * PFNWGLRESETFRAMECOUNTNVPROC) (HDC hDC); + +#define wglBindSwapBarrierNV WGLEW_GET_FUN(__wglewBindSwapBarrierNV) +#define wglJoinSwapGroupNV WGLEW_GET_FUN(__wglewJoinSwapGroupNV) +#define wglQueryFrameCountNV WGLEW_GET_FUN(__wglewQueryFrameCountNV) +#define wglQueryMaxSwapGroupsNV WGLEW_GET_FUN(__wglewQueryMaxSwapGroupsNV) +#define wglQuerySwapGroupNV WGLEW_GET_FUN(__wglewQuerySwapGroupNV) +#define wglResetFrameCountNV WGLEW_GET_FUN(__wglewResetFrameCountNV) + +#define WGLEW_NV_swap_group WGLEW_GET_VAR(__WGLEW_NV_swap_group) + +#endif /* WGL_NV_swap_group */ + +/* ----------------------- WGL_NV_vertex_array_range ----------------------- */ + +#ifndef WGL_NV_vertex_array_range +#define WGL_NV_vertex_array_range 1 + +typedef void * (WINAPI * PFNWGLALLOCATEMEMORYNVPROC) (GLsizei size, GLfloat readFrequency, GLfloat writeFrequency, GLfloat priority); +typedef void (WINAPI * PFNWGLFREEMEMORYNVPROC) (void *pointer); + +#define wglAllocateMemoryNV WGLEW_GET_FUN(__wglewAllocateMemoryNV) +#define wglFreeMemoryNV WGLEW_GET_FUN(__wglewFreeMemoryNV) + +#define WGLEW_NV_vertex_array_range WGLEW_GET_VAR(__WGLEW_NV_vertex_array_range) + +#endif /* WGL_NV_vertex_array_range */ + +/* -------------------------- WGL_NV_video_output -------------------------- */ + +#ifndef WGL_NV_video_output +#define WGL_NV_video_output 1 + +#define WGL_BIND_TO_VIDEO_RGB_NV 0x20C0 +#define WGL_BIND_TO_VIDEO_RGBA_NV 0x20C1 +#define WGL_BIND_TO_VIDEO_RGB_AND_DEPTH_NV 0x20C2 +#define WGL_VIDEO_OUT_COLOR_NV 0x20C3 +#define WGL_VIDEO_OUT_ALPHA_NV 0x20C4 +#define WGL_VIDEO_OUT_DEPTH_NV 0x20C5 +#define WGL_VIDEO_OUT_COLOR_AND_ALPHA_NV 0x20C6 +#define WGL_VIDEO_OUT_COLOR_AND_DEPTH_NV 0x20C7 +#define WGL_VIDEO_OUT_FRAME 0x20C8 +#define WGL_VIDEO_OUT_FIELD_1 0x20C9 +#define WGL_VIDEO_OUT_FIELD_2 0x20CA +#define WGL_VIDEO_OUT_STACKED_FIELDS_1_2 0x20CB +#define WGL_VIDEO_OUT_STACKED_FIELDS_2_1 0x20CC + +DECLARE_HANDLE(HPVIDEODEV); + +typedef BOOL (WINAPI * PFNWGLBINDVIDEOIMAGENVPROC) (HPVIDEODEV hVideoDevice, HPBUFFERARB hPbuffer, int iVideoBuffer); +typedef BOOL (WINAPI * PFNWGLGETVIDEODEVICENVPROC) (HDC hDC, int numDevices, HPVIDEODEV* hVideoDevice); +typedef BOOL (WINAPI * PFNWGLGETVIDEOINFONVPROC) (HPVIDEODEV hpVideoDevice, unsigned long* pulCounterOutputPbuffer, unsigned long *pulCounterOutputVideo); +typedef BOOL (WINAPI * PFNWGLRELEASEVIDEODEVICENVPROC) (HPVIDEODEV hVideoDevice); +typedef BOOL (WINAPI * PFNWGLRELEASEVIDEOIMAGENVPROC) (HPBUFFERARB hPbuffer, int iVideoBuffer); +typedef BOOL (WINAPI * PFNWGLSENDPBUFFERTOVIDEONVPROC) (HPBUFFERARB hPbuffer, int iBufferType, unsigned long* pulCounterPbuffer, BOOL bBlock); + +#define wglBindVideoImageNV WGLEW_GET_FUN(__wglewBindVideoImageNV) +#define wglGetVideoDeviceNV WGLEW_GET_FUN(__wglewGetVideoDeviceNV) +#define wglGetVideoInfoNV WGLEW_GET_FUN(__wglewGetVideoInfoNV) +#define wglReleaseVideoDeviceNV WGLEW_GET_FUN(__wglewReleaseVideoDeviceNV) +#define wglReleaseVideoImageNV WGLEW_GET_FUN(__wglewReleaseVideoImageNV) +#define wglSendPbufferToVideoNV WGLEW_GET_FUN(__wglewSendPbufferToVideoNV) + +#define WGLEW_NV_video_output WGLEW_GET_VAR(__WGLEW_NV_video_output) + +#endif /* WGL_NV_video_output */ + +/* -------------------------- WGL_OML_sync_control ------------------------- */ + +#ifndef WGL_OML_sync_control +#define WGL_OML_sync_control 1 + +typedef BOOL (WINAPI * PFNWGLGETMSCRATEOMLPROC) (HDC hdc, INT32* numerator, INT32 *denominator); +typedef BOOL (WINAPI * PFNWGLGETSYNCVALUESOMLPROC) (HDC hdc, INT64* ust, INT64 *msc, INT64 *sbc); +typedef INT64 (WINAPI * PFNWGLSWAPBUFFERSMSCOMLPROC) (HDC hdc, INT64 target_msc, INT64 divisor, INT64 remainder); +typedef INT64 (WINAPI * PFNWGLSWAPLAYERBUFFERSMSCOMLPROC) (HDC hdc, INT fuPlanes, INT64 target_msc, INT64 divisor, INT64 remainder); +typedef BOOL (WINAPI * PFNWGLWAITFORMSCOMLPROC) (HDC hdc, INT64 target_msc, INT64 divisor, INT64 remainder, INT64* ust, INT64 *msc, INT64 *sbc); +typedef BOOL (WINAPI * PFNWGLWAITFORSBCOMLPROC) (HDC hdc, INT64 target_sbc, INT64* ust, INT64 *msc, INT64 *sbc); + +#define wglGetMscRateOML WGLEW_GET_FUN(__wglewGetMscRateOML) +#define wglGetSyncValuesOML WGLEW_GET_FUN(__wglewGetSyncValuesOML) +#define wglSwapBuffersMscOML WGLEW_GET_FUN(__wglewSwapBuffersMscOML) +#define wglSwapLayerBuffersMscOML WGLEW_GET_FUN(__wglewSwapLayerBuffersMscOML) +#define wglWaitForMscOML WGLEW_GET_FUN(__wglewWaitForMscOML) +#define wglWaitForSbcOML WGLEW_GET_FUN(__wglewWaitForSbcOML) + +#define WGLEW_OML_sync_control WGLEW_GET_VAR(__WGLEW_OML_sync_control) + +#endif /* WGL_OML_sync_control */ + +/* ------------------------------------------------------------------------- */ + +#ifdef GLEW_MX +#define WGLEW_EXPORT +#else +#define WGLEW_EXPORT GLEWAPI +#endif /* GLEW_MX */ + +#ifdef GLEW_MX +struct WGLEWContextStruct +{ +#endif /* GLEW_MX */ + +WGLEW_EXPORT PFNWGLSETSTEREOEMITTERSTATE3DLPROC __wglewSetStereoEmitterState3DL; + +WGLEW_EXPORT PFNWGLCREATEBUFFERREGIONARBPROC __wglewCreateBufferRegionARB; +WGLEW_EXPORT PFNWGLDELETEBUFFERREGIONARBPROC __wglewDeleteBufferRegionARB; +WGLEW_EXPORT PFNWGLRESTOREBUFFERREGIONARBPROC __wglewRestoreBufferRegionARB; +WGLEW_EXPORT PFNWGLSAVEBUFFERREGIONARBPROC __wglewSaveBufferRegionARB; + +WGLEW_EXPORT PFNWGLCREATECONTEXTATTRIBSARBPROC __wglewCreateContextAttribsARB; + +WGLEW_EXPORT PFNWGLGETEXTENSIONSSTRINGARBPROC __wglewGetExtensionsStringARB; + +WGLEW_EXPORT PFNWGLGETCURRENTREADDCARBPROC __wglewGetCurrentReadDCARB; +WGLEW_EXPORT PFNWGLMAKECONTEXTCURRENTARBPROC __wglewMakeContextCurrentARB; + +WGLEW_EXPORT PFNWGLCREATEPBUFFERARBPROC __wglewCreatePbufferARB; +WGLEW_EXPORT PFNWGLDESTROYPBUFFERARBPROC __wglewDestroyPbufferARB; +WGLEW_EXPORT PFNWGLGETPBUFFERDCARBPROC __wglewGetPbufferDCARB; +WGLEW_EXPORT PFNWGLQUERYPBUFFERARBPROC __wglewQueryPbufferARB; +WGLEW_EXPORT PFNWGLRELEASEPBUFFERDCARBPROC __wglewReleasePbufferDCARB; + +WGLEW_EXPORT PFNWGLCHOOSEPIXELFORMATARBPROC __wglewChoosePixelFormatARB; +WGLEW_EXPORT PFNWGLGETPIXELFORMATATTRIBFVARBPROC __wglewGetPixelFormatAttribfvARB; +WGLEW_EXPORT PFNWGLGETPIXELFORMATATTRIBIVARBPROC __wglewGetPixelFormatAttribivARB; + +WGLEW_EXPORT PFNWGLBINDTEXIMAGEARBPROC __wglewBindTexImageARB; +WGLEW_EXPORT PFNWGLRELEASETEXIMAGEARBPROC __wglewReleaseTexImageARB; +WGLEW_EXPORT PFNWGLSETPBUFFERATTRIBARBPROC __wglewSetPbufferAttribARB; + +WGLEW_EXPORT PFNWGLBINDDISPLAYCOLORTABLEEXTPROC __wglewBindDisplayColorTableEXT; +WGLEW_EXPORT PFNWGLCREATEDISPLAYCOLORTABLEEXTPROC __wglewCreateDisplayColorTableEXT; +WGLEW_EXPORT PFNWGLDESTROYDISPLAYCOLORTABLEEXTPROC __wglewDestroyDisplayColorTableEXT; +WGLEW_EXPORT PFNWGLLOADDISPLAYCOLORTABLEEXTPROC __wglewLoadDisplayColorTableEXT; + +WGLEW_EXPORT PFNWGLGETEXTENSIONSSTRINGEXTPROC __wglewGetExtensionsStringEXT; + +WGLEW_EXPORT PFNWGLGETCURRENTREADDCEXTPROC __wglewGetCurrentReadDCEXT; +WGLEW_EXPORT PFNWGLMAKECONTEXTCURRENTEXTPROC __wglewMakeContextCurrentEXT; + +WGLEW_EXPORT PFNWGLCREATEPBUFFEREXTPROC __wglewCreatePbufferEXT; +WGLEW_EXPORT PFNWGLDESTROYPBUFFEREXTPROC __wglewDestroyPbufferEXT; +WGLEW_EXPORT PFNWGLGETPBUFFERDCEXTPROC __wglewGetPbufferDCEXT; +WGLEW_EXPORT PFNWGLQUERYPBUFFEREXTPROC __wglewQueryPbufferEXT; +WGLEW_EXPORT PFNWGLRELEASEPBUFFERDCEXTPROC __wglewReleasePbufferDCEXT; + +WGLEW_EXPORT PFNWGLCHOOSEPIXELFORMATEXTPROC __wglewChoosePixelFormatEXT; +WGLEW_EXPORT PFNWGLGETPIXELFORMATATTRIBFVEXTPROC __wglewGetPixelFormatAttribfvEXT; +WGLEW_EXPORT PFNWGLGETPIXELFORMATATTRIBIVEXTPROC __wglewGetPixelFormatAttribivEXT; + +WGLEW_EXPORT PFNWGLGETSWAPINTERVALEXTPROC __wglewGetSwapIntervalEXT; +WGLEW_EXPORT PFNWGLSWAPINTERVALEXTPROC __wglewSwapIntervalEXT; + +WGLEW_EXPORT PFNWGLGETDIGITALVIDEOPARAMETERSI3DPROC __wglewGetDigitalVideoParametersI3D; +WGLEW_EXPORT PFNWGLSETDIGITALVIDEOPARAMETERSI3DPROC __wglewSetDigitalVideoParametersI3D; + +WGLEW_EXPORT PFNWGLGETGAMMATABLEI3DPROC __wglewGetGammaTableI3D; +WGLEW_EXPORT PFNWGLGETGAMMATABLEPARAMETERSI3DPROC __wglewGetGammaTableParametersI3D; +WGLEW_EXPORT PFNWGLSETGAMMATABLEI3DPROC __wglewSetGammaTableI3D; +WGLEW_EXPORT PFNWGLSETGAMMATABLEPARAMETERSI3DPROC __wglewSetGammaTableParametersI3D; + +WGLEW_EXPORT PFNWGLDISABLEGENLOCKI3DPROC __wglewDisableGenlockI3D; +WGLEW_EXPORT PFNWGLENABLEGENLOCKI3DPROC __wglewEnableGenlockI3D; +WGLEW_EXPORT PFNWGLGENLOCKSAMPLERATEI3DPROC __wglewGenlockSampleRateI3D; +WGLEW_EXPORT PFNWGLGENLOCKSOURCEDELAYI3DPROC __wglewGenlockSourceDelayI3D; +WGLEW_EXPORT PFNWGLGENLOCKSOURCEEDGEI3DPROC __wglewGenlockSourceEdgeI3D; +WGLEW_EXPORT PFNWGLGENLOCKSOURCEI3DPROC __wglewGenlockSourceI3D; +WGLEW_EXPORT PFNWGLGETGENLOCKSAMPLERATEI3DPROC __wglewGetGenlockSampleRateI3D; +WGLEW_EXPORT PFNWGLGETGENLOCKSOURCEDELAYI3DPROC __wglewGetGenlockSourceDelayI3D; +WGLEW_EXPORT PFNWGLGETGENLOCKSOURCEEDGEI3DPROC __wglewGetGenlockSourceEdgeI3D; +WGLEW_EXPORT PFNWGLGETGENLOCKSOURCEI3DPROC __wglewGetGenlockSourceI3D; +WGLEW_EXPORT PFNWGLISENABLEDGENLOCKI3DPROC __wglewIsEnabledGenlockI3D; +WGLEW_EXPORT PFNWGLQUERYGENLOCKMAXSOURCEDELAYI3DPROC __wglewQueryGenlockMaxSourceDelayI3D; + +WGLEW_EXPORT PFNWGLASSOCIATEIMAGEBUFFEREVENTSI3DPROC __wglewAssociateImageBufferEventsI3D; +WGLEW_EXPORT PFNWGLCREATEIMAGEBUFFERI3DPROC __wglewCreateImageBufferI3D; +WGLEW_EXPORT PFNWGLDESTROYIMAGEBUFFERI3DPROC __wglewDestroyImageBufferI3D; +WGLEW_EXPORT PFNWGLRELEASEIMAGEBUFFEREVENTSI3DPROC __wglewReleaseImageBufferEventsI3D; + +WGLEW_EXPORT PFNWGLDISABLEFRAMELOCKI3DPROC __wglewDisableFrameLockI3D; +WGLEW_EXPORT PFNWGLENABLEFRAMELOCKI3DPROC __wglewEnableFrameLockI3D; +WGLEW_EXPORT PFNWGLISENABLEDFRAMELOCKI3DPROC __wglewIsEnabledFrameLockI3D; +WGLEW_EXPORT PFNWGLQUERYFRAMELOCKMASTERI3DPROC __wglewQueryFrameLockMasterI3D; + +WGLEW_EXPORT PFNWGLBEGINFRAMETRACKINGI3DPROC __wglewBeginFrameTrackingI3D; +WGLEW_EXPORT PFNWGLENDFRAMETRACKINGI3DPROC __wglewEndFrameTrackingI3D; +WGLEW_EXPORT PFNWGLGETFRAMEUSAGEI3DPROC __wglewGetFrameUsageI3D; +WGLEW_EXPORT PFNWGLQUERYFRAMETRACKINGI3DPROC __wglewQueryFrameTrackingI3D; + +WGLEW_EXPORT PFNWGLCREATEAFFINITYDCNVPROC __wglewCreateAffinityDCNV; +WGLEW_EXPORT PFNWGLDELETEDCNVPROC __wglewDeleteDCNV; +WGLEW_EXPORT PFNWGLENUMGPUDEVICESNVPROC __wglewEnumGpuDevicesNV; +WGLEW_EXPORT PFNWGLENUMGPUSFROMAFFINITYDCNVPROC __wglewEnumGpusFromAffinityDCNV; +WGLEW_EXPORT PFNWGLENUMGPUSNVPROC __wglewEnumGpusNV; + +WGLEW_EXPORT PFNWGLBINDVIDEODEVICENVPROC __wglewBindVideoDeviceNV; +WGLEW_EXPORT PFNWGLENUMERATEVIDEODEVICESNVPROC __wglewEnumerateVideoDevicesNV; +WGLEW_EXPORT PFNWGLQUERYCURRENTCONTEXTNVPROC __wglewQueryCurrentContextNV; + +WGLEW_EXPORT PFNWGLBINDSWAPBARRIERNVPROC __wglewBindSwapBarrierNV; +WGLEW_EXPORT PFNWGLJOINSWAPGROUPNVPROC __wglewJoinSwapGroupNV; +WGLEW_EXPORT PFNWGLQUERYFRAMECOUNTNVPROC __wglewQueryFrameCountNV; +WGLEW_EXPORT PFNWGLQUERYMAXSWAPGROUPSNVPROC __wglewQueryMaxSwapGroupsNV; +WGLEW_EXPORT PFNWGLQUERYSWAPGROUPNVPROC __wglewQuerySwapGroupNV; +WGLEW_EXPORT PFNWGLRESETFRAMECOUNTNVPROC __wglewResetFrameCountNV; + +WGLEW_EXPORT PFNWGLALLOCATEMEMORYNVPROC __wglewAllocateMemoryNV; +WGLEW_EXPORT PFNWGLFREEMEMORYNVPROC __wglewFreeMemoryNV; + +WGLEW_EXPORT PFNWGLBINDVIDEOIMAGENVPROC __wglewBindVideoImageNV; +WGLEW_EXPORT PFNWGLGETVIDEODEVICENVPROC __wglewGetVideoDeviceNV; +WGLEW_EXPORT PFNWGLGETVIDEOINFONVPROC __wglewGetVideoInfoNV; +WGLEW_EXPORT PFNWGLRELEASEVIDEODEVICENVPROC __wglewReleaseVideoDeviceNV; +WGLEW_EXPORT PFNWGLRELEASEVIDEOIMAGENVPROC __wglewReleaseVideoImageNV; +WGLEW_EXPORT PFNWGLSENDPBUFFERTOVIDEONVPROC __wglewSendPbufferToVideoNV; + +WGLEW_EXPORT PFNWGLGETMSCRATEOMLPROC __wglewGetMscRateOML; +WGLEW_EXPORT PFNWGLGETSYNCVALUESOMLPROC __wglewGetSyncValuesOML; +WGLEW_EXPORT PFNWGLSWAPBUFFERSMSCOMLPROC __wglewSwapBuffersMscOML; +WGLEW_EXPORT PFNWGLSWAPLAYERBUFFERSMSCOMLPROC __wglewSwapLayerBuffersMscOML; +WGLEW_EXPORT PFNWGLWAITFORMSCOMLPROC __wglewWaitForMscOML; +WGLEW_EXPORT PFNWGLWAITFORSBCOMLPROC __wglewWaitForSbcOML; +WGLEW_EXPORT GLboolean __WGLEW_3DFX_multisample; +WGLEW_EXPORT GLboolean __WGLEW_3DL_stereo_control; +WGLEW_EXPORT GLboolean __WGLEW_ARB_buffer_region; +WGLEW_EXPORT GLboolean __WGLEW_ARB_create_context; +WGLEW_EXPORT GLboolean __WGLEW_ARB_extensions_string; +WGLEW_EXPORT GLboolean __WGLEW_ARB_framebuffer_sRGB; +WGLEW_EXPORT GLboolean __WGLEW_ARB_make_current_read; +WGLEW_EXPORT GLboolean __WGLEW_ARB_multisample; +WGLEW_EXPORT GLboolean __WGLEW_ARB_pbuffer; +WGLEW_EXPORT GLboolean __WGLEW_ARB_pixel_format; +WGLEW_EXPORT GLboolean __WGLEW_ARB_pixel_format_float; +WGLEW_EXPORT GLboolean __WGLEW_ARB_render_texture; +WGLEW_EXPORT GLboolean __WGLEW_ATI_pixel_format_float; +WGLEW_EXPORT GLboolean __WGLEW_ATI_render_texture_rectangle; +WGLEW_EXPORT GLboolean __WGLEW_EXT_depth_float; +WGLEW_EXPORT GLboolean __WGLEW_EXT_display_color_table; +WGLEW_EXPORT GLboolean __WGLEW_EXT_extensions_string; +WGLEW_EXPORT GLboolean __WGLEW_EXT_framebuffer_sRGB; +WGLEW_EXPORT GLboolean __WGLEW_EXT_make_current_read; +WGLEW_EXPORT GLboolean __WGLEW_EXT_multisample; +WGLEW_EXPORT GLboolean __WGLEW_EXT_pbuffer; +WGLEW_EXPORT GLboolean __WGLEW_EXT_pixel_format; +WGLEW_EXPORT GLboolean __WGLEW_EXT_pixel_format_packed_float; +WGLEW_EXPORT GLboolean __WGLEW_EXT_swap_control; +WGLEW_EXPORT GLboolean __WGLEW_I3D_digital_video_control; +WGLEW_EXPORT GLboolean __WGLEW_I3D_gamma; +WGLEW_EXPORT GLboolean __WGLEW_I3D_genlock; +WGLEW_EXPORT GLboolean __WGLEW_I3D_image_buffer; +WGLEW_EXPORT GLboolean __WGLEW_I3D_swap_frame_lock; +WGLEW_EXPORT GLboolean __WGLEW_I3D_swap_frame_usage; +WGLEW_EXPORT GLboolean __WGLEW_NV_float_buffer; +WGLEW_EXPORT GLboolean __WGLEW_NV_gpu_affinity; +WGLEW_EXPORT GLboolean __WGLEW_NV_present_video; +WGLEW_EXPORT GLboolean __WGLEW_NV_render_depth_texture; +WGLEW_EXPORT GLboolean __WGLEW_NV_render_texture_rectangle; +WGLEW_EXPORT GLboolean __WGLEW_NV_swap_group; +WGLEW_EXPORT GLboolean __WGLEW_NV_vertex_array_range; +WGLEW_EXPORT GLboolean __WGLEW_NV_video_output; +WGLEW_EXPORT GLboolean __WGLEW_OML_sync_control; + +#ifdef GLEW_MX +}; /* WGLEWContextStruct */ +#endif /* GLEW_MX */ + +/* ------------------------------------------------------------------------- */ + +#ifdef GLEW_MX + +typedef struct WGLEWContextStruct WGLEWContext; +GLEWAPI GLenum wglewContextInit (WGLEWContext* ctx); +GLEWAPI GLboolean wglewContextIsSupported (WGLEWContext* ctx, const char* name); + +#define wglewInit() wglewContextInit(wglewGetContext()) +#define wglewIsSupported(x) wglewContextIsSupported(wglewGetContext(), x) + +#define WGLEW_GET_VAR(x) (*(const GLboolean*)&(wglewGetContext()->x)) +#define WGLEW_GET_FUN(x) wglewGetContext()->x + +#else /* GLEW_MX */ + +#define WGLEW_GET_VAR(x) (*(const GLboolean*)&x) +#define WGLEW_GET_FUN(x) x + +GLEWAPI GLboolean wglewIsSupported (const char* name); + +#endif /* GLEW_MX */ + +GLEWAPI GLboolean wglewGetExtension (const char* name); + +#ifdef __cplusplus +} +#endif + +#undef GLEWAPI + +#endif /* __wglew_h__ */ diff --git a/opengl/wglext.h b/opengl/wglext.h new file mode 100644 index 00000000..3fe2e2df --- /dev/null +++ b/opengl/wglext.h @@ -0,0 +1,929 @@ +#ifndef __wglext_h_ +#define __wglext_h_ + +#ifdef __cplusplus +extern "C" { +#endif + +/* +** Copyright (c) 2007-2010 The Khronos Group Inc. +** +** Permission is hereby granted, free of charge, to any person obtaining a +** copy of this software and/or associated documentation files (the +** "Materials"), to deal in the Materials without restriction, including +** without limitation the rights to use, copy, modify, merge, publish, +** distribute, sublicense, and/or sell copies of the Materials, and to +** permit persons to whom the Materials are furnished to do so, subject to +** the following conditions: +** +** The above copyright notice and this permission notice shall be included +** in all copies or substantial portions of the Materials. +** +** THE MATERIALS ARE PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, +** EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF +** MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. +** IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY +** CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, +** TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE +** MATERIALS OR THE USE OR OTHER DEALINGS IN THE MATERIALS. +*/ + +/* Function declaration macros - to move into glplatform.h */ + +#if defined(_WIN32) && !defined(APIENTRY) && !defined(__CYGWIN__) && !defined(__SCITECH_SNAP__) +#define WIN32_LEAN_AND_MEAN 1 +#include +#endif + +#ifndef APIENTRY +#define APIENTRY +#endif +#ifndef APIENTRYP +#define APIENTRYP APIENTRY * +#endif +#ifndef GLAPI +#define GLAPI extern +#endif + +/*************************************************************/ + +/* Header file version number */ +/* wglext.h last updated 2011/04/13 */ +/* Current version at http://www.opengl.org/registry/ */ +#define WGL_WGLEXT_VERSION 23 + +#ifndef WGL_ARB_buffer_region +#define WGL_FRONT_COLOR_BUFFER_BIT_ARB 0x00000001 +#define WGL_BACK_COLOR_BUFFER_BIT_ARB 0x00000002 +#define WGL_DEPTH_BUFFER_BIT_ARB 0x00000004 +#define WGL_STENCIL_BUFFER_BIT_ARB 0x00000008 +#endif + +#ifndef WGL_ARB_multisample +#define WGL_SAMPLE_BUFFERS_ARB 0x2041 +#define WGL_SAMPLES_ARB 0x2042 +#endif + +#ifndef WGL_ARB_extensions_string +#endif + +#ifndef WGL_ARB_pixel_format +#define WGL_NUMBER_PIXEL_FORMATS_ARB 0x2000 +#define WGL_DRAW_TO_WINDOW_ARB 0x2001 +#define WGL_DRAW_TO_BITMAP_ARB 0x2002 +#define WGL_ACCELERATION_ARB 0x2003 +#define WGL_NEED_PALETTE_ARB 0x2004 +#define WGL_NEED_SYSTEM_PALETTE_ARB 0x2005 +#define WGL_SWAP_LAYER_BUFFERS_ARB 0x2006 +#define WGL_SWAP_METHOD_ARB 0x2007 +#define WGL_NUMBER_OVERLAYS_ARB 0x2008 +#define WGL_NUMBER_UNDERLAYS_ARB 0x2009 +#define WGL_TRANSPARENT_ARB 0x200A +#define WGL_TRANSPARENT_RED_VALUE_ARB 0x2037 +#define WGL_TRANSPARENT_GREEN_VALUE_ARB 0x2038 +#define WGL_TRANSPARENT_BLUE_VALUE_ARB 0x2039 +#define WGL_TRANSPARENT_ALPHA_VALUE_ARB 0x203A +#define WGL_TRANSPARENT_INDEX_VALUE_ARB 0x203B +#define WGL_SHARE_DEPTH_ARB 0x200C +#define WGL_SHARE_STENCIL_ARB 0x200D +#define WGL_SHARE_ACCUM_ARB 0x200E +#define WGL_SUPPORT_GDI_ARB 0x200F +#define WGL_SUPPORT_OPENGL_ARB 0x2010 +#define WGL_DOUBLE_BUFFER_ARB 0x2011 +#define WGL_STEREO_ARB 0x2012 +#define WGL_PIXEL_TYPE_ARB 0x2013 +#define WGL_COLOR_BITS_ARB 0x2014 +#define WGL_RED_BITS_ARB 0x2015 +#define WGL_RED_SHIFT_ARB 0x2016 +#define WGL_GREEN_BITS_ARB 0x2017 +#define WGL_GREEN_SHIFT_ARB 0x2018 +#define WGL_BLUE_BITS_ARB 0x2019 +#define WGL_BLUE_SHIFT_ARB 0x201A +#define WGL_ALPHA_BITS_ARB 0x201B +#define WGL_ALPHA_SHIFT_ARB 0x201C +#define WGL_ACCUM_BITS_ARB 0x201D +#define WGL_ACCUM_RED_BITS_ARB 0x201E +#define WGL_ACCUM_GREEN_BITS_ARB 0x201F +#define WGL_ACCUM_BLUE_BITS_ARB 0x2020 +#define WGL_ACCUM_ALPHA_BITS_ARB 0x2021 +#define WGL_DEPTH_BITS_ARB 0x2022 +#define WGL_STENCIL_BITS_ARB 0x2023 +#define WGL_AUX_BUFFERS_ARB 0x2024 +#define WGL_NO_ACCELERATION_ARB 0x2025 +#define WGL_GENERIC_ACCELERATION_ARB 0x2026 +#define WGL_FULL_ACCELERATION_ARB 0x2027 +#define WGL_SWAP_EXCHANGE_ARB 0x2028 +#define WGL_SWAP_COPY_ARB 0x2029 +#define WGL_SWAP_UNDEFINED_ARB 0x202A +#define WGL_TYPE_RGBA_ARB 0x202B +#define WGL_TYPE_COLORINDEX_ARB 0x202C +#endif + +#ifndef WGL_ARB_make_current_read +#define ERROR_INVALID_PIXEL_TYPE_ARB 0x2043 +#define ERROR_INCOMPATIBLE_DEVICE_CONTEXTS_ARB 0x2054 +#endif + +#ifndef WGL_ARB_pbuffer +#define WGL_DRAW_TO_PBUFFER_ARB 0x202D +#define WGL_MAX_PBUFFER_PIXELS_ARB 0x202E +#define WGL_MAX_PBUFFER_WIDTH_ARB 0x202F +#define WGL_MAX_PBUFFER_HEIGHT_ARB 0x2030 +#define WGL_PBUFFER_LARGEST_ARB 0x2033 +#define WGL_PBUFFER_WIDTH_ARB 0x2034 +#define WGL_PBUFFER_HEIGHT_ARB 0x2035 +#define WGL_PBUFFER_LOST_ARB 0x2036 +#endif + +#ifndef WGL_ARB_render_texture +#define WGL_BIND_TO_TEXTURE_RGB_ARB 0x2070 +#define WGL_BIND_TO_TEXTURE_RGBA_ARB 0x2071 +#define WGL_TEXTURE_FORMAT_ARB 0x2072 +#define WGL_TEXTURE_TARGET_ARB 0x2073 +#define WGL_MIPMAP_TEXTURE_ARB 0x2074 +#define WGL_TEXTURE_RGB_ARB 0x2075 +#define WGL_TEXTURE_RGBA_ARB 0x2076 +#define WGL_NO_TEXTURE_ARB 0x2077 +#define WGL_TEXTURE_CUBE_MAP_ARB 0x2078 +#define WGL_TEXTURE_1D_ARB 0x2079 +#define WGL_TEXTURE_2D_ARB 0x207A +#define WGL_MIPMAP_LEVEL_ARB 0x207B +#define WGL_CUBE_MAP_FACE_ARB 0x207C +#define WGL_TEXTURE_CUBE_MAP_POSITIVE_X_ARB 0x207D +#define WGL_TEXTURE_CUBE_MAP_NEGATIVE_X_ARB 0x207E +#define WGL_TEXTURE_CUBE_MAP_POSITIVE_Y_ARB 0x207F +#define WGL_TEXTURE_CUBE_MAP_NEGATIVE_Y_ARB 0x2080 +#define WGL_TEXTURE_CUBE_MAP_POSITIVE_Z_ARB 0x2081 +#define WGL_TEXTURE_CUBE_MAP_NEGATIVE_Z_ARB 0x2082 +#define WGL_FRONT_LEFT_ARB 0x2083 +#define WGL_FRONT_RIGHT_ARB 0x2084 +#define WGL_BACK_LEFT_ARB 0x2085 +#define WGL_BACK_RIGHT_ARB 0x2086 +#define WGL_AUX0_ARB 0x2087 +#define WGL_AUX1_ARB 0x2088 +#define WGL_AUX2_ARB 0x2089 +#define WGL_AUX3_ARB 0x208A +#define WGL_AUX4_ARB 0x208B +#define WGL_AUX5_ARB 0x208C +#define WGL_AUX6_ARB 0x208D +#define WGL_AUX7_ARB 0x208E +#define WGL_AUX8_ARB 0x208F +#define WGL_AUX9_ARB 0x2090 +#endif + +#ifndef WGL_ARB_pixel_format_float +#define WGL_TYPE_RGBA_FLOAT_ARB 0x21A0 +#endif + +#ifndef WGL_ARB_framebuffer_sRGB +#define WGL_FRAMEBUFFER_SRGB_CAPABLE_ARB 0x20A9 +#endif + +#ifndef WGL_ARB_create_context +#define WGL_CONTEXT_DEBUG_BIT_ARB 0x00000001 +#define WGL_CONTEXT_FORWARD_COMPATIBLE_BIT_ARB 0x00000002 +#define WGL_CONTEXT_MAJOR_VERSION_ARB 0x2091 +#define WGL_CONTEXT_MINOR_VERSION_ARB 0x2092 +#define WGL_CONTEXT_LAYER_PLANE_ARB 0x2093 +#define WGL_CONTEXT_FLAGS_ARB 0x2094 +#define ERROR_INVALID_VERSION_ARB 0x2095 +#endif + +#ifndef WGL_ARB_create_context_profile +#define WGL_CONTEXT_PROFILE_MASK_ARB 0x9126 +#define WGL_CONTEXT_CORE_PROFILE_BIT_ARB 0x00000001 +#define WGL_CONTEXT_COMPATIBILITY_PROFILE_BIT_ARB 0x00000002 +#define ERROR_INVALID_PROFILE_ARB 0x2096 +#endif + +#ifndef WGL_ARB_create_context_robustness +#define WGL_CONTEXT_ROBUST_ACCESS_BIT_ARB 0x00000004 +#define WGL_LOSE_CONTEXT_ON_RESET_ARB 0x8252 +#define WGL_CONTEXT_RESET_NOTIFICATION_STRATEGY_ARB 0x8256 +#define WGL_NO_RESET_NOTIFICATION_ARB 0x8261 +#endif + +#ifndef WGL_EXT_make_current_read +#define ERROR_INVALID_PIXEL_TYPE_EXT 0x2043 +#endif + +#ifndef WGL_EXT_pixel_format +#define WGL_NUMBER_PIXEL_FORMATS_EXT 0x2000 +#define WGL_DRAW_TO_WINDOW_EXT 0x2001 +#define WGL_DRAW_TO_BITMAP_EXT 0x2002 +#define WGL_ACCELERATION_EXT 0x2003 +#define WGL_NEED_PALETTE_EXT 0x2004 +#define WGL_NEED_SYSTEM_PALETTE_EXT 0x2005 +#define WGL_SWAP_LAYER_BUFFERS_EXT 0x2006 +#define WGL_SWAP_METHOD_EXT 0x2007 +#define WGL_NUMBER_OVERLAYS_EXT 0x2008 +#define WGL_NUMBER_UNDERLAYS_EXT 0x2009 +#define WGL_TRANSPARENT_EXT 0x200A +#define WGL_TRANSPARENT_VALUE_EXT 0x200B +#define WGL_SHARE_DEPTH_EXT 0x200C +#define WGL_SHARE_STENCIL_EXT 0x200D +#define WGL_SHARE_ACCUM_EXT 0x200E +#define WGL_SUPPORT_GDI_EXT 0x200F +#define WGL_SUPPORT_OPENGL_EXT 0x2010 +#define WGL_DOUBLE_BUFFER_EXT 0x2011 +#define WGL_STEREO_EXT 0x2012 +#define WGL_PIXEL_TYPE_EXT 0x2013 +#define WGL_COLOR_BITS_EXT 0x2014 +#define WGL_RED_BITS_EXT 0x2015 +#define WGL_RED_SHIFT_EXT 0x2016 +#define WGL_GREEN_BITS_EXT 0x2017 +#define WGL_GREEN_SHIFT_EXT 0x2018 +#define WGL_BLUE_BITS_EXT 0x2019 +#define WGL_BLUE_SHIFT_EXT 0x201A +#define WGL_ALPHA_BITS_EXT 0x201B +#define WGL_ALPHA_SHIFT_EXT 0x201C +#define WGL_ACCUM_BITS_EXT 0x201D +#define WGL_ACCUM_RED_BITS_EXT 0x201E +#define WGL_ACCUM_GREEN_BITS_EXT 0x201F +#define WGL_ACCUM_BLUE_BITS_EXT 0x2020 +#define WGL_ACCUM_ALPHA_BITS_EXT 0x2021 +#define WGL_DEPTH_BITS_EXT 0x2022 +#define WGL_STENCIL_BITS_EXT 0x2023 +#define WGL_AUX_BUFFERS_EXT 0x2024 +#define WGL_NO_ACCELERATION_EXT 0x2025 +#define WGL_GENERIC_ACCELERATION_EXT 0x2026 +#define WGL_FULL_ACCELERATION_EXT 0x2027 +#define WGL_SWAP_EXCHANGE_EXT 0x2028 +#define WGL_SWAP_COPY_EXT 0x2029 +#define WGL_SWAP_UNDEFINED_EXT 0x202A +#define WGL_TYPE_RGBA_EXT 0x202B +#define WGL_TYPE_COLORINDEX_EXT 0x202C +#endif + +#ifndef WGL_EXT_pbuffer +#define WGL_DRAW_TO_PBUFFER_EXT 0x202D +#define WGL_MAX_PBUFFER_PIXELS_EXT 0x202E +#define WGL_MAX_PBUFFER_WIDTH_EXT 0x202F +#define WGL_MAX_PBUFFER_HEIGHT_EXT 0x2030 +#define WGL_OPTIMAL_PBUFFER_WIDTH_EXT 0x2031 +#define WGL_OPTIMAL_PBUFFER_HEIGHT_EXT 0x2032 +#define WGL_PBUFFER_LARGEST_EXT 0x2033 +#define WGL_PBUFFER_WIDTH_EXT 0x2034 +#define WGL_PBUFFER_HEIGHT_EXT 0x2035 +#endif + +#ifndef WGL_EXT_depth_float +#define WGL_DEPTH_FLOAT_EXT 0x2040 +#endif + +#ifndef WGL_3DFX_multisample +#define WGL_SAMPLE_BUFFERS_3DFX 0x2060 +#define WGL_SAMPLES_3DFX 0x2061 +#endif + +#ifndef WGL_EXT_multisample +#define WGL_SAMPLE_BUFFERS_EXT 0x2041 +#define WGL_SAMPLES_EXT 0x2042 +#endif + +#ifndef WGL_I3D_digital_video_control +#define WGL_DIGITAL_VIDEO_CURSOR_ALPHA_FRAMEBUFFER_I3D 0x2050 +#define WGL_DIGITAL_VIDEO_CURSOR_ALPHA_VALUE_I3D 0x2051 +#define WGL_DIGITAL_VIDEO_CURSOR_INCLUDED_I3D 0x2052 +#define WGL_DIGITAL_VIDEO_GAMMA_CORRECTED_I3D 0x2053 +#endif + +#ifndef WGL_I3D_gamma +#define WGL_GAMMA_TABLE_SIZE_I3D 0x204E +#define WGL_GAMMA_EXCLUDE_DESKTOP_I3D 0x204F +#endif + +#ifndef WGL_I3D_genlock +#define WGL_GENLOCK_SOURCE_MULTIVIEW_I3D 0x2044 +#define WGL_GENLOCK_SOURCE_EXTENAL_SYNC_I3D 0x2045 +#define WGL_GENLOCK_SOURCE_EXTENAL_FIELD_I3D 0x2046 +#define WGL_GENLOCK_SOURCE_EXTENAL_TTL_I3D 0x2047 +#define WGL_GENLOCK_SOURCE_DIGITAL_SYNC_I3D 0x2048 +#define WGL_GENLOCK_SOURCE_DIGITAL_FIELD_I3D 0x2049 +#define WGL_GENLOCK_SOURCE_EDGE_FALLING_I3D 0x204A +#define WGL_GENLOCK_SOURCE_EDGE_RISING_I3D 0x204B +#define WGL_GENLOCK_SOURCE_EDGE_BOTH_I3D 0x204C +#endif + +#ifndef WGL_I3D_image_buffer +#define WGL_IMAGE_BUFFER_MIN_ACCESS_I3D 0x00000001 +#define WGL_IMAGE_BUFFER_LOCK_I3D 0x00000002 +#endif + +#ifndef WGL_I3D_swap_frame_lock +#endif + +#ifndef WGL_NV_render_depth_texture +#define WGL_BIND_TO_TEXTURE_DEPTH_NV 0x20A3 +#define WGL_BIND_TO_TEXTURE_RECTANGLE_DEPTH_NV 0x20A4 +#define WGL_DEPTH_TEXTURE_FORMAT_NV 0x20A5 +#define WGL_TEXTURE_DEPTH_COMPONENT_NV 0x20A6 +#define WGL_DEPTH_COMPONENT_NV 0x20A7 +#endif + +#ifndef WGL_NV_render_texture_rectangle +#define WGL_BIND_TO_TEXTURE_RECTANGLE_RGB_NV 0x20A0 +#define WGL_BIND_TO_TEXTURE_RECTANGLE_RGBA_NV 0x20A1 +#define WGL_TEXTURE_RECTANGLE_NV 0x20A2 +#endif + +#ifndef WGL_ATI_pixel_format_float +#define WGL_TYPE_RGBA_FLOAT_ATI 0x21A0 +#endif + +#ifndef WGL_NV_float_buffer +#define WGL_FLOAT_COMPONENTS_NV 0x20B0 +#define WGL_BIND_TO_TEXTURE_RECTANGLE_FLOAT_R_NV 0x20B1 +#define WGL_BIND_TO_TEXTURE_RECTANGLE_FLOAT_RG_NV 0x20B2 +#define WGL_BIND_TO_TEXTURE_RECTANGLE_FLOAT_RGB_NV 0x20B3 +#define WGL_BIND_TO_TEXTURE_RECTANGLE_FLOAT_RGBA_NV 0x20B4 +#define WGL_TEXTURE_FLOAT_R_NV 0x20B5 +#define WGL_TEXTURE_FLOAT_RG_NV 0x20B6 +#define WGL_TEXTURE_FLOAT_RGB_NV 0x20B7 +#define WGL_TEXTURE_FLOAT_RGBA_NV 0x20B8 +#endif + +#ifndef WGL_3DL_stereo_control +#define WGL_STEREO_EMITTER_ENABLE_3DL 0x2055 +#define WGL_STEREO_EMITTER_DISABLE_3DL 0x2056 +#define WGL_STEREO_POLARITY_NORMAL_3DL 0x2057 +#define WGL_STEREO_POLARITY_INVERT_3DL 0x2058 +#endif + +#ifndef WGL_EXT_pixel_format_packed_float +#define WGL_TYPE_RGBA_UNSIGNED_FLOAT_EXT 0x20A8 +#endif + +#ifndef WGL_EXT_framebuffer_sRGB +#define WGL_FRAMEBUFFER_SRGB_CAPABLE_EXT 0x20A9 +#endif + +#ifndef WGL_NV_present_video +#define WGL_NUM_VIDEO_SLOTS_NV 0x20F0 +#endif + +#ifndef WGL_NV_video_out +#define WGL_BIND_TO_VIDEO_RGB_NV 0x20C0 +#define WGL_BIND_TO_VIDEO_RGBA_NV 0x20C1 +#define WGL_BIND_TO_VIDEO_RGB_AND_DEPTH_NV 0x20C2 +#define WGL_VIDEO_OUT_COLOR_NV 0x20C3 +#define WGL_VIDEO_OUT_ALPHA_NV 0x20C4 +#define WGL_VIDEO_OUT_DEPTH_NV 0x20C5 +#define WGL_VIDEO_OUT_COLOR_AND_ALPHA_NV 0x20C6 +#define WGL_VIDEO_OUT_COLOR_AND_DEPTH_NV 0x20C7 +#define WGL_VIDEO_OUT_FRAME 0x20C8 +#define WGL_VIDEO_OUT_FIELD_1 0x20C9 +#define WGL_VIDEO_OUT_FIELD_2 0x20CA +#define WGL_VIDEO_OUT_STACKED_FIELDS_1_2 0x20CB +#define WGL_VIDEO_OUT_STACKED_FIELDS_2_1 0x20CC +#endif + +#ifndef WGL_NV_swap_group +#endif + +#ifndef WGL_NV_gpu_affinity +#define WGL_ERROR_INCOMPATIBLE_AFFINITY_MASKS_NV 0x20D0 +#define WGL_ERROR_MISSING_AFFINITY_MASK_NV 0x20D1 +#endif + +#ifndef WGL_AMD_gpu_association +#define WGL_GPU_VENDOR_AMD 0x1F00 +#define WGL_GPU_RENDERER_STRING_AMD 0x1F01 +#define WGL_GPU_OPENGL_VERSION_STRING_AMD 0x1F02 +#define WGL_GPU_FASTEST_TARGET_GPUS_AMD 0x21A2 +#define WGL_GPU_RAM_AMD 0x21A3 +#define WGL_GPU_CLOCK_AMD 0x21A4 +#define WGL_GPU_NUM_PIPES_AMD 0x21A5 +#define WGL_GPU_NUM_SIMD_AMD 0x21A6 +#define WGL_GPU_NUM_RB_AMD 0x21A7 +#define WGL_GPU_NUM_SPI_AMD 0x21A8 +#endif + +#ifndef WGL_NV_video_capture +#define WGL_UNIQUE_ID_NV 0x20CE +#define WGL_NUM_VIDEO_CAPTURE_SLOTS_NV 0x20CF +#endif + +#ifndef WGL_NV_copy_image +#endif + +#ifndef WGL_NV_multisample_coverage +#define WGL_COVERAGE_SAMPLES_NV 0x2042 +#define WGL_COLOR_SAMPLES_NV 0x20B9 +#endif + +#ifndef WGL_EXT_create_context_es2_profile +#define WGL_CONTEXT_ES2_PROFILE_BIT_EXT 0x00000004 +#endif + +#ifndef WGL_NV_DX_interop +#define WGL_ACCESS_READ_ONLY_NV 0x00000000 +#define WGL_ACCESS_READ_WRITE_NV 0x00000001 +#define WGL_ACCESS_WRITE_DISCARD_NV 0x00000002 +#endif + + +/*************************************************************/ + +#ifndef WGL_ARB_pbuffer +DECLARE_HANDLE(HPBUFFERARB); +#endif +#ifndef WGL_EXT_pbuffer +DECLARE_HANDLE(HPBUFFEREXT); +#endif +#ifndef WGL_NV_present_video +DECLARE_HANDLE(HVIDEOOUTPUTDEVICENV); +#endif +#ifndef WGL_NV_video_output +DECLARE_HANDLE(HPVIDEODEV); +#endif +#ifndef WGL_NV_gpu_affinity +DECLARE_HANDLE(HPGPUNV); +DECLARE_HANDLE(HGPUNV); + +typedef struct _GPU_DEVICE { + DWORD cb; + CHAR DeviceName[32]; + CHAR DeviceString[128]; + DWORD Flags; + RECT rcVirtualScreen; +} GPU_DEVICE, *PGPU_DEVICE; +#endif +#ifndef WGL_NV_video_capture +DECLARE_HANDLE(HVIDEOINPUTDEVICENV); +#endif + +#ifndef WGL_ARB_buffer_region +#define WGL_ARB_buffer_region 1 +#ifdef WGL_WGLEXT_PROTOTYPES +extern HANDLE WINAPI wglCreateBufferRegionARB (HDC hDC, int iLayerPlane, UINT uType); +extern VOID WINAPI wglDeleteBufferRegionARB (HANDLE hRegion); +extern BOOL WINAPI wglSaveBufferRegionARB (HANDLE hRegion, int x, int y, int width, int height); +extern BOOL WINAPI wglRestoreBufferRegionARB (HANDLE hRegion, int x, int y, int width, int height, int xSrc, int ySrc); +#endif /* WGL_WGLEXT_PROTOTYPES */ +typedef HANDLE (WINAPI * PFNWGLCREATEBUFFERREGIONARBPROC) (HDC hDC, int iLayerPlane, UINT uType); +typedef VOID (WINAPI * PFNWGLDELETEBUFFERREGIONARBPROC) (HANDLE hRegion); +typedef BOOL (WINAPI * PFNWGLSAVEBUFFERREGIONARBPROC) (HANDLE hRegion, int x, int y, int width, int height); +typedef BOOL (WINAPI * PFNWGLRESTOREBUFFERREGIONARBPROC) (HANDLE hRegion, int x, int y, int width, int height, int xSrc, int ySrc); +#endif + +#ifndef WGL_ARB_multisample +#define WGL_ARB_multisample 1 +#endif + +#ifndef WGL_ARB_extensions_string +#define WGL_ARB_extensions_string 1 +#ifdef WGL_WGLEXT_PROTOTYPES +extern const char * WINAPI wglGetExtensionsStringARB (HDC hdc); +#endif /* WGL_WGLEXT_PROTOTYPES */ +typedef const char * (WINAPI * PFNWGLGETEXTENSIONSSTRINGARBPROC) (HDC hdc); +#endif + +#ifndef WGL_ARB_pixel_format +#define WGL_ARB_pixel_format 1 +#ifdef WGL_WGLEXT_PROTOTYPES +extern BOOL WINAPI wglGetPixelFormatAttribivARB (HDC hdc, int iPixelFormat, int iLayerPlane, UINT nAttributes, const int *piAttributes, int *piValues); +extern BOOL WINAPI wglGetPixelFormatAttribfvARB (HDC hdc, int iPixelFormat, int iLayerPlane, UINT nAttributes, const int *piAttributes, FLOAT *pfValues); +extern BOOL WINAPI wglChoosePixelFormatARB (HDC hdc, const int *piAttribIList, const FLOAT *pfAttribFList, UINT nMaxFormats, int *piFormats, UINT *nNumFormats); +#endif /* WGL_WGLEXT_PROTOTYPES */ +typedef BOOL (WINAPI * PFNWGLGETPIXELFORMATATTRIBIVARBPROC) (HDC hdc, int iPixelFormat, int iLayerPlane, UINT nAttributes, const int *piAttributes, int *piValues); +typedef BOOL (WINAPI * PFNWGLGETPIXELFORMATATTRIBFVARBPROC) (HDC hdc, int iPixelFormat, int iLayerPlane, UINT nAttributes, const int *piAttributes, FLOAT *pfValues); +typedef BOOL (WINAPI * PFNWGLCHOOSEPIXELFORMATARBPROC) (HDC hdc, const int *piAttribIList, const FLOAT *pfAttribFList, UINT nMaxFormats, int *piFormats, UINT *nNumFormats); +#endif + +#ifndef WGL_ARB_make_current_read +#define WGL_ARB_make_current_read 1 +#ifdef WGL_WGLEXT_PROTOTYPES +extern BOOL WINAPI wglMakeContextCurrentARB (HDC hDrawDC, HDC hReadDC, HGLRC hglrc); +extern HDC WINAPI wglGetCurrentReadDCARB (void); +#endif /* WGL_WGLEXT_PROTOTYPES */ +typedef BOOL (WINAPI * PFNWGLMAKECONTEXTCURRENTARBPROC) (HDC hDrawDC, HDC hReadDC, HGLRC hglrc); +typedef HDC (WINAPI * PFNWGLGETCURRENTREADDCARBPROC) (void); +#endif + +#ifndef WGL_ARB_pbuffer +#define WGL_ARB_pbuffer 1 +#ifdef WGL_WGLEXT_PROTOTYPES +extern HPBUFFERARB WINAPI wglCreatePbufferARB (HDC hDC, int iPixelFormat, int iWidth, int iHeight, const int *piAttribList); +extern HDC WINAPI wglGetPbufferDCARB (HPBUFFERARB hPbuffer); +extern int WINAPI wglReleasePbufferDCARB (HPBUFFERARB hPbuffer, HDC hDC); +extern BOOL WINAPI wglDestroyPbufferARB (HPBUFFERARB hPbuffer); +extern BOOL WINAPI wglQueryPbufferARB (HPBUFFERARB hPbuffer, int iAttribute, int *piValue); +#endif /* WGL_WGLEXT_PROTOTYPES */ +typedef HPBUFFERARB (WINAPI * PFNWGLCREATEPBUFFERARBPROC) (HDC hDC, int iPixelFormat, int iWidth, int iHeight, const int *piAttribList); +typedef HDC (WINAPI * PFNWGLGETPBUFFERDCARBPROC) (HPBUFFERARB hPbuffer); +typedef int (WINAPI * PFNWGLRELEASEPBUFFERDCARBPROC) (HPBUFFERARB hPbuffer, HDC hDC); +typedef BOOL (WINAPI * PFNWGLDESTROYPBUFFERARBPROC) (HPBUFFERARB hPbuffer); +typedef BOOL (WINAPI * PFNWGLQUERYPBUFFERARBPROC) (HPBUFFERARB hPbuffer, int iAttribute, int *piValue); +#endif + +#ifndef WGL_ARB_render_texture +#define WGL_ARB_render_texture 1 +#ifdef WGL_WGLEXT_PROTOTYPES +extern BOOL WINAPI wglBindTexImageARB (HPBUFFERARB hPbuffer, int iBuffer); +extern BOOL WINAPI wglReleaseTexImageARB (HPBUFFERARB hPbuffer, int iBuffer); +extern BOOL WINAPI wglSetPbufferAttribARB (HPBUFFERARB hPbuffer, const int *piAttribList); +#endif /* WGL_WGLEXT_PROTOTYPES */ +typedef BOOL (WINAPI * PFNWGLBINDTEXIMAGEARBPROC) (HPBUFFERARB hPbuffer, int iBuffer); +typedef BOOL (WINAPI * PFNWGLRELEASETEXIMAGEARBPROC) (HPBUFFERARB hPbuffer, int iBuffer); +typedef BOOL (WINAPI * PFNWGLSETPBUFFERATTRIBARBPROC) (HPBUFFERARB hPbuffer, const int *piAttribList); +#endif + +#ifndef WGL_ARB_pixel_format_float +#define WGL_ARB_pixel_format_float 1 +#endif + +#ifndef WGL_ARB_framebuffer_sRGB +#define WGL_ARB_framebuffer_sRGB 1 +#endif + +#ifndef WGL_ARB_create_context +#define WGL_ARB_create_context 1 +#ifdef WGL_WGLEXT_PROTOTYPES +extern HGLRC WINAPI wglCreateContextAttribsARB (HDC hDC, HGLRC hShareContext, const int *attribList); +#endif /* WGL_WGLEXT_PROTOTYPES */ +typedef HGLRC (WINAPI * PFNWGLCREATECONTEXTATTRIBSARBPROC) (HDC hDC, HGLRC hShareContext, const int *attribList); +#endif + +#ifndef WGL_ARB_create_context_profile +#define WGL_ARB_create_context_profile 1 +#endif + +#ifndef WGL_ARB_create_context_robustness +#define WGL_ARB_create_context_robustness 1 +#endif + +#ifndef WGL_EXT_display_color_table +#define WGL_EXT_display_color_table 1 +#ifdef WGL_WGLEXT_PROTOTYPES +extern GLboolean WINAPI wglCreateDisplayColorTableEXT (GLushort id); +extern GLboolean WINAPI wglLoadDisplayColorTableEXT (const GLushort *table, GLuint length); +extern GLboolean WINAPI wglBindDisplayColorTableEXT (GLushort id); +extern VOID WINAPI wglDestroyDisplayColorTableEXT (GLushort id); +#endif /* WGL_WGLEXT_PROTOTYPES */ +typedef GLboolean (WINAPI * PFNWGLCREATEDISPLAYCOLORTABLEEXTPROC) (GLushort id); +typedef GLboolean (WINAPI * PFNWGLLOADDISPLAYCOLORTABLEEXTPROC) (const GLushort *table, GLuint length); +typedef GLboolean (WINAPI * PFNWGLBINDDISPLAYCOLORTABLEEXTPROC) (GLushort id); +typedef VOID (WINAPI * PFNWGLDESTROYDISPLAYCOLORTABLEEXTPROC) (GLushort id); +#endif + +#ifndef WGL_EXT_extensions_string +#define WGL_EXT_extensions_string 1 +#ifdef WGL_WGLEXT_PROTOTYPES +extern const char * WINAPI wglGetExtensionsStringEXT (void); +#endif /* WGL_WGLEXT_PROTOTYPES */ +typedef const char * (WINAPI * PFNWGLGETEXTENSIONSSTRINGEXTPROC) (void); +#endif + +#ifndef WGL_EXT_make_current_read +#define WGL_EXT_make_current_read 1 +#ifdef WGL_WGLEXT_PROTOTYPES +extern BOOL WINAPI wglMakeContextCurrentEXT (HDC hDrawDC, HDC hReadDC, HGLRC hglrc); +extern HDC WINAPI wglGetCurrentReadDCEXT (void); +#endif /* WGL_WGLEXT_PROTOTYPES */ +typedef BOOL (WINAPI * PFNWGLMAKECONTEXTCURRENTEXTPROC) (HDC hDrawDC, HDC hReadDC, HGLRC hglrc); +typedef HDC (WINAPI * PFNWGLGETCURRENTREADDCEXTPROC) (void); +#endif + +#ifndef WGL_EXT_pbuffer +#define WGL_EXT_pbuffer 1 +#ifdef WGL_WGLEXT_PROTOTYPES +extern HPBUFFEREXT WINAPI wglCreatePbufferEXT (HDC hDC, int iPixelFormat, int iWidth, int iHeight, const int *piAttribList); +extern HDC WINAPI wglGetPbufferDCEXT (HPBUFFEREXT hPbuffer); +extern int WINAPI wglReleasePbufferDCEXT (HPBUFFEREXT hPbuffer, HDC hDC); +extern BOOL WINAPI wglDestroyPbufferEXT (HPBUFFEREXT hPbuffer); +extern BOOL WINAPI wglQueryPbufferEXT (HPBUFFEREXT hPbuffer, int iAttribute, int *piValue); +#endif /* WGL_WGLEXT_PROTOTYPES */ +typedef HPBUFFEREXT (WINAPI * PFNWGLCREATEPBUFFEREXTPROC) (HDC hDC, int iPixelFormat, int iWidth, int iHeight, const int *piAttribList); +typedef HDC (WINAPI * PFNWGLGETPBUFFERDCEXTPROC) (HPBUFFEREXT hPbuffer); +typedef int (WINAPI * PFNWGLRELEASEPBUFFERDCEXTPROC) (HPBUFFEREXT hPbuffer, HDC hDC); +typedef BOOL (WINAPI * PFNWGLDESTROYPBUFFEREXTPROC) (HPBUFFEREXT hPbuffer); +typedef BOOL (WINAPI * PFNWGLQUERYPBUFFEREXTPROC) (HPBUFFEREXT hPbuffer, int iAttribute, int *piValue); +#endif + +#ifndef WGL_EXT_pixel_format +#define WGL_EXT_pixel_format 1 +#ifdef WGL_WGLEXT_PROTOTYPES +extern BOOL WINAPI wglGetPixelFormatAttribivEXT (HDC hdc, int iPixelFormat, int iLayerPlane, UINT nAttributes, int *piAttributes, int *piValues); +extern BOOL WINAPI wglGetPixelFormatAttribfvEXT (HDC hdc, int iPixelFormat, int iLayerPlane, UINT nAttributes, int *piAttributes, FLOAT *pfValues); +extern BOOL WINAPI wglChoosePixelFormatEXT (HDC hdc, const int *piAttribIList, const FLOAT *pfAttribFList, UINT nMaxFormats, int *piFormats, UINT *nNumFormats); +#endif /* WGL_WGLEXT_PROTOTYPES */ +typedef BOOL (WINAPI * PFNWGLGETPIXELFORMATATTRIBIVEXTPROC) (HDC hdc, int iPixelFormat, int iLayerPlane, UINT nAttributes, int *piAttributes, int *piValues); +typedef BOOL (WINAPI * PFNWGLGETPIXELFORMATATTRIBFVEXTPROC) (HDC hdc, int iPixelFormat, int iLayerPlane, UINT nAttributes, int *piAttributes, FLOAT *pfValues); +typedef BOOL (WINAPI * PFNWGLCHOOSEPIXELFORMATEXTPROC) (HDC hdc, const int *piAttribIList, const FLOAT *pfAttribFList, UINT nMaxFormats, int *piFormats, UINT *nNumFormats); +#endif + +#ifndef WGL_EXT_swap_control +#define WGL_EXT_swap_control 1 +#ifdef WGL_WGLEXT_PROTOTYPES +extern BOOL WINAPI wglSwapIntervalEXT (int interval); +extern int WINAPI wglGetSwapIntervalEXT (void); +#endif /* WGL_WGLEXT_PROTOTYPES */ +typedef BOOL (WINAPI * PFNWGLSWAPINTERVALEXTPROC) (int interval); +typedef int (WINAPI * PFNWGLGETSWAPINTERVALEXTPROC) (void); +#endif + +#ifndef WGL_EXT_depth_float +#define WGL_EXT_depth_float 1 +#endif + +#ifndef WGL_NV_vertex_array_range +#define WGL_NV_vertex_array_range 1 +#ifdef WGL_WGLEXT_PROTOTYPES +extern void* WINAPI wglAllocateMemoryNV (GLsizei size, GLfloat readfreq, GLfloat writefreq, GLfloat priority); +extern void WINAPI wglFreeMemoryNV (void *pointer); +#endif /* WGL_WGLEXT_PROTOTYPES */ +typedef void* (WINAPI * PFNWGLALLOCATEMEMORYNVPROC) (GLsizei size, GLfloat readfreq, GLfloat writefreq, GLfloat priority); +typedef void (WINAPI * PFNWGLFREEMEMORYNVPROC) (void *pointer); +#endif + +#ifndef WGL_3DFX_multisample +#define WGL_3DFX_multisample 1 +#endif + +#ifndef WGL_EXT_multisample +#define WGL_EXT_multisample 1 +#endif + +#ifndef WGL_OML_sync_control +#define WGL_OML_sync_control 1 +#ifdef WGL_WGLEXT_PROTOTYPES +extern BOOL WINAPI wglGetSyncValuesOML (HDC hdc, INT64 *ust, INT64 *msc, INT64 *sbc); +extern BOOL WINAPI wglGetMscRateOML (HDC hdc, INT32 *numerator, INT32 *denominator); +extern INT64 WINAPI wglSwapBuffersMscOML (HDC hdc, INT64 target_msc, INT64 divisor, INT64 remainder); +extern INT64 WINAPI wglSwapLayerBuffersMscOML (HDC hdc, int fuPlanes, INT64 target_msc, INT64 divisor, INT64 remainder); +extern BOOL WINAPI wglWaitForMscOML (HDC hdc, INT64 target_msc, INT64 divisor, INT64 remainder, INT64 *ust, INT64 *msc, INT64 *sbc); +extern BOOL WINAPI wglWaitForSbcOML (HDC hdc, INT64 target_sbc, INT64 *ust, INT64 *msc, INT64 *sbc); +#endif /* WGL_WGLEXT_PROTOTYPES */ +typedef BOOL (WINAPI * PFNWGLGETSYNCVALUESOMLPROC) (HDC hdc, INT64 *ust, INT64 *msc, INT64 *sbc); +typedef BOOL (WINAPI * PFNWGLGETMSCRATEOMLPROC) (HDC hdc, INT32 *numerator, INT32 *denominator); +typedef INT64 (WINAPI * PFNWGLSWAPBUFFERSMSCOMLPROC) (HDC hdc, INT64 target_msc, INT64 divisor, INT64 remainder); +typedef INT64 (WINAPI * PFNWGLSWAPLAYERBUFFERSMSCOMLPROC) (HDC hdc, int fuPlanes, INT64 target_msc, INT64 divisor, INT64 remainder); +typedef BOOL (WINAPI * PFNWGLWAITFORMSCOMLPROC) (HDC hdc, INT64 target_msc, INT64 divisor, INT64 remainder, INT64 *ust, INT64 *msc, INT64 *sbc); +typedef BOOL (WINAPI * PFNWGLWAITFORSBCOMLPROC) (HDC hdc, INT64 target_sbc, INT64 *ust, INT64 *msc, INT64 *sbc); +#endif + +#ifndef WGL_I3D_digital_video_control +#define WGL_I3D_digital_video_control 1 +#ifdef WGL_WGLEXT_PROTOTYPES +extern BOOL WINAPI wglGetDigitalVideoParametersI3D (HDC hDC, int iAttribute, int *piValue); +extern BOOL WINAPI wglSetDigitalVideoParametersI3D (HDC hDC, int iAttribute, const int *piValue); +#endif /* WGL_WGLEXT_PROTOTYPES */ +typedef BOOL (WINAPI * PFNWGLGETDIGITALVIDEOPARAMETERSI3DPROC) (HDC hDC, int iAttribute, int *piValue); +typedef BOOL (WINAPI * PFNWGLSETDIGITALVIDEOPARAMETERSI3DPROC) (HDC hDC, int iAttribute, const int *piValue); +#endif + +#ifndef WGL_I3D_gamma +#define WGL_I3D_gamma 1 +#ifdef WGL_WGLEXT_PROTOTYPES +extern BOOL WINAPI wglGetGammaTableParametersI3D (HDC hDC, int iAttribute, int *piValue); +extern BOOL WINAPI wglSetGammaTableParametersI3D (HDC hDC, int iAttribute, const int *piValue); +extern BOOL WINAPI wglGetGammaTableI3D (HDC hDC, int iEntries, USHORT *puRed, USHORT *puGreen, USHORT *puBlue); +extern BOOL WINAPI wglSetGammaTableI3D (HDC hDC, int iEntries, const USHORT *puRed, const USHORT *puGreen, const USHORT *puBlue); +#endif /* WGL_WGLEXT_PROTOTYPES */ +typedef BOOL (WINAPI * PFNWGLGETGAMMATABLEPARAMETERSI3DPROC) (HDC hDC, int iAttribute, int *piValue); +typedef BOOL (WINAPI * PFNWGLSETGAMMATABLEPARAMETERSI3DPROC) (HDC hDC, int iAttribute, const int *piValue); +typedef BOOL (WINAPI * PFNWGLGETGAMMATABLEI3DPROC) (HDC hDC, int iEntries, USHORT *puRed, USHORT *puGreen, USHORT *puBlue); +typedef BOOL (WINAPI * PFNWGLSETGAMMATABLEI3DPROC) (HDC hDC, int iEntries, const USHORT *puRed, const USHORT *puGreen, const USHORT *puBlue); +#endif + +#ifndef WGL_I3D_genlock +#define WGL_I3D_genlock 1 +#ifdef WGL_WGLEXT_PROTOTYPES +extern BOOL WINAPI wglEnableGenlockI3D (HDC hDC); +extern BOOL WINAPI wglDisableGenlockI3D (HDC hDC); +extern BOOL WINAPI wglIsEnabledGenlockI3D (HDC hDC, BOOL *pFlag); +extern BOOL WINAPI wglGenlockSourceI3D (HDC hDC, UINT uSource); +extern BOOL WINAPI wglGetGenlockSourceI3D (HDC hDC, UINT *uSource); +extern BOOL WINAPI wglGenlockSourceEdgeI3D (HDC hDC, UINT uEdge); +extern BOOL WINAPI wglGetGenlockSourceEdgeI3D (HDC hDC, UINT *uEdge); +extern BOOL WINAPI wglGenlockSampleRateI3D (HDC hDC, UINT uRate); +extern BOOL WINAPI wglGetGenlockSampleRateI3D (HDC hDC, UINT *uRate); +extern BOOL WINAPI wglGenlockSourceDelayI3D (HDC hDC, UINT uDelay); +extern BOOL WINAPI wglGetGenlockSourceDelayI3D (HDC hDC, UINT *uDelay); +extern BOOL WINAPI wglQueryGenlockMaxSourceDelayI3D (HDC hDC, UINT *uMaxLineDelay, UINT *uMaxPixelDelay); +#endif /* WGL_WGLEXT_PROTOTYPES */ +typedef BOOL (WINAPI * PFNWGLENABLEGENLOCKI3DPROC) (HDC hDC); +typedef BOOL (WINAPI * PFNWGLDISABLEGENLOCKI3DPROC) (HDC hDC); +typedef BOOL (WINAPI * PFNWGLISENABLEDGENLOCKI3DPROC) (HDC hDC, BOOL *pFlag); +typedef BOOL (WINAPI * PFNWGLGENLOCKSOURCEI3DPROC) (HDC hDC, UINT uSource); +typedef BOOL (WINAPI * PFNWGLGETGENLOCKSOURCEI3DPROC) (HDC hDC, UINT *uSource); +typedef BOOL (WINAPI * PFNWGLGENLOCKSOURCEEDGEI3DPROC) (HDC hDC, UINT uEdge); +typedef BOOL (WINAPI * PFNWGLGETGENLOCKSOURCEEDGEI3DPROC) (HDC hDC, UINT *uEdge); +typedef BOOL (WINAPI * PFNWGLGENLOCKSAMPLERATEI3DPROC) (HDC hDC, UINT uRate); +typedef BOOL (WINAPI * PFNWGLGETGENLOCKSAMPLERATEI3DPROC) (HDC hDC, UINT *uRate); +typedef BOOL (WINAPI * PFNWGLGENLOCKSOURCEDELAYI3DPROC) (HDC hDC, UINT uDelay); +typedef BOOL (WINAPI * PFNWGLGETGENLOCKSOURCEDELAYI3DPROC) (HDC hDC, UINT *uDelay); +typedef BOOL (WINAPI * PFNWGLQUERYGENLOCKMAXSOURCEDELAYI3DPROC) (HDC hDC, UINT *uMaxLineDelay, UINT *uMaxPixelDelay); +#endif + +#ifndef WGL_I3D_image_buffer +#define WGL_I3D_image_buffer 1 +#ifdef WGL_WGLEXT_PROTOTYPES +extern LPVOID WINAPI wglCreateImageBufferI3D (HDC hDC, DWORD dwSize, UINT uFlags); +extern BOOL WINAPI wglDestroyImageBufferI3D (HDC hDC, LPVOID pAddress); +extern BOOL WINAPI wglAssociateImageBufferEventsI3D (HDC hDC, const HANDLE *pEvent, const LPVOID *pAddress, const DWORD *pSize, UINT count); +extern BOOL WINAPI wglReleaseImageBufferEventsI3D (HDC hDC, const LPVOID *pAddress, UINT count); +#endif /* WGL_WGLEXT_PROTOTYPES */ +typedef LPVOID (WINAPI * PFNWGLCREATEIMAGEBUFFERI3DPROC) (HDC hDC, DWORD dwSize, UINT uFlags); +typedef BOOL (WINAPI * PFNWGLDESTROYIMAGEBUFFERI3DPROC) (HDC hDC, LPVOID pAddress); +typedef BOOL (WINAPI * PFNWGLASSOCIATEIMAGEBUFFEREVENTSI3DPROC) (HDC hDC, const HANDLE *pEvent, const LPVOID *pAddress, const DWORD *pSize, UINT count); +typedef BOOL (WINAPI * PFNWGLRELEASEIMAGEBUFFEREVENTSI3DPROC) (HDC hDC, const LPVOID *pAddress, UINT count); +#endif + +#ifndef WGL_I3D_swap_frame_lock +#define WGL_I3D_swap_frame_lock 1 +#ifdef WGL_WGLEXT_PROTOTYPES +extern BOOL WINAPI wglEnableFrameLockI3D (void); +extern BOOL WINAPI wglDisableFrameLockI3D (void); +extern BOOL WINAPI wglIsEnabledFrameLockI3D (BOOL *pFlag); +extern BOOL WINAPI wglQueryFrameLockMasterI3D (BOOL *pFlag); +#endif /* WGL_WGLEXT_PROTOTYPES */ +typedef BOOL (WINAPI * PFNWGLENABLEFRAMELOCKI3DPROC) (void); +typedef BOOL (WINAPI * PFNWGLDISABLEFRAMELOCKI3DPROC) (void); +typedef BOOL (WINAPI * PFNWGLISENABLEDFRAMELOCKI3DPROC) (BOOL *pFlag); +typedef BOOL (WINAPI * PFNWGLQUERYFRAMELOCKMASTERI3DPROC) (BOOL *pFlag); +#endif + +#ifndef WGL_I3D_swap_frame_usage +#define WGL_I3D_swap_frame_usage 1 +#ifdef WGL_WGLEXT_PROTOTYPES +extern BOOL WINAPI wglGetFrameUsageI3D (float *pUsage); +extern BOOL WINAPI wglBeginFrameTrackingI3D (void); +extern BOOL WINAPI wglEndFrameTrackingI3D (void); +extern BOOL WINAPI wglQueryFrameTrackingI3D (DWORD *pFrameCount, DWORD *pMissedFrames, float *pLastMissedUsage); +#endif /* WGL_WGLEXT_PROTOTYPES */ +typedef BOOL (WINAPI * PFNWGLGETFRAMEUSAGEI3DPROC) (float *pUsage); +typedef BOOL (WINAPI * PFNWGLBEGINFRAMETRACKINGI3DPROC) (void); +typedef BOOL (WINAPI * PFNWGLENDFRAMETRACKINGI3DPROC) (void); +typedef BOOL (WINAPI * PFNWGLQUERYFRAMETRACKINGI3DPROC) (DWORD *pFrameCount, DWORD *pMissedFrames, float *pLastMissedUsage); +#endif + +#ifndef WGL_ATI_pixel_format_float +#define WGL_ATI_pixel_format_float 1 +#endif + +#ifndef WGL_NV_float_buffer +#define WGL_NV_float_buffer 1 +#endif + +#ifndef WGL_3DL_stereo_control +#define WGL_3DL_stereo_control 1 +#ifdef WGL_WGLEXT_PROTOTYPES +extern BOOL WINAPI wglSetStereoEmitterState3DL (HDC hDC, UINT uState); +#endif /* WGL_WGLEXT_PROTOTYPES */ +typedef BOOL (WINAPI * PFNWGLSETSTEREOEMITTERSTATE3DLPROC) (HDC hDC, UINT uState); +#endif + +#ifndef WGL_EXT_pixel_format_packed_float +#define WGL_EXT_pixel_format_packed_float 1 +#endif + +#ifndef WGL_EXT_framebuffer_sRGB +#define WGL_EXT_framebuffer_sRGB 1 +#endif + +#ifndef WGL_NV_present_video +#define WGL_NV_present_video 1 +#ifdef WGL_WGLEXT_PROTOTYPES +extern int WINAPI wglEnumerateVideoDevicesNV (HDC hDC, HVIDEOOUTPUTDEVICENV *phDeviceList); +extern BOOL WINAPI wglBindVideoDeviceNV (HDC hDC, unsigned int uVideoSlot, HVIDEOOUTPUTDEVICENV hVideoDevice, const int *piAttribList); +extern BOOL WINAPI wglQueryCurrentContextNV (int iAttribute, int *piValue); +#endif /* WGL_WGLEXT_PROTOTYPES */ +typedef int (WINAPI * PFNWGLENUMERATEVIDEODEVICESNVPROC) (HDC hDC, HVIDEOOUTPUTDEVICENV *phDeviceList); +typedef BOOL (WINAPI * PFNWGLBINDVIDEODEVICENVPROC) (HDC hDC, unsigned int uVideoSlot, HVIDEOOUTPUTDEVICENV hVideoDevice, const int *piAttribList); +typedef BOOL (WINAPI * PFNWGLQUERYCURRENTCONTEXTNVPROC) (int iAttribute, int *piValue); +#endif + +#ifndef WGL_NV_video_output +#define WGL_NV_video_output 1 +#ifdef WGL_WGLEXT_PROTOTYPES +extern BOOL WINAPI wglGetVideoDeviceNV (HDC hDC, int numDevices, HPVIDEODEV *hVideoDevice); +extern BOOL WINAPI wglReleaseVideoDeviceNV (HPVIDEODEV hVideoDevice); +extern BOOL WINAPI wglBindVideoImageNV (HPVIDEODEV hVideoDevice, HPBUFFERARB hPbuffer, int iVideoBuffer); +extern BOOL WINAPI wglReleaseVideoImageNV (HPBUFFERARB hPbuffer, int iVideoBuffer); +extern BOOL WINAPI wglSendPbufferToVideoNV (HPBUFFERARB hPbuffer, int iBufferType, unsigned long *pulCounterPbuffer, BOOL bBlock); +extern BOOL WINAPI wglGetVideoInfoNV (HPVIDEODEV hpVideoDevice, unsigned long *pulCounterOutputPbuffer, unsigned long *pulCounterOutputVideo); +#endif /* WGL_WGLEXT_PROTOTYPES */ +typedef BOOL (WINAPI * PFNWGLGETVIDEODEVICENVPROC) (HDC hDC, int numDevices, HPVIDEODEV *hVideoDevice); +typedef BOOL (WINAPI * PFNWGLRELEASEVIDEODEVICENVPROC) (HPVIDEODEV hVideoDevice); +typedef BOOL (WINAPI * PFNWGLBINDVIDEOIMAGENVPROC) (HPVIDEODEV hVideoDevice, HPBUFFERARB hPbuffer, int iVideoBuffer); +typedef BOOL (WINAPI * PFNWGLRELEASEVIDEOIMAGENVPROC) (HPBUFFERARB hPbuffer, int iVideoBuffer); +typedef BOOL (WINAPI * PFNWGLSENDPBUFFERTOVIDEONVPROC) (HPBUFFERARB hPbuffer, int iBufferType, unsigned long *pulCounterPbuffer, BOOL bBlock); +typedef BOOL (WINAPI * PFNWGLGETVIDEOINFONVPROC) (HPVIDEODEV hpVideoDevice, unsigned long *pulCounterOutputPbuffer, unsigned long *pulCounterOutputVideo); +#endif + +#ifndef WGL_NV_swap_group +#define WGL_NV_swap_group 1 +#ifdef WGL_WGLEXT_PROTOTYPES +extern BOOL WINAPI wglJoinSwapGroupNV (HDC hDC, GLuint group); +extern BOOL WINAPI wglBindSwapBarrierNV (GLuint group, GLuint barrier); +extern BOOL WINAPI wglQuerySwapGroupNV (HDC hDC, GLuint *group, GLuint *barrier); +extern BOOL WINAPI wglQueryMaxSwapGroupsNV (HDC hDC, GLuint *maxGroups, GLuint *maxBarriers); +extern BOOL WINAPI wglQueryFrameCountNV (HDC hDC, GLuint *count); +extern BOOL WINAPI wglResetFrameCountNV (HDC hDC); +#endif /* WGL_WGLEXT_PROTOTYPES */ +typedef BOOL (WINAPI * PFNWGLJOINSWAPGROUPNVPROC) (HDC hDC, GLuint group); +typedef BOOL (WINAPI * PFNWGLBINDSWAPBARRIERNVPROC) (GLuint group, GLuint barrier); +typedef BOOL (WINAPI * PFNWGLQUERYSWAPGROUPNVPROC) (HDC hDC, GLuint *group, GLuint *barrier); +typedef BOOL (WINAPI * PFNWGLQUERYMAXSWAPGROUPSNVPROC) (HDC hDC, GLuint *maxGroups, GLuint *maxBarriers); +typedef BOOL (WINAPI * PFNWGLQUERYFRAMECOUNTNVPROC) (HDC hDC, GLuint *count); +typedef BOOL (WINAPI * PFNWGLRESETFRAMECOUNTNVPROC) (HDC hDC); +#endif + +#ifndef WGL_NV_gpu_affinity +#define WGL_NV_gpu_affinity 1 +#ifdef WGL_WGLEXT_PROTOTYPES +extern BOOL WINAPI wglEnumGpusNV (UINT iGpuIndex, HGPUNV *phGpu); +extern BOOL WINAPI wglEnumGpuDevicesNV (HGPUNV hGpu, UINT iDeviceIndex, PGPU_DEVICE lpGpuDevice); +extern HDC WINAPI wglCreateAffinityDCNV (const HGPUNV *phGpuList); +extern BOOL WINAPI wglEnumGpusFromAffinityDCNV (HDC hAffinityDC, UINT iGpuIndex, HGPUNV *hGpu); +extern BOOL WINAPI wglDeleteDCNV (HDC hdc); +#endif /* WGL_WGLEXT_PROTOTYPES */ +typedef BOOL (WINAPI * PFNWGLENUMGPUSNVPROC) (UINT iGpuIndex, HGPUNV *phGpu); +typedef BOOL (WINAPI * PFNWGLENUMGPUDEVICESNVPROC) (HGPUNV hGpu, UINT iDeviceIndex, PGPU_DEVICE lpGpuDevice); +typedef HDC (WINAPI * PFNWGLCREATEAFFINITYDCNVPROC) (const HGPUNV *phGpuList); +typedef BOOL (WINAPI * PFNWGLENUMGPUSFROMAFFINITYDCNVPROC) (HDC hAffinityDC, UINT iGpuIndex, HGPUNV *hGpu); +typedef BOOL (WINAPI * PFNWGLDELETEDCNVPROC) (HDC hdc); +#endif + +#ifndef WGL_AMD_gpu_association +#define WGL_AMD_gpu_association 1 +#ifdef WGL_WGLEXT_PROTOTYPES +extern UINT WINAPI wglGetGPUIDsAMD (UINT maxCount, UINT *ids); +extern INT WINAPI wglGetGPUInfoAMD (UINT id, int property, GLenum dataType, UINT size, void *data); +extern UINT WINAPI wglGetContextGPUIDAMD (HGLRC hglrc); +extern HGLRC WINAPI wglCreateAssociatedContextAMD (UINT id); +extern HGLRC WINAPI wglCreateAssociatedContextAttribsAMD (UINT id, HGLRC hShareContext, const int *attribList); +extern BOOL WINAPI wglDeleteAssociatedContextAMD (HGLRC hglrc); +extern BOOL WINAPI wglMakeAssociatedContextCurrentAMD (HGLRC hglrc); +extern HGLRC WINAPI wglGetCurrentAssociatedContextAMD (void); +extern VOID WINAPI wglBlitContextFramebufferAMD (HGLRC dstCtx, GLint srcX0, GLint srcY0, GLint srcX1, GLint srcY1, GLint dstX0, GLint dstY0, GLint dstX1, GLint dstY1, GLbitfield mask, GLenum filter); +#endif /* WGL_WGLEXT_PROTOTYPES */ +typedef UINT (WINAPI * PFNWGLGETGPUIDSAMDPROC) (UINT maxCount, UINT *ids); +typedef INT (WINAPI * PFNWGLGETGPUINFOAMDPROC) (UINT id, int property, GLenum dataType, UINT size, void *data); +typedef UINT (WINAPI * PFNWGLGETCONTEXTGPUIDAMDPROC) (HGLRC hglrc); +typedef HGLRC (WINAPI * PFNWGLCREATEASSOCIATEDCONTEXTAMDPROC) (UINT id); +typedef HGLRC (WINAPI * PFNWGLCREATEASSOCIATEDCONTEXTATTRIBSAMDPROC) (UINT id, HGLRC hShareContext, const int *attribList); +typedef BOOL (WINAPI * PFNWGLDELETEASSOCIATEDCONTEXTAMDPROC) (HGLRC hglrc); +typedef BOOL (WINAPI * PFNWGLMAKEASSOCIATEDCONTEXTCURRENTAMDPROC) (HGLRC hglrc); +typedef HGLRC (WINAPI * PFNWGLGETCURRENTASSOCIATEDCONTEXTAMDPROC) (void); +typedef VOID (WINAPI * PFNWGLBLITCONTEXTFRAMEBUFFERAMDPROC) (HGLRC dstCtx, GLint srcX0, GLint srcY0, GLint srcX1, GLint srcY1, GLint dstX0, GLint dstY0, GLint dstX1, GLint dstY1, GLbitfield mask, GLenum filter); +#endif + +#ifndef WGL_NV_video_capture +#define WGL_NV_video_capture 1 +#ifdef WGL_WGLEXT_PROTOTYPES +extern BOOL WINAPI wglBindVideoCaptureDeviceNV (UINT uVideoSlot, HVIDEOINPUTDEVICENV hDevice); +extern UINT WINAPI wglEnumerateVideoCaptureDevicesNV (HDC hDc, HVIDEOINPUTDEVICENV *phDeviceList); +extern BOOL WINAPI wglLockVideoCaptureDeviceNV (HDC hDc, HVIDEOINPUTDEVICENV hDevice); +extern BOOL WINAPI wglQueryVideoCaptureDeviceNV (HDC hDc, HVIDEOINPUTDEVICENV hDevice, int iAttribute, int *piValue); +extern BOOL WINAPI wglReleaseVideoCaptureDeviceNV (HDC hDc, HVIDEOINPUTDEVICENV hDevice); +#endif /* WGL_WGLEXT_PROTOTYPES */ +typedef BOOL (WINAPI * PFNWGLBINDVIDEOCAPTUREDEVICENVPROC) (UINT uVideoSlot, HVIDEOINPUTDEVICENV hDevice); +typedef UINT (WINAPI * PFNWGLENUMERATEVIDEOCAPTUREDEVICESNVPROC) (HDC hDc, HVIDEOINPUTDEVICENV *phDeviceList); +typedef BOOL (WINAPI * PFNWGLLOCKVIDEOCAPTUREDEVICENVPROC) (HDC hDc, HVIDEOINPUTDEVICENV hDevice); +typedef BOOL (WINAPI * PFNWGLQUERYVIDEOCAPTUREDEVICENVPROC) (HDC hDc, HVIDEOINPUTDEVICENV hDevice, int iAttribute, int *piValue); +typedef BOOL (WINAPI * PFNWGLRELEASEVIDEOCAPTUREDEVICENVPROC) (HDC hDc, HVIDEOINPUTDEVICENV hDevice); +#endif + +#ifndef WGL_NV_copy_image +#define WGL_NV_copy_image 1 +#ifdef WGL_WGLEXT_PROTOTYPES +extern BOOL WINAPI wglCopyImageSubDataNV (HGLRC hSrcRC, GLuint srcName, GLenum srcTarget, GLint srcLevel, GLint srcX, GLint srcY, GLint srcZ, HGLRC hDstRC, GLuint dstName, GLenum dstTarget, GLint dstLevel, GLint dstX, GLint dstY, GLint dstZ, GLsizei width, GLsizei height, GLsizei depth); +#endif /* WGL_WGLEXT_PROTOTYPES */ +typedef BOOL (WINAPI * PFNWGLCOPYIMAGESUBDATANVPROC) (HGLRC hSrcRC, GLuint srcName, GLenum srcTarget, GLint srcLevel, GLint srcX, GLint srcY, GLint srcZ, HGLRC hDstRC, GLuint dstName, GLenum dstTarget, GLint dstLevel, GLint dstX, GLint dstY, GLint dstZ, GLsizei width, GLsizei height, GLsizei depth); +#endif + +#ifndef WGL_NV_multisample_coverage +#define WGL_NV_multisample_coverage 1 +#endif + +#ifndef WGL_NV_DX_interop +#define WGL_NV_DX_interop 1 +#ifdef WGL_WGLEXT_PROTOTYPES +extern BOOL WINAPI wglDXSetResourceShareHandleNV (void *dxObject, HANDLE shareHandle); +extern HANDLE WINAPI wglDXOpenDeviceNV (void *dxDevice); +extern BOOL WINAPI wglDXCloseDeviceNV (HANDLE hDevice); +extern HANDLE WINAPI wglDXRegisterObjectNV (HANDLE hDevice, void *dxObject, GLuint name, GLenum type, GLenum access); +extern BOOL WINAPI wglDXUnregisterObjectNV (HANDLE hDevice, HANDLE hObject); +extern BOOL WINAPI wglDXObjectAccessNV (HANDLE hObject, GLenum access); +extern BOOL WINAPI wglDXLockObjectsNV (HANDLE hDevice, GLint count, HANDLE *hObjects); +extern BOOL WINAPI wglDXUnlockObjectsNV (HANDLE hDevice, GLint count, HANDLE *hObjects); +#endif /* WGL_WGLEXT_PROTOTYPES */ +typedef BOOL (WINAPI * PFNWGLDXSETRESOURCESHAREHANDLENVPROC) (void *dxObject, HANDLE shareHandle); +typedef HANDLE (WINAPI * PFNWGLDXOPENDEVICENVPROC) (void *dxDevice); +typedef BOOL (WINAPI * PFNWGLDXCLOSEDEVICENVPROC) (HANDLE hDevice); +typedef HANDLE (WINAPI * PFNWGLDXREGISTEROBJECTNVPROC) (HANDLE hDevice, void *dxObject, GLuint name, GLenum type, GLenum access); +typedef BOOL (WINAPI * PFNWGLDXUNREGISTEROBJECTNVPROC) (HANDLE hDevice, HANDLE hObject); +typedef BOOL (WINAPI * PFNWGLDXOBJECTACCESSNVPROC) (HANDLE hObject, GLenum access); +typedef BOOL (WINAPI * PFNWGLDXLOCKOBJECTSNVPROC) (HANDLE hDevice, GLint count, HANDLE *hObjects); +typedef BOOL (WINAPI * PFNWGLDXUNLOCKOBJECTSNVPROC) (HANDLE hDevice, GLint count, HANDLE *hObjects); +#endif + + +#ifdef __cplusplus +} +#endif + +#endif diff --git a/parser.cpp b/parser.cpp new file mode 100644 index 00000000..548d15a6 --- /dev/null +++ b/parser.cpp @@ -0,0 +1,194 @@ + +#define _USE_OLD_RW_STL + +#include "parser.h" +#include "logs.h" + +/* + MaSzyna EU07 locomotive simulator parser + Copyright (C) 2003 TOLARIS + +*/ + + +///////////////////////////////////////////////////////////////////////////////////////////////////// +// cParser -- generic class for parsing text data. + +// constructors +cParser::cParser(std::string Stream,buffertype Type,std::string Path,bool tr) +{ + LoadTraction=tr; + // build comments map + mComments.insert(commentmap::value_type("/*","*/")); + mComments.insert(commentmap::value_type("//","\n")); + //mComments.insert(commentmap::value_type("--","\n")); //Ra: to chyba nie używane + // store to calculate sub-sequent includes from relative path + mPath=Path; + // reset pointers and attach proper type of buffer + switch (Type) + { + case buffer_FILE: + Path.append(Stream); + mStream=new std::ifstream(Path.c_str()); + break; + case buffer_TEXT: + mStream=new std::istringstream(Stream); + break; + default: + mStream=NULL; + } + mIncludeParser=NULL; + // calculate stream size + if (mStream) + { + mSize=mStream->rdbuf()->pubseekoff(0,std::ios_base::end); + mStream->rdbuf()->pubseekoff(0,std::ios_base::beg); + } + else + mSize=0; +} + +// destructor +cParser::~cParser() +{ + if (mIncludeParser) delete mIncludeParser; + if (mStream) delete mStream; + mComments.clear(); +} + +// methods +bool cParser::getTokens(int Count,bool ToLower,const char* Break) +{ +/* + if (LoadTraction==true) + trtest="niemaproblema"; //wczytywać + else + trtest="x"; //nie wczytywać +*/ + int i; + this->str(""); + this->clear(); + for (i=0;istr(string); + else + { + std::string temp=this->str(); + temp.append("\n"); + temp.append(string); + this->str(temp); + } + } + if (ipeek()!=EOF&& strchr( Break, c = mStream->get() ) == NULL) + { + if (ToLower) c=tolower(c); + token+=c; + if (trimComments(token)) // don't glue together words separated with comment + break; + } + } while (token=="" && mStream->peek()!=EOF); // double check to deal with trailing spaces + // launch child parser if include directive found. + // NOTE: parameter collecting uses default set of token separators. + if (token.compare("include")==0) + {//obsługa include + std::string includefile=readToken(ToLower); //nazwa pliku + if (LoadTraction?true:((includefile.find("tr/")==std::string::npos)&&(includefile.find("tra/")==std::string::npos))) + { + //std::string trtest2="niemaproblema"; //nazwa odporna na znalezienie "tr/" + //if (trtest=="x") //jeśli nie wczytywać drutów + //trtest2=includefile; //kopiowanie ścieżki do pliku + std::string parameter=readToken(false); //w parametrach nie zmniejszamy + while (parameter.compare("end")!=0) + { + parameters.push_back(parameter); + parameter=readToken(ToLower); + } + //if (trtest2.find("tr/")!=0) + mIncludeParser=new cParser(includefile,buffer_FILE,mPath,LoadTraction); + if (mIncludeParser->mSize<=0) + ErrorLog("Missed include: "+AnsiString(includefile.c_str())); + } + else + while (token.compare("end")!=0) + token=readToken(ToLower); + token=readToken(ToLower,Break); + } + return token; +} + +bool cParser::trimComments(std::string &String) +{ + for (commentmap::iterator cmIt=mComments.begin();cmIt!=mComments.end();++cmIt) + { + if (String.find((*cmIt).first)!=std::string::npos) + { + readComment((*cmIt).second); + String.resize(String.find((*cmIt).first)); + return true; + } + } + return false; +} + +std::string cParser::readComment(const std::string Break) +{//pobieranie znaków aż do znalezienia znacznika końca + std::string token=""; + while (mStream->peek()!=EOF) + {//o ile nie koniec pliku + token+=mStream->get(); //pobranie znaku + if (token.find(Break)!=std::string::npos) //szukanie znacznika końca + break; + } + return token; +} + +int cParser::getProgress() const +{ + return mStream->rdbuf()->pubseekoff( 0, std::ios_base::cur ) * 100 / mSize; +} + diff --git a/parser.h b/parser.h new file mode 100644 index 00000000..e14573cb --- /dev/null +++ b/parser.h @@ -0,0 +1,55 @@ + +#if !defined(rainKERNELTEXTPARSER_H_INCLUDED) +#define rainKERNELTEXTPARSER_H_INCLUDED + +#pragma warning ( disable : 4786 ) // 'containers too long for debug' warning + +#include +#include +#include +#include +#include +#include + +///////////////////////////////////////////////////////////////////////////////////////////////////// +// cParser -- generic class for parsing text data, either from file or provided string + +class cParser : public std::stringstream +{ +public: + //parameters: + enum buffertype {buffer_FILE,buffer_TEXT}; + //constructors: + cParser(std::string Stream,buffertype Type=buffer_TEXT,std::string Path="",bool tr=true); + //destructor: + virtual ~cParser(); + //methods: + template + inline void getToken(OutputT& output) {getTokens(); *this >> output;}; + inline void ignoreToken() {readToken();}; + inline void ignoreTokens(int count) {for (int i=0;ieof();}; + bool ok() {return !mStream->fail();}; + bool getTokens(int Count=1,bool ToLower=true,const char* Break="\n\t ;"); + int getProgress() const; // percentage of file processed. + //load traction? + bool LoadTraction; +protected: + // methods: + std::string readToken(bool ToLower=true,const char* Break="\n\t ;"); + std::string readComment(const std::string Break="\n\t ;"); + std::string trtest; + bool trimComments(std::string& String); + // members: + std::istream *mStream; // relevant kind of buffer is attached on creation. + std::string mPath; // path to open stream, for relative path lookups. + int mSize; // size of open stream, for progress report. + typedef std::map commentmap; + commentmap mComments; + cParser *mIncludeParser; // child class to handle include directives. + std::vector parameters; // parameter list for included file. +}; + +#endif // ..!defined(rainKERNELTEXTPARSER_H_INCLUDED) + diff --git a/sky.cpp b/sky.cpp new file mode 100644 index 00000000..388f2125 --- /dev/null +++ b/sky.cpp @@ -0,0 +1,65 @@ +//--------------------------------------------------------------------------- + +#include "system.hpp" +#include "classes.hpp" +#pragma hdrstop + +#include "sky.h" +#include "Globals.h" + +//--------------------------------------------------------------------------- +GLfloat lightPos[4] = { 0.0f, 0.0f, 0.0f, 1.0f }; + +__fastcall TSky::~TSky() +{ +}; + +__fastcall TSky::TSky() +{ +}; + + +void __fastcall TSky::Init() +{ + WriteLog(Global::asSky.c_str()); + WriteLog("init"); + AnsiString asModel; + asModel=Global::asSky; + if ((asModel!="1") && (asModel!="0")) +// { + mdCloud=TModelsManager::GetModel(asModel.c_str()); +// } +}; + + +void __fastcall TSky::Render() +{ + if (mdCloud) + {//jeśli jest model nieba + glPushMatrix(); + //glDisable(GL_DEPTH_TEST); + glTranslatef(Global::pCameraPosition.x, Global::pCameraPosition.y, Global::pCameraPosition.z); + glLightfv(GL_LIGHT0,GL_POSITION,lightPos); + if (Global::bUseVBO) + {//renderowanie z VBO + mdCloud->RaRender(100,0); + mdCloud->RaRenderAlpha(100,0); + } + else + {//renderowanie z Display List + mdCloud->Render(100,0); + mdCloud->RenderAlpha(100,0); + } + //glEnable(GL_DEPTH_TEST); + glClear(GL_DEPTH_BUFFER_BIT); + //glEnable(GL_LIGHTING); + glPopMatrix(); + glLightfv(GL_LIGHT0,GL_POSITION,Global::lightPos); + } +}; + + + +//--------------------------------------------------------------------------- + +#pragma package(smart_init) diff --git a/sky.h b/sky.h new file mode 100644 index 00000000..84746e74 --- /dev/null +++ b/sky.h @@ -0,0 +1,20 @@ +//--------------------------------------------------------------------------- + +#ifndef skyH +#define skyH + +#include "MdlMngr.h" + +class TSky +{ +private: + TModel3d *mdCloud; +public: + __fastcall TSky(); + __fastcall ~TSky(); + void __fastcall Init(); + void __fastcall Render(); +}; + +//--------------------------------------------------------------------------- +#endif diff --git a/usefull.h b/usefull.h new file mode 100644 index 00000000..44c9de57 --- /dev/null +++ b/usefull.h @@ -0,0 +1,44 @@ +//--------------------------------------------------------------------------- +#ifndef UsefullH +#define UsefullH + +#include "dumb3d.h" +#include "Logs.h" + +//#define B1(t) (t*t*t) +//#define B2(t) (3*t*t*(1-t)) +//#define B3(t) (3*t*(1-t)*(1-t)) +//#define B4(t) ((1-t)*(1-t)*(1-t)) +//Ra: to jest mocno nieoptymalne: 10+3*4=22 mnożenia, 6 odejmowań, 3*3=9 dodawań +//Ra: po przeliczeniu współczynników mamy: 3*3=9 mnożeń i 3*3=9 dodawań +//#define Interpolate(t,p1,cp1,cp2,p2) (B4(t)*p1+B3(t)*cp1+B2(t)*cp2+B1(t)*p2) + +//Ra: "delete NULL" nic nie zrobi, więc "if (a!=NULL)" jest zbędne +//#define SafeFree(a) if (a!=NULL) free(a) +#define SafeDelete(a) { delete (a); a=NULL; } +#define SafeDeleteArray(a) { delete[] (a); a=NULL; } + +#define sign(x) ((x)<0?-1:((x)>0?1:0)) + +#define DegToRad(a) ((M_PI/180.0)*(a)) //(a) w nawiasie, bo może być dodawaniem +#define RadToDeg(r) ((180.0/M_PI)*(r)) + +#define Fix(a,b,c) {if (ac) a=c;} + +#define asModelsPath AnsiString("models\\") +#define asSceneryPath AnsiString("scenery\\") +//#define asTexturePath AnsiString("textures\\") +//#define asTextureExt AnsiString(".bmp") +#define szSceneryPath "scenery\\" +#define szTexturePath "textures\\" +//#define szDefaultTextureExt ".dds" + + + +//#define DevelopTime //FIXME +//#define EditorMode + +//--------------------------------------------------------------------------- +#endif + + diff --git a/wavread.cpp b/wavread.cpp new file mode 100644 index 00000000..83a491ff --- /dev/null +++ b/wavread.cpp @@ -0,0 +1,299 @@ +//----------------------------------------------------------------------------- +// File: WavRead.cpp +// +// Desc: Wave file support for loading and playing Wave files using DirectSound +// buffers. +// +// Copyright (c) 1999 Microsoft Corp. All rights reserved. +//----------------------------------------------------------------------------- +#include +#include "WavRead.h" + + + + +//----------------------------------------------------------------------------- +// Defines, constants, and global variables +//----------------------------------------------------------------------------- +#define SAFE_DELETE(p) { if(p) { delete (p); (p)=NULL; } } +#define SAFE_RELEASE(p) { if(p) { (p)->Release(); (p)=NULL; } } + + + + +//----------------------------------------------------------------------------- +// Name: ReadMMIO() +// Desc: Support function for reading from a multimedia I/O stream +//----------------------------------------------------------------------------- +HRESULT ReadMMIO( HMMIO hmmioIn, MMCKINFO* pckInRIFF, WAVEFORMATEX** ppwfxInfo ) +{ + MMCKINFO ckIn; // chunk info. for general use. + PCMWAVEFORMAT pcmWaveFormat; // Temp PCM structure to load in. + + *ppwfxInfo = NULL; + + if( ( 0 != mmioDescend( hmmioIn, pckInRIFF, NULL, 0 ) ) ) + return E_FAIL; + + if( (pckInRIFF->ckid != FOURCC_RIFF) || + (pckInRIFF->fccType != mmioFOURCC('W', 'A', 'V', 'E') ) ) + return E_FAIL; + + // Search the input file for for the 'fmt ' chunk. + ckIn.ckid = mmioFOURCC('f', 'm', 't', ' '); + if( 0 != mmioDescend(hmmioIn, &ckIn, pckInRIFF, MMIO_FINDCHUNK) ) + return E_FAIL; + + // Expect the 'fmt' chunk to be at least as large as ; + // if there are extra parameters at the end, we'll ignore them + if( ckIn.cksize < (LONG) sizeof(PCMWAVEFORMAT) ) + return E_FAIL; + + // Read the 'fmt ' chunk into . + if( mmioRead( hmmioIn, (HPSTR) &pcmWaveFormat, + sizeof(pcmWaveFormat)) != sizeof(pcmWaveFormat) ) + return E_FAIL; + + // Allocate the waveformatex, but if its not pcm format, read the next + // word, and thats how many extra bytes to allocate. + if( pcmWaveFormat.wf.wFormatTag == WAVE_FORMAT_PCM ) + { + if( NULL == ( *ppwfxInfo = new WAVEFORMATEX ) ) + return E_FAIL; + + // Copy the bytes from the pcm structure to the waveformatex structure + memcpy( *ppwfxInfo, &pcmWaveFormat, sizeof(pcmWaveFormat) ); + (*ppwfxInfo)->cbSize = 0; + } + else + { + // Read in length of extra bytes. + WORD cbExtraBytes = 0L; + if( mmioRead( hmmioIn, (CHAR*)&cbExtraBytes, sizeof(WORD)) != sizeof(WORD) ) + return E_FAIL; + + *ppwfxInfo = (WAVEFORMATEX*)new CHAR[ sizeof(WAVEFORMATEX) + cbExtraBytes ]; + if( NULL == *ppwfxInfo ) + return E_FAIL; + + // Copy the bytes from the pcm structure to the waveformatex structure + memcpy( *ppwfxInfo, &pcmWaveFormat, sizeof(pcmWaveFormat) ); + (*ppwfxInfo)->cbSize = cbExtraBytes; + + // Now, read those extra bytes into the structure, if cbExtraAlloc != 0. + if( mmioRead( hmmioIn, (CHAR*)(((BYTE*)&((*ppwfxInfo)->cbSize))+sizeof(WORD)), + cbExtraBytes ) != cbExtraBytes ) + { + delete *ppwfxInfo; + *ppwfxInfo = NULL; + return E_FAIL; + } + } + + // Ascend the input file out of the 'fmt ' chunk. + if( 0 != mmioAscend( hmmioIn, &ckIn, 0 ) ) + { + delete *ppwfxInfo; + *ppwfxInfo = NULL; + return E_FAIL; + } + + return S_OK; +} + + + + +//----------------------------------------------------------------------------- +// Name: WaveOpenFile() +// Desc: This function will open a wave input file and prepare it for reading, +// so the data can be easily read with WaveReadFile. Returns 0 if +// successful, the error code if not. +//----------------------------------------------------------------------------- +HRESULT WaveOpenFile( CHAR* strFileName, HMMIO* phmmioIn, WAVEFORMATEX** ppwfxInfo, + MMCKINFO* pckInRIFF ) +{ + HRESULT hr; + HMMIO hmmioIn = NULL; + + if( NULL == ( hmmioIn = mmioOpen( strFileName, NULL, MMIO_ALLOCBUF|MMIO_READ ) ) ) + return E_FAIL; + + if( FAILED( hr = ReadMMIO( hmmioIn, pckInRIFF, ppwfxInfo ) ) ) + { + mmioClose( hmmioIn, 0 ); + return hr; + } + + *phmmioIn = hmmioIn; + + return S_OK; +} + + + + +//----------------------------------------------------------------------------- +// Name: WaveStartDataRead() +// Desc: Routine has to be called before WaveReadFile as it searches for the +// chunk to descend into for reading, that is, the 'data' chunk. For +// simplicity, this used to be in the open routine, but was taken out and +// moved to a separate routine so there was more control on the chunks +// that are before the data chunk, such as 'fact', etc... +//----------------------------------------------------------------------------- +HRESULT WaveStartDataRead( HMMIO* phmmioIn, MMCKINFO* pckIn, + MMCKINFO* pckInRIFF ) +{ + // Seek to the data + if( -1 == mmioSeek( *phmmioIn, pckInRIFF->dwDataOffset + sizeof(FOURCC), + SEEK_SET ) ) + return E_FAIL; + + // Search the input file for for the 'data' chunk. + pckIn->ckid = mmioFOURCC('d', 'a', 't', 'a'); + if( 0 != mmioDescend( *phmmioIn, pckIn, pckInRIFF, MMIO_FINDCHUNK ) ) + return E_FAIL; + + return S_OK; +} + + + + +//----------------------------------------------------------------------------- +// Name: WaveReadFile() +// Desc: Reads wave data from the wave file. Make sure we're descended into +// the data chunk before calling this function. +// hmmioIn - Handle to mmio. +// cbRead - # of bytes to read. +// pbDest - Destination buffer to put bytes. +// cbActualRead - # of bytes actually read. +//----------------------------------------------------------------------------- +HRESULT WaveReadFile( HMMIO hmmioIn, UINT cbRead, BYTE* pbDest, + MMCKINFO* pckIn, UINT* cbActualRead ) +{ + MMIOINFO mmioinfoIn; // current status of + + *cbActualRead = 0; + + if( 0 != mmioGetInfo( hmmioIn, &mmioinfoIn, 0 ) ) + return E_FAIL; + + UINT cbDataIn = cbRead; + if( cbDataIn > pckIn->cksize ) + cbDataIn = pckIn->cksize; + + pckIn->cksize -= cbDataIn; + + for( DWORD cT = 0; cT < cbDataIn; cT++ ) + { + // Copy the bytes from the io to the buffer. + if( mmioinfoIn.pchNext == mmioinfoIn.pchEndRead ) + { + if( 0 != mmioAdvance( hmmioIn, &mmioinfoIn, MMIO_READ ) ) + return E_FAIL; + + if( mmioinfoIn.pchNext == mmioinfoIn.pchEndRead ) + return E_FAIL; + } + + // Actual copy. + *((BYTE*)pbDest+cT) = *((BYTE*)mmioinfoIn.pchNext); + mmioinfoIn.pchNext++; + } + + if( 0 != mmioSetInfo( hmmioIn, &mmioinfoIn, 0 ) ) + return E_FAIL; + + *cbActualRead = cbDataIn; + return S_OK; +} + + + + +//----------------------------------------------------------------------------- +// Name: CWaveSoundRead() +// Desc: Constructs the class +//----------------------------------------------------------------------------- +CWaveSoundRead::CWaveSoundRead() +{ + m_pwfx = NULL; +} + + + + +//----------------------------------------------------------------------------- +// Name: ~CWaveSoundRead() +// Desc: Destructs the class +//----------------------------------------------------------------------------- +CWaveSoundRead::~CWaveSoundRead() +{ + Close(); + SAFE_DELETE( m_pwfx ); +} + + + + +//----------------------------------------------------------------------------- +// Name: Open() +// Desc: Opens a wave file for reading +//----------------------------------------------------------------------------- +HRESULT CWaveSoundRead::Open( CHAR* strFilename ) +{ + SAFE_DELETE( m_pwfx ); + + HRESULT hr; + + if( FAILED( hr = WaveOpenFile( strFilename, &m_hmmioIn, &m_pwfx, &m_ckInRiff ) ) ) + return hr; + + if( FAILED( hr = Reset() ) ) + return hr; + + return hr; +} + + + + +//----------------------------------------------------------------------------- +// Name: Reset() +// Desc: Resets the internal m_ckIn pointer so reading starts from the +// beginning of the file again +//----------------------------------------------------------------------------- +HRESULT CWaveSoundRead::Reset() +{ + return WaveStartDataRead( &m_hmmioIn, &m_ckIn, &m_ckInRiff ); +} + + + + +//----------------------------------------------------------------------------- +// Name: Read() +// Desc: Reads a wave file into a pointer and returns how much read +// using m_ckIn to determine where to start reading from +//----------------------------------------------------------------------------- +HRESULT CWaveSoundRead::Read( UINT nSizeToRead, BYTE* pbData, UINT* pnSizeRead ) +{ + return WaveReadFile( m_hmmioIn, nSizeToRead, pbData, &m_ckIn, pnSizeRead ); +} + + + + +//----------------------------------------------------------------------------- +// Name: Close() +// Desc: Closes an open wave file +//----------------------------------------------------------------------------- +HRESULT CWaveSoundRead::Close() +{ + mmioClose( m_hmmioIn, 0 ); + return S_OK; +} + + + diff --git a/wavread.h b/wavread.h new file mode 100644 index 00000000..7f7fe460 --- /dev/null +++ b/wavread.h @@ -0,0 +1,51 @@ +//----------------------------------------------------------------------------- +// File: WavRead.h +// +// Desc: Support for loading and playing Wave files using DirectSound sound +// buffers. +// +// Copyright (c) 1999 Microsoft Corp. All rights reserved. +//----------------------------------------------------------------------------- +#ifndef WAVE_READ_H +#define WAVE_READ_H + + +#include +#include + + +HRESULT WaveOpenFile( CHAR* strFileName, HMMIO* phmmioIn, WAVEFORMATEX** ppwfxInfo, + MMCKINFO* pckInRIFF ); +HRESULT WaveStartDataRead( HMMIO* phmmioIn, MMCKINFO* pckIn, + MMCKINFO* pckInRIFF ); +HRESULT WaveReadFile( HMMIO hmmioIn, UINT cbRead, BYTE* pbDest, + MMCKINFO* pckIn, UINT* cbActualRead ); + +//----------------------------------------------------------------------------- +// Name: class CWaveSoundRead +// Desc: A class to read in sound data from a Wave file +//----------------------------------------------------------------------------- +class CWaveSoundRead +{ +public: + WAVEFORMATEX* m_pwfx; // Pointer to WAVEFORMATEX structure + HMMIO m_hmmioIn; // MM I/O handle for the WAVE + MMCKINFO m_ckIn; // Multimedia RIFF chunk + MMCKINFO m_ckInRiff; // Use in opening a WAVE file + +public: + CWaveSoundRead(); + ~CWaveSoundRead(); + + HRESULT Open( CHAR* strFilename ); + HRESULT Reset(); + HRESULT Read( UINT nSizeToRead, BYTE* pbData, UINT* pnSizeRead ); + HRESULT Close(); + +}; + + +#endif WAVE_READ_H + + +