Merge of first part of changes from the apricot branch, especially

the features that are needed to run the game. Compile tested with
scons, make, but not cmake, that seems to have an issue not related
to these changes. The changes include:

* GLSL support in the viewport and game engine, enable in the game
  menu in textured draw mode.
* Synced and merged part of the duplicated blender and gameengine/
  gameplayer drawing code.
* Further refactoring of game engine drawing code, especially mesh
  storage changed a lot.
* Optimizations in game engine armatures to avoid recomputations.
* A python function to get the framerate estimate in game.

* An option take object color into account in materials.
* An option to restrict shadow casters to a lamp's layers.
* Increase from 10 to 18 texture slots for materials, lamps, word.
  An extra texture slot shows up once the last slot is used.

* Memory limit for undo, not enabled by default yet because it
  needs the .B.blend to be changed.
* Multiple undo for image painting.

* An offset for dupligroups, so not all objects in a group have to
  be at the origin.

29 files changed, 496 insertions, 454 deletions

diff --git a/source/gameengine/Ketsji/BL_BlenderShader.cpp b/source/gameengine/Ketsji/BL_BlenderShader.cpp
index a9a0771936c..13b8235687b 100644
--- a/source/gameengine/Ketsji/BL_BlenderShader.cpp
+++ b/source/gameengine/Ketsji/BL_BlenderShader.cpp
@@ -9,108 +9,64 @@
 #include "BL_BlenderShader.h"
 #include "BL_Material.h"
 
-#ifdef BLENDER_GLSL
 #include "GPU_extensions.h"
 #include "GPU_material.h"
-#endif
 
 #include "RAS_BucketManager.h"
 #include "RAS_MeshObject.h"
 #include "RAS_IRasterizer.h"
  
- /* this is evil, but we need the scene to create materials with
-  * lights from the correct scene .. */
-static struct Scene *GetSceneForName(const STR_String& scenename)
-{
-	Scene *sce;
-
-	for (sce= (Scene*)G.main->scene.first; sce; sce= (Scene*)sce->id.next)
-		if (scenename == (sce->id.name+2))
-			return sce;
-
-	return (Scene*)G.main->scene.first;
-}
-
-bool BL_BlenderShader::Ok()
-{
-#ifdef BLENDER_GLSL
-	VerifyShader();
-
-	return (mMat && mMat->gpumaterial);
-#else
-	return 0;
-#endif
-}
-
 BL_BlenderShader::BL_BlenderShader(KX_Scene *scene, struct Material *ma, int lightlayer)
 :
-#ifdef BLENDER_GLSL
 	mScene(scene),
 	mMat(ma),
-	mGPUMat(NULL),
-#endif
-	mBound(false),
 	mLightLayer(lightlayer)
 {
-#ifdef BLENDER_GLSL
-	mBlenderScene = GetSceneForName(scene->GetName());
+	mBlenderScene = scene->GetBlenderScene(); //GetSceneForName(scene->GetName());
 	mBlendMode = GPU_BLEND_SOLID;
 
-	if(mMat) {
+	if(mMat)
 		GPU_material_from_blender(mBlenderScene, mMat);
-		mGPUMat = mMat->gpumaterial;
-	}
-#endif
 }
 
 BL_BlenderShader::~BL_BlenderShader()
 {
-#ifdef BLENDER_GLSL
-	if(mMat && mMat->gpumaterial)
-		GPU_material_unbind(mMat->gpumaterial);
-#endif
+	if(mMat && GPU_material_from_blender(mBlenderScene, mMat))
+		GPU_material_unbind(GPU_material_from_blender(mBlenderScene, mMat));
 }
 
-bool BL_BlenderShader::VerifyShader()
+bool BL_BlenderShader::Ok()
 {
-#ifdef BLENDER_GLSL
-	if(mMat && !mMat->gpumaterial)
-		GPU_material_from_blender(mBlenderScene, mMat);
+	return VerifyShader();
+}
 
-	mGPUMat = mMat->gpumaterial;
-	
-	return (mMat && mGPUMat);
-#else
-	return false;
-#endif
+bool BL_BlenderShader::VerifyShader()
+{
+	if(mMat)
+		return (GPU_material_from_blender(mBlenderScene, mMat) != 0);
+	else
+		return false;
 }
 
-void BL_BlenderShader::SetProg(bool enable)
+void BL_BlenderShader::SetProg(bool enable, double time)
 {
-#ifdef BLENDER_GLSL
 	if(VerifyShader()) {
-		if(enable) {
-			GPU_material_bind(mGPUMat, mLightLayer);
-			mBound = true;
-		}
-		else {
-			GPU_material_unbind(mGPUMat);
-			mBound = false;
-		}
+		if(enable)
+			GPU_material_bind(GPU_material_from_blender(mBlenderScene, mMat), mLightLayer, time);
+		else
+			GPU_material_unbind(GPU_material_from_blender(mBlenderScene, mMat));
 	}
-#endif
 }
 
 int BL_BlenderShader::GetAttribNum()
 {
-#ifdef BLENDER_GLSL
 	GPUVertexAttribs attribs;
 	int i, enabled = 0;
 
 	if(!VerifyShader())
 		return enabled;
 
-	GPU_material_vertex_attributes(mGPUMat, &attribs);
+	GPU_material_vertex_attributes(GPU_material_from_blender(mBlenderScene, mMat), &attribs);
 
     for(i = 0; i < attribs.totlayer; i++)
 		if(attribs.layer[i].glindex+1 > enabled)
@@ -120,24 +76,23 @@ int BL_BlenderShader::GetAttribNum()
 		enabled = BL_MAX_ATTRIB;
 
 	return enabled;
-#else
-	return 0;
-#endif
 }
 
 void BL_BlenderShader::SetAttribs(RAS_IRasterizer* ras, const BL_Material *mat)
 {
-#ifdef BLENDER_GLSL
 	GPUVertexAttribs attribs;
+	GPUMaterial *gpumat;
 	int i, attrib_num;
 
 	ras->SetAttribNum(0);
 
 	if(!VerifyShader())
 		return;
+	
+	gpumat = GPU_material_from_blender(mBlenderScene, mMat);
 
 	if(ras->GetDrawingMode() == RAS_IRasterizer::KX_TEXTURED) {
-		GPU_material_vertex_attributes(mGPUMat, &attribs);
+		GPU_material_vertex_attributes(gpumat, &attribs);
 		attrib_num = GetAttribNum();
 
 		ras->SetTexCoordNum(0);
@@ -168,44 +123,37 @@ void BL_BlenderShader::SetAttribs(RAS_IRasterizer* ras, const BL_Material *mat)
 			else
 				ras->SetAttrib(RAS_IRasterizer::RAS_TEXCO_DISABLE, attribs.layer[i].glindex);
 		}
-
-		ras->EnableTextures(true);
 	}
-	else
-		ras->EnableTextures(false);
-#endif
 }
 
-void BL_BlenderShader::Update( const KX_MeshSlot & ms, RAS_IRasterizer* rasty )
+void BL_BlenderShader::Update(const RAS_MeshSlot & ms, RAS_IRasterizer* rasty )
 {
-#ifdef BLENDER_GLSL
 	float obmat[4][4], viewmat[4][4], viewinvmat[4][4], obcol[4];
+	GPUMaterial *gpumat;
 
-	VerifyShader();
+	gpumat = GPU_material_from_blender(mBlenderScene, mMat);
 
-	if(!mGPUMat) // || !mBound)
+	if(!gpumat || !GPU_material_bound(gpumat))
 		return;
 
 	MT_Matrix4x4 model;
 	model.setValue(ms.m_OpenGLMatrix);
-	MT_Matrix4x4 view;
-	rasty->GetViewMatrix(view);
+	const MT_Matrix4x4& view = rasty->GetViewMatrix();
+	const MT_Matrix4x4& viewinv = rasty->GetViewInvMatrix();
 
+	// note: getValue gives back column major as needed by OpenGL
 	model.getValue((float*)obmat);
 	view.getValue((float*)viewmat);
-
-	view.invert();
-	view.getValue((float*)viewinvmat);
+	viewinv.getValue((float*)viewinvmat);
 
 	if(ms.m_bObjectColor)
 		ms.m_RGBAcolor.getValue((float*)obcol);
 	else
 		obcol[0]= obcol[1]= obcol[2]= obcol[3]= 1.0f;
 
-	GPU_material_bind_uniforms(mGPUMat, obmat, viewmat, viewinvmat, obcol);
+	GPU_material_bind_uniforms(gpumat, obmat, viewmat, viewinvmat, obcol);
 
-	mBlendMode = GPU_material_blend_mode(mGPUMat, obcol);
-#endif
+	mBlendMode = GPU_material_blend_mode(gpumat, obcol);
 }
 
 int BL_BlenderShader::GetBlendMode()
@@ -215,12 +163,8 @@ int BL_BlenderShader::GetBlendMode()
 
 bool BL_BlenderShader::Equals(BL_BlenderShader *blshader)
 {
-#ifdef BLENDER_GLSL
 	/* to avoid unneeded state switches */
-	return (blshader && mGPUMat == blshader->mGPUMat && mLightLayer == blshader->mLightLayer);
-#else
-	return true;
-#endif
+	return (blshader && mMat == blshader->mMat && mLightLayer == blshader->mLightLayer);
 }
 
 // eof
diff --git a/source/gameengine/Ketsji/BL_BlenderShader.h b/source/gameengine/Ketsji/BL_BlenderShader.h
index da9765dafa4..5c1f59f94ad 100644
--- a/source/gameengine/Ketsji/BL_BlenderShader.h
+++ b/source/gameengine/Ketsji/BL_BlenderShader.h
@@ -2,9 +2,7 @@
 #ifndef __BL_GPUSHADER_H__
 #define __BL_GPUSHADER_H__
 
-#ifdef BLENDER_GLSL
 #include "GPU_material.h"
-#endif
 
 #include "MT_Matrix4x4.h"
 #include "MT_Matrix3x3.h"
@@ -29,13 +27,9 @@ class BL_Material;
 class BL_BlenderShader
 {
 private:
-#ifdef BLENDER_GLSL
 	KX_Scene		*mScene;
 	struct Scene	*mBlenderScene;
 	struct Material	*mMat;
-	GPUMaterial		*mGPUMat;
-#endif
-	bool			mBound;
 	int				mLightLayer;
 	int				mBlendMode;
 
@@ -46,11 +40,11 @@ public:
 	virtual ~BL_BlenderShader();
 
 	bool				Ok();
-	void				SetProg(bool enable);
+	void				SetProg(bool enable, double time=0.0);
 
 	int GetAttribNum();
 	void SetAttribs(class RAS_IRasterizer* ras, const BL_Material *mat);
-	void Update(const class KX_MeshSlot & ms, class RAS_IRasterizer* rasty);
+	void Update(const class RAS_MeshSlot & ms, class RAS_IRasterizer* rasty);
 	int GetBlendMode();
 
 	bool Equals(BL_BlenderShader *blshader);
diff --git a/source/gameengine/Ketsji/BL_Material.h b/source/gameengine/Ketsji/BL_Material.h
index dcb66ea2579..0eaa234566c 100644
--- a/source/gameengine/Ketsji/BL_Material.h
+++ b/source/gameengine/Ketsji/BL_Material.h
@@ -18,9 +18,9 @@ struct EnvMap;
 	this will default to users available units
 	to build with more available, just increment this value
 	although the more you add the slower the search time will be.
-	we will go for three, which should be enough
+	we will go for eight, which should be enough
 */
-#define MAXTEX			3	//match in RAS_TexVert & RAS_OpenGLRasterizer
+#define MAXTEX			8	//match in RAS_TexVert & RAS_OpenGLRasterizer
 
 // different mapping modes
 class BL_Mapping
@@ -139,7 +139,7 @@ enum BL_ras_mode
 	COLLIDER=2,
 	ZSORT=4,
 	ALPHA=8,
-	TRIANGLE=16,
+	// TRIANGLE=16,
 	USE_LIGHT=32,
 	WIRE=64
 };
diff --git a/source/gameengine/Ketsji/BL_Shader.cpp b/source/gameengine/Ketsji/BL_Shader.cpp
index 57d0fe4140f..f28d3fa2912 100644
--- a/source/gameengine/Ketsji/BL_Shader.cpp
+++ b/source/gameengine/Ketsji/BL_Shader.cpp
@@ -433,7 +433,7 @@ void BL_Shader::SetProg(bool enable)
 	}
 }
 
-void BL_Shader::Update( const KX_MeshSlot & ms, RAS_IRasterizer* rasty )
+void BL_Shader::Update( const RAS_MeshSlot & ms, RAS_IRasterizer* rasty )
 {
 	if(!Ok() || !mPreDef.size()) 
 		return;
@@ -445,8 +445,7 @@ void BL_Shader::Update( const KX_MeshSlot & ms, RAS_IRasterizer* rasty )
 	{
 		MT_Matrix4x4 model;
 		model.setValue(ms.m_OpenGLMatrix);
-		MT_Matrix4x4 view;
-		rasty->GetViewMatrix(view);
+		const MT_Matrix4x4& view = rasty->GetViewMatrix();
 
 		if(mAttr==SHD_TANGENT)
 			 ms.m_mesh->SetMeshModified(true);
@@ -525,13 +524,15 @@ void BL_Shader::Update( const KX_MeshSlot & ms, RAS_IRasterizer* rasty )
 					}
 				case VIEWMATRIX_INVERSE:
 					{
-						view.invert();
+						MT_Matrix4x4 viewinv = view;
+						viewinv.invert();
 						SetUniform(uni->mLoc, view);
 						break;
 					}
 				case VIEWMATRIX_INVERSETRANSPOSE:
 					{
-						view.invert();
+						MT_Matrix4x4 viewinv = view;
+						viewinv.invert();
 						SetUniform(uni->mLoc, view, true);
 						break;
 					}
@@ -670,6 +671,7 @@ void BL_Shader::SetUniform(int uniform, const MT_Matrix4x4& vec, bool transpose)
 		)
 	{
 		float value[16];
+		// note: getValue gives back column major as needed by OpenGL
 		vec.getValue(value);
 		glUniformMatrix4fvARB(uniform, 1, transpose?GL_TRUE:GL_FALSE, value);
 	}
diff --git a/source/gameengine/Ketsji/BL_Shader.h b/source/gameengine/Ketsji/BL_Shader.h
index 8f303454087..c7fae31ba03 100644
--- a/source/gameengine/Ketsji/BL_Shader.h
+++ b/source/gameengine/Ketsji/BL_Shader.h
@@ -177,7 +177,7 @@ public:
 	void UnloadShader();
 
 	// Update predefined uniforms each render call
-	void Update(const class KX_MeshSlot & ms, class RAS_IRasterizer* rasty);
+	void Update(const class RAS_MeshSlot & ms, class RAS_IRasterizer* rasty);
 
 	//// Set sampler units (copied)
 	//void InitializeSampler(int unit, BL_Texture* texture );
diff --git a/source/gameengine/Ketsji/CMakeLists.txt b/source/gameengine/Ketsji/CMakeLists.txt
index be009d94701..58411f6d25e 100644
--- a/source/gameengine/Ketsji/CMakeLists.txt
+++ b/source/gameengine/Ketsji/CMakeLists.txt
@@ -69,6 +69,7 @@ SET(INC
   ../../../intern/SoundSystem 
   ../../../source/blender/misc 
   ../../../source/blender/blenloader
+  ../../../source/blender/gpu
   ../../../extern/bullet2/src
   ../../../extern/solid
   ../../../extern/glew/include
diff --git a/source/gameengine/Ketsji/KX_BlenderMaterial.cpp b/source/gameengine/Ketsji/KX_BlenderMaterial.cpp
index a67e5b26667..f92200780d5 100644
--- a/source/gameengine/Ketsji/KX_BlenderMaterial.cpp
+++ b/source/gameengine/Ketsji/KX_BlenderMaterial.cpp
@@ -19,13 +19,12 @@
 #include "MT_Vector4.h"
 #include "MT_Matrix4x4.h"
 
+#include "RAS_BucketManager.h"
 #include "RAS_MeshObject.h"
 #include "RAS_IRasterizer.h"
 #include "RAS_OpenGLRasterizer/RAS_GLExtensionManager.h"
 
-extern "C" {
-#include "BDR_drawmesh.h"
-}
+#include "GPU_draw.h"
 
 #include "STR_HashedString.h"
 
@@ -48,7 +47,6 @@ KX_BlenderMaterial::KX_BlenderMaterial(
 	BL_Material *data,
 	bool skin,
 	int lightlayer,
-	void *clientobject,
 	PyTypeObject *T
 	)
 :	PyObjectPlus(T),
@@ -62,9 +60,7 @@ KX_BlenderMaterial::KX_BlenderMaterial(
 		data->transp,
 		((data->ras_mode &ALPHA)!=0),
 		((data->ras_mode &ZSORT)!=0),
-		lightlayer,
-		((data->ras_mode &TRIANGLE)!=0),
-		clientobject
+		lightlayer
 	),
 	mMaterial(data),
 	mShader(0),
@@ -78,9 +74,10 @@ KX_BlenderMaterial::KX_BlenderMaterial(
 {
 	// --------------------------------
 	// RAS_IPolyMaterial variables... 
-	m_flag |=RAS_BLENDERMAT;
-	m_flag |=(mMaterial->IdMode>=ONETEX)?RAS_MULTITEX:0;
-	m_flag |=(mMaterial->ras_mode & USE_LIGHT)!=0?RAS_MULTILIGHT:0;
+	m_flag |= RAS_BLENDERMAT;
+	m_flag |= (mMaterial->IdMode>=ONETEX)? RAS_MULTITEX: 0;
+	m_flag |= ((mMaterial->ras_mode & USE_LIGHT)!=0)? RAS_MULTILIGHT: 0;
+	m_flag |= (mMaterial->glslmat)? RAS_BLENDERGLSL: 0;
 
 	// figure max
 	int enabled = mMaterial->num_enabled;
@@ -97,7 +94,7 @@ KX_BlenderMaterial::KX_BlenderMaterial(
 			  mMaterial->blend_mode[i]
 			 );
 	}
-	m_multimode += mMaterial->IdMode+mMaterial->ras_mode;
+	m_multimode += mMaterial->IdMode+ (mMaterial->ras_mode & ~(COLLIDER|USE_LIGHT));
 
 }
 
@@ -204,7 +201,7 @@ void KX_BlenderMaterial::OnExit()
 	}
 
 	if( mMaterial->tface ) 
-		set_tpage(mMaterial->tface);
+		GPU_set_tpage(mMaterial->tface);
 }
 
 
@@ -256,25 +253,28 @@ void KX_BlenderMaterial::setShaderData( bool enable, RAS_IRasterizer *ras)
 void KX_BlenderMaterial::setBlenderShaderData( bool enable, RAS_IRasterizer *ras)
 {
 	if( !enable || !mBlenderShader->Ok() ) {
+		ras->SetBlendingMode(TF_SOLID);
+
 		// frame cleanup.
 		if(mLastBlenderShader) {
 			mLastBlenderShader->SetProg(false);
 			mLastBlenderShader= NULL;
 		}
+		else
+			BL_Texture::DisableAllTextures();
 
-		ras->SetBlendingMode(TF_SOLID);
-		BL_Texture::DisableAllTextures();
 		return;
 	}
 
 	if(!mBlenderShader->Equals(mLastBlenderShader)) {
 		ras->SetBlendingMode(mMaterial->transp);
-		BL_Texture::DisableAllTextures();
 
 		if(mLastBlenderShader)
 			mLastBlenderShader->SetProg(false);
+		else
+			BL_Texture::DisableAllTextures();
 
-		mBlenderShader->SetProg(true);
+		mBlenderShader->SetProg(true, ras->GetTime());
 		mLastBlenderShader= mBlenderShader;
 	}
 }
@@ -354,21 +354,22 @@ KX_BlenderMaterial::ActivatShaders(
 	if (GetCachingInfo() != cachingInfo) {
 
 		if (!cachingInfo)
-			tmp->setShaderData( false, rasty);
+			tmp->setShaderData(false, rasty);
 		
 		cachingInfo = GetCachingInfo();
 	
 		if(rasty->GetDrawingMode() == RAS_IRasterizer::KX_TEXTURED)
-			tmp->setShaderData( true, rasty);
+			tmp->setShaderData(true, rasty);
 		else
-			tmp->setShaderData( false, rasty);
+			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) || (mMaterial->mode & RAS_IRasterizer::KX_LINES) ||
+		    (rasty->GetDrawingMode() <= RAS_IRasterizer::KX_WIREFRAME))
 		{		
 			if((mMaterial->ras_mode &WIRE)!=0) 
 				rasty->SetCullFace(false);
@@ -394,31 +395,24 @@ KX_BlenderMaterial::ActivateBlenderShaders(
 		mLastShader= NULL;
 	}
 
-	// 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) {
+		if(rasty->GetDrawingMode() == RAS_IRasterizer::KX_TEXTURED)
 			tmp->setBlenderShaderData(true, rasty);
-			rasty->EnableTextures(true);
-		}
-		else {
+		else
 			tmp->setBlenderShaderData(false, rasty);
-			rasty->EnableTextures(false);
-		}
 
 		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) || (mMaterial->mode & RAS_IRasterizer::KX_LINES) ||
+		    (rasty->GetDrawingMode() <= RAS_IRasterizer::KX_WIREFRAME))
 		{		
 			if((mMaterial->ras_mode &WIRE)!=0) 
 				rasty->SetCullFace(false);
@@ -426,10 +420,10 @@ KX_BlenderMaterial::ActivateBlenderShaders(
 		}
 		else
 			rasty->SetLines(false);
-	}
 
-	ActivatGLMaterials(rasty);
-	mBlenderShader->SetAttribs(rasty, mMaterial);
+		ActivatGLMaterials(rasty);
+		mBlenderShader->SetAttribs(rasty, mMaterial);
+	}
 }
 
 void
@@ -466,7 +460,8 @@ KX_BlenderMaterial::ActivateMat(
 		else
 			rasty->SetCullFace(true);
 
-		if (((mMaterial->ras_mode &WIRE)!=0) || mMaterial->mode & RAS_IRasterizer::KX_LINES)
+		if (((mMaterial->ras_mode &WIRE)!=0) || (mMaterial->mode & RAS_IRasterizer::KX_LINES) ||
+		    (rasty->GetDrawingMode() <= RAS_IRasterizer::KX_WIREFRAME))
 		{		
 			if((mMaterial->ras_mode &WIRE)!=0) 
 				rasty->SetCullFace(false);
@@ -486,12 +481,10 @@ KX_BlenderMaterial::Activate(
 	TCachingInfo& cachingInfo
 	)const
 {
-	bool dopass = false;
-	if( GLEW_ARB_shader_objects && ( mShader && mShader->Ok() ) ) {
-		if( (mPass++) < mShader->getNumPass() ) {
+	if(GLEW_ARB_shader_objects && (mShader && mShader->Ok())) {
+		if((mPass++) < mShader->getNumPass() ) {
 			ActivatShaders(rasty, cachingInfo);
-			dopass = true;
-			return dopass;
+			return true;
 		}
 		else {
 			if(mShader == mLastShader) {
@@ -499,36 +492,29 @@ KX_BlenderMaterial::Activate(
 				mLastShader = NULL;
 			}
 			mPass = 0;
-			dopass = false;
-			return dopass;
+			return false;
 		}
 	}
-	else if( GLEW_ARB_shader_objects && ( mBlenderShader && mBlenderShader->Ok() ) ) {
-		if( (mPass++) == 0 ) {
+	else if( GLEW_ARB_shader_objects && (mBlenderShader && mBlenderShader->Ok() ) ) {
+		if(mPass++ == 0) {
 			ActivateBlenderShaders(rasty, cachingInfo);
-			dopass = true;
-			return dopass;
+			return true;
 		}
 		else {
 			mPass = 0;
-			dopass = false;
-			return dopass;
+			return false;
 		}
 	}
 	else {
-		switch (mPass++)
-		{
-			case 0:
-				ActivateMat(rasty, cachingInfo);
-				dopass = true;
-				break;
-			default:
-				mPass = 0;
-				dopass = false;
-				break;
+		if(mPass++ == 0) {
+			ActivateMat(rasty, cachingInfo);
+			return true;
+		}
+		else {
+			mPass = 0;
+			return false;
 		}
 	}
-	return dopass;
 }
 
 bool KX_BlenderMaterial::UsesLighting(RAS_IRasterizer *rasty) const
@@ -536,14 +522,15 @@ bool KX_BlenderMaterial::UsesLighting(RAS_IRasterizer *rasty) const
 	if(!RAS_IPolyMaterial::UsesLighting(rasty))
 		return false;
 
-	if(mShader && mShader->Ok());
+	if(mShader && mShader->Ok())
+		return true;
 	else if(mBlenderShader && mBlenderShader->Ok())
 		return false;
-	
-	return true;
+	else
+		return true;
 }
 
-void KX_BlenderMaterial::ActivateMeshSlot(const KX_MeshSlot & ms, RAS_IRasterizer* rasty) const
+void KX_BlenderMaterial::ActivateMeshSlot(const RAS_MeshSlot & ms, RAS_IRasterizer* rasty) const
 {
 	if(mShader && GLEW_ARB_shader_objects) {
 		mShader->Update(ms, rasty);
@@ -554,7 +541,7 @@ void KX_BlenderMaterial::ActivateMeshSlot(const KX_MeshSlot & ms, RAS_IRasterize
 		mBlenderShader->Update(ms, rasty);
 
 		/* we do blend modes here, because they can change per object
-		 * with the same material due to obcolor */
+		 * with the same material due to obcolor/obalpha */
 		blendmode = mBlenderShader->GetBlendMode();
 		if((blendmode == TF_SOLID || blendmode == TF_ALPHA) && mMaterial->transp != TF_SOLID)
 			blendmode = mMaterial->transp;
@@ -633,11 +620,7 @@ void KX_BlenderMaterial::ActivateTexGen(RAS_IRasterizer *ras) const
 			else 
 				ras->SetTexCoord(RAS_IRasterizer::RAS_TEXCO_DISABLE, i);
 		}
-
-		ras->EnableTextures(true);
 	}
-	else
-		ras->EnableTextures(false);
 }
 
 void KX_BlenderMaterial::setTexMatrixData(int i)
@@ -712,8 +695,7 @@ void KX_BlenderMaterial::setObjectMatrixData(int i, RAS_IRasterizer *ras)
 	glEnable(GL_TEXTURE_GEN_T);
 	glEnable(GL_TEXTURE_GEN_R);
 
-	MT_Matrix4x4 mvmat;
-	ras->GetViewMatrix(mvmat);
+	const MT_Matrix4x4& mvmat = ras->GetViewMatrix();
 
 	glMatrixMode(GL_TEXTURE);
 	glLoadIdentity();
@@ -835,7 +817,9 @@ KX_PYMETHODDEF_DOC( KX_BlenderMaterial, getShader , "getShader()")
 		}
 
 		if(mShader && !mShader->GetError()) {
+			m_flag &= ~RAS_BLENDERGLSL;
 			mMaterial->SetSharedMaterial(true);
+			mScene->GetBucketManager()->ReleaseDisplayLists(this);
 			Py_INCREF(mShader);
 			return mShader;
 		}else
@@ -870,8 +854,6 @@ void KX_BlenderMaterial::SetBlenderGLSLShader(void)
 		delete mBlenderShader;
 		mBlenderShader = 0;
 	}
-	else
-		m_flag |= RAS_BLENDERGLSL;
 }
 
 KX_PYMETHODDEF_DOC( KX_BlenderMaterial, getMaterialIndex, "getMaterialIndex()")
diff --git a/source/gameengine/Ketsji/KX_BlenderMaterial.h b/source/gameengine/Ketsji/KX_BlenderMaterial.h
index 0d7657b8cdb..4ddf5a924df 100644
--- a/source/gameengine/Ketsji/KX_BlenderMaterial.h
+++ b/source/gameengine/Ketsji/KX_BlenderMaterial.h
@@ -28,7 +28,6 @@ public:
 		BL_Material*	mat,
 		bool			skin,
 		int				lightlayer,
-		void*			clientobject,
 		PyTypeObject*	T=&Type
 	);
 
@@ -47,7 +46,7 @@ public:
 	
 	virtual 
 	void ActivateMeshSlot(
-		const KX_MeshSlot & ms, 
+		const RAS_MeshSlot & ms, 
 		RAS_IRasterizer* rasty 
 	) const;
 	
diff --git a/source/gameengine/Ketsji/KX_ConvertPhysicsObjects.cpp b/source/gameengine/Ketsji/KX_ConvertPhysicsObjects.cpp
index d6997ee29a8..9607489497d 100644
--- a/source/gameengine/Ketsji/KX_ConvertPhysicsObjects.cpp
+++ b/source/gameengine/Ketsji/KX_ConvertPhysicsObjects.cpp
@@ -76,16 +76,16 @@
 struct KX_PhysicsInstance
 {
 	DT_VertexBaseHandle	m_vertexbase;
-	int			m_vtxarray;
+	RAS_DisplayArray*	m_darray;
 	RAS_IPolyMaterial*	m_material;
-	
-	KX_PhysicsInstance(DT_VertexBaseHandle vertex_base, int vtxarray, RAS_IPolyMaterial* mat)
+
+	KX_PhysicsInstance(DT_VertexBaseHandle vertex_base, RAS_DisplayArray *darray, RAS_IPolyMaterial* mat)
 		: m_vertexbase(vertex_base),
-		  m_vtxarray(vtxarray),
-		  m_material(mat)
+		m_darray(darray),
+		m_material(mat)
 	{
 	}
-	
+
 	~KX_PhysicsInstance()
 	{
 		DT_DeleteVertexBase(m_vertexbase);
@@ -100,11 +100,11 @@ static void	BL_RegisterSumoObject(KX_GameObject* gameobj,class SM_Scene* sumoSce
 static DT_ShapeHandle CreateShapeFromMesh(RAS_MeshObject* meshobj, bool polytope);
 
 void	KX_ConvertSumoObject(	KX_GameObject* gameobj,
-				RAS_MeshObject* meshobj,
-				KX_Scene* kxscene,
-				PHY_ShapeProps* kxshapeprops,
-				PHY_MaterialProps*	kxmaterial,
-				struct	KX_ObjectProperties*	objprop)
+		RAS_MeshObject* meshobj,
+		KX_Scene* kxscene,
+		PHY_ShapeProps* kxshapeprops,
+		PHY_MaterialProps*	kxmaterial,
+		struct	KX_ObjectProperties*	objprop)
 
 
 {
@@ -150,23 +150,23 @@ void	KX_ConvertSumoObject(	KX_GameObject* gameobj,
 						objprop->m_boundobject.box.m_extends[1], 
 						objprop->m_boundobject.box.m_extends[2]);
 				smprop->m_inertia.scale(objprop->m_boundobject.box.m_extends[0]*objprop->m_boundobject.box.m_extends[0],
-					objprop->m_boundobject.box.m_extends[1]*objprop->m_boundobject.box.m_extends[1],
-					objprop->m_boundobject.box.m_extends[2]*objprop->m_boundobject.box.m_extends[2]);
+						objprop->m_boundobject.box.m_extends[1]*objprop->m_boundobject.box.m_extends[1],
+						objprop->m_boundobject.box.m_extends[2]*objprop->m_boundobject.box.m_extends[2]);
 				smprop->m_inertia *= smprop->m_mass/MT_Vector3(objprop->m_boundobject.box.m_extends).length();
 				break;
 			case KX_BOUNDCYLINDER:
 				shape = DT_NewCylinder(smprop->m_radius, objprop->m_boundobject.c.m_height);
 				smprop->m_inertia.scale(smprop->m_mass*smprop->m_radius*smprop->m_radius,
-					smprop->m_mass*smprop->m_radius*smprop->m_radius,
-					smprop->m_mass*objprop->m_boundobject.c.m_height*objprop->m_boundobject.c.m_height);
+						smprop->m_mass*smprop->m_radius*smprop->m_radius,
+						smprop->m_mass*objprop->m_boundobject.c.m_height*objprop->m_boundobject.c.m_height);
 				break;
 			case KX_BOUNDCONE:
 				shape = DT_NewCone(objprop->m_radius, objprop->m_boundobject.c.m_height);
 				smprop->m_inertia.scale(smprop->m_mass*smprop->m_radius*smprop->m_radius,
-					smprop->m_mass*smprop->m_radius*smprop->m_radius,
-					smprop->m_mass*objprop->m_boundobject.c.m_height*objprop->m_boundobject.c.m_height);
+						smprop->m_mass*smprop->m_radius*smprop->m_radius,
+						smprop->m_mass*objprop->m_boundobject.c.m_height*objprop->m_boundobject.c.m_height);
 				break;
-			/* Dynamic mesh objects.  WARNING! slow. */
+				/* Dynamic mesh objects.  WARNING! slow. */
 			case KX_BOUNDPOLYTOPE:
 				polytope = true;
 				// fall through
@@ -186,15 +186,15 @@ void	KX_ConvertSumoObject(	KX_GameObject* gameobj,
 				shape = DT_NewSphere(objprop->m_radius);
 				smprop->m_inertia *= smprop->m_mass*smprop->m_radius*smprop->m_radius;
 				break;
-				
+
 		}
-		
+
 		sumoObj = new SM_Object(shape, !objprop->m_ghost?smmaterial:NULL,smprop,NULL);
-		
+
 		sumoObj->setRigidBody(objprop->m_angular_rigidbody?true:false);
-		
+
 		BL_RegisterSumoObject(gameobj,sceneptr,sumoObj,"",true, true);
-		
+
 	} 
 	else {
 		// non physics object
@@ -320,12 +320,11 @@ static void	BL_RegisterSumoObject(
 		physicscontroller->SetObject(gameobj->GetSGNode());
 }
 
-static DT_ShapeHandle InstancePhysicsComplex(RAS_MeshObject* meshobj, int vtxarray, RAS_IPolyMaterial *mat)
+static DT_ShapeHandle InstancePhysicsComplex(RAS_MeshObject* meshobj, RAS_DisplayArray *darray, RAS_IPolyMaterial *mat)
 {
 	// instance a mesh from a single vertex array & material
-	const RAS_TexVert *vertex_array = &((*meshobj->GetVertexCache(mat)[vtxarray])[0]);
-	//const KX_IndexArray &index_array = *meshobj->GetIndexCache(mat)[vtxarray];
-	DT_VertexBaseHandle vertex_base = DT_NewVertexBase(vertex_array[0].getLocalXYZ(), sizeof(RAS_TexVert));
+	const RAS_TexVert *vertex_array = &darray->m_vertex[0];
+	DT_VertexBaseHandle vertex_base = DT_NewVertexBase(vertex_array[0].getXYZ(), sizeof(RAS_TexVert));
 	
 	DT_ShapeHandle shape = DT_NewComplexShape(vertex_base);
 	
@@ -337,15 +336,19 @@ static DT_ShapeHandle InstancePhysicsComplex(RAS_MeshObject* meshobj, int vtxarr
 		// only add polygons that have the collisionflag set
 		if (poly->IsCollider())
 		{
-			DT_VertexIndices(3, poly->GetVertexIndexBase().m_indexarray);
+			DT_Begin();
+			  DT_VertexIndex(poly->GetVertexOffset(0));
+			  DT_VertexIndex(poly->GetVertexOffset(1));
+			  DT_VertexIndex(poly->GetVertexOffset(2));
+			DT_End();
 			
 			// tesselate
 			if (poly->VertexCount() == 4)
 			{
 				DT_Begin();
-				  DT_VertexIndex(poly->GetVertexIndexBase().m_indexarray[0]);
-				  DT_VertexIndex(poly->GetVertexIndexBase().m_indexarray[2]);
-				  DT_VertexIndex(poly->GetVertexIndexBase().m_indexarray[3]);
+				  DT_VertexIndex(poly->GetVertexOffset(0));
+				  DT_VertexIndex(poly->GetVertexOffset(2));
+				  DT_VertexIndex(poly->GetVertexOffset(3));
 				DT_End();
 			}
 		}
@@ -354,16 +357,15 @@ static DT_ShapeHandle InstancePhysicsComplex(RAS_MeshObject* meshobj, int vtxarr
 	//DT_VertexIndices(indices.size(), &indices[0]);
 	DT_EndComplexShape();
 	
-	map_gamemesh_to_instance.insert(GEN_HashedPtr(meshobj), new KX_PhysicsInstance(vertex_base, vtxarray, mat));
+	map_gamemesh_to_instance.insert(GEN_HashedPtr(meshobj), new KX_PhysicsInstance(vertex_base, darray, mat));
 	return shape;
 }
 
-static DT_ShapeHandle InstancePhysicsPolytope(RAS_MeshObject* meshobj, int vtxarray, RAS_IPolyMaterial *mat)
+static DT_ShapeHandle InstancePhysicsPolytope(RAS_MeshObject* meshobj, RAS_DisplayArray *darray, RAS_IPolyMaterial *mat)
 {
 	// instance a mesh from a single vertex array & material
-	const RAS_TexVert *vertex_array = &((*meshobj->GetVertexCache(mat)[vtxarray])[0]);
-	//const KX_IndexArray &index_array = *meshobj->GetIndexCache(mat)[vtxarray];
-	DT_VertexBaseHandle vertex_base = DT_NewVertexBase(vertex_array[0].getLocalXYZ(), sizeof(RAS_TexVert));
+	const RAS_TexVert *vertex_array = &darray->m_vertex[0];
+	DT_VertexBaseHandle vertex_base = DT_NewVertexBase(vertex_array[0].getXYZ(), sizeof(RAS_TexVert));
 	
 	std::vector<DT_Index> indices;
 	for (int p = 0; p < meshobj->NumPolygons(); p++)
@@ -373,12 +375,12 @@ static DT_ShapeHandle InstancePhysicsPolytope(RAS_MeshObject* meshobj, int vtxar
 		// only add polygons that have the collisionflag set
 		if (poly->IsCollider())
 		{
-			indices.push_back(poly->GetVertexIndexBase().m_indexarray[0]);
-			indices.push_back(poly->GetVertexIndexBase().m_indexarray[1]);
-			indices.push_back(poly->GetVertexIndexBase().m_indexarray[2]);
+			indices.push_back(poly->GetVertexOffset(0));
+			indices.push_back(poly->GetVertexOffset(1));
+			indices.push_back(poly->GetVertexOffset(2));
 			
 			if (poly->VertexCount() == 4)
-				indices.push_back(poly->GetVertexIndexBase().m_indexarray[3]);
+				indices.push_back(poly->GetVertexOffset(3));
 		}
 	}
 
@@ -386,7 +388,7 @@ static DT_ShapeHandle InstancePhysicsPolytope(RAS_MeshObject* meshobj, int vtxar
 	DT_VertexIndices(indices.size(), &indices[0]);
 	DT_EndPolytope();
 	
-	map_gamemesh_to_instance.insert(GEN_HashedPtr(meshobj), new KX_PhysicsInstance(vertex_base, vtxarray, mat));
+	map_gamemesh_to_instance.insert(GEN_HashedPtr(meshobj), new KX_PhysicsInstance(vertex_base, darray, mat));
 	return shape;
 }
 
@@ -398,8 +400,8 @@ bool KX_ReInstanceShapeFromMesh(RAS_MeshObject* meshobj)
 	KX_PhysicsInstance *instance = *map_gamemesh_to_instance[GEN_HashedPtr(meshobj)];
 	if (instance)
 	{
-		const RAS_TexVert *vertex_array = &((*meshobj->GetVertexCache(instance->m_material)[instance->m_vtxarray])[0]);
-		DT_ChangeVertexBase(instance->m_vertexbase, vertex_array[0].getLocalXYZ());
+		const RAS_TexVert *vertex_array = &instance->m_darray->m_vertex[0];
+		DT_ChangeVertexBase(instance->m_vertexbase, vertex_array[0].getXYZ());
 		return true;
 	}
 	return false;
@@ -425,7 +427,7 @@ static DT_ShapeHandle CreateShapeFromMesh(RAS_MeshObject* meshobj, bool polytope
 	// Count the number of collision polygons and check they all come from the same 
 	// vertex array
 	int numvalidpolys = 0;
-	int vtxarray = -1;
+	RAS_DisplayArray *darray = NULL;
 	RAS_IPolyMaterial *poly_material = NULL;
 	bool reinstance = true;
 
@@ -437,14 +439,14 @@ static DT_ShapeHandle CreateShapeFromMesh(RAS_MeshObject* meshobj, bool polytope
 		if (poly->IsCollider())
 		{
 			// check polygon is from the same vertex array
-			if (poly->GetVertexIndexBase().m_vtxarray != vtxarray)
+			if (poly->GetDisplayArray() != darray)
 			{
-				if (vtxarray < 0)
-					vtxarray = poly->GetVertexIndexBase().m_vtxarray;
+				if (darray == NULL)
+					darray = poly->GetDisplayArray();
 				else
 				{
 					reinstance = false;
-					vtxarray = -1;
+					darray = NULL;
 				}
 			}
 			
@@ -478,9 +480,9 @@ static DT_ShapeHandle CreateShapeFromMesh(RAS_MeshObject* meshobj, bool polytope
 	if (reinstance)
 	{
 		if (polytope)
-			shape = InstancePhysicsPolytope(meshobj, vtxarray, poly_material);
+			shape = InstancePhysicsPolytope(meshobj, darray, poly_material);
 		else
-			shape = InstancePhysicsComplex(meshobj, vtxarray, poly_material);
+			shape = InstancePhysicsComplex(meshobj, darray, poly_material);
 	}
 	else
 	{
@@ -489,7 +491,7 @@ static DT_ShapeHandle CreateShapeFromMesh(RAS_MeshObject* meshobj, bool polytope
 			std::cout << "CreateShapeFromMesh: " << meshobj->GetName() << " is not suitable for polytope." << std::endl;
 			if (!poly_material)
 				std::cout << "                     Check mesh materials." << std::endl;
-			if (vtxarray < 0)
+			if (darray == NULL)
 				std::cout << "                     Check number of vertices." << std::endl;
 		}
 		
@@ -505,18 +507,10 @@ static DT_ShapeHandle CreateShapeFromMesh(RAS_MeshObject* meshobj, bool polytope
 			if (poly->IsCollider())
 			{   /* We have to tesselate here because SOLID can only raycast triangles */
 			   DT_Begin();
-				/* V1 */
-				DT_Vertex(meshobj->GetVertex(poly->GetVertexIndexBase().m_vtxarray, 
-					poly->GetVertexIndexBase().m_indexarray[2],
-					poly->GetMaterial()->GetPolyMaterial())->getLocalXYZ());
-				/* V2 */
-				DT_Vertex(meshobj->GetVertex(poly->GetVertexIndexBase().m_vtxarray, 
-					poly->GetVertexIndexBase().m_indexarray[1],
-					poly->GetMaterial()->GetPolyMaterial())->getLocalXYZ());
-				/* V3 */
-				DT_Vertex(meshobj->GetVertex(poly->GetVertexIndexBase().m_vtxarray, 
-					poly->GetVertexIndexBase().m_indexarray[0],
-					poly->GetMaterial()->GetPolyMaterial())->getLocalXYZ());
+				/* V1, V2, V3 */
+				DT_Vertex(poly->GetVertex(2)->getXYZ());
+				DT_Vertex(poly->GetVertex(1)->getXYZ());
+				DT_Vertex(poly->GetVertex(0)->getXYZ());
 				
 				numvalidpolys++;
 			   DT_End();
@@ -524,18 +518,10 @@ static DT_ShapeHandle CreateShapeFromMesh(RAS_MeshObject* meshobj, bool polytope
 				if (poly->VertexCount() == 4)
 				{
 				   DT_Begin();
-					/* V1 */
-					DT_Vertex(meshobj->GetVertex(poly->GetVertexIndexBase().m_vtxarray, 
-						poly->GetVertexIndexBase().m_indexarray[3],
-						poly->GetMaterial()->GetPolyMaterial())->getLocalXYZ());
-					/* V3 */
-					DT_Vertex(meshobj->GetVertex(poly->GetVertexIndexBase().m_vtxarray, 
-						poly->GetVertexIndexBase().m_indexarray[2],
-						poly->GetMaterial()->GetPolyMaterial())->getLocalXYZ());
-					/* V4 */
-					DT_Vertex(meshobj->GetVertex(poly->GetVertexIndexBase().m_vtxarray, 
-						poly->GetVertexIndexBase().m_indexarray[0],
-						poly->GetMaterial()->GetPolyMaterial())->getLocalXYZ());
+					/* V1, V3, V4 */
+					DT_Vertex(poly->GetVertex(3)->getXYZ());
+					DT_Vertex(poly->GetVertex(2)->getXYZ());
+					DT_Vertex(poly->GetVertex(0)->getXYZ());
 				
 					numvalidpolys++;
 				   DT_End();
diff --git a/source/gameengine/Ketsji/KX_GameObject.cpp b/source/gameengine/Ketsji/KX_GameObject.cpp
index cc2956813c1..bec5d188f06 100644
--- a/source/gameengine/Ketsji/KX_GameObject.cpp
+++ b/source/gameengine/Ketsji/KX_GameObject.cpp
@@ -79,10 +79,12 @@ KX_GameObject::KX_GameObject(
 	m_bDyna(false),
 	m_layer(0),
 	m_pBlenderObject(NULL),
+	m_pBlenderGroupObject(NULL),
 	m_bSuspendDynamics(false),
 	m_bUseObjectColor(false),
 	m_bIsNegativeScaling(false),
 	m_bVisible(true),
+	m_bCulled(true),
 	m_pPhysicsController1(NULL),
 	m_pPhysicsEnvironment(NULL),
 	m_xray(false),
@@ -101,8 +103,11 @@ KX_GameObject::KX_GameObject(
 };
 
 
+
 KX_GameObject::~KX_GameObject()
 {
+	RemoveMeshes();
+
 	// is this delete somewhere ?
 	//if (m_sumoObj)
 	//	delete m_sumoObj;
@@ -164,7 +169,6 @@ STR_String KX_GameObject::GetName()
 void KX_GameObject::SetName(STR_String name)
 {
 	m_name = name;
-
 };								// Set the name of the value
 
 
@@ -285,11 +289,11 @@ void KX_GameObject::ProcessReplica(KX_GameObject* replica)
 CValue* KX_GameObject::GetReplica()
 {
 	KX_GameObject* replica = new KX_GameObject(*this);
-	
+
 	// this will copy properties and so on...
 	CValue::AddDataToReplica(replica);
 	ProcessReplica(replica);
-	
+
 	return replica;
 }
 
@@ -355,24 +359,26 @@ double*	KX_GameObject::GetOpenGLMatrix()
 	return fl;
 }
 
+void KX_GameObject::AddMeshUser()
+{
+	for (size_t i=0;i<m_meshes.size();i++)
+		m_meshes[i]->AddMeshUser(this);
+	
+	UpdateBuckets();
+}
 
-
-void KX_GameObject::Bucketize()
+void KX_GameObject::UpdateBuckets()
 {
 	double* fl = GetOpenGLMatrix();
 
 	for (size_t i=0;i<m_meshes.size();i++)
-		m_meshes[i]->Bucketize(fl, this, m_bUseObjectColor, m_objectColor);
+		m_meshes[i]->UpdateBuckets(this, fl, m_bUseObjectColor, m_objectColor, m_bVisible, m_bCulled);
 }
 
-
-
 void KX_GameObject::RemoveMeshes()
 {
-	double* fl = GetOpenGLMatrix();
-
 	for (size_t i=0;i<m_meshes.size();i++)
-		m_meshes[i]->RemoveFromBuckets(fl, this);
+		m_meshes[i]->RemoveFromBuckets(this);
 
 	//note: meshes can be shared, and are deleted by KX_BlenderSceneConverter
 
@@ -455,13 +461,14 @@ KX_GameObject::UpdateMaterialData(
 	)
 {
 	int mesh = 0;
-
 	if (((unsigned int)mesh < m_meshes.size()) && mesh >= 0) {
-		RAS_MaterialBucket::Set::iterator mit = m_meshes[mesh]->GetFirstMaterial();
+		list<RAS_MeshMaterial>::iterator mit = m_meshes[mesh]->GetFirstMaterial();
+
 		for(; mit != m_meshes[mesh]->GetLastMaterial(); ++mit)
 		{
-			RAS_IPolyMaterial* poly = (*mit)->GetPolyMaterial();
-			if(poly->GetFlag() & RAS_BLENDERMAT)
+			RAS_IPolyMaterial* poly = mit->m_bucket->GetPolyMaterial();
+
+			if(poly->GetFlag() & RAS_BLENDERMAT )
 			{
 				KX_BlenderMaterial *m =  static_cast<KX_BlenderMaterial*>(poly);
 				
@@ -469,8 +476,7 @@ KX_GameObject::UpdateMaterialData(
 				{
 					m->UpdateIPO(rgba, specrgb,hard,spec,ref,emit, alpha);
 					// if mesh has only one material attached to it then use original hack with no need to edit vertices (better performance)
-					if(!(poly->GetFlag() & RAS_BLENDERGLSL))
-						SetObjectColor(rgba);
+					SetObjectColor(rgba);
 				}
 				else
 				{
@@ -504,60 +510,39 @@ KX_GameObject::SetVisible(
 	m_bVisible = v;
 }
 
-void
-KX_GameObject::SetLayer(
-	int l
+bool
+KX_GameObject::GetCulled(
+	void
 	)
 {
-	m_layer = l;
+	return m_bCulled;
 }
 
-int
-KX_GameObject::GetLayer(
-	void
+void
+KX_GameObject::SetCulled(
+	bool c
 	)
 {
-	return m_layer;
+	m_bCulled = c;
 }
 
-// used by Python, and the actuatorshould _not_ be misused by the
-// scene!
-void 
-KX_GameObject::MarkVisible(
-	bool visible
+
+void
+KX_GameObject::SetLayer(
+	int l
 	)
 {
-	/* If explicit visibility settings are used, this is
-	 * determined on this level. Maybe change this to mesh level
-	 * later on? */
-	
-	double* fl = GetOpenGLMatrixPtr()->getPointer();
-	for (size_t i=0;i<m_meshes.size();i++)
-	{
-		m_meshes[i]->MarkVisible(fl,this,visible,m_bUseObjectColor,m_objectColor);
-	}
+	m_layer = l;
 }
 
-
-// Always use the flag?
-void 
-KX_GameObject::MarkVisible(
+int
+KX_GameObject::GetLayer(
 	void
 	)
 {
-	double* fl = GetOpenGLMatrixPtr()->getPointer();
-	for (size_t i=0;i<m_meshes.size();i++)
-	{
-		m_meshes[i]->MarkVisible(fl,
-					 this,
-					 m_bVisible,
-					 m_bUseObjectColor,
-					 m_objectColor
-			);
-	}
+	return m_layer;
 }
 
-
 void KX_GameObject::addLinearVelocity(const MT_Vector3& lin_vel,bool local)
 {
 	if (m_pPhysicsController1)
@@ -1052,6 +1037,7 @@ int KX_GameObject::_setattr(const STR_String& attr, PyObject *value)	// _setattr
 		if (attr == "visible")
 		{
 			SetVisible(val != 0);
+			UpdateBuckets();
 			return 0;
 		}
 	}
@@ -1221,8 +1207,8 @@ PyObject* KX_GameObject::PySetVisible(PyObject* self, PyObject* value)
 		return NULL;
 	}
 	
-	MarkVisible(visible!=0);
-	m_bVisible = (visible!=0);
+	SetVisible(visible != 0);
+	UpdateBuckets();
 	Py_RETURN_NONE;
 	
 }
diff --git a/source/gameengine/Ketsji/KX_GameObject.h b/source/gameengine/Ketsji/KX_GameObject.h
index 508bc7cdfd0..9dcf6526448 100644
--- a/source/gameengine/Ketsji/KX_GameObject.h
+++ b/source/gameengine/Ketsji/KX_GameObject.h
@@ -75,15 +75,17 @@ protected:
 	int									m_layer;
 	std::vector<RAS_MeshObject*>		m_meshes;
 	struct Object*						m_pBlenderObject;
+	struct Object*						m_pBlenderGroupObject;
 	
 	bool								m_bSuspendDynamics;
 	bool								m_bUseObjectColor;
 	bool								m_bIsNegativeScaling;
 	MT_Vector4							m_objectColor;
 
-	// Is this object set to be visible? Only useful for the
-	// visibility subsystem right now.
-	bool       m_bVisible; 
+	// visible = user setting
+	// culled = while rendering, depending on camera
+	bool       							m_bVisible; 
+	bool       							m_bCulled; 
 
 	KX_IPhysicsController*				m_pPhysicsController1;
 	// used for ray casting
@@ -395,6 +397,16 @@ public:
 	{
 		m_pBlenderObject = obj;
 	}
+
+	struct Object* GetBlenderGroupObject( )
+	{
+		return m_pBlenderGroupObject;
+	}
+
+	void SetBlenderGroupObject( struct Object* obj)
+	{
+		m_pBlenderGroupObject = obj;
+	}
 	
 	bool IsDupliGroup()
 	{ 
@@ -538,18 +550,22 @@ public:
 	/**
 	 * @section Mesh accessor functions.
 	 */
+
+	/**	
+	 * Update buckets to indicate that there is a new
+	 * user of this object's meshes.
+	 */
+		void						
+	AddMeshUser(
+	);
 	
 	/**	
-	 * Run through the meshes associated with this
-	 * object and bucketize them. See RAS_Mesh for
-	 * more details on this function. Interesting to 
-	 * note that polygon bucketizing seems to happen on a per
-	 * object basis. Which may explain why there is such
-	 * a big performance gain when all static objects
-	 * are joined into 1.
+	 * Update buckets with data about the mesh after
+	 * creating or duplicating the object, changing
+	 * visibility, object color, .. .
 	 */
 		void						
-	Bucketize(
+	UpdateBuckets(
 	);
 
 	/**
@@ -610,38 +626,37 @@ public:
 	ResetDebugColor(
 	);
 
-	/** 
-	 * Set the visibility of the meshes associated with this
-	 * object.
+	/**
+	 * Was this object marked visible? (only for the explicit
+	 * visibility system).
 	 */
-		void						
-	MarkVisible(
-		bool visible
+		bool
+	GetVisible(
+		void
 	);
 
-	/** 
-	 * Set the visibility according to the visibility flag.
+	/**
+	 * Set visibility flag of this object
 	 */
-		void						
-	MarkVisible(
 		void
+	SetVisible(
+		bool b
 	);
 
 	/**
-	 * Was this object marked visible? (only for the ewxplicit
-	 * visibility system).
+	 * Was this object culled?
 	 */
 		bool
-	GetVisible(
+	GetCulled(
 		void
 	);
 
 	/**
-	 * Set visibility flag of this object
+	 * Set culled flag of this object
 	 */
 		void
-	SetVisible(
-		bool b
+	SetCulled(
+		bool c
 	);
 
 	/**
@@ -670,6 +685,14 @@ public:
 	) { return m_bIsNegativeScaling; }
 
 	/**
+	 * Is this a light?
+	 */
+		virtual bool
+	IsLight(
+		void
+	) { return false; }
+
+	/**
 	 * @section Logic bubbling methods.
 	 */
 
diff --git a/source/gameengine/Ketsji/KX_ISceneConverter.h b/source/gameengine/Ketsji/KX_ISceneConverter.h
index f069048cd3d..3709fa8c784 100644
--- a/source/gameengine/Ketsji/KX_ISceneConverter.h
+++ b/source/gameengine/Ketsji/KX_ISceneConverter.h
@@ -32,6 +32,8 @@
 #include "STR_String.h"
 #include "KX_Python.h"
 
+struct Scene;
+
 class KX_ISceneConverter 
 {
 
@@ -77,6 +79,8 @@ public:
 	// use blender glsl materials
 	virtual void SetGLSLMaterials(bool val) =0;
 	virtual bool GetGLSLMaterials()=0;
+
+	virtual struct Scene* GetBlenderSceneForName(const STR_String& name)=0;
 };
 
 #endif //__KX_ISCENECONVERTER_H
diff --git a/source/gameengine/Ketsji/KX_KetsjiEngine.cpp b/source/gameengine/Ketsji/KX_KetsjiEngine.cpp
index 1d6cc975ab5..cf98bb72601 100644
--- a/source/gameengine/Ketsji/KX_KetsjiEngine.cpp
+++ b/source/gameengine/Ketsji/KX_KetsjiEngine.cpp
@@ -96,6 +96,7 @@ double KX_KetsjiEngine::m_ticrate = DEFAULT_LOGIC_TIC_RATE;
 double KX_KetsjiEngine::m_anim_framerate = 25.0;
 double KX_KetsjiEngine::m_suspendedtime = 0.0;
 double KX_KetsjiEngine::m_suspendeddelta = 0.0;
+double KX_KetsjiEngine::m_average_framerate = 0.0;
 
 
 /**
@@ -310,6 +311,12 @@ void KX_KetsjiEngine::EndFrame()
 	{
 		RenderDebugProperties();
 	}
+
+	m_average_framerate = m_logger->GetAverage();
+	if (m_average_framerate < 1e-6)
+		m_average_framerate = 1e-6;
+	m_average_framerate = 1.0/m_average_framerate;
+
 	// Go to next profiling measurement, time spend after this call is shown in the next frame.
 	m_logger->NextMeasurement(m_kxsystem->GetTimeInSeconds());
 
@@ -321,8 +328,6 @@ void KX_KetsjiEngine::EndFrame()
 
 	
 	m_canvas->EndDraw();
-	
-
 }
 
 //#include "PIL_time.h"
@@ -897,11 +902,18 @@ void KX_KetsjiEngine::SetupRenderFrame(KX_Scene *scene, KX_Camera* cam)
 
 void KX_KetsjiEngine::RenderShadowBuffers(KX_Scene *scene)
 {
-	CListValue *lightlist = scene->GetLightList();
+	CListValue *objectlist = scene->GetObjectList();
 	int i, drawmode;
 
-	for(i=0; i<lightlist->GetCount(); i++) {
-		KX_LightObject *light = (KX_LightObject*)lightlist->GetValue(i);
+	m_rendertools->SetAuxilaryClientInfo(scene);
+
+	for(i=0; i<objectlist->GetCount(); i++) {
+		KX_GameObject *gameobj = (KX_GameObject*)objectlist->GetValue(i);
+
+		if(!gameobj->IsLight())
+			continue;
+
+		KX_LightObject *light = (KX_LightObject*)gameobj;
 
 		light->Update();
 
@@ -1281,12 +1293,13 @@ void KX_KetsjiEngine::RemoveScheduledScenes()
 
 KX_Scene* KX_KetsjiEngine::CreateScene(const STR_String& scenename)
 {
-
+	Scene *scene = m_sceneconverter->GetBlenderSceneForName(scenename);
 	KX_Scene* tmpscene = new KX_Scene(m_keyboarddevice,
 									  m_mousedevice,
 									  m_networkdevice,
 									  m_audiodevice,
-									  scenename);
+									  scenename,
+									  scene);
 
 	m_sceneconverter->ConvertScene(scenename,
 							  tmpscene,
@@ -1442,6 +1455,11 @@ void KX_KetsjiEngine::SetAnimFrameRate(double framerate)
 	m_anim_framerate = framerate;
 }
 
+double KX_KetsjiEngine::GetAverageFrameRate()
+{
+	return m_average_framerate;
+}
+
 void KX_KetsjiEngine::SetTimingDisplay(bool frameRate, bool profile, bool properties)
 {
 	m_show_framerate = frameRate;
diff --git a/source/gameengine/Ketsji/KX_KetsjiEngine.h b/source/gameengine/Ketsji/KX_KetsjiEngine.h
index 77b69ec2d9e..97458362f0f 100644
--- a/source/gameengine/Ketsji/KX_KetsjiEngine.h
+++ b/source/gameengine/Ketsji/KX_KetsjiEngine.h
@@ -149,6 +149,8 @@ private:
 	
 	/** Labels for profiling display. */
 	static const char		m_profileLabels[tc_numCategories][15];
+	/** Last estimated framerate */
+	static double			m_average_framerate;
 	/** Show the framerate on the game display? */
 	bool					m_show_framerate;
 	/** Show profiling info on the game display? */
@@ -272,6 +274,11 @@ public:
 	static void SetAnimFrameRate(double framerate);
 
 	/**
+	 * Gets the last estimated average framerate
+	 */
+	static double GetAverageFrameRate();
+
+	/**
 	 * Activates or deactivates timing information display.
 	 * @param frameRate		Display for frame rate on or off.
 	 * @param profile		Display for individual components on or off.
diff --git a/source/gameengine/Ketsji/KX_Light.cpp b/source/gameengine/Ketsji/KX_Light.cpp
index 4e3d6180d22..6cfe5610863 100644
--- a/source/gameengine/Ketsji/KX_Light.cpp
+++ b/source/gameengine/Ketsji/KX_Light.cpp
@@ -42,14 +42,13 @@
 
 #include "KX_PyMath.h"
 
-#ifdef BLENDER_GLSL
+#include "DNA_object_types.h"
 #include "GPU_material.h"
-#endif
  
 KX_LightObject::KX_LightObject(void* sgReplicationInfo,SG_Callbacks callbacks,
 							   class RAS_IRenderTools* rendertools,
 							   const RAS_LightObject&	lightobj,
-							   struct GPULamp *gpulamp,
+							   bool glsl,
 							   PyTypeObject* T
 							   )
  :
@@ -59,7 +58,8 @@ KX_LightObject::KX_LightObject(void* sgReplicationInfo,SG_Callbacks callbacks,
 	m_lightobj = lightobj;
 	m_lightobj.m_worldmatrix = GetOpenGLMatrixPtr();
 	m_rendertools->AddLight(&m_lightobj);
-	m_gpulamp = gpulamp;
+	m_glsl = glsl;
+	m_blenderscene = ((KX_Scene*)sgReplicationInfo)->GetBlenderScene();
 };
 
 
@@ -73,7 +73,7 @@ CValue*		KX_LightObject::GetReplica()
 {
 
 	KX_LightObject* replica = new KX_LightObject(*this);
-	
+
 	// this will copy properties and so on...
 	CValue::AddDataToReplica(replica);
 
@@ -81,13 +81,23 @@ CValue*		KX_LightObject::GetReplica()
 	
 	replica->m_lightobj.m_worldmatrix = replica->GetOpenGLMatrixPtr();
 	m_rendertools->AddLight(&replica->m_lightobj);
+
 	return replica;
 }
 
+GPULamp *KX_LightObject::GetGPULamp()
+{
+	if(m_glsl)
+		return GPU_lamp_from_blender(m_blenderscene, GetBlenderObject(), GetBlenderGroupObject());
+	else
+		return false;
+}
+
 void KX_LightObject::Update()
 {
-#ifdef BLENDER_GLSL
-	if(m_gpulamp) {
+	GPULamp *lamp;
+
+	if((lamp = GetGPULamp())) {
 		float obmat[4][4];
 		double *dobmat = GetOpenGLMatrixPtr()->getPointer();
 
@@ -95,38 +105,39 @@ void KX_LightObject::Update()
 			for(int j=0; j<4; j++, dobmat++)
 				obmat[i][j] = (float)*dobmat;
 
-		GPU_lamp_update(m_gpulamp, obmat);
+		GPU_lamp_update(lamp, obmat);
 	}
-#endif
 }
 
 bool KX_LightObject::HasShadowBuffer()
 {
-#ifdef BLENDER_GLSL
-	return (m_gpulamp && GPU_lamp_has_shadow_buffer(m_gpulamp));
-#else
-	return false;
-#endif
+	GPULamp *lamp;
+
+	if((lamp = GetGPULamp()))
+		return GPU_lamp_has_shadow_buffer(lamp);
+	else
+		return false;
 }
 
 int KX_LightObject::GetShadowLayer()
 {
-#ifdef BLENDER_GLSL
-	if(m_gpulamp)
-		return GPU_lamp_shadow_layer(m_gpulamp);
+	GPULamp *lamp;
+
+	if((lamp = GetGPULamp()))
+		return GPU_lamp_shadow_layer(lamp);
 	else
-#endif
 		return 0;
 }
 
 void KX_LightObject::BindShadowBuffer(RAS_IRasterizer *ras, KX_Camera *cam, MT_Transform& camtrans)
 {
-#ifdef BLENDER_GLSL
+	GPULamp *lamp;
 	float viewmat[4][4], winmat[4][4];
 	int winsize;
 
 	/* bind framebuffer */
-	GPU_lamp_shadow_buffer_bind(m_gpulamp, viewmat, &winsize, winmat);
+	lamp = GetGPULamp();
+	GPU_lamp_shadow_buffer_bind(lamp, viewmat, &winsize, winmat);
 
 	/* setup camera transformation */
 	MT_Matrix4x4 modelviewmat((float*)viewmat);
@@ -146,14 +157,12 @@ void KX_LightObject::BindShadowBuffer(RAS_IRasterizer *ras, KX_Camera *cam, MT_T
 	ras->SetProjectionMatrix(projectionmat);
 	ras->SetViewMatrix(modelviewmat, cam->NodeGetWorldPosition(),
 		cam->GetCameraLocation(), cam->GetCameraOrientation());
-#endif
 }
 
 void KX_LightObject::UnbindShadowBuffer(RAS_IRasterizer *ras)
 {
-#ifdef BLENDER_GLSL
-	GPU_lamp_shadow_buffer_unbind(m_gpulamp);
-#endif
+	GPULamp *lamp = GetGPULamp();
+	GPU_lamp_shadow_buffer_unbind(lamp);
 }
 
 PyObject* KX_LightObject::_getattr(const STR_String& attr)
diff --git a/source/gameengine/Ketsji/KX_Light.h b/source/gameengine/Ketsji/KX_Light.h
index 62eb26c61a8..e5dbf0b7f4a 100644
--- a/source/gameengine/Ketsji/KX_Light.h
+++ b/source/gameengine/Ketsji/KX_Light.h
@@ -33,6 +33,7 @@
 #include "KX_GameObject.h"
 
 struct GPULamp;
+struct Scene;
 class KX_Camera;
 class RAS_IRasterizer;
 class RAS_IRenderTools;
@@ -44,16 +45,18 @@ class KX_LightObject : public KX_GameObject
 protected:
 	RAS_LightObject		m_lightobj;
 	class RAS_IRenderTools*	m_rendertools;	//needed for registering and replication of lightobj
-	struct GPULamp		*m_gpulamp;
-	static char		doc[];
+	bool				m_glsl;
+	Scene*				m_blenderscene;
+	static char			doc[];
 
 public:
-	KX_LightObject(void* sgReplicationInfo,SG_Callbacks callbacks,class RAS_IRenderTools* rendertools,const struct RAS_LightObject&	lightobj, struct GPULamp *gpulamp, PyTypeObject *T = &Type);
+	KX_LightObject(void* sgReplicationInfo,SG_Callbacks callbacks,class RAS_IRenderTools* rendertools,const struct RAS_LightObject&	lightobj, bool glsl, PyTypeObject *T = &Type);
 	virtual ~KX_LightObject();
 	virtual CValue*		GetReplica();
 	RAS_LightObject*	GetLightData() { return &m_lightobj;}
 
 	/* GLSL shadow */
+	struct GPULamp *GetGPULamp();
 	bool HasShadowBuffer();
 	int GetShadowLayer();
 	void BindShadowBuffer(class RAS_IRasterizer *ras, class KX_Camera *cam, class MT_Transform& camtrans);
@@ -62,6 +65,8 @@ public:
 	
 	virtual PyObject* _getattr(const STR_String& attr); /* lens, near, far, projection_matrix */
 	virtual int       _setattr(const STR_String& attr, PyObject *pyvalue);
+
+	virtual bool IsLight(void) { return true; }
 };
 
 #endif //__KX_LIGHT
diff --git a/source/gameengine/Ketsji/KX_MeshProxy.cpp b/source/gameengine/Ketsji/KX_MeshProxy.cpp
index 29842af7fb6..5bfe8c70cba 100644
--- a/source/gameengine/Ketsji/KX_MeshProxy.cpp
+++ b/source/gameengine/Ketsji/KX_MeshProxy.cpp
@@ -96,10 +96,11 @@ KX_MeshProxy::_getattr(const STR_String& attr)
 	if (attr == "materials")
 	{
 		PyObject *materials = PyList_New(0);
-		RAS_MaterialBucket::Set::iterator mit = m_meshobj->GetFirstMaterial();
+		list<RAS_MeshMaterial>::iterator mit = m_meshobj->GetFirstMaterial();
 		for(; mit != m_meshobj->GetLastMaterial(); ++mit)
 		{
-			RAS_IPolyMaterial *polymat = (*mit)->GetPolyMaterial();
+			RAS_IPolyMaterial *polymat = mit->m_bucket->GetPolyMaterial();
+
 			if(polymat->GetFlag() & RAS_BLENDERMAT)
 			{
 				KX_BlenderMaterial *mat = static_cast<KX_BlenderMaterial*>(polymat);
@@ -204,11 +205,11 @@ PyObject* KX_MeshProxy::PyGetVertexArrayLength(PyObject* self,
 	
 	if (PyArg_ParseTuple(args,"i",&matid))
 	{
-		RAS_IPolyMaterial* mat = m_meshobj->GetMaterialBucket(matid)->GetPolyMaterial();
+		RAS_MeshMaterial *mmat = m_meshobj->GetMeshMaterial(matid);
+		RAS_IPolyMaterial* mat = mmat->m_bucket->GetPolyMaterial();
+
 		if (mat)
-		{
-			length = m_meshobj->GetVertexArrayLength(mat);
-		}
+			length = m_meshobj->NumVertices(mat);
 	}
 	else {
 		return NULL;
diff --git a/source/gameengine/Ketsji/KX_PolyProxy.cpp b/source/gameengine/Ketsji/KX_PolyProxy.cpp
index 658c8a98e4f..c6f6bc2db01 100644
--- a/source/gameengine/Ketsji/KX_PolyProxy.cpp
+++ b/source/gameengine/Ketsji/KX_PolyProxy.cpp
@@ -112,8 +112,8 @@ KX_PolyProxy::_getattr(const STR_String& attr)
 		unsigned int matid;
 		for (matid=0; matid<m_mesh->NumMaterials(); matid++)
 		{
-			RAS_MaterialBucket* meshBucket = m_mesh->GetMaterialBucket(matid);
-			if (meshBucket == polyBucket)
+			RAS_MeshMaterial* meshMat = m_mesh->GetMeshMaterial(matid);
+			if (meshMat->m_bucket == polyBucket)
 				// found it
 				break;
 		}
@@ -121,19 +121,19 @@ KX_PolyProxy::_getattr(const STR_String& attr)
 	}
 	if (attr == "v1")
 	{
-		return PyInt_FromLong(m_polygon->GetVertexIndexBase().m_indexarray[0]);
+		return PyInt_FromLong(m_polygon->GetVertexOffset(0));
 	}
 	if (attr == "v2")
 	{
-		return PyInt_FromLong(m_polygon->GetVertexIndexBase().m_indexarray[1]);
+		return PyInt_FromLong(m_polygon->GetVertexOffset(1));
 	}
 	if (attr == "v3")
 	{
-		return PyInt_FromLong(m_polygon->GetVertexIndexBase().m_indexarray[2]);
+		return PyInt_FromLong(m_polygon->GetVertexOffset(2));
 	}
 	if (attr == "v4")
 	{
-		return PyInt_FromLong(((m_polygon->VertexCount()>3)?m_polygon->GetVertexIndexBase().m_indexarray[3]:0));
+		return PyInt_FromLong(((m_polygon->VertexCount()>3)?m_polygon->GetVertexOffset(3):0));
 	}
 	if (attr == "visible")
 	{
@@ -178,8 +178,8 @@ KX_PYMETHODDEF_DOC_NOARG(KX_PolyProxy, getMaterialIndex,
 	unsigned int matid;
 	for (matid=0; matid<m_mesh->NumMaterials(); matid++)
 	{
-		RAS_MaterialBucket* meshBucket = m_mesh->GetMaterialBucket(matid);
-		if (meshBucket == polyBucket)
+		RAS_MeshMaterial* meshMat = m_mesh->GetMeshMaterial(matid);
+		if (meshMat->m_bucket == polyBucket)
 			// found it
 			break;
 	}
@@ -234,7 +234,7 @@ KX_PYMETHODDEF_DOC(KX_PolyProxy, getVertexIndex,
 	}
 	if (index < m_polygon->VertexCount())
 	{
-		return PyInt_FromLong(m_polygon->GetVertexIndexBase().m_indexarray[index]);
+		return PyInt_FromLong(m_polygon->GetVertexOffset(index));
 	}
 	return PyInt_FromLong(0);
 }
diff --git a/source/gameengine/Ketsji/KX_PolygonMaterial.cpp b/source/gameengine/Ketsji/KX_PolygonMaterial.cpp
index 144f74a1a4c..c9180bf3a80 100644
--- a/source/gameengine/Ketsji/KX_PolygonMaterial.cpp
+++ b/source/gameengine/Ketsji/KX_PolygonMaterial.cpp
@@ -35,10 +35,6 @@
 #include "BKE_global.h"
 #include "BKE_image.h"
 
-extern "C" {
-#include "BDR_drawmesh.h"
-}
-
 #include "DNA_material_types.h"
 #include "DNA_texture_types.h"
 #include "DNA_image_types.h"
@@ -46,6 +42,8 @@ extern "C" {
 
 #include "IMB_imbuf_types.h"
 
+#include "GPU_draw.h"
+
 #include "MEM_guardedalloc.h"
 
 #include "RAS_LightObject.h"
@@ -63,8 +61,6 @@ KX_PolygonMaterial::KX_PolygonMaterial(const STR_String &texname,
 											   bool alpha,
 											   bool zsort,
 											   int lightlayer,
-											   bool bIsTriangle,
-											   void* clientobject,
 											   struct MTFace* tface,
 											   unsigned int* mcol,
 											   PyTypeObject *T)
@@ -78,9 +74,7 @@ KX_PolygonMaterial::KX_PolygonMaterial(const STR_String &texname,
 							transp,
 							alpha,
 							zsort,
-							lightlayer,
-							bIsTriangle,
-							clientobject),
+							lightlayer),
 		m_tface(tface),
 		m_mcol(mcol),
 		m_material(material),
@@ -140,38 +134,29 @@ void KX_PolygonMaterial::DefaultActivate(RAS_IRasterizer* rasty, TCachingInfo& c
 	if (GetCachingInfo() != cachingInfo)
 	{
 		if (!cachingInfo)
-		{
-			set_tpage(NULL);
-		}
+			GPU_set_tpage(NULL);
+
 		cachingInfo = GetCachingInfo();
 
 		if ((m_drawingmode & 4)&& (rasty->GetDrawingMode() == RAS_IRasterizer::KX_TEXTURED))
 		{
-			update_realtime_texture((struct MTFace*) m_tface, rasty->GetTime());
-			set_tpage(m_tface);
-			rasty->EnableTextures(true);
+			Image *ima = (Image*)m_tface->tpage;
+			GPU_update_image_time(ima, rasty->GetTime());
+			GPU_set_tpage(m_tface);
 		}
 		else
-		{
-			set_tpage(NULL);
-			rasty->EnableTextures(false);
-		}
+			GPU_set_tpage(NULL);
 		
 		if(m_drawingmode & RAS_IRasterizer::KX_TWOSIDE)
-		{
 			rasty->SetCullFace(false);
-		}
 		else
-		{
 			rasty->SetCullFace(true);
-		}
 
-		if (m_drawingmode & RAS_IRasterizer::KX_LINES) {
+		if ((m_drawingmode & RAS_IRasterizer::KX_LINES) ||
+		    (rasty->GetDrawingMode() <= RAS_IRasterizer::KX_WIREFRAME))
 			rasty->SetLines(true);
-		}
-		else {
+		else
 			rasty->SetLines(false);
-		}
 	}
 
 	rasty->SetSpecularity(m_specular[0],m_specular[1],m_specular[2],m_specularity);
@@ -253,7 +238,8 @@ PyObject* KX_PolygonMaterial::_getattr(const STR_String& attr)
 	if (attr == "lightlayer")
 		return PyInt_FromLong(m_lightlayer);
 	if (attr == "triangle")
-		return PyInt_FromLong(m_bIsTriangle);
+		// deprecated, triangle/quads shouldn't have been a material property
+		return 0;
 		
 	if (attr == "diffuse")
 		return PyObjectFrom(m_diffuse);
@@ -333,7 +319,7 @@ int KX_PolygonMaterial::_setattr(const STR_String &attr, PyObject *pyvalue)
 		// This probably won't work...
 		if (attr == "triangle")
 		{
-			m_bIsTriangle = value;
+			// deprecated, triangle/quads shouldn't have been a material property
 			return 0;
 		}
 	}
@@ -386,7 +372,9 @@ KX_PYMETHODDEF_DOC(KX_PolygonMaterial, updateTexture, "updateTexture(tface, rast
 	{
 		MTFace *tface = (MTFace*) PyCObject_AsVoidPtr(pytface);
 		RAS_IRasterizer *rasty = (RAS_IRasterizer*) PyCObject_AsVoidPtr(pyrasty);
-		update_realtime_texture(tface, rasty->GetTime());
+		Image *ima = (Image*)tface->tpage;
+		GPU_update_image_time(ima, rasty->GetTime());
+
 		Py_Return;
 	}
 	
@@ -399,7 +387,7 @@ KX_PYMETHODDEF_DOC(KX_PolygonMaterial, setTexture, "setTexture(tface)")
 	if (PyArg_ParseTuple(args, "O!", &PyCObject_Type, &pytface))
 	{
 		MTFace *tface = (MTFace*) PyCObject_AsVoidPtr(pytface);
-		set_tpage(tface);
+		GPU_set_tpage(tface);
 		Py_Return;
 	}
 	
diff --git a/source/gameengine/Ketsji/KX_PolygonMaterial.h b/source/gameengine/Ketsji/KX_PolygonMaterial.h
index 11c8baa8b1f..fe116f757db 100644
--- a/source/gameengine/Ketsji/KX_PolygonMaterial.h
+++ b/source/gameengine/Ketsji/KX_PolygonMaterial.h
@@ -68,8 +68,6 @@ public:
 		bool alpha,
 		bool zsort,
 		int lightlayer,
-		bool bIsTriangle,
-		void* clientobject,
 		struct MTFace* tface,
 		unsigned int* mcol,
 		PyTypeObject *T = &Type);
diff --git a/source/gameengine/Ketsji/KX_PythonInit.cpp b/source/gameengine/Ketsji/KX_PythonInit.cpp
index 4b6a38f18c0..120311fb967 100644
--- a/source/gameengine/Ketsji/KX_PythonInit.cpp
+++ b/source/gameengine/Ketsji/KX_PythonInit.cpp
@@ -57,13 +57,13 @@
 #include "BL_ActionActuator.h"
 #include "RAS_IRasterizer.h"
 #include "RAS_ICanvas.h"
+#include "RAS_BucketManager.h"
 #include "MT_Vector3.h"
 #include "MT_Point3.h"
 #include "ListValue.h"
 #include "KX_Scene.h"
 #include "SND_DeviceManager.h"
 
-#include "RAS_OpenGLRasterizer/RAS_GLExtensionManager.h"
 #include "BL_Shader.h"
 
 #include "KX_PyMath.h"
@@ -83,6 +83,7 @@ extern "C" {
 #include "BKE_utildefines.h"
 #include "BKE_global.h"
 #include "BLI_blenlib.h"
+#include "GPU_material.h"
 
 static void setSandbox(TPythonSecurityLevel level);
 
@@ -90,6 +91,7 @@ static void setSandbox(TPythonSecurityLevel level);
 // 'local' copy of canvas ptr, for window height/width python scripts
 static RAS_ICanvas* gp_Canvas = NULL;
 static KX_Scene*	gp_KetsjiScene = NULL;
+static KX_KetsjiEngine*	gp_KetsjiEngine = NULL;
 static RAS_IRasterizer* gp_Rasterizer = NULL;
 
 void	KX_RasterizerDrawDebugLine(const MT_Vector3& from,const MT_Vector3& to,const MT_Vector3& color)
@@ -270,6 +272,11 @@ static PyObject* gPyGetPhysicsTicRate(PyObject*)
 	return PyFloat_FromDouble(PHY_GetActiveEnvironment()->getFixedTimeStep());
 }
 
+static PyObject* gPyGetAverageFrameRate(PyObject*)
+{
+	return PyFloat_FromDouble(KX_KetsjiEngine::GetAverageFrameRate());
+}
+
 static PyObject* gPyGetBlendFileList(PyObject*, PyObject* args)
 {
 	char cpath[sizeof(G.sce)];
@@ -409,6 +416,7 @@ static struct PyMethodDef game_methods[] = {
 	{"setLogicTicRate", (PyCFunction) gPySetLogicTicRate, METH_VARARGS, "Sets the logic tic rate"},
 	{"getPhysicsTicRate", (PyCFunction) gPyGetPhysicsTicRate, METH_NOARGS, "Gets the physics tic rate"},
 	{"setPhysicsTicRate", (PyCFunction) gPySetPhysicsTicRate, METH_VARARGS, "Sets the physics tic rate"},
+	{"getAverageFrameRate", (PyCFunction) gPyGetAverageFrameRate, METH_NOARGS, "Gets the estimated average frame rate"},
 	{"getBlendFileList", (PyCFunction)gPyGetBlendFileList, METH_VARARGS, "Gets a list of blend files in the same directory as the current blend file"},
 	{"PrintGLInfo", (PyCFunction)pyPrintExt, METH_NOARGS, "Prints GL Extension Info"},
 	{NULL, (PyCFunction) NULL, 0, NULL }
@@ -670,6 +678,76 @@ static PyObject* gPyDisableMotionBlur(PyObject*, PyObject* args)
 	Py_Return;
 }
 
+int getGLSLSettingFlag(char *setting)
+{
+	if(strcmp(setting, "lights") == 0)
+		return G_FILE_GLSL_NO_LIGHTS;
+	else if(strcmp(setting, "shaders") == 0)
+		return G_FILE_GLSL_NO_SHADERS;
+	else if(strcmp(setting, "shadows") == 0)
+		return G_FILE_GLSL_NO_SHADOWS;
+	else if(strcmp(setting, "ramps") == 0)
+		return G_FILE_GLSL_NO_RAMPS;
+	else if(strcmp(setting, "nodes") == 0)
+		return G_FILE_GLSL_NO_NODES;
+	else if(strcmp(setting, "extra_textures") == 0)
+		return G_FILE_GLSL_NO_EXTRA_TEX;
+	else
+		return -1;
+}
+
+static PyObject* gPySetGLSLMaterialSetting(PyObject*,
+											PyObject* args,
+											PyObject*)
+{
+	char *setting;
+	int enable, flag;
+
+	if (PyArg_ParseTuple(args,"si",&setting,&enable))
+	{
+		flag = getGLSLSettingFlag(setting);
+
+		if(flag != -1) {
+			if (enable)
+				G.fileflags &= ~flag;
+			else
+				G.fileflags |= flag;
+
+			/* display lists and GLSL materials need to be remade */
+			if(gp_KetsjiEngine) {
+				KX_SceneList *scenes = gp_KetsjiEngine->CurrentScenes();
+				KX_SceneList::iterator it;
+
+				for(it=scenes->begin(); it!=scenes->end(); it++)
+					if((*it)->GetBucketManager())
+						(*it)->GetBucketManager()->ReleaseDisplayLists();
+			}
+
+			GPU_materials_free();
+		}
+	}
+
+	Py_Return;
+}
+
+static PyObject* gPyGetGLSLMaterialSetting(PyObject*, 
+									 PyObject* args, 
+									 PyObject*)
+{
+	char *setting;
+	int enabled = 0, flag;
+
+	if (PyArg_ParseTuple(args,"s",&setting))
+	{
+		flag = getGLSLSettingFlag(setting);
+
+		if(flag != -1)
+			enabled = ((G.fileflags & flag) != 0);
+	}
+
+	return PyInt_FromLong(enabled);
+}
+
 STR_String	gPyGetWindowHeight__doc__="getWindowHeight doc";
 STR_String	gPyGetWindowWidth__doc__="getWindowWidth doc";
 STR_String	gPyEnableVisibility__doc__="enableVisibility doc";
@@ -703,11 +781,13 @@ static struct PyMethodDef rasterizer_methods[] = {
   {"getEyeSeparation", (PyCFunction) gPyGetEyeSeparation, METH_VARARGS, "get the eye separation for stereo mode"},
   {"setFocalLength", (PyCFunction) gPySetFocalLength, METH_VARARGS, "set the focal length for stereo mode"},
   {"getFocalLength", (PyCFunction) gPyGetFocalLength, METH_VARARGS, "get the focal length for stereo mode"},
+  {"setGLSLMaterialSetting",(PyCFunction) gPySetGLSLMaterialSetting,
+   METH_VARARGS, "set the state of a GLSL material setting"},
+  {"getGLSLMaterialSetting",(PyCFunction) gPyGetGLSLMaterialSetting,
+   METH_VARARGS, "get the state of a GLSL material setting"},
   { NULL, (PyCFunction) NULL, 0, NULL }
 };
 
-
-
 // Initialization function for the module (*must* be called initGameLogic)
 
 static char GameLogic_module_documentation[] =
@@ -720,11 +800,12 @@ static char Rasterizer_module_documentation[] =
 
 
 
-PyObject* initGameLogic(KX_Scene* scene) // quick hack to get gravity hook
+PyObject* initGameLogic(KX_KetsjiEngine *engine, KX_Scene* scene) // quick hack to get gravity hook
 {
 	PyObject* m;
 	PyObject* d;
 
+	gp_KetsjiEngine = engine;
 	gp_KetsjiScene = scene;
 
 	gUseVisibilityTemp=false;
diff --git a/source/gameengine/Ketsji/KX_PythonInit.h b/source/gameengine/Ketsji/KX_PythonInit.h
index f094a1ca575..388d073c6db 100644
--- a/source/gameengine/Ketsji/KX_PythonInit.h
+++ b/source/gameengine/Ketsji/KX_PythonInit.h
@@ -40,7 +40,7 @@ typedef enum {
 extern bool gUseVisibilityTemp;
 
 
-PyObject*	initGameLogic(class KX_Scene* ketsjiscene);
+PyObject*	initGameLogic(class KX_KetsjiEngine *engine, class KX_Scene* ketsjiscene);
 PyObject*	initGameKeys();
 PyObject*	initRasterizer(class RAS_IRasterizer* rasty,class RAS_ICanvas* canvas);
 PyObject*	initGamePlayerPythonScripting(const STR_String& progname, TPythonSecurityLevel level);
diff --git a/source/gameengine/Ketsji/KX_SG_BoneParentNodeRelationship.cpp b/source/gameengine/Ketsji/KX_SG_BoneParentNodeRelationship.cpp
index f085ff435dc..d651373869a 100644
--- a/source/gameengine/Ketsji/KX_SG_BoneParentNodeRelationship.cpp
+++ b/source/gameengine/Ketsji/KX_SG_BoneParentNodeRelationship.cpp
@@ -78,7 +78,7 @@ UpdateChildCoordinates(
 	
 	if (parent)
 	{
-		const BL_ArmatureObject *armature = (const BL_ArmatureObject*)(parent->GetSGClientObject());
+		BL_ArmatureObject *armature = (BL_ArmatureObject*)(parent->GetSGClientObject());
 		if (armature)
 		{
 			MT_Matrix4x4 parent_matrix;
diff --git a/source/gameengine/Ketsji/KX_Scene.cpp b/source/gameengine/Ketsji/KX_Scene.cpp
index 1c37fcea77e..2ad0412f1bf 100644
--- a/source/gameengine/Ketsji/KX_Scene.cpp
+++ b/source/gameengine/Ketsji/KX_Scene.cpp
@@ -68,6 +68,7 @@
 #include "SG_IObject.h"
 #include "SG_Tree.h"
 #include "DNA_group_types.h"
+#include "DNA_scene_types.h"
 #include "BKE_anim.h"
 
 #include "KX_SG_NodeRelationships.h"
@@ -116,7 +117,8 @@ KX_Scene::KX_Scene(class SCA_IInputDevice* keyboarddevice,
 				   class SCA_IInputDevice* mousedevice,
 				   class NG_NetworkDeviceInterface *ndi,
 				   class SND_IAudioDevice* adi,
-				   const STR_String& sceneName): 
+				   const STR_String& sceneName,
+				   Scene *scene): 
 	PyObjectPlus(&KX_Scene::Type),
 	m_keyboardmgr(NULL),
 	m_mousemgr(NULL),
@@ -126,7 +128,8 @@ KX_Scene::KX_Scene(class SCA_IInputDevice* keyboarddevice,
 	m_adi(adi),
 	m_networkDeviceInterface(ndi),
 	m_active_camera(NULL),
-	m_ueberExecutionPriority(0)
+	m_ueberExecutionPriority(0),
+	m_blenderScene(scene)
 {
 	m_suspendedtime = 0.0;
 	m_suspendeddelta = 0.0;
@@ -453,7 +456,7 @@ KX_GameObject* KX_Scene::AddNodeReplicaObject(class SG_IObject* node, class CVal
 
 	// this is the list of object that are send to the graphics pipeline
 	m_objectlist->Add(newobj->AddRef());
-	newobj->Bucketize();
+	newobj->AddMeshUser();
 
 	// logic cannot be replicated, until the whole hierarchy is replicated.
 	m_logicHierarchicalGameObjects.push_back(newobj);
@@ -623,6 +626,7 @@ void KX_Scene::DupliGroupRecurse(CValue* obj, int level)
 		if (blgroupobj == blenderobj)
 			// this check is also in group_duplilist()
 			continue;
+
 		gameobj = (KX_GameObject*)m_logicmgr->FindGameObjByBlendObj(blenderobj);
 		if (gameobj == NULL) 
 		{
@@ -630,6 +634,9 @@ void KX_Scene::DupliGroupRecurse(CValue* obj, int level)
 			// Should not happen as dupli group are created automatically 
 			continue;
 		}
+
+		gameobj->SetBlenderGroupObject(blgroupobj);
+
 		if ((blenderobj->lay & group->layer)==0)
 		{
 			// object is not visible in the 3D view, will not be instantiated
@@ -999,7 +1006,7 @@ void KX_Scene::ReplaceMesh(class CValue* obj,void* meshobj)
 			newobj->m_pDeformer = NULL;
 		}
 
-		if (mesh->m_class == 1) 
+		if (mesh->IsDeformed())
 		{
 			// we must create a new deformer but which one?
 			KX_GameObject* parentobj = newobj->GetParent();
@@ -1073,7 +1080,8 @@ void KX_Scene::ReplaceMesh(class CValue* obj,void* meshobj)
 				parentobj->Release();
 		}
 	}
-	gameobj->Bucketize();
+
+	gameobj->AddMeshUser();
 }
 
 
@@ -1225,7 +1233,9 @@ void KX_Scene::MarkSubTreeVisible(SG_Tree *node, RAS_IRasterizer* rasty, bool vi
 				for (int m=0;m<nummeshes;m++)
 					(gameobj->GetMesh(m))->SchedulePolygons(rasty->GetDrawingMode());
 			}
-			gameobj->MarkVisible(visible);
+
+			gameobj->SetCulled(!visible);
+			gameobj->UpdateBuckets();
 		}
 	}
 	if (node->Left())
@@ -1242,7 +1252,8 @@ void KX_Scene::MarkVisible(RAS_IRasterizer* rasty, KX_GameObject* gameobj,KX_Cam
 	
 	// Shadow lamp layers
 	if(layer && !(gameobj->GetLayer() & layer)) {
-		gameobj->MarkVisible(false);
+		gameobj->SetCulled(true);
+		gameobj->UpdateBuckets();
 		return;
 	}
 
@@ -1288,9 +1299,11 @@ void KX_Scene::MarkVisible(RAS_IRasterizer* rasty, KX_GameObject* gameobj,KX_Cam
 		}
 		// Visibility/ non-visibility are marked
 		// elsewhere now.
-		gameobj->MarkVisible();
+		gameobj->SetCulled(false);
+		gameobj->UpdateBuckets();
 	} else {
-		gameobj->MarkVisible(false);
+		gameobj->SetCulled(true);
+		gameobj->UpdateBuckets();
 	}
 }
 
diff --git a/source/gameengine/Ketsji/KX_Scene.h b/source/gameengine/Ketsji/KX_Scene.h
index 1c56dd1ee55..5f7e1167e27 100644
--- a/source/gameengine/Ketsji/KX_Scene.h
+++ b/source/gameengine/Ketsji/KX_Scene.h
@@ -54,6 +54,7 @@
  */
 struct SM_MaterialProps;
 struct SM_ShapeProps;
+struct Scene;
 
 class GEN_HashedPtr;
 class CListValue;
@@ -277,12 +278,15 @@ protected:
 	 */
 	PyObject* m_attrlist;
 
+	struct Scene* m_blenderScene;
+
 public:
 	KX_Scene(class SCA_IInputDevice* keyboarddevice,
 		class SCA_IInputDevice* mousedevice,
 		class NG_NetworkDeviceInterface* ndi,
 		class SND_IAudioDevice* adi,
-		const STR_String& scenename	);
+		const STR_String& scenename,
+		struct Scene* scene);
 
 	virtual	
 	~KX_Scene();
@@ -582,6 +586,10 @@ public:
 	 * was running and not suspended) and the "curtime"
 	 */
 	double getSuspendedDelta();
+	/**
+	 * Returns the Blender scene this was made from
+	 */
+	struct Scene *GetBlenderScene() { return m_blenderScene; }
 };
 
 typedef std::vector<KX_Scene*> KX_SceneList;
diff --git a/source/gameengine/Ketsji/KX_VertexProxy.cpp b/source/gameengine/Ketsji/KX_VertexProxy.cpp
index 5cec65dff1c..25205714308 100644
--- a/source/gameengine/Ketsji/KX_VertexProxy.cpp
+++ b/source/gameengine/Ketsji/KX_VertexProxy.cpp
@@ -82,7 +82,7 @@ PyObject*
 KX_VertexProxy::_getattr(const STR_String& attr)
 {
   if (attr == "XYZ")
-  	return PyObjectFrom(MT_Vector3(m_vertex->getLocalXYZ()));
+  	return PyObjectFrom(MT_Vector3(m_vertex->getXYZ()));
 
   if (attr == "UV")
   	return PyObjectFrom(MT_Point2(m_vertex->getUV1()));
@@ -102,11 +102,11 @@ KX_VertexProxy::_getattr(const STR_String& attr)
 
   // pos
   if (attr == "x")
-  	return PyFloat_FromDouble(m_vertex->getLocalXYZ()[0]);
+  	return PyFloat_FromDouble(m_vertex->getXYZ()[0]);
   if (attr == "y")
-  	return PyFloat_FromDouble(m_vertex->getLocalXYZ()[1]);
+  	return PyFloat_FromDouble(m_vertex->getXYZ()[1]);
   if (attr == "z")
-  	return PyFloat_FromDouble(m_vertex->getLocalXYZ()[2]);
+  	return PyFloat_FromDouble(m_vertex->getXYZ()[2]);
 
   // Col
   if (attr == "r")
@@ -184,7 +184,7 @@ int    KX_VertexProxy::_setattr(const STR_String& attr, PyObject *pyvalue)
   {
   	float val = PyFloat_AsDouble(pyvalue);
   	// pos
-	MT_Point3 pos(m_vertex->getLocalXYZ());
+	MT_Point3 pos(m_vertex->getXYZ());
   	if (attr == "x")
 	{
 		pos.x() = val;
@@ -312,7 +312,7 @@ PyObject* KX_VertexProxy::PyGetXYZ(PyObject*,
 			       PyObject*, 
 			       PyObject*)
 {
-	return PyObjectFrom(MT_Point3(m_vertex->getLocalXYZ()));
+	return PyObjectFrom(MT_Point3(m_vertex->getXYZ()));
 }
 
 PyObject* KX_VertexProxy::PySetXYZ(PyObject*, 
@@ -426,7 +426,7 @@ PyObject* KX_VertexProxy::PySetUV2(PyObject*,
 	{
 		if (PyVecTo(list, vec))
 		{
-			m_vertex->SetFlag((m_vertex->getFlag()|TV_2NDUV));
+			m_vertex->SetFlag((m_vertex->getFlag()|RAS_TexVert::SECOND_UV));
 			m_vertex->SetUnit(unit);
 			m_vertex->SetUV2(vec);
 			m_mesh->SetMeshModified(true);
diff --git a/source/gameengine/Ketsji/KX_VisibilityActuator.cpp b/source/gameengine/Ketsji/KX_VisibilityActuator.cpp
index b4693a7a7db..5a0cadcbcfe 100644
--- a/source/gameengine/Ketsji/KX_VisibilityActuator.cpp
+++ b/source/gameengine/Ketsji/KX_VisibilityActuator.cpp
@@ -76,7 +76,7 @@ KX_VisibilityActuator::Update()
 	KX_GameObject *obj = (KX_GameObject*) GetParent();
 	
 	obj->SetVisible(m_visible);
-	obj->MarkVisible();
+	obj->UpdateBuckets();
 
 	return true;
 }
diff --git a/source/gameengine/Ketsji/Makefile b/source/gameengine/Ketsji/Makefile
index 995237adf2c..0b48ad8b8c3 100644
--- a/source/gameengine/Ketsji/Makefile
+++ b/source/gameengine/Ketsji/Makefile
@@ -64,13 +64,9 @@ CPPFLAGS += -I../../blender/blenlib
 CPPFLAGS += -I../../blender/include
 CPPFLAGS += -I../../blender/makesdna
 CPPFLAGS += -I../../blender/imbuf
+CPPFLAGS += -I../../blender/gpu
 CPPFLAGS += -I$(NAN_GUARDEDALLOC)/include
 
-ifeq ($(WITH_BF_GLEXT),true)
-    CPPFLAGS += -DWITH_GLEXT
-endif
-
-
 ###########################
 
 SOURCEDIR = source/gameengine/Ketsji
diff --git a/source/gameengine/Ketsji/SConscript b/source/gameengine/Ketsji/SConscript
index f6f744b199a..02e7aed82a5 100644
--- a/source/gameengine/Ketsji/SConscript
+++ b/source/gameengine/Ketsji/SConscript
@@ -32,16 +32,13 @@ 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 #extern/glew/include'
+incs += ' #source/blender/misc #source/blender/blenloader #extern/glew/include #source/blender/gpu'
 
 cflags = []
 if env['OURPLATFORM'] == 'win32-vc':
 	cflags.append('/GR')
 	cflags.append('/Ox')
 
-if env['WITH_BF_GLEXT'] == 1:
-        env['CPPFLAGS'].append('-DWITH_GLEXT')
-
 incs += ' ' + env['BF_SOLID_INC']
 incs += ' ' + env['BF_PYTHON_INC']
 incs += ' ' + env['BF_SDL_INC']