From 00291b5cf4a0f16ddca425b74ed30e8ac35d40e2 Mon Sep 17 00:00:00 2001 From: Nathan Letwory Date: Mon, 22 Mar 2004 22:02:18 +0000 Subject: [GameEngine] Commit all Kester's changes made to the gameengine to restore 2.25 like physics. [SCons] Build with Solid as default when enabling the gameengine in the build process [SCons] Build solid and qhull from the extern directory and link statically against them That was about it. There are a few things that needs double checking: * Makefiles * Projectfiles * All the other systems than Linux and Windows on which the build (with scons) has been successfully tested. --- source/gameengine/Rasterizer/RAS_BucketManager.cpp | 97 +- source/gameengine/Rasterizer/RAS_BucketManager.h | 7 +- .../gameengine/Rasterizer/RAS_IPolygonMaterial.cpp | 4 +- .../gameengine/Rasterizer/RAS_IPolygonMaterial.h | 14 +- source/gameengine/Rasterizer/RAS_IRasterizer.h | 6 + source/gameengine/Rasterizer/RAS_IRenderTools.h | 4 +- .../gameengine/Rasterizer/RAS_MaterialBucket.cpp | 4 + source/gameengine/Rasterizer/RAS_MaterialBucket.h | 2 +- source/gameengine/Rasterizer/RAS_MeshObject.cpp | 29 +- source/gameengine/Rasterizer/RAS_MeshObject.h | 18 +- .../RAS_OpenGLRasterizer/RAS_CheckVertexArrays.cpp | 69 - .../RAS_OpenGLRasterizer/RAS_CheckVertexArrays.h | 38 - .../RAS_GLExtensionManager.cpp | 4373 ++++++++++++++++++++ .../RAS_OpenGLRasterizer/RAS_GLExtensionManager.h | 1718 ++++++++ .../RAS_OpenGLRasterizer/RAS_OpenGLRasterizer.cpp | 132 +- .../RAS_OpenGLRasterizer/RAS_OpenGLRasterizer.h | 3 +- .../RAS_VAOpenGLRasterizer.cpp | 84 +- .../Rasterizer/RAS_OpenGLRasterizer/SConscript | 2 +- .../Rasterizer/RAS_OpenGLRasterizer/mkglext.py | 538 +++ source/gameengine/Rasterizer/RAS_TexVert.cpp | 23 +- source/gameengine/Rasterizer/RAS_TexVert.h | 47 +- 21 files changed, 6889 insertions(+), 323 deletions(-) delete mode 100644 source/gameengine/Rasterizer/RAS_OpenGLRasterizer/RAS_CheckVertexArrays.cpp delete mode 100644 source/gameengine/Rasterizer/RAS_OpenGLRasterizer/RAS_CheckVertexArrays.h create mode 100644 source/gameengine/Rasterizer/RAS_OpenGLRasterizer/RAS_GLExtensionManager.cpp create mode 100644 source/gameengine/Rasterizer/RAS_OpenGLRasterizer/RAS_GLExtensionManager.h create mode 100644 source/gameengine/Rasterizer/RAS_OpenGLRasterizer/mkglext.py (limited to 'source/gameengine/Rasterizer') diff --git a/source/gameengine/Rasterizer/RAS_BucketManager.cpp b/source/gameengine/Rasterizer/RAS_BucketManager.cpp index 38eee62b954..9b8f455d518 100644 --- a/source/gameengine/Rasterizer/RAS_BucketManager.cpp +++ b/source/gameengine/Rasterizer/RAS_BucketManager.cpp @@ -49,6 +49,7 @@ #include "RAS_BucketManager.h" + RAS_BucketManager::RAS_BucketManager() { @@ -63,11 +64,7 @@ RAS_BucketManager::~RAS_BucketManager() void RAS_BucketManager::Renderbuckets( const MT_Transform& cameratrans, RAS_IRasterizer* rasty, RAS_IRenderTools* rendertools) { - int numbuckets = m_MaterialBuckets.size(); - - //default_gl_light(); - - int i; + std::vector::iterator bucket; rasty->EnableTextures(false); rasty->SetDepthMask(RAS_IRasterizer::KX_DEPTHMASK_ENABLED); @@ -76,84 +73,66 @@ void RAS_BucketManager::Renderbuckets( rasty->ClearCachingInfo(); RAS_MaterialBucket::StartFrame(); - - for (i=0;iClearScheduledPolygons(); - } + (*bucket)->ClearScheduledPolygons(); } - - vector alphabuckets; - - // if no visibility method is define, everything is drawn - - for (i=0;iIsTransparant()) - { - (*bucketptr)->Render(cameratrans,rasty,rendertools); - } else - { - alphabuckets.push_back(*bucketptr); - } - } + (*bucket)->ClearScheduledPolygons(); } + + for (bucket = m_MaterialBuckets.begin(); bucket != m_MaterialBuckets.end(); bucket++) + (*bucket)->Render(cameratrans,rasty,rendertools); rasty->SetDepthMask(RAS_IRasterizer::KX_DEPTHMASK_DISABLED); - int numalphabuckets = alphabuckets.size(); - for (vector::const_iterator it=alphabuckets.begin(); - !(it==alphabuckets.end());it++) + for (bucket = m_AlphaBuckets.begin(); bucket != m_AlphaBuckets.end(); bucket++) { - (*it)->Render(cameratrans,rasty,rendertools); + (*bucket)->Render(cameratrans,rasty,rendertools); } - alphabuckets.clear(); - - - RAS_MaterialBucket::EndFrame(); - rasty->SetDepthMask(RAS_IRasterizer::KX_DEPTHMASK_ENABLED); + + RAS_MaterialBucket::EndFrame(); } RAS_MaterialBucket* RAS_BucketManager::RAS_BucketManagerFindBucket(RAS_IPolyMaterial * material) { - - RAS_MaterialBucket** bucketptr = m_MaterialBuckets[*material]; - RAS_MaterialBucket* bucket=NULL; - if (!bucketptr) + std::vector::iterator it; + for (it = m_MaterialBuckets.begin(); it != m_MaterialBuckets.end(); it++) { - bucket = new RAS_MaterialBucket(material); - m_MaterialBuckets.insert(*material,bucket); - - } else + if (*(*it)->GetPolyMaterial() == *material) + return *it; + } + + for (it = m_AlphaBuckets.begin(); it != m_AlphaBuckets.end(); it++) { - bucket = *bucketptr; + if (*(*it)->GetPolyMaterial() == *material) + return *it; } - + + RAS_MaterialBucket *bucket = new RAS_MaterialBucket(material); + if (bucket->IsTransparant()) + m_AlphaBuckets.push_back(bucket); + else + m_MaterialBuckets.push_back(bucket); + return bucket; } void RAS_BucketManager::RAS_BucketManagerClearAll() { - - int numbuckets = m_MaterialBuckets.size(); - for (int i=0;i::iterator it; + for (it = m_MaterialBuckets.begin(); it != m_MaterialBuckets.end(); it++) { - RAS_MaterialBucket** bucketptr = m_MaterialBuckets.at(i); - if (bucketptr) - { - delete (*bucketptr); - *bucketptr=NULL; - - } + delete (*it); + } + for (it = m_AlphaBuckets.begin(); it != m_AlphaBuckets.end(); it++) + { + delete(*it); } - m_MaterialBuckets.clear(); + m_MaterialBuckets.clear(); + m_AlphaBuckets.clear(); } diff --git a/source/gameengine/Rasterizer/RAS_BucketManager.h b/source/gameengine/Rasterizer/RAS_BucketManager.h index 72427473fc1..834ae574bbc 100644 --- a/source/gameengine/Rasterizer/RAS_BucketManager.h +++ b/source/gameengine/Rasterizer/RAS_BucketManager.h @@ -38,10 +38,13 @@ #include "RAS_MaterialBucket.h" #include "GEN_Map.h" +#include + class RAS_BucketManager { - - GEN_Map m_MaterialBuckets; + //GEN_Map m_MaterialBuckets; + std::vector m_MaterialBuckets; + std::vector m_AlphaBuckets; public: RAS_BucketManager(); diff --git a/source/gameengine/Rasterizer/RAS_IPolygonMaterial.cpp b/source/gameengine/Rasterizer/RAS_IPolygonMaterial.cpp index 1a11a0400f4..88fb5349764 100644 --- a/source/gameengine/Rasterizer/RAS_IPolygonMaterial.cpp +++ b/source/gameengine/Rasterizer/RAS_IPolygonMaterial.cpp @@ -67,7 +67,6 @@ RAS_IPolyMaterial::RAS_IPolyMaterial(const STR_String& texname, bool RAS_IPolyMaterial::Equals(const RAS_IPolyMaterial& lhs) const { return ( - this->m_texturename == lhs.m_texturename && this->m_tile == lhs.m_tile && this->m_tilexrep == lhs.m_tilexrep && this->m_tileyrep == lhs.m_tileyrep && @@ -75,7 +74,8 @@ bool RAS_IPolyMaterial::Equals(const RAS_IPolyMaterial& lhs) const this->m_drawingmode == lhs.m_drawingmode && this->m_bIsTriangle == lhs.m_bIsTriangle && this->m_lightlayer == lhs.m_lightlayer && - this->m_materialname == lhs.m_materialname + this->m_texturename.hash() == lhs.m_texturename.hash() && + this->m_materialname.hash() == lhs.m_materialname.hash() ); } diff --git a/source/gameengine/Rasterizer/RAS_IPolygonMaterial.h b/source/gameengine/Rasterizer/RAS_IPolygonMaterial.h index 57d2ad9bc9a..01c3e80c055 100644 --- a/source/gameengine/Rasterizer/RAS_IPolygonMaterial.h +++ b/source/gameengine/Rasterizer/RAS_IPolygonMaterial.h @@ -47,13 +47,13 @@ class RAS_IPolyMaterial { //todo: remove these variables from this interface/protocol class protected: - STR_HashedString m_texturename; - STR_String m_materialname; //also needed for touchsensor - int m_tile; - int m_tilexrep,m_tileyrep; - int m_drawingmode; // tface->mode - int m_transparant; - int m_lightlayer; + STR_HashedString m_texturename; + STR_HashedString m_materialname; //also needed for touchsensor + int m_tile; + int m_tilexrep,m_tileyrep; + int m_drawingmode; // tface->mode + int m_transparant; + int m_lightlayer; bool m_bIsTriangle; public: diff --git a/source/gameengine/Rasterizer/RAS_IRasterizer.h b/source/gameengine/Rasterizer/RAS_IRasterizer.h index 2adfe596f01..144342e86cf 100644 --- a/source/gameengine/Rasterizer/RAS_IRasterizer.h +++ b/source/gameengine/Rasterizer/RAS_IRasterizer.h @@ -70,6 +70,11 @@ public: KX_DEPTHMASK_DISABLED }; + enum { + KX_TWOSIDE = 512, + KX_LINES = 32768 + }; + enum { RAS_STEREO_NOSTEREO = 1, RAS_STEREO_QUADBUFFERED, @@ -162,6 +167,7 @@ public: virtual void EnableTextures(bool enable)=0; virtual void SetCullFace(bool enable)=0; + virtual void SetLines(bool enable)=0; virtual double GetTime()=0; diff --git a/source/gameengine/Rasterizer/RAS_IRenderTools.h b/source/gameengine/Rasterizer/RAS_IRenderTools.h index 629d16e79d8..91b8fab5d18 100644 --- a/source/gameengine/Rasterizer/RAS_IRenderTools.h +++ b/source/gameengine/Rasterizer/RAS_IRenderTools.h @@ -64,8 +64,8 @@ public: RAS_IRenderTools( ) : - m_modified(true), - m_clientobject(NULL) + m_clientobject(NULL), + m_modified(true) { }; diff --git a/source/gameengine/Rasterizer/RAS_MaterialBucket.cpp b/source/gameengine/Rasterizer/RAS_MaterialBucket.cpp index d9e27c9c8d0..39de3a400aa 100644 --- a/source/gameengine/Rasterizer/RAS_MaterialBucket.cpp +++ b/source/gameengine/Rasterizer/RAS_MaterialBucket.cpp @@ -173,6 +173,8 @@ void RAS_MaterialBucket::Render(const MT_Transform& cameratrans, rendertools->SetClientObject((*m_meshSlots.begin()).m_clientObj); } + + //printf("RAS_MatBucket::Render: %d m_meshSlots\n", m_meshSlots.size()); bool dolights = m_material->GetDrawingMode()&16; @@ -191,6 +193,7 @@ void RAS_MaterialBucket::Render(const MT_Transform& cameratrans, for (T_MeshSlotList::const_iterator it = m_meshSlots.begin(); ! (it == m_meshSlots.end());it++) { + //printf("RAS_MatBucket::Render: (%p) %s MeshSlot %s\n", this, it->m_mesh->m_class?"Skin":"Mesh", (const char *)(*it).m_mesh->GetName()); if ((*it).m_bVisible) { rendertools->SetClientObject((*it).m_clientObj); @@ -245,6 +248,7 @@ void RAS_MaterialBucket::Render(const MT_Transform& cameratrans, rendertools->PopMatrix(); } + //printf("gets here\n"); } } diff --git a/source/gameengine/Rasterizer/RAS_MaterialBucket.h b/source/gameengine/Rasterizer/RAS_MaterialBucket.h index 6e5307ca5ed..e43273e9dcc 100644 --- a/source/gameengine/Rasterizer/RAS_MaterialBucket.h +++ b/source/gameengine/Rasterizer/RAS_MaterialBucket.h @@ -74,7 +74,7 @@ public: mutable bool m_bObjectColor; mutable MT_Vector4 m_RGBAcolor; - KX_MeshSlot() :m_bVisible(true), m_pDeformer(NULL) {} + KX_MeshSlot() :m_pDeformer(NULL), m_bVisible(true) {} // KX_MeshSlot() :m_bVisible(true) {} bool Less(const KX_MeshSlot& lhs) const; diff --git a/source/gameengine/Rasterizer/RAS_MeshObject.cpp b/source/gameengine/Rasterizer/RAS_MeshObject.cpp index 2a7323d845a..ce86d52d2bb 100644 --- a/source/gameengine/Rasterizer/RAS_MeshObject.cpp +++ b/source/gameengine/Rasterizer/RAS_MeshObject.cpp @@ -68,7 +68,8 @@ KX_ArrayOptimizer::~KX_ArrayOptimizer() RAS_MeshObject::RAS_MeshObject(int lightlayer) : m_bModified(true), - m_lightlayer(lightlayer) + m_lightlayer(lightlayer), + m_class(0) { } @@ -86,7 +87,7 @@ RAS_MeshObject::~RAS_MeshObject() -int RAS_MeshObject::GetLightLayer() +unsigned int RAS_MeshObject::GetLightLayer() { return m_lightlayer; } @@ -100,13 +101,13 @@ int RAS_MeshObject::NumMaterials() -const STR_String& RAS_MeshObject::GetMaterialName(int matid) +const STR_String& RAS_MeshObject::GetMaterialName(unsigned int matid) { if (m_materials.size() > 0 && (matid < m_materials.size())) { BucketMaterialSet::iterator it = m_materials.begin(); - for (int i = 1; i < m_materials.size(); i++) + for (unsigned int i = 1; i < m_materials.size(); i++) { it++; } @@ -118,7 +119,7 @@ const STR_String& RAS_MeshObject::GetMaterialName(int matid) -RAS_MaterialBucket* RAS_MeshObject::GetMaterialBucket(int matid) +RAS_MaterialBucket* RAS_MeshObject::GetMaterialBucket(unsigned int matid) { RAS_MaterialBucket* bucket = NULL; @@ -181,12 +182,12 @@ const STR_String& RAS_MeshObject::GetName() -const STR_String& RAS_MeshObject::GetTextureName(int matid) +const STR_String& RAS_MeshObject::GetTextureName(unsigned int matid) { if (m_materials.size() > 0 && (matid < m_materials.size())) { BucketMaterialSet::iterator it = m_materials.begin(); - for (int i = 1; i < m_materials.size(); i++) + for (unsigned int i = 1; i < m_materials.size(); i++) { it++; } @@ -321,7 +322,7 @@ int RAS_MeshObject::FindOrAddVertex(int vtxarray, idx.m_array = vtxarray; idx.m_index = numverts; idx.m_matid = (int) mat; - m_xyz_index_to_vertex_index_mapping[orgindex].push_back(idx); + m_xyz_index_to_vertex_index_mapping[orgindex].push_back(idx); return numverts; } @@ -354,8 +355,8 @@ int RAS_MeshObject::GetVertexArrayLength(RAS_IPolyMaterial* mat) -RAS_TexVert* RAS_MeshObject::GetVertex(int matid, - int index) +RAS_TexVert* RAS_MeshObject::GetVertex(unsigned int matid, + unsigned int index) { RAS_TexVert* vertex = NULL; @@ -368,7 +369,7 @@ RAS_TexVert* RAS_MeshObject::GetVertex(int matid, const vecVertexArray & vertexvec = GetVertexCache(mat); vector::const_iterator it = vertexvec.begin(); - for (int len = 0; it != vertexvec.end(); it++) + for (unsigned int len = 0; it != vertexvec.end(); it++) { if (index < len + (*it)->size()) { @@ -521,7 +522,7 @@ int RAS_MeshObject::FindVertexArray(int numverts, KX_ArrayOptimizer* ao = GetArrayOptimizer(polymat); - for (int i=0;im_VertexArrayCache1.size();i++) + for (unsigned int i=0;im_VertexArrayCache1.size();i++) { if ( (ao->m_TriangleArrayCount[i] + (numverts-2)) < BUCKET_MAX_TRIANGLES) { @@ -532,10 +533,6 @@ int RAS_MeshObject::FindVertexArray(int numverts, break; } } - else - { - int i=0; - } } if (array == -1) diff --git a/source/gameengine/Rasterizer/RAS_MeshObject.h b/source/gameengine/Rasterizer/RAS_MeshObject.h index 3aeed836ba0..e26715ef210 100644 --- a/source/gameengine/Rasterizer/RAS_MeshObject.h +++ b/source/gameengine/Rasterizer/RAS_MeshObject.h @@ -66,7 +66,9 @@ public: struct RAS_TriangleIndex { public: - int m_index[3]; + int m_index[3]; + int m_array; + RAS_IPolyMaterial* m_matid; bool m_collider; }; @@ -131,12 +133,14 @@ public: vector m_sortedMaterials; vector > m_xyz_index_to_vertex_index_mapping; vector m_triangle_indices; + + int m_class; - int GetLightLayer(); + unsigned int GetLightLayer(); int NumMaterials(); - const STR_String& GetMaterialName(int matid); - RAS_MaterialBucket* GetMaterialBucket(int matid); - const STR_String& GetTextureName(int matid); + const STR_String& GetMaterialName(unsigned int matid); + RAS_MaterialBucket* GetMaterialBucket(unsigned int matid); + const STR_String& GetTextureName(unsigned int matid); virtual void AddPolygon(RAS_Polygon* poly); void UpdateMaterialList(); @@ -217,8 +221,8 @@ public: int GetVertexArrayLength(RAS_IPolyMaterial* mat); RAS_TexVert* GetVertex( - int matid, - int index + unsigned int matid, + unsigned int index ); const vecIndexArrays& GetIndexCache (RAS_IPolyMaterial* mat); diff --git a/source/gameengine/Rasterizer/RAS_OpenGLRasterizer/RAS_CheckVertexArrays.cpp b/source/gameengine/Rasterizer/RAS_OpenGLRasterizer/RAS_CheckVertexArrays.cpp deleted file mode 100644 index f3c5b851112..00000000000 --- a/source/gameengine/Rasterizer/RAS_OpenGLRasterizer/RAS_CheckVertexArrays.cpp +++ /dev/null @@ -1,69 +0,0 @@ -/** - * $Id$ - * - * ***** BEGIN GPL/BL DUAL LICENSE BLOCK ***** - * - * This program is free software; you can redistribute it and/or - * modify it under the terms of the GNU General Public License - * as published by the Free Software Foundation; either version 2 - * of the License, or (at your option) any later version. The Blender - * Foundation also sells licenses for use in proprietary software under - * the Blender License. See http://www.blender.org/BL/ for information - * about this. - * - * This program is distributed in the hope that it will be useful, - * but WITHOUT ANY WARRANTY; without even the implied warranty of - * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the - * GNU General Public License for more details. - * - * You should have received a copy of the GNU General Public License - * along with this program; if not, write to the Free Software Foundation, - * Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. - * - * The Original Code is Copyright (C) 2001-2002 by NaN Holding BV. - * All rights reserved. - * - * The Original Code is: all of this file. - * - * Contributor(s): none yet. - * - * ***** END GPL/BL DUAL LICENSE BLOCK ***** - */ -#include "RAS_CheckVertexArrays.h" - -#ifdef HAVE_CONFIG_H -#include -#endif - -#ifdef WIN32 -#include -#endif // WIN32 -#ifdef __APPLE__ -#include -#else -#include -#endif - -#include "STR_String.h" - - -bool RAS_SystemSupportsVertexArrays() { - - bool result = false; - - char* ext = (char*) glGetString(GL_EXTENSIONS); - STR_String extensions; - - if (ext) - extensions = STR_String(ext); - -#ifdef WIN32 - if (extensions.Find("GL_EXT_compiled_vertex_array") >= 0) - { - result=true; - } -#endif //WIN32 - - return result; - -} diff --git a/source/gameengine/Rasterizer/RAS_OpenGLRasterizer/RAS_CheckVertexArrays.h b/source/gameengine/Rasterizer/RAS_OpenGLRasterizer/RAS_CheckVertexArrays.h deleted file mode 100644 index b87abb9c3dd..00000000000 --- a/source/gameengine/Rasterizer/RAS_OpenGLRasterizer/RAS_CheckVertexArrays.h +++ /dev/null @@ -1,38 +0,0 @@ -/** - * $Id$ - * - * ***** BEGIN GPL/BL DUAL LICENSE BLOCK ***** - * - * This program is free software; you can redistribute it and/or - * modify it under the terms of the GNU General Public License - * as published by the Free Software Foundation; either version 2 - * of the License, or (at your option) any later version. The Blender - * Foundation also sells licenses for use in proprietary software under - * the Blender License. See http://www.blender.org/BL/ for information - * about this. - * - * This program is distributed in the hope that it will be useful, - * but WITHOUT ANY WARRANTY; without even the implied warranty of - * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the - * GNU General Public License for more details. - * - * You should have received a copy of the GNU General Public License - * along with this program; if not, write to the Free Software Foundation, - * Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. - * - * The Original Code is Copyright (C) 2001-2002 by NaN Holding BV. - * All rights reserved. - * - * The Original Code is: all of this file. - * - * Contributor(s): none yet. - * - * ***** END GPL/BL DUAL LICENSE BLOCK ***** - */ -#ifndef __RAS_CHECKVERTEXARRAYS -#define __RAS_CHECKVERTEXARRAYS - -bool RAS_SystemSupportsVertexArrays(); - -#endif //__RAS_CHECKVERTEXARRAYS - diff --git a/source/gameengine/Rasterizer/RAS_OpenGLRasterizer/RAS_GLExtensionManager.cpp b/source/gameengine/Rasterizer/RAS_OpenGLRasterizer/RAS_GLExtensionManager.cpp new file mode 100644 index 00000000000..1ae8b25eb4d --- /dev/null +++ b/source/gameengine/Rasterizer/RAS_OpenGLRasterizer/RAS_GLExtensionManager.cpp @@ -0,0 +1,4373 @@ +/** + * $Id$ + * ***** BEGIN GPL/BL DUAL LICENSE BLOCK ***** + * + * This program is free software; you can redistribute it and/or + * modify it under the terms of the GNU General Public License + * as published by the Free Software Foundation; either version 2 + * of the License, or (at your option) any later version. The Blender + * Foundation also sells licenses for use in proprietary software under + * the Blender License. See http://www.blender.org/BL/ for information + * about this. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software Foundation, + * Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. + * + * The Original Code is Copyright (C) 2001-2002 by NaN Holding BV. + * All rights reserved. + * + * The Original Code is: all of this file. + * + * Contributor(s): none yet. + * + * ***** END GPL/BL DUAL LICENSE BLOCK ***** + */ +/* + The extension manager's job is to link at runtime OpenGL extension + functions. + + Since the various platform have different methods of finding a fn + pointer, this file attempts to encapsulate all that, so it gets a + little messy. Hopefully we can +*/ +#ifdef HAVE_CONFIG_H +#include +#endif + +#ifdef WIN32 +# include + +# include + +#elif defined(__APPLE__) +# include + +# include + +#else /* UNIX */ +# include +# include + +# include +#endif + +#include +#include +#include + +#include "STR_String.h" + +#include "RAS_GLExtensionManager.h" + +/* ----------------------------------------------------------------------------- + + Platform specific functions section. + + Required Functions: + static void bglInitEntryPoints (void) -- Loads the GL library + static void bglDeallocEntryPoints (void) -- Frees the GL library + static void *bglGetProcAddress(const GLubyte* entry) -- Finds the address of + the GL function entry + +*/ +#ifdef __APPLE__ +/* http://developer.apple.com/qa/qa2001/qa1188.html */ +CFBundleRef gBundleRefOpenGL = NULL; + +// ------------------------- + +static OSStatus bglInitEntryPoints (void) +{ + OSStatus err = noErr; + const Str255 frameworkName = "\pOpenGL.framework"; + FSRefParam fileRefParam; + FSRef fileRef; + CFURLRef bundleURLOpenGL; + + memset(&fileRefParam, 0, sizeof(fileRefParam)); + memset(&fileRef, 0, sizeof(fileRef)); + + fileRefParam.ioNamePtr = frameworkName; + fileRefParam.newRef = &fileRef; + + // Frameworks directory/folder + err = FindFolder (kSystemDomain, kFrameworksFolderType, false, + &fileRefParam.ioVRefNum, &fileRefParam.ioDirID); + if (noErr != err) { + DebugStr ("\pCould not find frameworks folder"); + return err; + } + err = PBMakeFSRefSync (&fileRefParam); // make FSRef for folder + if (noErr != err) { + DebugStr ("\pCould make FSref to frameworks folder"); + return err; + } + // create URL to folder + bundleURLOpenGL = CFURLCreateFromFSRef (kCFAllocatorDefault, + &fileRef); + if (!bundleURLOpenGL) { + DebugStr ("\pCould create OpenGL Framework bundle URL"); + return paramErr; + } + // create ref to GL's bundle + gBundleRefOpenGL = CFBundleCreate (kCFAllocatorDefault, + bundleURLOpenGL); + if (!gBundleRefOpenGL) { + DebugStr ("\pCould not create OpenGL Framework bundle"); + return paramErr; + } + CFRelease (bundleURLOpenGL); // release created bundle + // if the code was successfully loaded, look for our function. + if (!CFBundleLoadExecutable (gBundleRefOpenGL)) { + DebugStr ("\pCould not load MachO executable"); + return paramErr; + } + return err; +} + +// ------------------------- + +static void bglDeallocEntryPoints (void) +{ + if (gBundleRefOpenGL != NULL) { + // unload the bundle's code. + CFBundleUnloadExecutable (gBundleRefOpenGL); + CFRelease (gBundleRefOpenGL); + gBundleRefOpenGL = NULL; + } +} + +// ------------------------- + +static void * bglGetProcAddress (const GLubyte * pszProc) +{ + if (!gBundleRefOpenGL) + return NULL; + + return CFBundleGetFunctionPointerForName (gBundleRefOpenGL, + CFStringCreateWithCStringNoCopy (NULL, + (const char *) pszProc, CFStringGetSystemEncoding (), NULL)); +} +#elif defined(GLX_ARB_get_proc_address) +/* Not all glx.h define PFNGLXGETPROCADDRESSARBPROC ! + We define our own if needed. */ +#ifdef HAVE_PFNGLXGETPROCADDRESSARBPROC +#define PFNBGLXGETPROCADDRESSARBPROC PFNGLXGETPROCADDRESSARBPROC +#else +typedef void (*(*PFNBGLXGETPROCADDRESSARBPROC)(const GLubyte *procname))(); +#endif + +void *_getProcAddress(const GLubyte *procName) { return NULL; } +PFNBGLXGETPROCADDRESSARBPROC bglGetProcAddress; + +static void bglInitEntryPoints (void) +{ + Display *dpy = glXGetCurrentDisplay(); + std::vector Xextensions = STR_String(glXQueryExtensionsString(dpy, DefaultScreen(dpy))).Explode(' '); + if (std::find(Xextensions.begin(), Xextensions.end(), "GLX_ARB_get_proc_address") != Xextensions.end()) + { + void *libGL = dlopen("libGL.so", RTLD_LAZY); + if (libGL) + { + bglGetProcAddress = (PFNBGLXGETPROCADDRESSARBPROC) (dlsym(libGL, "glXGetProcAddressARB")); + dlclose(libGL); + if (!bglGetProcAddress) + bglGetProcAddress = (PFNBGLXGETPROCADDRESSARBPROC) _getProcAddress; + } + } +} + +static void bglDeallocEntryPoints (void) {} + +#elif defined(WIN32) +static void bglInitEntryPoints (void) {} +static void bglDeallocEntryPoints (void) {} + +#define bglGetProcAddress(entry) wglGetProcAddress((LPCSTR) entry) + +#else /* Unknown Platform - disable extensions */ +static void bglInitEntryPoints (void) {} +static void bglDeallocEntryPoints (void) {} + +static void *bglGetProcAddress(const GLubyte* entry) +{ + /* No Extensions! */ + return NULL; +} + +#endif /* End Platform Specific */ + +/* ----------------------------------------------------------------------------- + + GL Extension Manager. +*/ + +RAS_GLExtensionManager::RAS_GLExtensionManager(int debug) : + m_debug(debug) +{ + bglInitEntryPoints (); //init bundle + EnableExtension(_BGL_TEST); + LinkExtensions(); +} + +RAS_GLExtensionManager::~RAS_GLExtensionManager() +{ + bglDeallocEntryPoints(); +} + +bool RAS_GLExtensionManager::QueryExtension(STR_String extension_name) +{ + return std::find(extensions.begin(), extensions.end(), extension_name) != extensions.end(); +} + +bool RAS_GLExtensionManager::QueryExtension(RAS_GLExtensionManager::ExtensionName name) +{ + unsigned int num = (unsigned int) name; + if (num >= NUM_EXTENSIONS) + return false; + + return (enabled_extensions[num/(8*sizeof(unsigned int))] & (1<<(num%(8*sizeof(unsigned int))))) != 0; +} + +bool RAS_GLExtensionManager::QueryVersion(int major, int minor) +{ + STR_String gl_version = STR_String((const char *) glGetString(GL_VERSION)); + int i = gl_version.Find('.'); + STR_String gl_major = gl_version.Left(i); + STR_String gl_minor = gl_version.Mid(i+1, gl_version.FindOneOf(". ", i+1) - i - 1); + + if (m_debug) + { + static bool doQueryVersion = true; + if (doQueryVersion) + { + doQueryVersion = false; + std::cout << "GL_VERSION: " << gl_major << "." << gl_minor << " (" << gl_version << ")" << std::endl; + } + } + + if (gl_major.ToInt() >= major && gl_minor.ToInt() >= minor) + return true; + + return false; +} + + +void RAS_GLExtensionManager::EnableExtension(RAS_GLExtensionManager::ExtensionName name) +{ + unsigned int num = (unsigned int) name; + if (num < NUM_EXTENSIONS) + enabled_extensions[num/(8*sizeof(unsigned int))] |= (1<<(num%(8*sizeof(unsigned int)))); +} + +/******************************************************************************* +1. Extension function entry points go here + +Need to #ifdef (compile time test for extension) +Add null functions if appropriate + +Some extensions have been incorporated into the core GL, eg Multitexture was +added in GL v1.1. If Blender calls one of these functions before they are +linked, it will crash. Even worse, if Blender *indirectly* calls one of these +functions, (ie the GL implementation calls them itself) Blender will crash. + +We fix this by adding them to the RAS_GL namespace - the functions are now +private to the gameengine. Code can transparently use extensions by adding: + +using namespace RAS_GL; + +to their source. Cunning like a weasel. + +/******************************************************************************/ + +namespace RAS_GL { +/* Generated from mkglext.py */ + +/* GL_EXT_compiled_vertex_array */ +#ifdef GL_EXT_compiled_vertex_array +static void APIENTRY _lockfunc(GLint first,GLsizei count) {}; +static void APIENTRY _unlockfunc() {}; +PFNGLLOCKARRAYSEXTPROC glLockArraysEXT=_lockfunc; +PFNGLUNLOCKARRAYSEXTPROC glUnlockArraysEXT=_unlockfunc; +#endif + +#if defined(GL_ARB_transpose_matrix) +PFNGLLOADTRANSPOSEMATRIXFARBPROC glLoadTransposeMatrixfARB; +PFNGLLOADTRANSPOSEMATRIXDARBPROC glLoadTransposeMatrixdARB; +PFNGLMULTTRANSPOSEMATRIXFARBPROC glMultTransposeMatrixfARB; +PFNGLMULTTRANSPOSEMATRIXDARBPROC glMultTransposeMatrixdARB; +#endif + +#if defined(GL_ARB_multisample) +PFNGLSAMPLECOVERAGEARBPROC glSampleCoverageARB; +#endif + +#if defined(GL_ARB_texture_env_add) +#endif + +#if defined(GL_ARB_texture_cube_map) +#endif + +#if defined(GL_ARB_texture_compression) +PFNGLCOMPRESSEDTEXIMAGE3DARBPROC glCompressedTexImage3DARB; +PFNGLCOMPRESSEDTEXIMAGE2DARBPROC glCompressedTexImage2DARB; +PFNGLCOMPRESSEDTEXIMAGE1DARBPROC glCompressedTexImage1DARB; +PFNGLCOMPRESSEDTEXSUBIMAGE3DARBPROC glCompressedTexSubImage3DARB; +PFNGLCOMPRESSEDTEXSUBIMAGE2DARBPROC glCompressedTexSubImage2DARB; +PFNGLCOMPRESSEDTEXSUBIMAGE1DARBPROC glCompressedTexSubImage1DARB; +PFNGLGETCOMPRESSEDTEXIMAGEARBPROC glGetCompressedTexImageARB; +#endif + +#if defined(GL_ARB_texture_border_clamp) +#endif + +#if defined(GL_ARB_vertex_blend) +PFNGLWEIGHTBVARBPROC glWeightbvARB; +PFNGLWEIGHTSVARBPROC glWeightsvARB; +PFNGLWEIGHTIVARBPROC glWeightivARB; +PFNGLWEIGHTFVARBPROC glWeightfvARB; +PFNGLWEIGHTDVARBPROC glWeightdvARB; +PFNGLWEIGHTUBVARBPROC glWeightubvARB; +PFNGLWEIGHTUSVARBPROC glWeightusvARB; +PFNGLWEIGHTUIVARBPROC glWeightuivARB; +PFNGLWEIGHTPOINTERARBPROC glWeightPointerARB; +PFNGLVERTEXBLENDARBPROC glVertexBlendARB; +#endif + +#if defined(GL_ARB_matrix_palette) +PFNGLCURRENTPALETTEMATRIXARBPROC glCurrentPaletteMatrixARB; +PFNGLMATRIXINDEXUBVARBPROC glMatrixIndexubvARB; +PFNGLMATRIXINDEXUSVARBPROC glMatrixIndexusvARB; +PFNGLMATRIXINDEXUIVARBPROC glMatrixIndexuivARB; +PFNGLMATRIXINDEXPOINTERARBPROC glMatrixIndexPointerARB; +#endif + +#if defined(GL_ARB_texture_env_combine) +#endif + +#if defined(GL_ARB_texture_env_crossbar) +#endif + +#if defined(GL_ARB_texture_env_dot3) +#endif + +#if defined(GL_ARB_texture_mirrored_repeat) +#endif + +#if defined(GL_ARB_depth_texture) +#endif + +#if defined(GL_ARB_shadow) +#endif + +#if defined(GL_ARB_shadow_ambient) +#endif + +#if defined(GL_ARB_window_pos) +PFNGLWINDOWPOS2DARBPROC glWindowPos2dARB; +PFNGLWINDOWPOS2DVARBPROC glWindowPos2dvARB; +PFNGLWINDOWPOS2FARBPROC glWindowPos2fARB; +PFNGLWINDOWPOS2FVARBPROC glWindowPos2fvARB; +PFNGLWINDOWPOS2IARBPROC glWindowPos2iARB; +PFNGLWINDOWPOS2IVARBPROC glWindowPos2ivARB; +PFNGLWINDOWPOS2SARBPROC glWindowPos2sARB; +PFNGLWINDOWPOS2SVARBPROC glWindowPos2svARB; +PFNGLWINDOWPOS3DARBPROC glWindowPos3dARB; +PFNGLWINDOWPOS3DVARBPROC glWindowPos3dvARB; +PFNGLWINDOWPOS3FARBPROC glWindowPos3fARB; +PFNGLWINDOWPOS3FVARBPROC glWindowPos3fvARB; +PFNGLWINDOWPOS3IARBPROC glWindowPos3iARB; +PFNGLWINDOWPOS3IVARBPROC glWindowPos3ivARB; +PFNGLWINDOWPOS3SARBPROC glWindowPos3sARB; +PFNGLWINDOWPOS3SVARBPROC glWindowPos3svARB; +#endif + +#if defined(GL_ARB_vertex_program) +PFNGLVERTEXATTRIB1DARBPROC glVertexAttrib1dARB; +PFNGLVERTEXATTRIB1DVARBPROC glVertexAttrib1dvARB; +PFNGLVERTEXATTRIB1FARBPROC glVertexAttrib1fARB; +PFNGLVERTEXATTRIB1FVARBPROC glVertexAttrib1fvARB; +PFNGLVERTEXATTRIB1SARBPROC glVertexAttrib1sARB; +PFNGLVERTEXATTRIB1SVARBPROC glVertexAttrib1svARB; +PFNGLVERTEXATTRIB2DARBPROC glVertexAttrib2dARB; +PFNGLVERTEXATTRIB2DVARBPROC glVertexAttrib2dvARB; +PFNGLVERTEXATTRIB2FARBPROC glVertexAttrib2fARB; +PFNGLVERTEXATTRIB2FVARBPROC glVertexAttrib2fvARB; +PFNGLVERTEXATTRIB2SARBPROC glVertexAttrib2sARB; +PFNGLVERTEXATTRIB2SVARBPROC glVertexAttrib2svARB; +PFNGLVERTEXATTRIB3DARBPROC glVertexAttrib3dARB; +PFNGLVERTEXATTRIB3DVARBPROC glVertexAttrib3dvARB; +PFNGLVERTEXATTRIB3FARBPROC glVertexAttrib3fARB; +PFNGLVERTEXATTRIB3FVARBPROC glVertexAttrib3fvARB; +PFNGLVERTEXATTRIB3SARBPROC glVertexAttrib3sARB; +PFNGLVERTEXATTRIB3SVARBPROC glVertexAttrib3svARB; +PFNGLVERTEXATTRIB4NBVARBPROC glVertexAttrib4NbvARB; +PFNGLVERTEXATTRIB4NIVARBPROC glVertexAttrib4NivARB; +PFNGLVERTEXATTRIB4NSVARBPROC glVertexAttrib4NsvARB; +PFNGLVERTEXATTRIB4NUBARBPROC glVertexAttrib4NubARB; +PFNGLVERTEXATTRIB4NUBVARBPROC glVertexAttrib4NubvARB; +PFNGLVERTEXATTRIB4NUIVARBPROC glVertexAttrib4NuivARB; +PFNGLVERTEXATTRIB4NUSVARBPROC glVertexAttrib4NusvARB; +PFNGLVERTEXATTRIB4BVARBPROC glVertexAttrib4bvARB; +PFNGLVERTEXATTRIB4DARBPROC glVertexAttrib4dARB; +PFNGLVERTEXATTRIB4DVARBPROC glVertexAttrib4dvARB; +PFNGLVERTEXATTRIB4FARBPROC glVertexAttrib4fARB; +PFNGLVERTEXATTRIB4FVARBPROC glVertexAttrib4fvARB; +PFNGLVERTEXATTRIB4IVARBPROC glVertexAttrib4ivARB; +PFNGLVERTEXATTRIB4SARBPROC glVertexAttrib4sARB; +PFNGLVERTEXATTRIB4SVARBPROC glVertexAttrib4svARB; +PFNGLVERTEXATTRIB4UBVARBPROC glVertexAttrib4ubvARB; +PFNGLVERTEXATTRIB4UIVARBPROC glVertexAttrib4uivARB; +PFNGLVERTEXATTRIB4USVARBPROC glVertexAttrib4usvARB; +PFNGLVERTEXATTRIBPOINTERARBPROC glVertexAttribPointerARB; +PFNGLENABLEVERTEXATTRIBARRAYARBPROC glEnableVertexAttribArrayARB; +PFNGLDISABLEVERTEXATTRIBARRAYARBPROC glDisableVertexAttribArrayARB; +PFNGLPROGRAMSTRINGARBPROC glProgramStringARB; +PFNGLBINDPROGRAMARBPROC glBindProgramARB; +PFNGLDELETEPROGRAMSARBPROC glDeleteProgramsARB; +PFNGLGENPROGRAMSARBPROC glGenProgramsARB; +PFNGLPROGRAMENVPARAMETER4DARBPROC glProgramEnvParameter4dARB; +PFNGLPROGRAMENVPARAMETER4DVARBPROC glProgramEnvParameter4dvARB; +PFNGLPROGRAMENVPARAMETER4FARBPROC glProgramEnvParameter4fARB; +PFNGLPROGRAMENVPARAMETER4FVARBPROC glProgramEnvParameter4fvARB; +PFNGLPROGRAMLOCALPARAMETER4DARBPROC glProgramLocalParameter4dARB; +PFNGLPROGRAMLOCALPARAMETER4DVARBPROC glProgramLocalParameter4dvARB; +PFNGLPROGRAMLOCALPARAMETER4FARBPROC glProgramLocalParameter4fARB; +PFNGLPROGRAMLOCALPARAMETER4FVARBPROC glProgramLocalParameter4fvARB; +PFNGLGETPROGRAMENVPARAMETERDVARBPROC glGetProgramEnvParameterdvARB; +PFNGLGETPROGRAMENVPARAMETERFVARBPROC glGetProgramEnvParameterfvARB; +PFNGLGETPROGRAMLOCALPARAMETERDVARBPROC glGetProgramLocalParameterdvARB; +PFNGLGETPROGRAMLOCALPARAMETERFVARBPROC glGetProgramLocalParameterfvARB; +PFNGLGETPROGRAMIVARBPROC glGetProgramivARB; +PFNGLGETPROGRAMSTRINGARBPROC glGetProgramStringARB; +PFNGLGETVERTEXATTRIBDVARBPROC glGetVertexAttribdvARB; +PFNGLGETVERTEXATTRIBFVARBPROC glGetVertexAttribfvARB; +PFNGLGETVERTEXATTRIBIVARBPROC glGetVertexAttribivARB; +PFNGLGETVERTEXATTRIBPOINTERVARBPROC glGetVertexAttribPointervARB; +PFNGLISPROGRAMARBPROC glIsProgramARB; +#endif + +#if defined(GL_ARB_fragment_program) +#endif + +#if defined(GL_ARB_vertex_buffer_object) +PFNGLBINDBUFFERARBPROC glBindBufferARB; +PFNGLDELETEBUFFERSARBPROC glDeleteBuffersARB; +PFNGLGENBUFFERSARBPROC glGenBuffersARB; +PFNGLISBUFFERARBPROC glIsBufferARB; +PFNGLBUFFERDATAARBPROC glBufferDataARB; +PFNGLBUFFERSUBDATAARBPROC glBufferSubDataARB; +PFNGLGETBUFFERSUBDATAARBPROC glGetBufferSubDataARB; +PFNGLMAPBUFFERARBPROC glMapBufferARB; +PFNGLUNMAPBUFFERARBPROC glUnmapBufferARB; +PFNGLGETBUFFERPARAMETERIVARBPROC glGetBufferParameterivARB; +PFNGLGETBUFFERPOINTERVARBPROC glGetBufferPointervARB; +#endif + +#if defined(GL_ARB_occlusion_query) +PFNGLGENQUERIESARBPROC glGenQueriesARB; +PFNGLDELETEQUERIESARBPROC glDeleteQueriesARB; +PFNGLISQUERYARBPROC glIsQueryARB; +PFNGLBEGINQUERYARBPROC glBeginQueryARB; +PFNGLENDQUERYARBPROC glEndQueryARB; +PFNGLGETQUERYIVARBPROC glGetQueryivARB; +PFNGLGETQUERYOBJECTIVARBPROC glGetQueryObjectivARB; +PFNGLGETQUERYOBJECTUIVARBPROC glGetQueryObjectuivARB; +#endif + +#if defined(GL_ARB_shader_objects) +PFNGLDELETEOBJECTARBPROC glDeleteObjectARB; +PFNGLGETHANDLEARBPROC glGetHandleARB; +PFNGLDETACHOBJECTARBPROC glDetachObjectARB; +PFNGLCREATESHADEROBJECTARBPROC glCreateShaderObjectARB; +PFNGLSHADERSOURCEARBPROC glShaderSourceARB; +PFNGLCOMPILESHADERARBPROC glCompileShaderARB; +PFNGLCREATEPROGRAMOBJECTARBPROC glCreateProgramObjectARB; +PFNGLATTACHOBJECTARBPROC glAttachObjectARB; +PFNGLLINKPROGRAMARBPROC glLinkProgramARB; +PFNGLUSEPROGRAMOBJECTARBPROC glUseProgramObjectARB; +PFNGLVALIDATEPROGRAMARBPROC glValidateProgramARB; +PFNGLUNIFORM1FARBPROC glUniform1fARB; +PFNGLUNIFORM2FARBPROC glUniform2fARB; +PFNGLUNIFORM3FARBPROC glUniform3fARB; +PFNGLUNIFORM4FARBPROC glUniform4fARB; +PFNGLUNIFORM1IARBPROC glUniform1iARB; +PFNGLUNIFORM2IARBPROC glUniform2iARB; +PFNGLUNIFORM3IARBPROC glUniform3iARB; +PFNGLUNIFORM4IARBPROC glUniform4iARB; +PFNGLUNIFORM1FVARBPROC glUniform1fvARB; +PFNGLUNIFORM2FVARBPROC glUniform2fvARB; +PFNGLUNIFORM3FVARBPROC glUniform3fvARB; +PFNGLUNIFORM4FVARBPROC glUniform4fvARB; +PFNGLUNIFORM1IVARBPROC glUniform1ivARB; +PFNGLUNIFORM2IVARBPROC glUniform2ivARB; +PFNGLUNIFORM3IVARBPROC glUniform3ivARB; +PFNGLUNIFORM4IVARBPROC glUniform4ivARB; +PFNGLUNIFORMMATRIX2FVARBPROC glUniformMatrix2fvARB; +PFNGLUNIFORMMATRIX3FVARBPROC glUniformMatrix3fvARB; +PFNGLUNIFORMMATRIX4FVARBPROC glUniformMatrix4fvARB; +PFNGLGETOBJECTPARAMETERFVARBPROC glGetObjectParameterfvARB; +PFNGLGETOBJECTPARAMETERIVARBPROC glGetObjectParameterivARB; +PFNGLGETINFOLOGARBPROC glGetInfoLogARB; +PFNGLGETATTACHEDOBJECTSARBPROC glGetAttachedObjectsARB; +PFNGLGETUNIFORMLOCATIONARBPROC glGetUniformLocationARB; +PFNGLGETACTIVEUNIFORMARBPROC glGetActiveUniformARB; +PFNGLGETUNIFORMFVARBPROC glGetUniformfvARB; +PFNGLGETUNIFORMIVARBPROC glGetUniformivARB; +PFNGLGETSHADERSOURCEARBPROC glGetShaderSourceARB; +#endif + +#if defined(GL_ARB_vertex_shader) +PFNGLBINDATTRIBLOCATIONARBPROC glBindAttribLocationARB; +PFNGLGETACTIVEATTRIBARBPROC glGetActiveAttribARB; +PFNGLGETATTRIBLOCATIONARBPROC glGetAttribLocationARB; +#endif + +#if defined(GL_ARB_fragment_shader) +#endif + +#if defined(GL_ARB_shading_language_100) +#endif + +#if defined(GL_ARB_texture_non_power_of_two) +#endif + +#if defined(GL_ARB_point_sprite) +#endif + +#if defined(GL_ARB_fragment_program_shadow) +#endif + +#if defined(GL_EXT_abgr) +#endif + +#if defined(GL_EXT_texture3D) +PFNGLTEXIMAGE3DEXTPROC glTexImage3DEXT; +PFNGLTEXSUBIMAGE3DEXTPROC glTexSubImage3DEXT; +#endif + +#if defined(GL_SGIS_texture_filter4) +PFNGLGETTEXFILTERFUNCSGISPROC glGetTexFilterFuncSGIS; +PFNGLTEXFILTERFUNCSGISPROC glTexFilterFuncSGIS; +#endif + +#if defined(GL_EXT_histogram) +PFNGLGETHISTOGRAMEXTPROC glGetHistogramEXT; +PFNGLGETHISTOGRAMPARAMETERFVEXTPROC glGetHistogramParameterfvEXT; +PFNGLGETHISTOGRAMPARAMETERIVEXTPROC glGetHistogramParameterivEXT; +PFNGLGETMINMAXEXTPROC glGetMinmaxEXT; +PFNGLGETMINMAXPARAMETERFVEXTPROC glGetMinmaxParameterfvEXT; +PFNGLGETMINMAXPARAMETERIVEXTPROC glGetMinmaxParameterivEXT; +PFNGLHISTOGRAMEXTPROC glHistogramEXT; +PFNGLMINMAXEXTPROC glMinmaxEXT; +PFNGLRESETHISTOGRAMEXTPROC glResetHistogramEXT; +PFNGLRESETMINMAXEXTPROC glResetMinmaxEXT; +#endif + +#if defined(GL_EXT_convolution) +PFNGLCONVOLUTIONFILTER1DEXTPROC glConvolutionFilter1DEXT; +PFNGLCONVOLUTIONFILTER2DEXTPROC glConvolutionFilter2DEXT; +PFNGLCONVOLUTIONPARAMETERFEXTPROC glConvolutionParameterfEXT; +PFNGLCONVOLUTIONPARAMETERFVEXTPROC glConvolutionParameterfvEXT; +PFNGLCONVOLUTIONPARAMETERIEXTPROC glConvolutionParameteriEXT; +PFNGLCONVOLUTIONPARAMETERIVEXTPROC glConvolutionParameterivEXT; +PFNGLCOPYCONVOLUTIONFILTER1DEXTPROC glCopyConvolutionFilter1DEXT; +PFNGLCOPYCONVOLUTIONFILTER2DEXTPROC glCopyConvolutionFilter2DEXT; +PFNGLGETCONVOLUTIONFILTEREXTPROC glGetConvolutionFilterEXT; +PFNGLGETCONVOLUTIONPARAMETERFVEXTPROC glGetConvolutionParameterfvEXT; +PFNGLGETCONVOLUTIONPARAMETERIVEXTPROC glGetConvolutionParameterivEXT; +PFNGLGETSEPARABLEFILTEREXTPROC glGetSeparableFilterEXT; +PFNGLSEPARABLEFILTER2DEXTPROC glSeparableFilter2DEXT; +#endif + +#if defined(GL_SGI_color_table) +PFNGLCOLORTABLESGIPROC glColorTableSGI; +PFNGLCOLORTABLEPARAMETERFVSGIPROC glColorTableParameterfvSGI; +PFNGLCOLORTABLEPARAMETERIVSGIPROC glColorTableParameterivSGI; +PFNGLCOPYCOLORTABLESGIPROC glCopyColorTableSGI; +PFNGLGETCOLORTABLESGIPROC glGetColorTableSGI; +PFNGLGETCOLORTABLEPARAMETERFVSGIPROC glGetColorTableParameterfvSGI; +PFNGLGETCOLORTABLEPARAMETERIVSGIPROC glGetColorTableParameterivSGI; +#endif + +#if defined(GL_SGIX_pixel_texture) +PFNGLPIXELTEXGENSGIXPROC glPixelTexGenSGIX; +#endif + +#if defined(GL_SGIS_pixel_texture) +PFNGLPIXELTEXGENPARAMETERISGISPROC glPixelTexGenParameteriSGIS; +PFNGLPIXELTEXGENPARAMETERIVSGISPROC glPixelTexGenParameterivSGIS; +PFNGLPIXELTEXGENPARAMETERFSGISPROC glPixelTexGenParameterfSGIS; +PFNGLPIXELTEXGENPARAMETERFVSGISPROC glPixelTexGenParameterfvSGIS; +PFNGLGETPIXELTEXGENPARAMETERIVSGISPROC glGetPixelTexGenParameterivSGIS; +PFNGLGETPIXELTEXGENPARAMETERFVSGISPROC glGetPixelTexGenParameterfvSGIS; +#endif + +#if defined(GL_SGIS_texture4D) +PFNGLTEXIMAGE4DSGISPROC glTexImage4DSGIS; +PFNGLTEXSUBIMAGE4DSGISPROC glTexSubImage4DSGIS; +#endif + +#if defined(GL_SGI_texture_color_table) +#endif + +#if defined(GL_EXT_cmyka) +#endif + +#if defined(GL_SGIS_detail_texture) +PFNGLDETAILTEXFUNCSGISPROC glDetailTexFuncSGIS; +PFNGLGETDETAILTEXFUNCSGISPROC glGetDetailTexFuncSGIS; +#endif + +#if defined(GL_SGIS_sharpen_texture) +PFNGLSHARPENTEXFUNCSGISPROC glSharpenTexFuncSGIS; +PFNGLGETSHARPENTEXFUNCSGISPROC glGetSharpenTexFuncSGIS; +#endif + +#if defined(GL_EXT_packed_pixels) +#endif + +#if defined(GL_SGIS_texture_lod) +#endif + +#if defined(GL_SGIS_multisample) +PFNGLSAMPLEMASKSGISPROC glSampleMaskSGIS; +PFNGLSAMPLEPATTERNSGISPROC glSamplePatternSGIS; +#endif + +#if defined(GL_EXT_rescale_normal) +#endif + +#if defined(GL_EXT_misc_attribute) +#endif + +#if defined(GL_SGIS_generate_mipmap) +#endif + +#if defined(GL_SGIX_clipmap) +#endif + +#if defined(GL_SGIX_shadow) +#endif + +#if defined(GL_SGIS_texture_edge_clamp) +#endif + +#if defined(GL_SGIS_texture_border_clamp) +#endif + +#if defined(GL_EXT_blend_minmax) +PFNGLBLENDEQUATIONEXTPROC glBlendEquationEXT; +#endif + +#if defined(GL_EXT_blend_subtract) +#endif + +#if defined(GL_EXT_blend_logic_op) +#endif + +#if defined(GL_SGIX_interlace) +#endif + +#if defined(GL_SGIX_sprite) +PFNGLSPRITEPARAMETERFSGIXPROC glSpriteParameterfSGIX; +PFNGLSPRITEPARAMETERFVSGIXPROC glSpriteParameterfvSGIX; +PFNGLSPRITEPARAMETERISGIXPROC glSpriteParameteriSGIX; +PFNGLSPRITEPARAMETERIVSGIXPROC glSpriteParameterivSGIX; +#endif + +#if defined(GL_SGIX_texture_multi_buffer) +#endif + +#if defined(GL_SGIX_instruments) +PFNGLGETINSTRUMENTSSGIXPROC glGetInstrumentsSGIX; +PFNGLINSTRUMENTSBUFFERSGIXPROC glInstrumentsBufferSGIX; +PFNGLPOLLINSTRUMENTSSGIXPROC glPollInstrumentsSGIX; +PFNGLREADINSTRUMENTSSGIXPROC glReadInstrumentsSGIX; +PFNGLSTARTINSTRUMENTSSGIXPROC glStartInstrumentsSGIX; +PFNGLSTOPINSTRUMENTSSGIXPROC glStopInstrumentsSGIX; +#endif + +#if defined(GL_SGIX_texture_scale_bias) +#endif + +#if defined(GL_SGIX_framezoom) +PFNGLFRAMEZOOMSGIXPROC glFrameZoomSGIX; +#endif + +#if defined(GL_SGIX_tag_sample_buffer) +PFNGLTAGSAMPLEBUFFERSGIXPROC glTagSampleBufferSGIX; +#endif + +#if defined(GL_SGIX_reference_plane) +PFNGLREFERENCEPLANESGIXPROC glReferencePlaneSGIX; +#endif + +#if defined(GL_SGIX_flush_raster) +PFNGLFLUSHRASTERSGIXPROC glFlushRasterSGIX; +#endif + +#if defined(GL_SGIX_depth_texture) +#endif + +#if defined(GL_SGIS_fog_function) +PFNGLFOGFUNCSGISPROC glFogFuncSGIS; +PFNGLGETFOGFUNCSGISPROC glGetFogFuncSGIS; +#endif + +#if defined(GL_SGIX_fog_offset) +#endif + +#if defined(GL_HP_image_transform) +PFNGLIMAGETRANSFORMPARAMETERIHPPROC glImageTransformParameteriHP; +PFNGLIMAGETRANSFORMPARAMETERFHPPROC glImageTransformParameterfHP; +PFNGLIMAGETRANSFORMPARAMETERIVHPPROC glImageTransformParameterivHP; +PFNGLIMAGETRANSFORMPARAMETERFVHPPROC glImageTransformParameterfvHP; +PFNGLGETIMAGETRANSFORMPARAMETERIVHPPROC glGetImageTransformParameterivHP; +PFNGLGETIMAGETRANSFORMPARAMETERFVHPPROC glGetImageTransformParameterfvHP; +#endif + +#if defined(GL_HP_convolution_border_modes) +#endif + +#if defined(GL_SGIX_texture_add_env) +#endif + +#if defined(GL_EXT_color_subtable) +PFNGLCOLORSUBTABLEEXTPROC glColorSubTableEXT; +PFNGLCOPYCOLORSUBTABLEEXTPROC glCopyColorSubTableEXT; +#endif + +#if defined(GL_PGI_vertex_hints) +#endif + +#if defined(GL_PGI_misc_hints) +PFNGLHINTPGIPROC glHintPGI; +#endif + +#if defined(GL_EXT_paletted_texture) +PFNGLCOLORTABLEEXTPROC glColorTableEXT; +PFNGLGETCOLORTABLEEXTPROC glGetColorTableEXT; +PFNGLGETCOLORTABLEPARAMETERIVEXTPROC glGetColorTableParameterivEXT; +PFNGLGETCOLORTABLEPARAMETERFVEXTPROC glGetColorTableParameterfvEXT; +#endif + +#if defined(GL_EXT_clip_volume_hint) +#endif + +#if defined(GL_SGIX_list_priority) +PFNGLGETLISTPARAMETERFVSGIXPROC glGetListParameterfvSGIX; +PFNGLGETLISTPARAMETERIVSGIXPROC glGetListParameterivSGIX; +PFNGLLISTPARAMETERFSGIXPROC glListParameterfSGIX; +PFNGLLISTPARAMETERFVSGIXPROC glListParameterfvSGIX; +PFNGLLISTPARAMETERISGIXPROC glListParameteriSGIX; +PFNGLLISTPARAMETERIVSGIXPROC glListParameterivSGIX; +#endif + +#if defined(GL_SGIX_ir_instrument1) +#endif + +#if defined(GL_SGIX_texture_lod_bias) +#endif + +#if defined(GL_SGIX_shadow_ambient) +#endif + +#if defined(GL_EXT_index_texture) +#endif + +#if defined(GL_EXT_index_material) +PFNGLINDEXMATERIALEXTPROC glIndexMaterialEXT; +#endif + +#if defined(GL_EXT_index_func) +PFNGLINDEXFUNCEXTPROC glIndexFuncEXT; +#endif + +#if defined(GL_EXT_index_array_formats) +#endif + +#if defined(GL_EXT_cull_vertex) +PFNGLCULLPARAMETERDVEXTPROC glCullParameterdvEXT; +PFNGLCULLPARAMETERFVEXTPROC glCullParameterfvEXT; +#endif + +#if defined(GL_SGIX_ycrcb) +#endif + +#if defined(GL_IBM_rasterpos_clip) +#endif + +#if defined(GL_HP_texture_lighting) +#endif + +#if defined(GL_EXT_draw_range_elements) +PFNGLDRAWRANGEELEMENTSEXTPROC glDrawRangeElementsEXT; +#endif + +#if defined(GL_WIN_phong_shading) +#endif + +#if defined(GL_WIN_specular_fog) +#endif + +#if defined(GL_EXT_light_texture) +PFNGLAPPLYTEXTUREEXTPROC glApplyTextureEXT; +PFNGLTEXTURELIGHTEXTPROC glTextureLightEXT; +PFNGLTEXTUREMATERIALEXTPROC glTextureMaterialEXT; +#endif + +#if defined(GL_SGIX_blend_alpha_minmax) +#endif + +#if defined(GL_EXT_bgra) +#endif + +#if defined(GL_SGIX_async) +PFNGLASYNCMARKERSGIXPROC glAsyncMarkerSGIX; +PFNGLFINISHASYNCSGIXPROC glFinishAsyncSGIX; +PFNGLPOLLASYNCSGIXPROC glPollAsyncSGIX; +PFNGLGENASYNCMARKERSSGIXPROC glGenAsyncMarkersSGIX; +PFNGLDELETEASYNCMARKERSSGIXPROC glDeleteAsyncMarkersSGIX; +PFNGLISASYNCMARKERSGIXPROC glIsAsyncMarkerSGIX; +#endif + +#if defined(GL_SGIX_async_pixel) +#endif + +#if defined(GL_SGIX_async_histogram) +#endif + +#if defined(GL_INTEL_parallel_arrays) +PFNGLVERTEXPOINTERVINTELPROC glVertexPointervINTEL; +PFNGLNORMALPOINTERVINTELPROC glNormalPointervINTEL; +PFNGLCOLORPOINTERVINTELPROC glColorPointervINTEL; +PFNGLTEXCOORDPOINTERVINTELPROC glTexCoordPointervINTEL; +#endif + +#if defined(GL_HP_occlusion_test) +#endif + +#if defined(GL_EXT_pixel_transform) +PFNGLPIXELTRANSFORMPARAMETERIEXTPROC glPixelTransformParameteriEXT; +PFNGLPIXELTRANSFORMPARAMETERFEXTPROC glPixelTransformParameterfEXT; +PFNGLPIXELTRANSFORMPARAMETERIVEXTPROC glPixelTransformParameterivEXT; +PFNGLPIXELTRANSFORMPARAMETERFVEXTPROC glPixelTransformParameterfvEXT; +#endif + +#if defined(GL_EXT_pixel_transform_color_table) +#endif + +#if defined(GL_EXT_shared_texture_palette) +#endif + +#if defined(GL_EXT_separate_specular_color) +#endif + +#if defined(GL_EXT_secondary_color) +PFNGLSECONDARYCOLOR3BEXTPROC glSecondaryColor3bEXT; +PFNGLSECONDARYCOLOR3BVEXTPROC glSecondaryColor3bvEXT; +PFNGLSECONDARYCOLOR3DEXTPROC glSecondaryColor3dEXT; +PFNGLSECONDARYCOLOR3DVEXTPROC glSecondaryColor3dvEXT; +PFNGLSECONDARYCOLOR3FEXTPROC glSecondaryColor3fEXT; +PFNGLSECONDARYCOLOR3FVEXTPROC glSecondaryColor3fvEXT; +PFNGLSECONDARYCOLOR3IEXTPROC glSecondaryColor3iEXT; +PFNGLSECONDARYCOLOR3IVEXTPROC glSecondaryColor3ivEXT; +PFNGLSECONDARYCOLOR3SEXTPROC glSecondaryColor3sEXT; +PFNGLSECONDARYCOLOR3SVEXTPROC glSecondaryColor3svEXT; +PFNGLSECONDARYCOLOR3UBEXTPROC glSecondaryColor3ubEXT; +PFNGLSECONDARYCOLOR3UBVEXTPROC glSecondaryColor3ubvEXT; +PFNGLSECONDARYCOLOR3UIEXTPROC glSecondaryColor3uiEXT; +PFNGLSECONDARYCOLOR3UIVEXTPROC glSecondaryColor3uivEXT; +PFNGLSECONDARYCOLOR3USEXTPROC glSecondaryColor3usEXT; +PFNGLSECONDARYCOLOR3USVEXTPROC glSecondaryColor3usvEXT; +PFNGLSECONDARYCOLORPOINTEREXTPROC glSecondaryColorPointerEXT; +#endif + +#if defined(GL_EXT_texture_perturb_normal) +PFNGLTEXTURENORMALEXTPROC glTextureNormalEXT; +#endif + +#if defined(GL_EXT_multi_draw_arrays) +PFNGLMULTIDRAWARRAYSEXTPROC glMultiDrawArraysEXT; +PFNGLMULTIDRAWELEMENTSEXTPROC glMultiDrawElementsEXT; +#endif + +#if defined(GL_EXT_fog_coord) +PFNGLFOGCOORDFEXTPROC glFogCoordfEXT; +PFNGLFOGCOORDFVEXTPROC glFogCoordfvEXT; +PFNGLFOGCOORDDEXTPROC glFogCoorddEXT; +PFNGLFOGCOORDDVEXTPROC glFogCoorddvEXT; +PFNGLFOGCOORDPOINTEREXTPROC glFogCoordPointerEXT; +#endif + +#if defined(GL_REND_screen_coordinates) +#endif + +#if defined(GL_EXT_coordinate_frame) +PFNGLTANGENT3BEXTPROC glTangent3bEXT; +PFNGLTANGENT3BVEXTPROC glTangent3bvEXT; +PFNGLTANGENT3DEXTPROC glTangent3dEXT; +PFNGLTANGENT3DVEXTPROC glTangent3dvEXT; +PFNGLTANGENT3FEXTPROC glTangent3fEXT; +PFNGLTANGENT3FVEXTPROC glTangent3fvEXT; +PFNGLTANGENT3IEXTPROC glTangent3iEXT; +PFNGLTANGENT3IVEXTPROC glTangent3ivEXT; +PFNGLTANGENT3SEXTPROC glTangent3sEXT; +PFNGLTANGENT3SVEXTPROC glTangent3svEXT; +PFNGLBINORMAL3BEXTPROC glBinormal3bEXT; +PFNGLBINORMAL3BVEXTPROC glBinormal3bvEXT; +PFNGLBINORMAL3DEXTPROC glBinormal3dEXT; +PFNGLBINORMAL3DVEXTPROC glBinormal3dvEXT; +PFNGLBINORMAL3FEXTPROC glBinormal3fEXT; +PFNGLBINORMAL3FVEXTPROC glBinormal3fvEXT; +PFNGLBINORMAL3IEXTPROC glBinormal3iEXT; +PFNGLBINORMAL3IVEXTPROC glBinormal3ivEXT; +PFNGLBINORMAL3SEXTPROC glBinormal3sEXT; +PFNGLBINORMAL3SVEXTPROC glBinormal3svEXT; +PFNGLTANGENTPOINTEREXTPROC glTangentPointerEXT; +PFNGLBINORMALPOINTEREXTPROC glBinormalPointerEXT; +#endif + +#if defined(GL_EXT_texture_env_combine) +#endif + +#if defined(GL_APPLE_specular_vector) +#endif + +#if defined(GL_APPLE_transform_hint) +#endif + +#if defined(GL_SUNX_constant_data) +PFNGLFINISHTEXTURESUNXPROC glFinishTextureSUNX; +#endif + +#if defined(GL_SUN_global_alpha) +PFNGLGLOBALALPHAFACTORBSUNPROC glGlobalAlphaFactorbSUN; +PFNGLGLOBALALPHAFACTORSSUNPROC glGlobalAlphaFactorsSUN; +PFNGLGLOBALALPHAFACTORISUNPROC glGlobalAlphaFactoriSUN; +PFNGLGLOBALALPHAFACTORFSUNPROC glGlobalAlphaFactorfSUN; +PFNGLGLOBALALPHAFACTORDSUNPROC glGlobalAlphaFactordSUN; +PFNGLGLOBALALPHAFACTORUBSUNPROC glGlobalAlphaFactorubSUN; +PFNGLGLOBALALPHAFACTORUSSUNPROC glGlobalAlphaFactorusSUN; +PFNGLGLOBALALPHAFACTORUISUNPROC glGlobalAlphaFactoruiSUN; +#endif + +#if defined(GL_SUN_triangle_list) +PFNGLREPLACEMENTCODEUISUNPROC glReplacementCodeuiSUN; +PFNGLREPLACEMENTCODEUSSUNPROC glReplacementCodeusSUN; +PFNGLREPLACEMENTCODEUBSUNPROC glReplacementCodeubSUN; +PFNGLREPLACEMENTCODEUIVSUNPROC glReplacementCodeuivSUN; +PFNGLREPLACEMENTCODEUSVSUNPROC glReplacementCodeusvSUN; +PFNGLREPLACEMENTCODEUBVSUNPROC glReplacementCodeubvSUN; +PFNGLREPLACEMENTCODEPOINTERSUNPROC glReplacementCodePointerSUN; +#endif + +#if defined(GL_SUN_vertex) +PFNGLCOLOR4UBVERTEX2FSUNPROC glColor4ubVertex2fSUN; +PFNGLCOLOR4UBVERTEX2FVSUNPROC glColor4ubVertex2fvSUN; +PFNGLCOLOR4UBVERTEX3FSUNPROC glColor4ubVertex3fSUN; +PFNGLCOLOR4UBVERTEX3FVSUNPROC glColor4ubVertex3fvSUN; +PFNGLCOLOR3FVERTEX3FSUNPROC glColor3fVertex3fSUN; +PFNGLCOLOR3FVERTEX3FVSUNPROC glColor3fVertex3fvSUN; +PFNGLNORMAL3FVERTEX3FSUNPROC glNormal3fVertex3fSUN; +PFNGLNORMAL3FVERTEX3FVSUNPROC glNormal3fVertex3fvSUN; +PFNGLCOLOR4FNORMAL3FVERTEX3FSUNPROC glColor4fNormal3fVertex3fSUN; +PFNGLCOLOR4FNORMAL3FVERTEX3FVSUNPROC glColor4fNormal3fVertex3fvSUN; +PFNGLTEXCOORD2FVERTEX3FSUNPROC glTexCoord2fVertex3fSUN; +PFNGLTEXCOORD2FVERTEX3FVSUNPROC glTexCoord2fVertex3fvSUN; +PFNGLTEXCOORD4FVERTEX4FSUNPROC glTexCoord4fVertex4fSUN; +PFNGLTEXCOORD4FVERTEX4FVSUNPROC glTexCoord4fVertex4fvSUN; +PFNGLTEXCOORD2FCOLOR4UBVERTEX3FSUNPROC glTexCoord2fColor4ubVertex3fSUN; +PFNGLTEXCOORD2FCOLOR4UBVERTEX3FVSUNPROC glTexCoord2fColor4ubVertex3fvSUN; +PFNGLTEXCOORD2FCOLOR3FVERTEX3FSUNPROC glTexCoord2fColor3fVertex3fSUN; +PFNGLTEXCOORD2FCOLOR3FVERTEX3FVSUNPROC glTexCoord2fColor3fVertex3fvSUN; +PFNGLTEXCOORD2FNORMAL3FVERTEX3FSUNPROC glTexCoord2fNormal3fVertex3fSUN; +PFNGLTEXCOORD2FNORMAL3FVERTEX3FVSUNPROC glTexCoord2fNormal3fVertex3fvSUN; +PFNGLTEXCOORD2FCOLOR4FNORMAL3FVERTEX3FSUNPROC glTexCoord2fColor4fNormal3fVertex3fSUN; +PFNGLTEXCOORD2FCOLOR4FNORMAL3FVERTEX3FVSUNPROC glTexCoord2fColor4fNormal3fVertex3fvSUN; +PFNGLTEXCOORD4FCOLOR4FNORMAL3FVERTEX4FSUNPROC glTexCoord4fColor4fNormal3fVertex4fSUN; +PFNGLTEXCOORD4FCOLOR4FNORMAL3FVERTEX4FVSUNPROC glTexCoord4fColor4fNormal3fVertex4fvSUN; +PFNGLREPLACEMENTCODEUIVERTEX3FSUNPROC glReplacementCodeuiVertex3fSUN; +PFNGLREPLACEMENTCODEUIVERTEX3FVSUNPROC glReplacementCodeuiVertex3fvSUN; +PFNGLREPLACEMENTCODEUICOLOR4UBVERTEX3FSUNPROC glReplacementCodeuiColor4ubVertex3fSUN; +PFNGLREPLACEMENTCODEUICOLOR4UBVERTEX3FVSUNPROC glReplacementCodeuiColor4ubVertex3fvSUN; +PFNGLREPLACEMENTCODEUICOLOR3FVERTEX3FSUNPROC glReplacementCodeuiColor3fVertex3fSUN; +PFNGLREPLACEMENTCODEUICOLOR3FVERTEX3FVSUNPROC glReplacementCodeuiColor3fVertex3fvSUN; +PFNGLREPLACEMENTCODEUINORMAL3FVERTEX3FSUNPROC glReplacementCodeuiNormal3fVertex3fSUN; +PFNGLREPLACEMENTCODEUINORMAL3FVERTEX3FVSUNPROC glReplacementCodeuiNormal3fVertex3fvSUN; +PFNGLREPLACEMENTCODEUICOLOR4FNORMAL3FVERTEX3FSUNPROC glReplacementCodeuiColor4fNormal3fVertex3fSUN; +PFNGLREPLACEMENTCODEUICOLOR4FNORMAL3FVERTEX3FVSUNPROC glReplacementCodeuiColor4fNormal3fVertex3fvSUN; +PFNGLREPLACEMENTCODEUITEXCOORD2FVERTEX3FSUNPROC glReplacementCodeuiTexCoord2fVertex3fSUN; +PFNGLREPLACEMENTCODEUITEXCOORD2FVERTEX3FVSUNPROC glReplacementCodeuiTexCoord2fVertex3fvSUN; +PFNGLREPLACEMENTCODEUITEXCOORD2FNORMAL3FVERTEX3FSUNPROC glReplacementCodeuiTexCoord2fNormal3fVertex3fSUN; +PFNGLREPLACEMENTCODEUITEXCOORD2FNORMAL3FVERTEX3FVSUNPROC glReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN; +PFNGLREPLACEMENTCODEUITEXCOORD2FCOLOR4FNORMAL3FVERTEX3FSUNPROC glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fSUN; +PFNGLREPLACEMENTCODEUITEXCOORD2FCOLOR4FNORMAL3FVERTEX3FVSUNPROC glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN; +#endif + +#if defined(GL_EXT_blend_func_separate) +PFNGLBLENDFUNCSEPARATEEXTPROC glBlendFuncSeparateEXT; +#endif + +#if defined(GL_INGR_color_clamp) +#endif + +#if defined(GL_INGR_interlace_read) +#endif + +#if defined(GL_EXT_stencil_wrap) +#endif + +#if defined(GL_EXT_422_pixels) +#endif + +#if defined(GL_NV_texgen_reflection) +#endif + +#if defined(GL_SUN_convolution_border_modes) +#endif + +#if defined(GL_EXT_texture_env_add) +#endif + +#if defined(GL_EXT_texture_lod_bias) +#endif + +#if defined(GL_EXT_texture_filter_anisotropic) +#endif + +#if defined(GL_EXT_vertex_weighting) +PFNGLVERTEXWEIGHTFEXTPROC glVertexWeightfEXT; +PFNGLVERTEXWEIGHTFVEXTPROC glVertexWeightfvEXT; +PFNGLVERTEXWEIGHTPOINTEREXTPROC glVertexWeightPointerEXT; +#endif + +#if defined(GL_NV_light_max_exponent) +#endif + +#if defined(GL_NV_vertex_array_range) +PFNGLFLUSHVERTEXARRAYRANGENVPROC glFlushVertexArrayRangeNV; +PFNGLVERTEXARRAYRANGENVPROC glVertexArrayRangeNV; +#endif + +#if defined(GL_NV_register_combiners) +PFNGLCOMBINERPARAMETERFVNVPROC glCombinerParameterfvNV; +PFNGLCOMBINERPARAMETERFNVPROC glCombinerParameterfNV; +PFNGLCOMBINERPARAMETERIVNVPROC glCombinerParameterivNV; +PFNGLCOMBINERPARAMETERINVPROC glCombinerParameteriNV; +PFNGLCOMBINERINPUTNVPROC glCombinerInputNV; +PFNGLCOMBINEROUTPUTNVPROC glCombinerOutputNV; +PFNGLFINALCOMBINERINPUTNVPROC glFinalCombinerInputNV; +PFNGLGETCOMBINERINPUTPARAMETERFVNVPROC glGetCombinerInputParameterfvNV; +PFNGLGETCOMBINERINPUTPARAMETERIVNVPROC glGetCombinerInputParameterivNV; +PFNGLGETCOMBINEROUTPUTPARAMETERFVNVPROC glGetCombinerOutputParameterfvNV; +PFNGLGETCOMBINEROUTPUTPARAMETERIVNVPROC glGetCombinerOutputParameterivNV; +PFNGLGETFINALCOMBINERINPUTPARAMETERFVNVPROC glGetFinalCombinerInputParameterfvNV; +PFNGLGETFINALCOMBINERINPUTPARAMETERIVNVPROC glGetFinalCombinerInputParameterivNV; +#endif + +#if defined(GL_NV_fog_distance) +#endif + +#if defined(GL_NV_texgen_emboss) +#endif + +#if defined(GL_NV_blend_square) +#endif + +#if defined(GL_NV_texture_env_combine4) +#endif + +#if defined(GL_MESA_resize_buffers) +PFNGLRESIZEBUFFERSMESAPROC glResizeBuffersMESA; +#endif + +#if defined(GL_MESA_window_pos) +PFNGLWINDOWPOS2DMESAPROC glWindowPos2dMESA; +PFNGLWINDOWPOS2DVMESAPROC glWindowPos2dvMESA; +PFNGLWINDOWPOS2FMESAPROC glWindowPos2fMESA; +PFNGLWINDOWPOS2FVMESAPROC glWindowPos2fvMESA; +PFNGLWINDOWPOS2IMESAPROC glWindowPos2iMESA; +PFNGLWINDOWPOS2IVMESAPROC glWindowPos2ivMESA; +PFNGLWINDOWPOS2SMESAPROC glWindowPos2sMESA; +PFNGLWINDOWPOS2SVMESAPROC glWindowPos2svMESA; +PFNGLWINDOWPOS3DMESAPROC glWindowPos3dMESA; +PFNGLWINDOWPOS3DVMESAPROC glWindowPos3dvMESA; +PFNGLWINDOWPOS3FMESAPROC glWindowPos3fMESA; +PFNGLWINDOWPOS3FVMESAPROC glWindowPos3fvMESA; +PFNGLWINDOWPOS3IMESAPROC glWindowPos3iMESA; +PFNGLWINDOWPOS3IVMESAPROC glWindowPos3ivMESA; +PFNGLWINDOWPOS3SMESAPROC glWindowPos3sMESA; +PFNGLWINDOWPOS3SVMESAPROC glWindowPos3svMESA; +PFNGLWINDOWPOS4DMESAPROC glWindowPos4dMESA; +PFNGLWINDOWPOS4DVMESAPROC glWindowPos4dvMESA; +PFNGLWINDOWPOS4FMESAPROC glWindowPos4fMESA; +PFNGLWINDOWPOS4FVMESAPROC glWindowPos4fvMESA; +PFNGLWINDOWPOS4IMESAPROC glWindowPos4iMESA; +PFNGLWINDOWPOS4IVMESAPROC glWindowPos4ivMESA; +PFNGLWINDOWPOS4SMESAPROC glWindowPos4sMESA; +PFNGLWINDOWPOS4SVMESAPROC glWindowPos4svMESA; +#endif + +#if defined(GL_IBM_cull_vertex) +#endif + +#if defined(GL_IBM_multimode_draw_arrays) +PFNGLMULTIMODEDRAWARRAYSIBMPROC glMultiModeDrawArraysIBM; +PFNGLMULTIMODEDRAWELEMENTSIBMPROC glMultiModeDrawElementsIBM; +#endif + +#if defined(GL_IBM_vertex_array_lists) +PFNGLCOLORPOINTERLISTIBMPROC glColorPointerListIBM; +PFNGLSECONDARYCOLORPOINTERLISTIBMPROC glSecondaryColorPointerListIBM; +PFNGLEDGEFLAGPOINTERLISTIBMPROC glEdgeFlagPointerListIBM; +PFNGLFOGCOORDPOINTERLISTIBMPROC glFogCoordPointerListIBM; +PFNGLINDEXPOINTERLISTIBMPROC glIndexPointerListIBM; +PFNGLNORMALPOINTERLISTIBMPROC glNormalPointerListIBM; +PFNGLTEXCOORDPOINTERLISTIBMPROC glTexCoordPointerListIBM; +PFNGLVERTEXPOINTERLISTIBMPROC glVertexPointerListIBM; +#endif + +#if defined(GL_3DFX_texture_compression_FXT1) +#endif + +#if defined(GL_3DFX_multisample) +#endif + +#if defined(GL_3DFX_tbuffer) +PFNGLTBUFFERMASK3DFXPROC glTbufferMask3DFX; +#endif + +#if defined(GL_SGIX_vertex_preclip) +#endif + +#if defined(GL_SGIX_resample) +#endif + +#if defined(GL_SGIS_texture_color_mask) +PFNGLTEXTURECOLORMASKSGISPROC glTextureColorMaskSGIS; +#endif + +#if defined(GL_EXT_texture_env_dot3) +#endif + +#if defined(GL_ATI_texture_mirror_once) +#endif + +#if defined(GL_NV_fence) +PFNGLDELETEFENCESNVPROC glDeleteFencesNV; +PFNGLGENFENCESNVPROC glGenFencesNV; +PFNGLISFENCENVPROC glIsFenceNV; +PFNGLTESTFENCENVPROC glTestFenceNV; +PFNGLGETFENCEIVNVPROC glGetFenceivNV; +PFNGLFINISHFENCENVPROC glFinishFenceNV; +PFNGLSETFENCENVPROC glSetFenceNV; +#endif + +#if defined(GL_NV_evaluators) +PFNGLMAPCONTROLPOINTSNVPROC glMapControlPointsNV; +PFNGLMAPPARAMETERIVNVPROC glMapParameterivNV; +PFNGLMAPPARAMETERFVNVPROC glMapParameterfvNV; +PFNGLGETMAPCONTROLPOINTSNVPROC glGetMapControlPointsNV; +PFNGLGETMAPPARAMETERIVNVPROC glGetMapParameterivNV; +PFNGLGETMAPPARAMETERFVNVPROC glGetMapParameterfvNV; +PFNGLGETMAPATTRIBPARAMETERIVNVPROC glGetMapAttribParameterivNV; +PFNGLGETMAPATTRIBPARAMETERFVNVPROC glGetMapAttribParameterfvNV; +PFNGLEVALMAPSNVPROC glEvalMapsNV; +#endif + +#if defined(GL_NV_packed_depth_stencil) +#endif + +#if defined(GL_NV_register_combiners2) +PFNGLCOMBINERSTAGEPARAMETERFVNVPROC glCombinerStageParameterfvNV; +PFNGLGETCOMBINERSTAGEPARAMETERFVNVPROC glGetCombinerStageParameterfvNV; +#endif + +#if defined(GL_NV_texture_compression_vtc) +#endif + +#if defined(GL_NV_texture_rectangle) +#endif + +#if defined(GL_NV_texture_shader) +#endif + +#if defined(GL_NV_texture_shader2) +#endif + +#if defined(GL_NV_vertex_array_range2) +#endif + +#if defined(GL_NV_vertex_program) +PFNGLAREPROGRAMSRESIDENTNVPROC glAreProgramsResidentNV; +PFNGLBINDPROGRAMNVPROC glBindProgramNV; +PFNGLDELETEPROGRAMSNVPROC glDeleteProgramsNV; +PFNGLEXECUTEPROGRAMNVPROC glExecuteProgramNV; +PFNGLGENPROGRAMSNVPROC glGenProgramsNV; +PFNGLGETPROGRAMPARAMETERDVNVPROC glGetProgramParameterdvNV; +PFNGLGETPROGRAMPARAMETERFVNVPROC glGetProgramParameterfvNV; +PFNGLGETPROGRAMIVNVPROC glGetProgramivNV; +PFNGLGETPROGRAMSTRINGNVPROC glGetProgramStringNV; +PFNGLGETTRACKMATRIXIVNVPROC glGetTrackMatrixivNV; +PFNGLGETVERTEXATTRIBDVNVPROC glGetVertexAttribdvNV; +PFNGLGETVERTEXATTRIBFVNVPROC glGetVertexAttribfvNV; +PFNGLGETVERTEXATTRIBIVNVPROC glGetVertexAttribivNV; +PFNGLGETVERTEXATTRIBPOINTERVNVPROC glGetVertexAttribPointervNV; +PFNGLISPROGRAMNVPROC glIsProgramNV; +PFNGLLOADPROGRAMNVPROC glLoadProgramNV; +PFNGLPROGRAMPARAMETER4DNVPROC glProgramParameter4dNV; +PFNGLPROGRAMPARAMETER4DVNVPROC glProgramParameter4dvNV; +PFNGLPROGRAMPARAMETER4FNVPROC glProgramParameter4fNV; +PFNGLPROGRAMPARAMETER4FVNVPROC glProgramParameter4fvNV; +PFNGLPROGRAMPARAMETERS4DVNVPROC glProgramParameters4dvNV; +PFNGLPROGRAMPARAMETERS4FVNVPROC glProgramParameters4fvNV; +PFNGLREQUESTRESIDENTPROGRAMSNVPROC glRequestResidentProgramsNV; +PFNGLTRACKMATRIXNVPROC glTrackMatrixNV; +PFNGLVERTEXATTRIBPOINTERNVPROC glVertexAttribPointerNV; +PFNGLVERTEXATTRIB1DNVPROC glVertexAttrib1dNV; +PFNGLVERTEXATTRIB1DVNVPROC glVertexAttrib1dvNV; +PFNGLVERTEXATTRIB1FNVPROC glVertexAttrib1fNV; +PFNGLVERTEXATTRIB1FVNVPROC glVertexAttrib1fvNV; +PFNGLVERTEXATTRIB1SNVPROC glVertexAttrib1sNV; +PFNGLVERTEXATTRIB1SVNVPROC glVertexAttrib1svNV; +PFNGLVERTEXATTRIB2DNVPROC glVertexAttrib2dNV; +PFNGLVERTEXATTRIB2DVNVPROC glVertexAttrib2dvNV; +PFNGLVERTEXATTRIB2FNVPROC glVertexAttrib2fNV; +PFNGLVERTEXATTRIB2FVNVPROC glVertexAttrib2fvNV; +PFNGLVERTEXATTRIB2SNVPROC glVertexAttrib2sNV; +PFNGLVERTEXATTRIB2SVNVPROC glVertexAttrib2svNV; +PFNGLVERTEXATTRIB3DNVPROC glVertexAttrib3dNV; +PFNGLVERTEXATTRIB3DVNVPROC glVertexAttrib3dvNV; +PFNGLVERTEXATTRIB3FNVPROC glVertexAttrib3fNV; +PFNGLVERTEXATTRIB3FVNVPROC glVertexAttrib3fvNV; +PFNGLVERTEXATTRIB3SNVPROC glVertexAttrib3sNV; +PFNGLVERTEXATTRIB3SVNVPROC glVertexAttrib3svNV; +PFNGLVERTEXATTRIB4DNVPROC glVertexAttrib4dNV; +PFNGLVERTEXATTRIB4DVNVPROC glVertexAttrib4dvNV; +PFNGLVERTEXATTRIB4FNVPROC glVertexAttrib4fNV; +PFNGLVERTEXATTRIB4FVNVPROC glVertexAttrib4fvNV; +PFNGLVERTEXATTRIB4SNVPROC glVertexAttrib4sNV; +PFNGLVERTEXATTRIB4SVNVPROC glVertexAttrib4svNV; +PFNGLVERTEXATTRIB4UBNVPROC glVertexAttrib4ubNV; +PFNGLVERTEXATTRIB4UBVNVPROC glVertexAttrib4ubvNV; +PFNGLVERTEXATTRIBS1DVNVPROC glVertexAttribs1dvNV; +PFNGLVERTEXATTRIBS1FVNVPROC glVertexAttribs1fvNV; +PFNGLVERTEXATTRIBS1SVNVPROC glVertexAttribs1svNV; +PFNGLVERTEXATTRIBS2DVNVPROC glVertexAttribs2dvNV; +PFNGLVERTEXATTRIBS2FVNVPROC glVertexAttribs2fvNV; +PFNGLVERTEXATTRIBS2SVNVPROC glVertexAttribs2svNV; +PFNGLVERTEXATTRIBS3DVNVPROC glVertexAttribs3dvNV; +PFNGLVERTEXATTRIBS3FVNVPROC glVertexAttribs3fvNV; +PFNGLVERTEXATTRIBS3SVNVPROC glVertexAttribs3svNV; +PFNGLVERTEXATTRIBS4DVNVPROC glVertexAttribs4dvNV; +PFNGLVERTEXATTRIBS4FVNVPROC glVertexAttribs4fvNV; +PFNGLVERTEXATTRIBS4SVNVPROC glVertexAttribs4svNV; +PFNGLVERTEXATTRIBS4UBVNVPROC glVertexAttribs4ubvNV; +#endif + +#if defined(GL_SGIX_texture_coordinate_clamp) +#endif + +#if defined(GL_OML_interlace) +#endif + +#if defined(GL_OML_subsample) +#endif + +#if defined(GL_OML_resample) +#endif + +#if defined(GL_NV_copy_depth_to_color) +#endif + +#if defined(GL_ATI_envmap_bumpmap) +PFNGLTEXBUMPPARAMETERIVATIPROC glTexBumpParameterivATI; +PFNGLTEXBUMPPARAMETERFVATIPROC glTexBumpParameterfvATI; +PFNGLGETTEXBUMPPARAMETERIVATIPROC glGetTexBumpParameterivATI; +PFNGLGETTEXBUMPPARAMETERFVATIPROC glGetTexBumpParameterfvATI; +#endif + +#if defined(GL_ATI_fragment_shader) +PFNGLGENFRAGMENTSHADERSATIPROC glGenFragmentShadersATI; +PFNGLBINDFRAGMENTSHADERATIPROC glBindFragmentShaderATI; +PFNGLDELETEFRAGMENTSHADERATIPROC glDeleteFragmentShaderATI; +PFNGLBEGINFRAGMENTSHADERATIPROC glBeginFragmentShaderATI; +PFNGLENDFRAGMENTSHADERATIPROC glEndFragmentShaderATI; +PFNGLPASSTEXCOORDATIPROC glPassTexCoordATI; +PFNGLSAMPLEMAPATIPROC glSampleMapATI; +PFNGLCOLORFRAGMENTOP1ATIPROC glColorFragmentOp1ATI; +PFNGLCOLORFRAGMENTOP2ATIPROC glColorFragmentOp2ATI; +PFNGLCOLORFRAGMENTOP3ATIPROC glColorFragmentOp3ATI; +PFNGLALPHAFRAGMENTOP1ATIPROC glAlphaFragmentOp1ATI; +PFNGLALPHAFRAGMENTOP2ATIPROC glAlphaFragmentOp2ATI; +PFNGLALPHAFRAGMENTOP3ATIPROC glAlphaFragmentOp3ATI; +PFNGLSETFRAGMENTSHADERCONSTANTATIPROC glSetFragmentShaderConstantATI; +#endif + +#if defined(GL_ATI_pn_triangles) +#endif + +#if defined(GL_ATI_vertex_array_object) && 0 +PFNGLNEWOBJECTBUFFERATIPROC glNewObjectBufferATI; +PFNGLISOBJECTBUFFERATIPROC glIsObjectBufferATI; +PFNGLUPDATEOBJECTBUFFERATIPROC glUpdateObjectBufferATI; +PFNGLGETOBJECTBUFFERFVATIPROC glGetObjectBufferfvATI; +PFNGLGETOBJECTBUFFERIVATIPROC glGetObjectBufferivATI; +/* glDeleteObjectBufferATI became glFreeObjectBufferATI in GL_ATI_vertex_array_object v1.1 */ +PFNGLFREEOBJECTBUFFERATIPROC glFreeObjectBufferATI; +PFNGLARRAYOBJECTATIPROC glArrayObjectATI; +PFNGLGETARRAYOBJECTFVATIPROC glGetArrayObjectfvATI; +PFNGLGETARRAYOBJECTIVATIPROC glGetArrayObjectivATI; +PFNGLVARIANTARRAYOBJECTATIPROC glVariantArrayObjectATI; +PFNGLGETVARIANTARRAYOBJECTFVATIPROC glGetVariantArrayObjectfvATI; +PFNGLGETVARIANTARRAYOBJECTIVATIPROC glGetVariantArrayObjectivATI; +#endif + +#if defined(GL_EXT_vertex_shader) +PFNGLBEGINVERTEXSHADEREXTPROC glBeginVertexShaderEXT; +PFNGLENDVERTEXSHADEREXTPROC glEndVertexShaderEXT; +PFNGLBINDVERTEXSHADEREXTPROC glBindVertexShaderEXT; +PFNGLGENVERTEXSHADERSEXTPROC glGenVertexShadersEXT; +PFNGLDELETEVERTEXSHADEREXTPROC glDeleteVertexShaderEXT; +PFNGLSHADEROP1EXTPROC glShaderOp1EXT; +PFNGLSHADEROP2EXTPROC glShaderOp2EXT; +PFNGLSHADEROP3EXTPROC glShaderOp3EXT; +PFNGLSWIZZLEEXTPROC glSwizzleEXT; +PFNGLWRITEMASKEXTPROC glWriteMaskEXT; +PFNGLINSERTCOMPONENTEXTPROC glInsertComponentEXT; +PFNGLEXTRACTCOMPONENTEXTPROC glExtractComponentEXT; +PFNGLGENSYMBOLSEXTPROC glGenSymbolsEXT; +PFNGLSETINVARIANTEXTPROC glSetInvariantEXT; +PFNGLSETLOCALCONSTANTEXTPROC glSetLocalConstantEXT; +PFNGLVARIANTBVEXTPROC glVariantbvEXT; +PFNGLVARIANTSVEXTPROC glVariantsvEXT; +PFNGLVARIANTIVEXTPROC glVariantivEXT; +PFNGLVARIANTFVEXTPROC glVariantfvEXT; +PFNGLVARIANTDVEXTPROC glVariantdvEXT; +PFNGLVARIANTUBVEXTPROC glVariantubvEXT; +PFNGLVARIANTUSVEXTPROC glVariantusvEXT; +PFNGLVARIANTUIVEXTPROC glVariantuivEXT; +PFNGLVARIANTPOINTEREXTPROC glVariantPointerEXT; +PFNGLENABLEVARIANTCLIENTSTATEEXTPROC glEnableVariantClientStateEXT; +PFNGLDISABLEVARIANTCLIENTSTATEEXTPROC glDisableVariantClientStateEXT; +PFNGLBINDLIGHTPARAMETEREXTPROC glBindLightParameterEXT; +PFNGLBINDMATERIALPARAMETEREXTPROC glBindMaterialParameterEXT; +PFNGLBINDTEXGENPARAMETEREXTPROC glBindTexGenParameterEXT; +PFNGLBINDTEXTUREUNITPARAMETEREXTPROC glBindTextureUnitParameterEXT; +PFNGLBINDPARAMETEREXTPROC glBindParameterEXT; +PFNGLISVARIANTENABLEDEXTPROC glIsVariantEnabledEXT; +PFNGLGETVARIANTBOOLEANVEXTPROC glGetVariantBooleanvEXT; +PFNGLGETVARIANTINTEGERVEXTPROC glGetVariantIntegervEXT; +PFNGLGETVARIANTFLOATVEXTPROC glGetVariantFloatvEXT; +PFNGLGETVARIANTPOINTERVEXTPROC glGetVariantPointervEXT; +PFNGLGETINVARIANTBOOLEANVEXTPROC glGetInvariantBooleanvEXT; +PFNGLGETINVARIANTINTEGERVEXTPROC glGetInvariantIntegervEXT; +PFNGLGETINVARIANTFLOATVEXTPROC glGetInvariantFloatvEXT; +PFNGLGETLOCALCONSTANTBOOLEANVEXTPROC glGetLocalConstantBooleanvEXT; +PFNGLGETLOCALCONSTANTINTEGERVEXTPROC glGetLocalConstantIntegervEXT; +PFNGLGETLOCALCONSTANTFLOATVEXTPROC glGetLocalConstantFloatvEXT; +#endif + +#if defined(GL_ATI_vertex_streams) +PFNGLVERTEXSTREAM1SATIPROC glVertexStream1sATI; +PFNGLVERTEXSTREAM1SVATIPROC glVertexStream1svATI; +PFNGLVERTEXSTREAM1IATIPROC glVertexStream1iATI; +PFNGLVERTEXSTREAM1IVATIPROC glVertexStream1ivATI; +PFNGLVERTEXSTREAM1FATIPROC glVertexStream1fATI; +PFNGLVERTEXSTREAM1FVATIPROC glVertexStream1fvATI; +PFNGLVERTEXSTREAM1DATIPROC glVertexStream1dATI; +PFNGLVERTEXSTREAM1DVATIPROC glVertexStream1dvATI; +PFNGLVERTEXSTREAM2SATIPROC glVertexStream2sATI; +PFNGLVERTEXSTREAM2SVATIPROC glVertexStream2svATI; +PFNGLVERTEXSTREAM2IATIPROC glVertexStream2iATI; +PFNGLVERTEXSTREAM2IVATIPROC glVertexStream2ivATI; +PFNGLVERTEXSTREAM2FATIPROC glVertexStream2fATI; +PFNGLVERTEXSTREAM2FVATIPROC glVertexStream2fvATI; +PFNGLVERTEXSTREAM2DATIPROC glVertexStream2dATI; +PFNGLVERTEXSTREAM2DVATIPROC glVertexStream2dvATI; +PFNGLVERTEXSTREAM3SATIPROC glVertexStream3sATI; +PFNGLVERTEXSTREAM3SVATIPROC glVertexStream3svATI; +PFNGLVERTEXSTREAM3IATIPROC glVertexStream3iATI; +PFNGLVERTEXSTREAM3IVATIPROC glVertexStream3ivATI; +PFNGLVERTEXSTREAM3FATIPROC glVertexStream3fATI; +PFNGLVERTEXSTREAM3FVATIPROC glVertexStream3fvATI; +PFNGLVERTEXSTREAM3DATIPROC glVertexStream3dATI; +PFNGLVERTEXSTREAM3DVATIPROC glVertexStream3dvATI; +PFNGLVERTEXSTREAM4SATIPROC glVertexStream4sATI; +PFNGLVERTEXSTREAM4SVATIPROC glVertexStream4svATI; +PFNGLVERTEXSTREAM4IATIPROC glVertexStream4iATI; +PFNGLVERTEXSTREAM4IVATIPROC glVertexStream4ivATI; +PFNGLVERTEXSTREAM4FATIPROC glVertexStream4fATI; +PFNGLVERTEXSTREAM4FVATIPROC glVertexStream4fvATI; +PFNGLVERTEXSTREAM4DATIPROC glVertexStream4dATI; +PFNGLVERTEXSTREAM4DVATIPROC glVertexStream4dvATI; +PFNGLNORMALSTREAM3BATIPROC glNormalStream3bATI; +PFNGLNORMALSTREAM3BVATIPROC glNormalStream3bvATI; +PFNGLNORMALSTREAM3SATIPROC glNormalStream3sATI; +PFNGLNORMALSTREAM3SVATIPROC glNormalStream3svATI; +PFNGLNORMALSTREAM3IATIPROC glNormalStream3iATI; +PFNGLNORMALSTREAM3IVATIPROC glNormalStream3ivATI; +PFNGLNORMALSTREAM3FATIPROC glNormalStream3fATI; +PFNGLNORMALSTREAM3FVATIPROC glNormalStream3fvATI; +PFNGLNORMALSTREAM3DATIPROC glNormalStream3dATI; +PFNGLNORMALSTREAM3DVATIPROC glNormalStream3dvATI; +PFNGLCLIENTACTIVEVERTEXSTREAMATIPROC glClientActiveVertexStreamATI; +PFNGLVERTEXBLENDENVIATIPROC glVertexBlendEnviATI; +PFNGLVERTEXBLENDENVFATIPROC glVertexBlendEnvfATI; +#endif + +#if defined(GL_ATI_element_array) +PFNGLELEMENTPOINTERATIPROC glElementPointerATI; +PFNGLDRAWELEMENTARRAYATIPROC glDrawElementArrayATI; +PFNGLDRAWRANGEELEMENTARRAYATIPROC glDrawRangeElementArrayATI; +#endif + +#if defined(GL_SUN_mesh_array) +PFNGLDRAWMESHARRAYSSUNPROC glDrawMeshArraysSUN; +#endif + +#if defined(GL_SUN_slice_accum) +#endif + +#if defined(GL_NV_multisample_filter_hint) +#endif + +#if defined(GL_NV_depth_clamp) +#endif + +#if defined(GL_NV_occlusion_query) +PFNGLGENOCCLUSIONQUERIESNVPROC glGenOcclusionQueriesNV; +PFNGLDELETEOCCLUSIONQUERIESNVPROC glDeleteOcclusionQueriesNV; +PFNGLISOCCLUSIONQUERYNVPROC glIsOcclusionQueryNV; +PFNGLBEGINOCCLUSIONQUERYNVPROC glBeginOcclusionQueryNV; +PFNGLENDOCCLUSIONQUERYNVPROC glEndOcclusionQueryNV; +PFNGLGETOCCLUSIONQUERYIVNVPROC glGetOcclusionQueryivNV; +PFNGLGETOCCLUSIONQUERYUIVNVPROC glGetOcclusionQueryuivNV; +#endif + +#if defined(GL_NV_point_sprite) +PFNGLPOINTPARAMETERINVPROC glPointParameteriNV; +PFNGLPOINTPARAMETERIVNVPROC glPointParameterivNV; +#endif + +#if defined(GL_NV_texture_shader3) +#endif + +#if defined(GL_NV_vertex_program1_1) +#endif + +#if defined(GL_EXT_shadow_funcs) +#endif + +#if defined(GL_EXT_stencil_two_side) +PFNGLACTIVESTENCILFACEEXTPROC glActiveStencilFaceEXT; +#endif + +#if defined(GL_ATI_text_fragment_shader) +#endif + +#if defined(GL_APPLE_client_storage) +#endif + +#if defined(GL_APPLE_element_array) +PFNGLELEMENTPOINTERAPPLEPROC glElementPointerAPPLE; +PFNGLDRAWELEMENTARRAYAPPLEPROC glDrawElementArrayAPPLE; +PFNGLDRAWRANGEELEMENTARRAYAPPLEPROC glDrawRangeElementArrayAPPLE; +PFNGLMULTIDRAWELEMENTARRAYAPPLEPROC glMultiDrawElementArrayAPPLE; +PFNGLMULTIDRAWRANGEELEMENTARRAYAPPLEPROC glMultiDrawRangeElementArrayAPPLE; +#endif + +#if defined(GL_APPLE_fence) +PFNGLGENFENCESAPPLEPROC glGenFencesAPPLE; +PFNGLDELETEFENCESAPPLEPROC glDeleteFencesAPPLE; +PFNGLSETFENCEAPPLEPROC glSetFenceAPPLE; +PFNGLISFENCEAPPLEPROC glIsFenceAPPLE; +PFNGLTESTFENCEAPPLEPROC glTestFenceAPPLE; +PFNGLFINISHFENCEAPPLEPROC glFinishFenceAPPLE; +PFNGLTESTOBJECTAPPLEPROC glTestObjectAPPLE; +PFNGLFINISHOBJECTAPPLEPROC glFinishObjectAPPLE; +#endif + +#if defined(GL_APPLE_vertex_array_object) +PFNGLBINDVERTEXARRAYAPPLEPROC glBindVertexArrayAPPLE; +PFNGLDELETEVERTEXARRAYSAPPLEPROC glDeleteVertexArraysAPPLE; +PFNGLGENVERTEXARRAYSAPPLEPROC glGenVertexArraysAPPLE; +PFNGLISVERTEXARRAYAPPLEPROC glIsVertexArrayAPPLE; +#endif + +#if defined(GL_APPLE_vertex_array_range) +PFNGLVERTEXARRAYRANGEAPPLEPROC glVertexArrayRangeAPPLE; +PFNGLFLUSHVERTEXARRAYRANGEAPPLEPROC glFlushVertexArrayRangeAPPLE; +PFNGLVERTEXARRAYPARAMETERIAPPLEPROC glVertexArrayParameteriAPPLE; +#endif + +#if defined(GL_APPLE_ycbcr_422) +#endif + +#if defined(GL_S3_s3tc) +#endif + +#if defined(GL_ATI_draw_buffers) +PFNGLDRAWBUFFERSATIPROC glDrawBuffersATI; +#endif + +#if defined(GL_ATI_texture_env_combine3) +#endif + +#if defined(GL_ATI_texture_float) +#endif + +#if defined(GL_NV_float_buffer) +#endif + +#if defined(GL_NV_fragment_program) +PFNGLPROGRAMNAMEDPARAMETER4FNVPROC glProgramNamedParameter4fNV; +PFNGLPROGRAMNAMEDPARAMETER4DNVPROC glProgramNamedParameter4dNV; +PFNGLPROGRAMNAMEDPARAMETER4FVNVPROC glProgramNamedParameter4fvNV; +PFNGLPROGRAMNAMEDPARAMETER4DVNVPROC glProgramNamedParameter4dvNV; +PFNGLGETPROGRAMNAMEDPARAMETERFVNVPROC glGetProgramNamedParameterfvNV; +PFNGLGETPROGRAMNAMEDPARAMETERDVNVPROC glGetProgramNamedParameterdvNV; +#endif + +#if defined(GL_NV_half_float) +PFNGLVERTEX2HNVPROC glVertex2hNV; +PFNGLVERTEX2HVNVPROC glVertex2hvNV; +PFNGLVERTEX3HNVPROC glVertex3hNV; +PFNGLVERTEX3HVNVPROC glVertex3hvNV; +PFNGLVERTEX4HNVPROC glVertex4hNV; +PFNGLVERTEX4HVNVPROC glVertex4hvNV; +PFNGLNORMAL3HNVPROC glNormal3hNV; +PFNGLNORMAL3HVNVPROC glNormal3hvNV; +PFNGLCOLOR3HNVPROC glColor3hNV; +PFNGLCOLOR3HVNVPROC glColor3hvNV; +PFNGLCOLOR4HNVPROC glColor4hNV; +PFNGLCOLOR4HVNVPROC glColor4hvNV; +PFNGLTEXCOORD1HNVPROC glTexCoord1hNV; +PFNGLTEXCOORD1HVNVPROC glTexCoord1hvNV; +PFNGLTEXCOORD2HNVPROC glTexCoord2hNV; +PFNGLTEXCOORD2HVNVPROC glTexCoord2hvNV; +PFNGLTEXCOORD3HNVPROC glTexCoord3hNV; +PFNGLTEXCOORD3HVNVPROC glTexCoord3hvNV; +PFNGLTEXCOORD4HNVPROC glTexCoord4hNV; +PFNGLTEXCOORD4HVNVPROC glTexCoord4hvNV; +PFNGLMULTITEXCOORD1HNVPROC glMultiTexCoord1hNV; +PFNGLMULTITEXCOORD1HVNVPROC glMultiTexCoord1hvNV; +PFNGLMULTITEXCOORD2HNVPROC glMultiTexCoord2hNV; +PFNGLMULTITEXCOORD2HVNVPROC glMultiTexCoord2hvNV; +PFNGLMULTITEXCOORD3HNVPROC glMultiTexCoord3hNV; +PFNGLMULTITEXCOORD3HVNVPROC glMultiTexCoord3hvNV; +PFNGLMULTITEXCOORD4HNVPROC glMultiTexCoord4hNV; +PFNGLMULTITEXCOORD4HVNVPROC glMultiTexCoord4hvNV; +PFNGLFOGCOORDHNVPROC glFogCoordhNV; +PFNGLFOGCOORDHVNVPROC glFogCoordhvNV; +PFNGLSECONDARYCOLOR3HNVPROC glSecondaryColor3hNV; +PFNGLSECONDARYCOLOR3HVNVPROC glSecondaryColor3hvNV; +PFNGLVERTEXWEIGHTHNVPROC glVertexWeighthNV; +PFNGLVERTEXWEIGHTHVNVPROC glVertexWeighthvNV; +PFNGLVERTEXATTRIB1HNVPROC glVertexAttrib1hNV; +PFNGLVERTEXATTRIB1HVNVPROC glVertexAttrib1hvNV; +PFNGLVERTEXATTRIB2HNVPROC glVertexAttrib2hNV; +PFNGLVERTEXATTRIB2HVNVPROC glVertexAttrib2hvNV; +PFNGLVERTEXATTRIB3HNVPROC glVertexAttrib3hNV; +PFNGLVERTEXATTRIB3HVNVPROC glVertexAttrib3hvNV; +PFNGLVERTEXATTRIB4HNVPROC glVertexAttrib4hNV; +PFNGLVERTEXATTRIB4HVNVPROC glVertexAttrib4hvNV; +PFNGLVERTEXATTRIBS1HVNVPROC glVertexAttribs1hvNV; +PFNGLVERTEXATTRIBS2HVNVPROC glVertexAttribs2hvNV; +PFNGLVERTEXATTRIBS3HVNVPROC glVertexAttribs3hvNV; +PFNGLVERTEXATTRIBS4HVNVPROC glVertexAttribs4hvNV; +#endif + +#if defined(GL_NV_pixel_data_range) +PFNGLPIXELDATARANGENVPROC glPixelDataRangeNV; +PFNGLFLUSHPIXELDATARANGENVPROC glFlushPixelDataRangeNV; +#endif + +#if defined(GL_NV_primitive_restart) +PFNGLPRIMITIVERESTARTNVPROC glPrimitiveRestartNV; +PFNGLPRIMITIVERESTARTINDEXNVPROC glPrimitiveRestartIndexNV; +#endif + +#if defined(GL_NV_texture_expand_normal) +#endif + +#if defined(GL_NV_vertex_program2) +#endif + +#if defined(GL_ATI_map_object_buffer) +PFNGLMAPOBJECTBUFFERATIPROC glMapObjectBufferATI; +PFNGLUNMAPOBJECTBUFFERATIPROC glUnmapObjectBufferATI; +#endif + +#if defined(GL_ATI_separate_stencil) +PFNGLSTENCILOPSEPARATEATIPROC glStencilOpSeparateATI; +PFNGLSTENCILFUNCSEPARATEATIPROC glStencilFuncSeparateATI; +#endif + +#if defined(GL_ATI_vertex_attrib_array_object) +PFNGLVERTEXATTRIBARRAYOBJECTATIPROC glVertexAttribArrayObjectATI; +PFNGLGETVERTEXATTRIBARRAYOBJECTFVATIPROC glGetVertexAttribArrayObjectfvATI; +PFNGLGETVERTEXATTRIBARRAYOBJECTIVATIPROC glGetVertexAttribArrayObjectivATI; +#endif + +#if defined(GL_EXT_depth_bounds_test) +PFNGLDEPTHBOUNDSEXTPROC glDepthBoundsEXT; +#endif + +#if defined(GL_EXT_texture_mirror_clamp) +#endif + +#if defined(GL_EXT_blend_equation_separate) +PFNGLBLENDEQUATIONSEPARATEEXTPROC glBlendEquationSeparateEXT; +#endif + +#if defined(GL_MESA_pack_invert) +#endif + +#if defined(GL_MESA_ycbcr_texture) +#endif + +/* End mkglext.py */ +}; + +using namespace RAS_GL; + +/******************************************************************************* +2. Query extension functions here + +Need to #ifdef (compile time test for extension) +Use QueryExtension("GL_EXT_name") to test at runtime. +Use bglGetProcAddress to find entry point +Use EnableExtension(_GL_EXT_...) to allow Blender to use the extension. + + ******************************************************************************/ +void RAS_GLExtensionManager::LinkExtensions() +{ + static bool doDebugMessages = true; + extensions = STR_String((const char *) glGetString(GL_EXTENSIONS)).Explode(' '); + + /* Generated from mkglext.py */ + +#ifdef GL_EXT_compiled_vertex_array + if (QueryExtension("GL_EXT_compiled_vertex_array")) + { + glUnlockArraysEXT = reinterpret_cast(bglGetProcAddress((const GLubyte *) "glUnlockArraysEXT")); + glLockArraysEXT = reinterpret_cast(bglGetProcAddress((const GLubyte *) "glLockArraysEXT")); + if (glUnlockArraysEXT && glLockArraysEXT) + { + EnableExtension(_GL_EXT_compiled_vertex_array); + if (m_debug && doDebugMessages) + std::cout << "Enabled GL_EXT_compiled_vertex_array" << std::endl; + } else { + glUnlockArraysEXT = _unlockfunc; + glLockArraysEXT = _lockfunc; + std::cout << "ERROR: GL_EXT_compiled_vertex_array implementation is broken!" << std::endl; + } + } +#endif + + if (QueryExtension("GL_ARB_multitexture")) + { + EnableExtension(_GL_ARB_multitexture); + if (m_debug && doDebugMessages) + std::cout << "Enabled GL_ARB_multitexture" << std::endl; + } + +#if defined(GL_ARB_transpose_matrix) + if (QueryExtension("GL_ARB_transpose_matrix")) + { + glLoadTransposeMatrixfARB = reinterpret_cast(bglGetProcAddress((const GLubyte *) "glLoadTransposeMatrixfARB")); + glLoadTransposeMatrixdARB = reinterpret_cast(bglGetProcAddress((const GLubyte *) "glLoadTransposeMatrixdARB")); + glMultTransposeMatrixfARB = reinterpret_cast(bglGetProcAddress((const GLubyte *) "glMultTransposeMatrixfARB")); + glMultTransposeMatrixdARB = reinterpret_cast(bglGetProcAddress((const GLubyte *) "glMultTransposeMatrixdARB")); + if (glLoadTransposeMatrixfARB && glLoadTransposeMatrixdARB && glMultTransposeMatrixfARB && glMultTransposeMatrixdARB) { + EnableExtension(_GL_ARB_transpose_matrix); + if (m_debug && doDebugMessages) + std::cout << "Enabled GL_ARB_transpose_matrix" << std::endl; + } else { + std::cout << "ERROR: GL_ARB_transpose_matrix implementation is broken!" << std::endl; + } + } +#endif + +#if defined(GL_ARB_multisample) + if (QueryExtension("GL_ARB_multisample")) + { + glSampleCoverageARB = reinterpret_cast(bglGetProcAddress((const GLubyte *) "glSampleCoverageARB")); + if (glSampleCoverageARB) { + EnableExtension(_GL_ARB_multisample); + if (m_debug && doDebugMessages) + std::cout << "Enabled GL_ARB_multisample" << std::endl; + } else { + std::cout << "ERROR: GL_ARB_multisample implementation is broken!" << std::endl; + } + } +#endif + + if (QueryExtension("GL_ARB_texture_env_add")) + { + EnableExtension(_GL_ARB_texture_env_add); + if (m_debug && doDebugMessages) + std::cout << "Enabled GL_ARB_texture_env_add" << std::endl; + } + + if (QueryExtension("GL_ARB_texture_cube_map")) + { + EnableExtension(_GL_ARB_texture_cube_map); + if (m_debug && doDebugMessages) + std::cout << "Enabled GL_ARB_texture_cube_map" << std::endl; + } + +#if defined(GL_ARB_texture_compression) + if (QueryExtension("GL_ARB_texture_compression")) + { + glCompressedTexImage3DARB = reinterpret_cast(bglGetProcAddress((const GLubyte *) "glCompressedTexImage3DARB")); + glCompressedTexImage2DARB = reinterpret_cast(bglGetProcAddress((const GLubyte *) "glCompressedTexImage2DARB")); + glCompressedTexImage1DARB = reinterpret_cast(bglGetProcAddress((const GLubyte *) "glCompressedTexImage1DARB")); + glCompressedTexSubImage3DARB = reinterpret_cast(bglGetProcAddress((const GLubyte *) "glCompressedTexSubImage3DARB")); + glCompressedTexSubImage2DARB = reinterpret_cast(bglGetProcAddress((const GLubyte *) "glCompressedTexSubImage2DARB")); + glCompressedTexSubImage1DARB = reinterpret_cast(bglGetProcAddress((const GLubyte *) "glCompressedTexSubImage1DARB")); + glGetCompressedTexImageARB = reinterpret_cast(bglGetProcAddress((const GLubyte *) "glGetCompressedTexImageARB")); + if (glCompressedTexImage3DARB && glCompressedTexImage2DARB && glCompressedTexImage1DARB && glCompressedTexSubImage3DARB && glCompressedTexSubImage2DARB && glCompressedTexSubImage1DARB && glGetCompressedTexImageARB) { + EnableExtension(_GL_ARB_texture_compression); + if (m_debug && doDebugMessages) + std::cout << "Enabled GL_ARB_texture_compression" << std::endl; + } else { + std::cout << "ERROR: GL_ARB_texture_compression implementation is broken!" << std::endl; + } + } +#endif + + if (QueryExtension("GL_ARB_texture_border_clamp")) + { + EnableExtension(_GL_ARB_texture_border_clamp); + if (m_debug && doDebugMessages) + std::cout << "Enabled GL_ARB_texture_border_clamp" << std::endl; + } + +#if defined(GL_ARB_vertex_blend) + if (QueryExtension("GL_ARB_vertex_blend")) + { + glWeightbvARB = reinterpret_cast(bglGetProcAddress((const GLubyte *) "glWeightbvARB")); + glWeightsvARB = reinterpret_cast(bglGetProcAddress((const GLubyte *) "glWeightsvARB")); + glWeightivARB = reinterpret_cast(bglGetProcAddress((const GLubyte *) "glWeightivARB")); + glWeightfvARB = reinterpret_cast(bglGetProcAddress((const GLubyte *) "glWeightfvARB")); + glWeightdvARB = reinterpret_cast(bglGetProcAddress((const GLubyte *) "glWeightdvARB")); + glWeightubvARB = reinterpret_cast(bglGetProcAddress((const GLubyte *) "glWeightubvARB")); + glWeightusvARB = reinterpret_cast(bglGetProcAddress((const GLubyte *) "glWeightusvARB")); + glWeightuivARB = reinterpret_cast(bglGetProcAddress((const GLubyte *) "glWeightuivARB")); + glWeightPointerARB = reinterpret_cast(bglGetProcAddress((const GLubyte *) "glWeightPointerARB")); + glVertexBlendARB = reinterpret_cast(bglGetProcAddress((const GLubyte *) "glVertexBlendARB")); + if (glWeightbvARB && glWeightsvARB && glWeightivARB && glWeightfvARB && glWeightdvARB && glWeightubvARB && glWeightusvARB && glWeightuivARB && glWeightPointerARB && glVertexBlendARB) { + EnableExtension(_GL_ARB_vertex_blend); + if (m_debug && doDebugMessages) + std::cout << "Enabled GL_ARB_vertex_blend" << std::endl; + } else { + std::cout << "ERROR: GL_ARB_vertex_blend implementation is broken!" << std::endl; + } + } +#endif + +#if defined(GL_ARB_matrix_palette) + if (QueryExtension("GL_ARB_matrix_palette")) + { + glCurrentPaletteMatrixARB = reinterpret_cast(bglGetProcAddress((const GLubyte *) "glCurrentPaletteMatrixARB")); + glMatrixIndexubvARB = reinterpret_cast(bglGetProcAddress((const GLubyte *) "glMatrixIndexubvARB")); + glMatrixIndexusvARB = reinterpret_cast(bglGetProcAddress((const GLubyte *) "glMatrixIndexusvARB")); + glMatrixIndexuivARB = reinterpret_cast(bglGetProcAddress((const GLubyte *) "glMatrixIndexuivARB")); + glMatrixIndexPointerARB = reinterpret_cast(bglGetProcAddress((const GLubyte *) "glMatrixIndexPointerARB")); + if (glCurrentPaletteMatrixARB && glMatrixIndexubvARB && glMatrixIndexusvARB && glMatrixIndexuivARB && glMatrixIndexPointerARB) { + EnableExtension(_GL_ARB_matrix_palette); + if (m_debug && doDebugMessages) + std::cout << "Enabled GL_ARB_matrix_palette" << std::endl; + } else { + std::cout << "ERROR: GL_ARB_matrix_palette implementation is broken!" << std::endl; + } + } +#endif + + if (QueryExtension("GL_ARB_texture_env_combine")) + { + EnableExtension(_GL_ARB_texture_env_combine); + if (m_debug && doDebugMessages) + std::cout << "Enabled GL_ARB_texture_env_combine" << std::endl; + } + + if (QueryExtension("GL_ARB_texture_env_crossbar")) + { + EnableExtension(_GL_ARB_texture_env_crossbar); + if (m_debug && doDebugMessages) + std::cout << "Enabled GL_ARB_texture_env_crossbar" << std::endl; + } + + if (QueryExtension("GL_ARB_texture_env_dot3")) + { + EnableExtension(_GL_ARB_texture_env_dot3); + if (m_debug && doDebugMessages) + std::cout << "Enabled GL_ARB_texture_env_dot3" << std::endl; + } + + if (QueryExtension("GL_ARB_texture_mirrored_repeat")) + { + EnableExtension(_GL_ARB_texture_mirrored_repeat); + if (m_debug && doDebugMessages) + std::cout << "Enabled GL_ARB_texture_mirrored_repeat" << std::endl; + } + + if (QueryExtension("GL_ARB_depth_texture")) + { + EnableExtension(_GL_ARB_depth_texture); + if (m_debug && doDebugMessages) + std::cout << "Enabled GL_ARB_depth_texture" << std::endl; + } + + if (QueryExtension("GL_ARB_shadow")) + { + EnableExtension(_GL_ARB_shadow); + if (m_debug && doDebugMessages) + std::cout << "Enabled GL_ARB_shadow" << std::endl; + } + + if (QueryExtension("GL_ARB_shadow_ambient")) + { + EnableExtension(_GL_ARB_shadow_ambient); + if (m_debug && doDebugMessages) + std::cout << "Enabled GL_ARB_shadow_ambient" << std::endl; + } + +#if defined(GL_ARB_window_pos) + if (QueryExtension("GL_ARB_window_pos")) + { + glWindowPos2dARB = reinterpret_cast(bglGetProcAddress((const GLubyte *) "glWindowPos2dARB")); + glWindowPos2dvARB = reinterpret_cast(bglGetProcAddress((const GLubyte *) "glWindowPos2dvARB")); + glWindowPos2fARB = reinterpret_cast(bglGetProcAddress((const GLubyte *) "glWindowPos2fARB")); + glWindowPos2fvARB = reinterpret_cast(bglGetProcAddress((const GLubyte *) "glWindowPos2fvARB")); + glWindowPos2iARB = reinterpret_cast(bglGetProcAddress((const GLubyte *) "glWindowPos2iARB")); + glWindowPos2ivARB = reinterpret_cast(bglGetProcAddress((const GLubyte *) "glWindowPos2ivARB")); + glWindowPos2sARB = reinterpret_cast(bglGetProcAddress((const GLubyte *) "glWindowPos2sARB")); + glWindowPos2svARB = reinterpret_cast(bglGetProcAddress((const GLubyte *) "glWindowPos2svARB")); + glWindowPos3dARB = reinterpret_cast(bglGetProcAddress((const GLubyte *) "glWindowPos3dARB")); + glWindowPos3dvARB = reinterpret_cast(bglGetProcAddress((const GLubyte *) "glWindowPos3dvARB")); + glWindowPos3fARB = reinterpret_cast(bglGetProcAddress((const GLubyte *) "glWindowPos3fARB")); + glWindowPos3fvARB = reinterpret_cast(bglGetProcAddress((const GLubyte *) "glWindowPos3fvARB")); + glWindowPos3iARB = reinterpret_cast(bglGetProcAddress((const GLubyte *) "glWindowPos3iARB")); + glWindowPos3ivARB = reinterpret_cast(bglGetProcAddress((const GLubyte *) "glWindowPos3ivARB")); + glWindowPos3sARB = reinterpret_cast(bglGetProcAddress((const GLubyte *) "glWindowPos3sARB")); + glWindowPos3svARB = reinterpret_cast(bglGetProcAddress((const GLubyte *) "glWindowPos3svARB")); + if (glWindowPos2dARB && glWindowPos2dvARB && glWindowPos2fARB && glWindowPos2fvARB && glWindowPos2iARB && glWindowPos2ivARB && glWindowPos2sARB && glWindowPos2svARB && glWindowPos3dARB && glWindowPos3dvARB && glWindowPos3fARB && glWindowPos3fvARB && glWindowPos3iARB && glWindowPos3ivARB && glWindowPos3sARB && glWindowPos3svARB) { + EnableExtension(_GL_ARB_window_pos); + if (m_debug && doDebugMessages) + std::cout << "Enabled GL_ARB_window_pos" << std::endl; + } else { + std::cout << "ERROR: GL_ARB_window_pos implementation is broken!" << std::endl; + } + } +#endif + +#if defined(GL_ARB_vertex_program) + if (QueryExtension("GL_ARB_vertex_program")) + { + glVertexAttrib1dARB = reinterpret_cast(bglGetProcAddress((const GLubyte *) "glVertexAttrib1dARB")); + glVertexAttrib1dvARB = reinterpret_cast(bglGetProcAddress((const GLubyte *) "glVertexAttrib1dvARB")); + glVertexAttrib1fARB = reinterpret_cast(bglGetProcAddress((const GLubyte *) "glVertexAttrib1fARB")); + glVertexAttrib1fvARB = reinterpret_cast(bglGetProcAddress((const GLubyte *) "glVertexAttrib1fvARB")); + glVertexAttrib1sARB = reinterpret_cast(bglGetProcAddress((const GLubyte *) "glVertexAttrib1sARB")); + glVertexAttrib1svARB = reinterpret_cast(bglGetProcAddress((const GLubyte *) "glVertexAttrib1svARB")); + glVertexAttrib2dARB = reinterpret_cast(bglGetProcAddress((const GLubyte *) "glVertexAttrib2dARB")); + glVertexAttrib2dvARB = reinterpret_cast(bglGetProcAddress((const GLubyte *) "glVertexAttrib2dvARB")); + glVertexAttrib2fARB = reinterpret_cast(bglGetProcAddress((const GLubyte *) "glVertexAttrib2fARB")); + glVertexAttrib2fvARB = reinterpret_cast(bglGetProcAddress((const GLubyte *) "glVertexAttrib2fvARB")); + glVertexAttrib2sARB = reinterpret_cast(bglGetProcAddress((const GLubyte *) "glVertexAttrib2sARB")); + glVertexAttrib2svARB = reinterpret_cast(bglGetProcAddress((const GLubyte *) "glVertexAttrib2svARB")); + glVertexAttrib3dARB = reinterpret_cast(bglGetProcAddress((const GLubyte *) "glVertexAttrib3dARB")); + glVertexAttrib3dvARB = reinterpret_cast(bglGetProcAddress((const GLubyte *) "glVertexAttrib3dvARB")); + glVertexAttrib3fARB = reinterpret_cast(bglGetProcAddress((const GLubyte *) "glVertexAttrib3fARB")); + glVertexAttrib3fvARB = reinterpret_cast(bglGetProcAddress((const GLubyte *) "glVertexAttrib3fvARB")); + glVertexAttrib3sARB = reinterpret_cast(bglGetProcAddress((const GLubyte *) "glVertexAttrib3sARB")); + glVertexAttrib3svARB = reinterpret_cast(bglGetProcAddress((const GLubyte *) "glVertexAttrib3svARB")); + glVertexAttrib4NbvARB = reinterpret_cast(bglGetProcAddress((const GLubyte *) "glVertexAttrib4NbvARB")); + glVertexAttrib4NivARB = reinterpret_cast(bglGetProcAddress((const GLubyte *) "glVertexAttrib4NivARB")); + glVertexAttrib4NsvARB = reinterpret_cast(bglGetProcAddress((const GLubyte *) "glVertexAttrib4NsvARB")); + glVertexAttrib4NubARB = reinterpret_cast(bglGetProcAddress((const GLubyte *) "glVertexAttrib4NubARB")); + glVertexAttrib4NubvARB = reinterpret_cast(bglGetProcAddress((const GLubyte *) "glVertexAttrib4NubvARB")); + glVertexAttrib4NuivARB = reinterpret_cast(bglGetProcAddress((const GLubyte *) "glVertexAttrib4NuivARB")); + glVertexAttrib4NusvARB = reinterpret_cast(bglGetProcAddress((const GLubyte *) "glVertexAttrib4NusvARB")); + glVertexAttrib4bvARB = reinterpret_cast(bglGetProcAddress((const GLubyte *) "glVertexAttrib4bvARB")); + glVertexAttrib4dARB = reinterpret_cast(bglGetProcAddress((const GLubyte *) "glVertexAttrib4dARB")); + glVertexAttrib4dvARB = reinterpret_cast(bglGetProcAddress((const GLubyte *) "glVertexAttrib4dvARB")); + glVertexAttrib4fARB = reinterpret_cast(bglGetProcAddress((const GLubyte *) "glVertexAttrib4fARB")); + glVertexAttrib4fvARB = reinterpret_cast(bglGetProcAddress((const GLubyte *) "glVertexAttrib4fvARB")); + glVertexAttrib4ivARB = reinterpret_cast(bglGetProcAddress((const GLubyte *) "glVertexAttrib4ivARB")); + glVertexAttrib4sARB = reinterpret_cast(bglGetProcAddress((const GLubyte *) "glVertexAttrib4sARB")); + glVertexAttrib4svARB = reinterpret_cast(bglGetProcAddress((const GLubyte *) "glVertexAttrib4svARB")); + glVertexAttrib4ubvARB = reinterpret_cast(bglGetProcAddress((const GLubyte *) "glVertexAttrib4ubvARB")); + glVertexAttrib4uivARB = reinterpret_cast(bglGetProcAddress((const GLubyte *) "glVertexAttrib4uivARB")); + glVertexAttrib4usvARB = reinterpret_cast(bglGetProcAddress((const GLubyte *) "glVertexAttrib4usvARB")); + glVertexAttribPointerARB = reinterpret_cast(bglGetProcAddress((const GLubyte *) "glVertexAttribPointerARB")); + glEnableVertexAttribArrayARB = reinterpret_cast(bglGetProcAddress((const GLubyte *) "glEnableVertexAttribArrayARB")); + glDisableVertexAttribArrayARB = reinterpret_cast(bglGetProcAddress((const GLubyte *) "glDisableVertexAttribArrayARB")); + glProgramStringARB = reinterpret_cast(bglGetProcAddress((const GLubyte *) "glProgramStringARB")); + glBindProgramARB = reinterpret_cast(bglGetProcAddress((const GLubyte *) "glBindProgramARB")); + glDeleteProgramsARB = reinterpret_cast(bglGetProcAddress((const GLubyte *) "glDeleteProgramsARB")); + glGenProgramsARB = reinterpret_cast(bglGetProcAddress((const GLubyte *) "glGenProgramsARB")); + glProgramEnvParameter4dARB = reinterpret_cast(bglGetProcAddress((const GLubyte *) "glProgramEnvParameter4dARB")); + glProgramEnvParameter4dvARB = reinterpret_cast(bglGetProcAddress((const GLubyte *) "glProgramEnvParameter4dvARB")); + glProgramEnvParameter4fARB = reinterpret_cast(bglGetProcAddress((const GLubyte *) "glProgramEnvParameter4fARB")); + glProgramEnvParameter4fvARB = reinterpret_cast(bglGetProcAddress((const GLubyte *) "glProgramEnvParameter4fvARB")); + glProgramLocalParameter4dARB = reinterpret_cast(bglGetProcAddress((const GLubyte *) "glProgramLocalParameter4dARB")); + glProgramLocalParameter4dvARB = reinterpret_cast(bglGetProcAddress((const GLubyte *) "glProgramLocalParameter4dvARB")); + glProgramLocalParameter4fARB = reinterpret_cast(bglGetProcAddress((const GLubyte *) "glProgramLocalParameter4fARB")); + glProgramLocalParameter4fvARB = reinterpret_cast(bglGetProcAddress((const GLubyte *) "glProgramLocalParameter4fvARB")); + glGetProgramEnvParameterdvARB = reinterpret_cast(bglGetProcAddress((const GLubyte *) "glGetProgramEnvParameterdvARB")); + glGetProgramEnvParameterfvARB = reinterpret_cast(bglGetProcAddress((const GLubyte *) "glGetProgramEnvParameterfvARB")); + glGetProgramLocalParameterdvARB = reinterpret_cast(bglGetProcAddress((const GLubyte *) "glGetProgramLocalParameterdvARB")); + glGetProgramLocalParameterfvARB = reinterpret_cast(bglGetProcAddress((const GLubyte *) "glGetProgramLocalParameterfvARB")); + glGetProgramivARB = reinterpret_cast(bglGetProcAddress((const GLubyte *) "glGetProgramivARB")); + glGetProgramStringARB = reinterpret_cast(bglGetProcAddress((const GLubyte *) "glGetProgramStringARB")); + glGetVertexAttribdvARB = reinterpret_cast(bglGetProcAddress((const GLubyte *) "glGetVertexAttribdvARB")); + glGetVertexAttribfvARB = reinterpret_cast(bglGetProcAddress((const GLubyte *) "glGetVertexAttribfvARB")); + glGetVertexAttribivARB = reinterpret_cast(bglGetProcAddress((const GLubyte *) "glGetVertexAttribivARB")); + glGetVertexAttribPointervARB = reinterpret_cast(bglGetProcAddress((const GLubyte *) "glGetVertexAttribPointervARB")); + glIsProgramARB = reinterpret_cast(bglGetProcAddress((const GLubyte *) "glIsProgramARB")); + if (glVertexAttrib1dARB && glVertexAttrib1dvARB && glVertexAttrib1fARB && glVertexAttrib1fvARB && glVertexAttrib1sARB && glVertexAttrib1svARB && glVertexAttrib2dARB && glVertexAttrib2dvARB && glVertexAttrib2fARB && glVertexAttrib2fvARB && glVertexAttrib2sARB && glVertexAttrib2svARB && glVertexAttrib3dARB && glVertexAttrib3dvARB && glVertexAttrib3fARB && glVertexAttrib3fvARB && glVertexAttrib3sARB && glVertexAttrib3svARB && glVertexAttrib4NbvARB && glVertexAttrib4NivARB && glVertexAttrib4NsvARB && glVertexAttrib4NubARB && glVertexAttrib4NubvARB && glVertexAttrib4NuivARB && glVertexAttrib4NusvARB && glVertexAttrib4bvARB && glVertexAttrib4dARB && glVertexAttrib4dvARB && glVertexAttrib4fARB && glVertexAttrib4fvARB && glVertexAttrib4ivARB && glVertexAttrib4sARB && glVertexAttrib4svARB && glVertexAttrib4ubvARB && glVertexAttrib4uivARB && glVertexAttrib4usvARB && glVertexAttribPointerARB && glEnableVertexAttribArrayARB && glDisableVertexAttribArrayARB && glProgramStringARB && glBindProgramARB && glDeleteProgramsARB && glGenProgramsARB && glProgramEnvParameter4dARB && glProgramEnvParameter4dvARB && glProgramEnvParameter4fARB && glProgramEnvParameter4fvARB && glProgramLocalParameter4dARB && glProgramLocalParameter4dvARB && glProgramLocalParameter4fARB && glProgramLocalParameter4fvARB && glGetProgramEnvParameterdvARB && glGetProgramEnvParameterfvARB && glGetProgramLocalParameterdvARB && glGetProgramLocalParameterfvARB && glGetProgramivARB && glGetProgramStringARB && glGetVertexAttribdvARB && glGetVertexAttribfvARB && glGetVertexAttribivARB && glGetVertexAttribPointervARB && glIsProgramARB) { + EnableExtension(_GL_ARB_vertex_program); + if (m_debug && doDebugMessages) + std::cout << "Enabled GL_ARB_vertex_program" << std::endl; + } else { + std::cout << "ERROR: GL_ARB_vertex_program implementation is broken!" << std::endl; + } + } +#endif + + if (QueryExtension("GL_ARB_fragment_program")) + { + EnableExtension(_GL_ARB_fragment_program); + if (m_debug && doDebugMessages) + std::cout << "Enabled GL_ARB_fragment_program" << std::endl; + } + +#if defined(GL_ARB_vertex_buffer_object) + if (QueryExtension("GL_ARB_vertex_buffer_object")) + { + glBindBufferARB = reinterpret_cast(bglGetProcAddress((const GLubyte *) "glBindBufferARB")); + glDeleteBuffersARB = reinterpret_cast(bglGetProcAddress((const GLubyte *) "glDeleteBuffersARB")); + glGenBuffersARB = reinterpret_cast(bglGetProcAddress((const GLubyte *) "glGenBuffersARB")); + glIsBufferARB = reinterpret_cast(bglGetProcAddress((const GLubyte *) "glIsBufferARB")); + glBufferDataARB = reinterpret_cast(bglGetProcAddress((const GLubyte *) "glBufferDataARB")); + glBufferSubDataARB = reinterpret_cast(bglGetProcAddress((const GLubyte *) "glBufferSubDataARB")); + glGetBufferSubDataARB = reinterpret_cast(bglGetProcAddress((const GLubyte *) "glGetBufferSubDataARB")); + glMapBufferARB = reinterpret_cast(bglGetProcAddress((const GLubyte *) "glMapBufferARB")); + glUnmapBufferARB = reinterpret_cast(bglGetProcAddress((const GLubyte *) "glUnmapBufferARB")); + glGetBufferParameterivARB = reinterpret_cast(bglGetProcAddress((const GLubyte *) "glGetBufferParameterivARB")); + glGetBufferPointervARB = reinterpret_cast(bglGetProcAddress((const GLubyte *) "glGetBufferPointervARB")); + if (glBindBufferARB && glDeleteBuffersARB && glGenBuffersARB && glIsBufferARB && glBufferDataARB && glBufferSubDataARB && glGetBufferSubDataARB && glMapBufferARB && glUnmapBufferARB && glGetBufferParameterivARB && glGetBufferPointervARB) { + EnableExtension(_GL_ARB_vertex_buffer_object); + if (m_debug && doDebugMessages) + std::cout << "Enabled GL_ARB_vertex_buffer_object" << std::endl; + } else { + std::cout << "ERROR: GL_ARB_vertex_buffer_object implementation is broken!" << std::endl; + } + } +#endif + +#if defined(GL_ARB_occlusion_query) + if (QueryExtension("GL_ARB_occlusion_query")) + { + glGenQueriesARB = reinterpret_cast(bglGetProcAddress((const GLubyte *) "glGenQueriesARB")); + glDeleteQueriesARB = reinterpret_cast(bglGetProcAddress((const GLubyte *) "glDeleteQueriesARB")); + glIsQueryARB = reinterpret_cast(bglGetProcAddress((const GLubyte *) "glIsQueryARB")); + glBeginQueryARB = reinterpret_cast(bglGetProcAddress((const GLubyte *) "glBeginQueryARB")); + glEndQueryARB = reinterpret_cast(bglGetProcAddress((const GLubyte *) "glEndQueryARB")); + glGetQueryivARB = reinterpret_cast(bglGetProcAddress((const GLubyte *) "glGetQueryivARB")); + glGetQueryObjectivARB = reinterpret_cast(bglGetProcAddress((const GLubyte *) "glGetQueryObjectivARB")); + glGetQueryObjectuivARB = reinterpret_cast(bglGetProcAddress((const GLubyte *) "glGetQueryObjectuivARB")); + if (glGenQueriesARB && glDeleteQueriesARB && glIsQueryARB && glBeginQueryARB && glEndQueryARB && glGetQueryivARB && glGetQueryObjectivARB && glGetQueryObjectuivARB) { + EnableExtension(_GL_ARB_occlusion_query); + if (m_debug && doDebugMessages) + std::cout << "Enabled GL_ARB_occlusion_query" << std::endl; + } else { + std::cout << "ERROR: GL_ARB_occlusion_query implementation is broken!" << std::endl; + } + } +#endif + +#if defined(GL_ARB_shader_objects) + if (QueryExtension("GL_ARB_shader_objects")) + { + glDeleteObjectARB = reinterpret_cast(bglGetProcAddress((const GLubyte *) "glDeleteObjectARB")); + glGetHandleARB = reinterpret_cast(bglGetProcAddress((const GLubyte *) "glGetHandleARB")); + glDetachObjectARB = reinterpret_cast(bglGetProcAddress((const GLubyte *) "glDetachObjectARB")); + glCreateShaderObjectARB = reinterpret_cast(bglGetProcAddress((const GLubyte *) "glCreateShaderObjectARB")); + glShaderSourceARB = reinterpret_cast(bglGetProcAddress((const GLubyte *) "glShaderSourceARB")); + glCompileShaderARB = reinterpret_cast(bglGetProcAddress((const GLubyte *) "glCompileShaderARB")); + glCreateProgramObjectARB = reinterpret_cast(bglGetProcAddress((const GLubyte *) "glCreateProgramObjectARB")); + glAttachObjectARB = reinterpret_cast(bglGetProcAddress((const GLubyte *) "glAttachObjectARB")); + glLinkProgramARB = reinterpret_cast(bglGetProcAddress((const GLubyte *) "glLinkProgramARB")); + glUseProgramObjectARB = reinterpret_cast(bglGetProcAddress((const GLubyte *) "glUseProgramObjectARB")); + glValidateProgramARB = reinterpret_cast(bglGetProcAddress((const GLubyte *) "glValidateProgramARB")); + glUniform1fARB = reinterpret_cast(bglGetProcAddress((const GLubyte *) "glUniform1fARB")); + glUniform2fARB = reinterpret_cast(bglGetProcAddress((const GLubyte *) "glUniform2fARB")); + glUniform3fARB = reinterpret_cast(bglGetProcAddress((const GLubyte *) "glUniform3fARB")); + glUniform4fARB = reinterpret_cast(bglGetProcAddress((const GLubyte *) "glUniform4fARB")); + glUniform1iARB = reinterpret_cast(bglGetProcAddress((const GLubyte *) "glUniform1iARB")); + glUniform2iARB = reinterpret_cast(bglGetProcAddress((const GLubyte *) "glUniform2iARB")); + glUniform3iARB = reinterpret_cast(bglGetProcAddress((const GLubyte *) "glUniform3iARB")); + glUniform4iARB = reinterpret_cast(bglGetProcAddress((const GLubyte *) "glUniform4iARB")); + glUniform1fvARB = reinterpret_cast(bglGetProcAddress((const GLubyte *) "glUniform1fvARB")); + glUniform2fvARB = reinterpret_cast(bglGetProcAddress((const GLubyte *) "glUniform2fvARB")); + glUniform3fvARB = reinterpret_cast(bglGetProcAddress((const GLubyte *) "glUniform3fvARB")); + glUniform4fvARB = reinterpret_cast(bglGetProcAddress((const GLubyte *) "glUniform4fvARB")); + glUniform1ivARB = reinterpret_cast(bglGetProcAddress((const GLubyte *) "glUniform1ivARB")); + glUniform2ivARB = reinterpret_cast(bglGetProcAddress((const GLubyte *) "glUniform2ivARB")); + glUniform3ivARB = reinterpret_cast(bglGetProcAddress((const GLubyte *) "glUniform3ivARB")); + glUniform4ivARB = reinterpret_cast(bglGetProcAddress((const GLubyte *) "glUniform4ivARB")); + glUniformMatrix2fvARB = reinterpret_cast(bglGetProcAddress((const GLubyte *) "glUniformMatrix2fvARB")); + glUniformMatrix3fvARB = reinterpret_cast(bglGetProcAddress((const GLubyte *) "glUniformMatrix3fvARB")); + glUniformMatrix4fvARB = reinterpret_cast(bglGetProcAddress((const GLubyte *) "glUniformMatrix4fvARB")); + glGetObjectParameterfvARB = reinterpret_cast(bglGetProcAddress((const GLubyte *) "glGetObjectParameterfvARB")); + glGetObjectParameterivARB = reinterpret_cast(bglGetProcAddress((const GLubyte *) "glGetObjectParameterivARB")); + glGetInfoLogARB = reinterpret_cast(bglGetProcAddress((const GLubyte *) "glGetInfoLogARB")); + glGetAttachedObjectsARB = reinterpret_cast(bglGetProcAddress((const GLubyte *) "glGetAttachedObjectsARB")); + glGetUniformLocationARB = reinterpret_cast(bglGetProcAddress((const GLubyte *) "glGetUniformLocationARB")); + glGetActiveUniformARB = reinterpret_cast(bglGetProcAddress((const GLubyte *) "glGetActiveUniformARB")); + glGetUniformfvARB = reinterpret_cast(bglGetProcAddress((const GLubyte *) "glGetUniformfvARB")); + glGetUniformivARB = reinterpret_cast(bglGetProcAddress((const GLubyte *) "glGetUniformivARB")); + glGetShaderSourceARB = reinterpret_cast(bglGetProcAddress((const GLubyte *) "glGetShaderSourceARB")); + if (glDeleteObjectARB && glGetHandleARB && glDetachObjectARB && glCreateShaderObjectARB && glShaderSourceARB && glCompileShaderARB && glCreateProgramObjectARB && glAttachObjectARB && glLinkProgramARB && glUseProgramObjectARB && glValidateProgramARB && glUniform1fARB && glUniform2fARB && glUniform3fARB && glUniform4fARB && glUniform1iARB && glUniform2iARB && glUniform3iARB && glUniform4iARB && glUniform1fvARB && glUniform2fvARB && glUniform3fvARB && glUniform4fvARB && glUniform1ivARB && glUniform2ivARB && glUniform3ivARB && glUniform4ivARB && glUniformMatrix2fvARB && glUniformMatrix3fvARB && glUniformMatrix4fvARB && glGetObjectParameterfvARB && glGetObjectParameterivARB && glGetInfoLogARB && glGetAttachedObjectsARB && glGetUniformLocationARB && glGetActiveUniformARB && glGetUniformfvARB && glGetUniformivARB && glGetShaderSourceARB) { + EnableExtension(_GL_ARB_shader_objects); + if (m_debug && doDebugMessages) + std::cout << "Enabled GL_ARB_shader_objects" << std::endl; + } else { + std::cout << "ERROR: GL_ARB_shader_objects implementation is broken!" << std::endl; + } + } +#endif + +#if defined(GL_ARB_vertex_shader) + if (QueryExtension("GL_ARB_vertex_shader")) + { + glBindAttribLocationARB = reinterpret_cast(bglGetProcAddress((const GLubyte *) "glBindAttribLocationARB")); + glGetActiveAttribARB = reinterpret_cast(bglGetProcAddress((const GLubyte *) "glGetActiveAttribARB")); + glGetAttribLocationARB = reinterpret_cast(bglGetProcAddress((const GLubyte *) "glGetAttribLocationARB")); + if (glBindAttribLocationARB && glGetActiveAttribARB && glGetAttribLocationARB) { + EnableExtension(_GL_ARB_vertex_shader); + if (m_debug && doDebugMessages) + std::cout << "Enabled GL_ARB_vertex_shader" << std::endl; + } else { + std::cout << "ERROR: GL_ARB_vertex_shader implementation is broken!" << std::endl; + } + } +#endif + + if (QueryExtension("GL_ARB_fragment_shader")) + { + EnableExtension(_GL_ARB_fragment_shader); + if (m_debug && doDebugMessages) + std::cout << "Enabled GL_ARB_fragment_shader" << std::endl; + } + + if (QueryExtension("GL_ARB_shading_language_100")) + { + EnableExtension(_GL_ARB_shading_language_100); + if (m_debug && doDebugMessages) + std::cout << "Enabled GL_ARB_shading_language_100" << std::endl; + } + + if (QueryExtension("GL_ARB_texture_non_power_of_two")) + { + EnableExtension(_GL_ARB_texture_non_power_of_two); + if (m_debug && doDebugMessages) + std::cout << "Enabled GL_ARB_texture_non_power_of_two" << std::endl; + } + + if (QueryExtension("GL_ARB_point_sprite")) + { + EnableExtension(_GL_ARB_point_sprite); + if (m_debug && doDebugMessages) + std::cout << "Enabled GL_ARB_point_sprite" << std::endl; + } + + if (QueryExtension("GL_ARB_fragment_program_shadow")) + { + EnableExtension(_GL_ARB_fragment_program_shadow); + if (m_debug && doDebugMessages) + std::cout << "Enabled GL_ARB_fragment_program_shadow" << std::endl; + } + + if (QueryExtension("GL_EXT_abgr")) + { + EnableExtension(_GL_EXT_abgr); + if (m_debug && doDebugMessages) + std::cout << "Enabled GL_EXT_abgr" << std::endl; + } + +#if defined(GL_EXT_texture3D) + if (QueryExtension("GL_EXT_texture3D")) + { + glTexImage3DEXT = reinterpret_cast(bglGetProcAddress((const GLubyte *) "glTexImage3DEXT")); + glTexSubImage3DEXT = reinterpret_cast(bglGetProcAddress((const GLubyte *) "glTexSubImage3DEXT")); + if (glTexImage3DEXT && glTexSubImage3DEXT) { + EnableExtension(_GL_EXT_texture3D); + if (m_debug && doDebugMessages) + std::cout << "Enabled GL_EXT_texture3D" << std::endl; + } else { + std::cout << "ERROR: GL_EXT_texture3D implementation is broken!" << std::endl; + } + } +#endif + +#if defined(GL_SGIS_texture_filter4) + if (QueryExtension("GL_SGIS_texture_filter4")) + { + glGetTexFilterFuncSGIS = reinterpret_cast(bglGetProcAddress((const GLubyte *) "glGetTexFilterFuncSGIS")); + glTexFilterFuncSGIS = reinterpret_cast(bglGetProcAddress((const GLubyte *) "glTexFilterFuncSGIS")); + if (glGetTexFilterFuncSGIS && glTexFilterFuncSGIS) { + EnableExtension(_GL_SGIS_texture_filter4); + if (m_debug && doDebugMessages) + std::cout << "Enabled GL_SGIS_texture_filter4" << std::endl; + } else { + std::cout << "ERROR: GL_SGIS_texture_filter4 implementation is broken!" << std::endl; + } + } +#endif + +#if defined(GL_EXT_histogram) + if (QueryExtension("GL_EXT_histogram")) + { + glGetHistogramEXT = reinterpret_cast(bglGetProcAddress((const GLubyte *) "glGetHistogramEXT")); + glGetHistogramParameterfvEXT = reinterpret_cast(bglGetProcAddress((const GLubyte *) "glGetHistogramParameterfvEXT")); + glGetHistogramParameterivEXT = reinterpret_cast(bglGetProcAddress((const GLubyte *) "glGetHistogramParameterivEXT")); + glGetMinmaxEXT = reinterpret_cast(bglGetProcAddress((const GLubyte *) "glGetMinmaxEXT")); + glGetMinmaxParameterfvEXT = reinterpret_cast(bglGetProcAddress((const GLubyte *) "glGetMinmaxParameterfvEXT")); + glGetMinmaxParameterivEXT = reinterpret_cast(bglGetProcAddress((const GLubyte *) "glGetMinmaxParameterivEXT")); + glHistogramEXT = reinterpret_cast(bglGetProcAddress((const GLubyte *) "glHistogramEXT")); + glMinmaxEXT = reinterpret_cast(bglGetProcAddress((const GLubyte *) "glMinmaxEXT")); + glResetHistogramEXT = reinterpret_cast(bglGetProcAddress((const GLubyte *) "glResetHistogramEXT")); + glResetMinmaxEXT = reinterpret_cast(bglGetProcAddress((const GLubyte *) "glResetMinmaxEXT")); + if (glGetHistogramEXT && glGetHistogramParameterfvEXT && glGetHistogramParameterivEXT && glGetMinmaxEXT && glGetMinmaxParameterfvEXT && glGetMinmaxParameterivEXT && glHistogramEXT && glMinmaxEXT && glResetHistogramEXT && glResetMinmaxEXT) { + EnableExtension(_GL_EXT_histogram); + if (m_debug && doDebugMessages) + std::cout << "Enabled GL_EXT_histogram" << std::endl; + } else { + std::cout << "ERROR: GL_EXT_histogram implementation is broken!" << std::endl; + } + } +#endif + +#if defined(GL_EXT_convolution) + if (QueryExtension("GL_EXT_convolution")) + { + glConvolutionFilter1DEXT = reinterpret_cast(bglGetProcAddress((const GLubyte *) "glConvolutionFilter1DEXT")); + glConvolutionFilter2DEXT = reinterpret_cast(bglGetProcAddress((const GLubyte *) "glConvolutionFilter2DEXT")); + glConvolutionParameterfEXT = reinterpret_cast(bglGetProcAddress((const GLubyte *) "glConvolutionParameterfEXT")); + glConvolutionParameterfvEXT = reinterpret_cast(bglGetProcAddress((const GLubyte *) "glConvolutionParameterfvEXT")); + glConvolutionParameteriEXT = reinterpret_cast(bglGetProcAddress((const GLubyte *) "glConvolutionParameteriEXT")); + glConvolutionParameterivEXT = reinterpret_cast(bglGetProcAddress((const GLubyte *) "glConvolutionParameterivEXT")); + glCopyConvolutionFilter1DEXT = reinterpret_cast(bglGetProcAddress((const GLubyte *) "glCopyConvolutionFilter1DEXT")); + glCopyConvolutionFilter2DEXT = reinterpret_cast(bglGetProcAddress((const GLubyte *) "glCopyConvolutionFilter2DEXT")); + glGetConvolutionFilterEXT = reinterpret_cast(bglGetProcAddress((const GLubyte *) "glGetConvolutionFilterEXT")); + glGetConvolutionParameterfvEXT = reinterpret_cast(bglGetProcAddress((const GLubyte *) "glGetConvolutionParameterfvEXT")); + glGetConvolutionParameterivEXT = reinterpret_cast(bglGetProcAddress((const GLubyte *) "glGetConvolutionParameterivEXT")); + glGetSeparableFilterEXT = reinterpret_cast(bglGetProcAddress((const GLubyte *) "glGetSeparableFilterEXT")); + glSeparableFilter2DEXT = reinterpret_cast(bglGetProcAddress((const GLubyte *) "glSeparableFilter2DEXT")); + if (glConvolutionFilter1DEXT && glConvolutionFilter2DEXT && glConvolutionParameterfEXT && glConvolutionParameterfvEXT && glConvolutionParameteriEXT && glConvolutionParameterivEXT && glCopyConvolutionFilter1DEXT && glCopyConvolutionFilter2DEXT && glGetConvolutionFilterEXT && glGetConvolutionParameterfvEXT && glGetConvolutionParameterivEXT && glGetSeparableFilterEXT && glSeparableFilter2DEXT) { + EnableExtension(_GL_EXT_convolution); + if (m_debug && doDebugMessages) + std::cout << "Enabled GL_EXT_convolution" << std::endl; + } else { + std::cout << "ERROR: GL_EXT_convolution implementation is broken!" << std::endl; + } + } +#endif + +#if defined(GL_SGI_color_table) + if (QueryExtension("GL_SGI_color_table")) + { + glColorTableSGI = reinterpret_cast(bglGetProcAddress((const GLubyte *) "glColorTableSGI")); + glColorTableParameterfvSGI = reinterpret_cast(bglGetProcAddress((const GLubyte *) "glColorTableParameterfvSGI")); + glColorTableParameterivSGI = reinterpret_cast(bglGetProcAddress((const GLubyte *) "glColorTableParameterivSGI")); + glCopyColorTableSGI = reinterpret_cast(bglGetProcAddress((const GLubyte *) "glCopyColorTableSGI")); + glGetColorTableSGI = reinterpret_cast(bglGetProcAddress((const GLubyte *) "glGetColorTableSGI")); + glGetColorTableParameterfvSGI = reinterpret_cast(bglGetProcAddress((const GLubyte *) "glGetColorTableParameterfvSGI")); + glGetColorTableParameterivSGI = reinterpret_cast(bglGetProcAddress((const GLubyte *) "glGetColorTableParameterivSGI")); + if (glColorTableSGI && glColorTableParameterfvSGI && glColorTableParameterivSGI && glCopyColorTableSGI && glGetColorTableSGI && glGetColorTableParameterfvSGI && glGetColorTableParameterivSGI) { + EnableExtension(_GL_SGI_color_table); + if (m_debug && doDebugMessages) + std::cout << "Enabled GL_SGI_color_table" << std::endl; + } else { + std::cout << "ERROR: GL_SGI_color_table implementation is broken!" << std::endl; + } + } +#endif + +#if defined(GL_SGIX_pixel_texture) + if (QueryExtension("GL_SGIX_pixel_texture")) + { + glPixelTexGenSGIX = reinterpret_cast(bglGetProcAddress((const GLubyte *) "glPixelTexGenSGIX")); + if (glPixelTexGenSGIX) { + EnableExtension(_GL_SGIX_pixel_texture); + if (m_debug && doDebugMessages) + std::cout << "Enabled GL_SGIX_pixel_texture" << std::endl; + } else { + std::cout << "ERROR: GL_SGIX_pixel_texture implementation is broken!" << std::endl; + } + } +#endif + +#if defined(GL_SGIS_pixel_texture) + if (QueryExtension("GL_SGIS_pixel_texture")) + { + glPixelTexGenParameteriSGIS = reinterpret_cast(bglGetProcAddress((const GLubyte *) "glPixelTexGenParameteriSGIS")); + glPixelTexGenParameterivSGIS = reinterpret_cast(bglGetProcAddress((const GLubyte *) "glPixelTexGenParameterivSGIS")); + glPixelTexGenParameterfSGIS = reinterpret_cast(bglGetProcAddress((const GLubyte *) "glPixelTexGenParameterfSGIS")); + glPixelTexGenParameterfvSGIS = reinterpret_cast(bglGetProcAddress((const GLubyte *) "glPixelTexGenParameterfvSGIS")); + glGetPixelTexGenParameterivSGIS = reinterpret_cast(bglGetProcAddress((const GLubyte *) "glGetPixelTexGenParameterivSGIS")); + glGetPixelTexGenParameterfvSGIS = reinterpret_cast(bglGetProcAddress((const GLubyte *) "glGetPixelTexGenParameterfvSGIS")); + if (glPixelTexGenParameteriSGIS && glPixelTexGenParameterivSGIS && glPixelTexGenParameterfSGIS && glPixelTexGenParameterfvSGIS && glGetPixelTexGenParameterivSGIS && glGetPixelTexGenParameterfvSGIS) { + EnableExtension(_GL_SGIS_pixel_texture); + if (m_debug && doDebugMessages) + std::cout << "Enabled GL_SGIS_pixel_texture" << std::endl; + } else { + std::cout << "ERROR: GL_SGIS_pixel_texture implementation is broken!" << std::endl; + } + } +#endif + +#if defined(GL_SGIS_texture4D) + if (QueryExtension("GL_SGIS_texture4D")) + { + glTexImage4DSGIS = reinterpret_cast(bglGetProcAddress((const GLubyte *) "glTexImage4DSGIS")); + glTexSubImage4DSGIS = reinterpret_cast(bglGetProcAddress((const GLubyte *) "glTexSubImage4DSGIS")); + if (glTexImage4DSGIS && glTexSubImage4DSGIS) { + EnableExtension(_GL_SGIS_texture4D); + if (m_debug && doDebugMessages) + std::cout << "Enabled GL_SGIS_texture4D" << std::endl; + } else { + std::cout << "ERROR: GL_SGIS_texture4D implementation is broken!" << std::endl; + } + } +#endif + + if (QueryExtension("GL_SGI_texture_color_table")) + { + EnableExtension(_GL_SGI_texture_color_table); + if (m_debug && doDebugMessages) + std::cout << "Enabled GL_SGI_texture_color_table" << std::endl; + } + + if (QueryExtension("GL_EXT_cmyka")) + { + EnableExtension(_GL_EXT_cmyka); + if (m_debug && doDebugMessages) + std::cout << "Enabled GL_EXT_cmyka" << std::endl; + } + +#if defined(GL_SGIS_detail_texture) + if (QueryExtension("GL_SGIS_detail_texture")) + { + glDetailTexFuncSGIS = reinterpret_cast(bglGetProcAddress((const GLubyte *) "glDetailTexFuncSGIS")); + glGetDetailTexFuncSGIS = reinterpret_cast(bglGetProcAddress((const GLubyte *) "glGetDetailTexFuncSGIS")); + if (glDetailTexFuncSGIS && glGetDetailTexFuncSGIS) { + EnableExtension(_GL_SGIS_detail_texture); + if (m_debug && doDebugMessages) + std::cout << "Enabled GL_SGIS_detail_texture" << std::endl; + } else { + std::cout << "ERROR: GL_SGIS_detail_texture implementation is broken!" << std::endl; + } + } +#endif + +#if defined(GL_SGIS_sharpen_texture) + if (QueryExtension("GL_SGIS_sharpen_texture")) + { + glSharpenTexFuncSGIS = reinterpret_cast(bglGetProcAddress((const GLubyte *) "glSharpenTexFuncSGIS")); + glGetSharpenTexFuncSGIS = reinterpret_cast(bglGetProcAddress((const GLubyte *) "glGetSharpenTexFuncSGIS")); + if (glSharpenTexFuncSGIS && glGetSharpenTexFuncSGIS) { + EnableExtension(_GL_SGIS_sharpen_texture); + if (m_debug && doDebugMessages) + std::cout << "Enabled GL_SGIS_sharpen_texture" << std::endl; + } else { + std::cout << "ERROR: GL_SGIS_sharpen_texture implementation is broken!" << std::endl; + } + } +#endif + + if (QueryExtension("GL_EXT_packed_pixels")) + { + EnableExtension(_GL_EXT_packed_pixels); + if (m_debug && doDebugMessages) + std::cout << "Enabled GL_EXT_packed_pixels" << std::endl; + } + + if (QueryExtension("GL_SGIS_texture_lod")) + { + EnableExtension(_GL_SGIS_texture_lod); + if (m_debug && doDebugMessages) + std::cout << "Enabled GL_SGIS_texture_lod" << std::endl; + } + +#if defined(GL_SGIS_multisample) + if (QueryExtension("GL_SGIS_multisample")) + { + glSampleMaskSGIS = reinterpret_cast(bglGetProcAddress((const GLubyte *) "glSampleMaskSGIS")); + glSamplePatternSGIS = reinterpret_cast(bglGetProcAddress((const GLubyte *) "glSamplePatternSGIS")); + if (glSampleMaskSGIS && glSamplePatternSGIS) { + EnableExtension(_GL_SGIS_multisample); + if (m_debug && doDebugMessages) + std::cout << "Enabled GL_SGIS_multisample" << std::endl; + } else { + std::cout << "ERROR: GL_SGIS_multisample implementation is broken!" << std::endl; + } + } +#endif + + if (QueryExtension("GL_EXT_rescale_normal")) + { + EnableExtension(_GL_EXT_rescale_normal); + if (m_debug && doDebugMessages) + std::cout << "Enabled GL_EXT_rescale_normal" << std::endl; + } + + if (QueryExtension("GL_EXT_misc_attribute")) + { + EnableExtension(_GL_EXT_misc_attribute); + if (m_debug && doDebugMessages) + std::cout << "Enabled GL_EXT_misc_attribute" << std::endl; + } + + if (QueryExtension("GL_SGIS_generate_mipmap")) + { + EnableExtension(_GL_SGIS_generate_mipmap); + if (m_debug && doDebugMessages) + std::cout << "Enabled GL_SGIS_generate_mipmap" << std::endl; + } + + if (QueryExtension("GL_SGIX_clipmap")) + { + EnableExtension(_GL_SGIX_clipmap); + if (m_debug && doDebugMessages) + std::cout << "Enabled GL_SGIX_clipmap" << std::endl; + } + + if (QueryExtension("GL_SGIX_shadow")) + { + EnableExtension(_GL_SGIX_shadow); + if (m_debug && doDebugMessages) + std::cout << "Enabled GL_SGIX_shadow" << std::endl; + } + + if (QueryExtension("GL_SGIS_texture_edge_clamp")) + { + EnableExtension(_GL_SGIS_texture_edge_clamp); + if (m_debug && doDebugMessages) + std::cout << "Enabled GL_SGIS_texture_edge_clamp" << std::endl; + } + + if (QueryExtension("GL_SGIS_texture_border_clamp")) + { + EnableExtension(_GL_SGIS_texture_border_clamp); + if (m_debug && doDebugMessages) + std::cout << "Enabled GL_SGIS_texture_border_clamp" << std::endl; + } + +#if defined(GL_EXT_blend_minmax) + if (QueryExtension("GL_EXT_blend_minmax")) + { + glBlendEquationEXT = reinterpret_cast(bglGetProcAddress((const GLubyte *) "glBlendEquationEXT")); + if (glBlendEquationEXT) { + EnableExtension(_GL_EXT_blend_minmax); + if (m_debug && doDebugMessages) + std::cout << "Enabled GL_EXT_blend_minmax" << std::endl; + } else { + std::cout << "ERROR: GL_EXT_blend_minmax implementation is broken!" << std::endl; + } + } +#endif + + if (QueryExtension("GL_EXT_blend_subtract")) + { + EnableExtension(_GL_EXT_blend_subtract); + if (m_debug && doDebugMessages) + std::cout << "Enabled GL_EXT_blend_subtract" << std::endl; + } + + if (QueryExtension("GL_EXT_blend_logic_op")) + { + EnableExtension(_GL_EXT_blend_logic_op); + if (m_debug && doDebugMessages) + std::cout << "Enabled GL_EXT_blend_logic_op" << std::endl; + } + + if (QueryExtension("GL_SGIX_interlace")) + { + EnableExtension(_GL_SGIX_interlace); + if (m_debug && doDebugMessages) + std::cout << "Enabled GL_SGIX_interlace" << std::endl; + } + +#if defined(GL_SGIX_sprite) + if (QueryExtension("GL_SGIX_sprite")) + { + glSpriteParameterfSGIX = reinterpret_cast(bglGetProcAddress((const GLubyte *) "glSpriteParameterfSGIX")); + glSpriteParameterfvSGIX = reinterpret_cast(bglGetProcAddress((const GLubyte *) "glSpriteParameterfvSGIX")); + glSpriteParameteriSGIX = reinterpret_cast(bglGetProcAddress((const GLubyte *) "glSpriteParameteriSGIX")); + glSpriteParameterivSGIX = reinterpret_cast(bglGetProcAddress((const GLubyte *) "glSpriteParameterivSGIX")); + if (glSpriteParameterfSGIX && glSpriteParameterfvSGIX && glSpriteParameteriSGIX && glSpriteParameterivSGIX) { + EnableExtension(_GL_SGIX_sprite); + if (m_debug && doDebugMessages) + std::cout << "Enabled GL_SGIX_sprite" << std::endl; + } else { + std::cout << "ERROR: GL_SGIX_sprite implementation is broken!" << std::endl; + } + } +#endif + + if (QueryExtension("GL_SGIX_texture_multi_buffer")) + { + EnableExtension(_GL_SGIX_texture_multi_buffer); + if (m_debug && doDebugMessages) + std::cout << "Enabled GL_SGIX_texture_multi_buffer" << std::endl; + } + +#if defined(GL_SGIX_instruments) + if (QueryExtension("GL_SGIX_instruments")) + { + glGetInstrumentsSGIX = reinterpret_cast(bglGetProcAddress((const GLubyte *) "glGetInstrumentsSGIX")); + glInstrumentsBufferSGIX = reinterpret_cast(bglGetProcAddress((const GLubyte *) "glInstrumentsBufferSGIX")); + glPollInstrumentsSGIX = reinterpret_cast(bglGetProcAddress((const GLubyte *) "glPollInstrumentsSGIX")); + glReadInstrumentsSGIX = reinterpret_cast(bglGetProcAddress((const GLubyte *) "glReadInstrumentsSGIX")); + glStartInstrumentsSGIX = reinterpret_cast(bglGetProcAddress((const GLubyte *) "glStartInstrumentsSGIX")); + glStopInstrumentsSGIX = reinterpret_cast(bglGetProcAddress((const GLubyte *) "glStopInstrumentsSGIX")); + if (glGetInstrumentsSGIX && glInstrumentsBufferSGIX && glPollInstrumentsSGIX && glReadInstrumentsSGIX && glStartInstrumentsSGIX && glStopInstrumentsSGIX) { + EnableExtension(_GL_SGIX_instruments); + if (m_debug && doDebugMessages) + std::cout << "Enabled GL_SGIX_instruments" << std::endl; + } else { + std::cout << "ERROR: GL_SGIX_instruments implementation is broken!" << std::endl; + } + } +#endif + + if (QueryExtension("GL_SGIX_texture_scale_bias")) + { + EnableExtension(_GL_SGIX_texture_scale_bias); + if (m_debug && doDebugMessages) + std::cout << "Enabled GL_SGIX_texture_scale_bias" << std::endl; + } + +#if defined(GL_SGIX_framezoom) + if (QueryExtension("GL_SGIX_framezoom")) + { + glFrameZoomSGIX = reinterpret_cast(bglGetProcAddress((const GLubyte *) "glFrameZoomSGIX")); + if (glFrameZoomSGIX) { + EnableExtension(_GL_SGIX_framezoom); + if (m_debug && doDebugMessages) + std::cout << "Enabled GL_SGIX_framezoom" << std::endl; + } else { + std::cout << "ERROR: GL_SGIX_framezoom implementation is broken!" << std::endl; + } + } +#endif + +#if defined(GL_SGIX_tag_sample_buffer) + if (QueryExtension("GL_SGIX_tag_sample_buffer")) + { + glTagSampleBufferSGIX = reinterpret_cast(bglGetProcAddress((const GLubyte *) "glTagSampleBufferSGIX")); + if (glTagSampleBufferSGIX) { + EnableExtension(_GL_SGIX_tag_sample_buffer); + if (m_debug && doDebugMessages) + std::cout << "Enabled GL_SGIX_tag_sample_buffer" << std::endl; + } else { + std::cout << "ERROR: GL_SGIX_tag_sample_buffer implementation is broken!" << std::endl; + } + } +#endif + +#if defined(GL_SGIX_reference_plane) + if (QueryExtension("GL_SGIX_reference_plane")) + { + glReferencePlaneSGIX = reinterpret_cast(bglGetProcAddress((const GLubyte *) "glReferencePlaneSGIX")); + if (glReferencePlaneSGIX) { + EnableExtension(_GL_SGIX_reference_plane); + if (m_debug && doDebugMessages) + std::cout << "Enabled GL_SGIX_reference_plane" << std::endl; + } else { + std::cout << "ERROR: GL_SGIX_reference_plane implementation is broken!" << std::endl; + } + } +#endif + +#if defined(GL_SGIX_flush_raster) + if (QueryExtension("GL_SGIX_flush_raster")) + { + glFlushRasterSGIX = reinterpret_cast(bglGetProcAddress((const GLubyte *) "glFlushRasterSGIX")); + if (glFlushRasterSGIX) { + EnableExtension(_GL_SGIX_flush_raster); + if (m_debug && doDebugMessages) + std::cout << "Enabled GL_SGIX_flush_raster" << std::endl; + } else { + std::cout << "ERROR: GL_SGIX_flush_raster implementation is broken!" << std::endl; + } + } +#endif + + if (QueryExtension("GL_SGIX_depth_texture")) + { + EnableExtension(_GL_SGIX_depth_texture); + if (m_debug && doDebugMessages) + std::cout << "Enabled GL_SGIX_depth_texture" << std::endl; + } + +#if defined(GL_SGIS_fog_function) + if (QueryExtension("GL_SGIS_fog_function")) + { + glFogFuncSGIS = reinterpret_cast(bglGetProcAddress((const GLubyte *) "glFogFuncSGIS")); + glGetFogFuncSGIS = reinterpret_cast(bglGetProcAddress((const GLubyte *) "glGetFogFuncSGIS")); + if (glFogFuncSGIS && glGetFogFuncSGIS) { + EnableExtension(_GL_SGIS_fog_function); + if (m_debug && doDebugMessages) + std::cout << "Enabled GL_SGIS_fog_function" << std::endl; + } else { + std::cout << "ERROR: GL_SGIS_fog_function implementation is broken!" << std::endl; + } + } +#endif + + if (QueryExtension("GL_SGIX_fog_offset")) + { + EnableExtension(_GL_SGIX_fog_offset); + if (m_debug && doDebugMessages) + std::cout << "Enabled GL_SGIX_fog_offset" << std::endl; + } + +#if defined(GL_HP_image_transform) + if (QueryExtension("GL_HP_image_transform")) + { + glImageTransformParameteriHP = reinterpret_cast(bglGetProcAddress((const GLubyte *) "glImageTransformParameteriHP")); + glImageTransformParameterfHP = reinterpret_cast(bglGetProcAddress((const GLubyte *) "glImageTransformParameterfHP")); + glImageTransformParameterivHP = reinterpret_cast(bglGetProcAddress((const GLubyte *) "glImageTransformParameterivHP")); + glImageTransformParameterfvHP = reinterpret_cast(bglGetProcAddress((const GLubyte *) "glImageTransformParameterfvHP")); + glGetImageTransformParameterivHP = reinterpret_cast(bglGetProcAddress((const GLubyte *) "glGetImageTransformParameterivHP")); + glGetImageTransformParameterfvHP = reinterpret_cast(bglGetProcAddress((const GLubyte *) "glGetImageTransformParameterfvHP")); + if (glImageTransformParameteriHP && glImageTransformParameterfHP && glImageTransformParameterivHP && glImageTransformParameterfvHP && glGetImageTransformParameterivHP && glGetImageTransformParameterfvHP) { + EnableExtension(_GL_HP_image_transform); + if (m_debug && doDebugMessages) + std::cout << "Enabled GL_HP_image_transform" << std::endl; + } else { + std::cout << "ERROR: GL_HP_image_transform implementation is broken!" << std::endl; + } + } +#endif + + if (QueryExtension("GL_HP_convolution_border_modes")) + { + EnableExtension(_GL_HP_convolution_border_modes); + if (m_debug && doDebugMessages) + std::cout << "Enabled GL_HP_convolution_border_modes" << std::endl; + } + + if (QueryExtension("GL_SGIX_texture_add_env")) + { + EnableExtension(_GL_SGIX_texture_add_env); + if (m_debug && doDebugMessages) + std::cout << "Enabled GL_SGIX_texture_add_env" << std::endl; + } + +#if defined(GL_EXT_color_subtable) + if (QueryExtension("GL_EXT_color_subtable")) + { + glColorSubTableEXT = reinterpret_cast(bglGetProcAddress((const GLubyte *) "glColorSubTableEXT")); + glCopyColorSubTableEXT = reinterpret_cast(bglGetProcAddress((const GLubyte *) "glCopyColorSubTableEXT")); + if (glColorSubTableEXT && glCopyColorSubTableEXT) { + EnableExtension(_GL_EXT_color_subtable); + if (m_debug && doDebugMessages) + std::cout << "Enabled GL_EXT_color_subtable" << std::endl; + } else { + std::cout << "ERROR: GL_EXT_color_subtable implementation is broken!" << std::endl; + } + } +#endif + + if (QueryExtension("GL_PGI_vertex_hints")) + { + EnableExtension(_GL_PGI_vertex_hints); + if (m_debug && doDebugMessages) + std::cout << "Enabled GL_PGI_vertex_hints" << std::endl; + } + +#if defined(GL_PGI_misc_hints) + if (QueryExtension("GL_PGI_misc_hints")) + { + glHintPGI = reinterpret_cast(bglGetProcAddress((const GLubyte *) "glHintPGI")); + if (glHintPGI) { + EnableExtension(_GL_PGI_misc_hints); + if (m_debug && doDebugMessages) + std::cout << "Enabled GL_PGI_misc_hints" << std::endl; + } else { + std::cout << "ERROR: GL_PGI_misc_hints implementation is broken!" << std::endl; + } + } +#endif + +#if defined(GL_EXT_paletted_texture) + if (QueryExtension("GL_EXT_paletted_texture")) + { + glColorTableEXT = reinterpret_cast(bglGetProcAddress((const GLubyte *) "glColorTableEXT")); + glGetColorTableEXT = reinterpret_cast(bglGetProcAddress((const GLubyte *) "glGetColorTableEXT")); + glGetColorTableParameterivEXT = reinterpret_cast(bglGetProcAddress((const GLubyte *) "glGetColorTableParameterivEXT")); + glGetColorTableParameterfvEXT = reinterpret_cast(bglGetProcAddress((const GLubyte *) "glGetColorTableParameterfvEXT")); + if (glColorTableEXT && glGetColorTableEXT && glGetColorTableParameterivEXT && glGetColorTableParameterfvEXT) { + EnableExtension(_GL_EXT_paletted_texture); + if (m_debug && doDebugMessages) + std::cout << "Enabled GL_EXT_paletted_texture" << std::endl; + } else { + std::cout << "ERROR: GL_EXT_paletted_texture implementation is broken!" << std::endl; + } + } +#endif + + if (QueryExtension("GL_EXT_clip_volume_hint")) + { + EnableExtension(_GL_EXT_clip_volume_hint); + if (m_debug && doDebugMessages) + std::cout << "Enabled GL_EXT_clip_volume_hint" << std::endl; + } + +#if defined(GL_SGIX_list_priority) + if (QueryExtension("GL_SGIX_list_priority")) + { + glGetListParameterfvSGIX = reinterpret_cast(bglGetProcAddress((const GLubyte *) "glGetListParameterfvSGIX")); + glGetListParameterivSGIX = reinterpret_cast(bglGetProcAddress((const GLubyte *) "glGetListParameterivSGIX")); + glListParameterfSGIX = reinterpret_cast(bglGetProcAddress((const GLubyte *) "glListParameterfSGIX")); + glListParameterfvSGIX = reinterpret_cast(bglGetProcAddress((const GLubyte *) "glListParameterfvSGIX")); + glListParameteriSGIX = reinterpret_cast(bglGetProcAddress((const GLubyte *) "glListParameteriSGIX")); + glListParameterivSGIX = reinterpret_cast(bglGetProcAddress((const GLubyte *) "glListParameterivSGIX")); + if (glGetListParameterfvSGIX && glGetListParameterivSGIX && glListParameterfSGIX && glListParameterfvSGIX && glListParameteriSGIX && glListParameterivSGIX) { + EnableExtension(_GL_SGIX_list_priority); + if (m_debug && doDebugMessages) + std::cout << "Enabled GL_SGIX_list_priority" << std::endl; + } else { + std::cout << "ERROR: GL_SGIX_list_priority implementation is broken!" << std::endl; + } + } +#endif + + if (QueryExtension("GL_SGIX_ir_instrument1")) + { + EnableExtension(_GL_SGIX_ir_instrument1); + if (m_debug && doDebugMessages) + std::cout << "Enabled GL_SGIX_ir_instrument1" << std::endl; + } + + if (QueryExtension("GL_SGIX_texture_lod_bias")) + { + EnableExtension(_GL_SGIX_texture_lod_bias); + if (m_debug && doDebugMessages) + std::cout << "Enabled GL_SGIX_texture_lod_bias" << std::endl; + } + + if (QueryExtension("GL_SGIX_shadow_ambient")) + { + EnableExtension(_GL_SGIX_shadow_ambient); + if (m_debug && doDebugMessages) + std::cout << "Enabled GL_SGIX_shadow_ambient" << std::endl; + } + + if (QueryExtension("GL_EXT_index_texture")) + { + EnableExtension(_GL_EXT_index_texture); + if (m_debug && doDebugMessages) + std::cout << "Enabled GL_EXT_index_texture" << std::endl; + } + +#if defined(GL_EXT_index_material) + if (QueryExtension("GL_EXT_index_material")) + { + glIndexMaterialEXT = reinterpret_cast(bglGetProcAddress((const GLubyte *) "glIndexMaterialEXT")); + if (glIndexMaterialEXT) { + EnableExtension(_GL_EXT_index_material); + if (m_debug && doDebugMessages) + std::cout << "Enabled GL_EXT_index_material" << std::endl; + } else { + std::cout << "ERROR: GL_EXT_index_material implementation is broken!" << std::endl; + } + } +#endif + +#if defined(GL_EXT_index_func) + if (QueryExtension("GL_EXT_index_func")) + { + glIndexFuncEXT = reinterpret_cast(bglGetProcAddress((const GLubyte *) "glIndexFuncEXT")); + if (glIndexFuncEXT) { + EnableExtension(_GL_EXT_index_func); + if (m_debug && doDebugMessages) + std::cout << "Enabled GL_EXT_index_func" << std::endl; + } else { + std::cout << "ERROR: GL_EXT_index_func implementation is broken!" << std::endl; + } + } +#endif + + if (QueryExtension("GL_EXT_index_array_formats")) + { + EnableExtension(_GL_EXT_index_array_formats); + if (m_debug && doDebugMessages) + std::cout << "Enabled GL_EXT_index_array_formats" << std::endl; + } + +#if defined(GL_EXT_cull_vertex) + if (QueryExtension("GL_EXT_cull_vertex")) + { + glCullParameterdvEXT = reinterpret_cast(bglGetProcAddress((const GLubyte *) "glCullParameterdvEXT")); + glCullParameterfvEXT = reinterpret_cast(bglGetProcAddress((const GLubyte *) "glCullParameterfvEXT")); + if (glCullParameterdvEXT && glCullParameterfvEXT) { + EnableExtension(_GL_EXT_cull_vertex); + if (m_debug && doDebugMessages) + std::cout << "Enabled GL_EXT_cull_vertex" << std::endl; + } else { + std::cout << "ERROR: GL_EXT_cull_vertex implementation is broken!" << std::endl; + } + } +#endif + + if (QueryExtension("GL_SGIX_ycrcb")) + { + EnableExtension(_GL_SGIX_ycrcb); + if (m_debug && doDebugMessages) + std::cout << "Enabled GL_SGIX_ycrcb" << std::endl; + } + + if (QueryExtension("GL_IBM_rasterpos_clip")) + { + EnableExtension(_GL_IBM_rasterpos_clip); + if (m_debug && doDebugMessages) + std::cout << "Enabled GL_IBM_rasterpos_clip" << std::endl; + } + + if (QueryExtension("GL_HP_texture_lighting")) + { + EnableExtension(_GL_HP_texture_lighting); + if (m_debug && doDebugMessages) + std::cout << "Enabled GL_HP_texture_lighting" << std::endl; + } + +#if defined(GL_EXT_draw_range_elements) + if (QueryExtension("GL_EXT_draw_range_elements")) + { + glDrawRangeElementsEXT = reinterpret_cast(bglGetProcAddress((const GLubyte *) "glDrawRangeElementsEXT")); + if (glDrawRangeElementsEXT) { + EnableExtension(_GL_EXT_draw_range_elements); + if (m_debug && doDebugMessages) + std::cout << "Enabled GL_EXT_draw_range_elements" << std::endl; + } else { + std::cout << "ERROR: GL_EXT_draw_range_elements implementation is broken!" << std::endl; + } + } +#endif + + if (QueryExtension("GL_WIN_phong_shading")) + { + EnableExtension(_GL_WIN_phong_shading); + if (m_debug && doDebugMessages) + std::cout << "Enabled GL_WIN_phong_shading" << std::endl; + } + + if (QueryExtension("GL_WIN_specular_fog")) + { + EnableExtension(_GL_WIN_specular_fog); + if (m_debug && doDebugMessages) + std::cout << "Enabled GL_WIN_specular_fog" << std::endl; + } + +#if defined(GL_EXT_light_texture) + if (QueryExtension("GL_EXT_light_texture")) + { + glApplyTextureEXT = reinterpret_cast(bglGetProcAddress((const GLubyte *) "glApplyTextureEXT")); + glTextureLightEXT = reinterpret_cast(bglGetProcAddress((const GLubyte *) "glTextureLightEXT")); + glTextureMaterialEXT = reinterpret_cast(bglGetProcAddress((const GLubyte *) "glTextureMaterialEXT")); + if (glApplyTextureEXT && glTextureLightEXT && glTextureMaterialEXT) { + EnableExtension(_GL_EXT_light_texture); + if (m_debug && doDebugMessages) + std::cout << "Enabled GL_EXT_light_texture" << std::endl; + } else { + std::cout << "ERROR: GL_EXT_light_texture implementation is broken!" << std::endl; + } + } +#endif + + if (QueryExtension("GL_SGIX_blend_alpha_minmax")) + { + EnableExtension(_GL_SGIX_blend_alpha_minmax); + if (m_debug && doDebugMessages) + std::cout << "Enabled GL_SGIX_blend_alpha_minmax" << std::endl; + } + + if (QueryExtension("GL_EXT_bgra")) + { + EnableExtension(_GL_EXT_bgra); + if (m_debug && doDebugMessages) + std::cout << "Enabled GL_EXT_bgra" << std::endl; + } + +#if defined(GL_SGIX_async) + if (QueryExtension("GL_SGIX_async")) + { + glAsyncMarkerSGIX = reinterpret_cast(bglGetProcAddress((const GLubyte *) "glAsyncMarkerSGIX")); + glFinishAsyncSGIX = reinterpret_cast(bglGetProcAddress((const GLubyte *) "glFinishAsyncSGIX")); + glPollAsyncSGIX = reinterpret_cast(bglGetProcAddress((const GLubyte *) "glPollAsyncSGIX")); + glGenAsyncMarkersSGIX = reinterpret_cast(bglGetProcAddress((const GLubyte *) "glGenAsyncMarkersSGIX")); + glDeleteAsyncMarkersSGIX = reinterpret_cast(bglGetProcAddress((const GLubyte *) "glDeleteAsyncMarkersSGIX")); + glIsAsyncMarkerSGIX = reinterpret_cast(bglGetProcAddress((const GLubyte *) "glIsAsyncMarkerSGIX")); + if (glAsyncMarkerSGIX && glFinishAsyncSGIX && glPollAsyncSGIX && glGenAsyncMarkersSGIX && glDeleteAsyncMarkersSGIX && glIsAsyncMarkerSGIX) { + EnableExtension(_GL_SGIX_async); + if (m_debug && doDebugMessages) + std::cout << "Enabled GL_SGIX_async" << std::endl; + } else { + std::cout << "ERROR: GL_SGIX_async implementation is broken!" << std::endl; + } + } +#endif + + if (QueryExtension("GL_SGIX_async_pixel")) + { + EnableExtension(_GL_SGIX_async_pixel); + if (m_debug && doDebugMessages) + std::cout << "Enabled GL_SGIX_async_pixel" << std::endl; + } + + if (QueryExtension("GL_SGIX_async_histogram")) + { + EnableExtension(_GL_SGIX_async_histogram); + if (m_debug && doDebugMessages) + std::cout << "Enabled GL_SGIX_async_histogram" << std::endl; + } + +#if defined(GL_INTEL_parallel_arrays) + if (QueryExtension("GL_INTEL_parallel_arrays")) + { + glVertexPointervINTEL = reinterpret_cast(bglGetProcAddress((const GLubyte *) "glVertexPointervINTEL")); + glNormalPointervINTEL = reinterpret_cast(bglGetProcAddress((const GLubyte *) "glNormalPointervINTEL")); + glColorPointervINTEL = reinterpret_cast(bglGetProcAddress((const GLubyte *) "glColorPointervINTEL")); + glTexCoordPointervINTEL = reinterpret_cast(bglGetProcAddress((const GLubyte *) "glTexCoordPointervINTEL")); + if (glVertexPointervINTEL && glNormalPointervINTEL && glColorPointervINTEL && glTexCoordPointervINTEL) { + EnableExtension(_GL_INTEL_parallel_arrays); + if (m_debug && doDebugMessages) + std::cout << "Enabled GL_INTEL_parallel_arrays" << std::endl; + } else { + std::cout << "ERROR: GL_INTEL_parallel_arrays implementation is broken!" << std::endl; + } + } +#endif + + if (QueryExtension("GL_HP_occlusion_test")) + { + EnableExtension(_GL_HP_occlusion_test); + if (m_debug && doDebugMessages) + std::cout << "Enabled GL_HP_occlusion_test" << std::endl; + } + +#if defined(GL_EXT_pixel_transform) + if (QueryExtension("GL_EXT_pixel_transform")) + { + glPixelTransformParameteriEXT = reinterpret_cast(bglGetProcAddress((const GLubyte *) "glPixelTransformParameteriEXT")); + glPixelTransformParameterfEXT = reinterpret_cast(bglGetProcAddress((const GLubyte *) "glPixelTransformParameterfEXT")); + glPixelTransformParameterivEXT = reinterpret_cast(bglGetProcAddress((const GLubyte *) "glPixelTransformParameterivEXT")); + glPixelTransformParameterfvEXT = reinterpret_cast(bglGetProcAddress((const GLubyte *) "glPixelTransformParameterfvEXT")); + if (glPixelTransformParameteriEXT && glPixelTransformParameterfEXT && glPixelTransformParameterivEXT && glPixelTransformParameterfvEXT) { + EnableExtension(_GL_EXT_pixel_transform); + if (m_debug && doDebugMessages) + std::cout << "Enabled GL_EXT_pixel_transform" << std::endl; + } else { + std::cout << "ERROR: GL_EXT_pixel_transform implementation is broken!" << std::endl; + } + } +#endif + + if (QueryExtension("GL_EXT_pixel_transform_color_table")) + { + EnableExtension(_GL_EXT_pixel_transform_color_table); + if (m_debug && doDebugMessages) + std::cout << "Enabled GL_EXT_pixel_transform_color_table" << std::endl; + } + + if (QueryExtension("GL_EXT_shared_texture_palette")) + { + EnableExtension(_GL_EXT_shared_texture_palette); + if (m_debug && doDebugMessages) + std::cout << "Enabled GL_EXT_shared_texture_palette" << std::endl; + } + + if (QueryExtension("GL_EXT_separate_specular_color")) + { + EnableExtension(_GL_EXT_separate_specular_color); + if (m_debug && doDebugMessages) + std::cout << "Enabled GL_EXT_separate_specular_color" << std::endl; + } + +#if defined(GL_EXT_secondary_color) + if (QueryExtension("GL_EXT_secondary_color")) + { + glSecondaryColor3bEXT = reinterpret_cast(bglGetProcAddress((const GLubyte *) "glSecondaryColor3bEXT")); + glSecondaryColor3bvEXT = reinterpret_cast(bglGetProcAddress((const GLubyte *) "glSecondaryColor3bvEXT")); + glSecondaryColor3dEXT = reinterpret_cast(bglGetProcAddress((const GLubyte *) "glSecondaryColor3dEXT")); + glSecondaryColor3dvEXT = reinterpret_cast(bglGetProcAddress((const GLubyte *) "glSecondaryColor3dvEXT")); + glSecondaryColor3fEXT = reinterpret_cast(bglGetProcAddress((const GLubyte *) "glSecondaryColor3fEXT")); + glSecondaryColor3fvEXT = reinterpret_cast(bglGetProcAddress((const GLubyte *) "glSecondaryColor3fvEXT")); + glSecondaryColor3iEXT = reinterpret_cast(bglGetProcAddress((const GLubyte *) "glSecondaryColor3iEXT")); + glSecondaryColor3ivEXT = reinterpret_cast(bglGetProcAddress((const GLubyte *) "glSecondaryColor3ivEXT")); + glSecondaryColor3sEXT = reinterpret_cast(bglGetProcAddress((const GLubyte *) "glSecondaryColor3sEXT")); + glSecondaryColor3svEXT = reinterpret_cast(bglGetProcAddress((const GLubyte *) "glSecondaryColor3svEXT")); + glSecondaryColor3ubEXT = reinterpret_cast(bglGetProcAddress((const GLubyte *) "glSecondaryColor3ubEXT")); + glSecondaryColor3ubvEXT = reinterpret_cast(bglGetProcAddress((const GLubyte *) "glSecondaryColor3ubvEXT")); + glSecondaryColor3uiEXT = reinterpret_cast(bglGetProcAddress((const GLubyte *) "glSecondaryColor3uiEXT")); + glSecondaryColor3uivEXT = reinterpret_cast(bglGetProcAddress((const GLubyte *) "glSecondaryColor3uivEXT")); + glSecondaryColor3usEXT = reinterpret_cast(bglGetProcAddress((const GLubyte *) "glSecondaryColor3usEXT")); + glSecondaryColor3usvEXT = reinterpret_cast(bglGetProcAddress((const GLubyte *) "glSecondaryColor3usvEXT")); + glSecondaryColorPointerEXT = reinterpret_cast(bglGetProcAddress((const GLubyte *) "glSecondaryColorPointerEXT")); + if (glSecondaryColor3bEXT && glSecondaryColor3bvEXT && glSecondaryColor3dEXT && glSecondaryColor3dvEXT && glSecondaryColor3fEXT && glSecondaryColor3fvEXT && glSecondaryColor3iEXT && glSecondaryColor3ivEXT && glSecondaryColor3sEXT && glSecondaryColor3svEXT && glSecondaryColor3ubEXT && glSecondaryColor3ubvEXT && glSecondaryColor3uiEXT && glSecondaryColor3uivEXT && glSecondaryColor3usEXT && glSecondaryColor3usvEXT && glSecondaryColorPointerEXT) { + EnableExtension(_GL_EXT_secondary_color); + if (m_debug && doDebugMessages) + std::cout << "Enabled GL_EXT_secondary_color" << std::endl; + } else { + std::cout << "ERROR: GL_EXT_secondary_color implementation is broken!" << std::endl; + } + } +#endif + +#if defined(GL_EXT_texture_perturb_normal) + if (QueryExtension("GL_EXT_texture_perturb_normal")) + { + glTextureNormalEXT = reinterpret_cast(bglGetProcAddress((const GLubyte *) "glTextureNormalEXT")); + if (glTextureNormalEXT) { + EnableExtension(_GL_EXT_texture_perturb_normal); + if (m_debug && doDebugMessages) + std::cout << "Enabled GL_EXT_texture_perturb_normal" << std::endl; + } else { + std::cout << "ERROR: GL_EXT_texture_perturb_normal implementation is broken!" << std::endl; + } + } +#endif + +#if defined(GL_EXT_multi_draw_arrays) + if (QueryExtension("GL_EXT_multi_draw_arrays")) + { + glMultiDrawArraysEXT = reinterpret_cast(bglGetProcAddress((const GLubyte *) "glMultiDrawArraysEXT")); + glMultiDrawElementsEXT = reinterpret_cast(bglGetProcAddress((const GLubyte *) "glMultiDrawElementsEXT")); + if (glMultiDrawArraysEXT && glMultiDrawElementsEXT) { + EnableExtension(_GL_EXT_multi_draw_arrays); + if (m_debug && doDebugMessages) + std::cout << "Enabled GL_EXT_multi_draw_arrays" << std::endl; + } else { + std::cout << "ERROR: GL_EXT_multi_draw_arrays implementation is broken!" << std::endl; + } + } +#endif + +#if defined(GL_EXT_fog_coord) + if (QueryExtension("GL_EXT_fog_coord")) + { + glFogCoordfEXT = reinterpret_cast(bglGetProcAddress((const GLubyte *) "glFogCoordfEXT")); + glFogCoordfvEXT = reinterpret_cast(bglGetProcAddress((const GLubyte *) "glFogCoordfvEXT")); + glFogCoorddEXT = reinterpret_cast(bglGetProcAddress((const GLubyte *) "glFogCoorddEXT")); + glFogCoorddvEXT = reinterpret_cast(bglGetProcAddress((const GLubyte *) "glFogCoorddvEXT")); + glFogCoordPointerEXT = reinterpret_cast(bglGetProcAddress((const GLubyte *) "glFogCoordPointerEXT")); + if (glFogCoordfEXT && glFogCoordfvEXT && glFogCoorddEXT && glFogCoorddvEXT && glFogCoordPointerEXT) { + EnableExtension(_GL_EXT_fog_coord); + if (m_debug && doDebugMessages) + std::cout << "Enabled GL_EXT_fog_coord" << std::endl; + } else { + std::cout << "ERROR: GL_EXT_fog_coord implementation is broken!" << std::endl; + } + } +#endif + + if (QueryExtension("GL_REND_screen_coordinates")) + { + EnableExtension(_GL_REND_screen_coordinates); + if (m_debug && doDebugMessages) + std::cout << "Enabled GL_REND_screen_coordinates" << std::endl; + } + +#if defined(GL_EXT_coordinate_frame) + if (QueryExtension("GL_EXT_coordinate_frame")) + { + glTangent3bEXT = reinterpret_cast(bglGetProcAddress((const GLubyte *) "glTangent3bEXT")); + glTangent3bvEXT = reinterpret_cast(bglGetProcAddress((const GLubyte *) "glTangent3bvEXT")); + glTangent3dEXT = reinterpret_cast(bglGetProcAddress((const GLubyte *) "glTangent3dEXT")); + glTangent3dvEXT = reinterpret_cast(bglGetProcAddress((const GLubyte *) "glTangent3dvEXT")); + glTangent3fEXT = reinterpret_cast(bglGetProcAddress((const GLubyte *) "glTangent3fEXT")); + glTangent3fvEXT = reinterpret_cast(bglGetProcAddress((const GLubyte *) "glTangent3fvEXT")); + glTangent3iEXT = reinterpret_cast(bglGetProcAddress((const GLubyte *) "glTangent3iEXT")); + glTangent3ivEXT = reinterpret_cast(bglGetProcAddress((const GLubyte *) "glTangent3ivEXT")); + glTangent3sEXT = reinterpret_cast(bglGetProcAddress((const GLubyte *) "glTangent3sEXT")); + glTangent3svEXT = reinterpret_cast(bglGetProcAddress((const GLubyte *) "glTangent3svEXT")); + glBinormal3bEXT = reinterpret_cast(bglGetProcAddress((const GLubyte *) "glBinormal3bEXT")); + glBinormal3bvEXT = reinterpret_cast(bglGetProcAddress((const GLubyte *) "glBinormal3bvEXT")); + glBinormal3dEXT = reinterpret_cast(bglGetProcAddress((const GLubyte *) "glBinormal3dEXT")); + glBinormal3dvEXT = reinterpret_cast(bglGetProcAddress((const GLubyte *) "glBinormal3dvEXT")); + glBinormal3fEXT = reinterpret_cast(bglGetProcAddress((const GLubyte *) "glBinormal3fEXT")); + glBinormal3fvEXT = reinterpret_cast(bglGetProcAddress((const GLubyte *) "glBinormal3fvEXT")); + glBinormal3iEXT = reinterpret_cast(bglGetProcAddress((const GLubyte *) "glBinormal3iEXT")); + glBinormal3ivEXT = reinterpret_cast(bglGetProcAddress((const GLubyte *) "glBinormal3ivEXT")); + glBinormal3sEXT = reinterpret_cast(bglGetProcAddress((const GLubyte *) "glBinormal3sEXT")); + glBinormal3svEXT = reinterpret_cast(bglGetProcAddress((const GLubyte *) "glBinormal3svEXT")); + glTangentPointerEXT = reinterpret_cast(bglGetProcAddress((const GLubyte *) "glTangentPointerEXT")); + glBinormalPointerEXT = reinterpret_cast(bglGetProcAddress((const GLubyte *) "glBinormalPointerEXT")); + if (glTangent3bEXT && glTangent3bvEXT && glTangent3dEXT && glTangent3dvEXT && glTangent3fEXT && glTangent3fvEXT && glTangent3iEXT && glTangent3ivEXT && glTangent3sEXT && glTangent3svEXT && glBinormal3bEXT && glBinormal3bvEXT && glBinormal3dEXT && glBinormal3dvEXT && glBinormal3fEXT && glBinormal3fvEXT && glBinormal3iEXT && glBinormal3ivEXT && glBinormal3sEXT && glBinormal3svEXT && glTangentPointerEXT && glBinormalPointerEXT) { + EnableExtension(_GL_EXT_coordinate_frame); + if (m_debug && doDebugMessages) + std::cout << "Enabled GL_EXT_coordinate_frame" << std::endl; + } else { + std::cout << "ERROR: GL_EXT_coordinate_frame implementation is broken!" << std::endl; + } + } +#endif + + if (QueryExtension("GL_EXT_texture_env_combine")) + { + EnableExtension(_GL_EXT_texture_env_combine); + if (m_debug && doDebugMessages) + std::cout << "Enabled GL_EXT_texture_env_combine" << std::endl; + } + + if (QueryExtension("GL_APPLE_specular_vector")) + { + EnableExtension(_GL_APPLE_specular_vector); + if (m_debug && doDebugMessages) + std::cout << "Enabled GL_APPLE_specular_vector" << std::endl; + } + + if (QueryExtension("GL_APPLE_transform_hint")) + { + EnableExtension(_GL_APPLE_transform_hint); + if (m_debug && doDebugMessages) + std::cout << "Enabled GL_APPLE_transform_hint" << std::endl; + } + +#if defined(GL_SUNX_constant_data) + if (QueryExtension("GL_SUNX_constant_data")) + { + glFinishTextureSUNX = reinterpret_cast(bglGetProcAddress((const GLubyte *) "glFinishTextureSUNX")); + if (glFinishTextureSUNX) { + EnableExtension(_GL_SUNX_constant_data); + if (m_debug && doDebugMessages) + std::cout << "Enabled GL_SUNX_constant_data" << std::endl; + } else { + std::cout << "ERROR: GL_SUNX_constant_data implementation is broken!" << std::endl; + } + } +#endif + +#if defined(GL_SUN_global_alpha) + if (QueryExtension("GL_SUN_global_alpha")) + { + glGlobalAlphaFactorbSUN = reinterpret_cast(bglGetProcAddress((const GLubyte *) "glGlobalAlphaFactorbSUN")); + glGlobalAlphaFactorsSUN = reinterpret_cast(bglGetProcAddress((const GLubyte *) "glGlobalAlphaFactorsSUN")); + glGlobalAlphaFactoriSUN = reinterpret_cast(bglGetProcAddress((const GLubyte *) "glGlobalAlphaFactoriSUN")); + glGlobalAlphaFactorfSUN = reinterpret_cast(bglGetProcAddress((const GLubyte *) "glGlobalAlphaFactorfSUN")); + glGlobalAlphaFactordSUN = reinterpret_cast(bglGetProcAddress((const GLubyte *) "glGlobalAlphaFactordSUN")); + glGlobalAlphaFactorubSUN = reinterpret_cast(bglGetProcAddress((const GLubyte *) "glGlobalAlphaFactorubSUN")); + glGlobalAlphaFactorusSUN = reinterpret_cast(bglGetProcAddress((const GLubyte *) "glGlobalAlphaFactorusSUN")); + glGlobalAlphaFactoruiSUN = reinterpret_cast(bglGetProcAddress((const GLubyte *) "glGlobalAlphaFactoruiSUN")); + if (glGlobalAlphaFactorbSUN && glGlobalAlphaFactorsSUN && glGlobalAlphaFactoriSUN && glGlobalAlphaFactorfSUN && glGlobalAlphaFactordSUN && glGlobalAlphaFactorubSUN && glGlobalAlphaFactorusSUN && glGlobalAlphaFactoruiSUN) { + EnableExtension(_GL_SUN_global_alpha); + if (m_debug && doDebugMessages) + std::cout << "Enabled GL_SUN_global_alpha" << std::endl; + } else { + std::cout << "ERROR: GL_SUN_global_alpha implementation is broken!" << std::endl; + } + } +#endif + +#if defined(GL_SUN_triangle_list) + if (QueryExtension("GL_SUN_triangle_list")) + { + glReplacementCodeuiSUN = reinterpret_cast(bglGetProcAddress((const GLubyte *) "glReplacementCodeuiSUN")); + glReplacementCodeusSUN = reinterpret_cast(bglGetProcAddress((const GLubyte *) "glReplacementCodeusSUN")); + glReplacementCodeubSUN = reinterpret_cast(bglGetProcAddress((const GLubyte *) "glReplacementCodeubSUN")); + glReplacementCodeuivSUN = reinterpret_cast(bglGetProcAddress((const GLubyte *) "glReplacementCodeuivSUN")); + glReplacementCodeusvSUN = reinterpret_cast(bglGetProcAddress((const GLubyte *) "glReplacementCodeusvSUN")); + glReplacementCodeubvSUN = reinterpret_cast(bglGetProcAddress((const GLubyte *) "glReplacementCodeubvSUN")); + glReplacementCodePointerSUN = reinterpret_cast(bglGetProcAddress((const GLubyte *) "glReplacementCodePointerSUN")); + if (glReplacementCodeuiSUN && glReplacementCodeusSUN && glReplacementCodeubSUN && glReplacementCodeuivSUN && glReplacementCodeusvSUN && glReplacementCodeubvSUN && glReplacementCodePointerSUN) { + EnableExtension(_GL_SUN_triangle_list); + if (m_debug && doDebugMessages) + std::cout << "Enabled GL_SUN_triangle_list" << std::endl; + } else { + std::cout << "ERROR: GL_SUN_triangle_list implementation is broken!" << std::endl; + } + } +#endif + +#if defined(GL_SUN_vertex) + if (QueryExtension("GL_SUN_vertex")) + { + glColor4ubVertex2fSUN = reinterpret_cast(bglGetProcAddress((const GLubyte *) "glColor4ubVertex2fSUN")); + glColor4ubVertex2fvSUN = reinterpret_cast(bglGetProcAddress((const GLubyte *) "glColor4ubVertex2fvSUN")); + glColor4ubVertex3fSUN = reinterpret_cast(bglGetProcAddress((const GLubyte *) "glColor4ubVertex3fSUN")); + glColor4ubVertex3fvSUN = reinterpret_cast(bglGetProcAddress((const GLubyte *) "glColor4ubVertex3fvSUN")); + glColor3fVertex3fSUN = reinterpret_cast(bglGetProcAddress((const GLubyte *) "glColor3fVertex3fSUN")); + glColor3fVertex3fvSUN = reinterpret_cast(bglGetProcAddress((const GLubyte *) "glColor3fVertex3fvSUN")); + glNormal3fVertex3fSUN = reinterpret_cast(bglGetProcAddress((const GLubyte *) "glNormal3fVertex3fSUN")); + glNormal3fVertex3fvSUN = reinterpret_cast(bglGetProcAddress((const GLubyte *) "glNormal3fVertex3fvSUN")); + glColor4fNormal3fVertex3fSUN = reinterpret_cast(bglGetProcAddress((const GLubyte *) "glColor4fNormal3fVertex3fSUN")); + glColor4fNormal3fVertex3fvSUN = reinterpret_cast(bglGetProcAddress((const GLubyte *) "glColor4fNormal3fVertex3fvSUN")); + glTexCoord2fVertex3fSUN = reinterpret_cast(bglGetProcAddress((const GLubyte *) "glTexCoord2fVertex3fSUN")); + glTexCoord2fVertex3fvSUN = reinterpret_cast(bglGetProcAddress((const GLubyte *) "glTexCoord2fVertex3fvSUN")); + glTexCoord4fVertex4fSUN = reinterpret_cast(bglGetProcAddress((const GLubyte *) "glTexCoord4fVertex4fSUN")); + glTexCoord4fVertex4fvSUN = reinterpret_cast(bglGetProcAddress((const GLubyte *) "glTexCoord4fVertex4fvSUN")); + glTexCoord2fColor4ubVertex3fSUN = reinterpret_cast(bglGetProcAddress((const GLubyte *) "glTexCoord2fColor4ubVertex3fSUN")); + glTexCoord2fColor4ubVertex3fvSUN = reinterpret_cast(bglGetProcAddress((const GLubyte *) "glTexCoord2fColor4ubVertex3fvSUN")); + glTexCoord2fColor3fVertex3fSUN = reinterpret_cast(bglGetProcAddress((const GLubyte *) "glTexCoord2fColor3fVertex3fSUN")); + glTexCoord2fColor3fVertex3fvSUN = reinterpret_cast(bglGetProcAddress((const GLubyte *) "glTexCoord2fColor3fVertex3fvSUN")); + glTexCoord2fNormal3fVertex3fSUN = reinterpret_cast(bglGetProcAddress((const GLubyte *) "glTexCoord2fNormal3fVertex3fSUN")); + glTexCoord2fNormal3fVertex3fvSUN = reinterpret_cast(bglGetProcAddress((const GLubyte *) "glTexCoord2fNormal3fVertex3fvSUN")); + glTexCoord2fColor4fNormal3fVertex3fSUN = reinterpret_cast(bglGetProcAddress((const GLubyte *) "glTexCoord2fColor4fNormal3fVertex3fSUN")); + glTexCoord2fColor4fNormal3fVertex3fvSUN = reinterpret_cast(bglGetProcAddress((const GLubyte *) "glTexCoord2fColor4fNormal3fVertex3fvSUN")); + glTexCoord4fColor4fNormal3fVertex4fSUN = reinterpret_cast(bglGetProcAddress((const GLubyte *) "glTexCoord4fColor4fNormal3fVertex4fSUN")); + glTexCoord4fColor4fNormal3fVertex4fvSUN = reinterpret_cast(bglGetProcAddress((const GLubyte *) "glTexCoord4fColor4fNormal3fVertex4fvSUN")); + glReplacementCodeuiVertex3fSUN = reinterpret_cast(bglGetProcAddress((const GLubyte *) "glReplacementCodeuiVertex3fSUN")); + glReplacementCodeuiVertex3fvSUN = reinterpret_cast(bglGetProcAddress((const GLubyte *) "glReplacementCodeuiVertex3fvSUN")); + glReplacementCodeuiColor4ubVertex3fSUN = reinterpret_cast(bglGetProcAddress((const GLubyte *) "glReplacementCodeuiColor4ubVertex3fSUN")); + glReplacementCodeuiColor4ubVertex3fvSUN = reinterpret_cast(bglGetProcAddress((const GLubyte *) "glReplacementCodeuiColor4ubVertex3fvSUN")); + glReplacementCodeuiColor3fVertex3fSUN = reinterpret_cast(bglGetProcAddress((const GLubyte *) "glReplacementCodeuiColor3fVertex3fSUN")); + glReplacementCodeuiColor3fVertex3fvSUN = reinterpret_cast(bglGetProcAddress((const GLubyte *) "glReplacementCodeuiColor3fVertex3fvSUN")); + glReplacementCodeuiNormal3fVertex3fSUN = reinterpret_cast(bglGetProcAddress((const GLubyte *) "glReplacementCodeuiNormal3fVertex3fSUN")); + glReplacementCodeuiNormal3fVertex3fvSUN = reinterpret_cast(bglGetProcAddress((const GLubyte *) "glReplacementCodeuiNormal3fVertex3fvSUN")); + glReplacementCodeuiColor4fNormal3fVertex3fSUN = reinterpret_cast(bglGetProcAddress((const GLubyte *) "glReplacementCodeuiColor4fNormal3fVertex3fSUN")); + glReplacementCodeuiColor4fNormal3fVertex3fvSUN = reinterpret_cast(bglGetProcAddress((const GLubyte *) "glReplacementCodeuiColor4fNormal3fVertex3fvSUN")); + glReplacementCodeuiTexCoord2fVertex3fSUN = reinterpret_cast(bglGetProcAddress((const GLubyte *) "glReplacementCodeuiTexCoord2fVertex3fSUN")); + glReplacementCodeuiTexCoord2fVertex3fvSUN = reinterpret_cast(bglGetProcAddress((const GLubyte *) "glReplacementCodeuiTexCoord2fVertex3fvSUN")); + glReplacementCodeuiTexCoord2fNormal3fVertex3fSUN = reinterpret_cast(bglGetProcAddress((const GLubyte *) "glReplacementCodeuiTexCoord2fNormal3fVertex3fSUN")); + glReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN = reinterpret_cast(bglGetProcAddress((const GLubyte *) "glReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN")); + glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fSUN = reinterpret_cast(bglGetProcAddress((const GLubyte *) "glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fSUN")); + glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN = reinterpret_cast(bglGetProcAddress((const GLubyte *) "glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN")); + if (glColor4ubVertex2fSUN && glColor4ubVertex2fvSUN && glColor4ubVertex3fSUN && glColor4ubVertex3fvSUN && glColor3fVertex3fSUN && glColor3fVertex3fvSUN && glNormal3fVertex3fSUN && glNormal3fVertex3fvSUN && glColor4fNormal3fVertex3fSUN && glColor4fNormal3fVertex3fvSUN && glTexCoord2fVertex3fSUN && glTexCoord2fVertex3fvSUN && glTexCoord4fVertex4fSUN && glTexCoord4fVertex4fvSUN && glTexCoord2fColor4ubVertex3fSUN && glTexCoord2fColor4ubVertex3fvSUN && glTexCoord2fColor3fVertex3fSUN && glTexCoord2fColor3fVertex3fvSUN && glTexCoord2fNormal3fVertex3fSUN && glTexCoord2fNormal3fVertex3fvSUN && glTexCoord2fColor4fNormal3fVertex3fSUN && glTexCoord2fColor4fNormal3fVertex3fvSUN && glTexCoord4fColor4fNormal3fVertex4fSUN && glTexCoord4fColor4fNormal3fVertex4fvSUN && glReplacementCodeuiVertex3fSUN && glReplacementCodeuiVertex3fvSUN && glReplacementCodeuiColor4ubVertex3fSUN && glReplacementCodeuiColor4ubVertex3fvSUN && glReplacementCodeuiColor3fVertex3fSUN && glReplacementCodeuiColor3fVertex3fvSUN && glReplacementCodeuiNormal3fVertex3fSUN && glReplacementCodeuiNormal3fVertex3fvSUN && glReplacementCodeuiColor4fNormal3fVertex3fSUN && glReplacementCodeuiColor4fNormal3fVertex3fvSUN && glReplacementCodeuiTexCoord2fVertex3fSUN && glReplacementCodeuiTexCoord2fVertex3fvSUN && glReplacementCodeuiTexCoord2fNormal3fVertex3fSUN && glReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN && glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fSUN && glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN) { + EnableExtension(_GL_SUN_vertex); + if (m_debug && doDebugMessages) + std::cout << "Enabled GL_SUN_vertex" << std::endl; + } else { + std::cout << "ERROR: GL_SUN_vertex implementation is broken!" << std::endl; + } + } +#endif + +#if defined(GL_EXT_blend_func_separate) + if (QueryExtension("GL_EXT_blend_func_separate")) + { + glBlendFuncSeparateEXT = reinterpret_cast(bglGetProcAddress((const GLubyte *) "glBlendFuncSeparateEXT")); + if (glBlendFuncSeparateEXT) { + EnableExtension(_GL_EXT_blend_func_separate); + if (m_debug && doDebugMessages) + std::cout << "Enabled GL_EXT_blend_func_separate" << std::endl; + } else { + std::cout << "ERROR: GL_EXT_blend_func_separate implementation is broken!" << std::endl; + } + } +#endif + + if (QueryExtension("GL_INGR_color_clamp")) + { + EnableExtension(_GL_INGR_color_clamp); + if (m_debug && doDebugMessages) + std::cout << "Enabled GL_INGR_color_clamp" << std::endl; + } + + if (QueryExtension("GL_INGR_interlace_read")) + { + EnableExtension(_GL_INGR_interlace_read); + if (m_debug && doDebugMessages) + std::cout << "Enabled GL_INGR_interlace_read" << std::endl; + } + + if (QueryExtension("GL_EXT_stencil_wrap")) + { + EnableExtension(_GL_EXT_stencil_wrap); + if (m_debug && doDebugMessages) + std::cout << "Enabled GL_EXT_stencil_wrap" << std::endl; + } + + if (QueryExtension("GL_EXT_422_pixels")) + { + EnableExtension(_GL_EXT_422_pixels); + if (m_debug && doDebugMessages) + std::cout << "Enabled GL_EXT_422_pixels" << std::endl; + } + + if (QueryExtension("GL_NV_texgen_reflection")) + { + EnableExtension(_GL_NV_texgen_reflection); + if (m_debug && doDebugMessages) + std::cout << "Enabled GL_NV_texgen_reflection" << std::endl; + } + + if (QueryExtension("GL_SUN_convolution_border_modes")) + { + EnableExtension(_GL_SUN_convolution_border_modes); + if (m_debug && doDebugMessages) + std::cout << "Enabled GL_SUN_convolution_border_modes" << std::endl; + } + + if (QueryExtension("GL_EXT_texture_env_add")) + { + EnableExtension(_GL_EXT_texture_env_add); + if (m_debug && doDebugMessages) + std::cout << "Enabled GL_EXT_texture_env_add" << std::endl; + } + + if (QueryExtension("GL_EXT_texture_lod_bias")) + { + EnableExtension(_GL_EXT_texture_lod_bias); + if (m_debug && doDebugMessages) + std::cout << "Enabled GL_EXT_texture_lod_bias" << std::endl; + } + + if (QueryExtension("GL_EXT_texture_filter_anisotropic")) + { + EnableExtension(_GL_EXT_texture_filter_anisotropic); + if (m_debug && doDebugMessages) + std::cout << "Enabled GL_EXT_texture_filter_anisotropic" << std::endl; + } + +#if defined(GL_EXT_vertex_weighting) + if (QueryExtension("GL_EXT_vertex_weighting")) + { + glVertexWeightfEXT = reinterpret_cast(bglGetProcAddress((const GLubyte *) "glVertexWeightfEXT")); + glVertexWeightfvEXT = reinterpret_cast(bglGetProcAddress((const GLubyte *) "glVertexWeightfvEXT")); + glVertexWeightPointerEXT = reinterpret_cast(bglGetProcAddress((const GLubyte *) "glVertexWeightPointerEXT")); + if (glVertexWeightfEXT && glVertexWeightfvEXT && glVertexWeightPointerEXT) { + EnableExtension(_GL_EXT_vertex_weighting); + if (m_debug && doDebugMessages) + std::cout << "Enabled GL_EXT_vertex_weighting" << std::endl; + } else { + std::cout << "ERROR: GL_EXT_vertex_weighting implementation is broken!" << std::endl; + } + } +#endif + + if (QueryExtension("GL_NV_light_max_exponent")) + { + EnableExtension(_GL_NV_light_max_exponent); + if (m_debug && doDebugMessages) + std::cout << "Enabled GL_NV_light_max_exponent" << std::endl; + } + +#if defined(GL_NV_vertex_array_range) + if (QueryExtension("GL_NV_vertex_array_range")) + { + glFlushVertexArrayRangeNV = reinterpret_cast(bglGetProcAddress((const GLubyte *) "glFlushVertexArrayRangeNV")); + glVertexArrayRangeNV = reinterpret_cast(bglGetProcAddress((const GLubyte *) "glVertexArrayRangeNV")); + if (glFlushVertexArrayRangeNV && glVertexArrayRangeNV) { + EnableExtension(_GL_NV_vertex_array_range); + if (m_debug && doDebugMessages) + std::cout << "Enabled GL_NV_vertex_array_range" << std::endl; + } else { + std::cout << "ERROR: GL_NV_vertex_array_range implementation is broken!" << std::endl; + } + } +#endif + +#if defined(GL_NV_register_combiners) + if (QueryExtension("GL_NV_register_combiners")) + { + glCombinerParameterfvNV = reinterpret_cast(bglGetProcAddress((const GLubyte *) "glCombinerParameterfvNV")); + glCombinerParameterfNV = reinterpret_cast(bglGetProcAddress((const GLubyte *) "glCombinerParameterfNV")); + glCombinerParameterivNV = reinterpret_cast(bglGetProcAddress((const GLubyte *) "glCombinerParameterivNV")); + glCombinerParameteriNV = reinterpret_cast(bglGetProcAddress((const GLubyte *) "glCombinerParameteriNV")); + glCombinerInputNV = reinterpret_cast(bglGetProcAddress((const GLubyte *) "glCombinerInputNV")); + glCombinerOutputNV = reinterpret_cast(bglGetProcAddress((const GLubyte *) "glCombinerOutputNV")); + glFinalCombinerInputNV = reinterpret_cast(bglGetProcAddress((const GLubyte *) "glFinalCombinerInputNV")); + glGetCombinerInputParameterfvNV = reinterpret_cast(bglGetProcAddress((const GLubyte *) "glGetCombinerInputParameterfvNV")); + glGetCombinerInputParameterivNV = reinterpret_cast(bglGetProcAddress((const GLubyte *) "glGetCombinerInputParameterivNV")); + glGetCombinerOutputParameterfvNV = reinterpret_cast(bglGetProcAddress((const GLubyte *) "glGetCombinerOutputParameterfvNV")); + glGetCombinerOutputParameterivNV = reinterpret_cast(bglGetProcAddress((const GLubyte *) "glGetCombinerOutputParameterivNV")); + glGetFinalCombinerInputParameterfvNV = reinterpret_cast(bglGetProcAddress((const GLubyte *) "glGetFinalCombinerInputParameterfvNV")); + glGetFinalCombinerInputParameterivNV = reinterpret_cast(bglGetProcAddress((const GLubyte *) "glGetFinalCombinerInputParameterivNV")); + if (glCombinerParameterfvNV && glCombinerParameterfNV && glCombinerParameterivNV && glCombinerParameteriNV && glCombinerInputNV && glCombinerOutputNV && glFinalCombinerInputNV && glGetCombinerInputParameterfvNV && glGetCombinerInputParameterivNV && glGetCombinerOutputParameterfvNV && glGetCombinerOutputParameterivNV && glGetFinalCombinerInputParameterfvNV && glGetFinalCombinerInputParameterivNV) { + EnableExtension(_GL_NV_register_combiners); + if (m_debug && doDebugMessages) + std::cout << "Enabled GL_NV_register_combiners" << std::endl; + } else { + std::cout << "ERROR: GL_NV_register_combiners implementation is broken!" << std::endl; + } + } +#endif + + if (QueryExtension("GL_NV_fog_distance")) + { + EnableExtension(_GL_NV_fog_distance); + if (m_debug && doDebugMessages) + std::cout << "Enabled GL_NV_fog_distance" << std::endl; + } + + if (QueryExtension("GL_NV_texgen_emboss")) + { + EnableExtension(_GL_NV_texgen_emboss); + if (m_debug && doDebugMessages) + std::cout << "Enabled GL_NV_texgen_emboss" << std::endl; + } + + if (QueryExtension("GL_NV_blend_square")) + { + EnableExtension(_GL_NV_blend_square); + if (m_debug && doDebugMessages) + std::cout << "Enabled GL_NV_blend_square" << std::endl; + } + + if (QueryExtension("GL_NV_texture_env_combine4")) + { + EnableExtension(_GL_NV_texture_env_combine4); + if (m_debug && doDebugMessages) + std::cout << "Enabled GL_NV_texture_env_combine4" << std::endl; + } + +#if defined(GL_MESA_resize_buffers) + if (QueryExtension("GL_MESA_resize_buffers")) + { + glResizeBuffersMESA = reinterpret_cast(bglGetProcAddress((const GLubyte *) "glResizeBuffersMESA")); + if (glResizeBuffersMESA) { + EnableExtension(_GL_MESA_resize_buffers); + if (m_debug && doDebugMessages) + std::cout << "Enabled GL_MESA_resize_buffers" << std::endl; + } else { + std::cout << "ERROR: GL_MESA_resize_buffers implementation is broken!" << std::endl; + } + } +#endif + +#if defined(GL_MESA_window_pos) + if (QueryExtension("GL_MESA_window_pos")) + { + glWindowPos2dMESA = reinterpret_cast(bglGetProcAddress((const GLubyte *) "glWindowPos2dMESA")); + glWindowPos2dvMESA = reinterpret_cast(bglGetProcAddress((const GLubyte *) "glWindowPos2dvMESA")); + glWindowPos2fMESA = reinterpret_cast(bglGetProcAddress((const GLubyte *) "glWindowPos2fMESA")); + glWindowPos2fvMESA = reinterpret_cast(bglGetProcAddress((const GLubyte *) "glWindowPos2fvMESA")); + glWindowPos2iMESA = reinterpret_cast(bglGetProcAddress((const GLubyte *) "glWindowPos2iMESA")); + glWindowPos2ivMESA = reinterpret_cast(bglGetProcAddress((const GLubyte *) "glWindowPos2ivMESA")); + glWindowPos2sMESA = reinterpret_cast(bglGetProcAddress((const GLubyte *) "glWindowPos2sMESA")); + glWindowPos2svMESA = reinterpret_cast(bglGetProcAddress((const GLubyte *) "glWindowPos2svMESA")); + glWindowPos3dMESA = reinterpret_cast(bglGetProcAddress((const GLubyte *) "glWindowPos3dMESA")); + glWindowPos3dvMESA = reinterpret_cast(bglGetProcAddress((const GLubyte *) "glWindowPos3dvMESA")); + glWindowPos3fMESA = reinterpret_cast(bglGetProcAddress((const GLubyte *) "glWindowPos3fMESA")); + glWindowPos3fvMESA = reinterpret_cast(bglGetProcAddress((const GLubyte *) "glWindowPos3fvMESA")); + glWindowPos3iMESA = reinterpret_cast(bglGetProcAddress((const GLubyte *) "glWindowPos3iMESA")); + glWindowPos3ivMESA = reinterpret_cast(bglGetProcAddress((const GLubyte *) "glWindowPos3ivMESA")); + glWindowPos3sMESA = reinterpret_cast(bglGetProcAddress((const GLubyte *) "glWindowPos3sMESA")); + glWindowPos3svMESA = reinterpret_cast(bglGetProcAddress((const GLubyte *) "glWindowPos3svMESA")); + glWindowPos4dMESA = reinterpret_cast(bglGetProcAddress((const GLubyte *) "glWindowPos4dMESA")); + glWindowPos4dvMESA = reinterpret_cast(bglGetProcAddress((const GLubyte *) "glWindowPos4dvMESA")); + glWindowPos4fMESA = reinterpret_cast(bglGetProcAddress((const GLubyte *) "glWindowPos4fMESA")); + glWindowPos4fvMESA = reinterpret_cast(bglGetProcAddress((const GLubyte *) "glWindowPos4fvMESA")); + glWindowPos4iMESA = reinterpret_cast(bglGetProcAddress((const GLubyte *) "glWindowPos4iMESA")); + glWindowPos4ivMESA = reinterpret_cast(bglGetProcAddress((const GLubyte *) "glWindowPos4ivMESA")); + glWindowPos4sMESA = reinterpret_cast(bglGetProcAddress((const GLubyte *) "glWindowPos4sMESA")); + glWindowPos4svMESA = reinterpret_cast(bglGetProcAddress((const GLubyte *) "glWindowPos4svMESA")); + if (glWindowPos2dMESA && glWindowPos2dvMESA && glWindowPos2fMESA && glWindowPos2fvMESA && glWindowPos2iMESA && glWindowPos2ivMESA && glWindowPos2sMESA && glWindowPos2svMESA && glWindowPos3dMESA && glWindowPos3dvMESA && glWindowPos3fMESA && glWindowPos3fvMESA && glWindowPos3iMESA && glWindowPos3ivMESA && glWindowPos3sMESA && glWindowPos3svMESA && glWindowPos4dMESA && glWindowPos4dvMESA && glWindowPos4fMESA && glWindowPos4fvMESA && glWindowPos4iMESA && glWindowPos4ivMESA && glWindowPos4sMESA && glWindowPos4svMESA) { + EnableExtension(_GL_MESA_window_pos); + if (m_debug && doDebugMessages) + std::cout << "Enabled GL_MESA_window_pos" << std::endl; + } else { + std::cout << "ERROR: GL_MESA_window_pos implementation is broken!" << std::endl; + } + } +#endif + + if (QueryExtension("GL_IBM_cull_vertex")) + { + EnableExtension(_GL_IBM_cull_vertex); + if (m_debug && doDebugMessages) + std::cout << "Enabled GL_IBM_cull_vertex" << std::endl; + } + +#if defined(GL_IBM_multimode_draw_arrays) + if (QueryExtension("GL_IBM_multimode_draw_arrays")) + { + glMultiModeDrawArraysIBM = reinterpret_cast(bglGetProcAddress((const GLubyte *) "glMultiModeDrawArraysIBM")); + glMultiModeDrawElementsIBM = reinterpret_cast(bglGetProcAddress((const GLubyte *) "glMultiModeDrawElementsIBM")); + if (glMultiModeDrawArraysIBM && glMultiModeDrawElementsIBM) { + EnableExtension(_GL_IBM_multimode_draw_arrays); + if (m_debug && doDebugMessages) + std::cout << "Enabled GL_IBM_multimode_draw_arrays" << std::endl; + } else { + std::cout << "ERROR: GL_IBM_multimode_draw_arrays implementation is broken!" << std::endl; + } + } +#endif + +#if defined(GL_IBM_vertex_array_lists) + if (QueryExtension("GL_IBM_vertex_array_lists")) + { + glColorPointerListIBM = reinterpret_cast(bglGetProcAddress((const GLubyte *) "glColorPointerListIBM")); + glSecondaryColorPointerListIBM = reinterpret_cast(bglGetProcAddress((const GLubyte *) "glSecondaryColorPointerListIBM")); + glEdgeFlagPointerListIBM = reinterpret_cast(bglGetProcAddress((const GLubyte *) "glEdgeFlagPointerListIBM")); + glFogCoordPointerListIBM = reinterpret_cast(bglGetProcAddress((const GLubyte *) "glFogCoordPointerListIBM")); + glIndexPointerListIBM = reinterpret_cast(bglGetProcAddress((const GLubyte *) "glIndexPointerListIBM")); + glNormalPointerListIBM = reinterpret_cast(bglGetProcAddress((const GLubyte *) "glNormalPointerListIBM")); + glTexCoordPointerListIBM = reinterpret_cast(bglGetProcAddress((const GLubyte *) "glTexCoordPointerListIBM")); + glVertexPointerListIBM = reinterpret_cast(bglGetProcAddress((const GLubyte *) "glVertexPointerListIBM")); + if (glColorPointerListIBM && glSecondaryColorPointerListIBM && glEdgeFlagPointerListIBM && glFogCoordPointerListIBM && glIndexPointerListIBM && glNormalPointerListIBM && glTexCoordPointerListIBM && glVertexPointerListIBM) { + EnableExtension(_GL_IBM_vertex_array_lists); + if (m_debug && doDebugMessages) + std::cout << "Enabled GL_IBM_vertex_array_lists" << std::endl; + } else { + std::cout << "ERROR: GL_IBM_vertex_array_lists implementation is broken!" << std::endl; + } + } +#endif + + if (QueryExtension("GL_3DFX_texture_compression_FXT1")) + { + EnableExtension(_GL_3DFX_texture_compression_FXT1); + if (m_debug && doDebugMessages) + std::cout << "Enabled GL_3DFX_texture_compression_FXT1" << std::endl; + } + + if (QueryExtension("GL_3DFX_multisample")) + { + EnableExtension(_GL_3DFX_multisample); + if (m_debug && doDebugMessages) + std::cout << "Enabled GL_3DFX_multisample" << std::endl; + } + +#if defined(GL_3DFX_tbuffer) + if (QueryExtension("GL_3DFX_tbuffer")) + { + glTbufferMask3DFX = reinterpret_cast(bglGetProcAddress((const GLubyte *) "glTbufferMask3DFX")); + if (glTbufferMask3DFX) { + EnableExtension(_GL_3DFX_tbuffer); + if (m_debug && doDebugMessages) + std::cout << "Enabled GL_3DFX_tbuffer" << std::endl; + } else { + std::cout << "ERROR: GL_3DFX_tbuffer implementation is broken!" << std::endl; + } + } +#endif + + if (QueryExtension("GL_SGIX_vertex_preclip")) + { + EnableExtension(_GL_SGIX_vertex_preclip); + if (m_debug && doDebugMessages) + std::cout << "Enabled GL_SGIX_vertex_preclip" << std::endl; + } + + if (QueryExtension("GL_SGIX_resample")) + { + EnableExtension(_GL_SGIX_resample); + if (m_debug && doDebugMessages) + std::cout << "Enabled GL_SGIX_resample" << std::endl; + } + +#if defined(GL_SGIS_texture_color_mask) + if (QueryExtension("GL_SGIS_texture_color_mask")) + { + glTextureColorMaskSGIS = reinterpret_cast(bglGetProcAddress((const GLubyte *) "glTextureColorMaskSGIS")); + if (glTextureColorMaskSGIS) { + EnableExtension(_GL_SGIS_texture_color_mask); + if (m_debug && doDebugMessages) + std::cout << "Enabled GL_SGIS_texture_color_mask" << std::endl; + } else { + std::cout << "ERROR: GL_SGIS_texture_color_mask implementation is broken!" << std::endl; + } + } +#endif + + if (QueryExtension("GL_EXT_texture_env_dot3")) + { + EnableExtension(_GL_EXT_texture_env_dot3); + if (m_debug && doDebugMessages) + std::cout << "Enabled GL_EXT_texture_env_dot3" << std::endl; + } + + if (QueryExtension("GL_ATI_texture_mirror_once")) + { + EnableExtension(_GL_ATI_texture_mirror_once); + if (m_debug && doDebugMessages) + std::cout << "Enabled GL_ATI_texture_mirror_once" << std::endl; + } + +#if defined(GL_NV_fence) + if (QueryExtension("GL_NV_fence")) + { + glDeleteFencesNV = reinterpret_cast(bglGetProcAddress((const GLubyte *) "glDeleteFencesNV")); + glGenFencesNV = reinterpret_cast(bglGetProcAddress((const GLubyte *) "glGenFencesNV")); + glIsFenceNV = reinterpret_cast(bglGetProcAddress((const GLubyte *) "glIsFenceNV")); + glTestFenceNV = reinterpret_cast(bglGetProcAddress((const GLubyte *) "glTestFenceNV")); + glGetFenceivNV = reinterpret_cast(bglGetProcAddress((const GLubyte *) "glGetFenceivNV")); + glFinishFenceNV = reinterpret_cast(bglGetProcAddress((const GLubyte *) "glFinishFenceNV")); + glSetFenceNV = reinterpret_cast(bglGetProcAddress((const GLubyte *) "glSetFenceNV")); + if (glDeleteFencesNV && glGenFencesNV && glIsFenceNV && glTestFenceNV && glGetFenceivNV && glFinishFenceNV && glSetFenceNV) { + EnableExtension(_GL_NV_fence); + if (m_debug && doDebugMessages) + std::cout << "Enabled GL_NV_fence" << std::endl; + } else { + std::cout << "ERROR: GL_NV_fence implementation is broken!" << std::endl; + } + } +#endif + +#if defined(GL_NV_evaluators) + if (QueryExtension("GL_NV_evaluators")) + { + glMapControlPointsNV = reinterpret_cast(bglGetProcAddress((const GLubyte *) "glMapControlPointsNV")); + glMapParameterivNV = reinterpret_cast(bglGetProcAddress((const GLubyte *) "glMapParameterivNV")); + glMapParameterfvNV = reinterpret_cast(bglGetProcAddress((const GLubyte *) "glMapParameterfvNV")); + glGetMapControlPointsNV = reinterpret_cast(bglGetProcAddress((const GLubyte *) "glGetMapControlPointsNV")); + glGetMapParameterivNV = reinterpret_cast(bglGetProcAddress((const GLubyte *) "glGetMapParameterivNV")); + glGetMapParameterfvNV = reinterpret_cast(bglGetProcAddress((const GLubyte *) "glGetMapParameterfvNV")); + glGetMapAttribParameterivNV = reinterpret_cast(bglGetProcAddress((const GLubyte *) "glGetMapAttribParameterivNV")); + glGetMapAttribParameterfvNV = reinterpret_cast(bglGetProcAddress((const GLubyte *) "glGetMapAttribParameterfvNV")); + glEvalMapsNV = reinterpret_cast(bglGetProcAddress((const GLubyte *) "glEvalMapsNV")); + if (glMapControlPointsNV && glMapParameterivNV && glMapParameterfvNV && glGetMapControlPointsNV && glGetMapParameterivNV && glGetMapParameterfvNV && glGetMapAttribParameterivNV && glGetMapAttribParameterfvNV && glEvalMapsNV) { + EnableExtension(_GL_NV_evaluators); + if (m_debug && doDebugMessages) + std::cout << "Enabled GL_NV_evaluators" << std::endl; + } else { + std::cout << "ERROR: GL_NV_evaluators implementation is broken!" << std::endl; + } + } +#endif + + if (QueryExtension("GL_NV_packed_depth_stencil")) + { + EnableExtension(_GL_NV_packed_depth_stencil); + if (m_debug && doDebugMessages) + std::cout << "Enabled GL_NV_packed_depth_stencil" << std::endl; + } + +#if defined(GL_NV_register_combiners2) + if (QueryExtension("GL_NV_register_combiners2")) + { + glCombinerStageParameterfvNV = reinterpret_cast(bglGetProcAddress((const GLubyte *) "glCombinerStageParameterfvNV")); + glGetCombinerStageParameterfvNV = reinterpret_cast(bglGetProcAddress((const GLubyte *) "glGetCombinerStageParameterfvNV")); + if (glCombinerStageParameterfvNV && glGetCombinerStageParameterfvNV) { + EnableExtension(_GL_NV_register_combiners2); + if (m_debug && doDebugMessages) + std::cout << "Enabled GL_NV_register_combiners2" << std::endl; + } else { + std::cout << "ERROR: GL_NV_register_combiners2 implementation is broken!" << std::endl; + } + } +#endif + + if (QueryExtension("GL_NV_texture_compression_vtc")) + { + EnableExtension(_GL_NV_texture_compression_vtc); + if (m_debug && doDebugMessages) + std::cout << "Enabled GL_NV_texture_compression_vtc" << std::endl; + } + + if (QueryExtension("GL_NV_texture_rectangle")) + { + EnableExtension(_GL_NV_texture_rectangle); + if (m_debug && doDebugMessages) + std::cout << "Enabled GL_NV_texture_rectangle" << std::endl; + } + + if (QueryExtension("GL_NV_texture_shader")) + { + EnableExtension(_GL_NV_texture_shader); + if (m_debug && doDebugMessages) + std::cout << "Enabled GL_NV_texture_shader" << std::endl; + } + + if (QueryExtension("GL_NV_texture_shader2")) + { + EnableExtension(_GL_NV_texture_shader2); + if (m_debug && doDebugMessages) + std::cout << "Enabled GL_NV_texture_shader2" << std::endl; + } + + if (QueryExtension("GL_NV_vertex_array_range2")) + { + EnableExtension(_GL_NV_vertex_array_range2); + if (m_debug && doDebugMessages) + std::cout << "Enabled GL_NV_vertex_array_range2" << std::endl; + } + +#if defined(GL_NV_vertex_program) + if (QueryExtension("GL_NV_vertex_program")) + { + glAreProgramsResidentNV = reinterpret_cast(bglGetProcAddress((const GLubyte *) "glAreProgramsResidentNV")); + glBindProgramNV = reinterpret_cast(bglGetProcAddress((const GLubyte *) "glBindProgramNV")); + glDeleteProgramsNV = reinterpret_cast(bglGetProcAddress((const GLubyte *) "glDeleteProgramsNV")); + glExecuteProgramNV = reinterpret_cast(bglGetProcAddress((const GLubyte *) "glExecuteProgramNV")); + glGenProgramsNV = reinterpret_cast(bglGetProcAddress((const GLubyte *) "glGenProgramsNV")); + glGetProgramParameterdvNV = reinterpret_cast(bglGetProcAddress((const GLubyte *) "glGetProgramParameterdvNV")); + glGetProgramParameterfvNV = reinterpret_cast(bglGetProcAddress((const GLubyte *) "glGetProgramParameterfvNV")); + glGetProgramivNV = reinterpret_cast(bglGetProcAddress((const GLubyte *) "glGetProgramivNV")); + glGetProgramStringNV = reinterpret_cast(bglGetProcAddress((const GLubyte *) "glGetProgramStringNV")); + glGetTrackMatrixivNV = reinterpret_cast(bglGetProcAddress((const GLubyte *) "glGetTrackMatrixivNV")); + glGetVertexAttribdvNV = reinterpret_cast(bglGetProcAddress((const GLubyte *) "glGetVertexAttribdvNV")); + glGetVertexAttribfvNV = reinterpret_cast(bglGetProcAddress((const GLubyte *) "glGetVertexAttribfvNV")); + glGetVertexAttribivNV = reinterpret_cast(bglGetProcAddress((const GLubyte *) "glGetVertexAttribivNV")); + glGetVertexAttribPointervNV = reinterpret_cast(bglGetProcAddress((const GLubyte *) "glGetVertexAttribPointervNV")); + glIsProgramNV = reinterpret_cast(bglGetProcAddress((const GLubyte *) "glIsProgramNV")); + glLoadProgramNV = reinterpret_cast(bglGetProcAddress((const GLubyte *) "glLoadProgramNV")); + glProgramParameter4dNV = reinterpret_cast(bglGetProcAddress((const GLubyte *) "glProgramParameter4dNV")); + glProgramParameter4dvNV = reinterpret_cast(bglGetProcAddress((const GLubyte *) "glProgramParameter4dvNV")); + glProgramParameter4fNV = reinterpret_cast(bglGetProcAddress((const GLubyte *) "glProgramParameter4fNV")); + glProgramParameter4fvNV = reinterpret_cast(bglGetProcAddress((const GLubyte *) "glProgramParameter4fvNV")); + glProgramParameters4dvNV = reinterpret_cast(bglGetProcAddress((const GLubyte *) "glProgramParameters4dvNV")); + glProgramParameters4fvNV = reinterpret_cast(bglGetProcAddress((const GLubyte *) "glProgramParameters4fvNV")); + glRequestResidentProgramsNV = reinterpret_cast(bglGetProcAddress((const GLubyte *) "glRequestResidentProgramsNV")); + glTrackMatrixNV = reinterpret_cast(bglGetProcAddress((const GLubyte *) "glTrackMatrixNV")); + glVertexAttribPointerNV = reinterpret_cast(bglGetProcAddress((const GLubyte *) "glVertexAttribPointerNV")); + glVertexAttrib1dNV = reinterpret_cast(bglGetProcAddress((const GLubyte *) "glVertexAttrib1dNV")); + glVertexAttrib1dvNV = reinterpret_cast(bglGetProcAddress((const GLubyte *) "glVertexAttrib1dvNV")); + glVertexAttrib1fNV = reinterpret_cast(bglGetProcAddress((const GLubyte *) "glVertexAttrib1fNV")); + glVertexAttrib1fvNV = reinterpret_cast(bglGetProcAddress((const GLubyte *) "glVertexAttrib1fvNV")); + glVertexAttrib1sNV = reinterpret_cast(bglGetProcAddress((const GLubyte *) "glVertexAttrib1sNV")); + glVertexAttrib1svNV = reinterpret_cast(bglGetProcAddress((const GLubyte *) "glVertexAttrib1svNV")); + glVertexAttrib2dNV = reinterpret_cast(bglGetProcAddress((const GLubyte *) "glVertexAttrib2dNV")); + glVertexAttrib2dvNV = reinterpret_cast(bglGetProcAddress((const GLubyte *) "glVertexAttrib2dvNV")); + glVertexAttrib2fNV = reinterpret_cast(bglGetProcAddress((const GLubyte *) "glVertexAttrib2fNV")); + glVertexAttrib2fvNV = reinterpret_cast(bglGetProcAddress((const GLubyte *) "glVertexAttrib2fvNV")); + glVertexAttrib2sNV = reinterpret_cast(bglGetProcAddress((const GLubyte *) "glVertexAttrib2sNV")); + glVertexAttrib2svNV = reinterpret_cast(bglGetProcAddress((const GLubyte *) "glVertexAttrib2svNV")); + glVertexAttrib3dNV = reinterpret_cast(bglGetProcAddress((const GLubyte *) "glVertexAttrib3dNV")); + glVertexAttrib3dvNV = reinterpret_cast(bglGetProcAddress((const GLubyte *) "glVertexAttrib3dvNV")); + glVertexAttrib3fNV = reinterpret_cast(bglGetProcAddress((const GLubyte *) "glVertexAttrib3fNV")); + glVertexAttrib3fvNV = reinterpret_cast(bglGetProcAddress((const GLubyte *) "glVertexAttrib3fvNV")); + glVertexAttrib3sNV = reinterpret_cast(bglGetProcAddress((const GLubyte *) "glVertexAttrib3sNV")); + glVertexAttrib3svNV = reinterpret_cast(bglGetProcAddress((const GLubyte *) "glVertexAttrib3svNV")); + glVertexAttrib4dNV = reinterpret_cast(bglGetProcAddress((const GLubyte *) "glVertexAttrib4dNV")); + glVertexAttrib4dvNV = reinterpret_cast(bglGetProcAddress((const GLubyte *) "glVertexAttrib4dvNV")); + glVertexAttrib4fNV = reinterpret_cast(bglGetProcAddress((const GLubyte *) "glVertexAttrib4fNV")); + glVertexAttrib4fvNV = reinterpret_cast(bglGetProcAddress((const GLubyte *) "glVertexAttrib4fvNV")); + glVertexAttrib4sNV = reinterpret_cast(bglGetProcAddress((const GLubyte *) "glVertexAttrib4sNV")); + glVertexAttrib4svNV = reinterpret_cast(bglGetProcAddress((const GLubyte *) "glVertexAttrib4svNV")); + glVertexAttrib4ubNV = reinterpret_cast(bglGetProcAddress((const GLubyte *) "glVertexAttrib4ubNV")); + glVertexAttrib4ubvNV = reinterpret_cast(bglGetProcAddress((const GLubyte *) "glVertexAttrib4ubvNV")); + glVertexAttribs1dvNV = reinterpret_cast(bglGetProcAddress((const GLubyte *) "glVertexAttribs1dvNV")); + glVertexAttribs1fvNV = reinterpret_cast(bglGetProcAddress((const GLubyte *) "glVertexAttribs1fvNV")); + glVertexAttribs1svNV = reinterpret_cast(bglGetProcAddress((const GLubyte *) "glVertexAttribs1svNV")); + glVertexAttribs2dvNV = reinterpret_cast(bglGetProcAddress((const GLubyte *) "glVertexAttribs2dvNV")); + glVertexAttribs2fvNV = reinterpret_cast(bglGetProcAddress((const GLubyte *) "glVertexAttribs2fvNV")); + glVertexAttribs2svNV = reinterpret_cast(bglGetProcAddress((const GLubyte *) "glVertexAttribs2svNV")); + glVertexAttribs3dvNV = reinterpret_cast(bglGetProcAddress((const GLubyte *) "glVertexAttribs3dvNV")); + glVertexAttribs3fvNV = reinterpret_cast(bglGetProcAddress((const GLubyte *) "glVertexAttribs3fvNV")); + glVertexAttribs3svNV = reinterpret_cast(bglGetProcAddress((const GLubyte *) "glVertexAttribs3svNV")); + glVertexAttribs4dvNV = reinterpret_cast(bglGetProcAddress((const GLubyte *) "glVertexAttribs4dvNV")); + glVertexAttribs4fvNV = reinterpret_cast(bglGetProcAddress((const GLubyte *) "glVertexAttribs4fvNV")); + glVertexAttribs4svNV = reinterpret_cast(bglGetProcAddress((const GLubyte *) "glVertexAttribs4svNV")); + glVertexAttribs4ubvNV = reinterpret_cast(bglGetProcAddress((const GLubyte *) "glVertexAttribs4ubvNV")); + if (glAreProgramsResidentNV && glBindProgramNV && glDeleteProgramsNV && glExecuteProgramNV && glGenProgramsNV && glGetProgramParameterdvNV && glGetProgramParameterfvNV && glGetProgramivNV && glGetProgramStringNV && glGetTrackMatrixivNV && glGetVertexAttribdvNV && glGetVertexAttribfvNV && glGetVertexAttribivNV && glGetVertexAttribPointervNV && glIsProgramNV && glLoadProgramNV && glProgramParameter4dNV && glProgramParameter4dvNV && glProgramParameter4fNV && glProgramParameter4fvNV && glProgramParameters4dvNV && glProgramParameters4fvNV && glRequestResidentProgramsNV && glTrackMatrixNV && glVertexAttribPointerNV && glVertexAttrib1dNV && glVertexAttrib1dvNV && glVertexAttrib1fNV && glVertexAttrib1fvNV && glVertexAttrib1sNV && glVertexAttrib1svNV && glVertexAttrib2dNV && glVertexAttrib2dvNV && glVertexAttrib2fNV && glVertexAttrib2fvNV && glVertexAttrib2sNV && glVertexAttrib2svNV && glVertexAttrib3dNV && glVertexAttrib3dvNV && glVertexAttrib3fNV && glVertexAttrib3fvNV && glVertexAttrib3sNV && glVertexAttrib3svNV && glVertexAttrib4dNV && glVertexAttrib4dvNV && glVertexAttrib4fNV && glVertexAttrib4fvNV && glVertexAttrib4sNV && glVertexAttrib4svNV && glVertexAttrib4ubNV && glVertexAttrib4ubvNV && glVertexAttribs1dvNV && glVertexAttribs1fvNV && glVertexAttribs1svNV && glVertexAttribs2dvNV && glVertexAttribs2fvNV && glVertexAttribs2svNV && glVertexAttribs3dvNV && glVertexAttribs3fvNV && glVertexAttribs3svNV && glVertexAttribs4dvNV && glVertexAttribs4fvNV && glVertexAttribs4svNV && glVertexAttribs4ubvNV) { + EnableExtension(_GL_NV_vertex_program); + if (m_debug && doDebugMessages) + std::cout << "Enabled GL_NV_vertex_program" << std::endl; + } else { + std::cout << "ERROR: GL_NV_vertex_program implementation is broken!" << std::endl; + } + } +#endif + + if (QueryExtension("GL_SGIX_texture_coordinate_clamp")) + { + EnableExtension(_GL_SGIX_texture_coordinate_clamp); + if (m_debug && doDebugMessages) + std::cout << "Enabled GL_SGIX_texture_coordinate_clamp" << std::endl; + } + + if (QueryExtension("GL_OML_interlace")) + { + EnableExtension(_GL_OML_interlace); + if (m_debug && doDebugMessages) + std::cout << "Enabled GL_OML_interlace" << std::endl; + } + + if (QueryExtension("GL_OML_subsample")) + { + EnableExtension(_GL_OML_subsample); + if (m_debug && doDebugMessages) + std::cout << "Enabled GL_OML_subsample" << std::endl; + } + + if (QueryExtension("GL_OML_resample")) + { + EnableExtension(_GL_OML_resample); + if (m_debug && doDebugMessages) + std::cout << "Enabled GL_OML_resample" << std::endl; + } + + if (QueryExtension("GL_NV_copy_depth_to_color")) + { + EnableExtension(_GL_NV_copy_depth_to_color); + if (m_debug && doDebugMessages) + std::cout << "Enabled GL_NV_copy_depth_to_color" << std::endl; + } + +#if defined(GL_ATI_envmap_bumpmap) + if (QueryExtension("GL_ATI_envmap_bumpmap")) + { + glTexBumpParameterivATI = reinterpret_cast(bglGetProcAddress((const GLubyte *) "glTexBumpParameterivATI")); + glTexBumpParameterfvATI = reinterpret_cast(bglGetProcAddress((const GLubyte *) "glTexBumpParameterfvATI")); + glGetTexBumpParameterivATI = reinterpret_cast(bglGetProcAddress((const GLubyte *) "glGetTexBumpParameterivATI")); + glGetTexBumpParameterfvATI = reinterpret_cast(bglGetProcAddress((const GLubyte *) "glGetTexBumpParameterfvATI")); + if (glTexBumpParameterivATI && glTexBumpParameterfvATI && glGetTexBumpParameterivATI && glGetTexBumpParameterfvATI) { + EnableExtension(_GL_ATI_envmap_bumpmap); + if (m_debug && doDebugMessages) + std::cout << "Enabled GL_ATI_envmap_bumpmap" << std::endl; + } else { + std::cout << "ERROR: GL_ATI_envmap_bumpmap implementation is broken!" << std::endl; + } + } +#endif + +#if defined(GL_ATI_fragment_shader) + if (QueryExtension("GL_ATI_fragment_shader")) + { + glGenFragmentShadersATI = reinterpret_cast(bglGetProcAddress((const GLubyte *) "glGenFragmentShadersATI")); + glBindFragmentShaderATI = reinterpret_cast(bglGetProcAddress((const GLubyte *) "glBindFragmentShaderATI")); + glDeleteFragmentShaderATI = reinterpret_cast(bglGetProcAddress((const GLubyte *) "glDeleteFragmentShaderATI")); + glBeginFragmentShaderATI = reinterpret_cast(bglGetProcAddress((const GLubyte *) "glBeginFragmentShaderATI")); + glEndFragmentShaderATI = reinterpret_cast(bglGetProcAddress((const GLubyte *) "glEndFragmentShaderATI")); + glPassTexCoordATI = reinterpret_cast(bglGetProcAddress((const GLubyte *) "glPassTexCoordATI")); + glSampleMapATI = reinterpret_cast(bglGetProcAddress((const GLubyte *) "glSampleMapATI")); + glColorFragmentOp1ATI = reinterpret_cast(bglGetProcAddress((const GLubyte *) "glColorFragmentOp1ATI")); + glColorFragmentOp2ATI = reinterpret_cast(bglGetProcAddress((const GLubyte *) "glColorFragmentOp2ATI")); + glColorFragmentOp3ATI = reinterpret_cast(bglGetProcAddress((const GLubyte *) "glColorFragmentOp3ATI")); + glAlphaFragmentOp1ATI = reinterpret_cast(bglGetProcAddress((const GLubyte *) "glAlphaFragmentOp1ATI")); + glAlphaFragmentOp2ATI = reinterpret_cast(bglGetProcAddress((const GLubyte *) "glAlphaFragmentOp2ATI")); + glAlphaFragmentOp3ATI = reinterpret_cast(bglGetProcAddress((const GLubyte *) "glAlphaFragmentOp3ATI")); + glSetFragmentShaderConstantATI = reinterpret_cast(bglGetProcAddress((const GLubyte *) "glSetFragmentShaderConstantATI")); + if (glGenFragmentShadersATI && glBindFragmentShaderATI && glDeleteFragmentShaderATI && glBeginFragmentShaderATI && glEndFragmentShaderATI && glPassTexCoordATI && glSampleMapATI && glColorFragmentOp1ATI && glColorFragmentOp2ATI && glColorFragmentOp3ATI && glAlphaFragmentOp1ATI && glAlphaFragmentOp2ATI && glAlphaFragmentOp3ATI && glSetFragmentShaderConstantATI) { + EnableExtension(_GL_ATI_fragment_shader); + if (m_debug && doDebugMessages) + std::cout << "Enabled GL_ATI_fragment_shader" << std::endl; + } else { + std::cout << "ERROR: GL_ATI_fragment_shader implementation is broken!" << std::endl; + } + } +#endif + + if (QueryExtension("GL_ATI_pn_triangles")) + { + EnableExtension(_GL_ATI_pn_triangles); + if (m_debug && doDebugMessages) + std::cout << "Enabled GL_ATI_pn_triangles" << std::endl; + } + +#if defined(GL_ATI_vertex_array_object) && 0 + if (QueryExtension("GL_ATI_vertex_array_object")) + { + glNewObjectBufferATI = reinterpret_cast(bglGetProcAddress((const GLubyte *) "glNewObjectBufferATI")); + glIsObjectBufferATI = reinterpret_cast(bglGetProcAddress((const GLubyte *) "glIsObjectBufferATI")); + glUpdateObjectBufferATI = reinterpret_cast(bglGetProcAddress((const GLubyte *) "glUpdateObjectBufferATI")); + glGetObjectBufferfvATI = reinterpret_cast(bglGetProcAddress((const GLubyte *) "glGetObjectBufferfvATI")); + glGetObjectBufferivATI = reinterpret_cast(bglGetProcAddress((const GLubyte *) "glGetObjectBufferivATI")); + glFreeObjectBufferATI = reinterpret_cast(bglGetProcAddress((const GLubyte *) "glFreeObjectBufferATI")); + glArrayObjectATI = reinterpret_cast(bglGetProcAddress((const GLubyte *) "glArrayObjectATI")); + glGetArrayObjectfvATI = reinterpret_cast(bglGetProcAddress((const GLubyte *) "glGetArrayObjectfvATI")); + glGetArrayObjectivATI = reinterpret_cast(bglGetProcAddress((const GLubyte *) "glGetArrayObjectivATI")); + glVariantArrayObjectATI = reinterpret_cast(bglGetProcAddress((const GLubyte *) "glVariantArrayObjectATI")); + glGetVariantArrayObjectfvATI = reinterpret_cast(bglGetProcAddress((const GLubyte *) "glGetVariantArrayObjectfvATI")); + glGetVariantArrayObjectivATI = reinterpret_cast(bglGetProcAddress((const GLubyte *) "glGetVariantArrayObjectivATI")); + if (glNewObjectBufferATI && glIsObjectBufferATI && glUpdateObjectBufferATI && glGetObjectBufferfvATI && glGetObjectBufferivATI && glFreeObjectBufferATI && glArrayObjectATI && glGetArrayObjectfvATI && glGetArrayObjectivATI && glVariantArrayObjectATI && glGetVariantArrayObjectfvATI && glGetVariantArrayObjectivATI) { + EnableExtension(_GL_ATI_vertex_array_object); + if (m_debug && doDebugMessages) + std::cout << "Enabled GL_ATI_vertex_array_object" << std::endl; + } else { + std::cout << "ERROR: GL_ATI_vertex_array_object implementation is broken!" << std::endl; + } + } +#endif + +#if defined(GL_EXT_vertex_shader) + if (QueryExtension("GL_EXT_vertex_shader")) + { + glBeginVertexShaderEXT = reinterpret_cast(bglGetProcAddress((const GLubyte *) "glBeginVertexShaderEXT")); + glEndVertexShaderEXT = reinterpret_cast(bglGetProcAddress((const GLubyte *) "glEndVertexShaderEXT")); + glBindVertexShaderEXT = reinterpret_cast(bglGetProcAddress((const GLubyte *) "glBindVertexShaderEXT")); + glGenVertexShadersEXT = reinterpret_cast(bglGetProcAddress((const GLubyte *) "glGenVertexShadersEXT")); + glDeleteVertexShaderEXT = reinterpret_cast(bglGetProcAddress((const GLubyte *) "glDeleteVertexShaderEXT")); + glShaderOp1EXT = reinterpret_cast(bglGetProcAddress((const GLubyte *) "glShaderOp1EXT")); + glShaderOp2EXT = reinterpret_cast(bglGetProcAddress((const GLubyte *) "glShaderOp2EXT")); + glShaderOp3EXT = reinterpret_cast(bglGetProcAddress((const GLubyte *) "glShaderOp3EXT")); + glSwizzleEXT = reinterpret_cast(bglGetProcAddress((const GLubyte *) "glSwizzleEXT")); + glWriteMaskEXT = reinterpret_cast(bglGetProcAddress((const GLubyte *) "glWriteMaskEXT")); + glInsertComponentEXT = reinterpret_cast(bglGetProcAddress((const GLubyte *) "glInsertComponentEXT")); + glExtractComponentEXT = reinterpret_cast(bglGetProcAddress((const GLubyte *) "glExtractComponentEXT")); + glGenSymbolsEXT = reinterpret_cast(bglGetProcAddress((const GLubyte *) "glGenSymbolsEXT")); + glSetInvariantEXT = reinterpret_cast(bglGetProcAddress((const GLubyte *) "glSetInvariantEXT")); + glSetLocalConstantEXT = reinterpret_cast(bglGetProcAddress((const GLubyte *) "glSetLocalConstantEXT")); + glVariantbvEXT = reinterpret_cast(bglGetProcAddress((const GLubyte *) "glVariantbvEXT")); + glVariantsvEXT = reinterpret_cast(bglGetProcAddress((const GLubyte *) "glVariantsvEXT")); + glVariantivEXT = reinterpret_cast(bglGetProcAddress((const GLubyte *) "glVariantivEXT")); + glVariantfvEXT = reinterpret_cast(bglGetProcAddress((const GLubyte *) "glVariantfvEXT")); + glVariantdvEXT = reinterpret_cast(bglGetProcAddress((const GLubyte *) "glVariantdvEXT")); + glVariantubvEXT = reinterpret_cast(bglGetProcAddress((const GLubyte *) "glVariantubvEXT")); + glVariantusvEXT = reinterpret_cast(bglGetProcAddress((const GLubyte *) "glVariantusvEXT")); + glVariantuivEXT = reinterpret_cast(bglGetProcAddress((const GLubyte *) "glVariantuivEXT")); + glVariantPointerEXT = reinterpret_cast(bglGetProcAddress((const GLubyte *) "glVariantPointerEXT")); + glEnableVariantClientStateEXT = reinterpret_cast(bglGetProcAddress((const GLubyte *) "glEnableVariantClientStateEXT")); + glDisableVariantClientStateEXT = reinterpret_cast(bglGetProcAddress((const GLubyte *) "glDisableVariantClientStateEXT")); + glBindLightParameterEXT = reinterpret_cast(bglGetProcAddress((const GLubyte *) "glBindLightParameterEXT")); + glBindMaterialParameterEXT = reinterpret_cast(bglGetProcAddress((const GLubyte *) "glBindMaterialParameterEXT")); + glBindTexGenParameterEXT = reinterpret_cast(bglGetProcAddress((const GLubyte *) "glBindTexGenParameterEXT")); + glBindTextureUnitParameterEXT = reinterpret_cast(bglGetProcAddress((const GLubyte *) "glBindTextureUnitParameterEXT")); + glBindParameterEXT = reinterpret_cast(bglGetProcAddress((const GLubyte *) "glBindParameterEXT")); + glIsVariantEnabledEXT = reinterpret_cast(bglGetProcAddress((const GLubyte *) "glIsVariantEnabledEXT")); + glGetVariantBooleanvEXT = reinterpret_cast(bglGetProcAddress((const GLubyte *) "glGetVariantBooleanvEXT")); + glGetVariantIntegervEXT = reinterpret_cast(bglGetProcAddress((const GLubyte *) "glGetVariantIntegervEXT")); + glGetVariantFloatvEXT = reinterpret_cast(bglGetProcAddress((const GLubyte *) "glGetVariantFloatvEXT")); + glGetVariantPointervEXT = reinterpret_cast(bglGetProcAddress((const GLubyte *) "glGetVariantPointervEXT")); + glGetInvariantBooleanvEXT = reinterpret_cast(bglGetProcAddress((const GLubyte *) "glGetInvariantBooleanvEXT")); + glGetInvariantIntegervEXT = reinterpret_cast(bglGetProcAddress((const GLubyte *) "glGetInvariantIntegervEXT")); + glGetInvariantFloatvEXT = reinterpret_cast(bglGetProcAddress((const GLubyte *) "glGetInvariantFloatvEXT")); + glGetLocalConstantBooleanvEXT = reinterpret_cast(bglGetProcAddress((const GLubyte *) "glGetLocalConstantBooleanvEXT")); + glGetLocalConstantIntegervEXT = reinterpret_cast(bglGetProcAddress((const GLubyte *) "glGetLocalConstantIntegervEXT")); + glGetLocalConstantFloatvEXT = reinterpret_cast(bglGetProcAddress((const GLubyte *) "glGetLocalConstantFloatvEXT")); + if (glBeginVertexShaderEXT && glEndVertexShaderEXT && glBindVertexShaderEXT && glGenVertexShadersEXT && glDeleteVertexShaderEXT && glShaderOp1EXT && glShaderOp2EXT && glShaderOp3EXT && glSwizzleEXT && glWriteMaskEXT && glInsertComponentEXT && glExtractComponentEXT && glGenSymbolsEXT && glSetInvariantEXT && glSetLocalConstantEXT && glVariantbvEXT && glVariantsvEXT && glVariantivEXT && glVariantfvEXT && glVariantdvEXT && glVariantubvEXT && glVariantusvEXT && glVariantuivEXT && glVariantPointerEXT && glEnableVariantClientStateEXT && glDisableVariantClientStateEXT && glBindLightParameterEXT && glBindMaterialParameterEXT && glBindTexGenParameterEXT && glBindTextureUnitParameterEXT && glBindParameterEXT && glIsVariantEnabledEXT && glGetVariantBooleanvEXT && glGetVariantIntegervEXT && glGetVariantFloatvEXT && glGetVariantPointervEXT && glGetInvariantBooleanvEXT && glGetInvariantIntegervEXT && glGetInvariantFloatvEXT && glGetLocalConstantBooleanvEXT && glGetLocalConstantIntegervEXT && glGetLocalConstantFloatvEXT) { + EnableExtension(_GL_EXT_vertex_shader); + if (m_debug && doDebugMessages) + std::cout << "Enabled GL_EXT_vertex_shader" << std::endl; + } else { + std::cout << "ERROR: GL_EXT_vertex_shader implementation is broken!" << std::endl; + } + } +#endif + +#if defined(GL_ATI_vertex_streams) + if (QueryExtension("GL_ATI_vertex_streams")) + { + glVertexStream1sATI = reinterpret_cast(bglGetProcAddress((const GLubyte *) "glVertexStream1sATI")); + glVertexStream1svATI = reinterpret_cast(bglGetProcAddress((const GLubyte *) "glVertexStream1svATI")); + glVertexStream1iATI = reinterpret_cast(bglGetProcAddress((const GLubyte *) "glVertexStream1iATI")); + glVertexStream1ivATI = reinterpret_cast(bglGetProcAddress((const GLubyte *) "glVertexStream1ivATI")); + glVertexStream1fATI = reinterpret_cast(bglGetProcAddress((const GLubyte *) "glVertexStream1fATI")); + glVertexStream1fvATI = reinterpret_cast(bglGetProcAddress((const GLubyte *) "glVertexStream1fvATI")); + glVertexStream1dATI = reinterpret_cast(bglGetProcAddress((const GLubyte *) "glVertexStream1dATI")); + glVertexStream1dvATI = reinterpret_cast(bglGetProcAddress((const GLubyte *) "glVertexStream1dvATI")); + glVertexStream2sATI = reinterpret_cast(bglGetProcAddress((const GLubyte *) "glVertexStream2sATI")); + glVertexStream2svATI = reinterpret_cast(bglGetProcAddress((const GLubyte *) "glVertexStream2svATI")); + glVertexStream2iATI = reinterpret_cast(bglGetProcAddress((const GLubyte *) "glVertexStream2iATI")); + glVertexStream2ivATI = reinterpret_cast(bglGetProcAddress((const GLubyte *) "glVertexStream2ivATI")); + glVertexStream2fATI = reinterpret_cast(bglGetProcAddress((const GLubyte *) "glVertexStream2fATI")); + glVertexStream2fvATI = reinterpret_cast(bglGetProcAddress((const GLubyte *) "glVertexStream2fvATI")); + glVertexStream2dATI = reinterpret_cast(bglGetProcAddress((const GLubyte *) "glVertexStream2dATI")); + glVertexStream2dvATI = reinterpret_cast(bglGetProcAddress((const GLubyte *) "glVertexStream2dvATI")); + glVertexStream3sATI = reinterpret_cast(bglGetProcAddress((const GLubyte *) "glVertexStream3sATI")); + glVertexStream3svATI = reinterpret_cast(bglGetProcAddress((const GLubyte *) "glVertexStream3svATI")); + glVertexStream3iATI = reinterpret_cast(bglGetProcAddress((const GLubyte *) "glVertexStream3iATI")); + glVertexStream3ivATI = reinterpret_cast(bglGetProcAddress((const GLubyte *) "glVertexStream3ivATI")); + glVertexStream3fATI = reinterpret_cast(bglGetProcAddress((const GLubyte *) "glVertexStream3fATI")); + glVertexStream3fvATI = reinterpret_cast(bglGetProcAddress((const GLubyte *) "glVertexStream3fvATI")); + glVertexStream3dATI = reinterpret_cast(bglGetProcAddress((const GLubyte *) "glVertexStream3dATI")); + glVertexStream3dvATI = reinterpret_cast(bglGetProcAddress((const GLubyte *) "glVertexStream3dvATI")); + glVertexStream4sATI = reinterpret_cast(bglGetProcAddress((const GLubyte *) "glVertexStream4sATI")); + glVertexStream4svATI = reinterpret_cast(bglGetProcAddress((const GLubyte *) "glVertexStream4svATI")); + glVertexStream4iATI = reinterpret_cast(bglGetProcAddress((const GLubyte *) "glVertexStream4iATI")); + glVertexStream4ivATI = reinterpret_cast(bglGetProcAddress((const GLubyte *) "glVertexStream4ivATI")); + glVertexStream4fATI = reinterpret_cast(bglGetProcAddress((const GLubyte *) "glVertexStream4fATI")); + glVertexStream4fvATI = reinterpret_cast(bglGetProcAddress((const GLubyte *) "glVertexStream4fvATI")); + glVertexStream4dATI = reinterpret_cast(bglGetProcAddress((const GLubyte *) "glVertexStream4dATI")); + glVertexStream4dvATI = reinterpret_cast(bglGetProcAddress((const GLubyte *) "glVertexStream4dvATI")); + glNormalStream3bATI = reinterpret_cast(bglGetProcAddress((const GLubyte *) "glNormalStream3bATI")); + glNormalStream3bvATI = reinterpret_cast(bglGetProcAddress((const GLubyte *) "glNormalStream3bvATI")); + glNormalStream3sATI = reinterpret_cast(bglGetProcAddress((const GLubyte *) "glNormalStream3sATI")); + glNormalStream3svATI = reinterpret_cast(bglGetProcAddress((const GLubyte *) "glNormalStream3svATI")); + glNormalStream3iATI = reinterpret_cast(bglGetProcAddress((const GLubyte *) "glNormalStream3iATI")); + glNormalStream3ivATI = reinterpret_cast(bglGetProcAddress((const GLubyte *) "glNormalStream3ivATI")); + glNormalStream3fATI = reinterpret_cast(bglGetProcAddress((const GLubyte *) "glNormalStream3fATI")); + glNormalStream3fvATI = reinterpret_cast(bglGetProcAddress((const GLubyte *) "glNormalStream3fvATI")); + glNormalStream3dATI = reinterpret_cast(bglGetProcAddress((const GLubyte *) "glNormalStream3dATI")); + glNormalStream3dvATI = reinterpret_cast(bglGetProcAddress((const GLubyte *) "glNormalStream3dvATI")); + glClientActiveVertexStreamATI = reinterpret_cast(bglGetProcAddress((const GLubyte *) "glClientActiveVertexStreamATI")); + glVertexBlendEnviATI = reinterpret_cast(bglGetProcAddress((const GLubyte *) "glVertexBlendEnviATI")); + glVertexBlendEnvfATI = reinterpret_cast(bglGetProcAddress((const GLubyte *) "glVertexBlendEnvfATI")); + if (glVertexStream1sATI && glVertexStream1svATI && glVertexStream1iATI && glVertexStream1ivATI && glVertexStream1fATI && glVertexStream1fvATI && glVertexStream1dATI && glVertexStream1dvATI && glVertexStream2sATI && glVertexStream2svATI && glVertexStream2iATI && glVertexStream2ivATI && glVertexStream2fATI && glVertexStream2fvATI && glVertexStream2dATI && glVertexStream2dvATI && glVertexStream3sATI && glVertexStream3svATI && glVertexStream3iATI && glVertexStream3ivATI && glVertexStream3fATI && glVertexStream3fvATI && glVertexStream3dATI && glVertexStream3dvATI && glVertexStream4sATI && glVertexStream4svATI && glVertexStream4iATI && glVertexStream4ivATI && glVertexStream4fATI && glVertexStream4fvATI && glVertexStream4dATI && glVertexStream4dvATI && glNormalStream3bATI && glNormalStream3bvATI && glNormalStream3sATI && glNormalStream3svATI && glNormalStream3iATI && glNormalStream3ivATI && glNormalStream3fATI && glNormalStream3fvATI && glNormalStream3dATI && glNormalStream3dvATI && glClientActiveVertexStreamATI && glVertexBlendEnviATI && glVertexBlendEnvfATI) { + EnableExtension(_GL_ATI_vertex_streams); + if (m_debug && doDebugMessages) + std::cout << "Enabled GL_ATI_vertex_streams" << std::endl; + } else { + std::cout << "ERROR: GL_ATI_vertex_streams implementation is broken!" << std::endl; + } + } +#endif + +#if defined(GL_ATI_element_array) + if (QueryExtension("GL_ATI_element_array")) + { + glElementPointerATI = reinterpret_cast(bglGetProcAddress((const GLubyte *) "glElementPointerATI")); + glDrawElementArrayATI = reinterpret_cast(bglGetProcAddress((const GLubyte *) "glDrawElementArrayATI")); + glDrawRangeElementArrayATI = reinterpret_cast(bglGetProcAddress((const GLubyte *) "glDrawRangeElementArrayATI")); + if (glElementPointerATI && glDrawElementArrayATI && glDrawRangeElementArrayATI) { + EnableExtension(_GL_ATI_element_array); + if (m_debug && doDebugMessages) + std::cout << "Enabled GL_ATI_element_array" << std::endl; + } else { + std::cout << "ERROR: GL_ATI_element_array implementation is broken!" << std::endl; + } + } +#endif + +#if defined(GL_SUN_mesh_array) + if (QueryExtension("GL_SUN_mesh_array")) + { + glDrawMeshArraysSUN = reinterpret_cast(bglGetProcAddress((const GLubyte *) "glDrawMeshArraysSUN")); + if (glDrawMeshArraysSUN) { + EnableExtension(_GL_SUN_mesh_array); + if (m_debug && doDebugMessages) + std::cout << "Enabled GL_SUN_mesh_array" << std::endl; + } else { + std::cout << "ERROR: GL_SUN_mesh_array implementation is broken!" << std::endl; + } + } +#endif + + if (QueryExtension("GL_SUN_slice_accum")) + { + EnableExtension(_GL_SUN_slice_accum); + if (m_debug && doDebugMessages) + std::cout << "Enabled GL_SUN_slice_accum" << std::endl; + } + + if (QueryExtension("GL_NV_multisample_filter_hint")) + { + EnableExtension(_GL_NV_multisample_filter_hint); + if (m_debug && doDebugMessages) + std::cout << "Enabled GL_NV_multisample_filter_hint" << std::endl; + } + + if (QueryExtension("GL_NV_depth_clamp")) + { + EnableExtension(_GL_NV_depth_clamp); + if (m_debug && doDebugMessages) + std::cout << "Enabled GL_NV_depth_clamp" << std::endl; + } + +#if defined(GL_NV_occlusion_query) + if (QueryExtension("GL_NV_occlusion_query")) + { + glGenOcclusionQueriesNV = reinterpret_cast(bglGetProcAddress((const GLubyte *) "glGenOcclusionQueriesNV")); + glDeleteOcclusionQueriesNV = reinterpret_cast(bglGetProcAddress((const GLubyte *) "glDeleteOcclusionQueriesNV")); + glIsOcclusionQueryNV = reinterpret_cast(bglGetProcAddress((const GLubyte *) "glIsOcclusionQueryNV")); + glBeginOcclusionQueryNV = reinterpret_cast(bglGetProcAddress((const GLubyte *) "glBeginOcclusionQueryNV")); + glEndOcclusionQueryNV = reinterpret_cast(bglGetProcAddress((const GLubyte *) "glEndOcclusionQueryNV")); + glGetOcclusionQueryivNV = reinterpret_cast(bglGetProcAddress((const GLubyte *) "glGetOcclusionQueryivNV")); + glGetOcclusionQueryuivNV = reinterpret_cast(bglGetProcAddress((const GLubyte *) "glGetOcclusionQueryuivNV")); + if (glGenOcclusionQueriesNV && glDeleteOcclusionQueriesNV && glIsOcclusionQueryNV && glBeginOcclusionQueryNV && glEndOcclusionQueryNV && glGetOcclusionQueryivNV && glGetOcclusionQueryuivNV) { + EnableExtension(_GL_NV_occlusion_query); + if (m_debug && doDebugMessages) + std::cout << "Enabled GL_NV_occlusion_query" << std::endl; + } else { + std::cout << "ERROR: GL_NV_occlusion_query implementation is broken!" << std::endl; + } + } +#endif + +#if defined(GL_NV_point_sprite) + if (QueryExtension("GL_NV_point_sprite")) + { + glPointParameteriNV = reinterpret_cast(bglGetProcAddress((const GLubyte *) "glPointParameteriNV")); + glPointParameterivNV = reinterpret_cast(bglGetProcAddress((const GLubyte *) "glPointParameterivNV")); + if (glPointParameteriNV && glPointParameterivNV) { + EnableExtension(_GL_NV_point_sprite); + if (m_debug && doDebugMessages) + std::cout << "Enabled GL_NV_point_sprite" << std::endl; + } else { + std::cout << "ERROR: GL_NV_point_sprite implementation is broken!" << std::endl; + } + } +#endif + + if (QueryExtension("GL_NV_texture_shader3")) + { + EnableExtension(_GL_NV_texture_shader3); + if (m_debug && doDebugMessages) + std::cout << "Enabled GL_NV_texture_shader3" << std::endl; + } + + if (QueryExtension("GL_NV_vertex_program1_1")) + { + EnableExtension(_GL_NV_vertex_program1_1); + if (m_debug && doDebugMessages) + std::cout << "Enabled GL_NV_vertex_program1_1" << std::endl; + } + + if (QueryExtension("GL_EXT_shadow_funcs")) + { + EnableExtension(_GL_EXT_shadow_funcs); + if (m_debug && doDebugMessages) + std::cout << "Enabled GL_EXT_shadow_funcs" << std::endl; + } + +#if defined(GL_EXT_stencil_two_side) + if (QueryExtension("GL_EXT_stencil_two_side")) + { + glActiveStencilFaceEXT = reinterpret_cast(bglGetProcAddress((const GLubyte *) "glActiveStencilFaceEXT")); + if (glActiveStencilFaceEXT) { + EnableExtension(_GL_EXT_stencil_two_side); + if (m_debug && doDebugMessages) + std::cout << "Enabled GL_EXT_stencil_two_side" << std::endl; + } else { + std::cout << "ERROR: GL_EXT_stencil_two_side implementation is broken!" << std::endl; + } + } +#endif + + if (QueryExtension("GL_ATI_text_fragment_shader")) + { + EnableExtension(_GL_ATI_text_fragment_shader); + if (m_debug && doDebugMessages) + std::cout << "Enabled GL_ATI_text_fragment_shader" << std::endl; + } + + if (QueryExtension("GL_APPLE_client_storage")) + { + EnableExtension(_GL_APPLE_client_storage); + if (m_debug && doDebugMessages) + std::cout << "Enabled GL_APPLE_client_storage" << std::endl; + } + +#if defined(GL_APPLE_element_array) + if (QueryExtension("GL_APPLE_element_array")) + { + glElementPointerAPPLE = reinterpret_cast(bglGetProcAddress((const GLubyte *) "glElementPointerAPPLE")); + glDrawElementArrayAPPLE = reinterpret_cast(bglGetProcAddress((const GLubyte *) "glDrawElementArrayAPPLE")); + glDrawRangeElementArrayAPPLE = reinterpret_cast(bglGetProcAddress((const GLubyte *) "glDrawRangeElementArrayAPPLE")); + glMultiDrawElementArrayAPPLE = reinterpret_cast(bglGetProcAddress((const GLubyte *) "glMultiDrawElementArrayAPPLE")); + glMultiDrawRangeElementArrayAPPLE = reinterpret_cast(bglGetProcAddress((const GLubyte *) "glMultiDrawRangeElementArrayAPPLE")); + if (glElementPointerAPPLE && glDrawElementArrayAPPLE && glDrawRangeElementArrayAPPLE && glMultiDrawElementArrayAPPLE && glMultiDrawRangeElementArrayAPPLE) { + EnableExtension(_GL_APPLE_element_array); + if (m_debug && doDebugMessages) + std::cout << "Enabled GL_APPLE_element_array" << std::endl; + } else { + std::cout << "ERROR: GL_APPLE_element_array implementation is broken!" << std::endl; + } + } +#endif + +#if defined(GL_APPLE_fence) + if (QueryExtension("GL_APPLE_fence")) + { + glGenFencesAPPLE = reinterpret_cast(bglGetProcAddress((const GLubyte *) "glGenFencesAPPLE")); + glDeleteFencesAPPLE = reinterpret_cast(bglGetProcAddress((const GLubyte *) "glDeleteFencesAPPLE")); + glSetFenceAPPLE = reinterpret_cast(bglGetProcAddress((const GLubyte *) "glSetFenceAPPLE")); + glIsFenceAPPLE = reinterpret_cast(bglGetProcAddress((const GLubyte *) "glIsFenceAPPLE")); + glTestFenceAPPLE = reinterpret_cast(bglGetProcAddress((const GLubyte *) "glTestFenceAPPLE")); + glFinishFenceAPPLE = reinterpret_cast(bglGetProcAddress((const GLubyte *) "glFinishFenceAPPLE")); + glTestObjectAPPLE = reinterpret_cast(bglGetProcAddress((const GLubyte *) "glTestObjectAPPLE")); + glFinishObjectAPPLE = reinterpret_cast(bglGetProcAddress((const GLubyte *) "glFinishObjectAPPLE")); + if (glGenFencesAPPLE && glDeleteFencesAPPLE && glSetFenceAPPLE && glIsFenceAPPLE && glTestFenceAPPLE && glFinishFenceAPPLE && glTestObjectAPPLE && glFinishObjectAPPLE) { + EnableExtension(_GL_APPLE_fence); + if (m_debug && doDebugMessages) + std::cout << "Enabled GL_APPLE_fence" << std::endl; + } else { + std::cout << "ERROR: GL_APPLE_fence implementation is broken!" << std::endl; + } + } +#endif + +#if defined(GL_APPLE_vertex_array_object) + if (QueryExtension("GL_APPLE_vertex_array_object")) + { + glBindVertexArrayAPPLE = reinterpret_cast(bglGetProcAddress((const GLubyte *) "glBindVertexArrayAPPLE")); + glDeleteVertexArraysAPPLE = reinterpret_cast(bglGetProcAddress((const GLubyte *) "glDeleteVertexArraysAPPLE")); + glGenVertexArraysAPPLE = reinterpret_cast(bglGetProcAddress((const GLubyte *) "glGenVertexArraysAPPLE")); + glIsVertexArrayAPPLE = reinterpret_cast(bglGetProcAddress((const GLubyte *) "glIsVertexArrayAPPLE")); + if (glBindVertexArrayAPPLE && glDeleteVertexArraysAPPLE && glGenVertexArraysAPPLE && glIsVertexArrayAPPLE) { + EnableExtension(_GL_APPLE_vertex_array_object); + if (m_debug && doDebugMessages) + std::cout << "Enabled GL_APPLE_vertex_array_object" << std::endl; + } else { + std::cout << "ERROR: GL_APPLE_vertex_array_object implementation is broken!" << std::endl; + } + } +#endif + +#if defined(GL_APPLE_vertex_array_range) + if (QueryExtension("GL_APPLE_vertex_array_range")) + { + glVertexArrayRangeAPPLE = reinterpret_cast(bglGetProcAddress((const GLubyte *) "glVertexArrayRangeAPPLE")); + glFlushVertexArrayRangeAPPLE = reinterpret_cast(bglGetProcAddress((const GLubyte *) "glFlushVertexArrayRangeAPPLE")); + glVertexArrayParameteriAPPLE = reinterpret_cast(bglGetProcAddress((const GLubyte *) "glVertexArrayParameteriAPPLE")); + if (glVertexArrayRangeAPPLE && glFlushVertexArrayRangeAPPLE && glVertexArrayParameteriAPPLE) { + EnableExtension(_GL_APPLE_vertex_array_range); + if (m_debug && doDebugMessages) + std::cout << "Enabled GL_APPLE_vertex_array_range" << std::endl; + } else { + std::cout << "ERROR: GL_APPLE_vertex_array_range implementation is broken!" << std::endl; + } + } +#endif + + if (QueryExtension("GL_APPLE_ycbcr_422")) + { + EnableExtension(_GL_APPLE_ycbcr_422); + if (m_debug && doDebugMessages) + std::cout << "Enabled GL_APPLE_ycbcr_422" << std::endl; + } + + if (QueryExtension("GL_S3_s3tc")) + { + EnableExtension(_GL_S3_s3tc); + if (m_debug && doDebugMessages) + std::cout << "Enabled GL_S3_s3tc" << std::endl; + } + +#if defined(GL_ATI_draw_buffers) + if (QueryExtension("GL_ATI_draw_buffers")) + { + glDrawBuffersATI = reinterpret_cast(bglGetProcAddress((const GLubyte *) "glDrawBuffersATI")); + if (glDrawBuffersATI) { + EnableExtension(_GL_ATI_draw_buffers); + if (m_debug && doDebugMessages) + std::cout << "Enabled GL_ATI_draw_buffers" << std::endl; + } else { + std::cout << "ERROR: GL_ATI_draw_buffers implementation is broken!" << std::endl; + } + } +#endif + + if (QueryExtension("GL_ATI_texture_env_combine3")) + { + EnableExtension(_GL_ATI_texture_env_combine3); + if (m_debug && doDebugMessages) + std::cout << "Enabled GL_ATI_texture_env_combine3" << std::endl; + } + + if (QueryExtension("GL_ATI_texture_float")) + { + EnableExtension(_GL_ATI_texture_float); + if (m_debug && doDebugMessages) + std::cout << "Enabled GL_ATI_texture_float" << std::endl; + } + + if (QueryExtension("GL_NV_float_buffer")) + { + EnableExtension(_GL_NV_float_buffer); + if (m_debug && doDebugMessages) + std::cout << "Enabled GL_NV_float_buffer" << std::endl; + } + +#if defined(GL_NV_fragment_program) + if (QueryExtension("GL_NV_fragment_program")) + { + glProgramNamedParameter4fNV = reinterpret_cast(bglGetProcAddress((const GLubyte *) "glProgramNamedParameter4fNV")); + glProgramNamedParameter4dNV = reinterpret_cast(bglGetProcAddress((const GLubyte *) "glProgramNamedParameter4dNV")); + glProgramNamedParameter4fvNV = reinterpret_cast(bglGetProcAddress((const GLubyte *) "glProgramNamedParameter4fvNV")); + glProgramNamedParameter4dvNV = reinterpret_cast(bglGetProcAddress((const GLubyte *) "glProgramNamedParameter4dvNV")); + glGetProgramNamedParameterfvNV = reinterpret_cast(bglGetProcAddress((const GLubyte *) "glGetProgramNamedParameterfvNV")); + glGetProgramNamedParameterdvNV = reinterpret_cast(bglGetProcAddress((const GLubyte *) "glGetProgramNamedParameterdvNV")); + if (glProgramNamedParameter4fNV && glProgramNamedParameter4dNV && glProgramNamedParameter4fvNV && glProgramNamedParameter4dvNV && glGetProgramNamedParameterfvNV && glGetProgramNamedParameterdvNV) { + EnableExtension(_GL_NV_fragment_program); + if (m_debug && doDebugMessages) + std::cout << "Enabled GL_NV_fragment_program" << std::endl; + } else { + std::cout << "ERROR: GL_NV_fragment_program implementation is broken!" << std::endl; + } + } +#endif + +#if defined(GL_NV_half_float) + if (QueryExtension("GL_NV_half_float")) + { + glVertex2hNV = reinterpret_cast(bglGetProcAddress((const GLubyte *) "glVertex2hNV")); + glVertex2hvNV = reinterpret_cast(bglGetProcAddress((const GLubyte *) "glVertex2hvNV")); + glVertex3hNV = reinterpret_cast(bglGetProcAddress((const GLubyte *) "glVertex3hNV")); + glVertex3hvNV = reinterpret_cast(bglGetProcAddress((const GLubyte *) "glVertex3hvNV")); + glVertex4hNV = reinterpret_cast(bglGetProcAddress((const GLubyte *) "glVertex4hNV")); + glVertex4hvNV = reinterpret_cast(bglGetProcAddress((const GLubyte *) "glVertex4hvNV")); + glNormal3hNV = reinterpret_cast(bglGetProcAddress((const GLubyte *) "glNormal3hNV")); + glNormal3hvNV = reinterpret_cast(bglGetProcAddress((const GLubyte *) "glNormal3hvNV")); + glColor3hNV = reinterpret_cast(bglGetProcAddress((const GLubyte *) "glColor3hNV")); + glColor3hvNV = reinterpret_cast(bglGetProcAddress((const GLubyte *) "glColor3hvNV")); + glColor4hNV = reinterpret_cast(bglGetProcAddress((const GLubyte *) "glColor4hNV")); + glColor4hvNV = reinterpret_cast(bglGetProcAddress((const GLubyte *) "glColor4hvNV")); + glTexCoord1hNV = reinterpret_cast(bglGetProcAddress((const GLubyte *) "glTexCoord1hNV")); + glTexCoord1hvNV = reinterpret_cast(bglGetProcAddress((const GLubyte *) "glTexCoord1hvNV")); + glTexCoord2hNV = reinterpret_cast(bglGetProcAddress((const GLubyte *) "glTexCoord2hNV")); + glTexCoord2hvNV = reinterpret_cast(bglGetProcAddress((const GLubyte *) "glTexCoord2hvNV")); + glTexCoord3hNV = reinterpret_cast(bglGetProcAddress((const GLubyte *) "glTexCoord3hNV")); + glTexCoord3hvNV = reinterpret_cast(bglGetProcAddress((const GLubyte *) "glTexCoord3hvNV")); + glTexCoord4hNV = reinterpret_cast(bglGetProcAddress((const GLubyte *) "glTexCoord4hNV")); + glTexCoord4hvNV = reinterpret_cast(bglGetProcAddress((const GLubyte *) "glTexCoord4hvNV")); + glMultiTexCoord1hNV = reinterpret_cast(bglGetProcAddress((const GLubyte *) "glMultiTexCoord1hNV")); + glMultiTexCoord1hvNV = reinterpret_cast(bglGetProcAddress((const GLubyte *) "glMultiTexCoord1hvNV")); + glMultiTexCoord2hNV = reinterpret_cast(bglGetProcAddress((const GLubyte *) "glMultiTexCoord2hNV")); + glMultiTexCoord2hvNV = reinterpret_cast(bglGetProcAddress((const GLubyte *) "glMultiTexCoord2hvNV")); + glMultiTexCoord3hNV = reinterpret_cast(bglGetProcAddress((const GLubyte *) "glMultiTexCoord3hNV")); + glMultiTexCoord3hvNV = reinterpret_cast(bglGetProcAddress((const GLubyte *) "glMultiTexCoord3hvNV")); + glMultiTexCoord4hNV = reinterpret_cast(bglGetProcAddress((const GLubyte *) "glMultiTexCoord4hNV")); + glMultiTexCoord4hvNV = reinterpret_cast(bglGetProcAddress((const GLubyte *) "glMultiTexCoord4hvNV")); + glFogCoordhNV = reinterpret_cast(bglGetProcAddress((const GLubyte *) "glFogCoordhNV")); + glFogCoordhvNV = reinterpret_cast(bglGetProcAddress((const GLubyte *) "glFogCoordhvNV")); + glSecondaryColor3hNV = reinterpret_cast(bglGetProcAddress((const GLubyte *) "glSecondaryColor3hNV")); + glSecondaryColor3hvNV = reinterpret_cast(bglGetProcAddress((const GLubyte *) "glSecondaryColor3hvNV")); + glVertexWeighthNV = reinterpret_cast(bglGetProcAddress((const GLubyte *) "glVertexWeighthNV")); + glVertexWeighthvNV = reinterpret_cast(bglGetProcAddress((const GLubyte *) "glVertexWeighthvNV")); + glVertexAttrib1hNV = reinterpret_cast(bglGetProcAddress((const GLubyte *) "glVertexAttrib1hNV")); + glVertexAttrib1hvNV = reinterpret_cast(bglGetProcAddress((const GLubyte *) "glVertexAttrib1hvNV")); + glVertexAttrib2hNV = reinterpret_cast(bglGetProcAddress((const GLubyte *) "glVertexAttrib2hNV")); + glVertexAttrib2hvNV = reinterpret_cast(bglGetProcAddress((const GLubyte *) "glVertexAttrib2hvNV")); + glVertexAttrib3hNV = reinterpret_cast(bglGetProcAddress((const GLubyte *) "glVertexAttrib3hNV")); + glVertexAttrib3hvNV = reinterpret_cast(bglGetProcAddress((const GLubyte *) "glVertexAttrib3hvNV")); + glVertexAttrib4hNV = reinterpret_cast(bglGetProcAddress((const GLubyte *) "glVertexAttrib4hNV")); + glVertexAttrib4hvNV = reinterpret_cast(bglGetProcAddress((const GLubyte *) "glVertexAttrib4hvNV")); + glVertexAttribs1hvNV = reinterpret_cast(bglGetProcAddress((const GLubyte *) "glVertexAttribs1hvNV")); + glVertexAttribs2hvNV = reinterpret_cast(bglGetProcAddress((const GLubyte *) "glVertexAttribs2hvNV")); + glVertexAttribs3hvNV = reinterpret_cast(bglGetProcAddress((const GLubyte *) "glVertexAttribs3hvNV")); + glVertexAttribs4hvNV = reinterpret_cast(bglGetProcAddress((const GLubyte *) "glVertexAttribs4hvNV")); + if (glVertex2hNV && glVertex2hvNV && glVertex3hNV && glVertex3hvNV && glVertex4hNV && glVertex4hvNV && glNormal3hNV && glNormal3hvNV && glColor3hNV && glColor3hvNV && glColor4hNV && glColor4hvNV && glTexCoord1hNV && glTexCoord1hvNV && glTexCoord2hNV && glTexCoord2hvNV && glTexCoord3hNV && glTexCoord3hvNV && glTexCoord4hNV && glTexCoord4hvNV && glMultiTexCoord1hNV && glMultiTexCoord1hvNV && glMultiTexCoord2hNV && glMultiTexCoord2hvNV && glMultiTexCoord3hNV && glMultiTexCoord3hvNV && glMultiTexCoord4hNV && glMultiTexCoord4hvNV && glFogCoordhNV && glFogCoordhvNV && glSecondaryColor3hNV && glSecondaryColor3hvNV && glVertexWeighthNV && glVertexWeighthvNV && glVertexAttrib1hNV && glVertexAttrib1hvNV && glVertexAttrib2hNV && glVertexAttrib2hvNV && glVertexAttrib3hNV && glVertexAttrib3hvNV && glVertexAttrib4hNV && glVertexAttrib4hvNV && glVertexAttribs1hvNV && glVertexAttribs2hvNV && glVertexAttribs3hvNV && glVertexAttribs4hvNV) { + EnableExtension(_GL_NV_half_float); + if (m_debug && doDebugMessages) + std::cout << "Enabled GL_NV_half_float" << std::endl; + } else { + std::cout << "ERROR: GL_NV_half_float implementation is broken!" << std::endl; + } + } +#endif + +#if defined(GL_NV_pixel_data_range) + if (QueryExtension("GL_NV_pixel_data_range")) + { + glPixelDataRangeNV = reinterpret_cast(bglGetProcAddress((const GLubyte *) "glPixelDataRangeNV")); + glFlushPixelDataRangeNV = reinterpret_cast(bglGetProcAddress((const GLubyte *) "glFlushPixelDataRangeNV")); + if (glPixelDataRangeNV && glFlushPixelDataRangeNV) { + EnableExtension(_GL_NV_pixel_data_range); + if (m_debug && doDebugMessages) + std::cout << "Enabled GL_NV_pixel_data_range" << std::endl; + } else { + std::cout << "ERROR: GL_NV_pixel_data_range implementation is broken!" << std::endl; + } + } +#endif + +#if defined(GL_NV_primitive_restart) + if (QueryExtension("GL_NV_primitive_restart")) + { + glPrimitiveRestartNV = reinterpret_cast(bglGetProcAddress((const GLubyte *) "glPrimitiveRestartNV")); + glPrimitiveRestartIndexNV = reinterpret_cast(bglGetProcAddress((const GLubyte *) "glPrimitiveRestartIndexNV")); + if (glPrimitiveRestartNV && glPrimitiveRestartIndexNV) { + EnableExtension(_GL_NV_primitive_restart); + if (m_debug && doDebugMessages) + std::cout << "Enabled GL_NV_primitive_restart" << std::endl; + } else { + std::cout << "ERROR: GL_NV_primitive_restart implementation is broken!" << std::endl; + } + } +#endif + + if (QueryExtension("GL_NV_texture_expand_normal")) + { + EnableExtension(_GL_NV_texture_expand_normal); + if (m_debug && doDebugMessages) + std::cout << "Enabled GL_NV_texture_expand_normal" << std::endl; + } + + if (QueryExtension("GL_NV_vertex_program2")) + { + EnableExtension(_GL_NV_vertex_program2); + if (m_debug && doDebugMessages) + std::cout << "Enabled GL_NV_vertex_program2" << std::endl; + } + +#if defined(GL_ATI_map_object_buffer) + if (QueryExtension("GL_ATI_map_object_buffer")) + { + glMapObjectBufferATI = reinterpret_cast(bglGetProcAddress((const GLubyte *) "glMapObjectBufferATI")); + glUnmapObjectBufferATI = reinterpret_cast(bglGetProcAddress((const GLubyte *) "glUnmapObjectBufferATI")); + if (glMapObjectBufferATI && glUnmapObjectBufferATI) { + EnableExtension(_GL_ATI_map_object_buffer); + if (m_debug && doDebugMessages) + std::cout << "Enabled GL_ATI_map_object_buffer" << std::endl; + } else { + std::cout << "ERROR: GL_ATI_map_object_buffer implementation is broken!" << std::endl; + } + } +#endif + +#if defined(GL_ATI_separate_stencil) + if (QueryExtension("GL_ATI_separate_stencil")) + { + glStencilOpSeparateATI = reinterpret_cast(bglGetProcAddress((const GLubyte *) "glStencilOpSeparateATI")); + glStencilFuncSeparateATI = reinterpret_cast(bglGetProcAddress((const GLubyte *) "glStencilFuncSeparateATI")); + if (glStencilOpSeparateATI && glStencilFuncSeparateATI) { + EnableExtension(_GL_ATI_separate_stencil); + if (m_debug && doDebugMessages) + std::cout << "Enabled GL_ATI_separate_stencil" << std::endl; + } else { + std::cout << "ERROR: GL_ATI_separate_stencil implementation is broken!" << std::endl; + } + } +#endif + +#if defined(GL_ATI_vertex_attrib_array_object) + if (QueryExtension("GL_ATI_vertex_attrib_array_object")) + { + glVertexAttribArrayObjectATI = reinterpret_cast(bglGetProcAddress((const GLubyte *) "glVertexAttribArrayObjectATI")); + glGetVertexAttribArrayObjectfvATI = reinterpret_cast(bglGetProcAddress((const GLubyte *) "glGetVertexAttribArrayObjectfvATI")); + glGetVertexAttribArrayObjectivATI = reinterpret_cast(bglGetProcAddress((const GLubyte *) "glGetVertexAttribArrayObjectivATI")); + if (glVertexAttribArrayObjectATI && glGetVertexAttribArrayObjectfvATI && glGetVertexAttribArrayObjectivATI) { + EnableExtension(_GL_ATI_vertex_attrib_array_object); + if (m_debug && doDebugMessages) + std::cout << "Enabled GL_ATI_vertex_attrib_array_object" << std::endl; + } else { + std::cout << "ERROR: GL_ATI_vertex_attrib_array_object implementation is broken!" << std::endl; + } + } +#endif + +#if defined(GL_EXT_depth_bounds_test) + if (QueryExtension("GL_EXT_depth_bounds_test")) + { + glDepthBoundsEXT = reinterpret_cast(bglGetProcAddress((const GLubyte *) "glDepthBoundsEXT")); + if (glDepthBoundsEXT) { + EnableExtension(_GL_EXT_depth_bounds_test); + if (m_debug && doDebugMessages) + std::cout << "Enabled GL_EXT_depth_bounds_test" << std::endl; + } else { + std::cout << "ERROR: GL_EXT_depth_bounds_test implementation is broken!" << std::endl; + } + } +#endif + + if (QueryExtension("GL_EXT_texture_mirror_clamp")) + { + EnableExtension(_GL_EXT_texture_mirror_clamp); + if (m_debug && doDebugMessages) + std::cout << "Enabled GL_EXT_texture_mirror_clamp" << std::endl; + } + +#if defined(GL_EXT_blend_equation_separate) + if (QueryExtension("GL_EXT_blend_equation_separate")) + { + glBlendEquationSeparateEXT = reinterpret_cast(bglGetProcAddress((const GLubyte *) "glBlendEquationSeparateEXT")); + if (glBlendEquationSeparateEXT) { + EnableExtension(_GL_EXT_blend_equation_separate); + if (m_debug && doDebugMessages) + std::cout << "Enabled GL_EXT_blend_equation_separate" << std::endl; + } else { + std::cout << "ERROR: GL_EXT_blend_equation_separate implementation is broken!" << std::endl; + } + } +#endif + + if (QueryExtension("GL_MESA_pack_invert")) + { + EnableExtension(_GL_MESA_pack_invert); + if (m_debug && doDebugMessages) + std::cout << "Enabled GL_MESA_pack_invert" << std::endl; + } + + if (QueryExtension("GL_MESA_ycbcr_texture")) + { + EnableExtension(_GL_MESA_ycbcr_texture); + if (m_debug && doDebugMessages) + std::cout << "Enabled GL_MESA_ycbcr_texture" << std::endl; + } + + + /* End mkglext.py */ + doDebugMessages = false; +} + diff --git a/source/gameengine/Rasterizer/RAS_OpenGLRasterizer/RAS_GLExtensionManager.h b/source/gameengine/Rasterizer/RAS_OpenGLRasterizer/RAS_GLExtensionManager.h new file mode 100644 index 00000000000..8f570ee356c --- /dev/null +++ b/source/gameengine/Rasterizer/RAS_OpenGLRasterizer/RAS_GLExtensionManager.h @@ -0,0 +1,1718 @@ +/** + * $Id$ + * ***** BEGIN GPL/BL DUAL LICENSE BLOCK ***** + * + * This program is free software; you can redistribute it and/or + * modify it under the terms of the GNU General Public License + * as published by the Free Software Foundation; either version 2 + * of the License, or (at your option) any later version. The Blender + * Foundation also sells licenses for use in proprietary software under + * the Blender License. See http://www.blender.org/BL/ for information + * about this. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software Foundation, + * Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. + * + * The Original Code is Copyright (C) 2001-2002 by NaN Holding BV. + * All rights reserved. + * + * The Original Code is: all of this file. + * + * Contributor(s): none yet. + * + * ***** END GPL/BL DUAL LICENSE BLOCK ***** + */ + +#ifndef __RAS_GLEXTENSIONMANAGER_H__ +#define __RAS_GLEXTENSIONMANAGER_H__ + +#ifdef __APPLE__ +#include +#else +#include +#endif + +class RAS_GLExtensionManager +{ +public: + /* http://oss.sgi.com/projects/ogl-sample/registry/ */ + typedef enum { + /* ARB Extensions */ + _GL_ARB_multitexture , + _GLX_ARB_get_proc_address , + _GL_ARB_transpose_matrix , + _WGL_ARB_buffer_region , + _GL_ARB_multisample , + _GL_ARB_texture_env_add , + _GL_ARB_texture_cube_map , + _WGL_ARB_extensions_string , + _WGL_ARB_pixel_format , + _WGL_ARB_make_current_read , + _WGL_ARB_pbuffer , + _GL_ARB_texture_compression , + _GL_ARB_texture_border_clamp , + _GL_ARB_point_parameters , + _GL_ARB_vertex_blend , + _GL_ARB_matrix_palette , + _GL_ARB_texture_env_combine , + _GL_ARB_texture_env_crossbar , + _GL_ARB_texture_env_dot3 , + _WGL_ARB_render_texture , + _GL_ARB_texture_mirrored_repeat , + _GL_ARB_depth_texture , + _GL_ARB_shadow , + _GL_ARB_shadow_ambient , + _GL_ARB_window_pos , + _GL_ARB_vertex_program , + _GL_ARB_fragment_program , + _GL_ARB_vertex_buffer_object , + _GL_ARB_occlusion_query , + _GL_ARB_shader_objects , + _GL_ARB_vertex_shader , + _GL_ARB_fragment_shader , + _GL_ARB_shading_language_100 , + _GL_ARB_texture_non_power_of_two , + _GL_ARB_point_sprite , + _GL_ARB_fragment_program_shadow , + + /* Non ARB Extensions */ + _GL_EXT_abgr , + _GL_EXT_blend_color , + _GL_EXT_polygon_offset , + _GL_EXT_texture , + _GL_EXT_texture3D , + _GL_SGIS_texture_filter4 , + _GL_EXT_subtexture , + _GL_EXT_copy_texture , + _GL_EXT_histogram , + _GL_EXT_convolution , + _GL_SGI_color_matrix , + _GL_SGI_color_table , + _GL_SGIS_pixel_texture , + _GL_SGIS_texture4D , + _GL_SGI_texture_color_table , + _GL_EXT_cmyka , + _GL_EXT_texture_object , + _GL_SGIS_detail_texture , + _GL_SGIS_sharpen_texture , + _GL_EXT_packed_pixels , + _GL_SGIS_texture_lod , + _GL_SGIS_multisample , + _GL_EXT_rescale_normal , + _GLX_EXT_visual_info , + _GL_EXT_vertex_array , + _GL_EXT_misc_attribute , + _GL_SGIS_generate_mipmap , + _GL_SGIX_clipmap , + _GL_SGIX_shadow , + _GL_SGIS_texture_edge_clamp , + _GL_SGIS_texture_border_clamp , + _GL_EXT_blend_minmax , + _GL_EXT_blend_subtract , + _GL_EXT_blend_logic_op , + _GLX_SGI_swap_control , + _GLX_SGI_video_sync , + _GLX_SGI_make_current_read , + _GLX_SGIX_video_source , + _GLX_EXT_visual_rating , + _GL_SGIX_interlace , + _GLX_EXT_import_context , + _GLX_SGIX_fbconfig , + _GLX_SGIX_pbuffer , + _GL_SGIS_texture_select , + _GL_SGIX_sprite , + _GL_SGIX_texture_multi_buffer , + _GL_EXT_point_parameters , + _GL_SGIX_instruments , + _GL_SGIX_texture_scale_bias , + _GL_SGIX_framezoom , + _GL_SGIX_tag_sample_buffer , + _GL_SGIX_reference_plane , + _GL_SGIX_flush_raster , + _GLX_SGI_cushion , + _GL_SGIX_depth_texture , + _GL_SGIS_fog_function , + _GL_SGIX_fog_offset , + _GL_HP_image_transform , + _GL_HP_convolution_border_modes , + _GL_SGIX_texture_add_env , + _GL_EXT_color_subtable , + _GLU_EXT_object_space_tess , + _GL_PGI_vertex_hints , + _GL_PGI_misc_hints , + _GL_EXT_paletted_texture , + _GL_EXT_clip_volume_hint , + _GL_SGIX_list_priority , + _GL_SGIX_ir_instrument1 , + _GLX_SGIX_video_resize , + _GL_SGIX_texture_lod_bias , + _GLU_SGI_filter4_parameters , + _GLX_SGIX_dm_buffer , + _GL_SGIX_shadow_ambient , + _GLX_SGIX_swap_group , + _GLX_SGIX_swap_barrier , + _GL_EXT_index_texture , + _GL_EXT_index_material , + _GL_EXT_index_func , + _GL_EXT_index_array_formats , + _GL_EXT_compiled_vertex_array , + _GL_EXT_cull_vertex , + _GLU_EXT_nurbs_tessellator , + _GL_SGIX_ycrcb , + _GL_EXT_fragment_lighting , + _GL_IBM_rasterpos_clip , + _GL_HP_texture_lighting , + _GL_EXT_draw_range_elements , + _GL_WIN_phong_shading , + _GL_WIN_specular_fog , + _GLX_SGIS_color_range , + _GL_EXT_light_texture , + _GL_SGIX_blend_alpha_minmax , + _GL_EXT_scene_marker , + _GL_SGIX_pixel_texture_bits , + _GL_EXT_bgra , + _GL_SGIX_async , + _GL_SGIX_async_pixel , + _GL_SGIX_async_histogram , + _GL_INTEL_texture_scissor , + _GL_INTEL_parallel_arrays , + _GL_HP_occlusion_test , + _GL_EXT_pixel_transform , + _GL_EXT_pixel_transform_color_table , + _GL_EXT_shared_texture_palette , + _GLX_SGIS_blended_overlay , + _GL_EXT_separate_specular_color , + _GL_EXT_secondary_color , + _GL_EXT_texture_env , + _GL_EXT_texture_perturb_normal , + _GL_EXT_multi_draw_arrays , + _GL_EXT_fog_coord , + _GL_REND_screen_coordinates , + _GL_EXT_coordinate_frame , + _GL_EXT_texture_env_combine , + _GL_APPLE_specular_vector , + _GL_SGIX_pixel_texture , + _GL_APPLE_transform_hint , + _GL_SUNX_constant_data , + _GL_SUN_global_alpha , + _GL_SUN_triangle_list , + _GL_SUN_vertex , + _WGL_EXT_display_color_table , + _WGL_EXT_extensions_string , + _WGL_EXT_make_current_read , + _WGL_EXT_pixel_format , + _WGL_EXT_pbuffer , + _WGL_EXT_swap_control , + _GL_EXT_blend_func_separate , + _GL_INGR_color_clamp , + _GL_INGR_interlace_read , + _GL_EXT_stencil_wrap , + _WGL_EXT_depth_float , + _GL_EXT_422_pixels , + _GL_NV_texgen_reflection , + _GL_SGIX_texture_range , + _GL_SUN_convolution_border_modes , + _GLX_SUN_get_transparent_index , + _GL_EXT_texture_env_add , + _GL_EXT_texture_lod_bias , + _GL_EXT_texture_filter_anisotropic , + _GL_EXT_vertex_weighting , + _GL_NV_light_max_exponent , + _GL_NV_vertex_array_range , + _GL_NV_register_combiners , + _GL_NV_fog_distance , + _GL_NV_texgen_emboss , + _GL_NV_blend_square , + _GL_NV_texture_env_combine4 , + _GL_MESA_resize_buffers , + _GL_MESA_window_pos , + _GL_EXT_texture_compression_s3tc , + _GL_IBM_cull_vertex , + _GL_IBM_multimode_draw_arrays , + _GL_IBM_vertex_array_lists , + _GL_3DFX_texture_compression_FXT1 , + _GL_3DFX_multisample , + _GL_3DFX_tbuffer , + _WGL_EXT_multisample , + _GL_SGIX_vertex_preclip , + _GL_SGIX_resample , + _GL_SGIS_texture_color_mask , + _GLX_MESA_copy_sub_buffer , + _GLX_MESA_pixmap_colormap , + _GLX_MESA_release_buffers , + _GLX_MESA_set_3dfx_mode , + _GL_EXT_texture_env_dot3 , + _GL_ATI_texture_mirror_once , + _GL_NV_fence , + _GL_IBM_static_data , + _GL_IBM_texture_mirrored_repeat , + _GL_NV_evaluators , + _GL_NV_packed_depth_stencil , + _GL_NV_register_combiners2 , + _GL_NV_texture_compression_vtc , + _GL_NV_texture_rectangle , + _GL_NV_texture_shader , + _GL_NV_texture_shader2 , + _GL_NV_vertex_array_range2 , + _GL_NV_vertex_program , + _GLX_SGIX_visual_select_group , + _GL_SGIX_texture_coordinate_clamp , + _GLX_OML_swap_method , + _GLX_OML_sync_control , + _GL_OML_interlace , + _GL_OML_subsample , + _GL_OML_resample , + _WGL_OML_sync_control , + _GL_NV_copy_depth_to_color , + _GL_ATI_envmap_bumpmap , + _GL_ATI_fragment_shader , + _GL_ATI_pn_triangles , + _GL_ATI_vertex_array_object , + _GL_EXT_vertex_shader , + _GL_ATI_vertex_streams , + _WGL_I3D_digital_video_control , + _WGL_I3D_gamma , + _WGL_I3D_genlock , + _WGL_I3D_image_buffer , + _WGL_I3D_swap_frame_lock , + _WGL_I3D_swap_frame_usage , + _GL_ATI_element_array , + _GL_SUN_mesh_array , + _GL_SUN_slice_accum , + _GL_NV_multisample_filter_hint , + _GL_NV_depth_clamp , + _GL_NV_occlusion_query , + _GL_NV_point_sprite , + _WGL_NV_render_depth_texture , + _WGL_NV_render_texture_rectangle , + _GL_NV_texture_shader3 , + _GL_NV_vertex_program1_1 , + _GL_EXT_shadow_funcs , + _GL_EXT_stencil_two_side , + _GL_ATI_text_fragment_shader , + _GL_APPLE_client_storage , + _GL_APPLE_element_array , + _GL_APPLE_fence , + _GL_APPLE_vertex_array_object , + _GL_APPLE_vertex_array_range , + _GL_APPLE_ycbcr_422 , + _GL_S3_s3tc , + _GL_ATI_draw_buffers , + _WGL_ATI_pixel_format_float , + _GL_ATI_texture_env_combine3 , + _GL_ATI_texture_float , + _GL_NV_float_buffer , + _GL_NV_fragment_program , + _GL_NV_half_float , + _GL_NV_pixel_data_range , + _GL_NV_primitive_restart , + _GL_NV_texture_expand_normal , + _GL_NV_vertex_program2 , + _GL_ATI_map_object_buffer , + _GL_ATI_separate_stencil , + _GL_ATI_vertex_attrib_array_object , + _GL_OES_byte_coordinates , + _GL_OES_fixed_point , + _GL_OES_single_precision , + _GL_OES_compressed_paletted_texture , + _GL_OES_read_format , + _GL_OES_query_matrix , + _GL_EXT_depth_bounds_test , + _GL_EXT_texture_mirror_clamp , + _GL_EXT_blend_equation_separate , + _GL_MESA_pack_invert , + _GL_MESA_ycbcr_texture, + + /* Finished */ + _BGL_TEST, + NUM_EXTENSIONS + } ExtensionName; + + bool QueryExtension(ExtensionName name); + bool QueryVersion(int major, int minor); + + void LinkExtensions(); + + RAS_GLExtensionManager(int debug = 0); + // FIXME: GLX only + //RAS_GLExtensionManager(Display *dpy, int screen); + ~RAS_GLExtensionManager(); + +private: + std::vector extensions; + /* Bit array of available extensions */ + unsigned int enabled_extensions[(NUM_EXTENSIONS + 8*sizeof(unsigned int) - 1)/(8*sizeof(unsigned int))]; + int m_debug; + + bool QueryExtension(STR_String extension_name); + void EnableExtension(ExtensionName name); + +}; + +namespace RAS_GL { + +/* Begin mkglext.h */ + +/* GL_EXT_compiled_vertex_array */ +/* Always safe to call: will default to noop */ +#ifdef GL_EXT_compiled_vertex_array +extern PFNGLLOCKARRAYSEXTPROC glLockArraysEXT; +extern PFNGLUNLOCKARRAYSEXTPROC glUnlockArraysEXT; +#else +static inline void glLockArraysEXT(GLint x, GLsizei y) {} +static inline void glUnlockArraysEXT(void) {} +#endif + +#if defined(GL_ARB_transpose_matrix) +extern PFNGLLOADTRANSPOSEMATRIXFARBPROC glLoadTransposeMatrixfARB; +extern PFNGLLOADTRANSPOSEMATRIXDARBPROC glLoadTransposeMatrixdARB; +extern PFNGLMULTTRANSPOSEMATRIXFARBPROC glMultTransposeMatrixfARB; +extern PFNGLMULTTRANSPOSEMATRIXDARBPROC glMultTransposeMatrixdARB; +#endif + +#if defined(GL_ARB_multisample) +extern PFNGLSAMPLECOVERAGEARBPROC glSampleCoverageARB; +#endif + +#if defined(GL_ARB_texture_env_add) +#endif + +#if defined(GL_ARB_texture_cube_map) +#endif + +#if defined(GL_ARB_texture_compression) +extern PFNGLCOMPRESSEDTEXIMAGE3DARBPROC glCompressedTexImage3DARB; +extern PFNGLCOMPRESSEDTEXIMAGE2DARBPROC glCompressedTexImage2DARB; +extern PFNGLCOMPRESSEDTEXIMAGE1DARBPROC glCompressedTexImage1DARB; +extern PFNGLCOMPRESSEDTEXSUBIMAGE3DARBPROC glCompressedTexSubImage3DARB; +extern PFNGLCOMPRESSEDTEXSUBIMAGE2DARBPROC glCompressedTexSubImage2DARB; +extern PFNGLCOMPRESSEDTEXSUBIMAGE1DARBPROC glCompressedTexSubImage1DARB; +extern PFNGLGETCOMPRESSEDTEXIMAGEARBPROC glGetCompressedTexImageARB; +#endif + +#if defined(GL_ARB_texture_border_clamp) +#endif + +#if defined(GL_ARB_point_parameters) +extern PFNGLPOINTPARAMETERFARBPROC glPointParameterfARB; +extern PFNGLPOINTPARAMETERFVARBPROC glPointParameterfvARB; +#endif + +#if defined(GL_ARB_vertex_blend) +extern PFNGLWEIGHTBVARBPROC glWeightbvARB; +extern PFNGLWEIGHTSVARBPROC glWeightsvARB; +extern PFNGLWEIGHTIVARBPROC glWeightivARB; +extern PFNGLWEIGHTFVARBPROC glWeightfvARB; +extern PFNGLWEIGHTDVARBPROC glWeightdvARB; +extern PFNGLWEIGHTUBVARBPROC glWeightubvARB; +extern PFNGLWEIGHTUSVARBPROC glWeightusvARB; +extern PFNGLWEIGHTUIVARBPROC glWeightuivARB; +extern PFNGLWEIGHTPOINTERARBPROC glWeightPointerARB; +extern PFNGLVERTEXBLENDARBPROC glVertexBlendARB; +#endif + +#if defined(GL_ARB_matrix_palette) +extern PFNGLCURRENTPALETTEMATRIXARBPROC glCurrentPaletteMatrixARB; +extern PFNGLMATRIXINDEXUBVARBPROC glMatrixIndexubvARB; +extern PFNGLMATRIXINDEXUSVARBPROC glMatrixIndexusvARB; +extern PFNGLMATRIXINDEXUIVARBPROC glMatrixIndexuivARB; +extern PFNGLMATRIXINDEXPOINTERARBPROC glMatrixIndexPointerARB; +#endif + +#if defined(GL_ARB_texture_env_combine) +#endif + +#if defined(GL_ARB_texture_env_crossbar) +#endif + +#if defined(GL_ARB_texture_env_dot3) +#endif + +#if defined(GL_ARB_texture_mirrored_repeat) +#endif + +#if defined(GL_ARB_depth_texture) +#endif + +#if defined(GL_ARB_shadow) +#endif + +#if defined(GL_ARB_shadow_ambient) +#endif + +#if defined(GL_ARB_window_pos) +extern PFNGLWINDOWPOS2DARBPROC glWindowPos2dARB; +extern PFNGLWINDOWPOS2DVARBPROC glWindowPos2dvARB; +extern PFNGLWINDOWPOS2FARBPROC glWindowPos2fARB; +extern PFNGLWINDOWPOS2FVARBPROC glWindowPos2fvARB; +extern PFNGLWINDOWPOS2IARBPROC glWindowPos2iARB; +extern PFNGLWINDOWPOS2IVARBPROC glWindowPos2ivARB; +extern PFNGLWINDOWPOS2SARBPROC glWindowPos2sARB; +extern PFNGLWINDOWPOS2SVARBPROC glWindowPos2svARB; +extern PFNGLWINDOWPOS3DARBPROC glWindowPos3dARB; +extern PFNGLWINDOWPOS3DVARBPROC glWindowPos3dvARB; +extern PFNGLWINDOWPOS3FARBPROC glWindowPos3fARB; +extern PFNGLWINDOWPOS3FVARBPROC glWindowPos3fvARB; +extern PFNGLWINDOWPOS3IARBPROC glWindowPos3iARB; +extern PFNGLWINDOWPOS3IVARBPROC glWindowPos3ivARB; +extern PFNGLWINDOWPOS3SARBPROC glWindowPos3sARB; +extern PFNGLWINDOWPOS3SVARBPROC glWindowPos3svARB; +#endif + +#if defined(GL_ARB_vertex_program) +extern PFNGLVERTEXATTRIB1DARBPROC glVertexAttrib1dARB; +extern PFNGLVERTEXATTRIB1DVARBPROC glVertexAttrib1dvARB; +extern PFNGLVERTEXATTRIB1FARBPROC glVertexAttrib1fARB; +extern PFNGLVERTEXATTRIB1FVARBPROC glVertexAttrib1fvARB; +extern PFNGLVERTEXATTRIB1SARBPROC glVertexAttrib1sARB; +extern PFNGLVERTEXATTRIB1SVARBPROC glVertexAttrib1svARB; +extern PFNGLVERTEXATTRIB2DARBPROC glVertexAttrib2dARB; +extern PFNGLVERTEXATTRIB2DVARBPROC glVertexAttrib2dvARB; +extern PFNGLVERTEXATTRIB2FARBPROC glVertexAttrib2fARB; +extern PFNGLVERTEXATTRIB2FVARBPROC glVertexAttrib2fvARB; +extern PFNGLVERTEXATTRIB2SARBPROC glVertexAttrib2sARB; +extern PFNGLVERTEXATTRIB2SVARBPROC glVertexAttrib2svARB; +extern PFNGLVERTEXATTRIB3DARBPROC glVertexAttrib3dARB; +extern PFNGLVERTEXATTRIB3DVARBPROC glVertexAttrib3dvARB; +extern PFNGLVERTEXATTRIB3FARBPROC glVertexAttrib3fARB; +extern PFNGLVERTEXATTRIB3FVARBPROC glVertexAttrib3fvARB; +extern PFNGLVERTEXATTRIB3SARBPROC glVertexAttrib3sARB; +extern PFNGLVERTEXATTRIB3SVARBPROC glVertexAttrib3svARB; +extern PFNGLVERTEXATTRIB4NBVARBPROC glVertexAttrib4NbvARB; +extern PFNGLVERTEXATTRIB4NIVARBPROC glVertexAttrib4NivARB; +extern PFNGLVERTEXATTRIB4NSVARBPROC glVertexAttrib4NsvARB; +extern PFNGLVERTEXATTRIB4NUBARBPROC glVertexAttrib4NubARB; +extern PFNGLVERTEXATTRIB4NUBVARBPROC glVertexAttrib4NubvARB; +extern PFNGLVERTEXATTRIB4NUIVARBPROC glVertexAttrib4NuivARB; +extern PFNGLVERTEXATTRIB4NUSVARBPROC glVertexAttrib4NusvARB; +extern PFNGLVERTEXATTRIB4BVARBPROC glVertexAttrib4bvARB; +extern PFNGLVERTEXATTRIB4DARBPROC glVertexAttrib4dARB; +extern PFNGLVERTEXATTRIB4DVARBPROC glVertexAttrib4dvARB; +extern PFNGLVERTEXATTRIB4FARBPROC glVertexAttrib4fARB; +extern PFNGLVERTEXATTRIB4FVARBPROC glVertexAttrib4fvARB; +extern PFNGLVERTEXATTRIB4IVARBPROC glVertexAttrib4ivARB; +extern PFNGLVERTEXATTRIB4SARBPROC glVertexAttrib4sARB; +extern PFNGLVERTEXATTRIB4SVARBPROC glVertexAttrib4svARB; +extern PFNGLVERTEXATTRIB4UBVARBPROC glVertexAttrib4ubvARB; +extern PFNGLVERTEXATTRIB4UIVARBPROC glVertexAttrib4uivARB; +extern PFNGLVERTEXATTRIB4USVARBPROC glVertexAttrib4usvARB; +extern PFNGLVERTEXATTRIBPOINTERARBPROC glVertexAttribPointerARB; +extern PFNGLENABLEVERTEXATTRIBARRAYARBPROC glEnableVertexAttribArrayARB; +extern PFNGLDISABLEVERTEXATTRIBARRAYARBPROC glDisableVertexAttribArrayARB; +extern PFNGLPROGRAMSTRINGARBPROC glProgramStringARB; +extern PFNGLBINDPROGRAMARBPROC glBindProgramARB; +extern PFNGLDELETEPROGRAMSARBPROC glDeleteProgramsARB; +extern PFNGLGENPROGRAMSARBPROC glGenProgramsARB; +extern PFNGLPROGRAMENVPARAMETER4DARBPROC glProgramEnvParameter4dARB; +extern PFNGLPROGRAMENVPARAMETER4DVARBPROC glProgramEnvParameter4dvARB; +extern PFNGLPROGRAMENVPARAMETER4FARBPROC glProgramEnvParameter4fARB; +extern PFNGLPROGRAMENVPARAMETER4FVARBPROC glProgramEnvParameter4fvARB; +extern PFNGLPROGRAMLOCALPARAMETER4DARBPROC glProgramLocalParameter4dARB; +extern PFNGLPROGRAMLOCALPARAMETER4DVARBPROC glProgramLocalParameter4dvARB; +extern PFNGLPROGRAMLOCALPARAMETER4FARBPROC glProgramLocalParameter4fARB; +extern PFNGLPROGRAMLOCALPARAMETER4FVARBPROC glProgramLocalParameter4fvARB; +extern PFNGLGETPROGRAMENVPARAMETERDVARBPROC glGetProgramEnvParameterdvARB; +extern PFNGLGETPROGRAMENVPARAMETERFVARBPROC glGetProgramEnvParameterfvARB; +extern PFNGLGETPROGRAMLOCALPARAMETERDVARBPROC glGetProgramLocalParameterdvARB; +extern PFNGLGETPROGRAMLOCALPARAMETERFVARBPROC glGetProgramLocalParameterfvARB; +extern PFNGLGETPROGRAMIVARBPROC glGetProgramivARB; +extern PFNGLGETPROGRAMSTRINGARBPROC glGetProgramStringARB; +extern PFNGLGETVERTEXATTRIBDVARBPROC glGetVertexAttribdvARB; +extern PFNGLGETVERTEXATTRIBFVARBPROC glGetVertexAttribfvARB; +extern PFNGLGETVERTEXATTRIBIVARBPROC glGetVertexAttribivARB; +extern PFNGLGETVERTEXATTRIBPOINTERVARBPROC glGetVertexAttribPointervARB; +extern PFNGLISPROGRAMARBPROC glIsProgramARB; +#endif + +#if defined(GL_ARB_fragment_program) +#endif + +#if defined(GL_ARB_vertex_buffer_object) +extern PFNGLBINDBUFFERARBPROC glBindBufferARB; +extern PFNGLDELETEBUFFERSARBPROC glDeleteBuffersARB; +extern PFNGLGENBUFFERSARBPROC glGenBuffersARB; +extern PFNGLISBUFFERARBPROC glIsBufferARB; +extern PFNGLBUFFERDATAARBPROC glBufferDataARB; +extern PFNGLBUFFERSUBDATAARBPROC glBufferSubDataARB; +extern PFNGLGETBUFFERSUBDATAARBPROC glGetBufferSubDataARB; +extern PFNGLMAPBUFFERARBPROC glMapBufferARB; +extern PFNGLUNMAPBUFFERARBPROC glUnmapBufferARB; +extern PFNGLGETBUFFERPARAMETERIVARBPROC glGetBufferParameterivARB; +extern PFNGLGETBUFFERPOINTERVARBPROC glGetBufferPointervARB; +#endif + +#if defined(GL_ARB_occlusion_query) +extern PFNGLGENQUERIESARBPROC glGenQueriesARB; +extern PFNGLDELETEQUERIESARBPROC glDeleteQueriesARB; +extern PFNGLISQUERYARBPROC glIsQueryARB; +extern PFNGLBEGINQUERYARBPROC glBeginQueryARB; +extern PFNGLENDQUERYARBPROC glEndQueryARB; +extern PFNGLGETQUERYIVARBPROC glGetQueryivARB; +extern PFNGLGETQUERYOBJECTIVARBPROC glGetQueryObjectivARB; +extern PFNGLGETQUERYOBJECTUIVARBPROC glGetQueryObjectuivARB; +#endif + +#if defined(GL_ARB_shader_objects) +extern PFNGLDELETEOBJECTARBPROC glDeleteObjectARB; +extern PFNGLGETHANDLEARBPROC glGetHandleARB; +extern PFNGLDETACHOBJECTARBPROC glDetachObjectARB; +extern PFNGLCREATESHADEROBJECTARBPROC glCreateShaderObjectARB; +extern PFNGLSHADERSOURCEARBPROC glShaderSourceARB; +extern PFNGLCOMPILESHADERARBPROC glCompileShaderARB; +extern PFNGLCREATEPROGRAMOBJECTARBPROC glCreateProgramObjectARB; +extern PFNGLATTACHOBJECTARBPROC glAttachObjectARB; +extern PFNGLLINKPROGRAMARBPROC glLinkProgramARB; +extern PFNGLUSEPROGRAMOBJECTARBPROC glUseProgramObjectARB; +extern PFNGLVALIDATEPROGRAMARBPROC glValidateProgramARB; +extern PFNGLUNIFORM1FARBPROC glUniform1fARB; +extern PFNGLUNIFORM2FARBPROC glUniform2fARB; +extern PFNGLUNIFORM3FARBPROC glUniform3fARB; +extern PFNGLUNIFORM4FARBPROC glUniform4fARB; +extern PFNGLUNIFORM1IARBPROC glUniform1iARB; +extern PFNGLUNIFORM2IARBPROC glUniform2iARB; +extern PFNGLUNIFORM3IARBPROC glUniform3iARB; +extern PFNGLUNIFORM4IARBPROC glUniform4iARB; +extern PFNGLUNIFORM1FVARBPROC glUniform1fvARB; +extern PFNGLUNIFORM2FVARBPROC glUniform2fvARB; +extern PFNGLUNIFORM3FVARBPROC glUniform3fvARB; +extern PFNGLUNIFORM4FVARBPROC glUniform4fvARB; +extern PFNGLUNIFORM1IVARBPROC glUniform1ivARB; +extern PFNGLUNIFORM2IVARBPROC glUniform2ivARB; +extern PFNGLUNIFORM3IVARBPROC glUniform3ivARB; +extern PFNGLUNIFORM4IVARBPROC glUniform4ivARB; +extern PFNGLUNIFORMMATRIX2FVARBPROC glUniformMatrix2fvARB; +extern PFNGLUNIFORMMATRIX3FVARBPROC glUniformMatrix3fvARB; +extern PFNGLUNIFORMMATRIX4FVARBPROC glUniformMatrix4fvARB; +extern PFNGLGETOBJECTPARAMETERFVARBPROC glGetObjectParameterfvARB; +extern PFNGLGETOBJECTPARAMETERIVARBPROC glGetObjectParameterivARB; +extern PFNGLGETINFOLOGARBPROC glGetInfoLogARB; +extern PFNGLGETATTACHEDOBJECTSARBPROC glGetAttachedObjectsARB; +extern PFNGLGETUNIFORMLOCATIONARBPROC glGetUniformLocationARB; +extern PFNGLGETACTIVEUNIFORMARBPROC glGetActiveUniformARB; +extern PFNGLGETUNIFORMFVARBPROC glGetUniformfvARB; +extern PFNGLGETUNIFORMIVARBPROC glGetUniformivARB; +extern PFNGLGETSHADERSOURCEARBPROC glGetShaderSourceARB; +#endif + +#if defined(GL_ARB_vertex_shader) +extern PFNGLBINDATTRIBLOCATIONARBPROC glBindAttribLocationARB; +extern PFNGLGETACTIVEATTRIBARBPROC glGetActiveAttribARB; +extern PFNGLGETATTRIBLOCATIONARBPROC glGetAttribLocationARB; +#endif + +#if defined(GL_ARB_fragment_shader) +#endif + +#if defined(GL_ARB_shading_language_100) +#endif + +#if defined(GL_ARB_texture_non_power_of_two) +#endif + +#if defined(GL_ARB_point_sprite) +#endif + +#if defined(GL_ARB_fragment_program_shadow) +#endif + +#if defined(GL_EXT_abgr) +#endif + +#if defined(GL_EXT_texture3D) +extern PFNGLTEXIMAGE3DEXTPROC glTexImage3DEXT; +extern PFNGLTEXSUBIMAGE3DEXTPROC glTexSubImage3DEXT; +#endif + +#if defined(GL_SGIS_texture_filter4) +extern PFNGLGETTEXFILTERFUNCSGISPROC glGetTexFilterFuncSGIS; +extern PFNGLTEXFILTERFUNCSGISPROC glTexFilterFuncSGIS; +#endif + +#if defined(GL_EXT_histogram) +extern PFNGLGETHISTOGRAMEXTPROC glGetHistogramEXT; +extern PFNGLGETHISTOGRAMPARAMETERFVEXTPROC glGetHistogramParameterfvEXT; +extern PFNGLGETHISTOGRAMPARAMETERIVEXTPROC glGetHistogramParameterivEXT; +extern PFNGLGETMINMAXEXTPROC glGetMinmaxEXT; +extern PFNGLGETMINMAXPARAMETERFVEXTPROC glGetMinmaxParameterfvEXT; +extern PFNGLGETMINMAXPARAMETERIVEXTPROC glGetMinmaxParameterivEXT; +extern PFNGLHISTOGRAMEXTPROC glHistogramEXT; +extern PFNGLMINMAXEXTPROC glMinmaxEXT; +extern PFNGLRESETHISTOGRAMEXTPROC glResetHistogramEXT; +extern PFNGLRESETMINMAXEXTPROC glResetMinmaxEXT; +#endif + +#if defined(GL_EXT_convolution) +extern PFNGLCONVOLUTIONFILTER1DEXTPROC glConvolutionFilter1DEXT; +extern PFNGLCONVOLUTIONFILTER2DEXTPROC glConvolutionFilter2DEXT; +extern PFNGLCONVOLUTIONPARAMETERFEXTPROC glConvolutionParameterfEXT; +extern PFNGLCONVOLUTIONPARAMETERFVEXTPROC glConvolutionParameterfvEXT; +extern PFNGLCONVOLUTIONPARAMETERIEXTPROC glConvolutionParameteriEXT; +extern PFNGLCONVOLUTIONPARAMETERIVEXTPROC glConvolutionParameterivEXT; +extern PFNGLCOPYCONVOLUTIONFILTER1DEXTPROC glCopyConvolutionFilter1DEXT; +extern PFNGLCOPYCONVOLUTIONFILTER2DEXTPROC glCopyConvolutionFilter2DEXT; +extern PFNGLGETCONVOLUTIONFILTEREXTPROC glGetConvolutionFilterEXT; +extern PFNGLGETCONVOLUTIONPARAMETERFVEXTPROC glGetConvolutionParameterfvEXT; +extern PFNGLGETCONVOLUTIONPARAMETERIVEXTPROC glGetConvolutionParameterivEXT; +extern PFNGLGETSEPARABLEFILTEREXTPROC glGetSeparableFilterEXT; +extern PFNGLSEPARABLEFILTER2DEXTPROC glSeparableFilter2DEXT; +#endif + +#if defined(GL_SGI_color_table) +extern PFNGLCOLORTABLESGIPROC glColorTableSGI; +extern PFNGLCOLORTABLEPARAMETERFVSGIPROC glColorTableParameterfvSGI; +extern PFNGLCOLORTABLEPARAMETERIVSGIPROC glColorTableParameterivSGI; +extern PFNGLCOPYCOLORTABLESGIPROC glCopyColorTableSGI; +extern PFNGLGETCOLORTABLESGIPROC glGetColorTableSGI; +extern PFNGLGETCOLORTABLEPARAMETERFVSGIPROC glGetColorTableParameterfvSGI; +extern PFNGLGETCOLORTABLEPARAMETERIVSGIPROC glGetColorTableParameterivSGI; +#endif + +#if defined(GL_SGIX_pixel_texture) +extern PFNGLPIXELTEXGENSGIXPROC glPixelTexGenSGIX; +#endif + +#if defined(GL_SGIS_pixel_texture) +extern PFNGLPIXELTEXGENPARAMETERISGISPROC glPixelTexGenParameteriSGIS; +extern PFNGLPIXELTEXGENPARAMETERIVSGISPROC glPixelTexGenParameterivSGIS; +extern PFNGLPIXELTEXGENPARAMETERFSGISPROC glPixelTexGenParameterfSGIS; +extern PFNGLPIXELTEXGENPARAMETERFVSGISPROC glPixelTexGenParameterfvSGIS; +extern PFNGLGETPIXELTEXGENPARAMETERIVSGISPROC glGetPixelTexGenParameterivSGIS; +extern PFNGLGETPIXELTEXGENPARAMETERFVSGISPROC glGetPixelTexGenParameterfvSGIS; +#endif + +#if defined(GL_SGIS_texture4D) +extern PFNGLTEXIMAGE4DSGISPROC glTexImage4DSGIS; +extern PFNGLTEXSUBIMAGE4DSGISPROC glTexSubImage4DSGIS; +#endif + +#if defined(GL_SGI_texture_color_table) +#endif + +#if defined(GL_EXT_cmyka) +#endif + +#if defined(GL_SGIS_detail_texture) +extern PFNGLDETAILTEXFUNCSGISPROC glDetailTexFuncSGIS; +extern PFNGLGETDETAILTEXFUNCSGISPROC glGetDetailTexFuncSGIS; +#endif + +#if defined(GL_SGIS_sharpen_texture) +extern PFNGLSHARPENTEXFUNCSGISPROC glSharpenTexFuncSGIS; +extern PFNGLGETSHARPENTEXFUNCSGISPROC glGetSharpenTexFuncSGIS; +#endif + +#if defined(GL_EXT_packed_pixels) +#endif + +#if defined(GL_SGIS_texture_lod) +#endif + +#if defined(GL_SGIS_multisample) +extern PFNGLSAMPLEMASKSGISPROC glSampleMaskSGIS; +extern PFNGLSAMPLEPATTERNSGISPROC glSamplePatternSGIS; +#endif + +#if defined(GL_EXT_rescale_normal) +#endif + +#if defined(GL_EXT_misc_attribute) +#endif + +#if defined(GL_SGIS_generate_mipmap) +#endif + +#if defined(GL_SGIX_clipmap) +#endif + +#if defined(GL_SGIX_shadow) +#endif + +#if defined(GL_SGIS_texture_edge_clamp) +#endif + +#if defined(GL_SGIS_texture_border_clamp) +#endif + +#if defined(GL_EXT_blend_minmax) +extern PFNGLBLENDEQUATIONEXTPROC glBlendEquationEXT; +#endif + +#if defined(GL_EXT_blend_subtract) +#endif + +#if defined(GL_EXT_blend_logic_op) +#endif + +#if defined(GL_SGIX_interlace) +#endif + +#if defined(GL_SGIX_sprite) +extern PFNGLSPRITEPARAMETERFSGIXPROC glSpriteParameterfSGIX; +extern PFNGLSPRITEPARAMETERFVSGIXPROC glSpriteParameterfvSGIX; +extern PFNGLSPRITEPARAMETERISGIXPROC glSpriteParameteriSGIX; +extern PFNGLSPRITEPARAMETERIVSGIXPROC glSpriteParameterivSGIX; +#endif + +#if defined(GL_SGIX_texture_multi_buffer) +#endif + +#if defined(GL_SGIX_instruments) +extern PFNGLGETINSTRUMENTSSGIXPROC glGetInstrumentsSGIX; +extern PFNGLINSTRUMENTSBUFFERSGIXPROC glInstrumentsBufferSGIX; +extern PFNGLPOLLINSTRUMENTSSGIXPROC glPollInstrumentsSGIX; +extern PFNGLREADINSTRUMENTSSGIXPROC glReadInstrumentsSGIX; +extern PFNGLSTARTINSTRUMENTSSGIXPROC glStartInstrumentsSGIX; +extern PFNGLSTOPINSTRUMENTSSGIXPROC glStopInstrumentsSGIX; +#endif + +#if defined(GL_SGIX_texture_scale_bias) +#endif + +#if defined(GL_SGIX_framezoom) +extern PFNGLFRAMEZOOMSGIXPROC glFrameZoomSGIX; +#endif + +#if defined(GL_SGIX_tag_sample_buffer) +extern PFNGLTAGSAMPLEBUFFERSGIXPROC glTagSampleBufferSGIX; +#endif + +#if defined(GL_SGIX_reference_plane) +extern PFNGLREFERENCEPLANESGIXPROC glReferencePlaneSGIX; +#endif + +#if defined(GL_SGIX_flush_raster) +extern PFNGLFLUSHRASTERSGIXPROC glFlushRasterSGIX; +#endif + +#if defined(GL_SGIX_depth_texture) +#endif + +#if defined(GL_SGIS_fog_function) +extern PFNGLFOGFUNCSGISPROC glFogFuncSGIS; +extern PFNGLGETFOGFUNCSGISPROC glGetFogFuncSGIS; +#endif + +#if defined(GL_SGIX_fog_offset) +#endif + +#if defined(GL_HP_image_transform) +extern PFNGLIMAGETRANSFORMPARAMETERIHPPROC glImageTransformParameteriHP; +extern PFNGLIMAGETRANSFORMPARAMETERFHPPROC glImageTransformParameterfHP; +extern PFNGLIMAGETRANSFORMPARAMETERIVHPPROC glImageTransformParameterivHP; +extern PFNGLIMAGETRANSFORMPARAMETERFVHPPROC glImageTransformParameterfvHP; +extern PFNGLGETIMAGETRANSFORMPARAMETERIVHPPROC glGetImageTransformParameterivHP; +extern PFNGLGETIMAGETRANSFORMPARAMETERFVHPPROC glGetImageTransformParameterfvHP; +#endif + +#if defined(GL_HP_convolution_border_modes) +#endif + +#if defined(GL_SGIX_texture_add_env) +#endif + +#if defined(GL_EXT_color_subtable) +extern PFNGLCOLORSUBTABLEEXTPROC glColorSubTableEXT; +extern PFNGLCOPYCOLORSUBTABLEEXTPROC glCopyColorSubTableEXT; +#endif + +#if defined(GL_PGI_vertex_hints) +#endif + +#if defined(GL_PGI_misc_hints) +extern PFNGLHINTPGIPROC glHintPGI; +#endif + +#if defined(GL_EXT_paletted_texture) +extern PFNGLCOLORTABLEEXTPROC glColorTableEXT; +extern PFNGLGETCOLORTABLEEXTPROC glGetColorTableEXT; +extern PFNGLGETCOLORTABLEPARAMETERIVEXTPROC glGetColorTableParameterivEXT; +extern PFNGLGETCOLORTABLEPARAMETERFVEXTPROC glGetColorTableParameterfvEXT; +#endif + +#if defined(GL_EXT_clip_volume_hint) +#endif + +#if defined(GL_SGIX_list_priority) +extern PFNGLGETLISTPARAMETERFVSGIXPROC glGetListParameterfvSGIX; +extern PFNGLGETLISTPARAMETERIVSGIXPROC glGetListParameterivSGIX; +extern PFNGLLISTPARAMETERFSGIXPROC glListParameterfSGIX; +extern PFNGLLISTPARAMETERFVSGIXPROC glListParameterfvSGIX; +extern PFNGLLISTPARAMETERISGIXPROC glListParameteriSGIX; +extern PFNGLLISTPARAMETERIVSGIXPROC glListParameterivSGIX; +#endif + +#if defined(GL_SGIX_ir_instrument1) +#endif + +#if defined(GL_SGIX_texture_lod_bias) +#endif + +#if defined(GL_SGIX_shadow_ambient) +#endif + +#if defined(GL_EXT_index_texture) +#endif + +#if defined(GL_EXT_index_material) +extern PFNGLINDEXMATERIALEXTPROC glIndexMaterialEXT; +#endif + +#if defined(GL_EXT_index_func) +extern PFNGLINDEXFUNCEXTPROC glIndexFuncEXT; +#endif + +#if defined(GL_EXT_index_array_formats) +#endif + +#if defined(GL_EXT_cull_vertex) +extern PFNGLCULLPARAMETERDVEXTPROC glCullParameterdvEXT; +extern PFNGLCULLPARAMETERFVEXTPROC glCullParameterfvEXT; +#endif + +#if defined(GL_SGIX_ycrcb) +#endif + +#if defined(GL_IBM_rasterpos_clip) +#endif + +#if defined(GL_HP_texture_lighting) +#endif + +#if defined(GL_EXT_draw_range_elements) +extern PFNGLDRAWRANGEELEMENTSEXTPROC glDrawRangeElementsEXT; +#endif + +#if defined(GL_WIN_phong_shading) +#endif + +#if defined(GL_WIN_specular_fog) +#endif + +#if defined(GL_EXT_light_texture) +extern PFNGLAPPLYTEXTUREEXTPROC glApplyTextureEXT; +extern PFNGLTEXTURELIGHTEXTPROC glTextureLightEXT; +extern PFNGLTEXTUREMATERIALEXTPROC glTextureMaterialEXT; +#endif + +#if defined(GL_SGIX_blend_alpha_minmax) +#endif + +#if defined(GL_EXT_bgra) +#endif + +#if defined(GL_SGIX_async) +extern PFNGLASYNCMARKERSGIXPROC glAsyncMarkerSGIX; +extern PFNGLFINISHASYNCSGIXPROC glFinishAsyncSGIX; +extern PFNGLPOLLASYNCSGIXPROC glPollAsyncSGIX; +extern PFNGLGENASYNCMARKERSSGIXPROC glGenAsyncMarkersSGIX; +extern PFNGLDELETEASYNCMARKERSSGIXPROC glDeleteAsyncMarkersSGIX; +extern PFNGLISASYNCMARKERSGIXPROC glIsAsyncMarkerSGIX; +#endif + +#if defined(GL_SGIX_async_pixel) +#endif + +#if defined(GL_SGIX_async_histogram) +#endif + +#if defined(GL_INTEL_parallel_arrays) +extern PFNGLVERTEXPOINTERVINTELPROC glVertexPointervINTEL; +extern PFNGLNORMALPOINTERVINTELPROC glNormalPointervINTEL; +extern PFNGLCOLORPOINTERVINTELPROC glColorPointervINTEL; +extern PFNGLTEXCOORDPOINTERVINTELPROC glTexCoordPointervINTEL; +#endif + +#if defined(GL_HP_occlusion_test) +#endif + +#if defined(GL_EXT_pixel_transform) +extern PFNGLPIXELTRANSFORMPARAMETERIEXTPROC glPixelTransformParameteriEXT; +extern PFNGLPIXELTRANSFORMPARAMETERFEXTPROC glPixelTransformParameterfEXT; +extern PFNGLPIXELTRANSFORMPARAMETERIVEXTPROC glPixelTransformParameterivEXT; +extern PFNGLPIXELTRANSFORMPARAMETERFVEXTPROC glPixelTransformParameterfvEXT; +#endif + +#if defined(GL_EXT_pixel_transform_color_table) +#endif + +#if defined(GL_EXT_shared_texture_palette) +#endif + +#if defined(GL_EXT_separate_specular_color) +#endif + +#if defined(GL_EXT_secondary_color) +extern PFNGLSECONDARYCOLOR3BEXTPROC glSecondaryColor3bEXT; +extern PFNGLSECONDARYCOLOR3BVEXTPROC glSecondaryColor3bvEXT; +extern PFNGLSECONDARYCOLOR3DEXTPROC glSecondaryColor3dEXT; +extern PFNGLSECONDARYCOLOR3DVEXTPROC glSecondaryColor3dvEXT; +extern PFNGLSECONDARYCOLOR3FEXTPROC glSecondaryColor3fEXT; +extern PFNGLSECONDARYCOLOR3FVEXTPROC glSecondaryColor3fvEXT; +extern PFNGLSECONDARYCOLOR3IEXTPROC glSecondaryColor3iEXT; +extern PFNGLSECONDARYCOLOR3IVEXTPROC glSecondaryColor3ivEXT; +extern PFNGLSECONDARYCOLOR3SEXTPROC glSecondaryColor3sEXT; +extern PFNGLSECONDARYCOLOR3SVEXTPROC glSecondaryColor3svEXT; +extern PFNGLSECONDARYCOLOR3UBEXTPROC glSecondaryColor3ubEXT; +extern PFNGLSECONDARYCOLOR3UBVEXTPROC glSecondaryColor3ubvEXT; +extern PFNGLSECONDARYCOLOR3UIEXTPROC glSecondaryColor3uiEXT; +extern PFNGLSECONDARYCOLOR3UIVEXTPROC glSecondaryColor3uivEXT; +extern PFNGLSECONDARYCOLOR3USEXTPROC glSecondaryColor3usEXT; +extern PFNGLSECONDARYCOLOR3USVEXTPROC glSecondaryColor3usvEXT; +extern PFNGLSECONDARYCOLORPOINTEREXTPROC glSecondaryColorPointerEXT; +#endif + +#if defined(GL_EXT_texture_perturb_normal) +extern PFNGLTEXTURENORMALEXTPROC glTextureNormalEXT; +#endif + +#if defined(GL_EXT_multi_draw_arrays) +extern PFNGLMULTIDRAWARRAYSEXTPROC glMultiDrawArraysEXT; +extern PFNGLMULTIDRAWELEMENTSEXTPROC glMultiDrawElementsEXT; +#endif + +#if defined(GL_EXT_fog_coord) +extern PFNGLFOGCOORDFEXTPROC glFogCoordfEXT; +extern PFNGLFOGCOORDFVEXTPROC glFogCoordfvEXT; +extern PFNGLFOGCOORDDEXTPROC glFogCoorddEXT; +extern PFNGLFOGCOORDDVEXTPROC glFogCoorddvEXT; +extern PFNGLFOGCOORDPOINTEREXTPROC glFogCoordPointerEXT; +#endif + +#if defined(GL_REND_screen_coordinates) +#endif + +#if defined(GL_EXT_coordinate_frame) +extern PFNGLTANGENT3BEXTPROC glTangent3bEXT; +extern PFNGLTANGENT3BVEXTPROC glTangent3bvEXT; +extern PFNGLTANGENT3DEXTPROC glTangent3dEXT; +extern PFNGLTANGENT3DVEXTPROC glTangent3dvEXT; +extern PFNGLTANGENT3FEXTPROC glTangent3fEXT; +extern PFNGLTANGENT3FVEXTPROC glTangent3fvEXT; +extern PFNGLTANGENT3IEXTPROC glTangent3iEXT; +extern PFNGLTANGENT3IVEXTPROC glTangent3ivEXT; +extern PFNGLTANGENT3SEXTPROC glTangent3sEXT; +extern PFNGLTANGENT3SVEXTPROC glTangent3svEXT; +extern PFNGLBINORMAL3BEXTPROC glBinormal3bEXT; +extern PFNGLBINORMAL3BVEXTPROC glBinormal3bvEXT; +extern PFNGLBINORMAL3DEXTPROC glBinormal3dEXT; +extern PFNGLBINORMAL3DVEXTPROC glBinormal3dvEXT; +extern PFNGLBINORMAL3FEXTPROC glBinormal3fEXT; +extern PFNGLBINORMAL3FVEXTPROC glBinormal3fvEXT; +extern PFNGLBINORMAL3IEXTPROC glBinormal3iEXT; +extern PFNGLBINORMAL3IVEXTPROC glBinormal3ivEXT; +extern PFNGLBINORMAL3SEXTPROC glBinormal3sEXT; +extern PFNGLBINORMAL3SVEXTPROC glBinormal3svEXT; +extern PFNGLTANGENTPOINTEREXTPROC glTangentPointerEXT; +extern PFNGLBINORMALPOINTEREXTPROC glBinormalPointerEXT; +#endif + +#if defined(GL_EXT_texture_env_combine) +#endif + +#if defined(GL_APPLE_specular_vector) +#endif + +#if defined(GL_APPLE_transform_hint) +#endif + +#if defined(GL_SUNX_constant_data) +extern PFNGLFINISHTEXTURESUNXPROC glFinishTextureSUNX; +#endif + +#if defined(GL_SUN_global_alpha) +extern PFNGLGLOBALALPHAFACTORBSUNPROC glGlobalAlphaFactorbSUN; +extern PFNGLGLOBALALPHAFACTORSSUNPROC glGlobalAlphaFactorsSUN; +extern PFNGLGLOBALALPHAFACTORISUNPROC glGlobalAlphaFactoriSUN; +extern PFNGLGLOBALALPHAFACTORFSUNPROC glGlobalAlphaFactorfSUN; +extern PFNGLGLOBALALPHAFACTORDSUNPROC glGlobalAlphaFactordSUN; +extern PFNGLGLOBALALPHAFACTORUBSUNPROC glGlobalAlphaFactorubSUN; +extern PFNGLGLOBALALPHAFACTORUSSUNPROC glGlobalAlphaFactorusSUN; +extern PFNGLGLOBALALPHAFACTORUISUNPROC glGlobalAlphaFactoruiSUN; +#endif + +#if defined(GL_SUN_triangle_list) +extern PFNGLREPLACEMENTCODEUISUNPROC glReplacementCodeuiSUN; +extern PFNGLREPLACEMENTCODEUSSUNPROC glReplacementCodeusSUN; +extern PFNGLREPLACEMENTCODEUBSUNPROC glReplacementCodeubSUN; +extern PFNGLREPLACEMENTCODEUIVSUNPROC glReplacementCodeuivSUN; +extern PFNGLREPLACEMENTCODEUSVSUNPROC glReplacementCodeusvSUN; +extern PFNGLREPLACEMENTCODEUBVSUNPROC glReplacementCodeubvSUN; +extern PFNGLREPLACEMENTCODEPOINTERSUNPROC glReplacementCodePointerSUN; +#endif + +#if defined(GL_SUN_vertex) +extern PFNGLCOLOR4UBVERTEX2FSUNPROC glColor4ubVertex2fSUN; +extern PFNGLCOLOR4UBVERTEX2FVSUNPROC glColor4ubVertex2fvSUN; +extern PFNGLCOLOR4UBVERTEX3FSUNPROC glColor4ubVertex3fSUN; +extern PFNGLCOLOR4UBVERTEX3FVSUNPROC glColor4ubVertex3fvSUN; +extern PFNGLCOLOR3FVERTEX3FSUNPROC glColor3fVertex3fSUN; +extern PFNGLCOLOR3FVERTEX3FVSUNPROC glColor3fVertex3fvSUN; +extern PFNGLNORMAL3FVERTEX3FSUNPROC glNormal3fVertex3fSUN; +extern PFNGLNORMAL3FVERTEX3FVSUNPROC glNormal3fVertex3fvSUN; +extern PFNGLCOLOR4FNORMAL3FVERTEX3FSUNPROC glColor4fNormal3fVertex3fSUN; +extern PFNGLCOLOR4FNORMAL3FVERTEX3FVSUNPROC glColor4fNormal3fVertex3fvSUN; +extern PFNGLTEXCOORD2FVERTEX3FSUNPROC glTexCoord2fVertex3fSUN; +extern PFNGLTEXCOORD2FVERTEX3FVSUNPROC glTexCoord2fVertex3fvSUN; +extern PFNGLTEXCOORD4FVERTEX4FSUNPROC glTexCoord4fVertex4fSUN; +extern PFNGLTEXCOORD4FVERTEX4FVSUNPROC glTexCoord4fVertex4fvSUN; +extern PFNGLTEXCOORD2FCOLOR4UBVERTEX3FSUNPROC glTexCoord2fColor4ubVertex3fSUN; +extern PFNGLTEXCOORD2FCOLOR4UBVERTEX3FVSUNPROC glTexCoord2fColor4ubVertex3fvSUN; +extern PFNGLTEXCOORD2FCOLOR3FVERTEX3FSUNPROC glTexCoord2fColor3fVertex3fSUN; +extern PFNGLTEXCOORD2FCOLOR3FVERTEX3FVSUNPROC glTexCoord2fColor3fVertex3fvSUN; +extern PFNGLTEXCOORD2FNORMAL3FVERTEX3FSUNPROC glTexCoord2fNormal3fVertex3fSUN; +extern PFNGLTEXCOORD2FNORMAL3FVERTEX3FVSUNPROC glTexCoord2fNormal3fVertex3fvSUN; +extern PFNGLTEXCOORD2FCOLOR4FNORMAL3FVERTEX3FSUNPROC glTexCoord2fColor4fNormal3fVertex3fSUN; +extern PFNGLTEXCOORD2FCOLOR4FNORMAL3FVERTEX3FVSUNPROC glTexCoord2fColor4fNormal3fVertex3fvSUN; +extern PFNGLTEXCOORD4FCOLOR4FNORMAL3FVERTEX4FSUNPROC glTexCoord4fColor4fNormal3fVertex4fSUN; +extern PFNGLTEXCOORD4FCOLOR4FNORMAL3FVERTEX4FVSUNPROC glTexCoord4fColor4fNormal3fVertex4fvSUN; +extern PFNGLREPLACEMENTCODEUIVERTEX3FSUNPROC glReplacementCodeuiVertex3fSUN; +extern PFNGLREPLACEMENTCODEUIVERTEX3FVSUNPROC glReplacementCodeuiVertex3fvSUN; +extern PFNGLREPLACEMENTCODEUICOLOR4UBVERTEX3FSUNPROC glReplacementCodeuiColor4ubVertex3fSUN; +extern PFNGLREPLACEMENTCODEUICOLOR4UBVERTEX3FVSUNPROC glReplacementCodeuiColor4ubVertex3fvSUN; +extern PFNGLREPLACEMENTCODEUICOLOR3FVERTEX3FSUNPROC glReplacementCodeuiColor3fVertex3fSUN; +extern PFNGLREPLACEMENTCODEUICOLOR3FVERTEX3FVSUNPROC glReplacementCodeuiColor3fVertex3fvSUN; +extern PFNGLREPLACEMENTCODEUINORMAL3FVERTEX3FSUNPROC glReplacementCodeuiNormal3fVertex3fSUN; +extern PFNGLREPLACEMENTCODEUINORMAL3FVERTEX3FVSUNPROC glReplacementCodeuiNormal3fVertex3fvSUN; +extern PFNGLREPLACEMENTCODEUICOLOR4FNORMAL3FVERTEX3FSUNPROC glReplacementCodeuiColor4fNormal3fVertex3fSUN; +extern PFNGLREPLACEMENTCODEUICOLOR4FNORMAL3FVERTEX3FVSUNPROC glReplacementCodeuiColor4fNormal3fVertex3fvSUN; +extern PFNGLREPLACEMENTCODEUITEXCOORD2FVERTEX3FSUNPROC glReplacementCodeuiTexCoord2fVertex3fSUN; +extern PFNGLREPLACEMENTCODEUITEXCOORD2FVERTEX3FVSUNPROC glReplacementCodeuiTexCoord2fVertex3fvSUN; +extern PFNGLREPLACEMENTCODEUITEXCOORD2FNORMAL3FVERTEX3FSUNPROC glReplacementCodeuiTexCoord2fNormal3fVertex3fSUN; +extern PFNGLREPLACEMENTCODEUITEXCOORD2FNORMAL3FVERTEX3FVSUNPROC glReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN; +extern PFNGLREPLACEMENTCODEUITEXCOORD2FCOLOR4FNORMAL3FVERTEX3FSUNPROC glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fSUN; +extern PFNGLREPLACEMENTCODEUITEXCOORD2FCOLOR4FNORMAL3FVERTEX3FVSUNPROC glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN; +#endif + +#if defined(GL_EXT_blend_func_separate) +extern PFNGLBLENDFUNCSEPARATEEXTPROC glBlendFuncSeparateEXT; +#endif + +#if defined(GL_INGR_color_clamp) +#endif + +#if defined(GL_INGR_interlace_read) +#endif + +#if defined(GL_EXT_stencil_wrap) +#endif + +#if defined(GL_EXT_422_pixels) +#endif + +#if defined(GL_NV_texgen_reflection) +#endif + +#if defined(GL_SUN_convolution_border_modes) +#endif + +#if defined(GL_EXT_texture_env_add) +#endif + +#if defined(GL_EXT_texture_lod_bias) +#endif + +#if defined(GL_EXT_texture_filter_anisotropic) +#endif + +#if defined(GL_EXT_vertex_weighting) +extern PFNGLVERTEXWEIGHTFEXTPROC glVertexWeightfEXT; +extern PFNGLVERTEXWEIGHTFVEXTPROC glVertexWeightfvEXT; +extern PFNGLVERTEXWEIGHTPOINTEREXTPROC glVertexWeightPointerEXT; +#endif + +#if defined(GL_NV_light_max_exponent) +#endif + +#if defined(GL_NV_vertex_array_range) +extern PFNGLFLUSHVERTEXARRAYRANGENVPROC glFlushVertexArrayRangeNV; +extern PFNGLVERTEXARRAYRANGENVPROC glVertexArrayRangeNV; +#endif + +#if defined(GL_NV_register_combiners) +extern PFNGLCOMBINERPARAMETERFVNVPROC glCombinerParameterfvNV; +extern PFNGLCOMBINERPARAMETERFNVPROC glCombinerParameterfNV; +extern PFNGLCOMBINERPARAMETERIVNVPROC glCombinerParameterivNV; +extern PFNGLCOMBINERPARAMETERINVPROC glCombinerParameteriNV; +extern PFNGLCOMBINERINPUTNVPROC glCombinerInputNV; +extern PFNGLCOMBINEROUTPUTNVPROC glCombinerOutputNV; +extern PFNGLFINALCOMBINERINPUTNVPROC glFinalCombinerInputNV; +extern PFNGLGETCOMBINERINPUTPARAMETERFVNVPROC glGetCombinerInputParameterfvNV; +extern PFNGLGETCOMBINERINPUTPARAMETERIVNVPROC glGetCombinerInputParameterivNV; +extern PFNGLGETCOMBINEROUTPUTPARAMETERFVNVPROC glGetCombinerOutputParameterfvNV; +extern PFNGLGETCOMBINEROUTPUTPARAMETERIVNVPROC glGetCombinerOutputParameterivNV; +extern PFNGLGETFINALCOMBINERINPUTPARAMETERFVNVPROC glGetFinalCombinerInputParameterfvNV; +extern PFNGLGETFINALCOMBINERINPUTPARAMETERIVNVPROC glGetFinalCombinerInputParameterivNV; +#endif + +#if defined(GL_NV_fog_distance) +#endif + +#if defined(GL_NV_texgen_emboss) +#endif + +#if defined(GL_NV_blend_square) +#endif + +#if defined(GL_NV_texture_env_combine4) +#endif + +#if defined(GL_MESA_resize_buffers) +extern PFNGLRESIZEBUFFERSMESAPROC glResizeBuffersMESA; +#endif + +#if defined(GL_MESA_window_pos) +extern PFNGLWINDOWPOS2DMESAPROC glWindowPos2dMESA; +extern PFNGLWINDOWPOS2DVMESAPROC glWindowPos2dvMESA; +extern PFNGLWINDOWPOS2FMESAPROC glWindowPos2fMESA; +extern PFNGLWINDOWPOS2FVMESAPROC glWindowPos2fvMESA; +extern PFNGLWINDOWPOS2IMESAPROC glWindowPos2iMESA; +extern PFNGLWINDOWPOS2IVMESAPROC glWindowPos2ivMESA; +extern PFNGLWINDOWPOS2SMESAPROC glWindowPos2sMESA; +extern PFNGLWINDOWPOS2SVMESAPROC glWindowPos2svMESA; +extern PFNGLWINDOWPOS3DMESAPROC glWindowPos3dMESA; +extern PFNGLWINDOWPOS3DVMESAPROC glWindowPos3dvMESA; +extern PFNGLWINDOWPOS3FMESAPROC glWindowPos3fMESA; +extern PFNGLWINDOWPOS3FVMESAPROC glWindowPos3fvMESA; +extern PFNGLWINDOWPOS3IMESAPROC glWindowPos3iMESA; +extern PFNGLWINDOWPOS3IVMESAPROC glWindowPos3ivMESA; +extern PFNGLWINDOWPOS3SMESAPROC glWindowPos3sMESA; +extern PFNGLWINDOWPOS3SVMESAPROC glWindowPos3svMESA; +extern PFNGLWINDOWPOS4DMESAPROC glWindowPos4dMESA; +extern PFNGLWINDOWPOS4DVMESAPROC glWindowPos4dvMESA; +extern PFNGLWINDOWPOS4FMESAPROC glWindowPos4fMESA; +extern PFNGLWINDOWPOS4FVMESAPROC glWindowPos4fvMESA; +extern PFNGLWINDOWPOS4IMESAPROC glWindowPos4iMESA; +extern PFNGLWINDOWPOS4IVMESAPROC glWindowPos4ivMESA; +extern PFNGLWINDOWPOS4SMESAPROC glWindowPos4sMESA; +extern PFNGLWINDOWPOS4SVMESAPROC glWindowPos4svMESA; +#endif + +#if defined(GL_IBM_cull_vertex) +#endif + +#if defined(GL_IBM_multimode_draw_arrays) +extern PFNGLMULTIMODEDRAWARRAYSIBMPROC glMultiModeDrawArraysIBM; +extern PFNGLMULTIMODEDRAWELEMENTSIBMPROC glMultiModeDrawElementsIBM; +#endif + +#if defined(GL_IBM_vertex_array_lists) +extern PFNGLCOLORPOINTERLISTIBMPROC glColorPointerListIBM; +extern PFNGLSECONDARYCOLORPOINTERLISTIBMPROC glSecondaryColorPointerListIBM; +extern PFNGLEDGEFLAGPOINTERLISTIBMPROC glEdgeFlagPointerListIBM; +extern PFNGLFOGCOORDPOINTERLISTIBMPROC glFogCoordPointerListIBM; +extern PFNGLINDEXPOINTERLISTIBMPROC glIndexPointerListIBM; +extern PFNGLNORMALPOINTERLISTIBMPROC glNormalPointerListIBM; +extern PFNGLTEXCOORDPOINTERLISTIBMPROC glTexCoordPointerListIBM; +extern PFNGLVERTEXPOINTERLISTIBMPROC glVertexPointerListIBM; +#endif + +#if defined(GL_3DFX_texture_compression_FXT1) +#endif + +#if defined(GL_3DFX_multisample) +#endif + +#if defined(GL_3DFX_tbuffer) +extern PFNGLTBUFFERMASK3DFXPROC glTbufferMask3DFX; +#endif + +#if defined(GL_SGIX_vertex_preclip) +#endif + +#if defined(GL_SGIX_resample) +#endif + +#if defined(GL_SGIS_texture_color_mask) +extern PFNGLTEXTURECOLORMASKSGISPROC glTextureColorMaskSGIS; +#endif + +#if defined(GL_EXT_texture_env_dot3) +#endif + +#if defined(GL_ATI_texture_mirror_once) +#endif + +#if defined(GL_NV_fence) +extern PFNGLDELETEFENCESNVPROC glDeleteFencesNV; +extern PFNGLGENFENCESNVPROC glGenFencesNV; +extern PFNGLISFENCENVPROC glIsFenceNV; +extern PFNGLTESTFENCENVPROC glTestFenceNV; +extern PFNGLGETFENCEIVNVPROC glGetFenceivNV; +extern PFNGLFINISHFENCENVPROC glFinishFenceNV; +extern PFNGLSETFENCENVPROC glSetFenceNV; +#endif + +#if defined(GL_NV_evaluators) +extern PFNGLMAPCONTROLPOINTSNVPROC glMapControlPointsNV; +extern PFNGLMAPPARAMETERIVNVPROC glMapParameterivNV; +extern PFNGLMAPPARAMETERFVNVPROC glMapParameterfvNV; +extern PFNGLGETMAPCONTROLPOINTSNVPROC glGetMapControlPointsNV; +extern PFNGLGETMAPPARAMETERIVNVPROC glGetMapParameterivNV; +extern PFNGLGETMAPPARAMETERFVNVPROC glGetMapParameterfvNV; +extern PFNGLGETMAPATTRIBPARAMETERIVNVPROC glGetMapAttribParameterivNV; +extern PFNGLGETMAPATTRIBPARAMETERFVNVPROC glGetMapAttribParameterfvNV; +extern PFNGLEVALMAPSNVPROC glEvalMapsNV; +#endif + +#if defined(GL_NV_packed_depth_stencil) +#endif + +#if defined(GL_NV_register_combiners2) +extern PFNGLCOMBINERSTAGEPARAMETERFVNVPROC glCombinerStageParameterfvNV; +extern PFNGLGETCOMBINERSTAGEPARAMETERFVNVPROC glGetCombinerStageParameterfvNV; +#endif + +#if defined(GL_NV_texture_compression_vtc) +#endif + +#if defined(GL_NV_texture_rectangle) +#endif + +#if defined(GL_NV_texture_shader) +#endif + +#if defined(GL_NV_texture_shader2) +#endif + +#if defined(GL_NV_vertex_array_range2) +#endif + +#if defined(GL_NV_vertex_program) +extern PFNGLAREPROGRAMSRESIDENTNVPROC glAreProgramsResidentNV; +extern PFNGLBINDPROGRAMNVPROC glBindProgramNV; +extern PFNGLDELETEPROGRAMSNVPROC glDeleteProgramsNV; +extern PFNGLEXECUTEPROGRAMNVPROC glExecuteProgramNV; +extern PFNGLGENPROGRAMSNVPROC glGenProgramsNV; +extern PFNGLGETPROGRAMPARAMETERDVNVPROC glGetProgramParameterdvNV; +extern PFNGLGETPROGRAMPARAMETERFVNVPROC glGetProgramParameterfvNV; +extern PFNGLGETPROGRAMIVNVPROC glGetProgramivNV; +extern PFNGLGETPROGRAMSTRINGNVPROC glGetProgramStringNV; +extern PFNGLGETTRACKMATRIXIVNVPROC glGetTrackMatrixivNV; +extern PFNGLGETVERTEXATTRIBDVNVPROC glGetVertexAttribdvNV; +extern PFNGLGETVERTEXATTRIBFVNVPROC glGetVertexAttribfvNV; +extern PFNGLGETVERTEXATTRIBIVNVPROC glGetVertexAttribivNV; +extern PFNGLGETVERTEXATTRIBPOINTERVNVPROC glGetVertexAttribPointervNV; +extern PFNGLISPROGRAMNVPROC glIsProgramNV; +extern PFNGLLOADPROGRAMNVPROC glLoadProgramNV; +extern PFNGLPROGRAMPARAMETER4DNVPROC glProgramParameter4dNV; +extern PFNGLPROGRAMPARAMETER4DVNVPROC glProgramParameter4dvNV; +extern PFNGLPROGRAMPARAMETER4FNVPROC glProgramParameter4fNV; +extern PFNGLPROGRAMPARAMETER4FVNVPROC glProgramParameter4fvNV; +extern PFNGLPROGRAMPARAMETERS4DVNVPROC glProgramParameters4dvNV; +extern PFNGLPROGRAMPARAMETERS4FVNVPROC glProgramParameters4fvNV; +extern PFNGLREQUESTRESIDENTPROGRAMSNVPROC glRequestResidentProgramsNV; +extern PFNGLTRACKMATRIXNVPROC glTrackMatrixNV; +extern PFNGLVERTEXATTRIBPOINTERNVPROC glVertexAttribPointerNV; +extern PFNGLVERTEXATTRIB1DNVPROC glVertexAttrib1dNV; +extern PFNGLVERTEXATTRIB1DVNVPROC glVertexAttrib1dvNV; +extern PFNGLVERTEXATTRIB1FNVPROC glVertexAttrib1fNV; +extern PFNGLVERTEXATTRIB1FVNVPROC glVertexAttrib1fvNV; +extern PFNGLVERTEXATTRIB1SNVPROC glVertexAttrib1sNV; +extern PFNGLVERTEXATTRIB1SVNVPROC glVertexAttrib1svNV; +extern PFNGLVERTEXATTRIB2DNVPROC glVertexAttrib2dNV; +extern PFNGLVERTEXATTRIB2DVNVPROC glVertexAttrib2dvNV; +extern PFNGLVERTEXATTRIB2FNVPROC glVertexAttrib2fNV; +extern PFNGLVERTEXATTRIB2FVNVPROC glVertexAttrib2fvNV; +extern PFNGLVERTEXATTRIB2SNVPROC glVertexAttrib2sNV; +extern PFNGLVERTEXATTRIB2SVNVPROC glVertexAttrib2svNV; +extern PFNGLVERTEXATTRIB3DNVPROC glVertexAttrib3dNV; +extern PFNGLVERTEXATTRIB3DVNVPROC glVertexAttrib3dvNV; +extern PFNGLVERTEXATTRIB3FNVPROC glVertexAttrib3fNV; +extern PFNGLVERTEXATTRIB3FVNVPROC glVertexAttrib3fvNV; +extern PFNGLVERTEXATTRIB3SNVPROC glVertexAttrib3sNV; +extern PFNGLVERTEXATTRIB3SVNVPROC glVertexAttrib3svNV; +extern PFNGLVERTEXATTRIB4DNVPROC glVertexAttrib4dNV; +extern PFNGLVERTEXATTRIB4DVNVPROC glVertexAttrib4dvNV; +extern PFNGLVERTEXATTRIB4FNVPROC glVertexAttrib4fNV; +extern PFNGLVERTEXATTRIB4FVNVPROC glVertexAttrib4fvNV; +extern PFNGLVERTEXATTRIB4SNVPROC glVertexAttrib4sNV; +extern PFNGLVERTEXATTRIB4SVNVPROC glVertexAttrib4svNV; +extern PFNGLVERTEXATTRIB4UBNVPROC glVertexAttrib4ubNV; +extern PFNGLVERTEXATTRIB4UBVNVPROC glVertexAttrib4ubvNV; +extern PFNGLVERTEXATTRIBS1DVNVPROC glVertexAttribs1dvNV; +extern PFNGLVERTEXATTRIBS1FVNVPROC glVertexAttribs1fvNV; +extern PFNGLVERTEXATTRIBS1SVNVPROC glVertexAttribs1svNV; +extern PFNGLVERTEXATTRIBS2DVNVPROC glVertexAttribs2dvNV; +extern PFNGLVERTEXATTRIBS2FVNVPROC glVertexAttribs2fvNV; +extern PFNGLVERTEXATTRIBS2SVNVPROC glVertexAttribs2svNV; +extern PFNGLVERTEXATTRIBS3DVNVPROC glVertexAttribs3dvNV; +extern PFNGLVERTEXATTRIBS3FVNVPROC glVertexAttribs3fvNV; +extern PFNGLVERTEXATTRIBS3SVNVPROC glVertexAttribs3svNV; +extern PFNGLVERTEXATTRIBS4DVNVPROC glVertexAttribs4dvNV; +extern PFNGLVERTEXATTRIBS4FVNVPROC glVertexAttribs4fvNV; +extern PFNGLVERTEXATTRIBS4SVNVPROC glVertexAttribs4svNV; +extern PFNGLVERTEXATTRIBS4UBVNVPROC glVertexAttribs4ubvNV; +#endif + +#if defined(GL_SGIX_texture_coordinate_clamp) +#endif + +#if defined(GL_OML_interlace) +#endif + +#if defined(GL_OML_subsample) +#endif + +#if defined(GL_OML_resample) +#endif + +#if defined(GL_NV_copy_depth_to_color) +#endif + +#if defined(GL_ATI_envmap_bumpmap) +extern PFNGLTEXBUMPPARAMETERIVATIPROC glTexBumpParameterivATI; +extern PFNGLTEXBUMPPARAMETERFVATIPROC glTexBumpParameterfvATI; +extern PFNGLGETTEXBUMPPARAMETERIVATIPROC glGetTexBumpParameterivATI; +extern PFNGLGETTEXBUMPPARAMETERFVATIPROC glGetTexBumpParameterfvATI; +#endif + +#if defined(GL_ATI_fragment_shader) +extern PFNGLGENFRAGMENTSHADERSATIPROC glGenFragmentShadersATI; +extern PFNGLBINDFRAGMENTSHADERATIPROC glBindFragmentShaderATI; +extern PFNGLDELETEFRAGMENTSHADERATIPROC glDeleteFragmentShaderATI; +extern PFNGLBEGINFRAGMENTSHADERATIPROC glBeginFragmentShaderATI; +extern PFNGLENDFRAGMENTSHADERATIPROC glEndFragmentShaderATI; +extern PFNGLPASSTEXCOORDATIPROC glPassTexCoordATI; +extern PFNGLSAMPLEMAPATIPROC glSampleMapATI; +extern PFNGLCOLORFRAGMENTOP1ATIPROC glColorFragmentOp1ATI; +extern PFNGLCOLORFRAGMENTOP2ATIPROC glColorFragmentOp2ATI; +extern PFNGLCOLORFRAGMENTOP3ATIPROC glColorFragmentOp3ATI; +extern PFNGLALPHAFRAGMENTOP1ATIPROC glAlphaFragmentOp1ATI; +extern PFNGLALPHAFRAGMENTOP2ATIPROC glAlphaFragmentOp2ATI; +extern PFNGLALPHAFRAGMENTOP3ATIPROC glAlphaFragmentOp3ATI; +extern PFNGLSETFRAGMENTSHADERCONSTANTATIPROC glSetFragmentShaderConstantATI; +#endif + +#if defined(GL_ATI_pn_triangles) +#endif + +#if defined(GL_ATI_vertex_array_object) && 0 +extern PFNGLNEWOBJECTBUFFERATIPROC glNewObjectBufferATI; +extern PFNGLISOBJECTBUFFERATIPROC glIsObjectBufferATI; +extern PFNGLUPDATEOBJECTBUFFERATIPROC glUpdateObjectBufferATI; +extern PFNGLGETOBJECTBUFFERFVATIPROC glGetObjectBufferfvATI; +extern PFNGLGETOBJECTBUFFERIVATIPROC glGetObjectBufferivATI; +extern PFNGLFREEOBJECTBUFFERATIPROC glFreeObjectBufferATI; +extern PFNGLARRAYOBJECTATIPROC glArrayObjectATI; +extern PFNGLGETARRAYOBJECTFVATIPROC glGetArrayObjectfvATI; +extern PFNGLGETARRAYOBJECTIVATIPROC glGetArrayObjectivATI; +extern PFNGLVARIANTARRAYOBJECTATIPROC glVariantArrayObjectATI; +extern PFNGLGETVARIANTARRAYOBJECTFVATIPROC glGetVariantArrayObjectfvATI; +extern PFNGLGETVARIANTARRAYOBJECTIVATIPROC glGetVariantArrayObjectivATI; +#endif + +#if defined(GL_EXT_vertex_shader) +extern PFNGLBEGINVERTEXSHADEREXTPROC glBeginVertexShaderEXT; +extern PFNGLENDVERTEXSHADEREXTPROC glEndVertexShaderEXT; +extern PFNGLBINDVERTEXSHADEREXTPROC glBindVertexShaderEXT; +extern PFNGLGENVERTEXSHADERSEXTPROC glGenVertexShadersEXT; +extern PFNGLDELETEVERTEXSHADEREXTPROC glDeleteVertexShaderEXT; +extern PFNGLSHADEROP1EXTPROC glShaderOp1EXT; +extern PFNGLSHADEROP2EXTPROC glShaderOp2EXT; +extern PFNGLSHADEROP3EXTPROC glShaderOp3EXT; +extern PFNGLSWIZZLEEXTPROC glSwizzleEXT; +extern PFNGLWRITEMASKEXTPROC glWriteMaskEXT; +extern PFNGLINSERTCOMPONENTEXTPROC glInsertComponentEXT; +extern PFNGLEXTRACTCOMPONENTEXTPROC glExtractComponentEXT; +extern PFNGLGENSYMBOLSEXTPROC glGenSymbolsEXT; +extern PFNGLSETINVARIANTEXTPROC glSetInvariantEXT; +extern PFNGLSETLOCALCONSTANTEXTPROC glSetLocalConstantEXT; +extern PFNGLVARIANTBVEXTPROC glVariantbvEXT; +extern PFNGLVARIANTSVEXTPROC glVariantsvEXT; +extern PFNGLVARIANTIVEXTPROC glVariantivEXT; +extern PFNGLVARIANTFVEXTPROC glVariantfvEXT; +extern PFNGLVARIANTDVEXTPROC glVariantdvEXT; +extern PFNGLVARIANTUBVEXTPROC glVariantubvEXT; +extern PFNGLVARIANTUSVEXTPROC glVariantusvEXT; +extern PFNGLVARIANTUIVEXTPROC glVariantuivEXT; +extern PFNGLVARIANTPOINTEREXTPROC glVariantPointerEXT; +extern PFNGLENABLEVARIANTCLIENTSTATEEXTPROC glEnableVariantClientStateEXT; +extern PFNGLDISABLEVARIANTCLIENTSTATEEXTPROC glDisableVariantClientStateEXT; +extern PFNGLBINDLIGHTPARAMETEREXTPROC glBindLightParameterEXT; +extern PFNGLBINDMATERIALPARAMETEREXTPROC glBindMaterialParameterEXT; +extern PFNGLBINDTEXGENPARAMETEREXTPROC glBindTexGenParameterEXT; +extern PFNGLBINDTEXTUREUNITPARAMETEREXTPROC glBindTextureUnitParameterEXT; +extern PFNGLBINDPARAMETEREXTPROC glBindParameterEXT; +extern PFNGLISVARIANTENABLEDEXTPROC glIsVariantEnabledEXT; +extern PFNGLGETVARIANTBOOLEANVEXTPROC glGetVariantBooleanvEXT; +extern PFNGLGETVARIANTINTEGERVEXTPROC glGetVariantIntegervEXT; +extern PFNGLGETVARIANTFLOATVEXTPROC glGetVariantFloatvEXT; +extern PFNGLGETVARIANTPOINTERVEXTPROC glGetVariantPointervEXT; +extern PFNGLGETINVARIANTBOOLEANVEXTPROC glGetInvariantBooleanvEXT; +extern PFNGLGETINVARIANTINTEGERVEXTPROC glGetInvariantIntegervEXT; +extern PFNGLGETINVARIANTFLOATVEXTPROC glGetInvariantFloatvEXT; +extern PFNGLGETLOCALCONSTANTBOOLEANVEXTPROC glGetLocalConstantBooleanvEXT; +extern PFNGLGETLOCALCONSTANTINTEGERVEXTPROC glGetLocalConstantIntegervEXT; +extern PFNGLGETLOCALCONSTANTFLOATVEXTPROC glGetLocalConstantFloatvEXT; +#endif + +#if defined(GL_ATI_vertex_streams) +extern PFNGLVERTEXSTREAM1SATIPROC glVertexStream1sATI; +extern PFNGLVERTEXSTREAM1SVATIPROC glVertexStream1svATI; +extern PFNGLVERTEXSTREAM1IATIPROC glVertexStream1iATI; +extern PFNGLVERTEXSTREAM1IVATIPROC glVertexStream1ivATI; +extern PFNGLVERTEXSTREAM1FATIPROC glVertexStream1fATI; +extern PFNGLVERTEXSTREAM1FVATIPROC glVertexStream1fvATI; +extern PFNGLVERTEXSTREAM1DATIPROC glVertexStream1dATI; +extern PFNGLVERTEXSTREAM1DVATIPROC glVertexStream1dvATI; +extern PFNGLVERTEXSTREAM2SATIPROC glVertexStream2sATI; +extern PFNGLVERTEXSTREAM2SVATIPROC glVertexStream2svATI; +extern PFNGLVERTEXSTREAM2IATIPROC glVertexStream2iATI; +extern PFNGLVERTEXSTREAM2IVATIPROC glVertexStream2ivATI; +extern PFNGLVERTEXSTREAM2FATIPROC glVertexStream2fATI; +extern PFNGLVERTEXSTREAM2FVATIPROC glVertexStream2fvATI; +extern PFNGLVERTEXSTREAM2DATIPROC glVertexStream2dATI; +extern PFNGLVERTEXSTREAM2DVATIPROC glVertexStream2dvATI; +extern PFNGLVERTEXSTREAM3SATIPROC glVertexStream3sATI; +extern PFNGLVERTEXSTREAM3SVATIPROC glVertexStream3svATI; +extern PFNGLVERTEXSTREAM3IATIPROC glVertexStream3iATI; +extern PFNGLVERTEXSTREAM3IVATIPROC glVertexStream3ivATI; +extern PFNGLVERTEXSTREAM3FATIPROC glVertexStream3fATI; +extern PFNGLVERTEXSTREAM3FVATIPROC glVertexStream3fvATI; +extern PFNGLVERTEXSTREAM3DATIPROC glVertexStream3dATI; +extern PFNGLVERTEXSTREAM3DVATIPROC glVertexStream3dvATI; +extern PFNGLVERTEXSTREAM4SATIPROC glVertexStream4sATI; +extern PFNGLVERTEXSTREAM4SVATIPROC glVertexStream4svATI; +extern PFNGLVERTEXSTREAM4IATIPROC glVertexStream4iATI; +extern PFNGLVERTEXSTREAM4IVATIPROC glVertexStream4ivATI; +extern PFNGLVERTEXSTREAM4FATIPROC glVertexStream4fATI; +extern PFNGLVERTEXSTREAM4FVATIPROC glVertexStream4fvATI; +extern PFNGLVERTEXSTREAM4DATIPROC glVertexStream4dATI; +extern PFNGLVERTEXSTREAM4DVATIPROC glVertexStream4dvATI; +extern PFNGLNORMALSTREAM3BATIPROC glNormalStream3bATI; +extern PFNGLNORMALSTREAM3BVATIPROC glNormalStream3bvATI; +extern PFNGLNORMALSTREAM3SATIPROC glNormalStream3sATI; +extern PFNGLNORMALSTREAM3SVATIPROC glNormalStream3svATI; +extern PFNGLNORMALSTREAM3IATIPROC glNormalStream3iATI; +extern PFNGLNORMALSTREAM3IVATIPROC glNormalStream3ivATI; +extern PFNGLNORMALSTREAM3FATIPROC glNormalStream3fATI; +extern PFNGLNORMALSTREAM3FVATIPROC glNormalStream3fvATI; +extern PFNGLNORMALSTREAM3DATIPROC glNormalStream3dATI; +extern PFNGLNORMALSTREAM3DVATIPROC glNormalStream3dvATI; +extern PFNGLCLIENTACTIVEVERTEXSTREAMATIPROC glClientActiveVertexStreamATI; +extern PFNGLVERTEXBLENDENVIATIPROC glVertexBlendEnviATI; +extern PFNGLVERTEXBLENDENVFATIPROC glVertexBlendEnvfATI; +#endif + +#if defined(GL_ATI_element_array) +extern PFNGLELEMENTPOINTERATIPROC glElementPointerATI; +extern PFNGLDRAWELEMENTARRAYATIPROC glDrawElementArrayATI; +extern PFNGLDRAWRANGEELEMENTARRAYATIPROC glDrawRangeElementArrayATI; +#endif + +#if defined(GL_SUN_mesh_array) +extern PFNGLDRAWMESHARRAYSSUNPROC glDrawMeshArraysSUN; +#endif + +#if defined(GL_SUN_slice_accum) +#endif + +#if defined(GL_NV_multisample_filter_hint) +#endif + +#if defined(GL_NV_depth_clamp) +#endif + +#if defined(GL_NV_occlusion_query) +extern PFNGLGENOCCLUSIONQUERIESNVPROC glGenOcclusionQueriesNV; +extern PFNGLDELETEOCCLUSIONQUERIESNVPROC glDeleteOcclusionQueriesNV; +extern PFNGLISOCCLUSIONQUERYNVPROC glIsOcclusionQueryNV; +extern PFNGLBEGINOCCLUSIONQUERYNVPROC glBeginOcclusionQueryNV; +extern PFNGLENDOCCLUSIONQUERYNVPROC glEndOcclusionQueryNV; +extern PFNGLGETOCCLUSIONQUERYIVNVPROC glGetOcclusionQueryivNV; +extern PFNGLGETOCCLUSIONQUERYUIVNVPROC glGetOcclusionQueryuivNV; +#endif + +#if defined(GL_NV_point_sprite) +extern PFNGLPOINTPARAMETERINVPROC glPointParameteriNV; +extern PFNGLPOINTPARAMETERIVNVPROC glPointParameterivNV; +#endif + +#if defined(GL_NV_texture_shader3) +#endif + +#if defined(GL_NV_vertex_program1_1) +#endif + +#if defined(GL_EXT_shadow_funcs) +#endif + +#if defined(GL_EXT_stencil_two_side) +extern PFNGLACTIVESTENCILFACEEXTPROC glActiveStencilFaceEXT; +#endif + +#if defined(GL_ATI_text_fragment_shader) +#endif + +#if defined(GL_APPLE_client_storage) +#endif + +#if defined(GL_APPLE_element_array) +extern PFNGLELEMENTPOINTERAPPLEPROC glElementPointerAPPLE; +extern PFNGLDRAWELEMENTARRAYAPPLEPROC glDrawElementArrayAPPLE; +extern PFNGLDRAWRANGEELEMENTARRAYAPPLEPROC glDrawRangeElementArrayAPPLE; +extern PFNGLMULTIDRAWELEMENTARRAYAPPLEPROC glMultiDrawElementArrayAPPLE; +extern PFNGLMULTIDRAWRANGEELEMENTARRAYAPPLEPROC glMultiDrawRangeElementArrayAPPLE; +#endif + +#if defined(GL_APPLE_fence) +extern PFNGLGENFENCESAPPLEPROC glGenFencesAPPLE; +extern PFNGLDELETEFENCESAPPLEPROC glDeleteFencesAPPLE; +extern PFNGLSETFENCEAPPLEPROC glSetFenceAPPLE; +extern PFNGLISFENCEAPPLEPROC glIsFenceAPPLE; +extern PFNGLTESTFENCEAPPLEPROC glTestFenceAPPLE; +extern PFNGLFINISHFENCEAPPLEPROC glFinishFenceAPPLE; +extern PFNGLTESTOBJECTAPPLEPROC glTestObjectAPPLE; +extern PFNGLFINISHOBJECTAPPLEPROC glFinishObjectAPPLE; +#endif + +#if defined(GL_APPLE_vertex_array_object) +extern PFNGLBINDVERTEXARRAYAPPLEPROC glBindVertexArrayAPPLE; +extern PFNGLDELETEVERTEXARRAYSAPPLEPROC glDeleteVertexArraysAPPLE; +extern PFNGLGENVERTEXARRAYSAPPLEPROC glGenVertexArraysAPPLE; +extern PFNGLISVERTEXARRAYAPPLEPROC glIsVertexArrayAPPLE; +#endif + +#if defined(GL_APPLE_vertex_array_range) +extern PFNGLVERTEXARRAYRANGEAPPLEPROC glVertexArrayRangeAPPLE; +extern PFNGLFLUSHVERTEXARRAYRANGEAPPLEPROC glFlushVertexArrayRangeAPPLE; +extern PFNGLVERTEXARRAYPARAMETERIAPPLEPROC glVertexArrayParameteriAPPLE; +#endif + +#if defined(GL_APPLE_ycbcr_422) +#endif + +#if defined(GL_S3_s3tc) +#endif + +#if defined(GL_ATI_draw_buffers) +extern PFNGLDRAWBUFFERSATIPROC glDrawBuffersATI; +#endif + +#if defined(GL_ATI_texture_env_combine3) +#endif + +#if defined(GL_ATI_texture_float) +#endif + +#if defined(GL_NV_float_buffer) +#endif + +#if defined(GL_NV_fragment_program) +extern PFNGLPROGRAMNAMEDPARAMETER4FNVPROC glProgramNamedParameter4fNV; +extern PFNGLPROGRAMNAMEDPARAMETER4DNVPROC glProgramNamedParameter4dNV; +extern PFNGLPROGRAMNAMEDPARAMETER4FVNVPROC glProgramNamedParameter4fvNV; +extern PFNGLPROGRAMNAMEDPARAMETER4DVNVPROC glProgramNamedParameter4dvNV; +extern PFNGLGETPROGRAMNAMEDPARAMETERFVNVPROC glGetProgramNamedParameterfvNV; +extern PFNGLGETPROGRAMNAMEDPARAMETERDVNVPROC glGetProgramNamedParameterdvNV; +#endif + +#if defined(GL_NV_half_float) +extern PFNGLVERTEX2HNVPROC glVertex2hNV; +extern PFNGLVERTEX2HVNVPROC glVertex2hvNV; +extern PFNGLVERTEX3HNVPROC glVertex3hNV; +extern PFNGLVERTEX3HVNVPROC glVertex3hvNV; +extern PFNGLVERTEX4HNVPROC glVertex4hNV; +extern PFNGLVERTEX4HVNVPROC glVertex4hvNV; +extern PFNGLNORMAL3HNVPROC glNormal3hNV; +extern PFNGLNORMAL3HVNVPROC glNormal3hvNV; +extern PFNGLCOLOR3HNVPROC glColor3hNV; +extern PFNGLCOLOR3HVNVPROC glColor3hvNV; +extern PFNGLCOLOR4HNVPROC glColor4hNV; +extern PFNGLCOLOR4HVNVPROC glColor4hvNV; +extern PFNGLTEXCOORD1HNVPROC glTexCoord1hNV; +extern PFNGLTEXCOORD1HVNVPROC glTexCoord1hvNV; +extern PFNGLTEXCOORD2HNVPROC glTexCoord2hNV; +extern PFNGLTEXCOORD2HVNVPROC glTexCoord2hvNV; +extern PFNGLTEXCOORD3HNVPROC glTexCoord3hNV; +extern PFNGLTEXCOORD3HVNVPROC glTexCoord3hvNV; +extern PFNGLTEXCOORD4HNVPROC glTexCoord4hNV; +extern PFNGLTEXCOORD4HVNVPROC glTexCoord4hvNV; +extern PFNGLMULTITEXCOORD1HNVPROC glMultiTexCoord1hNV; +extern PFNGLMULTITEXCOORD1HVNVPROC glMultiTexCoord1hvNV; +extern PFNGLMULTITEXCOORD2HNVPROC glMultiTexCoord2hNV; +extern PFNGLMULTITEXCOORD2HVNVPROC glMultiTexCoord2hvNV; +extern PFNGLMULTITEXCOORD3HNVPROC glMultiTexCoord3hNV; +extern PFNGLMULTITEXCOORD3HVNVPROC glMultiTexCoord3hvNV; +extern PFNGLMULTITEXCOORD4HNVPROC glMultiTexCoord4hNV; +extern PFNGLMULTITEXCOORD4HVNVPROC glMultiTexCoord4hvNV; +extern PFNGLFOGCOORDHNVPROC glFogCoordhNV; +extern PFNGLFOGCOORDHVNVPROC glFogCoordhvNV; +extern PFNGLSECONDARYCOLOR3HNVPROC glSecondaryColor3hNV; +extern PFNGLSECONDARYCOLOR3HVNVPROC glSecondaryColor3hvNV; +extern PFNGLVERTEXWEIGHTHNVPROC glVertexWeighthNV; +extern PFNGLVERTEXWEIGHTHVNVPROC glVertexWeighthvNV; +extern PFNGLVERTEXATTRIB1HNVPROC glVertexAttrib1hNV; +extern PFNGLVERTEXATTRIB1HVNVPROC glVertexAttrib1hvNV; +extern PFNGLVERTEXATTRIB2HNVPROC glVertexAttrib2hNV; +extern PFNGLVERTEXATTRIB2HVNVPROC glVertexAttrib2hvNV; +extern PFNGLVERTEXATTRIB3HNVPROC glVertexAttrib3hNV; +extern PFNGLVERTEXATTRIB3HVNVPROC glVertexAttrib3hvNV; +extern PFNGLVERTEXATTRIB4HNVPROC glVertexAttrib4hNV; +extern PFNGLVERTEXATTRIB4HVNVPROC glVertexAttrib4hvNV; +extern PFNGLVERTEXATTRIBS1HVNVPROC glVertexAttribs1hvNV; +extern PFNGLVERTEXATTRIBS2HVNVPROC glVertexAttribs2hvNV; +extern PFNGLVERTEXATTRIBS3HVNVPROC glVertexAttribs3hvNV; +extern PFNGLVERTEXATTRIBS4HVNVPROC glVertexAttribs4hvNV; +#endif + +#if defined(GL_NV_pixel_data_range) +extern PFNGLPIXELDATARANGENVPROC glPixelDataRangeNV; +extern PFNGLFLUSHPIXELDATARANGENVPROC glFlushPixelDataRangeNV; +#endif + +#if defined(GL_NV_primitive_restart) +extern PFNGLPRIMITIVERESTARTNVPROC glPrimitiveRestartNV; +extern PFNGLPRIMITIVERESTARTINDEXNVPROC glPrimitiveRestartIndexNV; +#endif + +#if defined(GL_NV_texture_expand_normal) +#endif + +#if defined(GL_NV_vertex_program2) +#endif + +#if defined(GL_ATI_map_object_buffer) +extern PFNGLMAPOBJECTBUFFERATIPROC glMapObjectBufferATI; +extern PFNGLUNMAPOBJECTBUFFERATIPROC glUnmapObjectBufferATI; +#endif + +#if defined(GL_ATI_separate_stencil) +extern PFNGLSTENCILOPSEPARATEATIPROC glStencilOpSeparateATI; +extern PFNGLSTENCILFUNCSEPARATEATIPROC glStencilFuncSeparateATI; +#endif + +#if defined(GL_ATI_vertex_attrib_array_object) +extern PFNGLVERTEXATTRIBARRAYOBJECTATIPROC glVertexAttribArrayObjectATI; +extern PFNGLGETVERTEXATTRIBARRAYOBJECTFVATIPROC glGetVertexAttribArrayObjectfvATI; +extern PFNGLGETVERTEXATTRIBARRAYOBJECTIVATIPROC glGetVertexAttribArrayObjectivATI; +#endif + +#if defined(GL_EXT_depth_bounds_test) +extern PFNGLDEPTHBOUNDSEXTPROC glDepthBoundsEXT; +#endif + +#if defined(GL_EXT_texture_mirror_clamp) +#endif + +#if defined(GL_EXT_blend_equation_separate) +extern PFNGLBLENDEQUATIONSEPARATEEXTPROC glBlendEquationSeparateEXT; +#endif + +#if defined(GL_MESA_pack_invert) +#endif + +#if defined(GL_MESA_ycbcr_texture) +#endif + +/* end mkglext.py */ + +} /* namespace RAS_GL */ + +#endif /* __RAS_GLEXTENSIONMANAGER_H__ */ diff --git a/source/gameengine/Rasterizer/RAS_OpenGLRasterizer/RAS_OpenGLRasterizer.cpp b/source/gameengine/Rasterizer/RAS_OpenGLRasterizer/RAS_OpenGLRasterizer.cpp index b1c3e5b1996..b7f375e770c 100644 --- a/source/gameengine/Rasterizer/RAS_OpenGLRasterizer/RAS_OpenGLRasterizer.cpp +++ b/source/gameengine/Rasterizer/RAS_OpenGLRasterizer/RAS_OpenGLRasterizer.cpp @@ -1,3 +1,33 @@ +/** + * $Id$ + * ***** BEGIN GPL/BL DUAL LICENSE BLOCK ***** + * + * This program is free software; you can redistribute it and/or + * modify it under the terms of the GNU General Public License + * as published by the Free Software Foundation; either version 2 + * of the License, or (at your option) any later version. The Blender + * Foundation also sells licenses for use in proprietary software under + * the Blender License. See http://www.blender.org/BL/ for information + * about this. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software Foundation, + * Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. + * + * The Original Code is Copyright (C) 2001-2002 by NaN Holding BV. + * All rights reserved. + * + * The Original Code is: all of this file. + * + * Contributor(s): none yet. + * + * ***** END GPL/BL DUAL LICENSE BLOCK ***** + */ #include "RAS_OpenGLRasterizer.h" #ifdef HAVE_CONFIG_H @@ -23,8 +53,8 @@ RAS_OpenGLRasterizer::RAS_OpenGLRasterizer(RAS_ICanvas* canvas) :RAS_IRasterizer(canvas), m_2DCanvas(canvas), m_fogenabled(false), - m_materialCachingInfo(0), - m_noOfScanlines(32) + m_noOfScanlines(32), + m_materialCachingInfo(0) { m_viewmatrix.Identity(); m_stereomode = RAS_STEREO_NOSTEREO; @@ -314,11 +344,14 @@ void RAS_OpenGLRasterizer::SetDepthMask(int depthmask) case KX_DEPTHMASK_ENABLED: { glDepthMask(GL_TRUE); + //glDisable ( GL_ALPHA_TEST ); break; }; case KX_DEPTHMASK_DISABLED: { glDepthMask(GL_FALSE); + //glAlphaFunc ( GL_GREATER, 0.0 ) ; + //glEnable ( GL_ALPHA_TEST ) ; break; }; default: @@ -441,7 +474,6 @@ void RAS_OpenGLRasterizer::IndexPrimitives(const vecVertexArray & vertexarrays, const MT_Vector4& rgbacolor ) { - static const GLsizei vtxstride = sizeof(RAS_TexVert); GLenum drawmode; switch (mode) { @@ -460,7 +492,7 @@ void RAS_OpenGLRasterizer::IndexPrimitives(const vecVertexArray & vertexarrays, } const RAS_TexVert* vertexarray ; - int numindices,vt; + unsigned int numindices,vt; for (vt=0;vtsize(); - if (!numindices) break; @@ -480,7 +510,7 @@ void RAS_OpenGLRasterizer::IndexPrimitives(const vecVertexArray & vertexarrays, { glBegin(GL_LINES); vindex=0; - for (int i=0;isize(); - if (!numindices) break; @@ -675,7 +695,7 @@ void RAS_OpenGLRasterizer::IndexPrimitives_Ex(const vecVertexArray & vertexarray { glBegin(GL_LINES); vindex=0; - for (int i=0;isize(); - if (!numindices) break; @@ -968,7 +976,7 @@ void RAS_OpenGLRasterizer::IndexPrimitives_3DText(const vecVertexArray & vertexa { glBegin(GL_LINES); vindex=0; - for (int i=0;i #endif -#ifdef WIN32 - #include "RAS_VAOpenGLRasterizer.h" -#include -#include "GL/gl.h" - -typedef void (APIENTRY *GLLOCKARRAYSEXTPTR)(GLint first,GLsizei count); -typedef void (APIENTRY *GLUNLOCKARRAYSEXTPTR)(void); -void APIENTRY RAS_lockfunc(GLint first,GLsizei count) {}; -void APIENTRY RAS_unlockfunc() {}; -GLLOCKARRAYSEXTPTR glLockArraysEXT=RAS_lockfunc; -GLUNLOCKARRAYSEXTPTR glUnlockArraysEXT=RAS_unlockfunc; - - +#ifdef WIN32 +#include +#endif // WIN32 +#ifdef __APPLE__ +#include +#else +#include +#endif #include "STR_String.h" #include "RAS_TexVert.h" #include "MT_CmMatrix4x4.h" #include "RAS_IRenderTools.h" // rendering text +#include "RAS_GLExtensionManager.h" + +using namespace RAS_GL; + RAS_VAOpenGLRasterizer::RAS_VAOpenGLRasterizer(RAS_ICanvas* canvas) :RAS_OpenGLRasterizer(canvas) { - int i = 0; } @@ -38,7 +66,7 @@ RAS_VAOpenGLRasterizer::~RAS_VAOpenGLRasterizer() -bool RAS_VAOpenGLRasterizer::Init() +bool RAS_VAOpenGLRasterizer::Init(void) { bool result = RAS_OpenGLRasterizer::Init(); @@ -48,15 +76,7 @@ bool RAS_VAOpenGLRasterizer::Init() // if possible, add extensions to other platforms too, if this // rasterizer becomes messy just derive one for each platform // (ie. KX_Win32Rasterizer, KX_LinuxRasterizer etc.) - - glUnlockArraysEXT = reinterpret_cast(wglGetProcAddress("glUnlockArraysEXT")); - if (!glUnlockArraysEXT) - result = false; - - glLockArraysEXT = reinterpret_cast(wglGetProcAddress("glLockArraysEXT")); - if (!glLockArraysEXT) - result=false; - + glEnableClientState(GL_VERTEX_ARRAY); glDisableClientState(GL_TEXTURE_COORD_ARRAY); glDisableClientState(GL_NORMAL_ARRAY); @@ -149,7 +169,7 @@ void RAS_VAOpenGLRasterizer::IndexPrimitives( const vecVertexArray& vertexarrays } } const RAS_TexVert* vertexarray; - int numindices,vt; + unsigned int numindices, vt; if (drawmode != GL_LINES) { if (useObjectColor) @@ -177,14 +197,10 @@ void RAS_VAOpenGLRasterizer::IndexPrimitives( const vecVertexArray& vertexarrays if (!numindices) break; - mypointer = (unsigned char*)(vertexarray); - glVertexPointer(3,GL_FLOAT,vtxstride,mypointer); - mypointer+= 3*sizeof(float); - glTexCoordPointer(2,GL_FLOAT,vtxstride,mypointer); - mypointer+= 2*sizeof(float); - glColorPointer(4,GL_UNSIGNED_BYTE,vtxstride,mypointer); - mypointer += sizeof(int); - glNormalPointer(GL_SHORT,vtxstride,mypointer); + glVertexPointer(3,GL_FLOAT,vtxstride,vertexarray->getLocalXYZ()); + glTexCoordPointer(2,GL_FLOAT,vtxstride,vertexarray->getUV1()); + glColorPointer(4,GL_UNSIGNED_BYTE,vtxstride,&vertexarray->getRGBA()); + glNormalPointer(GL_SHORT,vtxstride,vertexarray->getNormal()); glLockArraysEXT(0,numverts); // here the actual drawing takes places glDrawElements(drawmode,numindices,GL_UNSIGNED_INT,&(indexarray[0])); @@ -212,5 +228,3 @@ bool RAS_VAOpenGLRasterizer::Stereo() return false; } - -#endif //WIN32 diff --git a/source/gameengine/Rasterizer/RAS_OpenGLRasterizer/SConscript b/source/gameengine/Rasterizer/RAS_OpenGLRasterizer/SConscript index 003ddbf404e..f45f3c6fc8d 100755 --- a/source/gameengine/Rasterizer/RAS_OpenGLRasterizer/SConscript +++ b/source/gameengine/Rasterizer/RAS_OpenGLRasterizer/SConscript @@ -3,7 +3,7 @@ Import ('library_env') ras_openglrasterizer_env = library_env.Copy () -source_files = ['RAS_CheckVertexArrays.cpp', +source_files = ['RAS_GLExtensionManager.cpp', 'RAS_OpenGLRasterizer.cpp', 'RAS_VAOpenGLRasterizer.cpp'] diff --git a/source/gameengine/Rasterizer/RAS_OpenGLRasterizer/mkglext.py b/source/gameengine/Rasterizer/RAS_OpenGLRasterizer/mkglext.py new file mode 100644 index 00000000000..416629b3aac --- /dev/null +++ b/source/gameengine/Rasterizer/RAS_OpenGLRasterizer/mkglext.py @@ -0,0 +1,538 @@ +#!/usr/bin/python +# +# $Id$ +# ***** BEGIN GPL/BL DUAL LICENSE BLOCK ***** +# +# This program is free software; you can redistribute it and/or +# modify it under the terms of the GNU General Public License +# as published by the Free Software Foundation; either version 2 +# of the License, or (at your option) any later version. The Blender +# Foundation also sells licenses for use in proprietary software under +# the Blender License. See http://www.blender.org/BL/ for information +# about this. +# +# This program is distributed in the hope that it will be useful, +# but WITHOUT ANY WARRANTY; without even the implied warranty of +# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +# GNU General Public License for more details. +# +# You should have received a copy of the GNU General Public License +# along with this program; if not, write to the Free Software Foundation, +# Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. +# +# The Original Code is Copyright (C) 2001-2002 by NaN Holding BV. +# All rights reserved. +# +# The Original Code is: all of this file. +# +# Contributor(s): none yet. +# +# ***** END GPL/BL DUAL LICENSE BLOCK ***** + +# +# mkglext.py generates code for linking extensions. +# +# It reads the glext.h header from stdin and writes code to stdout. +# +# Usage: mkglext.py < glext.h > tmp +# Code can be copied & pasted from tmp to GL_ExtensionManager.cpp. +# +# glext.h is available here: http://oss.sgi.com/projects/ogl-sample/ABI/glext.h +# + +from sys import stdin +import string, re + +glext_h = string.split(stdin.read(), '\n') + +# These extensions have been incorporated into the core GL or been superceded. +# Code will not be generated for these extensions +blacklist = [ + "GL_EXT_multisample", + "GL_INGR_blend_func_separate", + "GL_SGIX_fragment_lighting", + "GL_SGIX_polynomial_ffd", + "GL_SGIS_point_parameters", + "GL_EXT_texture_object", + "GL_EXT_subtexture", + "GL_EXT_copy_texture", + "GL_EXT_vertex_array", + "GL_EXT_point_parameters", + "GL_EXT_blend_color", + "GL_EXT_polygon_offset", + "GL_EXT_texture"] + +# Only code for these extensions will be generated. Extensions on both the +# blacklist & whitelist will not have code generated. +# This list is from http://oss.sgi.com/projects/ogl-sample/registry/ at 14-Mar-04 +whitelist = [ + # ARB Extensions + "GL_ARB_multitexture", + "GLX_ARB_get_proc_address", + "GL_ARB_transpose_matrix", + "WGL_ARB_buffer_region", + "GL_ARB_multisample", + "GL_ARB_texture_env_add", + "GL_ARB_texture_cube_map", + "WGL_ARB_extensions_string", + "WGL_ARB_pixel_format", + "WGL_ARB_make_current_read", + "WGL_ARB_pbuffer", + "GL_ARB_texture_compression", + "GL_ARB_texture_border_clamp", + "GL_ARB_point_parameters", + "GL_ARB_vertex_blend", + "GL_ARB_matrix_palette", + "GL_ARB_texture_env_combine", + "GL_ARB_texture_env_crossbar", + "GL_ARB_texture_env_dot3", + "WGL_ARB_render_texture", + "GL_ARB_texture_mirrored_repeat", + "GL_ARB_depth_texture", + "GL_ARB_shadow", + "GL_ARB_shadow_ambient", + "GL_ARB_window_pos", + "GL_ARB_vertex_program", + "GL_ARB_fragment_program", + "GL_ARB_vertex_buffer_object", + "GL_ARB_occlusion_query", + "GL_ARB_shader_objects", + "GL_ARB_vertex_shader", + "GL_ARB_fragment_shader", + "GL_ARB_shading_language_100", + "GL_ARB_texture_non_power_of_two", + "GL_ARB_point_sprite", + "GL_ARB_fragment_program_shadow", + + # Non ARB Extensions + "GL_EXT_abgr", + "GL_EXT_blend_color", + "GL_EXT_polygon_offset", + "GL_EXT_texture", + "GL_EXT_texture3D", + "GL_SGIS_texture_filter4", + "GL_EXT_subtexture", + "GL_EXT_copy_texture", + "GL_EXT_histogram", + "GL_EXT_convolution", + "GL_SGI_color_matrix", + "GL_SGI_color_table", + "GL_SGIS_pixel_texture", + "GL_SGIS_texture4D", + "GL_SGI_texture_color_table", + "GL_EXT_cmyka", + "GL_EXT_texture_object", + "GL_SGIS_detail_texture", + "GL_SGIS_sharpen_texture", + "GL_EXT_packed_pixels", + "GL_SGIS_texture_lod", + "GL_SGIS_multisample", + "GL_EXT_rescale_normal", + "GLX_EXT_visual_info", + "GL_EXT_vertex_array", + "GL_EXT_misc_attribute", + "GL_SGIS_generate_mipmap", + "GL_SGIX_clipmap", + "GL_SGIX_shadow", + "GL_SGIS_texture_edge_clamp", + "GL_SGIS_texture_border_clamp", + "GL_EXT_blend_minmax", + "GL_EXT_blend_subtract", + "GL_EXT_blend_logic_op", + "GLX_SGI_swap_control", + "GLX_SGI_video_sync", + "GLX_SGI_make_current_read", + "GLX_SGIX_video_source", + "GLX_EXT_visual_rating", + "GL_SGIX_interlace", + "GLX_EXT_import_context", + "GLX_SGIX_fbconfig", + "GLX_SGIX_pbuffer", + "GL_SGIS_texture_select", + "GL_SGIX_sprite", + "GL_SGIX_texture_multi_buffer", + "GL_EXT_point_parameters", + "GL_SGIX_instruments", + "GL_SGIX_texture_scale_bias", + "GL_SGIX_framezoom", + "GL_SGIX_tag_sample_buffer", + "GL_SGIX_reference_plane", + "GL_SGIX_flush_raster", + "GLX_SGI_cushion", + "GL_SGIX_depth_texture", + "GL_SGIS_fog_function", + "GL_SGIX_fog_offset", + "GL_HP_image_transform", + "GL_HP_convolution_border_modes", + "GL_SGIX_texture_add_env", + "GL_EXT_color_subtable", + "GLU_EXT_object_space_tess", + "GL_PGI_vertex_hints", + "GL_PGI_misc_hints", + "GL_EXT_paletted_texture", + "GL_EXT_clip_volume_hint", + "GL_SGIX_list_priority", + "GL_SGIX_ir_instrument1", + "GLX_SGIX_video_resize", + "GL_SGIX_texture_lod_bias", + "GLU_SGI_filter4_parameters", + "GLX_SGIX_dm_buffer", + "GL_SGIX_shadow_ambient", + "GLX_SGIX_swap_group", + "GLX_SGIX_swap_barrier", + "GL_EXT_index_texture", + "GL_EXT_index_material", + "GL_EXT_index_func", + "GL_EXT_index_array_formats", + "GL_EXT_compiled_vertex_array", + "GL_EXT_cull_vertex", + "GLU_EXT_nurbs_tessellator", + "GL_SGIX_ycrcb", + "GL_EXT_fragment_lighting", + "GL_IBM_rasterpos_clip", + "GL_HP_texture_lighting", + "GL_EXT_draw_range_elements", + "GL_WIN_phong_shading", + "GL_WIN_specular_fog", + "GLX_SGIS_color_range", + "GL_EXT_light_texture", + "GL_SGIX_blend_alpha_minmax", + "GL_EXT_scene_marker", + "GL_SGIX_pixel_texture_bits", + "GL_EXT_bgra", + "GL_SGIX_async", + "GL_SGIX_async_pixel", + "GL_SGIX_async_histogram", + "GL_INTEL_texture_scissor", + "GL_INTEL_parallel_arrays", + "GL_HP_occlusion_test", + "GL_EXT_pixel_transform", + "GL_EXT_pixel_transform_color_table", + "GL_EXT_shared_texture_palette", + "GLX_SGIS_blended_overlay", + "GL_EXT_separate_specular_color", + "GL_EXT_secondary_color", + "GL_EXT_texture_env", + "GL_EXT_texture_perturb_normal", + "GL_EXT_multi_draw_arrays", + "GL_EXT_fog_coord", + "GL_REND_screen_coordinates", + "GL_EXT_coordinate_frame", + "GL_EXT_texture_env_combine", + "GL_APPLE_specular_vector", + "GL_SGIX_pixel_texture", + "GL_APPLE_transform_hint", + "GL_SUNX_constant_data", + "GL_SUN_global_alpha", + "GL_SUN_triangle_list", + "GL_SUN_vertex", + "WGL_EXT_display_color_table", + "WGL_EXT_extensions_string", + "WGL_EXT_make_current_read", + "WGL_EXT_pixel_format", + "WGL_EXT_pbuffer", + "WGL_EXT_swap_control", + "GL_EXT_blend_func_separate", + "GL_INGR_color_clamp", + "GL_INGR_interlace_read", + "GL_EXT_stencil_wrap", + "WGL_EXT_depth_float", + "GL_EXT_422_pixels", + "GL_NV_texgen_reflection", + "GL_SGIX_texture_range", + "GL_SUN_convolution_border_modes", + "GLX_SUN_get_transparent_index", + "GL_EXT_texture_env_add", + "GL_EXT_texture_lod_bias", + "GL_EXT_texture_filter_anisotropic", + "GL_EXT_vertex_weighting", + "GL_NV_light_max_exponent", + "GL_NV_vertex_array_range", + "GL_NV_register_combiners", + "GL_NV_fog_distance", + "GL_NV_texgen_emboss", + "GL_NV_blend_square", + "GL_NV_texture_env_combine4", + "GL_MESA_resize_buffers", + "GL_MESA_window_pos", + "GL_EXT_texture_compression_s3tc", + "GL_IBM_cull_vertex", + "GL_IBM_multimode_draw_arrays", + "GL_IBM_vertex_array_lists", + "GL_3DFX_texture_compression_FXT1", + "GL_3DFX_multisample", + "GL_3DFX_tbuffer", + "WGL_EXT_multisample", + "GL_SGIX_vertex_preclip", + "GL_SGIX_resample", + "GL_SGIS_texture_color_mask", + "GLX_MESA_copy_sub_buffer", + "GLX_MESA_pixmap_colormap", + "GLX_MESA_release_buffers", + "GLX_MESA_set_3dfx_mode", + "GL_EXT_texture_env_dot3", + "GL_ATI_texture_mirror_once", + "GL_NV_fence", + "GL_IBM_static_data", + "GL_IBM_texture_mirrored_repeat", + "GL_NV_evaluators", + "GL_NV_packed_depth_stencil", + "GL_NV_register_combiners2", + "GL_NV_texture_compression_vtc", + "GL_NV_texture_rectangle", + "GL_NV_texture_shader", + "GL_NV_texture_shader2", + "GL_NV_vertex_array_range2", + "GL_NV_vertex_program", + "GLX_SGIX_visual_select_group", + "GL_SGIX_texture_coordinate_clamp", + "GLX_OML_swap_method", + "GLX_OML_sync_control", + "GL_OML_interlace", + "GL_OML_subsample", + "GL_OML_resample", + "WGL_OML_sync_control", + "GL_NV_copy_depth_to_color", + "GL_ATI_envmap_bumpmap", + "GL_ATI_fragment_shader", + "GL_ATI_pn_triangles", + "GL_ATI_vertex_array_object", + "GL_EXT_vertex_shader", + "GL_ATI_vertex_streams", + "WGL_I3D_digital_video_control", + "WGL_I3D_gamma", + "WGL_I3D_genlock", + "WGL_I3D_image_buffer", + "WGL_I3D_swap_frame_lock", + "WGL_I3D_swap_frame_usage", + "GL_ATI_element_array", + "GL_SUN_mesh_array", + "GL_SUN_slice_accum", + "GL_NV_multisample_filter_hint", + "GL_NV_depth_clamp", + "GL_NV_occlusion_query", + "GL_NV_point_sprite", + "WGL_NV_render_depth_texture", + "WGL_NV_render_texture_rectangle", + "GL_NV_texture_shader3", + "GL_NV_vertex_program1_1", + "GL_EXT_shadow_funcs", + "GL_EXT_stencil_two_side", + "GL_ATI_text_fragment_shader", + "GL_APPLE_client_storage", + "GL_APPLE_element_array", + "GL_APPLE_fence", + "GL_APPLE_vertex_array_object", + "GL_APPLE_vertex_array_range", + "GL_APPLE_ycbcr_422", + "GL_S3_s3tc", + "GL_ATI_draw_buffers", + "WGL_ATI_pixel_format_float", + "GL_ATI_texture_env_combine3", + "GL_ATI_texture_float", + "GL_NV_float_buffer", + "GL_NV_fragment_program", + "GL_NV_half_float", + "GL_NV_pixel_data_range", + "GL_NV_primitive_restart", + "GL_NV_texture_expand_normal", + "GL_NV_vertex_program2", + "GL_ATI_map_object_buffer", + "GL_ATI_separate_stencil", + "GL_ATI_vertex_attrib_array_object", + "GL_OES_byte_coordinates", + "GL_OES_fixed_point", + "GL_OES_single_precision", + "GL_OES_compressed_paletted_texture", + "GL_OES_read_format", + "GL_OES_query_matrix", + "GL_EXT_depth_bounds_test", + "GL_EXT_texture_mirror_clamp", + "GL_EXT_blend_equation_separate", + "GL_MESA_pack_invert", + "GL_MESA_ycbcr_texture"] + +""" +Example code output: +#ifdef GL_EXT_compiled_vertex_array + if (QueryExtension("GL_EXT_compiled_vertex_array")) + { + glUnlockArraysEXT = reinterpret_cast(bglGetProcAddress((const GLubyte *) "glUnlockArraysEXT")); + glLockArraysEXT = reinterpret_cast(bglGetProcAddress((const GLubyte *) "glLockArraysEXT")); + if (glUnlockArraysEXT && glLockArraysEXT) + { + EnableExtension(_GL_EXT_compiled_vertex_array); + if (m_debug && doDebugMessages) + std::cout << "Enabled GL_EXT_compiled_vertex_array" << std::endl; + } else { + std::cout << "ERROR: GL_EXT_compiled_vertex_array implementation is broken!" << std::endl; + } + } +#endif +""" +def writeext(ext, fnlist): + if (find(blacklist, ext)): + return + if (len(fnlist) == 0): + print "\tif (QueryExtension(\"" + ext + "\"))" + print "\t{" + print "\t\tEnableExtension(_" + ext + ");" + print "\t\tif (m_debug && doDebugMessages)" + print "\t\t\tstd::cout << \"Enabled " + ext + "\" << std::endl;" + print "\t}" + print + return + print "#if defined(" + ext + ")" + print "\tif (QueryExtension(\"" + ext + "\"))" + print "\t{" + for fn in fnlist: + print "\t\t" + fn[0] + " = reinterpret_cast<" + fn[1] + ">(bglGetProcAddress((const GLubyte *) \"" + fn[0] + "\"));" + errcheck = "" + for fn in fnlist: + if (errcheck == ""): + errcheck = fn[0] + else: + errcheck = errcheck + " && " + fn[0] + print "\t\tif (" + errcheck + ") {" + print "\t\t\tEnableExtension(_" + ext + ");" + print "\t\t\tif (m_debug && doDebugMessages)" + print "\t\t\t\tstd::cout << \"Enabled " + ext + "\" << std::endl;" + print "\t\t} else {" + print "\t\t\tstd::cout << \"ERROR: " + ext + " implementation is broken!\" << std::endl;" + print "\t\t}" + print "\t}" + print "#endif" + print + +""" +Example Output: +#if defined(GL_EXT_compiled_vertex_array) +PFNGLLOCKARRAYSEXTPROC glLockArraysEXT; +PFNGLUNLOCKARRAYSEXTPROC glUnlockArraysEXT; +#endif +""" +def writeproto(ext, fnlist): + if (find(blacklist, ext) or not find(whitelist, ext)): + return + print "#if defined(" + ext + ")" + for fn in fnlist: + print fn[1] + " " + fn[0] + ";" + print "#endif" + print + +""" +#ifdef GL_EXT_compiled_vertex_array +extern PFNGLLOCKARRAYSEXTPROC glLockArraysEXT; +extern PFNGLUNLOCKARRAYSEXTPROC glUnlockArraysEXT; +#endif +""" +def writeheader(ext, fnlisti): + if (find(blacklist, ext) or not find(whitelist, ext)): + return + print "#if defined(" + ext + ")" + for fn in fnlist: + print "extern " + fn[1] + " " + fn[0] + ";" + print "#endif" + print + +def find(l, x): + for i in l: + if (i == x): + return 1 + return 0 + +ext = "" +fns = [] +fnlist = [] +ifdef = 0 +for i in glext_h: + line = re.search('^#ifn?def', i) + if (line): + ifdef = ifdef + 1 + + line = re.search('^#ifndef (GL_.*)', i) + if (line): + if (not re.search('GL_VERSION.*', line.group(1)) and find(whitelist, line.group(1))): + ext = line.group(1) + + line = re.search('^#endif', i) + if (line): + ifdef = ifdef - 1 + if (ifdef == 0 and ext != ""): + writeproto(ext, fnlist) + ext = "" + fns = [] + fnlist = [] + if (ext != ""): + line = re.search('.*(gl.*) \(.*\);', i) + if (line): + fns += [line.group(1)] + line = re.search('.*PFN(.*)PROC.*', i) + if (line): + for j in fns: + if (string.lower(line.group(1)) == string.lower(j)): + fnlist += [(j, "PFN" + line.group(1) + "PROC")] + +ext = "" +fns = [] +fnlist = [] +ifdef = 0 +for i in glext_h: + line = re.search('^#ifn?def', i) + if (line): + ifdef = ifdef + 1 + + line = re.search('^#ifndef (GL_.*)', i) + if (line): + if (not re.search('GL_VERSION.*', line.group(1)) and find(whitelist, line.group(1))): + ext = line.group(1) + + line = re.search('^#endif', i) + if (line): + ifdef = ifdef - 1 + if (ifdef == 0 and ext != ""): + writeext(ext, fnlist) + ext = "" + fns = [] + fnlist = [] + if (ext != ""): + line = re.search('.*(gl.*) \(.*\);', i) + if (line): + fns += [line.group(1)] + line = re.search('.*PFN(.*)PROC.*', i) + if (line): + for j in fns: + if (string.lower(line.group(1)) == string.lower(j)): + fnlist += [(j, "PFN" + line.group(1) + "PROC")] + +ext = "" +fns = [] +fnlist = [] +ifdef = 0 +for i in glext_h: + line = re.search('^#ifn?def', i) + if (line): + ifdef = ifdef + 1 + + line = re.search('^#ifndef (GL_.*)', i) + if (line): + if (not re.search('GL_VERSION.*', line.group(1)) and find(whitelist, line.group(1))): + ext = line.group(1) + + line = re.search('^#endif', i) + if (line): + ifdef = ifdef - 1 + if (ifdef == 0 and ext != ""): + writeheader(ext, fnlist) + ext = "" + fns = [] + fnlist = [] + if (ext != ""): + line = re.search('.*(gl.*) \(.*\);', i) + if (line): + fns += [line.group(1)] + line = re.search('.*PFN(.*)PROC.*', i) + if (line): + for j in fns: + if (string.lower(line.group(1)) == string.lower(j)): + fnlist += [(j, "PFN" + line.group(1) + "PROC")] diff --git a/source/gameengine/Rasterizer/RAS_TexVert.cpp b/source/gameengine/Rasterizer/RAS_TexVert.cpp index c29a16c71d8..c5b193cc941 100644 --- a/source/gameengine/Rasterizer/RAS_TexVert.cpp +++ b/source/gameengine/Rasterizer/RAS_TexVert.cpp @@ -52,11 +52,6 @@ RAS_TexVert::RAS_TexVert(const MT_Point3& xyz, -const float* RAS_TexVert::getUV1 () const -{ - return m_uv1; -} - const MT_Point3& RAS_TexVert::xyz() @@ -97,8 +92,14 @@ void RAS_TexVert::SetNormal(const MT_Vector3& normal) } - +#ifndef RAS_TexVert_INLINE // leave multiline for debugging +const float* RAS_TexVert::getUV1 () const +{ + return m_uv1; +} + + const short* RAS_TexVert::getNormal() const { return m_normal; @@ -118,7 +119,7 @@ const unsigned int& RAS_TexVert::getRGBA() const return m_rgba; } - +#endif // compare two vertices, and return TRUE if both are almost identical (they can be shared) bool RAS_TexVert::closeTo(const RAS_TexVert* other) @@ -153,3 +154,11 @@ short RAS_TexVert::getFlag() const { return m_flag; } + +void RAS_TexVert::getOffsets(void* &xyz, void* &uv1, void* &rgba, void* &normal) const +{ + xyz = (void *) m_localxyz; + uv1 = (void *) m_uv1; + rgba = (void *) m_rgba; + normal = (void *) m_normal; +} diff --git a/source/gameengine/Rasterizer/RAS_TexVert.h b/source/gameengine/Rasterizer/RAS_TexVert.h index 0e19ea61d9d..cd529e7d586 100644 --- a/source/gameengine/Rasterizer/RAS_TexVert.h +++ b/source/gameengine/Rasterizer/RAS_TexVert.h @@ -42,14 +42,16 @@ static MT_Point2 g_pt2; #define TV_CALCFACENORMAL 0x0001 +#define RAS_TexVert_INLINE 1 + class RAS_TexVert { - float m_localxyz[3]; // 3*4=12 = 24 - float m_uv1[2]; // 2*4=8 = 24 + 16 = 40 - unsigned int m_rgba; //4 = 40 + 4 = 44 - short m_normal[3]; //3*2=6 = 50 - short m_flag; //32 bytes total size, fits nice = 52 = not fit nice + float m_localxyz[3]; // 3*4 = 12 = 24 + float m_uv1[2]; // 2*4 = 8 = 24 + 16 = 40 + unsigned int m_rgba; // 4 = 40 + 4 = 44 + short m_normal[3]; // 3*2 = 6 = 50 + short m_flag; // 32 bytes total size, fits nice = 52 = not fit nice public: @@ -64,11 +66,28 @@ public: ~RAS_TexVert() {}; // leave multiline for debugging +#ifdef RAS_TexVert_INLINE + const float* getUV1 () const { + return m_uv1; + }; + + const float* getLocalXYZ() const { + return m_localxyz; + }; + + const short* getNormal() const { + return m_normal; + } + + const unsigned int& getRGBA() const { + return m_rgba; + } +#else const float* getUV1 () const; - - //const float* getUV1 () const { - // return m_uv1; - //}; + const short* getNormal() const; + const float* getLocalXYZ() const; + const unsigned int& getRGBA() const; +#endif const MT_Point3& xyz(); @@ -77,14 +96,7 @@ public: void SetRGBA(const unsigned int rgba); void SetNormal(const MT_Vector3& normal); void SetFlag(const short flag); - // leave multiline for debugging - const short* getNormal() const; - //const float* getLocalXYZ() const { - // return m_localxyz; - //}; - - const float* getLocalXYZ() const; - const unsigned int& getRGBA() const; + // compare two vertices, and return TRUE if both are almost identical (they can be shared) bool closeTo(const RAS_TexVert* other); @@ -92,6 +104,7 @@ public: const MT_Point2& otheruv, const unsigned int otherrgba, short othernormal[3]) const; + void getOffsets(void*&xyz, void *&uv1, void *&rgba, void *&normal) const; }; #endif //__RAS_TEXVERT -- cgit v1.2.3