attempt to avoid nameclashes (although it is already in a namespace) -> extension names renamed from glXXX to blXXX.

5 files changed, 385 insertions, 385 deletions

diff --git a/source/gameengine/Ketsji/BL_Shader.cpp b/source/gameengine/Ketsji/BL_Shader.cpp
index 7e0b6df3a3a..369fc58fc50 100644
--- a/source/gameengine/Ketsji/BL_Shader.cpp
+++ b/source/gameengine/Ketsji/BL_Shader.cpp
@@ -67,15 +67,15 @@ BL_Shader::~BL_Shader()
 {
 #ifdef GL_ARB_shader_objects
 	if( mShader ) {
-		glDeleteObjectARB(mShader);
+		bgl::blDeleteObjectARB(mShader);
 		mShader = 0;
 	}
 	if( mFrag ) {
-		glDeleteObjectARB(mFrag);
+		bgl::blDeleteObjectARB(mFrag);
 		mFrag = 0;
 	}
 	if( mVert ) {
-		glDeleteObjectARB(mVert);
+		bgl::blDeleteObjectARB(mVert);
 		mVert		= 0;
 	}
 
@@ -83,7 +83,7 @@ BL_Shader::~BL_Shader()
 	fragProg	= 0;
 	mOk			= 0;
 
-	glUseProgramObjectARB(0);
+	bgl::blUseProgramObjectARB(0);
 #endif//GL_ARB_shader_objects
 }
 
@@ -101,56 +101,56 @@ bool BL_Shader::LinkProgram()
 	}
 	
 	// create our objects
-	unsigned int tmpVert = glCreateShaderObjectARB(GL_VERTEX_SHADER_ARB);
-	unsigned int tmpFrag = glCreateShaderObjectARB(GL_FRAGMENT_SHADER_ARB);
-	unsigned int tmpProg = glCreateProgramObjectARB();
+	unsigned int tmpVert = bgl::blCreateShaderObjectARB(GL_VERTEX_SHADER_ARB);
+	unsigned int tmpFrag = bgl::blCreateShaderObjectARB(GL_FRAGMENT_SHADER_ARB);
+	unsigned int tmpProg = bgl::blCreateProgramObjectARB();
 
 	if(!tmpVert || !tmpFrag || !tmpProg){
-		glDeleteObjectARB(tmpVert);
-		glDeleteObjectARB(tmpFrag);
-		glDeleteObjectARB(tmpProg);
+		bgl::blDeleteObjectARB(tmpVert);
+		bgl::blDeleteObjectARB(tmpFrag);
+		bgl::blDeleteObjectARB(tmpProg);
 		return false;
 	}
 	// set/compile vertex shader
-	glShaderSourceARB(tmpVert, 1, (const char**)&vertProg, 0);
-	glCompileShaderARB(tmpVert);
-	glGetObjectParameterivARB(tmpVert, GL_OBJECT_INFO_LOG_LENGTH_ARB, &vertlen);
+	bgl::blShaderSourceARB(tmpVert, 1, (const char**)&vertProg, 0);
+	bgl::blCompileShaderARB(tmpVert);
+	bgl::blGetObjectParameterivARB(tmpVert, GL_OBJECT_INFO_LOG_LENGTH_ARB, &vertlen);
 
 	if( vertlen > 0 && !PrintInfo(vertlen,tmpVert, "Vertex Shader") ){
 		spit("Vertex shader failed");
-		glDeleteObjectARB(tmpVert);
-		glDeleteObjectARB(tmpFrag);
-		glDeleteObjectARB(tmpProg);
+		bgl::blDeleteObjectARB(tmpVert);
+		bgl::blDeleteObjectARB(tmpFrag);
+		bgl::blDeleteObjectARB(tmpProg);
 		mOk	= 0;
 		return false;
 	}
 	// set/compile fragment shader
-	glShaderSourceARB(tmpFrag, 1,(const char**)&fragProg, 0);
-	glCompileShaderARB(tmpFrag);
-	glGetObjectParameterivARB(tmpFrag, GL_OBJECT_INFO_LOG_LENGTH_ARB, &fraglen);
+	bgl::blShaderSourceARB(tmpFrag, 1,(const char**)&fragProg, 0);
+	bgl::blCompileShaderARB(tmpFrag);
+	bgl::blGetObjectParameterivARB(tmpFrag, GL_OBJECT_INFO_LOG_LENGTH_ARB, &fraglen);
 	if(fraglen >0 && !PrintInfo(fraglen,tmpFrag, "Fragment Shader") ){
 		spit("Fragment shader failed");
-		glDeleteObjectARB(tmpVert);
-		glDeleteObjectARB(tmpFrag);
-		glDeleteObjectARB(tmpProg);
+		bgl::blDeleteObjectARB(tmpVert);
+		bgl::blDeleteObjectARB(tmpFrag);
+		bgl::blDeleteObjectARB(tmpProg);
 		mOk	= 0;
 		return false;
 	}
 
 	// set compiled vert/frag shader & link
-	glAttachObjectARB(tmpProg, tmpVert);
-	glAttachObjectARB(tmpProg, tmpFrag);
-	glLinkProgramARB(tmpProg);
+	bgl::blAttachObjectARB(tmpProg, tmpVert);
+	bgl::blAttachObjectARB(tmpProg, tmpFrag);
+	bgl::blLinkProgramARB(tmpProg);
 
-	glGetObjectParameterivARB(tmpProg, GL_OBJECT_INFO_LOG_LENGTH_ARB, &proglen);
+	bgl::blGetObjectParameterivARB(tmpProg, GL_OBJECT_INFO_LOG_LENGTH_ARB, &proglen);
 	if(proglen > 0){
 		PrintInfo(proglen,tmpProg, "GLSL Shader");
 	}
 	else{
 		spit("Program failed");
-		glDeleteObjectARB(tmpVert);
-		glDeleteObjectARB(tmpFrag);
-		glDeleteObjectARB(tmpProg);
+		bgl::blDeleteObjectARB(tmpVert);
+		bgl::blDeleteObjectARB(tmpFrag);
+		bgl::blDeleteObjectARB(tmpProg);
 		mOk	= 0;
 		return false;
 	}
@@ -175,7 +175,7 @@ bool BL_Shader::PrintInfo(int len, unsigned int handle, const char *type)
 		spit("BL_Shader::PrintInfo() MEM_mallocN failed");
 		return false;
 	}
-	glGetInfoLogARB(handle, len, &numchars, log);
+	bgl::blGetInfoLogARB(handle, len, &numchars, log);
 	
 	if(numchars >0){
 		spit(type);
@@ -332,14 +332,14 @@ KX_PYMETHODDEF_DOC( BL_Shader, setSource," setSource(vertexProgram, fragmentProg
 		vertProg = v;
 		fragProg = f;
 		if( LinkProgram() ) {
-			glUseProgramObjectARB( mShader );
+			bgl::blUseProgramObjectARB( mShader );
 			mUse = apply!=0;
 			Py_Return;
 		}
 		vertProg = 0;
 		fragProg = 0;
 		mUse = 0;
-		glUseProgramObjectARB( 0 );
+		bgl::blUseProgramObjectARB( 0 );
 		PyErr_Format(PyExc_ValueError, "GLSL Error");
 	}
 	return NULL;
@@ -352,9 +352,9 @@ KX_PYMETHODDEF_DOC( BL_Shader, setSource," setSource(vertexProgram, fragmentProg
 KX_PYMETHODDEF_DOC( BL_Shader, delSource, "delSource( )" )
 {
 #ifdef GL_ARB_shader_objects
-	glDeleteObjectARB(mShader);
-	glDeleteObjectARB(mFrag);
-	glDeleteObjectARB(mVert);
+	bgl::blDeleteObjectARB(mShader);
+	bgl::blDeleteObjectARB(mFrag);
+	bgl::blDeleteObjectARB(mVert);
 	mShader		= 0;
 	mFrag		= 0;
 	mVert		= 0;
@@ -362,7 +362,7 @@ KX_PYMETHODDEF_DOC( BL_Shader, delSource, "delSource( )" )
 	fragProg	= 0;
 	mOk			= 0;
 	mUse		= 0;
-	glUseProgramObjectARB(0);
+	bgl::blUseProgramObjectARB(0);
 #endif
 	Py_Return;
 
@@ -395,8 +395,8 @@ KX_PYMETHODDEF_DOC( BL_Shader, validate, "validate()")
 	}
 
 	int stat = 0;
-	glValidateProgramARB(mShader);
-	glGetObjectParameterivARB(mShader, GL_OBJECT_VALIDATE_STATUS_ARB, &stat);
+	bgl::blValidateProgramARB(mShader);
+	bgl::blGetObjectParameterivARB(mShader, GL_OBJECT_VALIDATE_STATUS_ARB, &stat);
 
 	return PyInt_FromLong((stat!=0));
 #else
@@ -417,7 +417,7 @@ KX_PYMETHODDEF_DOC( BL_Shader, setSampler, "setSampler(name, index)" )
 			PyErr_Format(PyExc_ValueError, "invalid shader object");
 			return NULL;
 		}
-		int loc= glGetUniformLocationARB(mShader, uniform);
+		int loc= bgl::blGetUniformLocationARB(mShader, uniform);
 		if( loc==-1 )
 		{
 			spit("Invalid uniform value: " << uniform << ".");
@@ -463,15 +463,15 @@ KX_PYMETHODDEF_DOC( BL_Shader, setUniform1f, "setUniform1f(name, fx)" )
 			PyErr_Format(PyExc_ValueError, "invalid shader object");
 			return NULL;
 		}
-		int loc= glGetUniformLocationARB(mShader, uniform);
+		int loc= bgl::blGetUniformLocationARB(mShader, uniform);
 		if( loc==-1 )
 		{
 			spit("Invalid uniform value: " << uniform << ".");
 			Py_Return;
 		}else
 		{
-			glUseProgramObjectARB( mShader );
-			glUniform1fARB( loc, value );
+			bgl::blUseProgramObjectARB( mShader );
+			bgl::blUniform1fARB( loc, value );
 			Py_Return;
 		}
 
@@ -495,15 +495,15 @@ KX_PYMETHODDEF_DOC( BL_Shader, setUniform2f , "setUniform2f(name, fx, fy)")
 			PyErr_Format(PyExc_ValueError, "invalid shader object");
 			return NULL;
 		}
-		int loc= glGetUniformLocationARB(mShader , uniform);
+		int loc= bgl::blGetUniformLocationARB(mShader , uniform);
 		if( loc==-1 )
 		{
 			spit("Invalid uniform value: " << uniform << ".");
 			Py_Return;
 		}else
 		{
-			glUseProgramObjectARB( mShader );
-			glUniform2fARB(loc, array[0],array[1] );
+			bgl::blUseProgramObjectARB( mShader );
+			bgl::blUniform2fARB(loc, array[0],array[1] );
 			Py_Return;
 		}
 
@@ -527,15 +527,15 @@ KX_PYMETHODDEF_DOC( BL_Shader, setUniform3f, "setUniform3f(name, fx,fy,fz) ")
 			PyErr_Format(PyExc_ValueError, "invalid shader object");
 			return NULL;
 		}
-		int loc= glGetUniformLocationARB(mShader , uniform);
+		int loc= bgl::blGetUniformLocationARB(mShader , uniform);
 		if( loc==-1 )
 		{
 			spit("Invalid uniform value: " << uniform << ".");
 			Py_Return;
 		}else
 		{
-			glUseProgramObjectARB(mShader);
-			glUniform3fARB(loc, array[0],array[1],array[2]);
+			bgl::blUseProgramObjectARB(mShader);
+			bgl::blUniform3fARB(loc, array[0],array[1],array[2]);
 			Py_Return;
 		}
 
@@ -559,15 +559,15 @@ KX_PYMETHODDEF_DOC( BL_Shader, setUniform4f, "setUniform4f(name, fx,fy,fz, fw) "
 			PyErr_Format(PyExc_ValueError, "invalid shader object");
 			return NULL;
 		}
-		int loc= glGetUniformLocationARB(mShader , uniform);
+		int loc= bgl::blGetUniformLocationARB(mShader , uniform);
 		if( loc==-1 )
 		{
 			spit("Invalid uniform value: " << uniform << ".");
 			Py_Return;
 		}else
 		{
-			glUseProgramObjectARB(mShader);
-			glUniform4fARB(loc, array[0],array[1],array[2], array[3]);
+			bgl::blUseProgramObjectARB(mShader);
+			bgl::blUniform4fARB(loc, array[0],array[1],array[2], array[3]);
 			Py_Return;
 		}
 	}
@@ -590,15 +590,15 @@ KX_PYMETHODDEF_DOC( BL_Shader, setUniform1i, "setUniform1i(name, ix)" )
 			PyErr_Format(PyExc_ValueError, "invalid shader object");
 			return NULL;
 		}
-		int loc= glGetUniformLocationARB(mShader, uniform);
+		int loc= bgl::blGetUniformLocationARB(mShader, uniform);
 		if( loc==-1 )
 		{
 			spit("Invalid uniform value: " << uniform << ".");
 			Py_Return;
 		}else
 		{
-			glUseProgramObjectARB( mShader );
-			glUniform1iARB( loc, value );
+			bgl::blUseProgramObjectARB( mShader );
+			bgl::blUniform1iARB( loc, value );
 			Py_Return;
 		}
 	}
@@ -621,15 +621,15 @@ KX_PYMETHODDEF_DOC( BL_Shader, setUniform2i , "setUniform2i(name, ix, iy)")
 			PyErr_Format(PyExc_ValueError, "invalid shader object");
 			return NULL;
 		}
-		int loc= glGetUniformLocationARB(mShader , uniform);
+		int loc= bgl::blGetUniformLocationARB(mShader , uniform);
 		if( loc==-1 )
 		{
 			spit("Invalid uniform value: " << uniform << ".");
 			Py_Return;
 		}else
 		{
-			glUseProgramObjectARB( mShader );
-			glUniform2iARB(loc, array[0],array[1] );
+			bgl::blUseProgramObjectARB( mShader );
+			bgl::blUniform2iARB(loc, array[0],array[1] );
 			Py_Return;
 		}
 	}
@@ -652,15 +652,15 @@ KX_PYMETHODDEF_DOC( BL_Shader, setUniform3i, "setUniform3i(name, ix,iy,iz) ")
 			PyErr_Format(PyExc_ValueError, "invalid shader object");
 			return NULL;
 		}
-		int loc= glGetUniformLocationARB(mShader , uniform);
+		int loc= bgl::blGetUniformLocationARB(mShader , uniform);
 		if( loc==-1 )
 		{
 			spit("Invalid uniform value: " << uniform << ".");
 			Py_Return;
 		}else
 		{
-			glUseProgramObjectARB(mShader);
-			glUniform3iARB(loc, array[0],array[1],array[2]);
+			bgl::blUseProgramObjectARB(mShader);
+			bgl::blUniform3iARB(loc, array[0],array[1],array[2]);
 			Py_Return;
 		}
 	}
@@ -682,15 +682,15 @@ KX_PYMETHODDEF_DOC( BL_Shader, setUniform4i, "setUniform4i(name, ix,iy,iz, iw) "
 			PyErr_Format(PyExc_ValueError, "invalid shader object");
 			return NULL;
 		}
-		int loc= glGetUniformLocationARB(mShader , uniform);
+		int loc= bgl::blGetUniformLocationARB(mShader , uniform);
 		if( loc==-1 )
 		{
 			spit("Invalid uniform value: " << uniform << ".");
 			Py_Return;
 		}else
 		{
-			glUseProgramObjectARB(mShader);
-			glUniform4iARB(loc, array[0],array[1],array[2], array[3]);
+			bgl::blUseProgramObjectARB(mShader);
+			bgl::blUniform4iARB(loc, array[0],array[1],array[2], array[3]);
 			Py_Return;
 		}
 	}
@@ -714,7 +714,7 @@ KX_PYMETHODDEF_DOC( BL_Shader, setUniformfv , "setUniformfv( float (list2 or lis
 			PyErr_Format(PyExc_ValueError, "invalid shader object");
 			return NULL;
 		}
-		int loc= glGetUniformLocationARB(mShader , uniform);
+		int loc= bgl::blGetUniformLocationARB(mShader , uniform);
 		if( loc==-1 )
 		{
 			spit("Invalid uniform value: " << uniform << ".");
@@ -735,20 +735,20 @@ KX_PYMETHODDEF_DOC( BL_Shader, setUniformfv , "setUniformfv( float (list2 or lis
 				{
 				case 2:
 					{
-						glUseProgramObjectARB(mShader);
-						glUniform2fARB(loc, array_data[0],array_data[1]);
+						bgl::blUseProgramObjectARB(mShader);
+						bgl::blUniform2fARB(loc, array_data[0],array_data[1]);
 						Py_Return;
 					} break;
 				case 3:
 					{
-						glUseProgramObjectARB(mShader);
-						glUniform3fARB(loc, array_data[0],array_data[1], array_data[2]);
+						bgl::blUseProgramObjectARB(mShader);
+						bgl::blUniform3fARB(loc, array_data[0],array_data[1], array_data[2]);
 						Py_Return;
 					}break;
 				case 4:
 					{
-						glUseProgramObjectARB(mShader);
-						glUniform4fARB(loc, array_data[0],array_data[1], array_data[2], array_data[3]);
+						bgl::blUseProgramObjectARB(mShader);
+						bgl::blUniform4fARB(loc, array_data[0],array_data[1], array_data[2], array_data[3]);
 						Py_Return;
 					}break;
 				default:
@@ -781,7 +781,7 @@ KX_PYMETHODDEF_DOC( BL_Shader, setUniformiv, "setUniformiv( int (list2 or list3
 			PyErr_Format(PyExc_ValueError, "invalid shader object");
 			return NULL;
 		}
-		int loc= glGetUniformLocationARB(mShader , uniform);
+		int loc= bgl::blGetUniformLocationARB(mShader , uniform);
 		if( loc==-1 )
 		{
 			spit("Invalid uniform value: " << uniform << ".");
@@ -802,20 +802,20 @@ KX_PYMETHODDEF_DOC( BL_Shader, setUniformiv, "setUniformiv( int (list2 or list3
 				{
 				case 2:
 					{
-						glUseProgramObjectARB(mShader);
-						glUniform2iARB(loc, array_data[0],array_data[1]);
+						bgl::blUseProgramObjectARB(mShader);
+						bgl::blUniform2iARB(loc, array_data[0],array_data[1]);
 						Py_Return;
 					} break;
 				case 3:
 					{
-						glUseProgramObjectARB(mShader);
-						glUniform3iARB(loc, array_data[0],array_data[1], array_data[2]);
+						bgl::blUseProgramObjectARB(mShader);
+						bgl::blUniform3iARB(loc, array_data[0],array_data[1], array_data[2]);
 						Py_Return;
 					}break;
 				case 4:
 					{
-						glUseProgramObjectARB(mShader);
-						glUniform4iARB(loc, array_data[0],array_data[1], array_data[2], array_data[3]);
+						bgl::blUseProgramObjectARB(mShader);
+						bgl::blUniform4iARB(loc, array_data[0],array_data[1], array_data[2], array_data[3]);
 						Py_Return;
 					}break;
 				default:
@@ -855,7 +855,7 @@ KX_PYMETHODDEF_DOC( BL_Shader, setUniformMatrix4,
 			PyErr_Format(PyExc_ValueError, "invalid shader object");
 			return NULL;
 		}
-		int loc= glGetUniformLocationARB(mShader , uniform);
+		int loc= bgl::blGetUniformLocationARB(mShader , uniform);
 		if( loc==-1 )
 		{
 			spit("Invalid uniform value: " << uniform << ".");
@@ -868,8 +868,8 @@ KX_PYMETHODDEF_DOC( BL_Shader, setUniformMatrix4,
 				if (PyMatTo(matrix, mat))
 				{
 					mat.getValue(matr);
-					glUseProgramObjectARB(mShader);
-					glUniformMatrix4fvARB(loc, 1, (transp!=0)?GL_TRUE:GL_FALSE, matr);
+					bgl::blUseProgramObjectARB(mShader);
+					bgl::blUniformMatrix4fvARB(loc, 1, (transp!=0)?GL_TRUE:GL_FALSE, matr);
 					Py_Return;
 				}
 			}
@@ -902,7 +902,7 @@ KX_PYMETHODDEF_DOC( BL_Shader, setUniformMatrix3,
 			PyErr_Format(PyExc_ValueError, "invalid shader object");
 			return NULL;
 		}
-		int loc= glGetUniformLocationARB(mShader , uniform);
+		int loc= bgl::blGetUniformLocationARB(mShader , uniform);
 		if( loc==-1 )
 		{
 			spit("Invalid uniform value: " << uniform << ".");
@@ -915,8 +915,8 @@ KX_PYMETHODDEF_DOC( BL_Shader, setUniformMatrix3,
 				if (PyMatTo(matrix, mat))
 				{
 					mat.getValue(matr);
-					glUseProgramObjectARB(mShader);
-					glUniformMatrix3fvARB(loc, 1, (transp!=0)?GL_TRUE:GL_FALSE, matr);
+					bgl::blUseProgramObjectARB(mShader);
+					bgl::blUniformMatrix3fvARB(loc, 1, (transp!=0)?GL_TRUE:GL_FALSE, matr);
 					Py_Return;
 				}
 			}
diff --git a/source/gameengine/Ketsji/KX_BlenderMaterial.cpp b/source/gameengine/Ketsji/KX_BlenderMaterial.cpp
index ebf040d3c5d..5a41328f489 100644
--- a/source/gameengine/Ketsji/KX_BlenderMaterial.cpp
+++ b/source/gameengine/Ketsji/KX_BlenderMaterial.cpp
@@ -139,7 +139,7 @@ void KX_BlenderMaterial::OnConstruction()
 
 	int i;
 	for(i=0; i<mMaterial->num_enabled; i++) {
-	glActiveTextureARB(GL_TEXTURE0_ARB+i);
+	bgl::blActiveTextureARB(GL_TEXTURE0_ARB+i);
 		#ifdef GL_ARB_texture_cube_map
 		if( mMaterial->mapping[i].mapping & USEENV ) {
 			if(!RAS_EXT_support._ARB_texture_cube_map) {
@@ -180,14 +180,14 @@ void KX_BlenderMaterial::OnExit()
 	if( RAS_EXT_support._ARB_shader_objects && mShader ) {
 		 //note, the shader here is allocated, per unique material
 		 //and this function is called per face
-		glUseProgramObjectARB(0);
+		bgl::blUseProgramObjectARB(0);
 		delete mShader;
 		mShader = 0;
 	}
 	#endif //GL_ARB_shader_objects
 
 	for(int i=0; i<mMaterial->num_enabled; i++) {
-		glActiveTextureARB(GL_TEXTURE0_ARB+i);
+		bgl::blActiveTextureARB(GL_TEXTURE0_ARB+i);
 
 		mTextures[i].DeleteTex();
 
@@ -213,7 +213,7 @@ void KX_BlenderMaterial::OnExit()
 		gTextureDict = 0;
 	}*/
 
-	glActiveTextureARB(GL_TEXTURE0_ARB);
+	bgl::blActiveTextureARB(GL_TEXTURE0_ARB);
 
 	#ifdef GL_ARB_texture_cube_map
 	if(RAS_EXT_support._ARB_texture_cube_map)
@@ -238,7 +238,7 @@ void KX_BlenderMaterial::DisableTexData()
 	#ifdef GL_ARB_multitexture
 	int i=(MAXTEX>=bgl::max_texture_units?bgl::max_texture_units:MAXTEX)-1;
 	for(; i>=0; i--) {
-		glActiveTextureARB(GL_TEXTURE0_ARB+i);
+		bgl::blActiveTextureARB(GL_TEXTURE0_ARB+i);
 		glMatrixMode(GL_TEXTURE);
 		glLoadIdentity();
 		glMatrixMode(GL_MODELVIEW);
@@ -268,13 +268,13 @@ void KX_BlenderMaterial::setShaderData( bool enable )
 	int i;
 	if( !enable || !mShader->Ok() ) {
 		// frame cleanup.
-		glUseProgramObjectARB( 0 );
+		bgl::blUseProgramObjectARB( 0 );
 		DisableTexData();
 		return;
 	}
 
 	DisableTexData();
-	glUseProgramObjectARB( mShader->GetProg() );
+	bgl::blUseProgramObjectARB( mShader->GetProg() );
 	
 	// for each enabled unit
 	for(i=0; i<mMaterial->num_enabled; i++) {
@@ -282,7 +282,7 @@ void KX_BlenderMaterial::setShaderData( bool enable )
 		const uSampler *samp = mShader->getSampler(i);
 		if( samp->loc == -1 || samp->glTexture == 0 ) continue;
 
-		glActiveTextureARB(GL_TEXTURE0_ARB+i);
+		bgl::blActiveTextureARB(GL_TEXTURE0_ARB+i);
 
 		#ifdef GL_ARB_texture_cube_map
 		if( mMaterial->mapping[i].mapping &USEENV ) {
@@ -297,7 +297,7 @@ void KX_BlenderMaterial::setShaderData( bool enable )
 		}
 		#endif//GL_ARB_texture_cube_map
 		// use a sampler
-		glUniform1iARB(samp->loc, i );
+		bgl::blUniform1iARB(samp->loc, i );
 	}
 	glDisable(GL_BLEND);
 
@@ -314,7 +314,7 @@ void KX_BlenderMaterial::setTexData( bool enable )
 	#ifdef GL_ARB_shader_objects
 	if(RAS_EXT_support._ARB_shader_objects) {
 		// switch back to fixed func
-		glUseProgramObjectARB( 0 );
+		bgl::blUseProgramObjectARB( 0 );
 	}
 	#endif//GL_ARB_shader_objects
 
@@ -336,7 +336,7 @@ void KX_BlenderMaterial::setTexData( bool enable )
 		// no material connected to the object
 		if( mTextures[0] ) {
 			if( !mTextures[0].Ok() ) return;
-			glActiveTextureARB(GL_TEXTURE0_ARB);
+			bgl::blActiveTextureARB(GL_TEXTURE0_ARB);
 			glBindTexture( GL_TEXTURE_2D, mTextures[0] );	
 			glEnable(GL_TEXTURE_2D);
 			setTextureEnvironment( -1 ); // modulate
@@ -352,7 +352,7 @@ void KX_BlenderMaterial::setTexData( bool enable )
 	for(i=0; (i<mMaterial->num_enabled); i++) {
 		if( !mTextures[i].Ok() ) continue;
 
-		glActiveTextureARB(GL_TEXTURE0_ARB+i);
+		bgl::blActiveTextureARB(GL_TEXTURE0_ARB+i);
 
 		#ifdef GL_ARB_texture_cube_map
 		// use environment maps
@@ -548,7 +548,7 @@ KX_BlenderMaterial::Activate(
 			return dopass;
 		}
 		else {
-			glUseProgramObjectARB( 0 );
+			bgl::blUseProgramObjectARB( 0 );
 			mPass = 0;
 			dopass = false;
 			return dopass;
diff --git a/source/gameengine/Rasterizer/RAS_OpenGLRasterizer/RAS_GLExtensionManager.cpp b/source/gameengine/Rasterizer/RAS_OpenGLRasterizer/RAS_GLExtensionManager.cpp
index 344fdbbf164..82a3f23dcf2 100644
--- a/source/gameengine/Rasterizer/RAS_OpenGLRasterizer/RAS_GLExtensionManager.cpp
+++ b/source/gameengine/Rasterizer/RAS_OpenGLRasterizer/RAS_GLExtensionManager.cpp
@@ -322,88 +322,88 @@ BL_EXTInfo RAS_EXT_support;
 
 #ifdef GL_ARB_multitexture
 int max_texture_units = 2;
-PFNGLACTIVETEXTUREARBPROC glActiveTextureARB;
-PFNGLCLIENTACTIVETEXTUREARBPROC glClientActiveTextureARB;
-PFNGLMULTITEXCOORD1DARBPROC glMultiTexCoord1dARB;
-PFNGLMULTITEXCOORD1DVARBPROC glMultiTexCoord1dvARB;
-PFNGLMULTITEXCOORD1FARBPROC glMultiTexCoord1fARB;
-PFNGLMULTITEXCOORD1FVARBPROC glMultiTexCoord1fvARB;
-PFNGLMULTITEXCOORD1IARBPROC glMultiTexCoord1iARB;
-PFNGLMULTITEXCOORD1IVARBPROC glMultiTexCoord1ivARB;
-PFNGLMULTITEXCOORD1SARBPROC glMultiTexCoord1sARB;
-PFNGLMULTITEXCOORD1SVARBPROC glMultiTexCoord1svARB;
-PFNGLMULTITEXCOORD2DARBPROC glMultiTexCoord2dARB;
-PFNGLMULTITEXCOORD2DVARBPROC glMultiTexCoord2dvARB;
-PFNGLMULTITEXCOORD2FARBPROC glMultiTexCoord2fARB;
-PFNGLMULTITEXCOORD2FVARBPROC glMultiTexCoord2fvARB;
-PFNGLMULTITEXCOORD2IARBPROC glMultiTexCoord2iARB;
-PFNGLMULTITEXCOORD2IVARBPROC glMultiTexCoord2ivARB;
-PFNGLMULTITEXCOORD2SARBPROC glMultiTexCoord2sARB;
-PFNGLMULTITEXCOORD2SVARBPROC glMultiTexCoord2svARB;
-PFNGLMULTITEXCOORD3DARBPROC glMultiTexCoord3dARB;
-PFNGLMULTITEXCOORD3DVARBPROC glMultiTexCoord3dvARB;
-PFNGLMULTITEXCOORD3FARBPROC glMultiTexCoord3fARB;
-PFNGLMULTITEXCOORD3FVARBPROC glMultiTexCoord3fvARB;
-PFNGLMULTITEXCOORD3IARBPROC glMultiTexCoord3iARB;
-PFNGLMULTITEXCOORD3IVARBPROC glMultiTexCoord3ivARB;
-PFNGLMULTITEXCOORD3SARBPROC glMultiTexCoord3sARB;
-PFNGLMULTITEXCOORD3SVARBPROC glMultiTexCoord3svARB;
-PFNGLMULTITEXCOORD4DARBPROC glMultiTexCoord4dARB;
-PFNGLMULTITEXCOORD4DVARBPROC glMultiTexCoord4dvARB;
-PFNGLMULTITEXCOORD4FARBPROC glMultiTexCoord4fARB;
-PFNGLMULTITEXCOORD4FVARBPROC glMultiTexCoord4fvARB;
-PFNGLMULTITEXCOORD4IARBPROC glMultiTexCoord4iARB;
-PFNGLMULTITEXCOORD4IVARBPROC glMultiTexCoord4ivARB;
-PFNGLMULTITEXCOORD4SARBPROC glMultiTexCoord4sARB;
-PFNGLMULTITEXCOORD4SVARBPROC glMultiTexCoord4svARB;
+ PFNGLACTIVETEXTUREARBPROC blActiveTextureARB;
+ PFNGLCLIENTACTIVETEXTUREARBPROC blClientActiveTextureARB;
+ PFNGLMULTITEXCOORD1DARBPROC blMultiTexCoord1dARB;
+ PFNGLMULTITEXCOORD1DVARBPROC blMultiTexCoord1dvARB;
+ PFNGLMULTITEXCOORD1FARBPROC blMultiTexCoord1fARB;
+ PFNGLMULTITEXCOORD1FVARBPROC blMultiTexCoord1fvARB;
+ PFNGLMULTITEXCOORD1IARBPROC blMultiTexCoord1iARB;
+ PFNGLMULTITEXCOORD1IVARBPROC blMultiTexCoord1ivARB;
+ PFNGLMULTITEXCOORD1SARBPROC blMultiTexCoord1sARB;
+ PFNGLMULTITEXCOORD1SVARBPROC blMultiTexCoord1svARB;
+ PFNGLMULTITEXCOORD2DARBPROC blMultiTexCoord2dARB;
+ PFNGLMULTITEXCOORD2DVARBPROC blMultiTexCoord2dvARB;
+ PFNGLMULTITEXCOORD2FARBPROC blMultiTexCoord2fARB;
+ PFNGLMULTITEXCOORD2FVARBPROC blMultiTexCoord2fvARB;
+ PFNGLMULTITEXCOORD2IARBPROC blMultiTexCoord2iARB;
+ PFNGLMULTITEXCOORD2IVARBPROC blMultiTexCoord2ivARB;
+ PFNGLMULTITEXCOORD2SARBPROC blMultiTexCoord2sARB;
+ PFNGLMULTITEXCOORD2SVARBPROC blMultiTexCoord2svARB;
+ PFNGLMULTITEXCOORD3DARBPROC blMultiTexCoord3dARB;
+ PFNGLMULTITEXCOORD3DVARBPROC blMultiTexCoord3dvARB;
+ PFNGLMULTITEXCOORD3FARBPROC blMultiTexCoord3fARB;
+ PFNGLMULTITEXCOORD3FVARBPROC blMultiTexCoord3fvARB;
+ PFNGLMULTITEXCOORD3IARBPROC blMultiTexCoord3iARB;
+ PFNGLMULTITEXCOORD3IVARBPROC blMultiTexCoord3ivARB;
+ PFNGLMULTITEXCOORD3SARBPROC blMultiTexCoord3sARB;
+ PFNGLMULTITEXCOORD3SVARBPROC blMultiTexCoord3svARB;
+ PFNGLMULTITEXCOORD4DARBPROC blMultiTexCoord4dARB;
+ PFNGLMULTITEXCOORD4DVARBPROC blMultiTexCoord4dvARB;
+ PFNGLMULTITEXCOORD4FARBPROC blMultiTexCoord4fARB;
+ PFNGLMULTITEXCOORD4FVARBPROC blMultiTexCoord4fvARB;
+ PFNGLMULTITEXCOORD4IARBPROC blMultiTexCoord4iARB;
+ PFNGLMULTITEXCOORD4IVARBPROC blMultiTexCoord4ivARB;
+ PFNGLMULTITEXCOORD4SARBPROC blMultiTexCoord4sARB;
+ PFNGLMULTITEXCOORD4SVARBPROC blMultiTexCoord4svARB;
 #endif
 
 #ifdef 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;
+ PFNGLDELETEOBJECTARBPROC blDeleteObjectARB;
+ PFNGLGETHANDLEARBPROC blGetHandleARB;
+ PFNGLDETACHOBJECTARBPROC blDetachObjectARB;
+ PFNGLCREATESHADEROBJECTARBPROC blCreateShaderObjectARB;
+ PFNGLSHADERSOURCEARBPROC blShaderSourceARB;
+ PFNGLCOMPILESHADERARBPROC blCompileShaderARB;
+ PFNGLCREATEPROGRAMOBJECTARBPROC blCreateProgramObjectARB;
+ PFNGLATTACHOBJECTARBPROC blAttachObjectARB;
+ PFNGLLINKPROGRAMARBPROC blLinkProgramARB;
+ PFNGLUSEPROGRAMOBJECTARBPROC blUseProgramObjectARB;
+ PFNGLVALIDATEPROGRAMARBPROC blValidateProgramARB;
+ PFNGLUNIFORM1FARBPROC blUniform1fARB;
+ PFNGLUNIFORM2FARBPROC blUniform2fARB;
+ PFNGLUNIFORM3FARBPROC blUniform3fARB;
+ PFNGLUNIFORM4FARBPROC blUniform4fARB;
+ PFNGLUNIFORM1IARBPROC blUniform1iARB;
+ PFNGLUNIFORM2IARBPROC blUniform2iARB;
+ PFNGLUNIFORM3IARBPROC blUniform3iARB;
+ PFNGLUNIFORM4IARBPROC blUniform4iARB;
+ PFNGLUNIFORM1FVARBPROC blUniform1fvARB;
+ PFNGLUNIFORM2FVARBPROC blUniform2fvARB;
+ PFNGLUNIFORM3FVARBPROC blUniform3fvARB;
+ PFNGLUNIFORM4FVARBPROC blUniform4fvARB;
+ PFNGLUNIFORM1IVARBPROC blUniform1ivARB;
+ PFNGLUNIFORM2IVARBPROC blUniform2ivARB;
+ PFNGLUNIFORM3IVARBPROC blUniform3ivARB;
+ PFNGLUNIFORM4IVARBPROC blUniform4ivARB;
+ PFNGLUNIFORMMATRIX2FVARBPROC blUniformMatrix2fvARB;
+ PFNGLUNIFORMMATRIX3FVARBPROC blUniformMatrix3fvARB;
+ PFNGLUNIFORMMATRIX4FVARBPROC blUniformMatrix4fvARB;
+ PFNGLGETOBJECTPARAMETERFVARBPROC blGetObjectParameterfvARB;
+ PFNGLGETOBJECTPARAMETERIVARBPROC blGetObjectParameterivARB;
+ PFNGLGETINFOLOGARBPROC blGetInfoLogARB;
+ PFNGLGETATTACHEDOBJECTSARBPROC blGetAttachedObjectsARB;
+ PFNGLGETUNIFORMLOCATIONARBPROC blGetUniformLocationARB;
+ PFNGLGETACTIVEUNIFORMARBPROC blGetActiveUniformARB;
+ PFNGLGETUNIFORMFVARBPROC blGetUniformfvARB;
+ PFNGLGETUNIFORMIVARBPROC blGetUniformivARB;
+ PFNGLGETSHADERSOURCEARBPROC blGetShaderSourceARB;
 #endif
 
 #ifdef GL_ARB_vertex_shader
-PFNGLBINDATTRIBLOCATIONARBPROC glBindAttribLocationARB;
-PFNGLGETACTIVEATTRIBARBPROC glGetActiveAttribARB;
-PFNGLGETATTRIBLOCATIONARBPROC glGetAttribLocationARB;
+PFNGLBINDATTRIBLOCATIONARBPROC blBindAttribLocationARB;
+PFNGLGETACTIVEATTRIBARBPROC blGetActiveAttribARB;
+PFNGLGETATTRIBLOCATIONARBPROC blGetAttribLocationARB;
 #endif
 
 } // namespace bgl
@@ -464,41 +464,41 @@ static void LinkExtensions()
 #ifdef GL_ARB_multitexture
 	if (QueryExtension("GL_ARB_multitexture"))
 	{
-		bgl::glActiveTextureARB = reinterpret_cast<PFNGLACTIVETEXTUREARBPROC>(bglGetProcAddress((const GLubyte *) "glActiveTextureARB"));
-		bgl::glClientActiveTextureARB = reinterpret_cast<PFNGLCLIENTACTIVETEXTUREARBPROC>(bglGetProcAddress((const GLubyte *) "glClientActiveTextureARB"));
-		bgl::glMultiTexCoord1dARB = reinterpret_cast<PFNGLMULTITEXCOORD1DARBPROC>(bglGetProcAddress((const GLubyte *) "glMultiTexCoord1dARB"));
-		bgl::glMultiTexCoord1dvARB = reinterpret_cast<PFNGLMULTITEXCOORD1DVARBPROC>(bglGetProcAddress((const GLubyte *) "glMultiTexCoord1dvARB"));
-		bgl::glMultiTexCoord1fARB = reinterpret_cast<PFNGLMULTITEXCOORD1FARBPROC>(bglGetProcAddress((const GLubyte *) "glMultiTexCoord1fARB"));
-		bgl::glMultiTexCoord1fvARB = reinterpret_cast<PFNGLMULTITEXCOORD1FVARBPROC>(bglGetProcAddress((const GLubyte *) "glMultiTexCoord1fvARB"));
-		bgl::glMultiTexCoord1iARB = reinterpret_cast<PFNGLMULTITEXCOORD1IARBPROC>(bglGetProcAddress((const GLubyte *) "glMultiTexCoord1iARB"));
-		bgl::glMultiTexCoord1ivARB = reinterpret_cast<PFNGLMULTITEXCOORD1IVARBPROC>(bglGetProcAddress((const GLubyte *) "glMultiTexCoord1ivARB"));
-		bgl::glMultiTexCoord1sARB = reinterpret_cast<PFNGLMULTITEXCOORD1SARBPROC>(bglGetProcAddress((const GLubyte *) "glMultiTexCoord1sARB"));
-		bgl::glMultiTexCoord1svARB = reinterpret_cast<PFNGLMULTITEXCOORD1SVARBPROC>(bglGetProcAddress((const GLubyte *) "glMultiTexCoord1svARB"));
-		bgl::glMultiTexCoord2dARB = reinterpret_cast<PFNGLMULTITEXCOORD2DARBPROC>(bglGetProcAddress((const GLubyte *) "glMultiTexCoord2dARB"));
-		bgl::glMultiTexCoord2dvARB = reinterpret_cast<PFNGLMULTITEXCOORD2DVARBPROC>(bglGetProcAddress((const GLubyte *) "glMultiTexCoord2dvARB"));
-		bgl::glMultiTexCoord2fARB = reinterpret_cast<PFNGLMULTITEXCOORD2FARBPROC>(bglGetProcAddress((const GLubyte *) "glMultiTexCoord2fARB"));
-		bgl::glMultiTexCoord2fvARB = reinterpret_cast<PFNGLMULTITEXCOORD2FVARBPROC>(bglGetProcAddress((const GLubyte *) "glMultiTexCoord2fvARB"));
-		bgl::glMultiTexCoord2iARB = reinterpret_cast<PFNGLMULTITEXCOORD2IARBPROC>(bglGetProcAddress((const GLubyte *) "glMultiTexCoord2iARB"));
-		bgl::glMultiTexCoord2ivARB = reinterpret_cast<PFNGLMULTITEXCOORD2IVARBPROC>(bglGetProcAddress((const GLubyte *) "glMultiTexCoord2ivARB"));
-		bgl::glMultiTexCoord2sARB = reinterpret_cast<PFNGLMULTITEXCOORD2SARBPROC>(bglGetProcAddress((const GLubyte *) "glMultiTexCoord2sARB"));
-		bgl::glMultiTexCoord2svARB = reinterpret_cast<PFNGLMULTITEXCOORD2SVARBPROC>(bglGetProcAddress((const GLubyte *) "glMultiTexCoord2svARB"));
-		bgl::glMultiTexCoord3dARB = reinterpret_cast<PFNGLMULTITEXCOORD3DARBPROC>(bglGetProcAddress((const GLubyte *) "glMultiTexCoord3dARB"));
-		bgl::glMultiTexCoord3dvARB = reinterpret_cast<PFNGLMULTITEXCOORD3DVARBPROC>(bglGetProcAddress((const GLubyte *) "glMultiTexCoord3dvARB"));
-		bgl::glMultiTexCoord3fARB = reinterpret_cast<PFNGLMULTITEXCOORD3FARBPROC>(bglGetProcAddress((const GLubyte *) "glMultiTexCoord3fARB"));
-		bgl::glMultiTexCoord3fvARB = reinterpret_cast<PFNGLMULTITEXCOORD3FVARBPROC>(bglGetProcAddress((const GLubyte *) "glMultiTexCoord3fvARB"));
-		bgl::glMultiTexCoord3iARB = reinterpret_cast<PFNGLMULTITEXCOORD3IARBPROC>(bglGetProcAddress((const GLubyte *) "glMultiTexCoord3iARB"));
-		bgl::glMultiTexCoord3ivARB = reinterpret_cast<PFNGLMULTITEXCOORD3IVARBPROC>(bglGetProcAddress((const GLubyte *) "glMultiTexCoord3ivARB"));
-		bgl::glMultiTexCoord3sARB = reinterpret_cast<PFNGLMULTITEXCOORD3SARBPROC>(bglGetProcAddress((const GLubyte *) "glMultiTexCoord3sARB"));
-		bgl::glMultiTexCoord3svARB = reinterpret_cast<PFNGLMULTITEXCOORD3SVARBPROC>(bglGetProcAddress((const GLubyte *) "glMultiTexCoord3svARB"));
-		bgl::glMultiTexCoord4dARB = reinterpret_cast<PFNGLMULTITEXCOORD4DARBPROC>(bglGetProcAddress((const GLubyte *) "glMultiTexCoord4dARB"));
-		bgl::glMultiTexCoord4dvARB = reinterpret_cast<PFNGLMULTITEXCOORD4DVARBPROC>(bglGetProcAddress((const GLubyte *) "glMultiTexCoord4dvARB"));
-		bgl::glMultiTexCoord4fARB = reinterpret_cast<PFNGLMULTITEXCOORD4FARBPROC>(bglGetProcAddress((const GLubyte *) "glMultiTexCoord4fARB"));
-		bgl::glMultiTexCoord4fvARB = reinterpret_cast<PFNGLMULTITEXCOORD4FVARBPROC>(bglGetProcAddress((const GLubyte *) "glMultiTexCoord4fvARB"));
-		bgl::glMultiTexCoord4iARB = reinterpret_cast<PFNGLMULTITEXCOORD4IARBPROC>(bglGetProcAddress((const GLubyte *) "glMultiTexCoord4iARB"));
-		bgl::glMultiTexCoord4ivARB = reinterpret_cast<PFNGLMULTITEXCOORD4IVARBPROC>(bglGetProcAddress((const GLubyte *) "glMultiTexCoord4ivARB"));
-		bgl::glMultiTexCoord4sARB = reinterpret_cast<PFNGLMULTITEXCOORD4SARBPROC>(bglGetProcAddress((const GLubyte *) "glMultiTexCoord4sARB"));
-		bgl::glMultiTexCoord4svARB = reinterpret_cast<PFNGLMULTITEXCOORD4SVARBPROC>(bglGetProcAddress((const GLubyte *) "glMultiTexCoord4svARB"));
-		if (bgl::glActiveTextureARB && bgl::glClientActiveTextureARB && bgl::glMultiTexCoord1dARB && bgl::glMultiTexCoord1dvARB && bgl::glMultiTexCoord1fARB && bgl::glMultiTexCoord1fvARB && bgl::glMultiTexCoord1iARB && bgl::glMultiTexCoord1ivARB && bgl::glMultiTexCoord1sARB && bgl::glMultiTexCoord1svARB && bgl::glMultiTexCoord2dARB && bgl::glMultiTexCoord2dvARB && bgl::glMultiTexCoord2fARB && bgl::glMultiTexCoord2fvARB && bgl::glMultiTexCoord2iARB && bgl::glMultiTexCoord2ivARB && bgl::glMultiTexCoord2sARB && bgl::glMultiTexCoord2svARB && bgl::glMultiTexCoord3dARB && bgl::glMultiTexCoord3dvARB && bgl::glMultiTexCoord3fARB && bgl::glMultiTexCoord3fvARB && bgl::glMultiTexCoord3iARB && bgl::glMultiTexCoord3ivARB && bgl::glMultiTexCoord3sARB && bgl::glMultiTexCoord3svARB && bgl::glMultiTexCoord4dARB && bgl::glMultiTexCoord4dvARB && bgl::glMultiTexCoord4fARB && bgl::glMultiTexCoord4fvARB && bgl::glMultiTexCoord4iARB && bgl::glMultiTexCoord4ivARB && bgl::glMultiTexCoord4sARB && bgl::glMultiTexCoord4svARB) {
+		bgl::blActiveTextureARB = reinterpret_cast<PFNGLACTIVETEXTUREARBPROC>(bglGetProcAddress((const GLubyte *) "glActiveTextureARB"));
+		bgl::blClientActiveTextureARB = reinterpret_cast<PFNGLCLIENTACTIVETEXTUREARBPROC>(bglGetProcAddress((const GLubyte *) "glClientActiveTextureARB"));
+		bgl::blMultiTexCoord1dARB = reinterpret_cast<PFNGLMULTITEXCOORD1DARBPROC>(bglGetProcAddress((const GLubyte *) "glMultiTexCoord1dARB"));
+		bgl::blMultiTexCoord1dvARB = reinterpret_cast<PFNGLMULTITEXCOORD1DVARBPROC>(bglGetProcAddress((const GLubyte *) "glMultiTexCoord1dvARB"));
+		bgl::blMultiTexCoord1fARB = reinterpret_cast<PFNGLMULTITEXCOORD1FARBPROC>(bglGetProcAddress((const GLubyte *) "glMultiTexCoord1fARB"));
+		bgl::blMultiTexCoord1fvARB = reinterpret_cast<PFNGLMULTITEXCOORD1FVARBPROC>(bglGetProcAddress((const GLubyte *) "glMultiTexCoord1fvARB"));
+		bgl::blMultiTexCoord1iARB = reinterpret_cast<PFNGLMULTITEXCOORD1IARBPROC>(bglGetProcAddress((const GLubyte *) "glMultiTexCoord1iARB"));
+		bgl::blMultiTexCoord1ivARB = reinterpret_cast<PFNGLMULTITEXCOORD1IVARBPROC>(bglGetProcAddress((const GLubyte *) "glMultiTexCoord1ivARB"));
+		bgl::blMultiTexCoord1sARB = reinterpret_cast<PFNGLMULTITEXCOORD1SARBPROC>(bglGetProcAddress((const GLubyte *) "glMultiTexCoord1sARB"));
+		bgl::blMultiTexCoord1svARB = reinterpret_cast<PFNGLMULTITEXCOORD1SVARBPROC>(bglGetProcAddress((const GLubyte *) "glMultiTexCoord1svARB"));
+		bgl::blMultiTexCoord2dARB = reinterpret_cast<PFNGLMULTITEXCOORD2DARBPROC>(bglGetProcAddress((const GLubyte *) "glMultiTexCoord2dARB"));
+		bgl::blMultiTexCoord2dvARB = reinterpret_cast<PFNGLMULTITEXCOORD2DVARBPROC>(bglGetProcAddress((const GLubyte *) "glMultiTexCoord2dvARB"));
+		bgl::blMultiTexCoord2fARB = reinterpret_cast<PFNGLMULTITEXCOORD2FARBPROC>(bglGetProcAddress((const GLubyte *) "glMultiTexCoord2fARB"));
+		bgl::blMultiTexCoord2fvARB = reinterpret_cast<PFNGLMULTITEXCOORD2FVARBPROC>(bglGetProcAddress((const GLubyte *) "glMultiTexCoord2fvARB"));
+		bgl::blMultiTexCoord2iARB = reinterpret_cast<PFNGLMULTITEXCOORD2IARBPROC>(bglGetProcAddress((const GLubyte *) "glMultiTexCoord2iARB"));
+		bgl::blMultiTexCoord2ivARB = reinterpret_cast<PFNGLMULTITEXCOORD2IVARBPROC>(bglGetProcAddress((const GLubyte *) "glMultiTexCoord2ivARB"));
+		bgl::blMultiTexCoord2sARB = reinterpret_cast<PFNGLMULTITEXCOORD2SARBPROC>(bglGetProcAddress((const GLubyte *) "glMultiTexCoord2sARB"));
+		bgl::blMultiTexCoord2svARB = reinterpret_cast<PFNGLMULTITEXCOORD2SVARBPROC>(bglGetProcAddress((const GLubyte *) "glMultiTexCoord2svARB"));
+		bgl::blMultiTexCoord3dARB = reinterpret_cast<PFNGLMULTITEXCOORD3DARBPROC>(bglGetProcAddress((const GLubyte *) "glMultiTexCoord3dARB"));
+		bgl::blMultiTexCoord3dvARB = reinterpret_cast<PFNGLMULTITEXCOORD3DVARBPROC>(bglGetProcAddress((const GLubyte *) "glMultiTexCoord3dvARB"));
+		bgl::blMultiTexCoord3fARB = reinterpret_cast<PFNGLMULTITEXCOORD3FARBPROC>(bglGetProcAddress((const GLubyte *) "glMultiTexCoord3fARB"));
+		bgl::blMultiTexCoord3fvARB = reinterpret_cast<PFNGLMULTITEXCOORD3FVARBPROC>(bglGetProcAddress((const GLubyte *) "glMultiTexCoord3fvARB"));
+		bgl::blMultiTexCoord3iARB = reinterpret_cast<PFNGLMULTITEXCOORD3IARBPROC>(bglGetProcAddress((const GLubyte *) "glMultiTexCoord3iARB"));
+		bgl::blMultiTexCoord3ivARB = reinterpret_cast<PFNGLMULTITEXCOORD3IVARBPROC>(bglGetProcAddress((const GLubyte *) "glMultiTexCoord3ivARB"));
+		bgl::blMultiTexCoord3sARB = reinterpret_cast<PFNGLMULTITEXCOORD3SARBPROC>(bglGetProcAddress((const GLubyte *) "glMultiTexCoord3sARB"));
+		bgl::blMultiTexCoord3svARB = reinterpret_cast<PFNGLMULTITEXCOORD3SVARBPROC>(bglGetProcAddress((const GLubyte *) "glMultiTexCoord3svARB"));
+		bgl::blMultiTexCoord4dARB = reinterpret_cast<PFNGLMULTITEXCOORD4DARBPROC>(bglGetProcAddress((const GLubyte *) "glMultiTexCoord4dARB"));
+		bgl::blMultiTexCoord4dvARB = reinterpret_cast<PFNGLMULTITEXCOORD4DVARBPROC>(bglGetProcAddress((const GLubyte *) "glMultiTexCoord4dvARB"));
+		bgl::blMultiTexCoord4fARB = reinterpret_cast<PFNGLMULTITEXCOORD4FARBPROC>(bglGetProcAddress((const GLubyte *) "glMultiTexCoord4fARB"));
+		bgl::blMultiTexCoord4fvARB = reinterpret_cast<PFNGLMULTITEXCOORD4FVARBPROC>(bglGetProcAddress((const GLubyte *) "glMultiTexCoord4fvARB"));
+		bgl::blMultiTexCoord4iARB = reinterpret_cast<PFNGLMULTITEXCOORD4IARBPROC>(bglGetProcAddress((const GLubyte *) "glMultiTexCoord4iARB"));
+		bgl::blMultiTexCoord4ivARB = reinterpret_cast<PFNGLMULTITEXCOORD4IVARBPROC>(bglGetProcAddress((const GLubyte *) "glMultiTexCoord4ivARB"));
+		bgl::blMultiTexCoord4sARB = reinterpret_cast<PFNGLMULTITEXCOORD4SARBPROC>(bglGetProcAddress((const GLubyte *) "glMultiTexCoord4sARB"));
+		bgl::blMultiTexCoord4svARB = reinterpret_cast<PFNGLMULTITEXCOORD4SVARBPROC>(bglGetProcAddress((const GLubyte *) "glMultiTexCoord4svARB"));
+		if (bgl::blActiveTextureARB && bgl::blClientActiveTextureARB && bgl::blMultiTexCoord1dARB && bgl::blMultiTexCoord1dvARB && bgl::blMultiTexCoord1fARB && bgl::blMultiTexCoord1fvARB && bgl::blMultiTexCoord1iARB && bgl::blMultiTexCoord1ivARB && bgl::blMultiTexCoord1sARB && bgl::blMultiTexCoord1svARB && bgl::blMultiTexCoord2dARB && bgl::blMultiTexCoord2dvARB && bgl::blMultiTexCoord2fARB && bgl::blMultiTexCoord2fvARB && bgl::blMultiTexCoord2iARB && bgl::blMultiTexCoord2ivARB && bgl::blMultiTexCoord2sARB && bgl::blMultiTexCoord2svARB && bgl::blMultiTexCoord3dARB && bgl::blMultiTexCoord3dvARB && bgl::blMultiTexCoord3fARB && bgl::blMultiTexCoord3fvARB && bgl::blMultiTexCoord3iARB && bgl::blMultiTexCoord3ivARB && bgl::blMultiTexCoord3sARB && bgl::blMultiTexCoord3svARB && bgl::blMultiTexCoord4dARB && bgl::blMultiTexCoord4dvARB && bgl::blMultiTexCoord4fARB && bgl::blMultiTexCoord4fvARB && bgl::blMultiTexCoord4iARB && bgl::blMultiTexCoord4ivARB && bgl::blMultiTexCoord4sARB && bgl::blMultiTexCoord4svARB) {
 			EnableExtension(_GL_ARB_multitexture);
 			RAS_EXT_support._ARB_multitexture = 1;
 			if (doDebugMessages)
@@ -512,46 +512,46 @@ static void LinkExtensions()
 #ifdef GL_ARB_shader_objects
 	if (QueryExtension("GL_ARB_shader_objects"))
 	{
-		glDeleteObjectARB = reinterpret_cast<PFNGLDELETEOBJECTARBPROC>(bglGetProcAddress((const GLubyte *) "glDeleteObjectARB"));
-		glGetHandleARB = reinterpret_cast<PFNGLGETHANDLEARBPROC>(bglGetProcAddress((const GLubyte *) "glGetHandleARB"));
-		glDetachObjectARB = reinterpret_cast<PFNGLDETACHOBJECTARBPROC>(bglGetProcAddress((const GLubyte *) "glDetachObjectARB"));
-		glCreateShaderObjectARB = reinterpret_cast<PFNGLCREATESHADEROBJECTARBPROC>(bglGetProcAddress((const GLubyte *) "glCreateShaderObjectARB"));
-		glShaderSourceARB = reinterpret_cast<PFNGLSHADERSOURCEARBPROC>(bglGetProcAddress((const GLubyte *) "glShaderSourceARB"));
-		glCompileShaderARB = reinterpret_cast<PFNGLCOMPILESHADERARBPROC>(bglGetProcAddress((const GLubyte *) "glCompileShaderARB"));
-		glCreateProgramObjectARB = reinterpret_cast<PFNGLCREATEPROGRAMOBJECTARBPROC>(bglGetProcAddress((const GLubyte *) "glCreateProgramObjectARB"));
-		glAttachObjectARB = reinterpret_cast<PFNGLATTACHOBJECTARBPROC>(bglGetProcAddress((const GLubyte *) "glAttachObjectARB"));
-		glLinkProgramARB = reinterpret_cast<PFNGLLINKPROGRAMARBPROC>(bglGetProcAddress((const GLubyte *) "glLinkProgramARB"));
-		glUseProgramObjectARB = reinterpret_cast<PFNGLUSEPROGRAMOBJECTARBPROC>(bglGetProcAddress((const GLubyte *) "glUseProgramObjectARB"));
-		glValidateProgramARB = reinterpret_cast<PFNGLVALIDATEPROGRAMARBPROC>(bglGetProcAddress((const GLubyte *) "glValidateProgramARB"));
-		glUniform1fARB = reinterpret_cast<PFNGLUNIFORM1FARBPROC>(bglGetProcAddress((const GLubyte *) "glUniform1fARB"));
-		glUniform2fARB = reinterpret_cast<PFNGLUNIFORM2FARBPROC>(bglGetProcAddress((const GLubyte *) "glUniform2fARB"));
-		glUniform3fARB = reinterpret_cast<PFNGLUNIFORM3FARBPROC>(bglGetProcAddress((const GLubyte *) "glUniform3fARB"));
-		glUniform4fARB = reinterpret_cast<PFNGLUNIFORM4FARBPROC>(bglGetProcAddress((const GLubyte *) "glUniform4fARB"));
-		glUniform1iARB = reinterpret_cast<PFNGLUNIFORM1IARBPROC>(bglGetProcAddress((const GLubyte *) "glUniform1iARB"));
-		glUniform2iARB = reinterpret_cast<PFNGLUNIFORM2IARBPROC>(bglGetProcAddress((const GLubyte *) "glUniform2iARB"));
-		glUniform3iARB = reinterpret_cast<PFNGLUNIFORM3IARBPROC>(bglGetProcAddress((const GLubyte *) "glUniform3iARB"));
-		glUniform4iARB = reinterpret_cast<PFNGLUNIFORM4IARBPROC>(bglGetProcAddress((const GLubyte *) "glUniform4iARB"));
-		glUniform1fvARB = reinterpret_cast<PFNGLUNIFORM1FVARBPROC>(bglGetProcAddress((const GLubyte *) "glUniform1fvARB"));
-		glUniform2fvARB = reinterpret_cast<PFNGLUNIFORM2FVARBPROC>(bglGetProcAddress((const GLubyte *) "glUniform2fvARB"));
-		glUniform3fvARB = reinterpret_cast<PFNGLUNIFORM3FVARBPROC>(bglGetProcAddress((const GLubyte *) "glUniform3fvARB"));
-		glUniform4fvARB = reinterpret_cast<PFNGLUNIFORM4FVARBPROC>(bglGetProcAddress((const GLubyte *) "glUniform4fvARB"));
-		glUniform1ivARB = reinterpret_cast<PFNGLUNIFORM1IVARBPROC>(bglGetProcAddress((const GLubyte *) "glUniform1ivARB"));
-		glUniform2ivARB = reinterpret_cast<PFNGLUNIFORM2IVARBPROC>(bglGetProcAddress((const GLubyte *) "glUniform2ivARB"));
-		glUniform3ivARB = reinterpret_cast<PFNGLUNIFORM3IVARBPROC>(bglGetProcAddress((const GLubyte *) "glUniform3ivARB"));
-		glUniform4ivARB = reinterpret_cast<PFNGLUNIFORM4IVARBPROC>(bglGetProcAddress((const GLubyte *) "glUniform4ivARB"));
-		glUniformMatrix2fvARB = reinterpret_cast<PFNGLUNIFORMMATRIX2FVARBPROC>(bglGetProcAddress((const GLubyte *) "glUniformMatrix2fvARB"));
-		glUniformMatrix3fvARB = reinterpret_cast<PFNGLUNIFORMMATRIX3FVARBPROC>(bglGetProcAddress((const GLubyte *) "glUniformMatrix3fvARB"));
-		glUniformMatrix4fvARB = reinterpret_cast<PFNGLUNIFORMMATRIX4FVARBPROC>(bglGetProcAddress((const GLubyte *) "glUniformMatrix4fvARB"));
-		glGetObjectParameterfvARB = reinterpret_cast<PFNGLGETOBJECTPARAMETERFVARBPROC>(bglGetProcAddress((const GLubyte *) "glGetObjectParameterfvARB"));
-		glGetObjectParameterivARB = reinterpret_cast<PFNGLGETOBJECTPARAMETERIVARBPROC>(bglGetProcAddress((const GLubyte *) "glGetObjectParameterivARB"));
-		glGetInfoLogARB = reinterpret_cast<PFNGLGETINFOLOGARBPROC>(bglGetProcAddress((const GLubyte *) "glGetInfoLogARB"));
-		glGetAttachedObjectsARB = reinterpret_cast<PFNGLGETATTACHEDOBJECTSARBPROC>(bglGetProcAddress((const GLubyte *) "glGetAttachedObjectsARB"));
-		glGetUniformLocationARB = reinterpret_cast<PFNGLGETUNIFORMLOCATIONARBPROC>(bglGetProcAddress((const GLubyte *) "glGetUniformLocationARB"));
-		glGetActiveUniformARB = reinterpret_cast<PFNGLGETACTIVEUNIFORMARBPROC>(bglGetProcAddress((const GLubyte *) "glGetActiveUniformARB"));
-		glGetUniformfvARB = reinterpret_cast<PFNGLGETUNIFORMFVARBPROC>(bglGetProcAddress((const GLubyte *) "glGetUniformfvARB"));
-		glGetUniformivARB = reinterpret_cast<PFNGLGETUNIFORMIVARBPROC>(bglGetProcAddress((const GLubyte *) "glGetUniformivARB"));
-		glGetShaderSourceARB = reinterpret_cast<PFNGLGETSHADERSOURCEARBPROC>(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) {
+		bgl::blDeleteObjectARB = reinterpret_cast<PFNGLDELETEOBJECTARBPROC>(bglGetProcAddress((const GLubyte *) "glDeleteObjectARB"));
+		bgl::blGetHandleARB = reinterpret_cast<PFNGLGETHANDLEARBPROC>(bglGetProcAddress((const GLubyte *) "glGetHandleARB"));
+		bgl::blDetachObjectARB = reinterpret_cast<PFNGLDETACHOBJECTARBPROC>(bglGetProcAddress((const GLubyte *) "glDetachObjectARB"));
+		bgl::blCreateShaderObjectARB = reinterpret_cast<PFNGLCREATESHADEROBJECTARBPROC>(bglGetProcAddress((const GLubyte *) "glCreateShaderObjectARB"));
+		bgl::blShaderSourceARB = reinterpret_cast<PFNGLSHADERSOURCEARBPROC>(bglGetProcAddress((const GLubyte *) "glShaderSourceARB"));
+		bgl::blCompileShaderARB = reinterpret_cast<PFNGLCOMPILESHADERARBPROC>(bglGetProcAddress((const GLubyte *) "glCompileShaderARB"));
+		bgl::blCreateProgramObjectARB = reinterpret_cast<PFNGLCREATEPROGRAMOBJECTARBPROC>(bglGetProcAddress((const GLubyte *) "glCreateProgramObjectARB"));
+		bgl::blAttachObjectARB = reinterpret_cast<PFNGLATTACHOBJECTARBPROC>(bglGetProcAddress((const GLubyte *) "glAttachObjectARB"));
+		bgl::blLinkProgramARB = reinterpret_cast<PFNGLLINKPROGRAMARBPROC>(bglGetProcAddress((const GLubyte *) "glLinkProgramARB"));
+		bgl::blUseProgramObjectARB = reinterpret_cast<PFNGLUSEPROGRAMOBJECTARBPROC>(bglGetProcAddress((const GLubyte *) "glUseProgramObjectARB"));
+		bgl::blValidateProgramARB = reinterpret_cast<PFNGLVALIDATEPROGRAMARBPROC>(bglGetProcAddress((const GLubyte *) "glValidateProgramARB"));
+		bgl::blUniform1fARB = reinterpret_cast<PFNGLUNIFORM1FARBPROC>(bglGetProcAddress((const GLubyte *) "glUniform1fARB"));
+		bgl::blUniform2fARB = reinterpret_cast<PFNGLUNIFORM2FARBPROC>(bglGetProcAddress((const GLubyte *) "glUniform2fARB"));
+		bgl::blUniform3fARB = reinterpret_cast<PFNGLUNIFORM3FARBPROC>(bglGetProcAddress((const GLubyte *) "glUniform3fARB"));
+		bgl::blUniform4fARB = reinterpret_cast<PFNGLUNIFORM4FARBPROC>(bglGetProcAddress((const GLubyte *) "glUniform4fARB"));
+		bgl::blUniform1iARB = reinterpret_cast<PFNGLUNIFORM1IARBPROC>(bglGetProcAddress((const GLubyte *) "glUniform1iARB"));
+		bgl::blUniform2iARB = reinterpret_cast<PFNGLUNIFORM2IARBPROC>(bglGetProcAddress((const GLubyte *) "glUniform2iARB"));
+		bgl::blUniform3iARB = reinterpret_cast<PFNGLUNIFORM3IARBPROC>(bglGetProcAddress((const GLubyte *) "glUniform3iARB"));
+		bgl::blUniform4iARB = reinterpret_cast<PFNGLUNIFORM4IARBPROC>(bglGetProcAddress((const GLubyte *) "glUniform4iARB"));
+		bgl::blUniform1fvARB = reinterpret_cast<PFNGLUNIFORM1FVARBPROC>(bglGetProcAddress((const GLubyte *) "glUniform1fvARB"));
+		bgl::blUniform2fvARB = reinterpret_cast<PFNGLUNIFORM2FVARBPROC>(bglGetProcAddress((const GLubyte *) "glUniform2fvARB"));
+		bgl::blUniform3fvARB = reinterpret_cast<PFNGLUNIFORM3FVARBPROC>(bglGetProcAddress((const GLubyte *) "glUniform3fvARB"));
+		bgl::blUniform4fvARB = reinterpret_cast<PFNGLUNIFORM4FVARBPROC>(bglGetProcAddress((const GLubyte *) "glUniform4fvARB"));
+		bgl::blUniform1ivARB = reinterpret_cast<PFNGLUNIFORM1IVARBPROC>(bglGetProcAddress((const GLubyte *) "glUniform1ivARB"));
+		bgl::blUniform2ivARB = reinterpret_cast<PFNGLUNIFORM2IVARBPROC>(bglGetProcAddress((const GLubyte *) "glUniform2ivARB"));
+		bgl::blUniform3ivARB = reinterpret_cast<PFNGLUNIFORM3IVARBPROC>(bglGetProcAddress((const GLubyte *) "glUniform3ivARB"));
+		bgl::blUniform4ivARB = reinterpret_cast<PFNGLUNIFORM4IVARBPROC>(bglGetProcAddress((const GLubyte *) "glUniform4ivARB"));
+		bgl::blUniformMatrix2fvARB = reinterpret_cast<PFNGLUNIFORMMATRIX2FVARBPROC>(bglGetProcAddress((const GLubyte *) "glUniformMatrix2fvARB"));
+		bgl::blUniformMatrix3fvARB = reinterpret_cast<PFNGLUNIFORMMATRIX3FVARBPROC>(bglGetProcAddress((const GLubyte *) "glUniformMatrix3fvARB"));
+		bgl::blUniformMatrix4fvARB = reinterpret_cast<PFNGLUNIFORMMATRIX4FVARBPROC>(bglGetProcAddress((const GLubyte *) "glUniformMatrix4fvARB"));
+		bgl::blGetObjectParameterfvARB = reinterpret_cast<PFNGLGETOBJECTPARAMETERFVARBPROC>(bglGetProcAddress((const GLubyte *) "glGetObjectParameterfvARB"));
+		bgl::blGetObjectParameterivARB = reinterpret_cast<PFNGLGETOBJECTPARAMETERIVARBPROC>(bglGetProcAddress((const GLubyte *) "glGetObjectParameterivARB"));
+		bgl::blGetInfoLogARB = reinterpret_cast<PFNGLGETINFOLOGARBPROC>(bglGetProcAddress((const GLubyte *) "glGetInfoLogARB"));
+		bgl::blGetAttachedObjectsARB = reinterpret_cast<PFNGLGETATTACHEDOBJECTSARBPROC>(bglGetProcAddress((const GLubyte *) "glGetAttachedObjectsARB"));
+		bgl::blGetUniformLocationARB = reinterpret_cast<PFNGLGETUNIFORMLOCATIONARBPROC>(bglGetProcAddress((const GLubyte *) "glGetUniformLocationARB"));
+		bgl::blGetActiveUniformARB = reinterpret_cast<PFNGLGETACTIVEUNIFORMARBPROC>(bglGetProcAddress((const GLubyte *) "glGetActiveUniformARB"));
+		bgl::blGetUniformfvARB = reinterpret_cast<PFNGLGETUNIFORMFVARBPROC>(bglGetProcAddress((const GLubyte *) "glGetUniformfvARB"));
+		bgl::blGetUniformivARB = reinterpret_cast<PFNGLGETUNIFORMIVARBPROC>(bglGetProcAddress((const GLubyte *) "glGetUniformivARB"));
+		bgl::blGetShaderSourceARB = reinterpret_cast<PFNGLGETSHADERSOURCEARBPROC>(bglGetProcAddress((const GLubyte *) "glGetShaderSourceARB"));
+		if (bgl::blDeleteObjectARB && bgl::blGetHandleARB && bgl::blDetachObjectARB && bgl::blCreateShaderObjectARB && bgl::blShaderSourceARB && bgl::blCompileShaderARB && bgl::blCreateProgramObjectARB && bgl::blAttachObjectARB && bgl::blLinkProgramARB && bgl::blUseProgramObjectARB && bgl::blValidateProgramARB && bgl::blUniform1fARB && bgl::blUniform2fARB && bgl::blUniform3fARB && bgl::blUniform4fARB && bgl::blUniform1iARB && bgl::blUniform2iARB && bgl::blUniform3iARB && bgl::blUniform4iARB && bgl::blUniform1fvARB && bgl::blUniform2fvARB && bgl::blUniform3fvARB && bgl::blUniform4fvARB && bgl::blUniform1ivARB && bgl::blUniform2ivARB && bgl::blUniform3ivARB && bgl::blUniform4ivARB && bgl::blUniformMatrix2fvARB && bgl::blUniformMatrix3fvARB && bgl::blUniformMatrix4fvARB && bgl::blGetObjectParameterfvARB && bgl::blGetObjectParameterivARB && bgl::blGetInfoLogARB && bgl::blGetAttachedObjectsARB && bgl::blGetUniformLocationARB && bgl::blGetActiveUniformARB && bgl::blGetUniformfvARB && bgl::blGetUniformivARB && bgl::blGetShaderSourceARB) {
 			EnableExtension(_GL_ARB_shader_objects);
 			RAS_EXT_support._ARB_shader_objects =1;
 			if (doDebugMessages)
@@ -565,10 +565,10 @@ static void LinkExtensions()
 #ifdef GL_ARB_vertex_shader
 	if (QueryExtension("GL_ARB_vertex_shader"))
 	{
-		glBindAttribLocationARB = reinterpret_cast<PFNGLBINDATTRIBLOCATIONARBPROC>(bglGetProcAddress((const GLubyte *) "glBindAttribLocationARB"));
-		glGetActiveAttribARB = reinterpret_cast<PFNGLGETACTIVEATTRIBARBPROC>(bglGetProcAddress((const GLubyte *) "glGetActiveAttribARB"));
-		glGetAttribLocationARB = reinterpret_cast<PFNGLGETATTRIBLOCATIONARBPROC>(bglGetProcAddress((const GLubyte *) "glGetAttribLocationARB"));
-		if (glBindAttribLocationARB && glGetActiveAttribARB && glGetAttribLocationARB) {
+		bgl::blBindAttribLocationARB = reinterpret_cast<PFNGLBINDATTRIBLOCATIONARBPROC>(bglGetProcAddress((const GLubyte *) "glBindAttribLocationARB"));
+		bgl::blGetActiveAttribARB = reinterpret_cast<PFNGLGETACTIVEATTRIBARBPROC>(bglGetProcAddress((const GLubyte *) "glGetActiveAttribARB"));
+		bgl::blGetAttribLocationARB = reinterpret_cast<PFNGLGETATTRIBLOCATIONARBPROC>(bglGetProcAddress((const GLubyte *) "glGetAttribLocationARB"));
+		if (bgl::blBindAttribLocationARB && bgl::blGetActiveAttribARB && bgl::blGetAttribLocationARB) {
 			EnableExtension(_GL_ARB_vertex_shader);
 			RAS_EXT_support._ARB_vertex_shader = 1;
 			if (doDebugMessages)
diff --git a/source/gameengine/Rasterizer/RAS_OpenGLRasterizer/RAS_GLExtensionManager.h b/source/gameengine/Rasterizer/RAS_OpenGLRasterizer/RAS_GLExtensionManager.h
index 2d862ea3853..9f81f48b6be 100644
--- a/source/gameengine/Rasterizer/RAS_OpenGLRasterizer/RAS_GLExtensionManager.h
+++ b/source/gameengine/Rasterizer/RAS_OpenGLRasterizer/RAS_GLExtensionManager.h
@@ -379,8 +379,8 @@ namespace bgl
 	void InitExtensions(int debug);
 
 #if defined(PFNGLPNTRIANGLESIATIPROC)
-extern PFNGLPNTRIANGLESIATIPROC glPNTrianglesiATI;
-extern PFNGLPNTRIANGLESFATIPROC glPNTrianglesfATI;
+extern PFNGLPNTRIANGLESIATIPROC blPNTrianglesiATI;
+extern PFNGLPNTRIANGLESFATIPROC blPNTrianglesfATI;
 #endif
 
 
@@ -413,89 +413,89 @@ extern BL_EXTInfo RAS_EXT_support;
 
 #ifdef GL_ARB_multitexture // defined in glext.h now...
 extern int max_texture_units;
-extern PFNGLACTIVETEXTUREARBPROC glActiveTextureARB;
-extern PFNGLCLIENTACTIVETEXTUREARBPROC glClientActiveTextureARB;
-extern PFNGLMULTITEXCOORD1DARBPROC glMultiTexCoord1dARB;
-extern PFNGLMULTITEXCOORD1DVARBPROC glMultiTexCoord1dvARB;
-extern PFNGLMULTITEXCOORD1FARBPROC glMultiTexCoord1fARB;
-extern PFNGLMULTITEXCOORD1FVARBPROC glMultiTexCoord1fvARB;
-extern PFNGLMULTITEXCOORD1IARBPROC glMultiTexCoord1iARB;
-extern PFNGLMULTITEXCOORD1IVARBPROC glMultiTexCoord1ivARB;
-extern PFNGLMULTITEXCOORD1SARBPROC glMultiTexCoord1sARB;
-extern PFNGLMULTITEXCOORD1SVARBPROC glMultiTexCoord1svARB;
-extern PFNGLMULTITEXCOORD2DARBPROC glMultiTexCoord2dARB;
-extern PFNGLMULTITEXCOORD2DVARBPROC glMultiTexCoord2dvARB;
-extern PFNGLMULTITEXCOORD2FARBPROC glMultiTexCoord2fARB;
-extern PFNGLMULTITEXCOORD2FVARBPROC glMultiTexCoord2fvARB;
-extern PFNGLMULTITEXCOORD2IARBPROC glMultiTexCoord2iARB;
-extern PFNGLMULTITEXCOORD2IVARBPROC glMultiTexCoord2ivARB;
-extern PFNGLMULTITEXCOORD2SARBPROC glMultiTexCoord2sARB;
-extern PFNGLMULTITEXCOORD2SVARBPROC glMultiTexCoord2svARB;
-extern PFNGLMULTITEXCOORD3DARBPROC glMultiTexCoord3dARB;
-extern PFNGLMULTITEXCOORD3DVARBPROC glMultiTexCoord3dvARB;
-extern PFNGLMULTITEXCOORD3FARBPROC glMultiTexCoord3fARB;
-extern PFNGLMULTITEXCOORD3FVARBPROC glMultiTexCoord3fvARB;
-extern PFNGLMULTITEXCOORD3IARBPROC glMultiTexCoord3iARB;
-extern PFNGLMULTITEXCOORD3IVARBPROC glMultiTexCoord3ivARB;
-extern PFNGLMULTITEXCOORD3SARBPROC glMultiTexCoord3sARB;
-extern PFNGLMULTITEXCOORD3SVARBPROC glMultiTexCoord3svARB;
-extern PFNGLMULTITEXCOORD4DARBPROC glMultiTexCoord4dARB;
-extern PFNGLMULTITEXCOORD4DVARBPROC glMultiTexCoord4dvARB;
-extern PFNGLMULTITEXCOORD4FARBPROC glMultiTexCoord4fARB;
-extern PFNGLMULTITEXCOORD4FVARBPROC glMultiTexCoord4fvARB;
-extern PFNGLMULTITEXCOORD4IARBPROC glMultiTexCoord4iARB;
-extern PFNGLMULTITEXCOORD4IVARBPROC glMultiTexCoord4ivARB;
-extern PFNGLMULTITEXCOORD4SARBPROC glMultiTexCoord4sARB;
-extern PFNGLMULTITEXCOORD4SVARBPROC glMultiTexCoord4svARB;
+extern PFNGLACTIVETEXTUREARBPROC blActiveTextureARB;
+extern PFNGLCLIENTACTIVETEXTUREARBPROC blClientActiveTextureARB;
+extern PFNGLMULTITEXCOORD1DARBPROC blMultiTexCoord1dARB;
+extern PFNGLMULTITEXCOORD1DVARBPROC blMultiTexCoord1dvARB;
+extern PFNGLMULTITEXCOORD1FARBPROC blMultiTexCoord1fARB;
+extern PFNGLMULTITEXCOORD1FVARBPROC blMultiTexCoord1fvARB;
+extern PFNGLMULTITEXCOORD1IARBPROC blMultiTexCoord1iARB;
+extern PFNGLMULTITEXCOORD1IVARBPROC blMultiTexCoord1ivARB;
+extern PFNGLMULTITEXCOORD1SARBPROC blMultiTexCoord1sARB;
+extern PFNGLMULTITEXCOORD1SVARBPROC blMultiTexCoord1svARB;
+extern PFNGLMULTITEXCOORD2DARBPROC blMultiTexCoord2dARB;
+extern PFNGLMULTITEXCOORD2DVARBPROC blMultiTexCoord2dvARB;
+extern PFNGLMULTITEXCOORD2FARBPROC blMultiTexCoord2fARB;
+extern PFNGLMULTITEXCOORD2FVARBPROC blMultiTexCoord2fvARB;
+extern PFNGLMULTITEXCOORD2IARBPROC blMultiTexCoord2iARB;
+extern PFNGLMULTITEXCOORD2IVARBPROC blMultiTexCoord2ivARB;
+extern PFNGLMULTITEXCOORD2SARBPROC blMultiTexCoord2sARB;
+extern PFNGLMULTITEXCOORD2SVARBPROC blMultiTexCoord2svARB;
+extern PFNGLMULTITEXCOORD3DARBPROC blMultiTexCoord3dARB;
+extern PFNGLMULTITEXCOORD3DVARBPROC blMultiTexCoord3dvARB;
+extern PFNGLMULTITEXCOORD3FARBPROC blMultiTexCoord3fARB;
+extern PFNGLMULTITEXCOORD3FVARBPROC blMultiTexCoord3fvARB;
+extern PFNGLMULTITEXCOORD3IARBPROC blMultiTexCoord3iARB;
+extern PFNGLMULTITEXCOORD3IVARBPROC blMultiTexCoord3ivARB;
+extern PFNGLMULTITEXCOORD3SARBPROC blMultiTexCoord3sARB;
+extern PFNGLMULTITEXCOORD3SVARBPROC blMultiTexCoord3svARB;
+extern PFNGLMULTITEXCOORD4DARBPROC blMultiTexCoord4dARB;
+extern PFNGLMULTITEXCOORD4DVARBPROC blMultiTexCoord4dvARB;
+extern PFNGLMULTITEXCOORD4FARBPROC blMultiTexCoord4fARB;
+extern PFNGLMULTITEXCOORD4FVARBPROC blMultiTexCoord4fvARB;
+extern PFNGLMULTITEXCOORD4IARBPROC blMultiTexCoord4iARB;
+extern PFNGLMULTITEXCOORD4IVARBPROC blMultiTexCoord4ivARB;
+extern PFNGLMULTITEXCOORD4SARBPROC blMultiTexCoord4sARB;
+extern PFNGLMULTITEXCOORD4SVARBPROC blMultiTexCoord4svARB;
 #endif
 
 
 #ifdef 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;
+extern PFNGLDELETEOBJECTARBPROC blDeleteObjectARB;
+extern PFNGLGETHANDLEARBPROC blGetHandleARB;
+extern PFNGLDETACHOBJECTARBPROC blDetachObjectARB;
+extern PFNGLCREATESHADEROBJECTARBPROC blCreateShaderObjectARB;
+extern PFNGLSHADERSOURCEARBPROC blShaderSourceARB;
+extern PFNGLCOMPILESHADERARBPROC blCompileShaderARB;
+extern PFNGLCREATEPROGRAMOBJECTARBPROC blCreateProgramObjectARB;
+extern PFNGLATTACHOBJECTARBPROC blAttachObjectARB;
+extern PFNGLLINKPROGRAMARBPROC blLinkProgramARB;
+extern PFNGLUSEPROGRAMOBJECTARBPROC blUseProgramObjectARB;
+extern PFNGLVALIDATEPROGRAMARBPROC blValidateProgramARB;
+extern PFNGLUNIFORM1FARBPROC blUniform1fARB;
+extern PFNGLUNIFORM2FARBPROC blUniform2fARB;
+extern PFNGLUNIFORM3FARBPROC blUniform3fARB;
+extern PFNGLUNIFORM4FARBPROC blUniform4fARB;
+extern PFNGLUNIFORM1IARBPROC blUniform1iARB;
+extern PFNGLUNIFORM2IARBPROC blUniform2iARB;
+extern PFNGLUNIFORM3IARBPROC blUniform3iARB;
+extern PFNGLUNIFORM4IARBPROC blUniform4iARB;
+extern PFNGLUNIFORM1FVARBPROC blUniform1fvARB;
+extern PFNGLUNIFORM2FVARBPROC blUniform2fvARB;
+extern PFNGLUNIFORM3FVARBPROC blUniform3fvARB;
+extern PFNGLUNIFORM4FVARBPROC blUniform4fvARB;
+extern PFNGLUNIFORM1IVARBPROC blUniform1ivARB;
+extern PFNGLUNIFORM2IVARBPROC blUniform2ivARB;
+extern PFNGLUNIFORM3IVARBPROC blUniform3ivARB;
+extern PFNGLUNIFORM4IVARBPROC blUniform4ivARB;
+extern PFNGLUNIFORMMATRIX2FVARBPROC blUniformMatrix2fvARB;
+extern PFNGLUNIFORMMATRIX3FVARBPROC blUniformMatrix3fvARB;
+extern PFNGLUNIFORMMATRIX4FVARBPROC blUniformMatrix4fvARB;
+extern PFNGLGETOBJECTPARAMETERFVARBPROC blGetObjectParameterfvARB;
+extern PFNGLGETOBJECTPARAMETERIVARBPROC blGetObjectParameterivARB;
+extern PFNGLGETINFOLOGARBPROC blGetInfoLogARB;
+extern PFNGLGETATTACHEDOBJECTSARBPROC blGetAttachedObjectsARB;
+extern PFNGLGETUNIFORMLOCATIONARBPROC blGetUniformLocationARB;
+extern PFNGLGETACTIVEUNIFORMARBPROC blGetActiveUniformARB;
+extern PFNGLGETUNIFORMFVARBPROC blGetUniformfvARB;
+extern PFNGLGETUNIFORMIVARBPROC blGetUniformivARB;
+extern PFNGLGETSHADERSOURCEARBPROC blGetShaderSourceARB;
 #endif
 
 #ifdef GL_ARB_vertex_shader
-extern PFNGLBINDATTRIBLOCATIONARBPROC glBindAttribLocationARB;
-extern PFNGLGETACTIVEATTRIBARBPROC glGetActiveAttribARB;
-extern PFNGLGETATTRIBLOCATIONARBPROC glGetAttribLocationARB;
+extern PFNGLBINDATTRIBLOCATIONARBPROC blBindAttribLocationARB;
+extern PFNGLGETACTIVEATTRIBARBPROC blGetActiveAttribARB;
+extern PFNGLGETATTRIBLOCATIONARBPROC blGetAttribLocationARB;
 #endif
 
 } /* namespace bgl */
diff --git a/source/gameengine/Rasterizer/RAS_OpenGLRasterizer/RAS_OpenGLRasterizer.cpp b/source/gameengine/Rasterizer/RAS_OpenGLRasterizer/RAS_OpenGLRasterizer.cpp
index 7a140fd0f7e..8acd5168bd9 100644
--- a/source/gameengine/Rasterizer/RAS_OpenGLRasterizer/RAS_OpenGLRasterizer.cpp
+++ b/source/gameengine/Rasterizer/RAS_OpenGLRasterizer/RAS_OpenGLRasterizer.cpp
@@ -1265,10 +1265,10 @@ void RAS_OpenGLRasterizer::IndexPrimitivesMulti(
 							if( vertexarray[(indexarray[vindex])].getFlag() & TV_2NDUV &&
 								vertexarray[(indexarray[vindex])].getUnit() == unit ) 
 							{
-								bgl::glMultiTexCoord2fvARB(GL_TEXTURE0_ARB+unit, vertexarray[(indexarray[vindex])].getUV2());
+								bgl::blMultiTexCoord2fvARB(GL_TEXTURE0_ARB+unit, vertexarray[(indexarray[vindex])].getUV2());
 								continue;
 							}
-							bgl::glMultiTexCoord2fvARB(GL_TEXTURE0_ARB+unit, vertexarray[(indexarray[vindex])].getUV1());
+							bgl::blMultiTexCoord2fvARB(GL_TEXTURE0_ARB+unit, vertexarray[(indexarray[vindex])].getUV1());
 						}
 						// ------------------------------
 
@@ -1281,10 +1281,10 @@ void RAS_OpenGLRasterizer::IndexPrimitivesMulti(
 							if( vertexarray[(indexarray[vindex])].getFlag() & TV_2NDUV &&
 								vertexarray[(indexarray[vindex])].getUnit() == unit ) 
 							{
-								bgl::glMultiTexCoord2fvARB(GL_TEXTURE0_ARB+unit, vertexarray[(indexarray[vindex])].getUV2());
+								bgl::blMultiTexCoord2fvARB(GL_TEXTURE0_ARB+unit, vertexarray[(indexarray[vindex])].getUV2());
 								continue;
 							}
-							bgl::glMultiTexCoord2fvARB(GL_TEXTURE0_ARB+unit, vertexarray[(indexarray[vindex])].getUV1());
+							bgl::blMultiTexCoord2fvARB(GL_TEXTURE0_ARB+unit, vertexarray[(indexarray[vindex])].getUV1());
 						}
 						// ------------------------------
 						glVertex3fv(vertexarray[(indexarray[vindex])].getLocalXYZ());
@@ -1296,10 +1296,10 @@ void RAS_OpenGLRasterizer::IndexPrimitivesMulti(
 							if( vertexarray[(indexarray[vindex])].getFlag() & TV_2NDUV &&
 								vertexarray[(indexarray[vindex])].getUnit() == unit ) 
 							{
-								bgl::glMultiTexCoord2fvARB(GL_TEXTURE0_ARB+unit, vertexarray[(indexarray[vindex])].getUV2());
+								bgl::blMultiTexCoord2fvARB(GL_TEXTURE0_ARB+unit, vertexarray[(indexarray[vindex])].getUV2());
 								continue;
 							}
-							bgl::glMultiTexCoord2fvARB(GL_TEXTURE0_ARB+unit, vertexarray[(indexarray[vindex])].getUV1());
+							bgl::blMultiTexCoord2fvARB(GL_TEXTURE0_ARB+unit, vertexarray[(indexarray[vindex])].getUV1());
 						}
 						// ------------------------------
 						glVertex3fv(vertexarray[(indexarray[vindex])].getLocalXYZ());
@@ -1311,10 +1311,10 @@ void RAS_OpenGLRasterizer::IndexPrimitivesMulti(
 							if( vertexarray[(indexarray[vindex])].getFlag() & TV_2NDUV &&
 								vertexarray[(indexarray[vindex])].getUnit() == unit ) 
 							{
-								bgl::glMultiTexCoord2fvARB(GL_TEXTURE0_ARB+unit, vertexarray[(indexarray[vindex])].getUV2());
+								bgl::blMultiTexCoord2fvARB(GL_TEXTURE0_ARB+unit, vertexarray[(indexarray[vindex])].getUV2());
 								continue;
 							}
-							bgl::glMultiTexCoord2fvARB(GL_TEXTURE0_ARB+unit, vertexarray[(indexarray[vindex])].getUV1());
+							bgl::blMultiTexCoord2fvARB(GL_TEXTURE0_ARB+unit, vertexarray[(indexarray[vindex])].getUV1());
 						}
 						// ------------------------------
 						glVertex3fv(vertexarray[(indexarray[vindex])].getLocalXYZ());
@@ -1336,10 +1336,10 @@ void RAS_OpenGLRasterizer::IndexPrimitivesMulti(
 							if( vertexarray[(indexarray[vindex])].getFlag() & TV_2NDUV &&
 								vertexarray[(indexarray[vindex])].getUnit() == unit ) 
 							{
-								bgl::glMultiTexCoord2fvARB(GL_TEXTURE0_ARB+unit, vertexarray[(indexarray[vindex])].getUV2());
+								bgl::blMultiTexCoord2fvARB(GL_TEXTURE0_ARB+unit, vertexarray[(indexarray[vindex])].getUV2());
 								continue;
 							}
-							bgl::glMultiTexCoord2fvARB(GL_TEXTURE0_ARB+unit, vertexarray[(indexarray[vindex])].getUV1());
+							bgl::blMultiTexCoord2fvARB(GL_TEXTURE0_ARB+unit, vertexarray[(indexarray[vindex])].getUV1());
 						}
 						// ------------------------------
 						glVertex3fv(vertexarray[(indexarray[vindex])].getLocalXYZ());
@@ -1352,10 +1352,10 @@ void RAS_OpenGLRasterizer::IndexPrimitivesMulti(
 							if( vertexarray[(indexarray[vindex])].getFlag() & TV_2NDUV &&
 								vertexarray[(indexarray[vindex])].getUnit() == unit ) 
 							{
-								bgl::glMultiTexCoord2fvARB(GL_TEXTURE0_ARB+unit, vertexarray[(indexarray[vindex])].getUV2());
+								bgl::blMultiTexCoord2fvARB(GL_TEXTURE0_ARB+unit, vertexarray[(indexarray[vindex])].getUV2());
 								continue;
 							}
-							bgl::glMultiTexCoord2fvARB(GL_TEXTURE0_ARB+unit, vertexarray[(indexarray[vindex])].getUV1());
+							bgl::blMultiTexCoord2fvARB(GL_TEXTURE0_ARB+unit, vertexarray[(indexarray[vindex])].getUV1());
 						}
 						// ------------------------------
 						glVertex3fv(vertexarray[(indexarray[vindex])].getLocalXYZ());
@@ -1368,10 +1368,10 @@ void RAS_OpenGLRasterizer::IndexPrimitivesMulti(
 							if( vertexarray[(indexarray[vindex])].getFlag() & TV_2NDUV &&
 								vertexarray[(indexarray[vindex])].getUnit() == unit ) 
 							{
-								bgl::glMultiTexCoord2fvARB(GL_TEXTURE0_ARB+unit, vertexarray[(indexarray[vindex])].getUV2());
+								bgl::blMultiTexCoord2fvARB(GL_TEXTURE0_ARB+unit, vertexarray[(indexarray[vindex])].getUV2());
 								continue;
 							}
-							bgl::glMultiTexCoord2fvARB(GL_TEXTURE0_ARB+unit, vertexarray[(indexarray[vindex])].getUV1());
+							bgl::blMultiTexCoord2fvARB(GL_TEXTURE0_ARB+unit, vertexarray[(indexarray[vindex])].getUV1());
 						}
 						// ------------------------------
 
@@ -1385,10 +1385,10 @@ void RAS_OpenGLRasterizer::IndexPrimitivesMulti(
 							if( vertexarray[(indexarray[vindex])].getFlag() & TV_2NDUV &&
 								vertexarray[(indexarray[vindex])].getUnit() == unit ) 
 							{
-								bgl::glMultiTexCoord2fvARB(GL_TEXTURE0_ARB+unit, vertexarray[(indexarray[vindex])].getUV2());
+								bgl::blMultiTexCoord2fvARB(GL_TEXTURE0_ARB+unit, vertexarray[(indexarray[vindex])].getUV2());
 								continue;
 							}
-							bgl::glMultiTexCoord2fvARB(GL_TEXTURE0_ARB+unit, vertexarray[(indexarray[vindex])].getUV1());
+							bgl::blMultiTexCoord2fvARB(GL_TEXTURE0_ARB+unit, vertexarray[(indexarray[vindex])].getUV1());
 						}
 						// ------------------------------
 
@@ -1416,10 +1416,10 @@ void RAS_OpenGLRasterizer::IndexPrimitivesMulti(
 							if( vertexarray[(indexarray[vindex])].getFlag() & TV_2NDUV &&
 								vertexarray[(indexarray[vindex])].getUnit() == unit ) 
 							{
-								bgl::glMultiTexCoord2fvARB(GL_TEXTURE0_ARB+unit, vertexarray[(indexarray[vindex])].getUV2());
+								bgl::blMultiTexCoord2fvARB(GL_TEXTURE0_ARB+unit, vertexarray[(indexarray[vindex])].getUV2());
 								continue;
 							}
-							bgl::glMultiTexCoord2fvARB(GL_TEXTURE0_ARB+unit, vertexarray[(indexarray[vindex])].getUV1());
+							bgl::blMultiTexCoord2fvARB(GL_TEXTURE0_ARB+unit, vertexarray[(indexarray[vindex])].getUV1());
 						}
 						// ------------------------------
 
@@ -1432,10 +1432,10 @@ void RAS_OpenGLRasterizer::IndexPrimitivesMulti(
 							if( vertexarray[(indexarray[vindex])].getFlag() & TV_2NDUV &&
 								vertexarray[(indexarray[vindex])].getUnit() == unit ) 
 							{
-								bgl::glMultiTexCoord2fvARB(GL_TEXTURE0_ARB+unit, vertexarray[(indexarray[vindex])].getUV2());
+								bgl::blMultiTexCoord2fvARB(GL_TEXTURE0_ARB+unit, vertexarray[(indexarray[vindex])].getUV2());
 								continue;
 							}
-							bgl::glMultiTexCoord2fvARB(GL_TEXTURE0_ARB+unit, vertexarray[(indexarray[vindex])].getUV1());
+							bgl::blMultiTexCoord2fvARB(GL_TEXTURE0_ARB+unit, vertexarray[(indexarray[vindex])].getUV1());
 						}
 						// ------------------------------
 
@@ -1448,10 +1448,10 @@ void RAS_OpenGLRasterizer::IndexPrimitivesMulti(
 							if( vertexarray[(indexarray[vindex])].getFlag() & TV_2NDUV &&
 								vertexarray[(indexarray[vindex])].getUnit() == unit ) 
 							{
-								bgl::glMultiTexCoord2fvARB(GL_TEXTURE0_ARB+unit, vertexarray[(indexarray[vindex])].getUV2());
+								bgl::blMultiTexCoord2fvARB(GL_TEXTURE0_ARB+unit, vertexarray[(indexarray[vindex])].getUV2());
 								continue;
 							}
-							bgl::glMultiTexCoord2fvARB(GL_TEXTURE0_ARB+unit, vertexarray[(indexarray[vindex])].getUV1());
+							bgl::blMultiTexCoord2fvARB(GL_TEXTURE0_ARB+unit, vertexarray[(indexarray[vindex])].getUV1());
 						}
 						// ------------------------------
 
@@ -1471,10 +1471,10 @@ void RAS_OpenGLRasterizer::IndexPrimitivesMulti(
 							if( vertexarray[(indexarray[vindex])].getFlag() & TV_2NDUV &&
 								vertexarray[(indexarray[vindex])].getUnit() == unit ) 
 							{
-								bgl::glMultiTexCoord2fvARB(GL_TEXTURE0_ARB+unit, vertexarray[(indexarray[vindex])].getUV2());
+								bgl::blMultiTexCoord2fvARB(GL_TEXTURE0_ARB+unit, vertexarray[(indexarray[vindex])].getUV2());
 								continue;
 							}
-							bgl::glMultiTexCoord2fvARB(GL_TEXTURE0_ARB+unit, vertexarray[(indexarray[vindex])].getUV1());
+							bgl::blMultiTexCoord2fvARB(GL_TEXTURE0_ARB+unit, vertexarray[(indexarray[vindex])].getUV1());
 						}
 						// ------------------------------
 
@@ -1488,10 +1488,10 @@ void RAS_OpenGLRasterizer::IndexPrimitivesMulti(
 							if( vertexarray[(indexarray[vindex])].getFlag() & TV_2NDUV &&
 								vertexarray[(indexarray[vindex])].getUnit() == unit ) 
 							{
-								bgl::glMultiTexCoord2fvARB(GL_TEXTURE0_ARB+unit, vertexarray[(indexarray[vindex])].getUV2());
+								bgl::blMultiTexCoord2fvARB(GL_TEXTURE0_ARB+unit, vertexarray[(indexarray[vindex])].getUV2());
 								continue;
 							}
-							bgl::glMultiTexCoord2fvARB(GL_TEXTURE0_ARB+unit, vertexarray[(indexarray[vindex])].getUV1());
+							bgl::blMultiTexCoord2fvARB(GL_TEXTURE0_ARB+unit, vertexarray[(indexarray[vindex])].getUV1());
 						}
 						// ------------------------------
 						glVertex3fv(vertexarray[(indexarray[vindex])].getLocalXYZ());
@@ -1504,10 +1504,10 @@ void RAS_OpenGLRasterizer::IndexPrimitivesMulti(
 							if( vertexarray[(indexarray[vindex])].getFlag() & TV_2NDUV &&
 								vertexarray[(indexarray[vindex])].getUnit() == unit ) 
 							{
-								bgl::glMultiTexCoord2fvARB(GL_TEXTURE0_ARB+unit, vertexarray[(indexarray[vindex])].getUV2());
+								bgl::blMultiTexCoord2fvARB(GL_TEXTURE0_ARB+unit, vertexarray[(indexarray[vindex])].getUV2());
 								continue;
 							}
-							bgl::glMultiTexCoord2fvARB(GL_TEXTURE0_ARB+unit, vertexarray[(indexarray[vindex])].getUV1());
+							bgl::blMultiTexCoord2fvARB(GL_TEXTURE0_ARB+unit, vertexarray[(indexarray[vindex])].getUV1());
 						}
 						// ------------------------------
 						glVertex3fv(vertexarray[(indexarray[vindex])].getLocalXYZ());
@@ -1620,10 +1620,10 @@ void RAS_OpenGLRasterizer::IndexPrimitivesMulti_Ex(const vecVertexArray & vertex
 							if( vertexarray[(indexarray[vindex])].getFlag() & TV_2NDUV &&
 								vertexarray[(indexarray[vindex])].getUnit() == unit ) 
 							{
-								bgl::glMultiTexCoord2fvARB(GL_TEXTURE0_ARB+unit, vertexarray[(indexarray[vindex])].getUV2());
+								bgl::blMultiTexCoord2fvARB(GL_TEXTURE0_ARB+unit, vertexarray[(indexarray[vindex])].getUV2());
 								continue;
 							}
-							bgl::glMultiTexCoord2fvARB(GL_TEXTURE0_ARB+unit, vertexarray[(indexarray[vindex])].getUV1());
+							bgl::blMultiTexCoord2fvARB(GL_TEXTURE0_ARB+unit, vertexarray[(indexarray[vindex])].getUV1());
 						}
 						// ------------------------------
 						
@@ -1638,10 +1638,10 @@ void RAS_OpenGLRasterizer::IndexPrimitivesMulti_Ex(const vecVertexArray & vertex
 							if( vertexarray[(indexarray[vindex])].getFlag() & TV_2NDUV &&
 								vertexarray[(indexarray[vindex])].getUnit() == unit ) 
 							{
-								bgl::glMultiTexCoord2fvARB(GL_TEXTURE0_ARB+unit, vertexarray[(indexarray[vindex])].getUV2());
+								bgl::blMultiTexCoord2fvARB(GL_TEXTURE0_ARB+unit, vertexarray[(indexarray[vindex])].getUV2());
 								continue;
 							}
-							bgl::glMultiTexCoord2fvARB(GL_TEXTURE0_ARB+unit, vertexarray[(indexarray[vindex])].getUV1());
+							bgl::blMultiTexCoord2fvARB(GL_TEXTURE0_ARB+unit, vertexarray[(indexarray[vindex])].getUV1());
 						}
 						// ------------------------------
 						
@@ -1656,10 +1656,10 @@ void RAS_OpenGLRasterizer::IndexPrimitivesMulti_Ex(const vecVertexArray & vertex
 							if( vertexarray[(indexarray[vindex])].getFlag() & TV_2NDUV &&
 								vertexarray[(indexarray[vindex])].getUnit() == unit ) 
 							{
-								bgl::glMultiTexCoord2fvARB(GL_TEXTURE0_ARB+unit, vertexarray[(indexarray[vindex])].getUV2());
+								bgl::blMultiTexCoord2fvARB(GL_TEXTURE0_ARB+unit, vertexarray[(indexarray[vindex])].getUV2());
 								continue;
 							}
-							bgl::glMultiTexCoord2fvARB(GL_TEXTURE0_ARB+unit, vertexarray[(indexarray[vindex])].getUV1());
+							bgl::blMultiTexCoord2fvARB(GL_TEXTURE0_ARB+unit, vertexarray[(indexarray[vindex])].getUV1());
 						}
 						// ------------------------------
 						
@@ -1674,10 +1674,10 @@ void RAS_OpenGLRasterizer::IndexPrimitivesMulti_Ex(const vecVertexArray & vertex
 							if( vertexarray[(indexarray[vindex])].getFlag() & TV_2NDUV &&
 								vertexarray[(indexarray[vindex])].getUnit() == unit ) 
 							{
-								bgl::glMultiTexCoord2fvARB(GL_TEXTURE0_ARB+unit, vertexarray[(indexarray[vindex])].getUV2());
+								bgl::blMultiTexCoord2fvARB(GL_TEXTURE0_ARB+unit, vertexarray[(indexarray[vindex])].getUV2());
 								continue;
 							}
-							bgl::glMultiTexCoord2fvARB(GL_TEXTURE0_ARB+unit, vertexarray[(indexarray[vindex])].getUV1());
+							bgl::blMultiTexCoord2fvARB(GL_TEXTURE0_ARB+unit, vertexarray[(indexarray[vindex])].getUV1());
 						}
 						// ------------------------------
 						
@@ -1721,10 +1721,10 @@ void RAS_OpenGLRasterizer::IndexPrimitivesMulti_Ex(const vecVertexArray & vertex
 							if( vertexarray[(indexarray[vindex])].getFlag() & TV_2NDUV &&
 								vertexarray[(indexarray[vindex])].getUnit() == unit ) 
 							{
-								bgl::glMultiTexCoord2fvARB(GL_TEXTURE0_ARB+unit, vertexarray[(indexarray[vindex])].getUV2());
+								bgl::blMultiTexCoord2fvARB(GL_TEXTURE0_ARB+unit, vertexarray[(indexarray[vindex])].getUV2());
 								continue;
 							}
-							bgl::glMultiTexCoord2fvARB(GL_TEXTURE0_ARB+unit, vertexarray[(indexarray[vindex])].getUV1());
+							bgl::blMultiTexCoord2fvARB(GL_TEXTURE0_ARB+unit, vertexarray[(indexarray[vindex])].getUV1());
 						}
 						// ------------------------------
 						
@@ -1740,10 +1740,10 @@ void RAS_OpenGLRasterizer::IndexPrimitivesMulti_Ex(const vecVertexArray & vertex
 							if( vertexarray[(indexarray[vindex])].getFlag() & TV_2NDUV &&
 								vertexarray[(indexarray[vindex])].getUnit() == unit ) 
 							{
-								bgl::glMultiTexCoord2fvARB(GL_TEXTURE0_ARB+unit, vertexarray[(indexarray[vindex])].getUV2());
+								bgl::blMultiTexCoord2fvARB(GL_TEXTURE0_ARB+unit, vertexarray[(indexarray[vindex])].getUV2());
 								continue;
 							}
-							bgl::glMultiTexCoord2fvARB(GL_TEXTURE0_ARB+unit, vertexarray[(indexarray[vindex])].getUV1());
+							bgl::blMultiTexCoord2fvARB(GL_TEXTURE0_ARB+unit, vertexarray[(indexarray[vindex])].getUV1());
 						}
 						// ------------------------------
 						
@@ -1759,10 +1759,10 @@ void RAS_OpenGLRasterizer::IndexPrimitivesMulti_Ex(const vecVertexArray & vertex
 							if( vertexarray[(indexarray[vindex])].getFlag() & TV_2NDUV &&
 								vertexarray[(indexarray[vindex])].getUnit() == unit ) 
 							{
-								bgl::glMultiTexCoord2fvARB(GL_TEXTURE0_ARB+unit, vertexarray[(indexarray[vindex])].getUV2());
+								bgl::blMultiTexCoord2fvARB(GL_TEXTURE0_ARB+unit, vertexarray[(indexarray[vindex])].getUV2());
 								continue;
 							}
-							bgl::glMultiTexCoord2fvARB(GL_TEXTURE0_ARB+unit, vertexarray[(indexarray[vindex])].getUV1());
+							bgl::blMultiTexCoord2fvARB(GL_TEXTURE0_ARB+unit, vertexarray[(indexarray[vindex])].getUV1());
 						}
 						// ------------------------------
 						
@@ -1777,10 +1777,10 @@ void RAS_OpenGLRasterizer::IndexPrimitivesMulti_Ex(const vecVertexArray & vertex
 							if( vertexarray[(indexarray[vindex])].getFlag() & TV_2NDUV &&
 								vertexarray[(indexarray[vindex])].getUnit() == unit ) 
 							{
-								bgl::glMultiTexCoord2fvARB(GL_TEXTURE0_ARB+unit, vertexarray[(indexarray[vindex])].getUV2());
+								bgl::blMultiTexCoord2fvARB(GL_TEXTURE0_ARB+unit, vertexarray[(indexarray[vindex])].getUV2());
 								continue;
 							}
-							bgl::glMultiTexCoord2fvARB(GL_TEXTURE0_ARB+unit, vertexarray[(indexarray[vindex])].getUV1());
+							bgl::blMultiTexCoord2fvARB(GL_TEXTURE0_ARB+unit, vertexarray[(indexarray[vindex])].getUV1());
 						}
 						// ------------------------------
 						glVertex3fv(vertexarray[(indexarray[vindex])].getLocalXYZ());
@@ -1824,10 +1824,10 @@ void RAS_OpenGLRasterizer::IndexPrimitivesMulti_Ex(const vecVertexArray & vertex
 							if( vertexarray[(indexarray[vindex])].getFlag() & TV_2NDUV &&
 								vertexarray[(indexarray[vindex])].getUnit() == unit ) 
 							{
-								bgl::glMultiTexCoord2fvARB(GL_TEXTURE0_ARB+unit, vertexarray[(indexarray[vindex])].getUV2());
+								bgl::blMultiTexCoord2fvARB(GL_TEXTURE0_ARB+unit, vertexarray[(indexarray[vindex])].getUV2());
 								continue;
 							}
-							bgl::glMultiTexCoord2fvARB(GL_TEXTURE0_ARB+unit, vertexarray[(indexarray[vindex])].getUV1());
+							bgl::blMultiTexCoord2fvARB(GL_TEXTURE0_ARB+unit, vertexarray[(indexarray[vindex])].getUV1());
 						}
 						// ------------------------------
 						glVertex3fv(vertexarray[(indexarray[vindex])].getLocalXYZ());
@@ -1840,10 +1840,10 @@ void RAS_OpenGLRasterizer::IndexPrimitivesMulti_Ex(const vecVertexArray & vertex
 							if( vertexarray[(indexarray[vindex])].getFlag() & TV_2NDUV &&
 								vertexarray[(indexarray[vindex])].getUnit() == unit ) 
 							{
-								bgl::glMultiTexCoord2fvARB(GL_TEXTURE0_ARB+unit, vertexarray[(indexarray[vindex])].getUV2());
+								bgl::blMultiTexCoord2fvARB(GL_TEXTURE0_ARB+unit, vertexarray[(indexarray[vindex])].getUV2());
 								continue;
 							}
-							bgl::glMultiTexCoord2fvARB(GL_TEXTURE0_ARB+unit, vertexarray[(indexarray[vindex])].getUV1());
+							bgl::blMultiTexCoord2fvARB(GL_TEXTURE0_ARB+unit, vertexarray[(indexarray[vindex])].getUV1());
 						}
 						// ------------------------------
 						glVertex3fv(vertexarray[(indexarray[vindex])].getLocalXYZ());
@@ -1856,10 +1856,10 @@ void RAS_OpenGLRasterizer::IndexPrimitivesMulti_Ex(const vecVertexArray & vertex
 							if( vertexarray[(indexarray[vindex])].getFlag() & TV_2NDUV &&
 								vertexarray[(indexarray[vindex])].getUnit() == unit ) 
 							{
-								bgl::glMultiTexCoord2fvARB(GL_TEXTURE0_ARB+unit, vertexarray[(indexarray[vindex])].getUV2());
+								bgl::blMultiTexCoord2fvARB(GL_TEXTURE0_ARB+unit, vertexarray[(indexarray[vindex])].getUV2());
 								continue;
 							}
-							bgl::glMultiTexCoord2fvARB(GL_TEXTURE0_ARB+unit, vertexarray[(indexarray[vindex])].getUV1());
+							bgl::blMultiTexCoord2fvARB(GL_TEXTURE0_ARB+unit, vertexarray[(indexarray[vindex])].getUV1());
 						}
 						// ------------------------------
 						glVertex3fv(vertexarray[(indexarray[vindex])].getLocalXYZ());
@@ -1896,10 +1896,10 @@ void RAS_OpenGLRasterizer::IndexPrimitivesMulti_Ex(const vecVertexArray & vertex
 							if( vertexarray[(indexarray[vindex])].getFlag() & TV_2NDUV &&
 								vertexarray[(indexarray[vindex])].getUnit() == unit ) 
 							{
-								bgl::glMultiTexCoord2fvARB(GL_TEXTURE0_ARB+unit, vertexarray[(indexarray[vindex])].getUV2());
+								bgl::blMultiTexCoord2fvARB(GL_TEXTURE0_ARB+unit, vertexarray[(indexarray[vindex])].getUV2());
 								continue;
 							}
-							bgl::glMultiTexCoord2fvARB(GL_TEXTURE0_ARB+unit, vertexarray[(indexarray[vindex])].getUV1());
+							bgl::blMultiTexCoord2fvARB(GL_TEXTURE0_ARB+unit, vertexarray[(indexarray[vindex])].getUV1());
 						}
 						// ------------------------------
 						glVertex3fv(vertexarray[(indexarray[vindex])].getLocalXYZ());
@@ -1913,10 +1913,10 @@ void RAS_OpenGLRasterizer::IndexPrimitivesMulti_Ex(const vecVertexArray & vertex
 							if( vertexarray[(indexarray[vindex])].getFlag() & TV_2NDUV &&
 								vertexarray[(indexarray[vindex])].getUnit() == unit ) 
 							{
-								bgl::glMultiTexCoord2fvARB(GL_TEXTURE0_ARB+unit, vertexarray[(indexarray[vindex])].getUV2());
+								bgl::blMultiTexCoord2fvARB(GL_TEXTURE0_ARB+unit, vertexarray[(indexarray[vindex])].getUV2());
 								continue;
 							}
-							bgl::glMultiTexCoord2fvARB(GL_TEXTURE0_ARB+unit, vertexarray[(indexarray[vindex])].getUV1());
+							bgl::blMultiTexCoord2fvARB(GL_TEXTURE0_ARB+unit, vertexarray[(indexarray[vindex])].getUV1());
 						}
 						// ------------------------------
 						glVertex3fv(vertexarray[(indexarray[vindex])].getLocalXYZ());
@@ -1930,10 +1930,10 @@ void RAS_OpenGLRasterizer::IndexPrimitivesMulti_Ex(const vecVertexArray & vertex
 							if( vertexarray[(indexarray[vindex])].getFlag() & TV_2NDUV &&
 								vertexarray[(indexarray[vindex])].getUnit() == unit ) 
 							{
-								bgl::glMultiTexCoord2fvARB(GL_TEXTURE0_ARB+unit, vertexarray[(indexarray[vindex])].getUV2());
+								bgl::blMultiTexCoord2fvARB(GL_TEXTURE0_ARB+unit, vertexarray[(indexarray[vindex])].getUV2());
 								continue;
 							}
-							bgl::glMultiTexCoord2fvARB(GL_TEXTURE0_ARB+unit, vertexarray[(indexarray[vindex])].getUV1());
+							bgl::blMultiTexCoord2fvARB(GL_TEXTURE0_ARB+unit, vertexarray[(indexarray[vindex])].getUV1());
 						}
 						// ------------------------------
 						glVertex3fv(vertexarray[(indexarray[vindex])].getLocalXYZ());