applied Charlies patch for game engine graphics. display list support, and bumpmapping shader improvements.

12 files changed, 866 insertions, 594 deletions

diff --git a/source/gameengine/Ketsji/BL_Material.h b/source/gameengine/Ketsji/BL_Material.h
index 7a813cc6c72..27d59257cbd 100644
--- a/source/gameengine/Ketsji/BL_Material.h
+++ b/source/gameengine/Ketsji/BL_Material.h
@@ -146,7 +146,8 @@ enum BL_MappingFlag
 	USENORM	=8,
 	USEORCO =16,
 	USEUV	=32,
-	DISABLE =64
+	USETANG	=64,
+	DISABLE =128
 };
 
 // BL_Material::BL_Mapping::projplane
diff --git a/source/gameengine/Ketsji/BL_Shader.cpp b/source/gameengine/Ketsji/BL_Shader.cpp
index c1e2028f3fb..a0da2690ccc 100644
--- a/source/gameengine/Ketsji/BL_Shader.cpp
+++ b/source/gameengine/Ketsji/BL_Shader.cpp
@@ -11,7 +11,6 @@
 #include <GL/glu.h>
 #endif
 
-
 #include <iostream>
 #include "BL_Shader.h"
 #include "BL_Material.h"
@@ -29,12 +28,115 @@
 //using namespace bgl;
 #define spit(x) std::cout << x << std::endl;
 
+/* ----
+	testing for a faster solution!
+	...  just compile out
+	The idea is to install a shader in other 
+	areas if code, find the shader via the scene and,
+	install it with ...
+
+	shader->ApplyShader()
+	...
+	shader->UnloadShader()
+*/
+#define SORT_UNIFORMS 1
+
+#define UNIFORM_MAX_LEN sizeof(float)*16
+
+BL_Uniform::BL_Uniform(int data_size)
+:	mLoc(-1),
+	mDirty(true),
+	mType(UNI_NONE),
+	mTranspose(0),
+	mDataLen(data_size)
+{
+#ifdef SORT_UNIFORMS
+	MT_assert(mDataLen <= UNIFORM_MAX_LEN);
+	mData = (void*)MEM_mallocN(mDataLen, "shader-uniform-alloc");
+#endif
+}
+
+BL_Uniform::~BL_Uniform()
+{
+#ifdef SORT_UNIFORMS
+	if(mData) {
+		MEM_freeN(mData);
+		mData=0;
+	}
+#endif
+}
+
+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);
+
+	if(!mDirty) 
+		return;
+
+	switch(mType)
+	{
+	case UNI_FLOAT: {
+			float *f = (float*)mData;
+			bgl::blUniform1fARB(mLoc,(GLfloat)*f);
+		}break;
+	case UNI_INT: {
+			int *f = (int*)mData;
+			bgl::blUniform1iARB(mLoc, (GLint)*f);
+		}break;
+	case UNI_FLOAT2: {
+			float *f = (float*)mData;
+			bgl::blUniform2fvARB(mLoc,1, (GLfloat*)f);
+		}break;
+	case UNI_FLOAT3: {
+			float *f = (float*)mData;
+			bgl::blUniform3fvARB(mLoc,1,(GLfloat*)f);
+		}break;
+	case UNI_FLOAT4: {
+			float *f = (float*)mData;
+			bgl::blUniform4fvARB(mLoc,1,(GLfloat*)f);
+		}break;
+	case UNI_INT2: {
+			int *f = (int*)mData;
+			bgl::blUniform2ivARB(mLoc,1,(GLint*)f);
+		}break; 
+	case UNI_INT3: {
+			int *f = (int*)mData;
+			bgl::blUniform3ivARB(mLoc,1,(GLint*)f);
+		}break; 
+	case UNI_INT4: {
+			int *f = (int*)mData;
+			bgl::blUniform4ivARB(mLoc,1,(GLint*)f);
+		}break;
+	case UNI_MAT4: {
+			float *f = (float*)mData;
+			bgl::blUniformMatrix4fvARB(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);
+		}break;
+	}
+	mDirty = false;
+#endif
+#endif
+}
+
+void BL_Uniform::SetData(int location, int type,bool transpose)
+{
+#ifdef SORT_UNIFORMS
+	mType	= type;
+	mLoc	= location;
+	mDirty	= true;
+#endif
+}
+
 const bool BL_Shader::Ok()const
 {
 	return (mShader !=0 && mOk && mUse);
 }
 
-
 BL_Shader::BL_Shader(PyTypeObject *T)
 :	PyObjectPlus(T),
 	mShader(0),
@@ -44,20 +146,11 @@ BL_Shader::BL_Shader(PyTypeObject *T)
 	vertProg(""),
 	fragProg(""),
 	mError(0),
-	mAttr(0),
-	mPreDefLoc(-1),
-	mPreDefType(-1),
-	mDeleteTexture(0)
+	mDirty(true)
 {
 	// if !RAS_EXT_support._ARB_shader_objects this class will not be used
-
 	for (int i=0; i<MAXTEX; i++) {
-		mSampler[i].type = 0;
-		mSampler[i].pass = 0;
-		mSampler[i].unit = -1;
-		mSampler[i].loc  = -1;
-		mSampler[i].gl_texture = 0;
-		mSampler[i].flag=0;
+		mSampler[i] = BL_Sampler();
 	}
 }
 
@@ -66,14 +159,14 @@ using namespace bgl;
 BL_Shader::~BL_Shader()
 {
 #ifdef GL_ARB_shader_objects
-	for (int i=0; i<MAXTEX; i++) 
-	{
-		if(mSampler[i].flag & OWN)
-		{
-			if(mSampler[i].gl_texture)
-				mSampler[i].gl_texture->DeleteTex();
+	for (int i=0; i<MAXTEX; i++){
+		if(mSampler[i].mOwn) {
+			if(mSampler[i].mTexture)
+				mSampler[i].mTexture->DeleteTex();
 		}
 	}
+	ClearUniforms();
+
 	if( mShader ) {
 		bgl::blDeleteObjectARB(mShader);
 		mShader = 0;
@@ -81,11 +174,113 @@ BL_Shader::~BL_Shader()
 	vertProg	= 0;
 	fragProg	= 0;
 	mOk			= 0;
-
 	bgl::blUseProgramObjectARB(0);
 #endif//GL_ARB_shader_objects
 }
 
+void BL_Shader::ClearUniforms()
+{
+	BL_UniformVec::iterator it = mUniforms.begin();
+	while(it != mUniforms.end()){
+		delete (*it);
+		it++;
+	}
+	mUniforms.clear();
+
+	
+	BL_UniformVecDef::iterator itp = mPreDef.begin();
+	while(itp != mPreDef.end()) {
+		delete (*itp);
+		itp++;
+	}
+	mPreDef.clear();
+
+}
+
+
+BL_Uniform  *BL_Shader::FindUniform(const int location)
+{
+#ifdef SORT_UNIFORMS
+	BL_UniformVec::iterator it = mUniforms.begin();
+	while(it != mUniforms.end()) {
+		if((*it)->GetLocation() == location)
+			return (*it);
+		it++;
+	}
+#endif
+	return 0;
+}
+
+void BL_Shader::SetUniformfv(int location, int type, float *param,int size, bool transpose)
+{
+#ifdef SORT_UNIFORMS
+#ifndef NDEBUG
+	MT_assert(type > UNI_NONE && type < UNI_MAX);
+	MT_assert(location);
+	MT_assert(param);
+	MT_assert(size > 0 && size <= UNIFORM_MAX_LEN);
+#endif
+
+	BL_Uniform *uni= FindUniform(location);
+	if(uni) {
+		memcpy(uni->getData(), param, size);
+		uni->SetData(location, type, transpose);
+	}
+	else {
+		uni = new BL_Uniform(size);
+		memcpy(uni->getData(), param, size);
+
+		uni->SetData(location, type, transpose);
+		mUniforms.push_back(uni);
+	}
+	mDirty = true;
+#endif
+}
+
+void BL_Shader::SetUniformiv(int location, int type, int *param,int size, bool transpose)
+{
+#ifdef SORT_UNIFORMS
+#ifndef NDEBUG
+	MT_assert(type > UNI_NONE && type < UNI_MAX);
+	MT_assert(location);
+	MT_assert(param);
+	MT_assert(size > 0 && size <= UNIFORM_MAX_LEN);
+#endif
+
+	BL_Uniform *uni= FindUniform(location);
+	if(uni) {
+		memcpy(uni->getData(), param, size);
+		uni->SetData(location, type, transpose);
+	}
+	else {
+		uni = new BL_Uniform(size);
+		memcpy(uni->getData(), param, size);
+		uni->SetData(location, type, transpose);
+		mUniforms.push_back(uni);
+	}
+	mDirty = true;
+#endif
+}
+
+
+void BL_Shader::ApplyShader()
+{
+#ifdef SORT_UNIFORMS
+	if(!mDirty) 
+		return;
+
+	for(unsigned int i=0; i<mUniforms.size(); i++)
+		mUniforms[i]->Apply(this);
+
+	mDirty = false;
+#endif
+}
+
+void BL_Shader::UnloadShader()
+{
+	//
+}
+
 
 bool BL_Shader::LinkProgram()
 {
@@ -214,12 +409,12 @@ programError:
 #endif//GL_ARB_shader_objects
 }
 
-char *BL_Shader::GetVertPtr()
+const char *BL_Shader::GetVertPtr()
 {
 	return vertProg?vertProg:0;
 }
 
-char *BL_Shader::GetFragPtr()
+const char *BL_Shader::GetFragPtr()
 {
 	return fragProg?fragProg:0;
 }
@@ -239,7 +434,7 @@ unsigned int BL_Shader::GetProg()
 	return mShader;
 }
 
-const uSampler* BL_Shader::getSampler(int i)
+const BL_Sampler* BL_Shader::GetSampler(int i)
 {
 	MT_assert(i<=MAXTEX);
 	return &mSampler[i];
@@ -258,23 +453,14 @@ void BL_Shader::SetSampler(int loc, int unit)
 #endif
 }
 
-
-void BL_Shader::InitializeSampler(
-	int type,
-	int unit,
-	int pass,
-	BL_Texture* texture)
+void BL_Shader::InitializeSampler(int unit, BL_Texture* texture)
 {
 	MT_assert(unit<=MAXTEX);
-	mSampler[unit].gl_texture = texture;
-	mSampler[unit].loc =-1;
-	mSampler[unit].pass=0;
-	mSampler[unit].type=type;
-	mSampler[unit].unit=unit;
-	mSampler[unit].flag = 0;
+	mSampler[unit].mTexture = texture;
+	mSampler[unit].mLoc =-1;
+	mSampler[unit].mOwn = 0;
 }
 
-
 void BL_Shader::SetProg(bool enable)
 {
 #ifdef GL_ARB_shader_objects
@@ -296,7 +482,8 @@ void BL_Shader::SetProg(bool enable)
 void BL_Shader::Update( const KX_MeshSlot & ms, RAS_IRasterizer* rasty )
 {
 #ifdef GL_ARB_shader_objects
-	if(!Ok()) return;
+	if(!Ok() || !mPreDef.size()) 
+		return;
 
 	if( RAS_EXT_support._ARB_fragment_shader &&
 		RAS_EXT_support._ARB_vertex_shader &&
@@ -307,86 +494,99 @@ void BL_Shader::Update( const KX_MeshSlot & ms, RAS_IRasterizer* rasty )
 		model.setValue(ms.m_OpenGLMatrix);
 		MT_Matrix4x4 view;
 		rasty->GetViewMatrix(view);
-		switch (mPreDefType)
+
+		BL_UniformVecDef::iterator it;
+		for(it = mPreDef.begin(); it!= mPreDef.end(); it++)
 		{
-			case MODELMATRIX:
-				{
-					SetUniform(mPreDefLoc, model);
-					break;
-				}
-			case MODELMATRIX_TRANSPOSE:
-				{
-					SetUniform(mPreDefLoc, model, true);
-					break;
-				}
-			case MODELMATRIX_INVERSE:
-				{
-					model.invert();
-					SetUniform(mPreDefLoc, model);
-					break;
-				}
-			case MODELMATRIX_INVERSETRANSPOSE:
-				{
-					model.invert();
-					SetUniform(mPreDefLoc, model, true);
-					break;
-				}
-			case MODELVIEWMATRIX:
-				{
-					SetUniform(mPreDefLoc, view*model);
-					break;
-				}
+			BL_DefUniform *uni = (*it);
+			if(!uni->mLoc) continue;
 
-			case MODELVIEWMATRIX_TRANSPOSE:
-				{
-					MT_Matrix4x4 mat(view*model);
-					SetUniform(mPreDefLoc, mat, true);
-					break;
-				}
-			case MODELVIEWMATRIX_INVERSE:
-				{
-					MT_Matrix4x4 mat(view*model);
-					mat.invert();
-					SetUniform(mPreDefLoc, mat);
-					break;
-				}
-			case MODELVIEWMATRIX_INVERSETRANSPOSE:
-				{
-					MT_Matrix4x4 mat(view*model);
-					mat.invert();
-					SetUniform(mPreDefLoc, mat, true);
-					break;
-				}
-			case CAM_POS:
-				{
-					MT_Point3 pos(rasty->GetCameraPosition());
-					SetUniform(mPreDefLoc, pos);
-					break;
-				}
-			case VIEWMATRIX:
-				{
-					SetUniform(mPreDefLoc, view);
-					break;
-				}
-			case VIEWMATRIX_TRANSPOSE:
-				{
-					SetUniform(mPreDefLoc, view, true);
-					break;
-				}
-			case VIEWMATRIX_INVERSE:
-				{
-					view.invert();
-					SetUniform(mPreDefLoc, view);
-					break;
-				}
-			case VIEWMATRIX_INVERSETRANSPOSE:
-				{
-					view.invert();
-					SetUniform(mPreDefLoc, view, true);
+			switch (uni->mType)
+			{
+				case MODELMATRIX:
+					{
+						SetUniform(uni->mLoc, model);
+						break;
+					}
+				case MODELMATRIX_TRANSPOSE:
+					{
+						SetUniform(uni->mLoc, model, true);
+						break;
+					}
+				case MODELMATRIX_INVERSE:
+					{
+						model.invert();
+						SetUniform(uni->mLoc, model);
+						break;
+					}
+				case MODELMATRIX_INVERSETRANSPOSE:
+					{
+						model.invert();
+						SetUniform(uni->mLoc, model, true);
+						break;
+					}
+				case MODELVIEWMATRIX:
+					{
+						SetUniform(uni->mLoc, view*model);
+						break;
+					}
+
+				case MODELVIEWMATRIX_TRANSPOSE:
+					{
+						MT_Matrix4x4 mat(view*model);
+						SetUniform(uni->mLoc, mat, true);
+						break;
+					}
+				case MODELVIEWMATRIX_INVERSE:
+					{
+						MT_Matrix4x4 mat(view*model);
+						mat.invert();
+						SetUniform(uni->mLoc, mat);
+						break;
+					}
+				case MODELVIEWMATRIX_INVERSETRANSPOSE:
+					{
+						MT_Matrix4x4 mat(view*model);
+						mat.invert();
+						SetUniform(uni->mLoc, mat, true);
+						break;
+					}
+				case CAM_POS:
+					{
+						MT_Point3 pos(rasty->GetCameraPosition());
+						SetUniform(uni->mLoc, pos);
+						break;
+					}
+				case VIEWMATRIX:
+					{
+						SetUniform(uni->mLoc, view);
+						break;
+					}
+				case VIEWMATRIX_TRANSPOSE:
+					{
+						SetUniform(uni->mLoc, view, true);
+						break;
+					}
+				case VIEWMATRIX_INVERSE:
+					{
+						view.invert();
+						SetUniform(uni->mLoc, view);
+						break;
+					}
+				case VIEWMATRIX_INVERSETRANSPOSE:
+					{
+						view.invert();
+						SetUniform(uni->mLoc, view, true);
+						break;
+					}
+				case CONSTANT_TIMER:
+					{
+						SetUniform(uni->mLoc, (float)rasty->GetTime());
+						break;
+					}
+				default:
 					break;
-				}
-			default:
-				break;
+			}
 		}
 	}
 #endif
@@ -428,7 +628,11 @@ int BL_Shader::GetUniformLocation(const STR_String& name)
 		RAS_EXT_support._ARB_shader_objects 
 		)
 	{
-		return bgl::blGetUniformLocationARB(mShader, name.ReadPtr());
+		MT_assert(mShader!=0);
+		int location = bgl::blGetUniformLocationARB(mShader, name.ReadPtr());
+		if(location == -1)
+			spit("Invalid uniform value: " << name.ReadPtr() << ".");
+		return location;
 	}
 #endif
 	return -1;
@@ -493,6 +697,19 @@ void BL_Shader::SetUniform(int uniform, const unsigned int& 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 
+		)
+	{
+		bgl::blUniform1iARB(uniform, val);
+	}
+#endif
+}
+
 void BL_Shader::SetUniform(int uniform, const float& val)
 {
 #ifdef GL_ARB_shader_objects
@@ -530,14 +747,55 @@ void BL_Shader::SetUniform(int uniform, const MT_Matrix3x3& vec, bool transpose)
 		)
 	{
 		float value[9];
-		value[0] = vec[0][0]; value[1] = vec[1][0]; value[2] = vec[2][0]; 
-		value[3] = vec[0][1]; value[4] = vec[1][1]; value[5] = vec[2][1]; 
-		value[6] = vec[0][2]; value[7] = vec[1][2]; value[7] = vec[2][2]; 
+		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);
 	}
 #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(len == 2) 
+			bgl::blUniform2fvARB(uniform, 1,(GLfloat*)val);
+		else if (len == 3)
+			bgl::blUniform3fvARB(uniform, 1,(GLfloat*)val);
+		else if (len == 4)
+			bgl::blUniform4fvARB(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(len == 2) 
+			bgl::blUniform2ivARB(uniform, 1, (GLint*)val);
+		else if (len == 3)
+			bgl::blUniform3ivARB(uniform, 1, (GLint*)val);
+		else if (len == 4)
+			bgl::blUniform4ivARB(uniform, 1, (GLint*)val);
+		else
+			MT_assert(0);
+	}
+#endif
+}
+
+
 PyObject* BL_Shader::_getattr(const STR_String& attr)
 {
 	_getattr_up(PyObjectPlus);
@@ -563,7 +821,8 @@ PyMethodDef BL_Shader::Methods[] =
 	KX_PYMETHODTABLE( BL_Shader, setUniform2i ),
 	KX_PYMETHODTABLE( BL_Shader, setUniform3i ),
 	KX_PYMETHODTABLE( BL_Shader, setUniform4i ),
-	KX_PYMETHODTABLE( BL_Shader, setAttrib ),
+// TODO: GL_ARB_vertex/fragment_program support
+//	KX_PYMETHODTABLE( BL_Shader, setAttrib ),
 
 	KX_PYMETHODTABLE( BL_Shader, setUniformfv ),
 	KX_PYMETHODTABLE( BL_Shader, setUniformiv ),
@@ -634,16 +893,15 @@ KX_PYMETHODDEF_DOC( BL_Shader, setSource," setSource(vertexProgram, fragmentProg
 KX_PYMETHODDEF_DOC( BL_Shader, delSource, "delSource( )" )
 {
 #ifdef GL_ARB_shader_objects
+	ClearUniforms();
+	bgl::blUseProgramObjectARB(0);
+
 	bgl::blDeleteObjectARB(mShader);
 	mShader		= 0;
-	vertProg	= 0;
-	fragProg	= 0;
 	mOk			= 0;
 	mUse		= 0;
-	bgl::blUseProgramObjectARB(0);
 #endif
 	Py_Return;
-
 }
 
 KX_PYMETHODDEF_DOC( BL_Shader, isValid, "isValid()" )
@@ -693,7 +951,6 @@ KX_PYMETHODDEF_DOC( BL_Shader, validate, "validate()")
 
 KX_PYMETHODDEF_DOC( BL_Shader, setSampler, "setSampler(name, index)" )
 {
-#ifdef GL_ARB_shader_objects
 	if(mError) {
 		Py_INCREF(Py_None);
 		return Py_None;
@@ -703,29 +960,16 @@ KX_PYMETHODDEF_DOC( BL_Shader, setSampler, "setSampler(name, index)" )
 	int index=-1;
 	if(PyArg_ParseTuple(args, "si", &uniform, &index)) 
 	{
-		if(mShader==0) {
-			PyErr_Format(PyExc_ValueError, "invalid shader object");
-			return NULL;
-		}
-
-		int loc= bgl::blGetUniformLocationARB(mShader, uniform);
-		if( loc==-1 ) {
-			spit("Invalid uniform value: " << uniform << ".");
-			Py_Return;
-		}
-
-		else {
+		int loc = GetUniformLocation(uniform);
+		if(loc != -1) {
 			if(index <= MAXTEX)
-				mSampler[index].loc = loc;
+				mSampler[index].mLoc = loc;
 			else
 				spit("Invalid texture sample index: " << index);
-			Py_Return;
 		}
+		Py_Return;
 	}
 	return NULL;
-#else
-	Py_Return;
-#endif//GL_ARB_shader_objects
 }
 
 KX_PYMETHODDEF_DOC( BL_Shader, setNumberOfPasses, "setNumberOfPasses( max-pass )" )
@@ -741,7 +985,6 @@ KX_PYMETHODDEF_DOC( BL_Shader, setNumberOfPasses, "setNumberOfPasses( max-pass )
 /// access functions
 KX_PYMETHODDEF_DOC( BL_Shader, setUniform1f, "setUniform1f(name, fx)" )
 {
-#ifdef GL_ARB_shader_objects
 	if(mError) {
 		Py_INCREF(Py_None);
 		return Py_None;
@@ -751,34 +994,23 @@ KX_PYMETHODDEF_DOC( BL_Shader, setUniform1f, "setUniform1f(name, fx)" )
 	float value=0;
 	if(PyArg_ParseTuple(args, "sf", &uniform, &value ))
 	{
-		if( mShader==0 )
-		{
-			PyErr_Format(PyExc_ValueError, "invalid shader object");
-			return NULL;
-		}
-		int loc= bgl::blGetUniformLocationARB(mShader, uniform);
-		if( loc==-1 )
+		int loc = GetUniformLocation(uniform);
+		if(loc != -1)
 		{
-			spit("Invalid uniform value: " << uniform << ".");
-			Py_Return;
-		}else
-		{
-			bgl::blUseProgramObjectARB( mShader );
-			bgl::blUniform1fARB( loc, value );
-			Py_Return;
+#ifdef SORT_UNIFORMS
+			SetUniformfv(loc, BL_Uniform::UNI_FLOAT, &value, sizeof(float));
+#else			
+			SetUniform( loc, (float)value );
+#endif
 		}
-
+		Py_Return;
 	}
 	return NULL;
-#else
-	Py_Return;
-#endif
 }
 
 
 KX_PYMETHODDEF_DOC( BL_Shader, setUniform2f , "setUniform2f(name, fx, fy)")
 {
-#ifdef GL_ARB_shader_objects
 	if(mError) {
 		Py_INCREF(Py_None);
 		return Py_None;
@@ -787,34 +1019,23 @@ KX_PYMETHODDEF_DOC( BL_Shader, setUniform2f , "setUniform2f(name, fx, fy)")
 	float array[2]={ 0,0 };
 	if(PyArg_ParseTuple(args, "sff", &uniform, &array[0],&array[1] ))
 	{
-		if( mShader==0 )
-		{
-			PyErr_Format(PyExc_ValueError, "invalid shader object");
-			return NULL;
-		}
-		int loc= bgl::blGetUniformLocationARB(mShader , uniform);
-		if( loc==-1 )
-		{
-			spit("Invalid uniform value: " << uniform << ".");
-			Py_Return;
-		}else
+		int loc = GetUniformLocation(uniform);
+		if(loc != -1)
 		{
-			bgl::blUseProgramObjectARB( mShader );
-			bgl::blUniform2fARB(loc, array[0],array[1] );
-			Py_Return;
+#ifdef SORT_UNIFORMS
+			SetUniformfv(loc, BL_Uniform::UNI_FLOAT2, array, (sizeof(float)*2) );
+#else
+			SetUniform(loc, array, 2);
+#endif
 		}
-
+		Py_Return;
 	}
 	return NULL;
-#else
-	Py_Return;
-#endif//GL_ARB_shader_objects
 }
 
 
 KX_PYMETHODDEF_DOC( BL_Shader, setUniform3f, "setUniform3f(name, fx,fy,fz) ")
 {
-#ifdef GL_ARB_shader_objects
 	if(mError) {
 		Py_INCREF(Py_None);
 		return Py_None;
@@ -823,34 +1044,24 @@ KX_PYMETHODDEF_DOC( BL_Shader, setUniform3f, "setUniform3f(name, fx,fy,fz) ")
 	float array[3]={0,0,0};
 	if(PyArg_ParseTuple(args, "sfff", &uniform, &array[0],&array[1],&array[2]))
 	{
-		if(mShader==0)
-		{
-			PyErr_Format(PyExc_ValueError, "invalid shader object");
-			return NULL;
-		}
-		int loc= bgl::blGetUniformLocationARB(mShader , uniform);
-		if( loc==-1 )
-		{
-			spit("Invalid uniform value: " << uniform << ".");
-			Py_Return;
-		}else
+		int loc = GetUniformLocation(uniform);
+		if(loc != -1)
 		{
-			bgl::blUseProgramObjectARB(mShader);
-			bgl::blUniform3fARB(loc, array[0],array[1],array[2]);
-			Py_Return;
+#ifdef SORT_UNIFORMS
+			SetUniformfv(loc, BL_Uniform::UNI_FLOAT3, array, (sizeof(float)*3) );
+#else
+			SetUniform(loc, array, 3);
+#endif
 		}
+		Py_Return;
 
 	}
 	return NULL;
-#else
-	Py_Return;
-#endif//GL_ARB_shader_objects
 }
 
 
 KX_PYMETHODDEF_DOC( BL_Shader, setUniform4f, "setUniform4f(name, fx,fy,fz, fw) ")
 {
-#ifdef GL_ARB_shader_objects
 	if(mError) {
 		Py_INCREF(Py_None);
 		return Py_None;
@@ -859,33 +1070,23 @@ KX_PYMETHODDEF_DOC( BL_Shader, setUniform4f, "setUniform4f(name, fx,fy,fz, fw) "
 	float array[4]={0,0,0,0};
 	if(PyArg_ParseTuple(args, "sffff", &uniform, &array[0],&array[1],&array[2], &array[3]))
 	{
-		if(mShader==0)
+		int loc = GetUniformLocation(uniform);
+		if(loc != -1)
 		{
-			PyErr_Format(PyExc_ValueError, "invalid shader object");
-			return NULL;
-		}
-		int loc= bgl::blGetUniformLocationARB(mShader , uniform);
-		if( loc==-1 )
-		{
-			spit("Invalid uniform value: " << uniform << ".");
-			Py_Return;
-		}else
-		{
-			bgl::blUseProgramObjectARB(mShader);
-			bgl::blUniform4fARB(loc, array[0],array[1],array[2], array[3]);
-			Py_Return;
+#ifdef SORT_UNIFORMS
+			SetUniformfv(loc, BL_Uniform::UNI_FLOAT4, array, (sizeof(float)*4) );
+#else
+			SetUniform(loc, array, 4);
+#endif
 		}
+		Py_Return;
 	}
 	return NULL;
-#else
-	Py_Return;
-#endif//GL_ARB_shader_objects
 }
 
 
 KX_PYMETHODDEF_DOC( BL_Shader, setUniform1i, "setUniform1i(name, ix)" )
 {
-#ifdef GL_ARB_shader_objects
 	if(mError) {
 		Py_INCREF(Py_None);
 		return Py_None;
@@ -894,33 +1095,23 @@ KX_PYMETHODDEF_DOC( BL_Shader, setUniform1i, "setUniform1i(name, ix)" )
 	int value=0;
 	if(PyArg_ParseTuple(args, "si", &uniform, &value ))
 	{
-		if( mShader==0 )
-		{
-			PyErr_Format(PyExc_ValueError, "invalid shader object");
-			return NULL;
-		}
-		int loc= bgl::blGetUniformLocationARB(mShader, uniform);
-		if( loc==-1 )
-		{
-			spit("Invalid uniform value: " << uniform << ".");
-			Py_Return;
-		}else
+		int loc = GetUniformLocation(uniform);
+		if(loc != -1)
 		{
-			bgl::blUseProgramObjectARB( mShader );
-			bgl::blUniform1iARB( loc, value );
-			Py_Return;
+#ifdef SORT_UNIFORMS
+			SetUniformiv(loc, BL_Uniform::UNI_INT, &value, sizeof(int));
+#else
+			SetUniform(loc, (int)value);
+#endif
 		}
+		Py_Return;
 	}
 	return NULL;
-#else
-	Py_Return;
-#endif//GL_ARB_shader_objects
 }
 
 
 KX_PYMETHODDEF_DOC( BL_Shader, setUniform2i , "setUniform2i(name, ix, iy)")
 {
-#ifdef GL_ARB_shader_objects
 	if(mError) {
 		Py_INCREF(Py_None);
 		return Py_None;
@@ -929,67 +1120,48 @@ KX_PYMETHODDEF_DOC( BL_Shader, setUniform2i , "setUniform2i(name, ix, iy)")
 	int array[2]={ 0,0 };
 	if(PyArg_ParseTuple(args, "sii", &uniform, &array[0],&array[1] ))
 	{
-		if( mShader==0 )
-		{
-			PyErr_Format(PyExc_ValueError, "invalid shader object");
-			return NULL;
-		}
-		int loc= bgl::blGetUniformLocationARB(mShader , uniform);
-		if( loc==-1 )
+		int loc = GetUniformLocation(uniform);
+		if(loc != -1)
 		{
-			spit("Invalid uniform value: " << uniform << ".");
-			Py_Return;
-		}else
-		{
-			bgl::blUseProgramObjectARB( mShader );
-			bgl::blUniform2iARB(loc, array[0],array[1] );
-			Py_Return;
+#ifdef SORT_UNIFORMS
+			SetUniformiv(loc, BL_Uniform::UNI_INT2, array, sizeof(int)*2);
+#else
+			SetUniform(loc, array, 2);
+#endif
 		}
+		Py_Return;
 	}
 	return NULL;
-#else
-	Py_Return;
-#endif//GL_ARB_shader_objects
 }
 
 
 KX_PYMETHODDEF_DOC( BL_Shader, setUniform3i, "setUniform3i(name, ix,iy,iz) ")
 {
-#ifdef GL_ARB_shader_objects
 	if(mError) {
 		Py_INCREF(Py_None);
 		return Py_None;
 	}
+
 	char *uniform="";
 	int array[3]={0,0,0};
 	if(PyArg_ParseTuple(args, "siii", &uniform, &array[0],&array[1],&array[2]))
 	{
-		if(mShader==0)
+		int loc = GetUniformLocation(uniform);
+		if(loc != -1)
 		{
-			PyErr_Format(PyExc_ValueError, "invalid shader object");
-			return NULL;
-		}
-		int loc= bgl::blGetUniformLocationARB(mShader , uniform);
-		if( loc==-1 )
-		{
-			spit("Invalid uniform value: " << uniform << ".");
-			Py_Return;
-		}else
-		{
-			bgl::blUseProgramObjectARB(mShader);
-			bgl::blUniform3iARB(loc, array[0],array[1],array[2]);
-			Py_Return;
+#ifdef SORT_UNIFORMS
+			SetUniformiv(loc, BL_Uniform::UNI_INT3, array, sizeof(int)*3);
+#else
+			SetUniform(loc, array, 3);
+#endif
 		}
+		Py_Return;
 	}
 	return NULL;
-#else
-	Py_Return;
-#endif//GL_ARB_shader_objects
 }
 
 KX_PYMETHODDEF_DOC( BL_Shader, setUniform4i, "setUniform4i(name, ix,iy,iz, iw) ")
 {
-#ifdef GL_ARB_shader_objects
 	if(mError) {
 		Py_INCREF(Py_None);
 		return Py_None;
@@ -998,32 +1170,22 @@ KX_PYMETHODDEF_DOC( BL_Shader, setUniform4i, "setUniform4i(name, ix,iy,iz, iw) "
 	int array[4]={0,0,0, 0};
 	if(PyArg_ParseTuple(args, "siiii", &uniform, &array[0],&array[1],&array[2], &array[3] ))
 	{
-		if(mShader==0)
-		{
-			PyErr_Format(PyExc_ValueError, "invalid shader object");
-			return NULL;
-		}
-		int loc= bgl::blGetUniformLocationARB(mShader , uniform);
-		if( loc==-1 )
-		{
-			spit("Invalid uniform value: " << uniform << ".");
-			Py_Return;
-		}else
+		int loc = GetUniformLocation(uniform);
+		if(loc != -1)
 		{
-			bgl::blUseProgramObjectARB(mShader);
-			bgl::blUniform4iARB(loc, array[0],array[1],array[2], array[3]);
-			Py_Return;
+#ifdef SORT_UNIFORMS
+			SetUniformiv(loc, BL_Uniform::UNI_INT4, array, sizeof(int)*4);
+#else
+			SetUniform(loc, array, 4);
+#endif
 		}
+		Py_Return;
 	}
 	return NULL;
-#else
-	Py_Return;
-#endif//GL_ARB_shader_objects
 }
 
 KX_PYMETHODDEF_DOC( BL_Shader, setUniformfv , "setUniformfv( float (list2 or list3 or list4) )")
 {
-#ifdef GL_ARB_shader_objects
 	if(mError) {
 		Py_INCREF(Py_None);
 		return Py_None;
@@ -1034,17 +1196,8 @@ KX_PYMETHODDEF_DOC( BL_Shader, setUniformfv , "setUniformfv( float (list2 or lis
 
 	if(PyArg_ParseTuple(args, "sO", &uniform, &listPtr))
 	{
-		if(mShader==0)
-		{
-			PyErr_Format(PyExc_ValueError, "invalid shader object");
-			return NULL;
-		}
-		int loc= bgl::blGetUniformLocationARB(mShader , uniform);
-		if( loc==-1 )
-		{
-			spit("Invalid uniform value: " << uniform << ".");
-			Py_Return;
-		}else
+		int loc = GetUniformLocation(uniform);
+		if(loc != -1)
 		{
 			if(PySequence_Check(listPtr))
 			{
@@ -1056,24 +1209,37 @@ KX_PYMETHODDEF_DOC( BL_Shader, setUniformfv , "setUniformfv( float (list2 or lis
 					array_data[i] = (float)PyFloat_AsDouble(item);
 					Py_DECREF(item);
 				}
+
 				switch(list_size)
 				{
 				case 2:
 					{
-						bgl::blUseProgramObjectARB(mShader);
-						bgl::blUniform2fARB(loc, array_data[0],array_data[1]);
+						float array2[2] = { array_data[0],array_data[1] };
+#ifdef SORT_UNIFORMS
+						SetUniformfv(loc, BL_Uniform::UNI_FLOAT2, array2, sizeof(float)*2);
+#else
+						SetUniform(loc, array2, 2);						
+#endif
 						Py_Return;
 					} break;
 				case 3:
 					{
-						bgl::blUseProgramObjectARB(mShader);
-						bgl::blUniform3fARB(loc, array_data[0],array_data[1], array_data[2]);
+						float array3[3] = { array_data[0],array_data[1],array_data[2] };
+#ifdef SORT_UNIFORMS
+						SetUniformfv(loc, BL_Uniform::UNI_FLOAT3, array3, sizeof(float)*3);
+#else
+						SetUniform(loc, array3, 3);	
+#endif
 						Py_Return;
 					}break;
 				case 4:
 					{
-						bgl::blUseProgramObjectARB(mShader);
-						bgl::blUniform4fARB(loc, array_data[0],array_data[1], array_data[2], array_data[3]);
+						float array4[4] = { array_data[0],array_data[1],array_data[2],array_data[3] };
+#ifdef SORT_UNIFORMS
+						SetUniformfv(loc, BL_Uniform::UNI_FLOAT4, array4, sizeof(float)*4);
+#else
+						SetUniform(loc, array4, 4);	
+#endif
 						Py_Return;
 					}break;
 				default:
@@ -1086,15 +1252,10 @@ KX_PYMETHODDEF_DOC( BL_Shader, setUniformfv , "setUniformfv( float (list2 or lis
 		}
 	}
 	return NULL;
-#else
-	Py_Return;
-#endif//GL_ARB_shader_objects
-
 }
 
 KX_PYMETHODDEF_DOC( BL_Shader, setUniformiv, "setUniformiv( int (list2 or list3 or list4) )")
 {
-#ifdef GL_ARB_shader_objects
 	if(mError) {
 		Py_INCREF(Py_None);
 		return Py_None;
@@ -1105,17 +1266,8 @@ KX_PYMETHODDEF_DOC( BL_Shader, setUniformiv, "setUniformiv( int (list2 or list3
 
 	if(PyArg_ParseTuple(args, "sO", &uniform, &listPtr))
 	{
-		if(mShader==0)
-		{
-			PyErr_Format(PyExc_ValueError, "invalid shader object");
-			return NULL;
-		}
-		int loc= bgl::blGetUniformLocationARB(mShader , uniform);
-		if( loc==-1 )
-		{
-			spit("Invalid uniform value: " << uniform << ".");
-			Py_Return;
-		}else
+		int loc = GetUniformLocation(uniform);
+		if(loc != -1)
 		{
 			if(PySequence_Check(listPtr))
 			{
@@ -1131,20 +1283,34 @@ KX_PYMETHODDEF_DOC( BL_Shader, setUniformiv, "setUniformiv( int (list2 or list3
 				{
 				case 2:
 					{
-						bgl::blUseProgramObjectARB(mShader);
-						bgl::blUniform2iARB(loc, array_data[0],array_data[1]);
+						int array2[2] = { array_data[0],array_data[1]};
+#ifdef SORT_UNIFORMS
+						SetUniformiv(loc, BL_Uniform::UNI_INT2, array2, sizeof(int)*2);
+#else
+						SetUniform(loc, array2, 2);						
+#endif
 						Py_Return;
 					} break;
 				case 3:
 					{
-						bgl::blUseProgramObjectARB(mShader);
-						bgl::blUniform3iARB(loc, array_data[0],array_data[1], array_data[2]);
+						int array3[3] = { array_data[0],array_data[1],array_data[2] };
+#ifdef SORT_UNIFORMS
+						SetUniformiv(loc, BL_Uniform::UNI_INT3, array3, sizeof(int)*3);
+						
+#else
+						SetUniform(loc, array3, 3);	
+#endif
 						Py_Return;
 					}break;
 				case 4:
 					{
-						bgl::blUseProgramObjectARB(mShader);
-						bgl::blUniform4iARB(loc, array_data[0],array_data[1], array_data[2], array_data[3]);
+						int array4[4] = { array_data[0],array_data[1],array_data[2],array_data[3] };
+#ifdef SORT_UNIFORMS
+						SetUniformiv(loc, BL_Uniform::UNI_INT4, array4, sizeof(int)*4);
+						
+#else
+						SetUniform(loc, array4, 4);	
+#endif
 						Py_Return;
 					}break;
 				default:
@@ -1157,16 +1323,12 @@ KX_PYMETHODDEF_DOC( BL_Shader, setUniformiv, "setUniformiv( int (list2 or list3
 		}
 	}
 	return NULL;
-#else
-	Py_Return;
-#endif//GL_ARB_shader_objects
 }
 
 
 KX_PYMETHODDEF_DOC( BL_Shader, setUniformMatrix4, 
 "setUniformMatrix4(uniform-name, mat-4x4, transpose(row-major=true, col-major=false)" )
 {
-#ifdef GL_ARB_shader_objects
 	if(mError) {
 		Py_INCREF(Py_None);
 		return Py_None;
@@ -1184,42 +1346,32 @@ KX_PYMETHODDEF_DOC( BL_Shader, setUniformMatrix4,
 	int transp=1; // MT_ is row major so transpose by default....
 	if(PyArg_ParseTuple(args, "sO|i",&uniform, &matrix,&transp))
 	{
-		if(mShader==0)
-		{
-			PyErr_Format(PyExc_ValueError, "invalid shader object");
-			return NULL;
-		}
-		int loc= bgl::blGetUniformLocationARB(mShader , uniform);
-		if( loc==-1 )
-		{
-			spit("Invalid uniform value: " << uniform << ".");
-			Py_Return;
-		}else
+		int loc = GetUniformLocation(uniform);
+		if(loc != -1)
 		{
 			if (PyObject_IsMT_Matrix(matrix, 4))
 			{
 				MT_Matrix4x4 mat;
 				if (PyMatTo(matrix, mat))
 				{
+#ifdef SORT_UNIFORMS
 					mat.getValue(matr);
-					bgl::blUseProgramObjectARB(mShader);
-					bgl::blUniformMatrix4fvARB(loc, 1, (transp!=0)?GL_TRUE:GL_FALSE, matr);
+					SetUniformfv(loc, BL_Uniform::UNI_MAT4, matr, (sizeof(float)*16), (transp!=0) );
+#else
+					SetUniform(loc,mat,(transp!=0));
+#endif
 					Py_Return;
 				}
 			}
 		}
 	}
 	return NULL;
-#else
-	Py_Return;
-#endif//GL_ARB_shader_objects
 }
 
 
 KX_PYMETHODDEF_DOC( BL_Shader, setUniformMatrix3,
 "setUniformMatrix3(uniform-name, list[3x3], transpose(row-major=true, col-major=false)" )
 {
-#ifdef GL_ARB_shader_objects
 	if(mError) {
 		Py_INCREF(Py_None);
 		return Py_None;
@@ -1236,93 +1388,72 @@ KX_PYMETHODDEF_DOC( BL_Shader, setUniformMatrix3,
 	int transp=1; // MT_ is row major so transpose by default....
 	if(PyArg_ParseTuple(args, "sO|i",&uniform, &matrix,&transp))
 	{
-		if(mShader==0)
-		{
-			PyErr_Format(PyExc_ValueError, "invalid shader object");
-			return NULL;
-		}
-		int loc= bgl::blGetUniformLocationARB(mShader , uniform);
-		if( loc==-1 )
-		{
-			spit("Invalid uniform value: " << uniform << ".");
-			Py_Return;
-		}else
+		int loc = GetUniformLocation(uniform);
+		if(loc != -1)
 		{
 			if (PyObject_IsMT_Matrix(matrix, 3))
 			{
 				MT_Matrix3x3 mat;
 				if (PyMatTo(matrix, mat))
 				{
+#ifdef SORT_UNIFORMS
 					mat.getValue(matr);
-					bgl::blUseProgramObjectARB(mShader);
-					bgl::blUniformMatrix3fvARB(loc, 1, (transp!=0)?GL_TRUE:GL_FALSE, matr);
+					SetUniformfv(loc, BL_Uniform::UNI_MAT3, matr, (sizeof(float)*9), (transp!=0) );
+#else
+					SetUniform(loc,mat,(transp!=0));
+#endif
 					Py_Return;
+
 				}
 			}
 		}
 	}
 	return NULL;
-#else
-	Py_Return;
-#endif//GL_ARB_shader_objects
 }
 
 KX_PYMETHODDEF_DOC( BL_Shader, setAttrib, "setAttrib(enum)" )
 {
-#ifdef GL_ARB_shader_objects
-	if(mError) {
-		Py_INCREF(Py_None);
-		return Py_None;
-	}
-	int attr=0;
-	if(PyArg_ParseTuple(args, "i", &attr ))
-	{
-		if(mShader==0)
-		{
-			PyErr_Format(PyExc_ValueError, "invalid shader object");
-			return NULL;
-		}
-		mAttr=SHD_TANGENT;
-		bgl::blUseProgramObjectARB(mShader);
-		bgl::blBindAttribLocationARB(mShader, mAttr, "Tangent");
-		Py_Return;
-	}
-	return NULL;
-#endif
 	Py_Return;
 }
 
+
 KX_PYMETHODDEF_DOC( BL_Shader, setUniformDef, "setUniformDef(name, enum)" )
 {
-#ifdef GL_ARB_shader_objects
 	if(mError) {
 		Py_INCREF(Py_None);
 		return Py_None;
 	}
 
 	char *uniform="";
-	int nloc;
+	int nloc=0;
 	if(PyArg_ParseTuple(args, "si",&uniform, &nloc))
 	{
-		if(mShader==0) {
-			PyErr_Format(PyExc_ValueError, "invalid shader object");
-			return NULL;
-		}
-		int loc= bgl::blGetUniformLocationARB(mShader , uniform);
-		if( loc==-1 )
+		int loc = GetUniformLocation(uniform);
+		if(loc != -1)
 		{
-			spit("Invalid uniform value: " << uniform << ".");
-			Py_Return;
-		}else
-		{
-			mPreDefLoc = loc;
-			mPreDefType = nloc;
+			bool defined = false;
+			BL_UniformVecDef::iterator it = mPreDef.begin();
+			while(it != mPreDef.end()) {
+				if((*it)->mLoc == loc) {
+					defined = true;
+					break;
+				}
+				it++;
+			}
+			if(defined)
+			{
+				Py_Return;
+			}
+
+			BL_DefUniform *uni = new BL_DefUniform();
+			uni->mLoc = loc;
+			uni->mType = nloc;
+			uni->mFlag = 0;
+			mPreDef.push_back(uni);
 			Py_Return;
 		}
 	}
 	return NULL;
-
-#endif
 }
 
-
+// eof
diff --git a/source/gameengine/Ketsji/BL_Shader.h b/source/gameengine/Ketsji/BL_Shader.h
index 6536fdc8175..550f4750a33 100644
--- a/source/gameengine/Ketsji/BL_Shader.h
+++ b/source/gameengine/Ketsji/BL_Shader.h
@@ -11,53 +11,124 @@
 #include "MT_Tuple3.h"
 #include "MT_Tuple4.h"
 
-// -----------------------------------
-// user state management
-typedef struct uSampler
+#define SHADER_ATTRIBMAX 1
+
+/**
+ * BL_Sampler
+ *  Sampler access 
+ */
+class BL_Sampler
+{
+public:
+	BL_Sampler():
+		mLoc(-1),
+		mTexture(0),
+		mOwn(0)
+	{
+	}
+	int				mLoc;		// Sampler location
+	BL_Texture*		mTexture;	// Texture data
+	bool			mOwn;		// True if we own it
+};
+
+/**
+ * BL_Uniform
+ *  uniform storage 
+ */
+class BL_Uniform 
 {
-	unsigned int	type;
-	int				pass;
-	int				unit;
-	int				loc;
-	BL_Texture*		gl_texture;
-	int				flag;
-}uSampler;
-
-#define SAMP_2D		1
-#define SAMP_CUBE	2
-#define ATTRIBMAX	1
-
-// uSampler::flag;
-enum 
+private:
+	int			mLoc;		// Uniform location
+	void*		mData;		// Memory allocated for variable
+	bool		mDirty;		// Caching variable  
+	int			mType;		// Enum UniformTypes
+	bool		mTranspose; // Transpose matrices
+	const int	mDataLen;	// Length of our data
+public:
+	BL_Uniform(int data_size);
+	~BL_Uniform();
+	
+
+	void Apply(class BL_Shader *shader);
+	void SetData(int location, int type, bool transpose=false);
+
+	enum UniformTypes {
+		UNI_NONE	=0,
+		UNI_INT,
+		UNI_FLOAT,
+		UNI_INT2,
+		UNI_FLOAT2,
+		UNI_INT3,
+		UNI_FLOAT3,
+		UNI_INT4,
+		UNI_FLOAT4,
+		UNI_MAT3,
+		UNI_MAT4,
+		UNI_MAX
+	};
+
+	int GetLocation()	{ return mLoc; }
+	void* getData()		{ return mData; }
+};
+
+/**
+ * BL_DefUniform
+ * pre defined uniform storage 
+ */
+class BL_DefUniform
 {
-	OWN=1
+public:
+	BL_DefUniform() :
+		mType(0),
+		mLoc(0),
+		mFlag(0)
+	{
+	}
+	int				mType;
+	int				mLoc;
+	unsigned int	mFlag;
 };
 
-// ----------------
+/**
+ * BL_Shader
+ *  shader access
+ */
 class BL_Shader : public PyObjectPlus
 {
 	Py_Header;
 private:
-	unsigned int	mShader;
-	int				mPass;
-	bool			mOk;
-	bool			mUse;
-	uSampler		mSampler[MAXTEX];
-	char*			vertProg;
-	char*			fragProg;
-	bool			mError;
-	
-	int				mAttr;
-	int				mPreDefLoc;
-	int				mPreDefType;
-	bool			mDeleteTexture;
+	typedef std::vector<BL_Uniform*>	BL_UniformVec;
+	typedef std::vector<BL_DefUniform*>	BL_UniformVecDef;
+
+	unsigned int	mShader;			// Shader object 
+	int				mPass;				// 1.. unused
+	bool			mOk;				// Valid and ok
+	bool			mUse;				// ...
+	BL_Sampler		mSampler[MAXTEX];	// Number of samplers
+	char*			vertProg;			// Vertex program string
+	char*			fragProg;			// Fragment program string
+	bool			mError;				// ...
+	bool			mDirty;				// 
+
+	// Compiles and links the shader
+	bool LinkProgram();
+
+	// Stored uniform variables
+	BL_UniformVec		mUniforms;
+	BL_UniformVecDef	mPreDef;
+
+	// search by location
+	BL_Uniform*		FindUniform(const int location);
+	// clears uniform data
+	void			ClearUniforms();
 
-	bool			LinkProgram();
 public:
 	BL_Shader(PyTypeObject *T=&Type);
 	virtual ~BL_Shader();
 
-	enum AttribTypes{
+	// Unused for now tangent is set as 
+	// tex coords
+	enum AttribTypes {
 		SHD_TANGENT =1
 	};
 
@@ -78,46 +149,61 @@ public:
 		VIEWMATRIX_TRANSPOSE,
 		VIEWMATRIX_INVERSE,
 		VIEWMATRIX_INVERSETRANSPOSE,
-		CAM_POS
+
+		// Current camera position 
+		CAM_POS,
+
+		// RAS timer
+		CONSTANT_TIMER
 	};
 
-	char*		GetVertPtr();
-	char*		GetFragPtr();
-	void		SetVertPtr( char *vert );
-	void		SetFragPtr( char *frag );
+	const char* GetVertPtr();
+	const char* GetFragPtr();
+	void SetVertPtr( char *vert );
+	void SetFragPtr( char *frag );
 	
 	// ---
 	int getNumPass()	{return mPass;}
-	bool use()			{return mUse;}
 	bool GetError()		{return mError;}
 	// ---
-	// access
-	const uSampler*		getSampler(int i);
+	const BL_Sampler*	GetSampler(int i);
 	void				SetSampler(int loc, int unit);
 
 	const bool			Ok()const;
 	unsigned int		GetProg();
 	void				SetProg(bool enable);
-	int					GetAttribute(){return mAttr;};
 
-	void InitializeSampler( int type, int unit, int pass, BL_Texture* texture );
+	// -- 
+	// Apply methods : sets colected uniforms
+	void ApplyShader();
+	void UnloadShader();
 
-	void Update( const class KX_MeshSlot & ms, class RAS_IRasterizer* rasty );
+	// Update predefined uniforms each render call
+	void Update(const class KX_MeshSlot & ms, class RAS_IRasterizer* rasty);
 
-	// form tuhopuu2
-	virtual int GetAttribLocation(const STR_String& name);
-	virtual void BindAttribute(const STR_String& attr, int loc);
-	virtual int GetUniformLocation(const STR_String& name);
-	virtual void SetUniform(int uniform, const MT_Tuple2& vec);
-	virtual void SetUniform(int uniform, const MT_Tuple3& vec);
-	virtual void SetUniform(int uniform, const MT_Tuple4& vec);
-	virtual void SetUniform(int uniform, const unsigned int& val);
-	virtual void SetUniform(int uniform, const float& val);
-	virtual void SetUniform(int uniform, const MT_Matrix4x4& vec, bool transpose=false);
-	virtual void SetUniform(int uniform, const MT_Matrix3x3& vec, bool transpose=false);
+	// Set sampler units (copied)
+	void InitializeSampler(int unit, BL_Texture* texture );
 
-	// -----------------------------------
-	// python interface
+
+	void SetUniformfv(int location,int type, float *param, int size,bool transpose=false);
+	void SetUniformiv(int location,int type, int *param, int size,bool transpose=false);
+
+	int GetAttribLocation(const STR_String& name);
+	void BindAttribute(const STR_String& attr, int loc);
+	int GetUniformLocation(const STR_String& name);
+
+	void SetUniform(int uniform, const MT_Tuple2& vec);
+	void SetUniform(int uniform, const MT_Tuple3& vec);
+	void SetUniform(int uniform, const MT_Tuple4& vec);
+	void SetUniform(int uniform, const MT_Matrix4x4& vec, bool transpose=false);
+	void SetUniform(int uniform, const MT_Matrix3x3& vec, bool transpose=false);
+	void SetUniform(int uniform, const float& val);
+	void SetUniform(int uniform, const float* val, int len);
+	void SetUniform(int uniform, const int* val, int len);
+	void SetUniform(int uniform, const unsigned int& val);
+	void SetUniform(int uniform, const int val);
+
+	// Python interface
 	virtual PyObject* _getattr(const STR_String& attr);
 
 	KX_PYMETHOD_DOC( BL_Shader, setSource );
@@ -148,11 +234,9 @@ public:
 
 	KX_PYMETHOD_DOC( BL_Shader, setAttrib );
 
-	// these come from within the material buttons
+	// These come from within the material buttons
 	// sampler2d/samplerCube work
 	KX_PYMETHOD_DOC( BL_Shader, setSampler);
 };
 
-
-
 #endif//__BL_SHADER_H__
diff --git a/source/gameengine/Ketsji/BL_Texture.cpp b/source/gameengine/Ketsji/BL_Texture.cpp
index 4ff31b885ba..e6356207225 100644
--- a/source/gameengine/Ketsji/BL_Texture.cpp
+++ b/source/gameengine/Ketsji/BL_Texture.cpp
@@ -59,8 +59,8 @@ BL_Texture::BL_Texture()
 	mOk(0),
 	mNeedsDeleted(0),
 	mType(0),
-	mName(""),
-	mUnit(0)
+	mUnit(0),
+	mEnvState(0)
 {
 	// --
 }
@@ -77,6 +77,16 @@ void BL_Texture::DeleteTex()
 		mNeedsDeleted = 0;
 		mOk = 0;
 	}
+
+	if(mEnvState) {
+		glDeleteLists((GLuint)mEnvState, 1);
+		mEnvState =0;
+	}
+
+	if(mDisableState) {
+		glDeleteLists((GLuint)mDisableState, 1);
+		mDisableState =0;
+	}
 }
 
 
@@ -98,7 +108,6 @@ bool BL_Texture::InitFromImage(int unit,  Image *img, bool mipmap)
 	}
 	mTexture = img->bindcode;
 
-	mName = img->id.name;
 	mType = GL_TEXTURE_2D;
 	mUnit = unit;
 
@@ -193,7 +202,6 @@ bool BL_Texture::InitCubeMap(int unit,  EnvMap *cubemap )
 	mNeedsDeleted =	1;
 	mType = GL_TEXTURE_CUBE_MAP_ARB;
 	mTexture = 0;
-	mName = CubeMap->ima->id.name;
 	mUnit = unit;
 
 
@@ -263,13 +271,6 @@ bool BL_Texture::InitCubeMap(int unit,  EnvMap *cubemap )
 #endif//GL_ARB_texture_cube_map
 }
 
-
-STR_String BL_Texture::GetName() const
-{
-	return mName;
-}
-
-
 bool BL_Texture::IsValid()
 {
 	return (mTexture!= 0)?glIsTexture(mTexture)!=0:false;
@@ -308,8 +309,12 @@ int BL_Texture::GetMaxUnits()
 void BL_Texture::ActivateFirst()
 {
 #ifdef GL_ARB_multitexture
-	if(RAS_EXT_support._ARB_multitexture)
+	if(RAS_EXT_support._ARB_multitexture) {
 		bgl::blActiveTextureARB(GL_TEXTURE0_ARB);
+		//if(mVertexArray)
+		//	bgl::blClientActiveTextureARB(GL_TEXTURE0_ARB);
+	}
+
 #endif
 }
 
@@ -318,7 +323,11 @@ void BL_Texture::ActivateUnit(int unit)
 #ifdef GL_ARB_multitexture
 	if(RAS_EXT_support._ARB_multitexture) {
 		if(unit <= MAXTEX)
+		{
 			bgl::blActiveTextureARB(GL_TEXTURE0_ARB+unit);
+			//if(mVertexArray)
+			//	bgl::blClientActiveTextureARB(GL_TEXTURE0_ARB+unit);
+		}
 	}
 #endif
 }
@@ -327,8 +336,11 @@ void BL_Texture::ActivateUnit(int unit)
 void BL_Texture::DisableUnit()
 {
 #ifdef GL_ARB_multitexture
-	if(RAS_EXT_support._ARB_multitexture)
+	if(RAS_EXT_support._ARB_multitexture){
 		bgl::blActiveTextureARB(GL_TEXTURE0_ARB+mUnit);
+		//if(mVertexArray)
+		//	bgl::blClientActiveTextureARB(GL_TEXTURE0_ARB+mUnit);
+	}
 #endif
 	glMatrixMode(GL_TEXTURE);
 	glLoadIdentity();
@@ -350,10 +362,23 @@ void BL_Texture::DisableUnit()
 void BL_Texture::DisableAllTextures()
 {
 #ifdef GL_ARB_multitexture
+	if(mDisableState != 0 && glIsList(mDisableState)) {
+		glCallList(mDisableState);
+		return;
+	}
+	if(!mDisableState)
+		mDisableState = glGenLists(1);
+
+	glNewList(mDisableState, GL_COMPILE_AND_EXECUTE);
+
 	glDisable(GL_BLEND);
 	for(int i=0; i<MAXTEX; i++) {
 		if(RAS_EXT_support._ARB_multitexture)
+		{
 			bgl::blActiveTextureARB(GL_TEXTURE0_ARB+i);
+			//if(mVertexArray)
+			//	bgl::blClientActiveTextureARB(GL_TEXTURE0_ARB+i);
+		}
 		glMatrixMode(GL_TEXTURE);
 		glLoadIdentity();
 		glMatrixMode(GL_MODELVIEW);
@@ -368,6 +393,8 @@ void BL_Texture::DisableAllTextures()
 		glDisable(GL_TEXTURE_GEN_Q);
 		glTexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_MODULATE );
 	}
+
+	glEndList();
 #endif
 }
 
@@ -376,7 +403,11 @@ void BL_Texture::ActivateTexture()
 {
 #ifdef GL_ARB_multitexture
 	if(RAS_EXT_support._ARB_multitexture)
+	{
 		bgl::blActiveTextureARB(GL_TEXTURE0_ARB+mUnit);
+	//	if(mVertexArray)
+	//		bgl::blClientActiveTextureARB(GL_TEXTURE0_ARB+mUnit);
+	}
 #ifdef GL_ARB_texture_cube_map
 	if(mType == GL_TEXTURE_CUBE_MAP_ARB && RAS_EXT_support._ARB_texture_cube_map ) {
 		glDisable(GL_TEXTURE_2D);
@@ -385,7 +416,10 @@ void BL_Texture::ActivateTexture()
 	} else
 #endif
 	{
-		glDisable(GL_TEXTURE_CUBE_MAP_ARB);
+#ifdef GL_ARB_texture_cube_map
+		if(RAS_EXT_support._ARB_texture_cube_map )
+			glDisable(GL_TEXTURE_CUBE_MAP_ARB);
+#endif
 		glBindTexture( GL_TEXTURE_2D, mTexture );	
 		glEnable(GL_TEXTURE_2D);
 	}
@@ -443,6 +477,16 @@ void BL_Texture::setTexEnv(BL_Material *mat, bool modulate)
 		return;
 	}
 
+	if(glIsList(mEnvState))
+	{
+		glCallList(mEnvState);
+		return;
+	}
+	if(!mEnvState)
+		mEnvState = glGenLists(1);
+
+	glNewList(mEnvState, GL_COMPILE_AND_EXECUTE);
+
 	glTexEnvf(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_COMBINE_ARB );
 
 	GLfloat blend_operand		= GL_SRC_COLOR;
@@ -560,6 +604,8 @@ void BL_Texture::setTexEnv(BL_Material *mat, bool modulate)
 			} break;
 	}
 	glTexEnvf(	GL_TEXTURE_ENV, GL_RGB_SCALE_ARB,	1.0);
+
+	glEndList();
 #endif //!GL_ARB_texture_env_combine
 }
 
@@ -571,6 +617,9 @@ int BL_Texture::GetPow2(int n)
 	return n;
 }
 
+
+unsigned int BL_Texture::mDisableState = 0;
+
 extern "C" {
 
 void my_envmap_split_ima(EnvMap *env)
diff --git a/source/gameengine/Ketsji/BL_Texture.h b/source/gameengine/Ketsji/BL_Texture.h
index 2df14580e65..0c12b11b12b 100644
--- a/source/gameengine/Ketsji/BL_Texture.h
+++ b/source/gameengine/Ketsji/BL_Texture.h
@@ -1,8 +1,8 @@
 #ifndef __BL_TEXTURE_H__
 #define __BL_TEXTURE_H__
 
-#include <vector>
-#include <map>
+//	#include <vector>
+//	#include <map>
 
 #include "MT_Matrix4x4.h"
 #include "KX_Camera.h"
@@ -11,39 +11,36 @@
 struct Image;
 struct EnvMap;
 class BL_Material;
-class RTData;
 class RAS_Rect;
 class RAS_ICanvas;
+//class RTData;
 
-// --
 #include "STR_String.h"
 
 class BL_Texture
 {
 private:
 	// -----------------------------------
-	unsigned int		mTexture;
-	bool				mError;
-	bool				mOk;
-	bool				mNeedsDeleted;
-	unsigned int		mType;
-	STR_String			mName;
-	int					mUnit;
+	unsigned int		mTexture;		// Bound texture unit data
+	bool				mError;			// Errors
+	bool				mOk;			// ...
+	bool				mNeedsDeleted;	// If generated
+	unsigned int		mType;			// enum TEXTURE_2D | CUBE_MAP 
+	int					mUnit;			// Texture unit associated with mTexture
+	unsigned int		mEnvState;		// cache textureEnv
+	static unsigned int	mDisableState;	// speed up disabling calls
 	// -----------------------------------
+
 	void InitNonPow2Tex(unsigned int *p,int x,int y,bool mipmap );
 	void InitGLTex(unsigned int *p,int x,int y,bool mipmap );
-
 public:
 	BL_Texture();
 	~BL_Texture( );
-	
-	//operator const unsigned int () const;
+
 	bool Ok();
 	int	 GetUnit()			{return mUnit;}
 	void SetUnit(int unit)	{mUnit = unit;}
 
-	STR_String GetName() const;
-
 	unsigned int GetTextureType() const;
 	void DeleteTex();
 
diff --git a/source/gameengine/Ketsji/KX_BlenderMaterial.cpp b/source/gameengine/Ketsji/KX_BlenderMaterial.cpp
index d416ef55613..f61cab58392 100644
--- a/source/gameengine/Ketsji/KX_BlenderMaterial.cpp
+++ b/source/gameengine/Ketsji/KX_BlenderMaterial.cpp
@@ -193,14 +193,16 @@ void KX_BlenderMaterial::setShaderData( bool enable, RAS_IRasterizer *ras)
 	
 	BL_Texture::ActivateFirst();
 
+	mShader->ApplyShader();
+
 	// for each enabled unit
 	for(i=0; i<mMaterial->num_enabled; i++) {
-		const uSampler *samp = mShader->getSampler(i);
-		BL_Texture *tex = samp->gl_texture;
-		if( samp->loc == -1 || !tex || !tex->Ok() ) 
+		const BL_Sampler *samp = mShader->GetSampler(i);
+		BL_Texture *tex = samp->mTexture;
+		if( samp->mLoc == -1 || !tex || !tex->Ok() ) 
 			continue;
 		tex->ActivateTexture();
-		mShader->SetSampler(samp->loc, i);
+		mShader->SetSampler(samp->mLoc, i);
 	}
 	if(!mUserDefBlend) {
 		setDefaultBlending();
@@ -272,7 +274,7 @@ KX_BlenderMaterial::ActivatShaders(
 	TCachingInfo& cachingInfo)const
 {
 	KX_BlenderMaterial *tmp = const_cast<KX_BlenderMaterial*>(this);
-	
+
 	// reset... 
 	if(tmp->mMaterial->IsShared()) 
 		cachingInfo =0;
@@ -299,44 +301,17 @@ KX_BlenderMaterial::ActivatShaders(
 			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);
 	}
-	
-	// shaders have access to the variables set here
-	// via builtin GLSL variables
-	// eg: gl_FrontMaterial.diffuse
-	// --
-	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->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->SetAmbient(mMaterial->amb);
-
-	if (mMaterial->material)
-		rasty->SetPolygonOffset(-mMaterial->material->zoffs, 0.0);
-
-	tmp->applyTexGen(rasty);
 
+	ActivatGLMaterials(rasty);
+	ActivateTexGen(rasty);
 }
 
 void
@@ -367,37 +342,16 @@ KX_BlenderMaterial::ActivateMat(
 			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);
 	}
-		
-	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->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->SetAmbient(mMaterial->amb);
-	if (mMaterial->material)
-		rasty->SetPolygonOffset(-mMaterial->material->zoffs, 0.0);
-
-	tmp->applyTexGen(rasty);
+	ActivatGLMaterials(rasty);
+	ActivateTexGen(rasty);
 }
 
 
@@ -443,6 +397,57 @@ void KX_BlenderMaterial::ActivateMeshSlot(const KX_MeshSlot & ms, RAS_IRasterize
 		mShader->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
+	);
+
+	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->SetEmissive(	
+		mMaterial->matcolor[0]*mMaterial->emit,
+		mMaterial->matcolor[1]*mMaterial->emit,
+		mMaterial->matcolor[2]*mMaterial->emit,
+		1.0
+		);
+	rasty->SetAmbient(mMaterial->amb);
+	if (mMaterial->material)
+		rasty->SetPolygonOffset(-mMaterial->material->zoffs, 0.0);
+}
+
+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);
+
+	for(int i=0; i<mMaterial->num_enabled; i++) {
+		int mode = mMaterial->mapping[i].mapping;
+		
+		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);
+	}
+}
 
 bool KX_BlenderMaterial::setDefaultBlending()
 {
@@ -543,29 +548,6 @@ void KX_BlenderMaterial::setObjectMatrixData(int i, RAS_IRasterizer *ras)
 
 }
 
-void KX_BlenderMaterial::applyTexGen(RAS_IRasterizer *ras)
-{
-	if(mShader && RAS_EXT_support._ARB_shader_objects)
-		if(mShader->GetAttribute() == BL_Shader::SHD_TANGENT)
-			ras->SetAttrib(RAS_IRasterizer::RAS_TEXTANGENT);
-
-	for(int i=0; i<mMaterial->num_enabled; i++) {
-		int mode = mMaterial->mapping[i].mapping;
-		
-		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 
-			ras->SetTexCoords(RAS_IRasterizer::RAS_TEXCO_DISABLE, i);
-	}
-}
-
-
 // ------------------------------------
 void KX_BlenderMaterial::UpdateIPO(
 	MT_Vector4 rgba,
@@ -625,7 +607,6 @@ PyParentObject KX_BlenderMaterial::Parents[] = {
 
 PyObject* KX_BlenderMaterial::_getattr(const STR_String& attr)
 {
-	// nodda ?
 	_getattr_up(PyObjectPlus);
 }
 
@@ -672,9 +653,9 @@ KX_PYMETHODDEF_DOC( KX_BlenderMaterial, getShader , "getShader()")
 			mShader = new BL_Shader();
 			for(int i= 0; i<mMaterial->num_enabled; i++) {
 				if(mMaterial->mapping[i].mapping & USEENV )
-					mShader->InitializeSampler(SAMP_CUBE, i, 0, &mTextures[i]);
+					mShader->InitializeSampler(i, &mTextures[i]);
 				else
-					mShader->InitializeSampler(SAMP_2D, i, 0, &mTextures[i]);
+					mShader->InitializeSampler(i, &mTextures[i]);
 			}
 			mModified = true;
 		}
diff --git a/source/gameengine/Ketsji/KX_BlenderMaterial.h b/source/gameengine/Ketsji/KX_BlenderMaterial.h
index ad229509224..4dac7f294ec 100644
--- a/source/gameengine/Ketsji/KX_BlenderMaterial.h
+++ b/source/gameengine/Ketsji/KX_BlenderMaterial.h
@@ -93,6 +93,9 @@ private:
 	unsigned int	mBlendFunc[2];
 	bool			mModified;
 
+	void ActivatGLMaterials( RAS_IRasterizer* rasty )const;
+	void ActivateTexGen( RAS_IRasterizer *ras ) const;
+
 
 	// message centers
 	void	setTexData( bool enable,RAS_IRasterizer *ras);
@@ -104,7 +107,6 @@ private:
 
 	void	setLightData();
 
-	void	applyTexGen(RAS_IRasterizer *ras);
 	// cleanup stuff
 	void	OnExit();
 
diff --git a/source/gameengine/Ketsji/KX_MeshProxy.cpp b/source/gameengine/Ketsji/KX_MeshProxy.cpp
index f6505c2965f..ebca3e13d7f 100644
--- a/source/gameengine/Ketsji/KX_MeshProxy.cpp
+++ b/source/gameengine/Ketsji/KX_MeshProxy.cpp
@@ -84,6 +84,12 @@ KX_PYMETHODTABLE(KX_MeshProxy, reinstancePhysicsMesh),
   {NULL,NULL} //Sentinel
 };
 
+void KX_MeshProxy::SetMeshModified(bool v)
+{
+	m_meshobj->SetMeshModified(v);
+}
+
+
 PyObject*
 KX_MeshProxy::_getattr(const STR_String& attr)
 {
@@ -211,7 +217,7 @@ PyObject* KX_MeshProxy::PyGetVertex(PyObject* self,
 		RAS_TexVert* vertex = m_meshobj->GetVertex(matindex,vertexindex);
 		if (vertex)
 		{
-			vertexob = new KX_VertexProxy(vertex);
+			vertexob = new KX_VertexProxy(this, vertex);
 		}
 	}
 
diff --git a/source/gameengine/Ketsji/KX_MeshProxy.h b/source/gameengine/Ketsji/KX_MeshProxy.h
index 6aa832ea224..9a8aa2a6f33 100644
--- a/source/gameengine/Ketsji/KX_MeshProxy.h
+++ b/source/gameengine/Ketsji/KX_MeshProxy.h
@@ -43,6 +43,8 @@ public:
 	KX_MeshProxy(class RAS_MeshObject* mesh);
 	virtual ~KX_MeshProxy();
 
+	void SetMeshModified(bool v);
+
 	// stuff for cvalue related things
 	virtual CValue*		Calc(VALUE_OPERATOR op, CValue *val) ;
 	virtual CValue*		CalcFinal(VALUE_DATA_TYPE dtype, VALUE_OPERATOR op, CValue *val);
diff --git a/source/gameengine/Ketsji/KX_PythonInit.cpp b/source/gameengine/Ketsji/KX_PythonInit.cpp
index ceb5da67877..f86b984c789 100644
--- a/source/gameengine/Ketsji/KX_PythonInit.cpp
+++ b/source/gameengine/Ketsji/KX_PythonInit.cpp
@@ -773,6 +773,7 @@ PyObject* initGameLogic(KX_Scene* scene) // quick hack to get gravity hook
 	KX_MACRO_addTypesToDict(d, VIEWMATRIX_INVERSE, BL_Shader::VIEWMATRIX_INVERSE);
 	KX_MACRO_addTypesToDict(d, VIEWMATRIX_INVERSETRANSPOSE, BL_Shader::VIEWMATRIX_INVERSETRANSPOSE);
 	KX_MACRO_addTypesToDict(d, CAM_POS, BL_Shader::CAM_POS);
+	KX_MACRO_addTypesToDict(d, CONSTANT_TIMER, BL_Shader::CONSTANT_TIMER);
 
 	// Check for errors
 	if (PyErr_Occurred())
diff --git a/source/gameengine/Ketsji/KX_VertexProxy.cpp b/source/gameengine/Ketsji/KX_VertexProxy.cpp
index b06e9ee8529..cacf3987e63 100644
--- a/source/gameengine/Ketsji/KX_VertexProxy.cpp
+++ b/source/gameengine/Ketsji/KX_VertexProxy.cpp
@@ -140,6 +140,7 @@ int    KX_VertexProxy::_setattr(const STR_String& attr, PyObject *pyvalue)
 		if (PyVecTo(pyvalue, vec))
 		{
 			m_vertex->SetXYZ(vec);
+			m_mesh->SetMeshModified(true);
 			return 0;
 		}
 		return 1;
@@ -151,6 +152,7 @@ int    KX_VertexProxy::_setattr(const STR_String& attr, PyObject *pyvalue)
 		if (PyVecTo(pyvalue, vec))
 		{
 			m_vertex->SetUV(vec);
+			m_mesh->SetMeshModified(true);
 			return 0;
 		}
 		return 1;
@@ -162,6 +164,7 @@ int    KX_VertexProxy::_setattr(const STR_String& attr, PyObject *pyvalue)
 		if (PyVecTo(pyvalue, vec))
 		{
 			m_vertex->SetRGBA(vec);
+			m_mesh->SetMeshModified(true);
 			return 0;
 		}
 		return 1;
@@ -173,6 +176,7 @@ int    KX_VertexProxy::_setattr(const STR_String& attr, PyObject *pyvalue)
 		if (PyVecTo(pyvalue, vec))
 		{
 			m_vertex->SetNormal(vec);
+			m_mesh->SetMeshModified(true);
 			return 0;
 		}
 		return 1;
@@ -188,6 +192,7 @@ int    KX_VertexProxy::_setattr(const STR_String& attr, PyObject *pyvalue)
 	{
 		pos.x() = val;
 		m_vertex->SetXYZ(pos);
+		m_mesh->SetMeshModified(true);
 		return 0;
 	}
 	
@@ -195,6 +200,7 @@ int    KX_VertexProxy::_setattr(const STR_String& attr, PyObject *pyvalue)
 	{
 		pos.y() = val;
 		m_vertex->SetXYZ(pos);
+		m_mesh->SetMeshModified(true);
 		return 0;
 	}
 	
@@ -202,6 +208,7 @@ int    KX_VertexProxy::_setattr(const STR_String& attr, PyObject *pyvalue)
 	{
 		pos.z() = val;
 		m_vertex->SetXYZ(pos);
+		m_mesh->SetMeshModified(true);
 		return 0;
 	}
 	
@@ -211,6 +218,7 @@ int    KX_VertexProxy::_setattr(const STR_String& attr, PyObject *pyvalue)
 	{
 		uv[0] = val;
 		m_vertex->SetUV(uv);
+		m_mesh->SetMeshModified(true);
 		return 0;
 	}
 
@@ -218,6 +226,7 @@ int    KX_VertexProxy::_setattr(const STR_String& attr, PyObject *pyvalue)
 	{
 		uv[1] = val;
 		m_vertex->SetUV(uv);
+		m_mesh->SetMeshModified(true);
 		return 0;
 	}
 
@@ -227,6 +236,7 @@ int    KX_VertexProxy::_setattr(const STR_String& attr, PyObject *pyvalue)
 	{
 		uv[0] = val;
 		m_vertex->SetUV2(uv);
+		m_mesh->SetMeshModified(true);
 		return 0;
 	}
 
@@ -234,6 +244,7 @@ int    KX_VertexProxy::_setattr(const STR_String& attr, PyObject *pyvalue)
 	{
 		uv[1] = val;
 		m_vertex->SetUV2(uv);
+		m_mesh->SetMeshModified(true);
 		return 0;
 	}
 	
@@ -245,24 +256,28 @@ int    KX_VertexProxy::_setattr(const STR_String& attr, PyObject *pyvalue)
 	{
 		cp[0] = (unsigned char) val;
 		m_vertex->SetRGBA(icol);
+		m_mesh->SetMeshModified(true);
 		return 0;
 	}
 	if (attr == "g")
 	{
 		cp[1] = (unsigned char) val;
 		m_vertex->SetRGBA(icol);
+		m_mesh->SetMeshModified(true);
 		return 0;
 	}
 	if (attr == "b")
 	{
 		cp[2] = (unsigned char) val;
 		m_vertex->SetRGBA(icol);
+		m_mesh->SetMeshModified(true);
 		return 0;
 	}
 	if (attr == "a")
 	{
 		cp[3] = (unsigned char) val;
 		m_vertex->SetRGBA(icol);
+		m_mesh->SetMeshModified(true);
 		return 0;
 	}
   }
@@ -270,8 +285,9 @@ int    KX_VertexProxy::_setattr(const STR_String& attr, PyObject *pyvalue)
   return SCA_IObject::_setattr(attr, pyvalue);
 }
 
-KX_VertexProxy::KX_VertexProxy(RAS_TexVert* vertex)
-:m_vertex(vertex)
+KX_VertexProxy::KX_VertexProxy(KX_MeshProxy*mesh, RAS_TexVert* vertex)
+:	m_vertex(vertex),
+	m_mesh(mesh)
 {
 }
 
@@ -310,7 +326,7 @@ PyObject* KX_VertexProxy::PySetXYZ(PyObject*,
 	if (PyVecArgTo(args, vec))
 	{
 		m_vertex->SetXYZ(vec);
-	
+		m_mesh->SetMeshModified(true);
 		Py_Return;
 	}
 	
@@ -332,7 +348,7 @@ PyObject* KX_VertexProxy::PySetNormal(PyObject*,
 	if (PyVecArgTo(args, vec))
 	{
 		m_vertex->SetNormal(vec);
-		
+		m_mesh->SetMeshModified(true);
 		Py_Return;
 	}
 	
@@ -356,6 +372,7 @@ PyObject* KX_VertexProxy::PySetRGBA(PyObject*,
 	if (PyArg_ParseTuple(args, "(ffff)", &r, &g, &b, &a))
 	{
 		m_vertex->SetRGBA(MT_Vector4(r, g, b, a));
+		m_mesh->SetMeshModified(true);
 		Py_Return;
 	}
 	PyErr_Clear();
@@ -364,6 +381,7 @@ PyObject* KX_VertexProxy::PySetRGBA(PyObject*,
 	if (PyArg_ParseTuple(args,"i",&rgba))
 	{
 		m_vertex->SetRGBA(rgba);
+		m_mesh->SetMeshModified(true);
 		Py_Return;
 	}
 	
@@ -386,7 +404,7 @@ PyObject* KX_VertexProxy::PySetUV(PyObject*,
 	if (PyVecArgTo(args, vec))
 	{
 		m_vertex->SetUV(vec);
-		
+		m_mesh->SetMeshModified(true);
 		Py_Return;
 	}
 	
@@ -414,10 +432,9 @@ PyObject* KX_VertexProxy::PySetUV2(PyObject*,
 			m_vertex->SetFlag((m_vertex->getFlag()|TV_2NDUV));
 			m_vertex->SetUnit(unit);
 			m_vertex->SetUV2(vec);
+			m_mesh->SetMeshModified(true);
 			Py_Return;
 		}
 	}
 	return NULL;
 }
-
-
diff --git a/source/gameengine/Ketsji/KX_VertexProxy.h b/source/gameengine/Ketsji/KX_VertexProxy.h
index 49fa8ca88c9..acae9cf5a34 100644
--- a/source/gameengine/Ketsji/KX_VertexProxy.h
+++ b/source/gameengine/Ketsji/KX_VertexProxy.h
@@ -40,8 +40,9 @@ class KX_VertexProxy	: public SCA_IObject
 protected:
 
 	class RAS_TexVert*	m_vertex;
+	class KX_MeshProxy*	m_mesh;
 public:
-	KX_VertexProxy(class RAS_TexVert* vertex);
+	KX_VertexProxy(class KX_MeshProxy*mesh, class RAS_TexVert* vertex);
 	virtual ~KX_VertexProxy();
 
 	// stuff for cvalue related things