Merge of apricot branch game engine changes into trunk, excluding GLSL.

GLEW
====

Added the GLEW opengl extension library into extern/, always compiled
into Blender now. This is much nicer than doing this kind of extension
management manually, and will be used in the game engine, for GLSL, and
other opengl extensions.

* According to the GLEW website it works on Windows, Linux, Mac OS X,
  FreeBSD, Irix, and Solaris. There might still be platform specific
  issues due to this commit, so let me know and I'll look into it.
* This means also that all extensions will now always be compiled in,
  regardless of the glext.h on the platform where compilation happens.

Game Engine
===========

Refactoring of the use of opengl extensions and other drawing code
in the game engine, and cleaning up some hacks related to GLSL
integration. These changes will be merged into trunk too after this.

The game engine graphics demos & apricot level survived my tests,
but this could use some good testing of course.

For users: please test with the options "Generate Display Lists" and
"Vertex Arrays" enabled, these should be the fastest and are supposed
to be "unreliable", but if that's the case that's probably due to bugs
that can be fixed.

* The game engine now also uses GLEW for extensions, replacing the
  custom opengl extensions code that was there. Removes a lot of
  #ifdef's, but the runtime checks stay of course.
* Removed the WITHOUT_GLEXT environment variable. This was added to
  work around a specific bug and only disabled multitexturing anyway.
  It might also have caused a slowdown since it was retrieving the
  environment variable for every vertex in immediate mode (bug #13680).

* Refactored the code to allow drawing skinned meshes with vertex
  arrays too, removing some specific immediate mode drawing functions
  for this that only did extra normal calculation. Now it always splits
  vertices of flat faces instead.
* Refactored normal recalculation with some minor optimizations,
  required for the above change.
* Removed some outdated code behind the __NLA_OLDDEFORM #ifdef.
* Fixed various bugs in setting of multitexture coordinates and vertex
  attributes for vertex arrays. These were not being enabled/disabled
  correct according to the opengl spec, leading to crashes. Also tangent
  attributes used an immediate mode call for vertex arrays, which can't
  work.
* Fixed use of uninitialized variable in RAS_TexVert.
* Exporting skinned meshes was doing O(n^2) lookups for vertices and
  deform weights, now uses same trick as regular meshes.

14 files changed, 583 insertions, 462 deletions

diff --git a/source/gameengine/Ketsji/BL_BlenderShader.cpp b/source/gameengine/Ketsji/BL_BlenderShader.cpp
new file mode 100644
index 00000000000..06e012123b1
--- /dev/null
+++ b/source/gameengine/Ketsji/BL_BlenderShader.cpp
@@ -0,0 +1,149 @@
+
+#include "DNA_customdata_types.h"
+
+#include "BL_BlenderShader.h"
+
+#if 0
+#include "GPU_extensions.h"
+#include "GPU_material.h"
+#endif
+
+#include "RAS_MeshObject.h"
+#include "RAS_IRasterizer.h"
+
+const bool BL_BlenderShader::Ok()const
+{
+#if 0
+	return (mGPUMat != 0);
+#endif
+
+	return false;
+}
+
+BL_BlenderShader::BL_BlenderShader(struct Material *ma)
+:
+#if 0
+	mGPUMat(0),
+#endif
+	mBound(false)
+{
+#if 0
+	if(ma)
+		mGPUMat = GPU_material_from_blender(ma, GPU_PROFILE_DERIVEDMESH);
+#endif
+}
+
+BL_BlenderShader::~BL_BlenderShader()
+{
+#if 0
+	if(mGPUMat) {
+		GPU_material_unbind(mGPUMat);
+		mGPUMat = 0;
+	}
+#endif
+}
+
+void BL_BlenderShader::ApplyShader()
+{
+}
+
+void BL_BlenderShader::SetProg(bool enable)
+{
+#if 0
+	if(mGPUMat) {
+		if(enable) {
+			GPU_material_bind(mGPUMat);
+			mBound = true;
+		}
+		else {
+			GPU_material_unbind(mGPUMat);
+			mBound = false;
+		}
+	}
+#endif
+}
+
+int BL_BlenderShader::GetAttribNum()
+{
+#if 0
+	GPUVertexAttribs attribs;
+	int i, enabled = 0;
+
+	if(!mGPUMat)
+		return enabled;
+
+	GPU_material_vertex_attributes(mGPUMat, &attribs);
+
+    for(i = 0; i < attribs.totlayer; i++)
+		if(attribs.layer[i].glindex+1 > enabled)
+			enabled= attribs.layer[i].glindex+1;
+	
+	if(enabled > BL_MAX_ATTRIB)
+		enabled = BL_MAX_ATTRIB;
+
+	return enabled;
+#endif
+
+	return 0;
+}
+
+void BL_BlenderShader::SetTexCoords(RAS_IRasterizer* ras)
+{
+#if 0
+	GPUVertexAttribs attribs;
+	int i, attrib_num;
+
+	if(!mGPUMat)
+		return;
+
+	if(ras->GetDrawingMode() == RAS_IRasterizer::KX_TEXTURED) {
+		GPU_material_vertex_attributes(mGPUMat, &attribs);
+		attrib_num = GetAttribNum();
+
+		ras->SetTexCoordNum(0);
+		ras->SetAttribNum(attrib_num);
+		for(i=0; i<attrib_num; i++)
+			ras->SetAttrib(RAS_IRasterizer::RAS_TEXCO_DISABLE, i);
+
+		for(i = 0; i < attribs.totlayer; i++) {
+			if(attribs.layer[i].glindex > attrib_num)
+				continue;
+
+			if(attribs.layer[i].type == CD_MTFACE)
+				ras->SetAttrib(RAS_IRasterizer::RAS_TEXCO_UV1, attribs.layer[i].glindex);
+			else if(attribs.layer[i].type == CD_TANGENT)
+				ras->SetAttrib(RAS_IRasterizer::RAS_TEXTANGENT, attribs.layer[i].glindex);
+			else if(attribs.layer[i].type == CD_ORCO)
+				ras->SetAttrib(RAS_IRasterizer::RAS_TEXCO_ORCO, attribs.layer[i].glindex);
+			else if(attribs.layer[i].type == CD_NORMAL)
+				ras->SetAttrib(RAS_IRasterizer::RAS_TEXCO_NORM, attribs.layer[i].glindex);
+		}
+
+		ras->EnableTextures(true);
+	}
+	else
+		ras->EnableTextures(false);
+#endif
+}
+
+void BL_BlenderShader::Update( const KX_MeshSlot & ms, RAS_IRasterizer* rasty )
+{
+#if 0
+	float obmat[4][4], viewmat[4][4];
+
+	if(!mGPUMat || !mBound)
+		return;
+
+	MT_Matrix4x4 model;
+	model.setValue(ms.m_OpenGLMatrix);
+	MT_Matrix4x4 view;
+	rasty->GetViewMatrix(view);
+
+	model.getValue((float*)obmat);
+	view.getValue((float*)viewmat);
+
+	GPU_material_bind_uniforms(mGPUMat, obmat, viewmat);
+#endif
+}
+
+// eof
diff --git a/source/gameengine/Ketsji/BL_BlenderShader.h b/source/gameengine/Ketsji/BL_BlenderShader.h
new file mode 100644
index 00000000000..4cab0e644c3
--- /dev/null
+++ b/source/gameengine/Ketsji/BL_BlenderShader.h
@@ -0,0 +1,44 @@
+
+#ifndef __BL_GPUSHADER_H__
+#define __BL_GPUSHADER_H__
+
+#if 0
+#include "GPU_material.h"
+#endif
+
+#include "MT_Matrix4x4.h"
+#include "MT_Matrix3x3.h"
+#include "MT_Tuple2.h"
+#include "MT_Tuple3.h"
+#include "MT_Tuple4.h"
+
+struct Material;
+
+#define BL_MAX_ATTRIB	16
+
+/**
+ * BL_BlenderShader
+ *  Blender GPU shader material
+ */
+class BL_BlenderShader
+{
+private:
+#if 0
+	GPUMaterial		*mGPUMat;
+#endif
+	bool			mBound;
+
+public:
+	BL_BlenderShader(struct Material *ma);
+	virtual ~BL_BlenderShader();
+
+	const bool			Ok()const;
+	void				SetProg(bool enable);
+
+	void ApplyShader();
+	void SetTexCoords(class RAS_IRasterizer* ras);
+	int GetAttribNum();
+	void Update(const class KX_MeshSlot & ms, class RAS_IRasterizer* rasty);
+};
+
+#endif//__BL_GPUSHADER_H__
diff --git a/source/gameengine/Ketsji/BL_Material.cpp b/source/gameengine/Ketsji/BL_Material.cpp
index 7ed2da590a9..f5312ccd023 100644
--- a/source/gameengine/Ketsji/BL_Material.cpp
+++ b/source/gameengine/Ketsji/BL_Material.cpp
@@ -34,6 +34,7 @@ BL_Material::BL_Material()
 	rgb[3] = 0;
 	IdMode = 0;
 	ras_mode = 0;
+	glslmat = 0;
 	tile = 0;
 	matname = "NoMaterial";
 	matcolor[0] = 0.5f;
diff --git a/source/gameengine/Ketsji/BL_Material.h b/source/gameengine/Ketsji/BL_Material.h
index 8be91316237..ddb6662830a 100644
--- a/source/gameengine/Ketsji/BL_Material.h
+++ b/source/gameengine/Ketsji/BL_Material.h
@@ -20,7 +20,7 @@ struct EnvMap;
 	although the more you add the slower the search time will be.
 	we will go for three, which should be enough
 */
-#define MAXTEX			3//match in RAS_TexVert & RAS_OpenGLRasterizer
+#define MAXTEX			3	//match in RAS_TexVert & RAS_OpenGLRasterizer
 
 // different mapping modes
 class BL_Mapping
@@ -47,6 +47,7 @@ public:
 
 	int IdMode;
 	unsigned int ras_mode;
+	bool glslmat;
 
 	STR_String texname[MAXTEX];
 	unsigned int flag[MAXTEX];
diff --git a/source/gameengine/Ketsji/BL_Shader.cpp b/source/gameengine/Ketsji/BL_Shader.cpp
index 105a87e767b..15350db6650 100644
--- a/source/gameengine/Ketsji/BL_Shader.cpp
+++ b/source/gameengine/Ketsji/BL_Shader.cpp
@@ -1,21 +1,5 @@
 
-
-#ifdef WIN32
-#include <windows.h>
-#endif // WIN32
-#ifdef __APPLE__
-#define GL_GLEXT_LEGACY 1
-#include <OpenGL/gl.h>
-#include <OpenGL/glu.h>
-#else
-#include <GL/gl.h>
-/* #if defined(__sun__) && !defined(__sparc__)
-#include <mesa/glu.h>
-#else
-*/
-#include <GL/glu.h>
-/* #endif */
-#endif
+#include "GL/glew.h"
 
 #include <iostream>
 #include "BL_Shader.h"
@@ -31,7 +15,6 @@
 #include "RAS_MeshObject.h"
 #include "RAS_IRasterizer.h"
 
-//using namespace bgl;
 #define spit(x) std::cout << x << std::endl;
 
 #define SORT_UNIFORMS 1
@@ -46,7 +29,7 @@ BL_Uniform::BL_Uniform(int data_size)
 	mDataLen(data_size)
 {
 #ifdef SORT_UNIFORMS
-	MT_assert(mDataLen <= UNIFORM_MAX_LEN);
+	MT_assert((int)mDataLen <= UNIFORM_MAX_LEN);
 	mData = (void*)MEM_mallocN(mDataLen, "shader-uniform-alloc");
 #endif
 }
@@ -63,7 +46,6 @@ BL_Uniform::~BL_Uniform()
 
 void BL_Uniform::Apply(class BL_Shader *shader)
 {
-#ifdef GL_ARB_shader_objects
 #ifdef SORT_UNIFORMS
 	MT_assert(mType > UNI_NONE && mType < UNI_MAX && mData);
 
@@ -74,48 +56,47 @@ void BL_Uniform::Apply(class BL_Shader *shader)
 	{
 	case UNI_FLOAT: {
 			float *f = (float*)mData;
-			bgl::blUniform1fARB(mLoc,(GLfloat)*f);
+			glUniform1fARB(mLoc,(GLfloat)*f);
 		}break;
 	case UNI_INT: {
 			int *f = (int*)mData;
-			bgl::blUniform1iARB(mLoc, (GLint)*f);
+			glUniform1iARB(mLoc, (GLint)*f);
 		}break;
 	case UNI_FLOAT2: {
 			float *f = (float*)mData;
-			bgl::blUniform2fvARB(mLoc,1, (GLfloat*)f);
+			glUniform2fvARB(mLoc,1, (GLfloat*)f);
 		}break;
 	case UNI_FLOAT3: {
 			float *f = (float*)mData;
-			bgl::blUniform3fvARB(mLoc,1,(GLfloat*)f);
+			glUniform3fvARB(mLoc,1,(GLfloat*)f);
 		}break;
 	case UNI_FLOAT4: {
 			float *f = (float*)mData;
-			bgl::blUniform4fvARB(mLoc,1,(GLfloat*)f);
+			glUniform4fvARB(mLoc,1,(GLfloat*)f);
 		}break;
 	case UNI_INT2: {
 			int *f = (int*)mData;
-			bgl::blUniform2ivARB(mLoc,1,(GLint*)f);
+			glUniform2ivARB(mLoc,1,(GLint*)f);
 		}break; 
 	case UNI_INT3: {
 			int *f = (int*)mData;
-			bgl::blUniform3ivARB(mLoc,1,(GLint*)f);
+			glUniform3ivARB(mLoc,1,(GLint*)f);
 		}break; 
 	case UNI_INT4: {
 			int *f = (int*)mData;
-			bgl::blUniform4ivARB(mLoc,1,(GLint*)f);
+			glUniform4ivARB(mLoc,1,(GLint*)f);
 		}break;
 	case UNI_MAT4: {
 			float *f = (float*)mData;
-			bgl::blUniformMatrix4fvARB(mLoc, 1, mTranspose?GL_TRUE:GL_FALSE,(GLfloat*)f);
+			glUniformMatrix4fvARB(mLoc, 1, mTranspose?GL_TRUE:GL_FALSE,(GLfloat*)f);
 		}break;
 	case UNI_MAT3: {
 			float *f = (float*)mData;
-			bgl::blUniformMatrix3fvARB(mLoc, 1, mTranspose?GL_TRUE:GL_FALSE,(GLfloat*)f);
+			glUniformMatrix3fvARB(mLoc, 1, mTranspose?GL_TRUE:GL_FALSE,(GLfloat*)f);
 		}break;
 	}
 	mDirty = false;
 #endif
-#endif
 }
 
 void BL_Uniform::SetData(int location, int type,bool transpose)
@@ -144,17 +125,14 @@ BL_Shader::BL_Shader(PyTypeObject *T)
 	mError(0),
 	mDirty(true)
 {
-	// if !RAS_EXT_support._ARB_shader_objects this class will not be used
+	// if !GLEW_ARB_shader_objects this class will not be used
 	//for (int i=0; i<MAXTEX; i++) {
 	//	mSampler[i] = BL_Sampler();
 	//}
 }
 
-using namespace bgl;
-
 BL_Shader::~BL_Shader()
 {
-#ifdef GL_ARB_shader_objects
 	//for (int i=0; i<MAXTEX; i++){
 	//	if(mSampler[i].mOwn) {
 	//		if(mSampler[i].mTexture)
@@ -164,14 +142,13 @@ BL_Shader::~BL_Shader()
 	ClearUniforms();
 
 	if( mShader ) {
-		bgl::blDeleteObjectARB(mShader);
+		glDeleteObjectARB(mShader);
 		mShader = 0;
 	}
 	vertProg	= 0;
 	fragProg	= 0;
 	mOk			= 0;
-	bgl::blUseProgramObjectARB(0);
-#endif//GL_ARB_shader_objects
+	glUseProgramObjectARB(0);
 }
 
 void BL_Shader::ClearUniforms()
@@ -266,8 +243,6 @@ void BL_Shader::UnloadShader()
 
 bool BL_Shader::LinkProgram()
 {
-#ifdef GL_ARB_shader_objects
-
 	int vertlen = 0, fraglen=0, proglen=0;
 	int vertstatus=0, fragstatus=0, progstatus=0;
 	unsigned int tmpVert=0, tmpFrag=0, tmpProg=0;
@@ -281,25 +256,25 @@ bool BL_Shader::LinkProgram()
 		spit("Invalid GLSL sources");
 		return false;
 	}
-	if( !RAS_EXT_support._ARB_fragment_shader) {
+	if( !GLEW_ARB_fragment_shader) {
 		spit("Fragment shaders not supported");
 		return false;
 	}
-	if( !RAS_EXT_support._ARB_vertex_shader) {
+	if( !GLEW_ARB_vertex_shader) {
 		spit("Vertex shaders not supported");
 		return false;
 	}
 	
 	// -- vertex shader ------------------
-	tmpVert = bgl::blCreateShaderObjectARB(GL_VERTEX_SHADER_ARB);
-	bgl::blShaderSourceARB(tmpVert, 1, (const char**)&vertProg, 0);
-	bgl::blCompileShaderARB(tmpVert);
-	bgl::blGetObjectParameterivARB(tmpVert, GL_OBJECT_INFO_LOG_LENGTH_ARB,(GLint*) &vertlen);
+	tmpVert = glCreateShaderObjectARB(GL_VERTEX_SHADER_ARB);
+	glShaderSourceARB(tmpVert, 1, (const char**)&vertProg, 0);
+	glCompileShaderARB(tmpVert);
+	glGetObjectParameterivARB(tmpVert, GL_OBJECT_INFO_LOG_LENGTH_ARB,(GLint*) &vertlen);
 	
 	// print info if any
 	if( vertlen > 0 && vertlen < MAX_LOG_LEN){
 		logInf = (char*)MEM_mallocN(vertlen, "vert-log");
-		bgl::blGetInfoLogARB(tmpVert, vertlen, (GLsizei*)&char_len, logInf);
+		glGetInfoLogARB(tmpVert, vertlen, (GLsizei*)&char_len, logInf);
 		if(char_len >0) {
 			spit("---- Vertex Shader Error ----");
 			spit(logInf);
@@ -308,20 +283,20 @@ bool BL_Shader::LinkProgram()
 		logInf=0;
 	}
 	// check for compile errors
-	bgl::blGetObjectParameterivARB(tmpVert, GL_OBJECT_COMPILE_STATUS_ARB,(GLint*)&vertstatus);
+	glGetObjectParameterivARB(tmpVert, GL_OBJECT_COMPILE_STATUS_ARB,(GLint*)&vertstatus);
 	if(!vertstatus) {
 		spit("---- Vertex shader failed to compile ----");
 		goto programError;
 	}
 
 	// -- fragment shader ----------------
-	tmpFrag = bgl::blCreateShaderObjectARB(GL_FRAGMENT_SHADER_ARB);
-	bgl::blShaderSourceARB(tmpFrag, 1,(const char**)&fragProg, 0);
-	bgl::blCompileShaderARB(tmpFrag);
-	bgl::blGetObjectParameterivARB(tmpFrag, GL_OBJECT_INFO_LOG_LENGTH_ARB, (GLint*) &fraglen);
+	tmpFrag = glCreateShaderObjectARB(GL_FRAGMENT_SHADER_ARB);
+	glShaderSourceARB(tmpFrag, 1,(const char**)&fragProg, 0);
+	glCompileShaderARB(tmpFrag);
+	glGetObjectParameterivARB(tmpFrag, GL_OBJECT_INFO_LOG_LENGTH_ARB, (GLint*) &fraglen);
 	if(fraglen >0 && fraglen < MAX_LOG_LEN){
 		logInf = (char*)MEM_mallocN(fraglen, "frag-log");
-		bgl::blGetInfoLogARB(tmpFrag, fraglen,(GLsizei*) &char_len, logInf);
+		glGetInfoLogARB(tmpFrag, fraglen,(GLsizei*) &char_len, logInf);
 		if(char_len >0) {
 			spit("---- Fragment Shader Error ----");
 			spit(logInf);
@@ -330,7 +305,7 @@ bool BL_Shader::LinkProgram()
 		logInf=0;
 	}
 
-	bgl::blGetObjectParameterivARB(tmpFrag, GL_OBJECT_COMPILE_STATUS_ARB, (GLint*) &fragstatus);
+	glGetObjectParameterivARB(tmpFrag, GL_OBJECT_COMPILE_STATUS_ARB, (GLint*) &fragstatus);
 	if(!fragstatus){
 		spit("---- Fragment shader failed to compile ----");
 		goto programError;
@@ -339,17 +314,17 @@ bool BL_Shader::LinkProgram()
 	
 	// -- program ------------------------
 	//  set compiled vert/frag shader & link
-	tmpProg = bgl::blCreateProgramObjectARB();
-	bgl::blAttachObjectARB(tmpProg, tmpVert);
-	bgl::blAttachObjectARB(tmpProg, tmpFrag);
-	bgl::blLinkProgramARB(tmpProg);
-	bgl::blGetObjectParameterivARB(tmpProg, GL_OBJECT_INFO_LOG_LENGTH_ARB, (GLint*) &proglen);
-	bgl::blGetObjectParameterivARB(tmpProg, GL_OBJECT_LINK_STATUS_ARB, (GLint*) &progstatus);
+	tmpProg = glCreateProgramObjectARB();
+	glAttachObjectARB(tmpProg, tmpVert);
+	glAttachObjectARB(tmpProg, tmpFrag);
+	glLinkProgramARB(tmpProg);
+	glGetObjectParameterivARB(tmpProg, GL_OBJECT_INFO_LOG_LENGTH_ARB, (GLint*) &proglen);
+	glGetObjectParameterivARB(tmpProg, GL_OBJECT_LINK_STATUS_ARB, (GLint*) &progstatus);
 	
 
 	if(proglen > 0 && proglen < MAX_LOG_LEN) {
 		logInf = (char*)MEM_mallocN(proglen, "prog-log");
-		bgl::blGetInfoLogARB(tmpProg, proglen, (GLsizei*)&char_len, logInf);
+		glGetInfoLogARB(tmpProg, proglen, (GLsizei*)&char_len, logInf);
 		if(char_len >0) {
 			spit("---- GLSL Program ----");
 			spit(logInf);
@@ -365,24 +340,24 @@ bool BL_Shader::LinkProgram()
 
 	// set
 	mShader = tmpProg;
-	bgl::blDeleteObjectARB(tmpVert);
-	bgl::blDeleteObjectARB(tmpFrag);
+	glDeleteObjectARB(tmpVert);
+	glDeleteObjectARB(tmpFrag);
 	mOk		= 1;
 	mError = 0;
 	return true;
 
 programError:
 	if(tmpVert) {
-		bgl::blDeleteObjectARB(tmpVert);
+		glDeleteObjectARB(tmpVert);
 		tmpVert=0;
 	}
 	if(tmpFrag) {
-		bgl::blDeleteObjectARB(tmpFrag);
+		glDeleteObjectARB(tmpFrag);
 		tmpFrag=0;
 	}
 
 	if(tmpProg) {
-		bgl::blDeleteObjectARB(tmpProg);
+		glDeleteObjectARB(tmpProg);
 		tmpProg=0;
 	}
 
@@ -390,9 +365,6 @@ programError:
 	mUse	= 0;
 	mError	= 1;
 	return false;
-#else
-	return false;
-#endif//GL_ARB_shader_objects
 }
 
 const char *BL_Shader::GetVertPtr()
@@ -428,15 +400,13 @@ unsigned int BL_Shader::GetProg()
 
 void BL_Shader::SetSampler(int loc, int unit)
 {
-#ifdef GL_ARB_shader_objects
-	if( RAS_EXT_support._ARB_fragment_shader &&
-		RAS_EXT_support._ARB_vertex_shader &&
-		RAS_EXT_support._ARB_shader_objects 
+	if( GLEW_ARB_fragment_shader &&
+		GLEW_ARB_vertex_shader &&
+		GLEW_ARB_shader_objects 
 		)
 	{
-		bgl::blUniform1iARB(loc, unit);
+		glUniform1iARB(loc, unit);
 	}
-#endif
 }
 //
 //void BL_Shader::InitializeSampler(int unit, BL_Texture* texture)
@@ -449,31 +419,28 @@ void BL_Shader::SetSampler(int loc, int unit)
 
 void BL_Shader::SetProg(bool enable)
 {
-#ifdef GL_ARB_shader_objects
-	if( RAS_EXT_support._ARB_fragment_shader &&
-		RAS_EXT_support._ARB_vertex_shader &&
-		RAS_EXT_support._ARB_shader_objects 
+	if( GLEW_ARB_fragment_shader &&
+		GLEW_ARB_vertex_shader &&
+		GLEW_ARB_shader_objects 
 		)
 	{
 		if(	mShader != 0 && mOk && enable) {
-			bgl::blUseProgramObjectARB(mShader);
+			glUseProgramObjectARB(mShader);
 		}
 		else {
-			bgl::blUseProgramObjectARB(0);	
+			glUseProgramObjectARB(0);	
 		}
 	}
-#endif
 }
 
 void BL_Shader::Update( const KX_MeshSlot & ms, RAS_IRasterizer* rasty )
 {
-#ifdef GL_ARB_shader_objects
 	if(!Ok() || !mPreDef.size()) 
 		return;
 
-	if( RAS_EXT_support._ARB_fragment_shader &&
-		RAS_EXT_support._ARB_vertex_shader &&
-		RAS_EXT_support._ARB_shader_objects 
+	if( GLEW_ARB_fragment_shader &&
+		GLEW_ARB_vertex_shader &&
+		GLEW_ARB_shader_objects 
 		)
 	{
 		MT_Matrix4x4 model;
@@ -578,210 +545,185 @@ void BL_Shader::Update( const KX_MeshSlot & ms, RAS_IRasterizer* rasty )
 			}
 		}
 	}
-#endif
 }
 
 
 int BL_Shader::GetAttribLocation(const STR_String& name)
 {
-#ifdef GL_ARB_shader_objects
-	if( RAS_EXT_support._ARB_fragment_shader &&
-		RAS_EXT_support._ARB_vertex_shader &&
-		RAS_EXT_support._ARB_shader_objects 
+	if( GLEW_ARB_fragment_shader &&
+		GLEW_ARB_vertex_shader &&
+		GLEW_ARB_shader_objects 
 		)
 	{
-		return bgl::blGetAttribLocationARB(mShader, name.ReadPtr());
+		return glGetAttribLocationARB(mShader, name.ReadPtr());
 	}
-#endif
+
 	return -1;
 }
 
 void BL_Shader::BindAttribute(const STR_String& attr, int loc)
 {
-#ifdef GL_ARB_shader_objects
-	if( RAS_EXT_support._ARB_fragment_shader &&
-		RAS_EXT_support._ARB_vertex_shader &&
-		RAS_EXT_support._ARB_shader_objects 
+	if( GLEW_ARB_fragment_shader &&
+		GLEW_ARB_vertex_shader &&
+		GLEW_ARB_shader_objects 
 		)
 	{
-		bgl::blBindAttribLocationARB(mShader, loc, attr.ReadPtr());
+		glBindAttribLocationARB(mShader, loc, attr.ReadPtr());
 	}
-#endif
 }
 
 int BL_Shader::GetUniformLocation(const STR_String& name)
 {
-#ifdef GL_ARB_shader_objects
-	if( RAS_EXT_support._ARB_fragment_shader &&
-		RAS_EXT_support._ARB_vertex_shader &&
-		RAS_EXT_support._ARB_shader_objects 
+	if( GLEW_ARB_fragment_shader &&
+		GLEW_ARB_vertex_shader &&
+		GLEW_ARB_shader_objects 
 		)
 	{
 		MT_assert(mShader!=0);
-		int location = bgl::blGetUniformLocationARB(mShader, name.ReadPtr());
+		int location = glGetUniformLocationARB(mShader, name.ReadPtr());
 		if(location == -1)
 			spit("Invalid uniform value: " << name.ReadPtr() << ".");
 		return location;
 	}
-#endif
+
 	return -1;
 }
 
 void BL_Shader::SetUniform(int uniform, const MT_Tuple2& vec)
 {
-#ifdef GL_ARB_shader_objects
-	if( RAS_EXT_support._ARB_fragment_shader &&
-		RAS_EXT_support._ARB_vertex_shader &&
-		RAS_EXT_support._ARB_shader_objects 
+	if( GLEW_ARB_fragment_shader &&
+		GLEW_ARB_vertex_shader &&
+		GLEW_ARB_shader_objects 
 		)
 	{
 		float value[2];
 		vec.getValue(value);
-		bgl::blUniform2fvARB(uniform, 1, value);
+		glUniform2fvARB(uniform, 1, value);
 	}
-#endif
 
 }
 
 void BL_Shader::SetUniform(int uniform, const MT_Tuple3& vec)
 {
-#ifdef GL_ARB_shader_objects
-	if( RAS_EXT_support._ARB_fragment_shader &&
-		RAS_EXT_support._ARB_vertex_shader &&
-		RAS_EXT_support._ARB_shader_objects 
+	if( GLEW_ARB_fragment_shader &&
+		GLEW_ARB_vertex_shader &&
+		GLEW_ARB_shader_objects 
 		)
 	{	
 		float value[3];
 		vec.getValue(value);
-		bgl::blUniform3fvARB(uniform, 1, value);
+		glUniform3fvARB(uniform, 1, value);
 	}
-#endif
 }
 
 void BL_Shader::SetUniform(int uniform, const MT_Tuple4& vec)
 {
-#ifdef GL_ARB_shader_objects
-	if( RAS_EXT_support._ARB_fragment_shader &&
-		RAS_EXT_support._ARB_vertex_shader &&
-		RAS_EXT_support._ARB_shader_objects 
+	if( GLEW_ARB_fragment_shader &&
+		GLEW_ARB_vertex_shader &&
+		GLEW_ARB_shader_objects 
 		)
 	{
 		float value[4];
 		vec.getValue(value);
-		bgl::blUniform4fvARB(uniform, 1, value);
+		glUniform4fvARB(uniform, 1, value);
 	}
-#endif
 }
 
 void BL_Shader::SetUniform(int uniform, const unsigned int& val)
 {
-#ifdef GL_ARB_shader_objects
-	if( RAS_EXT_support._ARB_fragment_shader &&
-		RAS_EXT_support._ARB_vertex_shader &&
-		RAS_EXT_support._ARB_shader_objects 
+	if( GLEW_ARB_fragment_shader &&
+		GLEW_ARB_vertex_shader &&
+		GLEW_ARB_shader_objects 
 		)
 	{
-		bgl::blUniform1iARB(uniform, val);
+		glUniform1iARB(uniform, val);
 	}
-#endif
 }
 
 void BL_Shader::SetUniform(int uniform, const int val)
 {
-#ifdef GL_ARB_shader_objects
-	if( RAS_EXT_support._ARB_fragment_shader &&
-		RAS_EXT_support._ARB_vertex_shader &&
-		RAS_EXT_support._ARB_shader_objects 
+	if( GLEW_ARB_fragment_shader &&
+		GLEW_ARB_vertex_shader &&
+		GLEW_ARB_shader_objects 
 		)
 	{
-		bgl::blUniform1iARB(uniform, val);
+		glUniform1iARB(uniform, val);
 	}
-#endif
 }
 
 void BL_Shader::SetUniform(int uniform, const float& val)
 {
-#ifdef GL_ARB_shader_objects
-	if( RAS_EXT_support._ARB_fragment_shader &&
-		RAS_EXT_support._ARB_vertex_shader &&
-		RAS_EXT_support._ARB_shader_objects 
+	if( GLEW_ARB_fragment_shader &&
+		GLEW_ARB_vertex_shader &&
+		GLEW_ARB_shader_objects 
 		)
 	{
-		bgl::blUniform1fARB(uniform, val);
+		glUniform1fARB(uniform, val);
 	}
-#endif
 }
 
 void BL_Shader::SetUniform(int uniform, const MT_Matrix4x4& vec, bool transpose)
 {
-#ifdef GL_ARB_shader_objects
-	if( RAS_EXT_support._ARB_fragment_shader &&
-		RAS_EXT_support._ARB_vertex_shader &&
-		RAS_EXT_support._ARB_shader_objects 
+	if( GLEW_ARB_fragment_shader &&
+		GLEW_ARB_vertex_shader &&
+		GLEW_ARB_shader_objects 
 		)
 	{
 		float value[16];
 		vec.getValue(value);
-		bgl::blUniformMatrix4fvARB(uniform, 1, transpose?GL_TRUE:GL_FALSE, value);
+		glUniformMatrix4fvARB(uniform, 1, transpose?GL_TRUE:GL_FALSE, value);
 	}
-#endif
 }
 
 void BL_Shader::SetUniform(int uniform, const MT_Matrix3x3& vec, bool transpose)
 {
-#ifdef GL_ARB_shader_objects
-	if( RAS_EXT_support._ARB_fragment_shader &&
-		RAS_EXT_support._ARB_vertex_shader &&
-		RAS_EXT_support._ARB_shader_objects 
+	if( GLEW_ARB_fragment_shader &&
+		GLEW_ARB_vertex_shader &&
+		GLEW_ARB_shader_objects 
 		)
 	{
 		float value[9];
 		value[0] = (float)vec[0][0]; value[1] = (float)vec[1][0]; value[2] = (float)vec[2][0]; 
 		value[3] = (float)vec[0][1]; value[4] = (float)vec[1][1]; value[5] = (float)vec[2][1]; 
 		value[6] = (float)vec[0][2]; value[7] = (float)vec[1][2]; value[7] = (float)vec[2][2]; 
-		bgl::blUniformMatrix3fvARB(uniform, 1, transpose?GL_TRUE:GL_FALSE, value);
+		glUniformMatrix3fvARB(uniform, 1, transpose?GL_TRUE:GL_FALSE, value);
 	}
-#endif
 }
 
 void BL_Shader::SetUniform(int uniform, const float* val, int len)
 {
-#ifdef GL_ARB_shader_objects
-	if( RAS_EXT_support._ARB_fragment_shader &&
-		RAS_EXT_support._ARB_vertex_shader &&
-		RAS_EXT_support._ARB_shader_objects 
+	if( GLEW_ARB_fragment_shader &&
+		GLEW_ARB_vertex_shader &&
+		GLEW_ARB_shader_objects 
 		)
 	{
 		if(len == 2) 
-			bgl::blUniform2fvARB(uniform, 1,(GLfloat*)val);
+			glUniform2fvARB(uniform, 1,(GLfloat*)val);
 		else if (len == 3)
-			bgl::blUniform3fvARB(uniform, 1,(GLfloat*)val);
+			glUniform3fvARB(uniform, 1,(GLfloat*)val);
 		else if (len == 4)
-			bgl::blUniform4fvARB(uniform, 1,(GLfloat*)val);
+			glUniform4fvARB(uniform, 1,(GLfloat*)val);
 		else
 			MT_assert(0);
 	}
-#endif
 }
 
 void BL_Shader::SetUniform(int uniform, const int* val, int len)
 {
-#ifdef GL_ARB_shader_objects
-	if( RAS_EXT_support._ARB_fragment_shader &&
-		RAS_EXT_support._ARB_vertex_shader &&
-		RAS_EXT_support._ARB_shader_objects 
+	if( GLEW_ARB_fragment_shader &&
+		GLEW_ARB_vertex_shader &&
+		GLEW_ARB_shader_objects 
 		)
 	{
 		if(len == 2) 
-			bgl::blUniform2ivARB(uniform, 1, (GLint*)val);
+			glUniform2ivARB(uniform, 1, (GLint*)val);
 		else if (len == 3)
-			bgl::blUniform3ivARB(uniform, 1, (GLint*)val);
+			glUniform3ivARB(uniform, 1, (GLint*)val);
 		else if (len == 4)
-			bgl::blUniform4ivARB(uniform, 1, (GLint*)val);
+			glUniform4ivARB(uniform, 1, (GLint*)val);
 		else
 			MT_assert(0);
 	}
-#endif
 }
 
 
@@ -849,7 +791,6 @@ PyParentObject BL_Shader::Parents[] = {
 
 KX_PYMETHODDEF_DOC( BL_Shader, setSource," setSource(vertexProgram, fragmentProgram)" )
 {
-#ifdef GL_ARB_shader_objects
 	if(mShader !=0 && mOk  )
 	{
 		// already set...
@@ -862,7 +803,7 @@ KX_PYMETHODDEF_DOC( BL_Shader, setSource," setSource(vertexProgram, fragmentProg
 		vertProg = v;
 		fragProg = f;
 		if( LinkProgram() ) {
-			bgl::blUseProgramObjectARB( mShader );
+			glUseProgramObjectARB( mShader );
 			mUse = apply!=0;
 			Py_Return;
 		}
@@ -871,24 +812,19 @@ KX_PYMETHODDEF_DOC( BL_Shader, setSource," setSource(vertexProgram, fragmentProg
 		mUse = 0;
 		Py_Return;
 	}
-	return NULL;
-#else
 	Py_Return;
-#endif
 }
 
 
 KX_PYMETHODDEF_DOC( BL_Shader, delSource, "delSource( )" )
 {
-#ifdef GL_ARB_shader_objects
 	ClearUniforms();
-	bgl::blUseProgramObjectARB(0);
+	glUseProgramObjectARB(0);
 
-	bgl::blDeleteObjectARB(mShader);
+	glDeleteObjectARB(mShader);
 	mShader		= 0;
 	mOk			= 0;
 	mUse		= 0;
-#endif
 	Py_Return;
 }
 
@@ -909,7 +845,6 @@ KX_PYMETHODDEF_DOC( BL_Shader, getFragmentProg ,"getFragmentProg( )" )
 
 KX_PYMETHODDEF_DOC( BL_Shader, validate, "validate()")
 {
-#ifdef GL_ARB_shader_objects
 	if(mError) {
 		Py_INCREF(Py_None);
 		return Py_None;
@@ -919,15 +854,15 @@ KX_PYMETHODDEF_DOC( BL_Shader, validate, "validate()")
 		return NULL;
 	}
 	int stat = 0;
-	bgl::blValidateProgramARB(mShader);
-	bgl::blGetObjectParameterivARB(mShader, GL_OBJECT_VALIDATE_STATUS_ARB,(GLint*) &stat);
+	glValidateProgramARB(mShader);
+	glGetObjectParameterivARB(mShader, GL_OBJECT_VALIDATE_STATUS_ARB,(GLint*) &stat);
 
 
 	if(stat > 0 && stat < MAX_LOG_LEN) {
 		int char_len=0;
 		char *logInf = (char*)MEM_mallocN(stat, "validate-log");
 
-		bgl::blGetInfoLogARB(mShader, stat,(GLsizei*) &char_len, logInf);
+		glGetInfoLogARB(mShader, stat,(GLsizei*) &char_len, logInf);
 		if(char_len >0) {
 			spit("---- GLSL Validation ----");
 			spit(logInf);
@@ -935,7 +870,6 @@ KX_PYMETHODDEF_DOC( BL_Shader, validate, "validate()")
 		MEM_freeN(logInf);
 		logInf=0;
 	}
-#endif//GL_ARB_shader_objects
 	Py_Return;
 }
 
@@ -1412,7 +1346,6 @@ KX_PYMETHODDEF_DOC( BL_Shader, setUniformMatrix3,
 
 KX_PYMETHODDEF_DOC( BL_Shader, setAttrib, "setAttrib(enum)" )
 {
-#ifdef GL_ARB_shader_objects
 	if(mError) {
 		Py_INCREF(Py_None);
 		return Py_None;
@@ -1424,11 +1357,10 @@ KX_PYMETHODDEF_DOC( BL_Shader, setAttrib, "setAttrib(enum)" )
 			return NULL;
 		}
 		mAttr=SHD_TANGENT;
-		bgl::blUseProgramObjectARB(mShader);
-		bgl::blBindAttribLocationARB(mShader, mAttr, "Tangent");
+		glUseProgramObjectARB(mShader);
+		glBindAttribLocationARB(mShader, mAttr, "Tangent");
 		Py_Return;
 	}
-#endif
 	return NULL;
 }
 
diff --git a/source/gameengine/Ketsji/BL_Texture.cpp b/source/gameengine/Ketsji/BL_Texture.cpp
index 687b1af957d..f24ef4322f0 100644
--- a/source/gameengine/Ketsji/BL_Texture.cpp
+++ b/source/gameengine/Ketsji/BL_Texture.cpp
@@ -1,19 +1,6 @@
 // ------------------------------------
-#ifdef WIN32
-#include <windows.h>
-#endif // WIN32
-#ifdef __APPLE__
-#define GL_GLEXT_LEGACY 1
-#include <OpenGL/gl.h>
-#include <OpenGL/glu.h>
-#else
-#include <GL/gl.h>
-/* #if defined(__sun__) && !defined(__sparc__)
-#include <mesa/glu.h>
-#else */
-#include <GL/glu.h>
-/* #endif */
-#endif
+
+#include "GL/glew.h"
 
 #include <iostream>
 #include <map>
@@ -30,15 +17,11 @@
 #include "BLI_blenlib.h"
 
 #include "RAS_OpenGLRasterizer/RAS_GLExtensionManager.h"
-#include "RAS_OpenGLRasterizer/ARB_multitexture.h"
 #include "RAS_ICanvas.h"
 #include "RAS_Rect.h"
 
 #include "KX_GameObject.h"
 
-
-using namespace bgl;
-
 #define spit(x) std::cout << x << std::endl;
 
 #include "MEM_guardedalloc.h"
@@ -220,9 +203,7 @@ void BL_Texture::InitNonPow2Tex(unsigned int *pix,int x,int y,bool mipmap)
 
 bool BL_Texture::InitCubeMap(int unit,  EnvMap *cubemap)
 {
-#ifdef GL_ARB_texture_cube_map
-
-	if (!RAS_EXT_support._ARB_texture_cube_map)
+	if (!GLEW_ARB_texture_cube_map)
 	{
 		spit("cubemaps not supported");
 		mOk = false;
@@ -312,9 +293,8 @@ bool BL_Texture::InitCubeMap(int unit,  EnvMap *cubemap)
 	glTexParameteri( GL_TEXTURE_CUBE_MAP_ARB, GL_TEXTURE_MAG_FILTER, GL_LINEAR );
 	glTexParameteri( GL_TEXTURE_CUBE_MAP_ARB, GL_TEXTURE_WRAP_S,	 GL_CLAMP_TO_EDGE );
 	glTexParameteri( GL_TEXTURE_CUBE_MAP_ARB, GL_TEXTURE_WRAP_T,	 GL_CLAMP_TO_EDGE );
-	#ifdef GL_VERSION_1_2
-	glTexParameteri( GL_TEXTURE_CUBE_MAP_ARB, GL_TEXTURE_WRAP_R,	 GL_CLAMP_TO_EDGE );
-	#endif
+	if(GLEW_VERSION_1_2)
+		glTexParameteri( GL_TEXTURE_CUBE_MAP_ARB, GL_TEXTURE_WRAP_R,	 GL_CLAMP_TO_EDGE );
 
 	if (needs_split)
 		my_free_envmapdata(cubemap);
@@ -326,13 +306,6 @@ bool BL_Texture::InitCubeMap(int unit,  EnvMap *cubemap)
 
 	mOk = IsValid();
 	return mOk;
-
-#else
-
-	mOk = false;
-	return mOk;
-
-#endif//GL_ARB_texture_cube_map
 }
 
 bool BL_Texture::IsValid()
@@ -362,58 +335,40 @@ int BL_Texture::GetMaxUnits()
 {
 	GLint unit=0;
 
-#if defined(GL_ARB_multitexture) && defined(WITH_GLEXT)
-	if (!getenv("WITHOUT_GLEXT")) {
-		if(RAS_EXT_support._ARB_multitexture) {
-			glGetIntegerv(GL_MAX_TEXTURE_UNITS_ARB, &unit);
-			return (MAXTEX>=unit?unit:MAXTEX);
-		}
+	if(GLEW_ARB_multitexture) {
+		glGetIntegerv(GL_MAX_TEXTURE_UNITS_ARB, &unit);
+		return (MAXTEX>=unit?unit:MAXTEX);
 	}
-#endif
+
 	return 0;
 }
 
 void BL_Texture::ActivateFirst()
 {
-#if defined(GL_ARB_multitexture) && defined(WITH_GLEXT)
-	if (!getenv("WITHOUT_GLEXT")) {
-		if(RAS_EXT_support._ARB_multitexture)
-			bgl::blActiveTextureARB(GL_TEXTURE0_ARB);
-	}
-#endif
+	if(GLEW_ARB_multitexture)
+		glActiveTextureARB(GL_TEXTURE0_ARB);
 }
 
 void BL_Texture::ActivateUnit(int unit)
 {
-#if defined(GL_ARB_multitexture) && defined(WITH_GLEXT)
-	if (!getenv("WITHOUT_GLEXT")) {
-		if(RAS_EXT_support._ARB_multitexture)
-			if(unit <= MAXTEX)
-				bgl::blActiveTextureARB(GL_TEXTURE0_ARB+unit);
-	}
-#endif
+	if(GLEW_ARB_multitexture)
+		if(unit <= MAXTEX)
+			glActiveTextureARB(GL_TEXTURE0_ARB+unit);
 }
 
 
 void BL_Texture::DisableUnit()
 {
-#if defined(GL_ARB_multitexture) && defined(WITH_GLEXT)
-	if (!getenv("WITHOUT_GLEXT")) {
-		if(RAS_EXT_support._ARB_multitexture)
-			bgl::blActiveTextureARB(GL_TEXTURE0_ARB+mUnit);
-	}
-#endif
-
+	if(GLEW_ARB_multitexture)
+		glActiveTextureARB(GL_TEXTURE0_ARB+mUnit);
 
 	glMatrixMode(GL_TEXTURE);
 	glLoadIdentity();
 	glMatrixMode(GL_MODELVIEW);
 
-	#ifdef GL_ARB_texture_cube_map
-	if(RAS_EXT_support._ARB_texture_cube_map && glIsEnabled(GL_TEXTURE_CUBE_MAP_ARB))
+	if(GLEW_ARB_texture_cube_map && glIsEnabled(GL_TEXTURE_CUBE_MAP_ARB))
 		glDisable(GL_TEXTURE_CUBE_MAP_ARB);
 	else
-	#endif
 	{
 		if (glIsEnabled(GL_TEXTURE_2D))
 			glDisable(GL_TEXTURE_2D);
@@ -429,56 +384,45 @@ void BL_Texture::DisableUnit()
 
 void BL_Texture::DisableAllTextures()
 {
-#if defined(GL_ARB_multitexture) && defined(WITH_GLEXT)
-	if (!getenv("WITHOUT_GLEXT")) {
-		glDisable(GL_BLEND);
-		for(int i=0; i<MAXTEX; i++) {
-			if(RAS_EXT_support._ARB_multitexture)
-				bgl::blActiveTextureARB(GL_TEXTURE0_ARB+i);
-
-			glMatrixMode(GL_TEXTURE);
-			glLoadIdentity();
-			glMatrixMode(GL_MODELVIEW);
-			glDisable(GL_TEXTURE_2D);	
-			glDisable(GL_TEXTURE_GEN_S);
-			glDisable(GL_TEXTURE_GEN_T);
-			glDisable(GL_TEXTURE_GEN_R);
-			glDisable(GL_TEXTURE_GEN_Q);
-			glTexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_MODULATE );
-		}
-		if(RAS_EXT_support._ARB_multitexture)
-			bgl::blActiveTextureARB(GL_TEXTURE0_ARB);
+	glDisable(GL_BLEND);
+
+	for(int i=0; i<MAXTEX; i++) {
+		if(GLEW_ARB_multitexture)
+			glActiveTextureARB(GL_TEXTURE0_ARB+i);
+
+		glMatrixMode(GL_TEXTURE);
+		glLoadIdentity();
+		glMatrixMode(GL_MODELVIEW);
+		glDisable(GL_TEXTURE_2D);	
+		glDisable(GL_TEXTURE_GEN_S);
+		glDisable(GL_TEXTURE_GEN_T);
+		glDisable(GL_TEXTURE_GEN_R);
+		glDisable(GL_TEXTURE_GEN_Q);
+		glTexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_MODULATE );
 	}
-#endif
+
+	if(GLEW_ARB_multitexture)
+		glActiveTextureARB(GL_TEXTURE0_ARB);
 }
 
 
 void BL_Texture::ActivateTexture()
 {
-#if defined(GL_ARB_multitexture) && defined(WITH_GLEXT)
-	if (!getenv("WITHOUT_GLEXT")) {
-		if(RAS_EXT_support._ARB_multitexture)
-			bgl::blActiveTextureARB(GL_TEXTURE0_ARB+mUnit);
+	if(GLEW_ARB_multitexture)
+		glActiveTextureARB(GL_TEXTURE0_ARB+mUnit);
 
-#ifdef GL_ARB_texture_cube_map
-		if (mType == GL_TEXTURE_CUBE_MAP_ARB && RAS_EXT_support._ARB_texture_cube_map)
-		{
-			glBindTexture( GL_TEXTURE_CUBE_MAP_ARB, mTexture );	
-			glEnable(GL_TEXTURE_CUBE_MAP_ARB);
-		} else
-#endif
-		{
-
-			#ifdef GL_ARB_texture_cube_map
-			if(RAS_EXT_support._ARB_texture_cube_map )
-				glDisable(GL_TEXTURE_CUBE_MAP_ARB);
-			#endif
+	if (mType == GL_TEXTURE_CUBE_MAP_ARB && GLEW_ARB_texture_cube_map)
+	{
+		glBindTexture( GL_TEXTURE_CUBE_MAP_ARB, mTexture );	
+		glEnable(GL_TEXTURE_CUBE_MAP_ARB);
+	}
+	else {
+		if(GLEW_ARB_texture_cube_map )
+			glDisable(GL_TEXTURE_CUBE_MAP_ARB);
 
-			glBindTexture( GL_TEXTURE_2D, mTexture );	
-			glEnable(GL_TEXTURE_2D);
-		}
+		glBindTexture( GL_TEXTURE_2D, mTexture );	
+		glEnable(GL_TEXTURE_2D);
 	}
-#endif
 }
 
 void BL_Texture::SetMapping(int mode)
@@ -492,9 +436,8 @@ void BL_Texture::SetMapping(int mode)
 		return;
 	}
 
-#ifdef GL_ARB_texture_cube_map
 	if( mType == GL_TEXTURE_CUBE_MAP_ARB && 
-		RAS_EXT_support._ARB_texture_cube_map &&
+		GLEW_ARB_texture_cube_map &&
 		mode &USEREFL) 
 	{
 		glTexGeni(GL_S, GL_TEXTURE_GEN_MODE, GL_REFLECTION_MAP_ARB );
@@ -508,7 +451,6 @@ void BL_Texture::SetMapping(int mode)
 		return;
 	}
 	else
-#endif
 	{
 		glTexGeni(GL_S, GL_TEXTURE_GEN_MODE, GL_SPHERE_MAP );
 		glTexGeni(GL_T, GL_TEXTURE_GEN_MODE, GL_SPHERE_MAP );
@@ -523,11 +465,7 @@ void BL_Texture::SetMapping(int mode)
 
 void BL_Texture::setTexEnv(BL_Material *mat, bool modulate)
 {
-#ifndef GL_ARB_texture_env_combine
-	glTexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_MODULATE );
-	return;
-#else
-	if(modulate || !RAS_EXT_support._ARB_texture_env_combine){
+	if(modulate || !GLEW_ARB_texture_env_combine){
 		glTexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_MODULATE );
 		return;
 	}
@@ -661,7 +599,6 @@ void BL_Texture::setTexEnv(BL_Material *mat, bool modulate)
 	glTexEnvf(	GL_TEXTURE_ENV, GL_RGB_SCALE_ARB,	1.0);
 
 	glEndList();
-#endif //!GL_ARB_texture_env_combine
 }
 
 int BL_Texture::GetPow2(int n)
diff --git a/source/gameengine/Ketsji/CMakeLists.txt b/source/gameengine/Ketsji/CMakeLists.txt
index a10b07ff491..3b907d8d530 100644
--- a/source/gameengine/Ketsji/CMakeLists.txt
+++ b/source/gameengine/Ketsji/CMakeLists.txt
@@ -59,6 +59,7 @@ SET(INC
   ../../../source/blender/blenloader
   ../../../extern/bullet2/src
   ../../../extern/solid
+  ../../../extern/glew/include
   ${PYTHON_INC}
   ${SDL_INC}
 )
diff --git a/source/gameengine/Ketsji/KX_BlenderMaterial.cpp b/source/gameengine/Ketsji/KX_BlenderMaterial.cpp
index cc978760da7..02b1ffd432a 100644
--- a/source/gameengine/Ketsji/KX_BlenderMaterial.cpp
+++ b/source/gameengine/Ketsji/KX_BlenderMaterial.cpp
@@ -6,22 +6,7 @@
 #include <config.h>
 #endif
 
-#ifdef WIN32
-#include <windows.h>
-#endif // WIN32
-#ifdef __APPLE__
-#define GL_GLEXT_LEGACY 1
-#include <OpenGL/gl.h>
-#include <OpenGL/glu.h>
-#else
-#include <GL/gl.h>
-/* #if defined(__sun__) && !defined(__sparc__)
-#include <mesa/glu.h>
-#else
-*/
-#include <GL/glu.h>
-/* #endif */
-#endif
+#include "GL/glew.h"
 
 #include "KX_BlenderMaterial.h"
 #include "BL_Material.h"
@@ -37,7 +22,6 @@
 #include "RAS_MeshObject.h"
 #include "RAS_IRasterizer.h"
 #include "RAS_OpenGLRasterizer/RAS_GLExtensionManager.h"
-#include "RAS_OpenGLRasterizer/ARB_multitexture.h"
 
 extern "C" {
 #include "BDR_drawmesh.h"
@@ -52,7 +36,6 @@ extern "C" {
 #include "DNA_meshdata_types.h"
 #include "BKE_mesh.h"
 // ------------------------------------
-using namespace bgl;
 #define spit(x) std::cout << x << std::endl;
 
 //static PyObject *gTextureDict = 0;
@@ -81,6 +64,7 @@ KX_BlenderMaterial::KX_BlenderMaterial(
 	),
 	mMaterial(data),
 	mShader(0),
+	mBlenderShader(0),
 	mScene(scene),
 	mUserDefBlend(0),
 	mModified(0),
@@ -100,9 +84,6 @@ KX_BlenderMaterial::KX_BlenderMaterial(
 	int max = BL_Texture::GetMaxUnits();
 	mMaterial->num_enabled = enabled>=max?max:enabled;
 
-	// base class
-	m_enabled = mMaterial->num_enabled;
-
 	// test the sum of the various modes for equality
 	// so we can ether accept or reject this material 
 	// as being equal, this is rather important to 
@@ -144,25 +125,30 @@ void KX_BlenderMaterial::OnConstruction()
 	if (mConstructed)
 		// when material are reused between objects
 		return;
-
-	// for each unique material...
-	int i;
-	for(i=0; i<mMaterial->num_enabled; i++) {
-		if( mMaterial->mapping[i].mapping & USEENV ) {
-			if(!RAS_EXT_support._ARB_texture_cube_map) {
-				spit("CubeMap textures not supported");
-				continue;
-			}
-			if(!mTextures[i].InitCubeMap(i, mMaterial->cubemap[i] ) )
-				spit("unable to initialize image("<<i<<") in "<< 
-						 mMaterial->matname<< ", image will not be available");
-		} 
 	
-		else {
-			if( mMaterial->img[i] ) {
-				if( ! mTextures[i].InitFromImage(i, mMaterial->img[i], (mMaterial->flag[i] &MIPMAP)!=0 ))
+	if(mMaterial->glslmat) {
+		SetBlenderGLSLShader();
+	}
+	else {
+		// for each unique material...
+		int i;
+		for(i=0; i<mMaterial->num_enabled; i++) {
+			if( mMaterial->mapping[i].mapping & USEENV ) {
+				if(!GLEW_ARB_texture_cube_map) {
+					spit("CubeMap textures not supported");
+					continue;
+				}
+				if(!mTextures[i].InitCubeMap(i, mMaterial->cubemap[i] ) )
 					spit("unable to initialize image("<<i<<") in "<< 
-						mMaterial->matname<< ", image will not be available");
+							 mMaterial->matname<< ", image will not be available");
+			} 
+		
+			else {
+				if( mMaterial->img[i] ) {
+					if( ! mTextures[i].InitFromImage(i, mMaterial->img[i], (mMaterial->flag[i] &MIPMAP)!=0 ))
+						spit("unable to initialize image("<<i<<") in "<< 
+							mMaterial->matname<< ", image will not be available");
+				}
 			}
 		}
 	}
@@ -176,11 +162,17 @@ void KX_BlenderMaterial::OnExit()
 	if( mShader ) {
 		 //note, the shader here is allocated, per unique material
 		 //and this function is called per face
-		mShader->SetProg(0);
+		mShader->SetProg(false);
 		delete mShader;
 		mShader = 0;
 	}
 
+	if( mBlenderShader ) {
+		mBlenderShader->SetProg(false);
+		delete mBlenderShader;
+		mBlenderShader = 0;
+	}
+
 	BL_Texture::ActivateFirst();
 	for(int i=0; i<mMaterial->num_enabled; i++) {
 		BL_Texture::ActivateUnit(i);
@@ -195,7 +187,7 @@ void KX_BlenderMaterial::OnExit()
 
 void KX_BlenderMaterial::setShaderData( bool enable, RAS_IRasterizer *ras)
 {
-	MT_assert(RAS_EXT_support._ARB_shader_objects && mShader);
+	MT_assert(GLEW_ARB_shader_objects && mShader);
 
 	int i;
 	if( !enable || !mShader->Ok() ) {
@@ -229,10 +221,23 @@ void KX_BlenderMaterial::setShaderData( bool enable, RAS_IRasterizer *ras)
 	}
 }
 
+void KX_BlenderMaterial::setBlenderShaderData( bool enable, RAS_IRasterizer *ras)
+{
+	if( !enable || !mBlenderShader->Ok() ) {
+		// frame cleanup.
+		mBlenderShader->SetProg(false);
+		BL_Texture::DisableAllTextures();
+		return;
+	}
+
+	BL_Texture::DisableAllTextures();
+	mBlenderShader->SetProg(true);
+	mBlenderShader->ApplyShader();
+}
 
 void KX_BlenderMaterial::setTexData( bool enable, RAS_IRasterizer *ras)
 {
-	if(RAS_EXT_support._ARB_shader_objects && mShader) 
+	if(GLEW_ARB_shader_objects && mShader) 
 		mShader->SetProg(false);
 
 	BL_Texture::DisableAllTextures();
@@ -301,12 +306,53 @@ KX_BlenderMaterial::ActivatShaders(
 		
 		cachingInfo = GetCachingInfo();
 	
-		if (rasty->GetDrawingMode() == RAS_IRasterizer::KX_TEXTURED ) {
+		if(rasty->GetDrawingMode() == RAS_IRasterizer::KX_TEXTURED)
 			tmp->setShaderData( true, rasty);
+		else
+			tmp->setShaderData( false, rasty);
+
+		if(mMaterial->mode & RAS_IRasterizer::KX_TWOSIDE)
+			rasty->SetCullFace(false);
+		else
+			rasty->SetCullFace(true);
+
+		if (((mMaterial->ras_mode &WIRE)!=0) || mMaterial->mode & RAS_IRasterizer::KX_LINES)
+		{		
+			if((mMaterial->ras_mode &WIRE)!=0) 
+				rasty->SetCullFace(false);
+			rasty->SetLines(true);
+		}
+		else
+			rasty->SetLines(false);
+	}
+
+	ActivatGLMaterials(rasty);
+	ActivateTexGen(rasty);
+}
+
+void
+KX_BlenderMaterial::ActivateBlenderShaders(
+	RAS_IRasterizer* rasty, 
+	TCachingInfo& cachingInfo)const
+{
+	KX_BlenderMaterial *tmp = const_cast<KX_BlenderMaterial*>(this);
+
+	// reset... 
+	if(tmp->mMaterial->IsShared()) 
+		cachingInfo =0;
+	
+	if (GetCachingInfo() != cachingInfo) {
+		if (!cachingInfo)
+			tmp->setBlenderShaderData(false, rasty);
+		
+		cachingInfo = GetCachingInfo();
+	
+		if(rasty->GetDrawingMode() == RAS_IRasterizer::KX_TEXTURED) {
+			tmp->setBlenderShaderData(true, rasty);
 			rasty->EnableTextures(true);
 		}
 		else {
-			tmp->setShaderData( false, rasty);
+			tmp->setBlenderShaderData(false, rasty);
 			rasty->EnableTextures(false);
 		}
 
@@ -326,7 +372,7 @@ KX_BlenderMaterial::ActivatShaders(
 	}
 
 	ActivatGLMaterials(rasty);
-	ActivateTexGen(rasty);
+	mBlenderShader->SetTexCoords(rasty);
 }
 
 void
@@ -342,14 +388,10 @@ KX_BlenderMaterial::ActivateMat(
 		
 		cachingInfo = GetCachingInfo();
 
-		if (rasty->GetDrawingMode() == RAS_IRasterizer::KX_TEXTURED) {
+		if (rasty->GetDrawingMode() == RAS_IRasterizer::KX_TEXTURED)
 			tmp->setTexData( true,rasty  );
-			rasty->EnableTextures(true);
-		}
-		else{
+		else
 			tmp->setTexData( false,rasty);
-			rasty->EnableTextures(false);
-		}
 
 		if(mMaterial->mode & RAS_IRasterizer::KX_TWOSIDE)
 			rasty->SetCullFace(false);
@@ -365,11 +407,11 @@ KX_BlenderMaterial::ActivateMat(
 		else
 			rasty->SetLines(false);
 	}
+
 	ActivatGLMaterials(rasty);
 	ActivateTexGen(rasty);
 }
 
-
 bool 
 KX_BlenderMaterial::Activate( 
 	RAS_IRasterizer* rasty,  
@@ -377,7 +419,7 @@ KX_BlenderMaterial::Activate(
 	)const
 {
 	bool dopass = false;
-	if( RAS_EXT_support._ARB_shader_objects && ( mShader && mShader->Ok() ) ) {
+	if( GLEW_ARB_shader_objects && ( mShader && mShader->Ok() ) ) {
 		if( (mPass++) < mShader->getNumPass() ) {
 			ActivatShaders(rasty, cachingInfo);
 			dopass = true;
@@ -390,6 +432,18 @@ KX_BlenderMaterial::Activate(
 			return dopass;
 		}
 	}
+	else if( GLEW_ARB_shader_objects && ( mBlenderShader && mBlenderShader->Ok() ) ) {
+		if( (mPass++) == 0 ) {
+			ActivateBlenderShaders(rasty, cachingInfo);
+			dopass = true;
+			return dopass;
+		}
+		else {
+			mPass = 0;
+			dopass = false;
+			return dopass;
+		}
+	}
 	else {
 		switch (mPass++)
 		{
@@ -408,34 +462,39 @@ KX_BlenderMaterial::Activate(
 
 void KX_BlenderMaterial::ActivateMeshSlot(const KX_MeshSlot & ms, RAS_IRasterizer* rasty) const
 {
-	if(mShader && RAS_EXT_support._ARB_shader_objects)
+	if(mShader && GLEW_ARB_shader_objects)
 		mShader->Update(ms, rasty);
+	if(mBlenderShader && GLEW_ARB_shader_objects)
+		mBlenderShader->Update(ms, rasty);
 }
 
 void KX_BlenderMaterial::ActivatGLMaterials( RAS_IRasterizer* rasty )const
 {
-	rasty->SetSpecularity(
-		mMaterial->speccolor[0]*mMaterial->spec_f,
-		mMaterial->speccolor[1]*mMaterial->spec_f,
-		mMaterial->speccolor[2]*mMaterial->spec_f,
-		mMaterial->spec_f
-	);
+	if(!mBlenderShader) {
+		rasty->SetSpecularity(
+			mMaterial->speccolor[0]*mMaterial->spec_f,
+			mMaterial->speccolor[1]*mMaterial->spec_f,
+			mMaterial->speccolor[2]*mMaterial->spec_f,
+			mMaterial->spec_f
+		);
+
+		rasty->SetShinyness( mMaterial->hard );
 
-	rasty->SetShinyness( mMaterial->hard );
+		rasty->SetDiffuse(
+			mMaterial->matcolor[0]*mMaterial->ref+mMaterial->emit, 
+			mMaterial->matcolor[1]*mMaterial->ref+mMaterial->emit,
+			mMaterial->matcolor[2]*mMaterial->ref+mMaterial->emit,
+			1.0f);
 
-	rasty->SetDiffuse(
-		mMaterial->matcolor[0]*mMaterial->ref+mMaterial->emit, 
-		mMaterial->matcolor[1]*mMaterial->ref+mMaterial->emit,
-		mMaterial->matcolor[2]*mMaterial->ref+mMaterial->emit,
-		1.0f);
+		rasty->SetEmissive(	
+			mMaterial->matcolor[0]*mMaterial->emit,
+			mMaterial->matcolor[1]*mMaterial->emit,
+			mMaterial->matcolor[2]*mMaterial->emit,
+			1.0 );
 
-	rasty->SetEmissive(	
-		mMaterial->matcolor[0]*mMaterial->emit,
-		mMaterial->matcolor[1]*mMaterial->emit,
-		mMaterial->matcolor[2]*mMaterial->emit,
-		1.0 );
+		rasty->SetAmbient(mMaterial->amb);
+	}
 
-	rasty->SetAmbient(mMaterial->amb);
 	if (mMaterial->material)
 		rasty->SetPolygonOffset(-mMaterial->material->zoffs, 0.0);
 }
@@ -443,34 +502,46 @@ void KX_BlenderMaterial::ActivatGLMaterials( RAS_IRasterizer* rasty )const
 
 void KX_BlenderMaterial::ActivateTexGen(RAS_IRasterizer *ras) const
 {
-	if(mShader && RAS_EXT_support._ARB_shader_objects)
-		if(mShader->GetAttribute() == BL_Shader::SHD_TANGENT)
-			ras->SetAttrib(RAS_IRasterizer::RAS_TEXTANGENT);
+	if(ras->GetDrawingMode() == RAS_IRasterizer::KX_TEXTURED) {
+		ras->SetAttribNum(0);
+		if(mShader && GLEW_ARB_shader_objects) {
+			if(mShader->GetAttribute() == BL_Shader::SHD_TANGENT) {
+				ras->SetAttrib(RAS_IRasterizer::RAS_TEXTANGENT, 1);
+				ras->SetAttribNum(2);
+			}
+		}
 
-	for(int i=0; i<mMaterial->num_enabled; i++) {
-		int mode = mMaterial->mapping[i].mapping;
+		ras->SetTexCoordNum(mMaterial->num_enabled);
 
-		if (mode &USECUSTOMUV)
-		{
-			STR_String str = mMaterial->mapping[i].uvCoName;
-			if (!str.IsEmpty())
-				ras->SetTexCoords(RAS_IRasterizer::RAS_TEXCO_UV2, i);
-			continue;
+		for(int i=0; i<mMaterial->num_enabled; i++) {
+			int mode = mMaterial->mapping[i].mapping;
+
+			if (mode &USECUSTOMUV)
+			{
+				STR_String str = mMaterial->mapping[i].uvCoName;
+				if (!str.IsEmpty())
+					ras->SetTexCoord(RAS_IRasterizer::RAS_TEXCO_UV2, i);
+				continue;
+			}
+
+			if( mode &(USEREFL|USEOBJ))
+				ras->SetTexCoord(RAS_IRasterizer::RAS_TEXCO_GEN, i);
+			else if(mode &USEORCO)
+				ras->SetTexCoord(RAS_IRasterizer::RAS_TEXCO_ORCO, i);
+			else if(mode &USENORM)
+				ras->SetTexCoord(RAS_IRasterizer::RAS_TEXCO_NORM, i);
+			else if(mode &USEUV)
+				ras->SetTexCoord(RAS_IRasterizer::RAS_TEXCO_UV1, i);
+			else if(mode &USETANG)
+				ras->SetTexCoord(RAS_IRasterizer::RAS_TEXTANGENT, i);
+			else 
+				ras->SetTexCoord(RAS_IRasterizer::RAS_TEXCO_DISABLE, i);
 		}
 
-		if( mode &(USEREFL|USEOBJ))
-			ras->SetTexCoords(RAS_IRasterizer::RAS_TEXCO_GEN, i);
-		else if(mode &USEORCO)
-			ras->SetTexCoords(RAS_IRasterizer::RAS_TEXCO_ORCO, i);
-		else if(mode &USENORM)
-			ras->SetTexCoords(RAS_IRasterizer::RAS_TEXCO_NORM, i);
-		else if(mode &USEUV)
-			ras->SetTexCoords(RAS_IRasterizer::RAS_TEXCO_UV1, i);
-		else if(mode &USETANG)
-			ras->SetTexCoords(RAS_IRasterizer::RAS_TEXTANGENT, i);
-		else 
-			ras->SetTexCoords(RAS_IRasterizer::RAS_TEXCO_DISABLE, i);
+		ras->EnableTextures(true);
 	}
+	else
+		ras->EnableTextures(false);
 }
 
 bool KX_BlenderMaterial::setDefaultBlending()
@@ -503,8 +574,7 @@ void KX_BlenderMaterial::setTexMatrixData(int i)
 	glMatrixMode(GL_TEXTURE);
 	glLoadIdentity();
 
-#ifdef GL_ARB_texture_cube_map
-	if( RAS_EXT_support._ARB_texture_cube_map && 
+	if( GLEW_ARB_texture_cube_map && 
 		mTextures[i].GetTextureType() == GL_TEXTURE_CUBE_MAP_ARB && 
 		mMaterial->mapping[i].mapping & USEREFL) {
 		glScalef( 
@@ -514,7 +584,6 @@ void KX_BlenderMaterial::setTexMatrixData(int i)
 		);
 	}
 	else
-#endif
 	{
 		glScalef( 
 			mMaterial->mapping[i].scale[0], 
@@ -663,28 +732,23 @@ int KX_BlenderMaterial::_setattr(const STR_String& attr, PyObject *pyvalue)
 
 KX_PYMETHODDEF_DOC( KX_BlenderMaterial, getShader , "getShader()")
 {
-#ifdef GL_ARB_fragment_shader
-	if( !RAS_EXT_support._ARB_fragment_shader) {
+	if( !GLEW_ARB_fragment_shader) {
 		if(!mModified)
 			spit("Fragment shaders not supported");
 	
 		mModified = true;
 		Py_Return;
 	}
-#endif
 
-#ifdef GL_ARB_vertex_shader
-	if( !RAS_EXT_support._ARB_vertex_shader) {
+	if( !GLEW_ARB_vertex_shader) {
 		if(!mModified)
 			spit("Vertex shaders not supported");
 
 		mModified = true;
 		Py_Return;
 	}
-#endif
 
-#ifdef GL_ARB_shader_objects
-	if(!RAS_EXT_support._ARB_shader_objects)  {
+	if(!GLEW_ARB_shader_objects)  {
 		if(!mModified)
 			spit("GLSL not supported");
 		mModified = true;
@@ -723,13 +787,20 @@ KX_PYMETHODDEF_DOC( KX_BlenderMaterial, getShader , "getShader()")
 	}
 	PyErr_Format(PyExc_ValueError, "GLSL Error");
 	return NULL;
-
-#else
-	Py_Return;
-#endif//GL_ARB_shader_objects
 }
 
 
+void KX_BlenderMaterial::SetBlenderGLSLShader(void)
+{
+	if(!mBlenderShader)
+		mBlenderShader = new BL_BlenderShader(mMaterial->material);
+
+	if(!mBlenderShader->Ok()) {
+		delete mBlenderShader;
+		mBlenderShader = 0;
+	}
+}
+
 KX_PYMETHODDEF_DOC( KX_BlenderMaterial, getMaterialIndex, "getMaterialIndex()")
 {
 	return PyInt_FromLong( mMaterial->material_index );
diff --git a/source/gameengine/Ketsji/KX_BlenderMaterial.h b/source/gameengine/Ketsji/KX_BlenderMaterial.h
index b9d48199520..62e96b71937 100644
--- a/source/gameengine/Ketsji/KX_BlenderMaterial.h
+++ b/source/gameengine/Ketsji/KX_BlenderMaterial.h
@@ -8,6 +8,7 @@
 #include "BL_Material.h"
 #include "BL_Texture.h"
 #include "BL_Shader.h"
+#include "BL_BlenderShader.h"
 
 #include "PyObjectPlus.h"
 
@@ -60,6 +61,10 @@ public:
 		TCachingInfo& cachingInfo
 	)const;
 
+	void ActivateBlenderShaders(
+		RAS_IRasterizer* rasty, 
+		TCachingInfo& cachingInfo
+	)const;
 
 	MTFace* GetMTFace(void) const;
 	unsigned int* GetMCol(void) const;
@@ -86,8 +91,9 @@ public:
 	// pre calculate to avoid pops/lag at startup
 	virtual void OnConstruction( );
 private:
-	BL_Material*	mMaterial;
-	BL_Shader*		mShader;
+	BL_Material*		mMaterial;
+	BL_Shader*			mShader;
+	BL_BlenderShader*	mBlenderShader;
 	KX_Scene*		mScene;
 	BL_Texture		mTextures[MAXTEX];		// texture array
 	bool			mUserDefBlend;
@@ -95,12 +101,15 @@ private:
 	bool			mModified;
 	bool			mConstructed;			// if false, don't clean on exit
 
+	void SetBlenderGLSLShader();
+
 	void ActivatGLMaterials( RAS_IRasterizer* rasty )const;
 	void ActivateTexGen( RAS_IRasterizer *ras ) const;
 
 
 	// message centers
 	void	setTexData( bool enable,RAS_IRasterizer *ras);
+	void	setBlenderShaderData( bool enable, RAS_IRasterizer *ras);
 	void	setShaderData( bool enable, RAS_IRasterizer *ras);
 
 	bool	setDefaultBlending();
diff --git a/source/gameengine/Ketsji/KX_GameObject.cpp b/source/gameengine/Ketsji/KX_GameObject.cpp
index 6fde94fec53..5698c106b17 100644
--- a/source/gameengine/Ketsji/KX_GameObject.cpp
+++ b/source/gameengine/Ketsji/KX_GameObject.cpp
@@ -81,8 +81,8 @@ KX_GameObject::KX_GameObject(
 	m_bVisible(true),
 	m_pPhysicsController1(NULL),
 	m_pPhysicsEnvironment(NULL),
-	m_isDeformable(false),
-	m_pHitObject(NULL)
+	m_pHitObject(NULL),
+	m_isDeformable(false)
 {
 	m_ignore_activity_culling = false;
 	m_pClient_info = new KX_ClientObjectInfo(this, KX_ClientObjectInfo::ACTOR);
diff --git a/source/gameengine/Ketsji/KX_ISceneConverter.h b/source/gameengine/Ketsji/KX_ISceneConverter.h
index bba289bf891..f069048cd3d 100644
--- a/source/gameengine/Ketsji/KX_ISceneConverter.h
+++ b/source/gameengine/Ketsji/KX_ISceneConverter.h
@@ -74,6 +74,9 @@ public:
 	virtual void SetMaterials(bool val) =0;
 	virtual bool GetMaterials()=0;
 
+	// use blender glsl materials
+	virtual void SetGLSLMaterials(bool val) =0;
+	virtual bool GetGLSLMaterials()=0;
 };
 
 #endif //__KX_ISCENECONVERTER_H
diff --git a/source/gameengine/Ketsji/KX_PythonInit.cpp b/source/gameengine/Ketsji/KX_PythonInit.cpp
index a80a7f04e8f..0831788009d 100644
--- a/source/gameengine/Ketsji/KX_PythonInit.cpp
+++ b/source/gameengine/Ketsji/KX_PythonInit.cpp
@@ -28,25 +28,7 @@
  * Initialize Python thingies.
  */
 
-#ifdef HAVE_CONFIG_H
-#include <config.h>
-#endif
-
-#ifdef WIN32
-#include <windows.h>
-#endif // WIN32
-#ifdef __APPLE__
-#define GL_GLEXT_LEGACY 1
-#include <OpenGL/gl.h>
-#include <OpenGL/glu.h>
-#else
-#include <GL/gl.h>
-/* #if defined(__sun__) && !defined(__sparc__)
-#include <mesa/glu.h>
-#else */
-#include <GL/glu.h>
-/* #endif */
-#endif
+#include "GL/glew.h"
 
 #include <stdlib.h>
 
@@ -310,17 +292,13 @@ static PyObject* gPyGetCurrentScene(PyObject* self,
 static PyObject *pyPrintExt(PyObject *,PyObject *,PyObject *)
 {
 #define pprint(x) std::cout << x << std::endl;
-	bgl::BL_EXTInfo ext = bgl::RAS_EXT_support;
 	bool count=0;
 	bool support=0;
 	pprint("Supported Extensions...");
-#ifdef GL_ARB_shader_objects
-	pprint(" GL_ARB_shader_objects supported?       "<< (ext._ARB_shader_objects?"yes.":"no."));
+	pprint(" GL_ARB_shader_objects supported?       "<< (GLEW_ARB_shader_objects?"yes.":"no."));
 	count = 1;
-#endif
 
-#ifdef GL_ARB_vertex_shader
-	support= ext._ARB_vertex_shader;
+	support= GLEW_ARB_vertex_shader;
 	pprint(" GL_ARB_vertex_shader supported?        "<< (support?"yes.":"no."));
 	count = 1;
 	if(support){
@@ -339,9 +317,8 @@ static PyObject *pyPrintExt(PyObject *,PyObject *,PyObject *)
 		pprint("  Max combined texture units." << max);
 		pprint("");
 	}
-#endif
-#ifdef GL_ARB_fragment_shader
-	support=ext._ARB_fragment_shader;
+
+	support=GLEW_ARB_fragment_shader;
 	pprint(" GL_ARB_fragment_shader supported?      "<< (support?"yes.":"no."));
 	count = 1;
 	if(support){
@@ -351,9 +328,8 @@ static PyObject *pyPrintExt(PyObject *,PyObject *,PyObject *)
 		pprint("  Max uniform components." << max);
 		pprint("");
 	}
-#endif
-#ifdef GL_ARB_texture_cube_map
-	support = ext._ARB_texture_cube_map;
+
+	support = GLEW_ARB_texture_cube_map;
 	pprint(" GL_ARB_texture_cube_map supported?     "<< (support?"yes.":"no."));
 	count = 1;
 	if(support){
@@ -363,25 +339,21 @@ static PyObject *pyPrintExt(PyObject *,PyObject *,PyObject *)
 		pprint("  Max cubemap size." << size);
 		pprint("");
 	}
-#endif
-#if defined(GL_ARB_multitexture) && defined(WITH_GLEXT)
-	if (!getenv("WITHOUT_GLEXT")) {
-		support = ext._ARB_multitexture;
-		count = 1;
-		pprint(" GL_ARB_multitexture supported?         "<< (support?"yes.":"no."));
-		if(support){
-			pprint(" ----------Details----------");
-			int units=0;
-			glGetIntegerv(GL_MAX_TEXTURE_UNITS_ARB, (GLint*)&units);
-			pprint("  Max texture units available.  " << units);
-			pprint("");
-		}
+
+	support = GLEW_ARB_multitexture;
+	count = 1;
+	pprint(" GL_ARB_multitexture supported?         "<< (support?"yes.":"no."));
+	if(support){
+		pprint(" ----------Details----------");
+		int units=0;
+		glGetIntegerv(GL_MAX_TEXTURE_UNITS_ARB, (GLint*)&units);
+		pprint("  Max texture units available.  " << units);
+		pprint("");
 	}
-#endif
-#ifdef GL_ARB_texture_env_combine
-	pprint(" GL_ARB_texture_env_combine supported?  "<< (ext._ARB_texture_env_combine?"yes.":"no."));
+
+	pprint(" GL_ARB_texture_env_combine supported?  "<< (GLEW_ARB_texture_env_combine?"yes.":"no."));
 	count = 1;
-#endif
+
 	if(!count)
 		pprint("No extenstions are used in this build");
 
diff --git a/source/gameengine/Ketsji/Makefile b/source/gameengine/Ketsji/Makefile
index e6e541d0931..47a4855b00c 100644
--- a/source/gameengine/Ketsji/Makefile
+++ b/source/gameengine/Ketsji/Makefile
@@ -36,6 +36,7 @@ include nan_compile.mk
 CCFLAGS += $(LEVEL_1_CPP_WARNINGS)
 
 CPPFLAGS += $(OGL_CPPFLAGS)
+CPPFLAGS += -I$(NAN_GLEW)/include
 CPPFLAGS += -I$(OPENGL_HEADERS)
 CPPFLAGS += -I$(NAN_PYTHON)/include/python$(NAN_PYTHON_VERSION) -I../../blender/python
 CPPFLAGS += -I$(NAN_STRING)/include    
diff --git a/source/gameengine/Ketsji/SConscript b/source/gameengine/Ketsji/SConscript
index c7c80345796..fdac5a71071 100644
--- a/source/gameengine/Ketsji/SConscript
+++ b/source/gameengine/Ketsji/SConscript
@@ -18,7 +18,7 @@ incs += ' #source/gameengine/SceneGraph #source/gameengine/Physics/common #sourc
 incs += ' #source/gameengine/Physics/BlOde #source/gameengine/Physics/Dummy'
 incs += ' #source/gameengine/Physics/Sumo #source/gameengine/Physics/Sumo/include'
 incs += ' #source/gameengine/Physics/Sumo/Fuzzics/include #source/gameengine/Network/LoopBackNetwork'
-incs += ' #source/blender/misc #source/blender/blenloader'
+incs += ' #source/blender/misc #source/blender/blenloader #extern/glew/include'
 
 cflags = []
 if env['OURPLATFORM'] == 'win32-vc':