Final merge of HEAD (bf-blender) into the orange branch.

Here are my notes on things to look out for as potential problem
spots:

source/blender/blenkernel/intern/displist.c:
+ is initfastshade(void) supposed to be empty? I had
to make it empty to get the merged tree to compile.

source/blender/python/api2_2x/Armature.c:
+ went with the version that had Armature_getLayers()

source/blender/python/api2_2x/Object.c
+ went with the version of Object_getPose() from bf-blender.
(#ifdef 0-ed the other version)

source/blender/python/api2_2x/Pose.[ch]
+ had problems linking due to no Pose_Init() ... copied these
two files straight from bf-blender.

source/blender/src/drawview.c:
+ view3d_panel_properties() had things shifted a few things shifted
a few pixels, otherwise, things were painless

source/blender/src/splash.jpg.c:
+ went with bf-blender version (orange is dead)

source/gameengine:
+ went with bf-blender version -- does not compile due to IMB_rect* stuff,
Ton should look into this.

11 files changed, 603 insertions, 386 deletions

diff --git a/source/gameengine/Ketsji/BL_Material.h b/source/gameengine/Ketsji/BL_Material.h
index 0b8856690d4..cf753414245 100644
--- a/source/gameengine/Ketsji/BL_Material.h
+++ b/source/gameengine/Ketsji/BL_Material.h
@@ -112,7 +112,8 @@ enum BL_flag
 	USEALPHA=4,		// use actual alpha channel
 	TEXALPHA=8,		// use alpha combiner functions
 	TEXNEG=16,		// negate blending
-	HASIPO=32
+	HASIPO=32,
+	USENEGALPHA=64
 };
 
 // BL_Material::ras_mode
diff --git a/source/gameengine/Ketsji/BL_Shader.cpp b/source/gameengine/Ketsji/BL_Shader.cpp
index 7e0b6df3a3a..4c41101b462 100644
--- a/source/gameengine/Ketsji/BL_Shader.cpp
+++ b/source/gameengine/Ketsji/BL_Shader.cpp
@@ -3,6 +3,7 @@
 #include <windows.h>
 #endif // WIN32
 #ifdef __APPLE__
+#define GL_GLEXT_LEGACY 1
 #include <OpenGL/gl.h>
 #include <OpenGL/glu.h>
 #else
@@ -31,7 +32,7 @@ const bool BL_Shader::Ok()const
 	return (mShader !=0 && mOk && mUse);
 }
 
-BL_Shader::BL_Shader(int n, PyTypeObject *T)
+BL_Shader::BL_Shader(PyTypeObject *T)
 :	PyObjectPlus(T),
 	mShader(0),
 	mVert(0),
@@ -40,19 +41,14 @@ BL_Shader::BL_Shader(int n, PyTypeObject *T)
 	mOk(0),
 	mUse(0),
 	vertProg(""),
-	fragProg("")
+	fragProg(""),
+	mError(0),
+	mLog(0)
+
 {
 	// if !RAS_EXT_support._ARB_shader_objects this class will not be used
 
-	mBlending.src	= -1;
-	mBlending.dest	= -1;
-	mBlending.const_color[0] = 0.0;
-	mBlending.const_color[1] = 0.0;
-	mBlending.const_color[2] = 0.0;
-	mBlending.const_color[3] = 1.0;
-
-	for (int i=0; i<MAXTEX; i++)
-	{
+	for (int i=0; i<MAXTEX; i++) {
 		mSampler[i].type = 0;
 		mSampler[i].pass = 0;
 		mSampler[i].unit = -1;
@@ -66,16 +62,20 @@ using namespace bgl;
 BL_Shader::~BL_Shader()
 {
 #ifdef GL_ARB_shader_objects
+	if(mLog) {
+		MEM_freeN(mLog);
+		mLog=0;
+	}
 	if( mShader ) {
-		glDeleteObjectARB(mShader);
+		bgl::blDeleteObjectARB(mShader);
 		mShader = 0;
 	}
 	if( mFrag ) {
-		glDeleteObjectARB(mFrag);
+		bgl::blDeleteObjectARB(mFrag);
 		mFrag = 0;
 	}
 	if( mVert ) {
-		glDeleteObjectARB(mVert);
+		bgl::blDeleteObjectARB(mVert);
 		mVert		= 0;
 	}
 
@@ -83,7 +83,7 @@ BL_Shader::~BL_Shader()
 	fragProg	= 0;
 	mOk			= 0;
 
-	glUseProgramObjectARB(0);
+	bgl::blUseProgramObjectARB(0);
 #endif//GL_ARB_shader_objects
 }
 
@@ -91,68 +91,74 @@ BL_Shader::~BL_Shader()
 bool BL_Shader::LinkProgram()
 {
 #ifdef GL_ARB_shader_objects
-	int numchars=0;
-	char* log=0;
+
 	int vertlen = 0, fraglen=0, proglen=0;
+	int vertstatus=0, fragstatus=0, progstatus=0;
+	unsigned int tmpVert=0, tmpFrag=0, tmpProg=0;
+	int char_len=0;
+
+	if(mError)
+		goto programError;
 
 	if(!vertProg || !fragProg){
 		spit("Invalid GLSL sources");
 		return false;
 	}
-	
-	// create our objects
-	unsigned int tmpVert = glCreateShaderObjectARB(GL_VERTEX_SHADER_ARB);
-	unsigned int tmpFrag = glCreateShaderObjectARB(GL_FRAGMENT_SHADER_ARB);
-	unsigned int tmpProg = glCreateProgramObjectARB();
-
-	if(!tmpVert || !tmpFrag || !tmpProg){
-		glDeleteObjectARB(tmpVert);
-		glDeleteObjectARB(tmpFrag);
-		glDeleteObjectARB(tmpProg);
+	if( !RAS_EXT_support._ARB_fragment_shader) {
+		spit("Fragment shaders not supported");
 		return false;
 	}
-	// set/compile vertex shader
-	glShaderSourceARB(tmpVert, 1, (const char**)&vertProg, 0);
-	glCompileShaderARB(tmpVert);
-	glGetObjectParameterivARB(tmpVert, GL_OBJECT_INFO_LOG_LENGTH_ARB, &vertlen);
-
-	if( vertlen > 0 && !PrintInfo(vertlen,tmpVert, "Vertex Shader") ){
-		spit("Vertex shader failed");
-		glDeleteObjectARB(tmpVert);
-		glDeleteObjectARB(tmpFrag);
-		glDeleteObjectARB(tmpProg);
-		mOk	= 0;
+	if( !RAS_EXT_support._ARB_vertex_shader) {
+		spit("Vertex shaders not supported");
 		return false;
 	}
-	// set/compile fragment shader
-	glShaderSourceARB(tmpFrag, 1,(const char**)&fragProg, 0);
-	glCompileShaderARB(tmpFrag);
-	glGetObjectParameterivARB(tmpFrag, GL_OBJECT_INFO_LOG_LENGTH_ARB, &fraglen);
-	if(fraglen >0 && !PrintInfo(fraglen,tmpFrag, "Fragment Shader") ){
-		spit("Fragment shader failed");
-		glDeleteObjectARB(tmpVert);
-		glDeleteObjectARB(tmpFrag);
-		glDeleteObjectARB(tmpProg);
-		mOk	= 0;
-		return false;
+	
+	// -- vertex shader ------------------
+	tmpVert = bgl::blCreateShaderObjectARB(GL_VERTEX_SHADER_ARB);
+	bgl::blShaderSourceARB(tmpVert, 1, (const char**)&vertProg, 0);
+	bgl::blCompileShaderARB(tmpVert);
+	bgl::blGetObjectParameterivARB(tmpVert, GL_OBJECT_INFO_LOG_LENGTH_ARB, &vertlen);
+	// print info if any
+	if( vertlen > 1){
+		PrintInfo(vertlen,tmpVert, &char_len);
+		goto programError;
 	}
-
-	// set compiled vert/frag shader & link
-	glAttachObjectARB(tmpProg, tmpVert);
-	glAttachObjectARB(tmpProg, tmpFrag);
-	glLinkProgramARB(tmpProg);
-
-	glGetObjectParameterivARB(tmpProg, GL_OBJECT_INFO_LOG_LENGTH_ARB, &proglen);
-	if(proglen > 0){
-		PrintInfo(proglen,tmpProg, "GLSL Shader");
+	// check for compile errors
+	bgl::blGetObjectParameterivARB(tmpVert, GL_OBJECT_COMPILE_STATUS_ARB, &vertstatus);
+	if(!vertstatus)
+		goto programError;
+
+	// -- fragment shader ----------------
+	tmpFrag = bgl::blCreateShaderObjectARB(GL_FRAGMENT_SHADER_ARB);
+	bgl::blShaderSourceARB(tmpFrag, 1,(const char**)&fragProg, 0);
+	bgl::blCompileShaderARB(tmpFrag);
+	bgl::blGetObjectParameterivARB(tmpFrag, GL_OBJECT_INFO_LOG_LENGTH_ARB, &fraglen);
+	if(fraglen >1 ){
+		PrintInfo(fraglen,tmpFrag, &char_len);
+		goto programError;
 	}
-	else{
-		spit("Program failed");
-		glDeleteObjectARB(tmpVert);
-		glDeleteObjectARB(tmpFrag);
-		glDeleteObjectARB(tmpProg);
-		mOk	= 0;
-		return false;
+	bgl::blGetObjectParameterivARB(tmpFrag, GL_OBJECT_COMPILE_STATUS_ARB, &fragstatus);
+	if(!fragstatus)
+		goto programError;
+
+	
+	// -- program ------------------------
+	//  set compiled vert/frag shader & link
+	tmpProg = bgl::blCreateProgramObjectARB();
+	bgl::blAttachObjectARB(tmpProg, tmpVert);
+	bgl::blAttachObjectARB(tmpProg, tmpFrag);
+	bgl::blLinkProgramARB(tmpProg);
+	bgl::blGetObjectParameterivARB(tmpProg, GL_OBJECT_INFO_LOG_LENGTH_ARB, &proglen);
+	bgl::blGetObjectParameterivARB(tmpProg, GL_OBJECT_LINK_STATUS_ARB, &progstatus);
+	if(!progstatus)
+		goto programError;
+
+	if(proglen > 0) {
+		// print success
+		PrintInfo(proglen,tmpProg, &char_len);
+		if(char_len >0)
+			spit(mLog);
+		mError = 0;
 	}
 
 	// set
@@ -161,34 +167,42 @@ bool BL_Shader::LinkProgram()
 	mFrag	= tmpFrag;
 	mOk		= 1;
 	return true;
+
+programError:
+	if(tmpVert) {
+		bgl::blDeleteObjectARB(tmpVert);
+		tmpVert=0;
+	}
+	if(tmpFrag) {
+		bgl::blDeleteObjectARB(tmpFrag);
+		tmpFrag=0;
+	}
+
+	if(tmpProg) {
+		bgl::blDeleteObjectARB(tmpProg);
+		tmpProg=0;
+	}
+
+	mOk	= 0;
+	mUse=0;
+	mError = 1;
+	spit("----------");
+	spit("GLSL Error ");
+	if(mLog)
+		spit(mLog);
+	spit("--------------------");
+	return false;
 #else
 	return false;
 #endif//GL_ARB_shader_objects
 }
 
-bool BL_Shader::PrintInfo(int len, unsigned int handle, const char *type)
+void BL_Shader::PrintInfo(int len, unsigned int handle, int* num)
 {
 #ifdef GL_ARB_shader_objects
-	int numchars=0;
-	char *log = (char*)MEM_mallocN(sizeof(char)*len, "print_log");
-	if(!log) {
-		spit("BL_Shader::PrintInfo() MEM_mallocN failed");
-		return false;
-	}
-	glGetInfoLogARB(handle, len, &numchars, log);
-	
-	if(numchars >0){
-		spit(type);
-		spit(log);
-		MEM_freeN(log);
-		log=0;
-		return false;
-	}
-	MEM_freeN(log);
-	log=0;
-	return true;
-#else
-	return false
+	mLog = (char*)MEM_mallocN(sizeof(char)*len, "print_log");
+	//MT_assert(mLog, "Failed to create memory");
+	bgl::blGetInfoLogARB(handle, len, num, mLog);
 #endif//GL_ARB_shader_objects
 }
 
@@ -234,13 +248,6 @@ const uSampler* BL_Shader::getSampler(int i)
 	return &mSampler[i];
 }
 
-const uBlending *BL_Shader::getBlending( int pass )
-{
-	return &mBlending;
-}
-
-
-
 void BL_Shader::InitializeSampler(
 	int type,
 	int unit,
@@ -287,7 +294,6 @@ PyMethodDef BL_Shader::Methods[] =
 	KX_PYMETHODTABLE( BL_Shader, setSampler  ),
 	KX_PYMETHODTABLE( BL_Shader, setUniformMatrix4 ),
 	KX_PYMETHODTABLE( BL_Shader, setUniformMatrix3 ),
-	// KX_PYMETHODTABLE( BL_Shader, setBlending ),
 
 	{NULL,NULL} //Sentinel
 };
@@ -332,15 +338,14 @@ KX_PYMETHODDEF_DOC( BL_Shader, setSource," setSource(vertexProgram, fragmentProg
 		vertProg = v;
 		fragProg = f;
 		if( LinkProgram() ) {
-			glUseProgramObjectARB( mShader );
+			bgl::blUseProgramObjectARB( mShader );
 			mUse = apply!=0;
 			Py_Return;
 		}
 		vertProg = 0;
 		fragProg = 0;
 		mUse = 0;
-		glUseProgramObjectARB( 0 );
-		PyErr_Format(PyExc_ValueError, "GLSL Error");
+		Py_Return;
 	}
 	return NULL;
 #else
@@ -352,9 +357,9 @@ KX_PYMETHODDEF_DOC( BL_Shader, setSource," setSource(vertexProgram, fragmentProg
 KX_PYMETHODDEF_DOC( BL_Shader, delSource, "delSource( )" )
 {
 #ifdef GL_ARB_shader_objects
-	glDeleteObjectARB(mShader);
-	glDeleteObjectARB(mFrag);
-	glDeleteObjectARB(mVert);
+	bgl::blDeleteObjectARB(mShader);
+	bgl::blDeleteObjectARB(mFrag);
+	bgl::blDeleteObjectARB(mVert);
 	mShader		= 0;
 	mFrag		= 0;
 	mVert		= 0;
@@ -362,13 +367,12 @@ KX_PYMETHODDEF_DOC( BL_Shader, delSource, "delSource( )" )
 	fragProg	= 0;
 	mOk			= 0;
 	mUse		= 0;
-	glUseProgramObjectARB(0);
+	bgl::blUseProgramObjectARB(0);
 #endif
 	Py_Return;
 
 }
 
-
 KX_PYMETHODDEF_DOC( BL_Shader, isValid, "isValid()" )
 {
 	return PyInt_FromLong( ( mShader !=0 &&  mOk ) );
@@ -384,21 +388,22 @@ KX_PYMETHODDEF_DOC( BL_Shader, getFragmentProg ,"getFragmentProg( )" )
 	return PyString_FromString(fragProg?fragProg:"");
 }
 
-
 KX_PYMETHODDEF_DOC( BL_Shader, validate, "validate()")
 {
 #ifdef GL_ARB_shader_objects
-	if(mShader==0)
-	{
+	if(mError) {
+		Py_INCREF(Py_None);
+		return Py_None;
+	}
+
+	if(mShader==0) {
 		PyErr_Format(PyExc_TypeError, "invalid shader object");
 		return NULL;
 	}
-
 	int stat = 0;
-	glValidateProgramARB(mShader);
-	glGetObjectParameterivARB(mShader, GL_OBJECT_VALIDATE_STATUS_ARB, &stat);
-
-	return PyInt_FromLong((stat!=0));
+	bgl::blValidateProgramARB(mShader);
+	bgl::blGetObjectParameterivARB(mShader, GL_OBJECT_VALIDATE_STATUS_ARB, &stat);
+	return PyInt_FromLong(0);
 #else
 	Py_Return;
 #endif//GL_ARB_shader_objects
@@ -408,6 +413,11 @@ 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;
+	}
+
 	char *uniform="";
 	int index=-1;
 	if(PyArg_ParseTuple(args, "si", &uniform, &index)) 
@@ -417,7 +427,7 @@ KX_PYMETHODDEF_DOC( BL_Shader, setSampler, "setSampler(name, index)" )
 			PyErr_Format(PyExc_ValueError, "invalid shader object");
 			return NULL;
 		}
-		int loc= glGetUniformLocationARB(mShader, uniform);
+		int loc= bgl::blGetUniformLocationARB(mShader, uniform);
 		if( loc==-1 )
 		{
 			spit("Invalid uniform value: " << uniform << ".");
@@ -446,7 +456,7 @@ KX_PYMETHODDEF_DOC( BL_Shader, setNumberOfPasses, "setNumberOfPasses( max-pass )
 	if(!PyArg_ParseTuple(args, "i", &pass))
 		return NULL;
 
-	mPass = pass;
+	mPass = 1;
 	Py_Return;
 }
 
@@ -454,6 +464,11 @@ KX_PYMETHODDEF_DOC( BL_Shader, setNumberOfPasses, "setNumberOfPasses( max-pass )
 KX_PYMETHODDEF_DOC( BL_Shader, setUniform1f, "setUniform1f(name, fx)" )
 {
 #ifdef GL_ARB_shader_objects
+	if(mError) {
+		Py_INCREF(Py_None);
+		return Py_None;
+	}
+
 	char *uniform="";
 	float value=0;
 	if(PyArg_ParseTuple(args, "sf", &uniform, &value ))
@@ -463,15 +478,15 @@ KX_PYMETHODDEF_DOC( BL_Shader, setUniform1f, "setUniform1f(name, fx)" )
 			PyErr_Format(PyExc_ValueError, "invalid shader object");
 			return NULL;
 		}
-		int loc= glGetUniformLocationARB(mShader, uniform);
+		int loc= bgl::blGetUniformLocationARB(mShader, uniform);
 		if( loc==-1 )
 		{
 			spit("Invalid uniform value: " << uniform << ".");
 			Py_Return;
 		}else
 		{
-			glUseProgramObjectARB( mShader );
-			glUniform1fARB( loc, value );
+			bgl::blUseProgramObjectARB( mShader );
+			bgl::blUniform1fARB( loc, value );
 			Py_Return;
 		}
 
@@ -486,6 +501,10 @@ KX_PYMETHODDEF_DOC( BL_Shader, setUniform1f, "setUniform1f(name, fx)" )
 KX_PYMETHODDEF_DOC( BL_Shader, setUniform2f , "setUniform2f(name, fx, fy)")
 {
 #ifdef GL_ARB_shader_objects
+	if(mError) {
+		Py_INCREF(Py_None);
+		return Py_None;
+	}
 	char *uniform="";
 	float array[2]={ 0,0 };
 	if(PyArg_ParseTuple(args, "sff", &uniform, &array[0],&array[1] ))
@@ -495,15 +514,15 @@ KX_PYMETHODDEF_DOC( BL_Shader, setUniform2f , "setUniform2f(name, fx, fy)")
 			PyErr_Format(PyExc_ValueError, "invalid shader object");
 			return NULL;
 		}
-		int loc= glGetUniformLocationARB(mShader , uniform);
+		int loc= bgl::blGetUniformLocationARB(mShader , uniform);
 		if( loc==-1 )
 		{
 			spit("Invalid uniform value: " << uniform << ".");
 			Py_Return;
 		}else
 		{
-			glUseProgramObjectARB( mShader );
-			glUniform2fARB(loc, array[0],array[1] );
+			bgl::blUseProgramObjectARB( mShader );
+			bgl::blUniform2fARB(loc, array[0],array[1] );
 			Py_Return;
 		}
 
@@ -518,6 +537,10 @@ KX_PYMETHODDEF_DOC( BL_Shader, setUniform2f , "setUniform2f(name, fx, fy)")
 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;
+	}
 	char *uniform="";
 	float array[3]={0,0,0};
 	if(PyArg_ParseTuple(args, "sfff", &uniform, &array[0],&array[1],&array[2]))
@@ -527,15 +550,15 @@ KX_PYMETHODDEF_DOC( BL_Shader, setUniform3f, "setUniform3f(name, fx,fy,fz) ")
 			PyErr_Format(PyExc_ValueError, "invalid shader object");
 			return NULL;
 		}
-		int loc= glGetUniformLocationARB(mShader , uniform);
+		int loc= bgl::blGetUniformLocationARB(mShader , uniform);
 		if( loc==-1 )
 		{
 			spit("Invalid uniform value: " << uniform << ".");
 			Py_Return;
 		}else
 		{
-			glUseProgramObjectARB(mShader);
-			glUniform3fARB(loc, array[0],array[1],array[2]);
+			bgl::blUseProgramObjectARB(mShader);
+			bgl::blUniform3fARB(loc, array[0],array[1],array[2]);
 			Py_Return;
 		}
 
@@ -550,6 +573,10 @@ KX_PYMETHODDEF_DOC( BL_Shader, setUniform3f, "setUniform3f(name, fx,fy,fz) ")
 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;
+	}
 	char *uniform="";
 	float array[4]={0,0,0,0};
 	if(PyArg_ParseTuple(args, "sffff", &uniform, &array[0],&array[1],&array[2], &array[3]))
@@ -559,15 +586,15 @@ KX_PYMETHODDEF_DOC( BL_Shader, setUniform4f, "setUniform4f(name, fx,fy,fz, fw) "
 			PyErr_Format(PyExc_ValueError, "invalid shader object");
 			return NULL;
 		}
-		int loc= glGetUniformLocationARB(mShader , uniform);
+		int loc= bgl::blGetUniformLocationARB(mShader , uniform);
 		if( loc==-1 )
 		{
 			spit("Invalid uniform value: " << uniform << ".");
 			Py_Return;
 		}else
 		{
-			glUseProgramObjectARB(mShader);
-			glUniform4fARB(loc, array[0],array[1],array[2], array[3]);
+			bgl::blUseProgramObjectARB(mShader);
+			bgl::blUniform4fARB(loc, array[0],array[1],array[2], array[3]);
 			Py_Return;
 		}
 	}
@@ -581,6 +608,10 @@ KX_PYMETHODDEF_DOC( BL_Shader, setUniform4f, "setUniform4f(name, fx,fy,fz, fw) "
 KX_PYMETHODDEF_DOC( BL_Shader, setUniform1i, "setUniform1i(name, ix)" )
 {
 #ifdef GL_ARB_shader_objects
+	if(mError) {
+		Py_INCREF(Py_None);
+		return Py_None;
+	}
 	char *uniform="";
 	int value=0;
 	if(PyArg_ParseTuple(args, "si", &uniform, &value ))
@@ -590,15 +621,15 @@ KX_PYMETHODDEF_DOC( BL_Shader, setUniform1i, "setUniform1i(name, ix)" )
 			PyErr_Format(PyExc_ValueError, "invalid shader object");
 			return NULL;
 		}
-		int loc= glGetUniformLocationARB(mShader, uniform);
+		int loc= bgl::blGetUniformLocationARB(mShader, uniform);
 		if( loc==-1 )
 		{
 			spit("Invalid uniform value: " << uniform << ".");
 			Py_Return;
 		}else
 		{
-			glUseProgramObjectARB( mShader );
-			glUniform1iARB( loc, value );
+			bgl::blUseProgramObjectARB( mShader );
+			bgl::blUniform1iARB( loc, value );
 			Py_Return;
 		}
 	}
@@ -612,6 +643,10 @@ KX_PYMETHODDEF_DOC( BL_Shader, setUniform1i, "setUniform1i(name, ix)" )
 KX_PYMETHODDEF_DOC( BL_Shader, setUniform2i , "setUniform2i(name, ix, iy)")
 {
 #ifdef GL_ARB_shader_objects
+	if(mError) {
+		Py_INCREF(Py_None);
+		return Py_None;
+	}
 	char *uniform="";
 	int array[2]={ 0,0 };
 	if(PyArg_ParseTuple(args, "sii", &uniform, &array[0],&array[1] ))
@@ -621,15 +656,15 @@ KX_PYMETHODDEF_DOC( BL_Shader, setUniform2i , "setUniform2i(name, ix, iy)")
 			PyErr_Format(PyExc_ValueError, "invalid shader object");
 			return NULL;
 		}
-		int loc= glGetUniformLocationARB(mShader , uniform);
+		int loc= bgl::blGetUniformLocationARB(mShader , uniform);
 		if( loc==-1 )
 		{
 			spit("Invalid uniform value: " << uniform << ".");
 			Py_Return;
 		}else
 		{
-			glUseProgramObjectARB( mShader );
-			glUniform2iARB(loc, array[0],array[1] );
+			bgl::blUseProgramObjectARB( mShader );
+			bgl::blUniform2iARB(loc, array[0],array[1] );
 			Py_Return;
 		}
 	}
@@ -643,6 +678,10 @@ KX_PYMETHODDEF_DOC( BL_Shader, setUniform2i , "setUniform2i(name, ix, iy)")
 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]))
@@ -652,15 +691,15 @@ KX_PYMETHODDEF_DOC( BL_Shader, setUniform3i, "setUniform3i(name, ix,iy,iz) ")
 			PyErr_Format(PyExc_ValueError, "invalid shader object");
 			return NULL;
 		}
-		int loc= glGetUniformLocationARB(mShader , uniform);
+		int loc= bgl::blGetUniformLocationARB(mShader , uniform);
 		if( loc==-1 )
 		{
 			spit("Invalid uniform value: " << uniform << ".");
 			Py_Return;
 		}else
 		{
-			glUseProgramObjectARB(mShader);
-			glUniform3iARB(loc, array[0],array[1],array[2]);
+			bgl::blUseProgramObjectARB(mShader);
+			bgl::blUniform3iARB(loc, array[0],array[1],array[2]);
 			Py_Return;
 		}
 	}
@@ -673,6 +712,10 @@ KX_PYMETHODDEF_DOC( BL_Shader, setUniform3i, "setUniform3i(name, ix,iy,iz) ")
 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;
+	}
 	char *uniform="";
 	int array[4]={0,0,0, 0};
 	if(PyArg_ParseTuple(args, "siiii", &uniform, &array[0],&array[1],&array[2], &array[3] ))
@@ -682,15 +725,15 @@ KX_PYMETHODDEF_DOC( BL_Shader, setUniform4i, "setUniform4i(name, ix,iy,iz, iw) "
 			PyErr_Format(PyExc_ValueError, "invalid shader object");
 			return NULL;
 		}
-		int loc= glGetUniformLocationARB(mShader , uniform);
+		int loc= bgl::blGetUniformLocationARB(mShader , uniform);
 		if( loc==-1 )
 		{
 			spit("Invalid uniform value: " << uniform << ".");
 			Py_Return;
 		}else
 		{
-			glUseProgramObjectARB(mShader);
-			glUniform4iARB(loc, array[0],array[1],array[2], array[3]);
+			bgl::blUseProgramObjectARB(mShader);
+			bgl::blUniform4iARB(loc, array[0],array[1],array[2], array[3]);
 			Py_Return;
 		}
 	}
@@ -703,6 +746,10 @@ KX_PYMETHODDEF_DOC( BL_Shader, setUniform4i, "setUniform4i(name, ix,iy,iz, iw) "
 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;
+	}
 	char*uniform = "";
 	PyObject *listPtr =0;
 	float array_data[4] = {0.f,0.f,0.f,0.f};
@@ -714,7 +761,7 @@ KX_PYMETHODDEF_DOC( BL_Shader, setUniformfv , "setUniformfv( float (list2 or lis
 			PyErr_Format(PyExc_ValueError, "invalid shader object");
 			return NULL;
 		}
-		int loc= glGetUniformLocationARB(mShader , uniform);
+		int loc= bgl::blGetUniformLocationARB(mShader , uniform);
 		if( loc==-1 )
 		{
 			spit("Invalid uniform value: " << uniform << ".");
@@ -735,20 +782,20 @@ KX_PYMETHODDEF_DOC( BL_Shader, setUniformfv , "setUniformfv( float (list2 or lis
 				{
 				case 2:
 					{
-						glUseProgramObjectARB(mShader);
-						glUniform2fARB(loc, array_data[0],array_data[1]);
+						bgl::blUseProgramObjectARB(mShader);
+						bgl::blUniform2fARB(loc, array_data[0],array_data[1]);
 						Py_Return;
 					} break;
 				case 3:
 					{
-						glUseProgramObjectARB(mShader);
-						glUniform3fARB(loc, array_data[0],array_data[1], array_data[2]);
+						bgl::blUseProgramObjectARB(mShader);
+						bgl::blUniform3fARB(loc, array_data[0],array_data[1], array_data[2]);
 						Py_Return;
 					}break;
 				case 4:
 					{
-						glUseProgramObjectARB(mShader);
-						glUniform4fARB(loc, array_data[0],array_data[1], array_data[2], array_data[3]);
+						bgl::blUseProgramObjectARB(mShader);
+						bgl::blUniform4fARB(loc, array_data[0],array_data[1], array_data[2], array_data[3]);
 						Py_Return;
 					}break;
 				default:
@@ -770,6 +817,10 @@ KX_PYMETHODDEF_DOC( BL_Shader, setUniformfv , "setUniformfv( float (list2 or lis
 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;
+	}
 	char*uniform = "";
 	PyObject *listPtr =0;
 	int array_data[4] = {0,0,0,0};
@@ -781,7 +832,7 @@ KX_PYMETHODDEF_DOC( BL_Shader, setUniformiv, "setUniformiv( int (list2 or list3
 			PyErr_Format(PyExc_ValueError, "invalid shader object");
 			return NULL;
 		}
-		int loc= glGetUniformLocationARB(mShader , uniform);
+		int loc= bgl::blGetUniformLocationARB(mShader , uniform);
 		if( loc==-1 )
 		{
 			spit("Invalid uniform value: " << uniform << ".");
@@ -802,20 +853,20 @@ KX_PYMETHODDEF_DOC( BL_Shader, setUniformiv, "setUniformiv( int (list2 or list3
 				{
 				case 2:
 					{
-						glUseProgramObjectARB(mShader);
-						glUniform2iARB(loc, array_data[0],array_data[1]);
+						bgl::blUseProgramObjectARB(mShader);
+						bgl::blUniform2iARB(loc, array_data[0],array_data[1]);
 						Py_Return;
 					} break;
 				case 3:
 					{
-						glUseProgramObjectARB(mShader);
-						glUniform3iARB(loc, array_data[0],array_data[1], array_data[2]);
+						bgl::blUseProgramObjectARB(mShader);
+						bgl::blUniform3iARB(loc, array_data[0],array_data[1], array_data[2]);
 						Py_Return;
 					}break;
 				case 4:
 					{
-						glUseProgramObjectARB(mShader);
-						glUniform4iARB(loc, array_data[0],array_data[1], array_data[2], array_data[3]);
+						bgl::blUseProgramObjectARB(mShader);
+						bgl::blUniform4iARB(loc, array_data[0],array_data[1], array_data[2], array_data[3]);
 						Py_Return;
 					}break;
 				default:
@@ -838,6 +889,11 @@ 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;
+	}
+
 	float matr[16] = {
 		1,0,0,0,
 		0,1,0,0,
@@ -855,7 +911,7 @@ KX_PYMETHODDEF_DOC( BL_Shader, setUniformMatrix4,
 			PyErr_Format(PyExc_ValueError, "invalid shader object");
 			return NULL;
 		}
-		int loc= glGetUniformLocationARB(mShader , uniform);
+		int loc= bgl::blGetUniformLocationARB(mShader , uniform);
 		if( loc==-1 )
 		{
 			spit("Invalid uniform value: " << uniform << ".");
@@ -868,8 +924,8 @@ KX_PYMETHODDEF_DOC( BL_Shader, setUniformMatrix4,
 				if (PyMatTo(matrix, mat))
 				{
 					mat.getValue(matr);
-					glUseProgramObjectARB(mShader);
-					glUniformMatrix4fvARB(loc, 1, (transp!=0)?GL_TRUE:GL_FALSE, matr);
+					bgl::blUseProgramObjectARB(mShader);
+					bgl::blUniformMatrix4fvARB(loc, 1, (transp!=0)?GL_TRUE:GL_FALSE, matr);
 					Py_Return;
 				}
 			}
@@ -886,6 +942,11 @@ 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;
+	}
+
 	float matr[9] = {
 		1,0,0,
 		0,1,0,
@@ -902,7 +963,7 @@ KX_PYMETHODDEF_DOC( BL_Shader, setUniformMatrix3,
 			PyErr_Format(PyExc_ValueError, "invalid shader object");
 			return NULL;
 		}
-		int loc= glGetUniformLocationARB(mShader , uniform);
+		int loc= bgl::blGetUniformLocationARB(mShader , uniform);
 		if( loc==-1 )
 		{
 			spit("Invalid uniform value: " << uniform << ".");
@@ -915,8 +976,8 @@ KX_PYMETHODDEF_DOC( BL_Shader, setUniformMatrix3,
 				if (PyMatTo(matrix, mat))
 				{
 					mat.getValue(matr);
-					glUseProgramObjectARB(mShader);
-					glUniformMatrix3fvARB(loc, 1, (transp!=0)?GL_TRUE:GL_FALSE, matr);
+					bgl::blUseProgramObjectARB(mShader);
+					bgl::blUniformMatrix3fvARB(loc, 1, (transp!=0)?GL_TRUE:GL_FALSE, matr);
 					Py_Return;
 				}
 			}
@@ -927,16 +988,3 @@ KX_PYMETHODDEF_DOC( BL_Shader, setUniformMatrix3,
 	Py_Return;
 #endif//GL_ARB_shader_objects
 }
-
-
-KX_PYMETHODDEF_DOC( BL_Shader, setBlending, "setBlending(src, dest)" )
-{
-	int src, dest;
-	if(PyArg_ParseTuple(args, "ii", &src, &dest))
-	{
-		mBlending.src = src;
-		mBlending.dest = dest;
-		Py_Return;
-	}
-	return NULL;
-}
diff --git a/source/gameengine/Ketsji/BL_Shader.h b/source/gameengine/Ketsji/BL_Shader.h
index 2e08eeb0d70..25db6a0b9f4 100644
--- a/source/gameengine/Ketsji/BL_Shader.h
+++ b/source/gameengine/Ketsji/BL_Shader.h
@@ -18,17 +18,6 @@ typedef struct uSampler
 #define SAMP_2D		1
 #define SAMP_CUBE	2
 
-
-// -----------------------------------
-typedef struct uBlending
-{
-	unsigned int pass;
-	int src;	// GL_ blend func values
-	int dest;
-	float const_color[4];
-}uBlending;
-// -----------------------------------
-
 // ----------------
 class BL_Shader : public PyObjectPlus
 {
@@ -41,14 +30,15 @@ private:
 	bool			mOk;
 	bool			mUse;
 	uSampler		mSampler[MAXTEX];
-	uBlending		mBlending;
 	char*			vertProg;
 	char*			fragProg;
-	bool			LinkProgram();
-	bool			PrintInfo(int len, unsigned int handle, const char *type);
+	bool			mError;
+	char*			mLog;
 
+	bool			LinkProgram();
+	void			PrintInfo( int len, unsigned int handle,int *num);
 public:
-	BL_Shader(int n, PyTypeObject *T=&Type);
+	BL_Shader(PyTypeObject *T=&Type);
 	virtual ~BL_Shader();
 
 	char*		GetVertPtr();
@@ -59,11 +49,10 @@ public:
 	// ---
 	int getNumPass()	{return mPass;}
 	bool use()			{return mUse;}
-
+	bool GetError()		{return mError;}
 	// ---
 	// access
 	const uSampler*		getSampler(int i);
-	const uBlending*	getBlending( int pass );
 	const bool			Ok()const;
 
 	unsigned int		GetProg();
@@ -108,8 +97,6 @@ public:
 	// these come from within the material buttons
 	// sampler2d/samplerCube work
 	KX_PYMETHOD_DOC( BL_Shader, setSampler);
-	// user blending funcs
-	KX_PYMETHOD_DOC( BL_Shader, setBlending );
 };
 
 
diff --git a/source/gameengine/Ketsji/BL_Texture.cpp b/source/gameengine/Ketsji/BL_Texture.cpp
index 0ed7a9c33cf..2b01d3df560 100644
--- a/source/gameengine/Ketsji/BL_Texture.cpp
+++ b/source/gameengine/Ketsji/BL_Texture.cpp
@@ -3,6 +3,7 @@
 #include <windows.h>
 #endif // WIN32
 #ifdef __APPLE__
+#define GL_GLEXT_LEGACY 1
 #include <OpenGL/gl.h>
 #include <OpenGL/glu.h>
 #else
@@ -20,7 +21,6 @@
 #include "DNA_image_types.h"
 #include "IMB_imbuf_types.h"
 #include "BKE_image.h"
-//#include "IMB_imbuf.h"
 #include "BLI_blenlib.h"
 
 #include "RAS_GLExtensionManager.h"
@@ -35,6 +35,7 @@ using namespace bgl;
 extern "C" {
 	// envmaps
 	#include "IMB_imbuf.h"
+	
 	void my_envmap_split_ima(EnvMap *env);
 	void my_free_envmapdata(EnvMap *env);
 }
@@ -345,18 +346,18 @@ void my_envmap_split_ima(EnvMap *env)
 			ima->ok= 1;
 			env->cube[part]= ima;
 		}
-		IMB_rectcpy(env->cube[0]->ibuf, env->ima->ibuf, 
-			0, 0, 0, 0, dx, dx);
-		IMB_rectcpy(env->cube[1]->ibuf, env->ima->ibuf, 
-			0, 0, dx, 0, dx, dx);
-		IMB_rectcpy(env->cube[2]->ibuf, env->ima->ibuf, 
-			0, 0, 2*dx, 0, dx, dx);
-		IMB_rectcpy(env->cube[3]->ibuf, env->ima->ibuf, 
-			0, 0, 0, dx, dx, dx);
-		IMB_rectcpy(env->cube[4]->ibuf, env->ima->ibuf, 
-			0, 0, dx, dx, dx, dx);
-		IMB_rectcpy(env->cube[5]->ibuf, env->ima->ibuf, 
-			0, 0, 2*dx, dx, dx, dx);
+		IMB_rectop(env->cube[0]->ibuf, env->ima->ibuf, 
+			0, 0, 0, 0, dx, dx, IMB_rectcpy, 0);
+		IMB_rectop(env->cube[1]->ibuf, env->ima->ibuf, 
+			0, 0, dx, 0, dx, dx, IMB_rectcpy, 0);
+		IMB_rectop(env->cube[2]->ibuf, env->ima->ibuf, 
+			0, 0, 2*dx, 0, dx, dx, IMB_rectcpy, 0);
+		IMB_rectop(env->cube[3]->ibuf, env->ima->ibuf, 
+			0, 0, 0, dx, dx, dx, IMB_rectcpy, 0);
+		IMB_rectop(env->cube[4]->ibuf, env->ima->ibuf, 
+			0, 0, dx, dx, dx, dx, IMB_rectcpy, 0);
+		IMB_rectop(env->cube[5]->ibuf, env->ima->ibuf, 
+			0, 0, 2*dx, dx, dx, dx, IMB_rectcpy, 0);
 		env->ok= 2;
 	}
 }
diff --git a/source/gameengine/Ketsji/KX_BlenderMaterial.cpp b/source/gameengine/Ketsji/KX_BlenderMaterial.cpp
index ebf040d3c5d..429a9ea7a65 100644
--- a/source/gameengine/Ketsji/KX_BlenderMaterial.cpp
+++ b/source/gameengine/Ketsji/KX_BlenderMaterial.cpp
@@ -10,6 +10,7 @@
 #include <windows.h>
 #endif // WIN32
 #ifdef __APPLE__
+#define GL_GLEXT_LEGACY 1
 #include <OpenGL/gl.h>
 #include <OpenGL/glu.h>
 #else
@@ -22,6 +23,7 @@
 #include "KX_Scene.h"
 #include "KX_Light.h"
 #include "KX_GameObject.h"
+#include "KX_MeshProxy.h"
 
 #include "MT_Vector3.h"
 #include "MT_Vector4.h"
@@ -75,7 +77,10 @@ KX_BlenderMaterial::KX_BlenderMaterial(
 	mMaterial(data),
 	mShader(0),
 	mScene(scene),
+	mUserDefBlend(0),
+	mModified(0),
 	mPass(0)
+
 {
 	///RAS_EXT_support._ARB_multitexture == true if were here
 
@@ -101,8 +106,8 @@ KX_BlenderMaterial::KX_BlenderMaterial(
 	// prevent material bleeding
 	for(int i=0; i<mMaterial->num_enabled; i++) {
 		m_multimode	+=
-			(mMaterial->flag[i]	+
-			 mMaterial->blend_mode[i]
+			( mMaterial->flag[i]	+
+			  mMaterial->blend_mode[i]
 			 );
 	}
 	m_multimode += mMaterial->IdMode+mMaterial->ras_mode;
@@ -132,14 +137,9 @@ void KX_BlenderMaterial::OnConstruction()
 	if(!gTextureDict)
 		gTextureDict = PyDict_New();
 */
-	#ifdef GL_ARB_shader_objects
-	if( RAS_EXT_support._ARB_shader_objects )
-		mShader = new BL_Shader( mMaterial->num_enabled );
-	#endif
-
 	int i;
 	for(i=0; i<mMaterial->num_enabled; i++) {
-	glActiveTextureARB(GL_TEXTURE0_ARB+i);
+	bgl::blActiveTextureARB(GL_TEXTURE0_ARB+i);
 		#ifdef GL_ARB_texture_cube_map
 		if( mMaterial->mapping[i].mapping & USEENV ) {
 			if(!RAS_EXT_support._ARB_texture_cube_map) {
@@ -149,9 +149,6 @@ void KX_BlenderMaterial::OnConstruction()
 			if(!mTextures[i].InitCubeMap( mMaterial->cubemap[i] ) )
 				spit("unable to initialize image("<<i<<") in "<< 
 						mMaterial->matname<< ", image will not be available");
-
-			if( RAS_EXT_support._ARB_shader_objects )
-				mShader->InitializeSampler(SAMP_CUBE, i, 0, mTextures[i]);
 		} 
 	
 		else {
@@ -160,9 +157,6 @@ void KX_BlenderMaterial::OnConstruction()
 				if( ! mTextures[i].InitFromImage(mMaterial->img[i], (mMaterial->flag[i] &MIPMAP)!=0 ))
 					spit("unable to initialize image("<<i<<") in "<< 
 						 mMaterial->matname<< ", image will not be available");
-			
-				if( RAS_EXT_support._ARB_shader_objects )
-					mShader->InitializeSampler(SAMP_2D, i, 0, mTextures[i]);
 			}
 		#ifdef GL_ARB_texture_cube_map
 		}
@@ -170,24 +164,27 @@ void KX_BlenderMaterial::OnConstruction()
 		/*PyDict_SetItemString(gTextureDict, mTextures[i].GetName().Ptr(), PyInt_FromLong(mTextures[i]));*/
 	}
 	#endif//GL_ARB_multitexture
+
+	mBlendFunc[0] =0;
+	mBlendFunc[1] =0;
 }
 
 void KX_BlenderMaterial::OnExit()
 {
 	#ifdef GL_ARB_multitexture
-
+	
 	#ifdef GL_ARB_shader_objects
 	if( RAS_EXT_support._ARB_shader_objects && mShader ) {
 		 //note, the shader here is allocated, per unique material
 		 //and this function is called per face
-		glUseProgramObjectARB(0);
+		bgl::blUseProgramObjectARB(0);
 		delete mShader;
 		mShader = 0;
 	}
 	#endif //GL_ARB_shader_objects
 
 	for(int i=0; i<mMaterial->num_enabled; i++) {
-		glActiveTextureARB(GL_TEXTURE0_ARB+i);
+		bgl::blActiveTextureARB(GL_TEXTURE0_ARB+i);
 
 		mTextures[i].DeleteTex();
 
@@ -213,7 +210,7 @@ void KX_BlenderMaterial::OnExit()
 		gTextureDict = 0;
 	}*/
 
-	glActiveTextureARB(GL_TEXTURE0_ARB);
+	bgl::blActiveTextureARB(GL_TEXTURE0_ARB);
 
 	#ifdef GL_ARB_texture_cube_map
 	if(RAS_EXT_support._ARB_texture_cube_map)
@@ -238,7 +235,7 @@ void KX_BlenderMaterial::DisableTexData()
 	#ifdef GL_ARB_multitexture
 	int i=(MAXTEX>=bgl::max_texture_units?bgl::max_texture_units:MAXTEX)-1;
 	for(; i>=0; i--) {
-		glActiveTextureARB(GL_TEXTURE0_ARB+i);
+		bgl::blActiveTextureARB(GL_TEXTURE0_ARB+i);
 		glMatrixMode(GL_TEXTURE);
 		glLoadIdentity();
 		glMatrixMode(GL_MODELVIEW);
@@ -268,13 +265,13 @@ void KX_BlenderMaterial::setShaderData( bool enable )
 	int i;
 	if( !enable || !mShader->Ok() ) {
 		// frame cleanup.
-		glUseProgramObjectARB( 0 );
+		bgl::blUseProgramObjectARB( 0 );
 		DisableTexData();
 		return;
 	}
 
 	DisableTexData();
-	glUseProgramObjectARB( mShader->GetProg() );
+	bgl::blUseProgramObjectARB( mShader->GetProg() );
 	
 	// for each enabled unit
 	for(i=0; i<mMaterial->num_enabled; i++) {
@@ -282,7 +279,7 @@ void KX_BlenderMaterial::setShaderData( bool enable )
 		const uSampler *samp = mShader->getSampler(i);
 		if( samp->loc == -1 || samp->glTexture == 0 ) continue;
 
-		glActiveTextureARB(GL_TEXTURE0_ARB+i);
+		bgl::blActiveTextureARB(GL_TEXTURE0_ARB+i);
 
 		#ifdef GL_ARB_texture_cube_map
 		if( mMaterial->mapping[i].mapping &USEENV ) {
@@ -297,9 +294,17 @@ void KX_BlenderMaterial::setShaderData( bool enable )
 		}
 		#endif//GL_ARB_texture_cube_map
 		// use a sampler
-		glUniform1iARB(samp->loc, i );
+		bgl::blUniform1iARB(samp->loc, i );
+	}
+
+	if(!mUserDefBlend) {
+		setDefaultBlending();
+	}else
+	{
+		glEnable(GL_BLEND);
+		// tested to be valid enums
+		glBlendFunc(mBlendFunc[0], mBlendFunc[1]);
 	}
-	glDisable(GL_BLEND);
 
 	#endif//GL_ARB_shader_objects
 	#endif//GL_ARB_multitexture
@@ -314,7 +319,7 @@ void KX_BlenderMaterial::setTexData( bool enable )
 	#ifdef GL_ARB_shader_objects
 	if(RAS_EXT_support._ARB_shader_objects) {
 		// switch back to fixed func
-		glUseProgramObjectARB( 0 );
+		bgl::blUseProgramObjectARB( 0 );
 	}
 	#endif//GL_ARB_shader_objects
 
@@ -336,7 +341,7 @@ void KX_BlenderMaterial::setTexData( bool enable )
 		// no material connected to the object
 		if( mTextures[0] ) {
 			if( !mTextures[0].Ok() ) return;
-			glActiveTextureARB(GL_TEXTURE0_ARB);
+			bgl::blActiveTextureARB(GL_TEXTURE0_ARB);
 			glBindTexture( GL_TEXTURE_2D, mTextures[0] );	
 			glEnable(GL_TEXTURE_2D);
 			setTextureEnvironment( -1 ); // modulate
@@ -352,7 +357,7 @@ void KX_BlenderMaterial::setTexData( bool enable )
 	for(i=0; (i<mMaterial->num_enabled); i++) {
 		if( !mTextures[i].Ok() ) continue;
 
-		glActiveTextureARB(GL_TEXTURE0_ARB+i);
+		bgl::blActiveTextureARB(GL_TEXTURE0_ARB+i);
 
 		#ifdef GL_ARB_texture_cube_map
 		// use environment maps
@@ -388,15 +393,16 @@ void KX_BlenderMaterial::setTexData( bool enable )
 		#ifdef GL_ARB_texture_cube_map
 		}
 		#endif//GL_ARB_texture_cube_map
-
-		// if either unit has set blending
-		// and its the last pass
-		lastblend += setBlending( i ); // dry run
-		if(lastblend >0 && i==mMaterial->num_enabled-1)
-			setBlending( i, true );
-		else if(lastblend == 0 && i==mMaterial->num_enabled-1)
-			glDisable(GL_BLEND);
 	}
+	if(!mUserDefBlend) {
+		setDefaultBlending();
+	}else
+	{
+		glEnable(GL_BLEND);
+		// tested to be valid enums
+		glBlendFunc(mBlendFunc[0], mBlendFunc[1]);
+	}
+
 	#endif//GL_ARB_multitexture
 }
 
@@ -548,7 +554,7 @@ KX_BlenderMaterial::Activate(
 			return dopass;
 		}
 		else {
-			glUseProgramObjectARB( 0 );
+			bgl::blUseProgramObjectARB( 0 );
 			mPass = 0;
 			dopass = false;
 			return dopass;
@@ -587,9 +593,8 @@ void KX_BlenderMaterial::setTextureEnvironment( int textureIndex )
 	glTexEnvf(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_COMBINE_ARB );
 
 	GLfloat blend_operand		= GL_SRC_COLOR;
-	GLfloat blend_operand_prev	= GL_SRC_COLOR;
+	GLfloat blend_operand_prev  = GL_SRC_COLOR;
 
-	// all sources here are RGB by default
 	GLenum combiner = GL_COMBINE_RGB_ARB;
 	GLenum source0 = GL_SOURCE0_RGB_ARB;
 	GLenum source1 = GL_SOURCE1_RGB_ARB;
@@ -597,6 +602,7 @@ void KX_BlenderMaterial::setTextureEnvironment( int textureIndex )
 	GLenum op0 = GL_OPERAND0_RGB_ARB;
 	GLenum op1 = GL_OPERAND1_RGB_ARB;
 	GLenum op2 = GL_OPERAND2_RGB_ARB;
+	GLfloat alphaOp = GL_SRC_ALPHA;
 
 	// switch to alpha combiners
 	if( (mMaterial->flag[textureIndex] &TEXALPHA) ) {
@@ -608,7 +614,6 @@ void KX_BlenderMaterial::setTextureEnvironment( int textureIndex )
 		op1 = GL_OPERAND1_ALPHA_ARB;
 		op2 = GL_OPERAND2_ALPHA_ARB;
 		blend_operand = GL_SRC_ALPHA;
-		blend_operand_prev = GL_SRC_ALPHA;
 		
 		// invert
 		if(mMaterial->flag[textureIndex] &TEXNEG) {
@@ -618,27 +623,42 @@ void KX_BlenderMaterial::setTextureEnvironment( int textureIndex )
 	}
 	else {
 		if(mMaterial->flag[textureIndex] &TEXNEG) {
-			blend_operand_prev = GL_ONE_MINUS_SRC_COLOR;
+			blend_operand_prev=GL_ONE_MINUS_SRC_COLOR;
 			blend_operand = GL_ONE_MINUS_SRC_COLOR;
 		}
 	}
-	// on Texture0 GL_PREVIOUS_ARB is the primary color
-	// on Texture1 GL_PREVIOUS_ARB is Texture0 env
+	bool using_alpha = false;
+
+	if(mMaterial->flag[textureIndex] &USEALPHA){
+		alphaOp = GL_ONE_MINUS_SRC_ALPHA;
+		using_alpha=true;
+	}
+	else if(mMaterial->flag[textureIndex] &USENEGALPHA){
+		alphaOp = GL_SRC_ALPHA;
+		using_alpha = true;
+	}
+
 	switch( mMaterial->blend_mode[textureIndex] ) {
 		case BLEND_MIX:
 			{
 				// ------------------------------
-				GLfloat base_col[4];
-				base_col[0]	 = base_col[1]  = base_col[2]  = 0.f;
-				base_col[3]	 = 1.f-mMaterial->color_blend[textureIndex];
-				glTexEnvfv( GL_TEXTURE_ENV, GL_TEXTURE_ENV_COLOR,base_col );
+				if(!using_alpha) {
+					GLfloat base_col[4];
+					base_col[0]	 = base_col[1]  = base_col[2]  = 0.f;
+					base_col[3]	 = 1.f-mMaterial->color_blend[textureIndex];
+					glTexEnvfv( GL_TEXTURE_ENV, GL_TEXTURE_ENV_COLOR,base_col );
+				}
 				glTexEnvf(	GL_TEXTURE_ENV, combiner,	GL_INTERPOLATE_ARB);
 				glTexEnvf(	GL_TEXTURE_ENV, source0,	GL_PREVIOUS_ARB);
 				glTexEnvf(	GL_TEXTURE_ENV, op0,		blend_operand_prev );
 				glTexEnvf(	GL_TEXTURE_ENV, source1,	GL_TEXTURE );
 				glTexEnvf(	GL_TEXTURE_ENV, op1,		blend_operand);
-				glTexEnvf(	GL_TEXTURE_ENV, source2,	GL_CONSTANT_ARB );
-				glTexEnvf(	GL_TEXTURE_ENV, op2,		GL_SRC_ALPHA);
+				if(!using_alpha)
+					glTexEnvf(	GL_TEXTURE_ENV, source2,	GL_CONSTANT_ARB );
+				else
+					glTexEnvf(	GL_TEXTURE_ENV, source2,	GL_TEXTURE );
+
+				glTexEnvf(	GL_TEXTURE_ENV, op2,		alphaOp);
 			}break;
 		case BLEND_MUL: 
 			{
@@ -647,7 +667,10 @@ void KX_BlenderMaterial::setTextureEnvironment( int textureIndex )
 				glTexEnvf(	GL_TEXTURE_ENV, source0,	GL_PREVIOUS_ARB);
 				glTexEnvf(	GL_TEXTURE_ENV, op0,		blend_operand_prev);
 				glTexEnvf(	GL_TEXTURE_ENV, source1,	GL_TEXTURE );
-				glTexEnvf(	GL_TEXTURE_ENV, op1,		blend_operand);
+				if(using_alpha)
+					glTexEnvf(	GL_TEXTURE_ENV, op1,		alphaOp);
+				else
+					glTexEnvf(	GL_TEXTURE_ENV, op1,		blend_operand);
 			}break;
 		case BLEND_ADD: 
 			{
@@ -656,7 +679,10 @@ void KX_BlenderMaterial::setTextureEnvironment( int textureIndex )
 				glTexEnvf(	GL_TEXTURE_ENV, source0,	GL_PREVIOUS_ARB );
 				glTexEnvf(	GL_TEXTURE_ENV, op0,		blend_operand_prev );
 				glTexEnvf(	GL_TEXTURE_ENV, source1,	GL_TEXTURE );
-				glTexEnvf(	GL_TEXTURE_ENV, op1,		blend_operand );
+				if(using_alpha)
+					glTexEnvf(	GL_TEXTURE_ENV, op1,		alphaOp);
+				else
+					glTexEnvf(	GL_TEXTURE_ENV, op1,		blend_operand);
 			}break;
 		case BLEND_SUB: 
 			{
@@ -674,37 +700,16 @@ void KX_BlenderMaterial::setTextureEnvironment( int textureIndex )
 				glTexEnvf(	GL_TEXTURE_ENV, source0,	GL_PREVIOUS_ARB );
 				glTexEnvf(	GL_TEXTURE_ENV, op0,		blend_operand_prev );
 				glTexEnvf(	GL_TEXTURE_ENV, source1,	GL_TEXTURE );
-				glTexEnvf(	GL_TEXTURE_ENV, op1,		blend_operand);
+				if(using_alpha)
+					glTexEnvf(	GL_TEXTURE_ENV, op1,		alphaOp);
+				else
+					glTexEnvf(	GL_TEXTURE_ENV, op1,		blend_operand);
 			} break;
 	}
+	glTexEnvf(	GL_TEXTURE_ENV, GL_RGB_SCALE_ARB,	1.0);
 #endif //!GL_ARB_texture_env_combine
 }
 
-bool KX_BlenderMaterial::setBlending( int ind, bool enable) 
-{
-	if(!enable) {
-		if(mMaterial->flag[ind] &CALCALPHA )	return true;
-		else if(mMaterial->flag[ind] &USEALPHA )	return true;
-		return false;
-	}
-	else {
-		// additive
-		if(mMaterial->flag[ind] &CALCALPHA ) {
-			glEnable(GL_BLEND);
-			glBlendFunc(GL_ONE, GL_ONE);
-			return true;
-		}
-
-		// use alpha channel
-		else if(mMaterial->flag[ind] &USEALPHA ) {
-			glEnable(GL_BLEND);
-			glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
-			return true;
-		}
-	}
-	return false;
-}
-
 bool KX_BlenderMaterial::setDefaultBlending()
 {
 	if( mMaterial->transp &TF_ADD) {
@@ -873,6 +878,7 @@ PyMethodDef KX_BlenderMaterial::Methods[] =
 {
 	KX_PYMETHODTABLE( KX_BlenderMaterial, getShader ),
 	KX_PYMETHODTABLE( KX_BlenderMaterial, getMaterialIndex ),
+	KX_PYMETHODTABLE( KX_BlenderMaterial, setBlending ),
 //	KX_PYMETHODTABLE( KX_BlenderMaterial, getTexture ),
 //	KX_PYMETHODTABLE( KX_BlenderMaterial, setTexture ),
 
@@ -914,20 +920,78 @@ int KX_BlenderMaterial::_setattr(const STR_String& attr, PyObject *pyvalue)
 	return PyObjectPlus::_setattr(attr, pyvalue);
 }
 
+
 KX_PYMETHODDEF_DOC( KX_BlenderMaterial, getShader , "getShader()")
 {
-	#ifdef GL_ARB_shader_objects
-	if(!RAS_EXT_support._ARB_shader_objects) {
-		PyErr_Format(PyExc_SystemError, "GLSL not supported");
-		return NULL;
+#ifdef GL_ARB_fragment_shader
+	if( !RAS_EXT_support._ARB_fragment_shader) {
+		if(!mModified)
+			spit("Fragment shaders not supported");
+	
+		mModified = true;
+		Py_Return;
+	}
+#endif
+
+#ifdef GL_ARB_vertex_shader
+	if( !RAS_EXT_support._ARB_vertex_shader) {
+		if(!mModified)
+			spit("Vertex shaders not supported");
+
+		mModified = true;
+		Py_Return;
+	}
+#endif
+
+#ifdef GL_ARB_shader_objects
+	if(!RAS_EXT_support._ARB_shader_objects)  {
+		if(!mModified)
+			spit("GLSL not supported");
+		mModified = true;
+		Py_Return;
 	}
 	else {
-		Py_INCREF(mShader);
-		return mShader;
+		// returns Py_None on error
+		// the calling script will need to check
+
+		if(!mShader && !mModified) {
+			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]);
+				else
+					mShader->InitializeSampler(SAMP_2D, i, 0, mTextures[i]);
+			}
+			mModified = true;
+		}
+
+		if(mShader && !mShader->GetError()) {
+			Py_INCREF(mShader);
+			return mShader;
+		}else
+		{
+			// decref all references to the object
+			// then delete it!
+			// We will then go back to fixed functionality
+			// for this material
+			if(mShader) {
+				if(mShader->ob_refcnt > 1) {
+					Py_DECREF(mShader);
+				}
+				else {
+					delete mShader;
+					mShader=0;
+				}
+			}
+		}
+		Py_Return;
 	}
-	#else
+	PyErr_Format(PyExc_ValueError, "GLSL Error");
+	return NULL;
+
+#else
 	Py_Return;
-	#endif//GL_ARB_shader_objects
+#endif//GL_ARB_shader_objects
 }
 
 KX_PYMETHODDEF_DOC( KX_BlenderMaterial, getMaterialIndex, "getMaterialIndex()")
@@ -947,3 +1011,45 @@ KX_PYMETHODDEF_DOC( KX_BlenderMaterial, setTexture , "setTexture( index, tex)")
 	return NULL;
 }
 
+static unsigned int GL_array[11] = {
+	GL_ZERO,
+	GL_ONE,
+	GL_SRC_COLOR,
+	GL_ONE_MINUS_SRC_COLOR,
+	GL_DST_COLOR,
+	GL_ONE_MINUS_DST_COLOR,
+	GL_SRC_ALPHA,
+	GL_ONE_MINUS_SRC_ALPHA,
+	GL_DST_ALPHA,
+	GL_ONE_MINUS_DST_ALPHA,
+	GL_SRC_ALPHA_SATURATE
+};
+
+KX_PYMETHODDEF_DOC( KX_BlenderMaterial, setBlending , "setBlending( GameLogic.src, GameLogic.dest)")
+{
+	unsigned int b[2];
+	if(PyArg_ParseTuple(args, "ii", &b[0], &b[1]))
+	{
+		bool value_found[2] = {false, false};
+		for(int i=0; i<11; i++)
+		{
+			if(b[0] == GL_array[i]) {
+				value_found[0] = true;
+				mBlendFunc[0] = b[0];
+			}
+			if(b[1] == GL_array[i]) {
+				value_found[1] = true;
+				mBlendFunc[1] = b[1];
+			}
+			if(value_found[0] && value_found[1]) break;
+		}
+		if(!value_found[0] || !value_found[1]) {
+			PyErr_Format(PyExc_ValueError, "invalid enum.");
+			return NULL;
+		}
+		mUserDefBlend = true;
+		Py_Return;
+	}
+	return NULL;
+}
+
diff --git a/source/gameengine/Ketsji/KX_BlenderMaterial.h b/source/gameengine/Ketsji/KX_BlenderMaterial.h
index 57348144890..a250dcf81c4 100644
--- a/source/gameengine/Ketsji/KX_BlenderMaterial.h
+++ b/source/gameengine/Ketsji/KX_BlenderMaterial.h
@@ -72,6 +72,7 @@ public:
 	KX_PYMETHOD_DOC( KX_BlenderMaterial, getTexture );
 	KX_PYMETHOD_DOC( KX_BlenderMaterial, setTexture );
 
+	KX_PYMETHOD_DOC( KX_BlenderMaterial, setBlending );
 	// --------------------------------
 	// pre calculate to avoid pops/lag at startup
 	virtual void OnConstruction( );
@@ -82,6 +83,10 @@ private:
 	KX_Scene*		mScene;
 	BL_Texture		mTextures[MAXTEX];		// texture array
 	
+	bool			mUserDefBlend;
+	unsigned int	mBlendFunc[2];
+	bool			mModified;
+
 	// message centers
 	void	setTexData( bool enable );
 	void	setShaderData( bool enable );
@@ -90,7 +95,6 @@ private:
 	void	setEnvMap( bool val, bool cube=false);
 	void	setTexMatrixData(int i);
 	bool	setDefaultBlending();
-	bool	setBlending( int ind, bool enable=false );
 	void	setObjectMatrixData(int i);
 
 	// cleanup stuff
diff --git a/source/gameengine/Ketsji/KX_KetsjiEngine.cpp b/source/gameengine/Ketsji/KX_KetsjiEngine.cpp
index 022c5d0c3ee..41bece58e84 100644
--- a/source/gameengine/Ketsji/KX_KetsjiEngine.cpp
+++ b/source/gameengine/Ketsji/KX_KetsjiEngine.cpp
@@ -127,8 +127,10 @@ KX_KetsjiEngine::KX_KetsjiEngine(KX_ISystem* system)
 	
 	m_firstframe(true),
 	
-	m_previoustime(0.0),
-	m_deltatime(0.0),
+	m_frameTime(0.f),
+	m_clockTime(0.f),
+	m_previousClockTime(0.f),
+
 
 	m_exitcode(KX_EXIT_REQUEST_NO_REQUEST),
 	m_exitstring(""),
@@ -258,13 +260,19 @@ void KX_KetsjiEngine::SetSceneConverter(KX_ISceneConverter* sceneconverter)
  */
 void KX_KetsjiEngine::StartEngine()
 {
-	m_previoustime = m_kxsystem->GetTimeInSeconds();
+	m_clockTime = m_kxsystem->GetTimeInSeconds();
+	m_frameTime = m_kxsystem->GetTimeInSeconds();
+	m_previousClockTime = m_kxsystem->GetTimeInSeconds();
+
 	m_firstframe = true;
 	m_bInitialized = true;
 	m_ticrate = DEFAULT_LOGIC_TIC_RATE;
 	m_currentFrame = 0;
 
-	m_sceneconverter->ResetPhysicsObjectsAnimationIpo();
+	if (m_game2ipo)
+	{
+		m_sceneconverter->ResetPhysicsObjectsAnimationIpo();
+	}
 
 }
 
@@ -317,33 +325,32 @@ void KX_KetsjiEngine::EndFrame()
 
 }
 
-
+#include "PIL_time.h"
 
 void KX_KetsjiEngine::NextFrame()
 {
 	m_logger->StartLog(tc_services, m_kxsystem->GetTimeInSeconds(), true);
-
-	double curtime;
+	
 	if (m_bFixedTime)
-		curtime = m_previoustime + 1.0/m_ticrate;
+		m_clockTime += 1.0/m_ticrate;
 	else
-		curtime = m_kxsystem->GetTimeInSeconds();
-	m_deltatime += curtime - m_previoustime;
-	float	realDeltaTime = curtime - m_previoustime;
-
+		m_clockTime = m_kxsystem->GetTimeInSeconds();
 	
-	double localtime = curtime - m_deltatime;
+	double deltatime = m_clockTime - m_frameTime;
 
 	// Compute the number of logic frames to do each update (fixed tic bricks)
-	int frames = (int) (m_deltatime*m_ticrate);
-	m_deltatime -= double(frames)/m_ticrate;
+	int frames =int(deltatime*m_ticrate);
+	
+//	if (!frames)
+//		PIL_sleep_ms(4);
 	
 	KX_SceneList::iterator sceneit;
 	
 	while (frames)
 	{
 
-		localtime += 1.0/m_ticrate;
+		m_frameTime += 1.0/m_ticrate;
+		
 		for (sceneit = m_scenes.begin();sceneit != m_scenes.end(); ++sceneit)
 		// for each scene, call the proceed functions
 		{
@@ -361,15 +368,15 @@ void KX_KetsjiEngine::NextFrame()
 				// if the scene was suspended recalcutlate the delta tu "curtime"
 				m_suspendedtime = scene->getSuspendedTime();
 				if (scene->getSuspendedTime()!=0.0)
-					scene->setSuspendedDelta(scene->getSuspendedDelta()+curtime-scene->getSuspendedTime());
+					scene->setSuspendedDelta(scene->getSuspendedDelta()+m_clockTime-scene->getSuspendedTime());
 				m_suspendeddelta = scene->getSuspendedDelta();
 
 				
 				m_logger->StartLog(tc_network, m_kxsystem->GetTimeInSeconds(), true);
-				scene->GetNetworkScene()->proceed(localtime);
+				scene->GetNetworkScene()->proceed(m_frameTime);
 	
 				m_logger->StartLog(tc_scenegraph, m_kxsystem->GetTimeInSeconds(), true);
-				scene->UpdateParents(localtime);
+				scene->UpdateParents(m_frameTime);
 				
 				m_logger->StartLog(tc_physics, m_kxsystem->GetTimeInSeconds(), true);
 				// set Python hooks for each scene
@@ -381,36 +388,39 @@ void KX_KetsjiEngine::NextFrame()
 				// Update scenegraph after physics step. This maps physics calculations
 				// into node positions.		
 				m_logger->StartLog(tc_scenegraph, m_kxsystem->GetTimeInSeconds(), true);
-				scene->UpdateParents(localtime);
+				scene->UpdateParents(m_frameTime);
 				
 				// Process sensors, and controllers
 				m_logger->StartLog(tc_logic, m_kxsystem->GetTimeInSeconds(), true);
-				scene->LogicBeginFrame(localtime);
+				scene->LogicBeginFrame(m_frameTime);
 	
 				// Scenegraph needs to be updated again, because Logic Controllers 
 				// can affect the local matrices.
 				m_logger->StartLog(tc_scenegraph, m_kxsystem->GetTimeInSeconds(), true);
-				scene->UpdateParents(localtime);
+				scene->UpdateParents(m_frameTime);
 	
 				// Process actuators
 	
 				// Do some cleanup work for this logic frame
 				m_logger->StartLog(tc_logic, m_kxsystem->GetTimeInSeconds(), true);
-				scene->LogicUpdateFrame(localtime, true);
+				scene->LogicUpdateFrame(m_frameTime, true);
 				scene->LogicEndFrame();
 	
 				// Actuators can affect the scenegraph
 				m_logger->StartLog(tc_scenegraph, m_kxsystem->GetTimeInSeconds(), true);
-				scene->UpdateParents(localtime);
+				scene->UpdateParents(m_frameTime);
 				
 				m_logger->StartLog(tc_physics, m_kxsystem->GetTimeInSeconds(), true);
 				scene->GetPhysicsEnvironment()->beginFrame();
 		
 				// Perform physics calculations on the scene. This can involve 
 				// many iterations of the physics solver.
-				scene->GetPhysicsEnvironment()->proceedDeltaTime(localtime,realDeltaTime);
-				m_previoustime = curtime;
+				scene->GetPhysicsEnvironment()->proceedDeltaTime(m_frameTime,1.0/m_ticrate);//m_deltatimerealDeltaTime);
 
+				m_logger->StartLog(tc_scenegraph, m_kxsystem->GetTimeInSeconds(), true);
+				scene->UpdateParents(m_frameTime);
+			
+			
 				if (m_game2ipo)
 				{
 					m_sceneconverter->WritePhysicsObjectToAnimationIpo(m_currentFrame++);
@@ -420,7 +430,7 @@ void KX_KetsjiEngine::NextFrame()
 			} // suspended
 			else
 				if(scene->getSuspendedTime()==0.0)
-					scene->setSuspendedTime(curtime);
+					scene->setSuspendedTime(m_clockTime);
 	
 			DoSound(scene);
 	
@@ -447,55 +457,63 @@ void KX_KetsjiEngine::NextFrame()
 		frames--;
 	}
 
-	// Logic update sub frame: this will let some logic bricks run at the
-	// full frame rate.
-	for (sceneit = m_scenes.begin();sceneit != m_scenes.end(); ++sceneit)
-	// for each scene, call the proceed functions
-	{
-		KX_Scene* scene = *sceneit;
+	bool bUseAsyncLogicBricks= false;
 
-		if (!scene->IsSuspended())
+	if (bUseAsyncLogicBricks)
+	{	
+		// Logic update sub frame: this will let some logic bricks run at the
+		// full frame rate.
+		for (sceneit = m_scenes.begin();sceneit != m_scenes.end(); ++sceneit)
+		// for each scene, call the proceed functions
 		{
-			// if the scene was suspended recalcutlate the delta tu "curtime"
-			m_suspendedtime = scene->getSuspendedTime();
-			if (scene->getSuspendedTime()!=0.0)
-				scene->setSuspendedDelta(scene->getSuspendedDelta()+curtime-scene->getSuspendedTime());
-			m_suspendeddelta = scene->getSuspendedDelta();
-			
-			// set Python hooks for each scene
-			PHY_SetActiveEnvironment(scene->GetPhysicsEnvironment());
-			PHY_SetActiveScene(scene);
-			
-			m_logger->StartLog(tc_scenegraph, m_kxsystem->GetTimeInSeconds(), true);
-			scene->UpdateParents(curtime);
-
-			// Perform physics calculations on the scene. This can involve 
-			// many iterations of the physics solver.
-			m_logger->StartLog(tc_physics, m_kxsystem->GetTimeInSeconds(), true);
-			scene->GetPhysicsEnvironment()->proceedDeltaTime(curtime,0.f);
-			// Update scenegraph after physics step. This maps physics calculations
-			// into node positions.		
-			m_logger->StartLog(tc_scenegraph, m_kxsystem->GetTimeInSeconds(), true);
-			scene->UpdateParents(curtime);
-			
-			// Do some cleanup work for this logic frame
-			m_logger->StartLog(tc_logic, m_kxsystem->GetTimeInSeconds(), true);
-			scene->LogicUpdateFrame(curtime, false);
+			KX_Scene* scene = *sceneit;
+
+			if (!scene->IsSuspended())
+			{
+				// if the scene was suspended recalcutlate the delta tu "curtime"
+				m_suspendedtime = scene->getSuspendedTime();
+				if (scene->getSuspendedTime()!=0.0)
+					scene->setSuspendedDelta(scene->getSuspendedDelta()+m_clockTime-scene->getSuspendedTime());
+				m_suspendeddelta = scene->getSuspendedDelta();
+				
+				// set Python hooks for each scene
+				PHY_SetActiveEnvironment(scene->GetPhysicsEnvironment());
+				PHY_SetActiveScene(scene);
+				
+				m_logger->StartLog(tc_scenegraph, m_kxsystem->GetTimeInSeconds(), true);
+				scene->UpdateParents(m_clockTime);
 
-			// Actuators can affect the scenegraph
-			m_logger->StartLog(tc_scenegraph, m_kxsystem->GetTimeInSeconds(), true);
-			scene->UpdateParents(curtime);
-			 
- 			scene->setSuspendedTime(0.0);
-		} // suspended
- 		else
- 			if(scene->getSuspendedTime()==0.0)
- 				scene->setSuspendedTime(curtime);
+				// Perform physics calculations on the scene. This can involve 
+				// many iterations of the physics solver.
+				m_logger->StartLog(tc_physics, m_kxsystem->GetTimeInSeconds(), true);
+				scene->GetPhysicsEnvironment()->proceedDeltaTime(m_clockTime,0.f);
+				// Update scenegraph after physics step. This maps physics calculations
+				// into node positions.		
+				m_logger->StartLog(tc_scenegraph, m_kxsystem->GetTimeInSeconds(), true);
+				scene->UpdateParents(m_clockTime);
+				
+				// Do some cleanup work for this logic frame
+				m_logger->StartLog(tc_logic, m_kxsystem->GetTimeInSeconds(), true);
+				scene->LogicUpdateFrame(m_clockTime, false);
 
-		DoSound(scene);
+				// Actuators can affect the scenegraph
+				m_logger->StartLog(tc_scenegraph, m_kxsystem->GetTimeInSeconds(), true);
+				scene->UpdateParents(m_clockTime);
+				 
+ 				scene->setSuspendedTime(0.0);
+			} // suspended
+ 			else
+ 				if(scene->getSuspendedTime()==0.0)
+ 					scene->setSuspendedTime(m_clockTime);
 
-		m_logger->StartLog(tc_services, m_kxsystem->GetTimeInSeconds(), true);
+			DoSound(scene);
+
+			m_logger->StartLog(tc_services, m_kxsystem->GetTimeInSeconds(), true);
+		}
 	}
+
+
+	m_previousClockTime = m_clockTime;
 	
 	// Start logging time spend outside main loop
 	m_logger->StartLog(tc_outside, m_kxsystem->GetTimeInSeconds(), true);
diff --git a/source/gameengine/Ketsji/KX_KetsjiEngine.h b/source/gameengine/Ketsji/KX_KetsjiEngine.h
index bea558e4427..c476cdb5894 100644
--- a/source/gameengine/Ketsji/KX_KetsjiEngine.h
+++ b/source/gameengine/Ketsji/KX_KetsjiEngine.h
@@ -99,8 +99,10 @@ private:
 	bool				m_firstframe;
 	int					m_currentFrame;
 
-	double				m_previoustime;
-	double				m_deltatime;
+	double				m_frameTime;//discrete timestamp of the 'game logic frame'
+	double				m_clockTime;//current time
+	double				m_previousClockTime;//previous clock time
+
 	static double			m_ticrate;
 
 	static double			m_suspendedtime;
diff --git a/source/gameengine/Ketsji/KX_PyConstraintBinding.cpp b/source/gameengine/Ketsji/KX_PyConstraintBinding.cpp
index 2317f9c3a9c..0e7ebc6442e 100644
--- a/source/gameengine/Ketsji/KX_PyConstraintBinding.cpp
+++ b/source/gameengine/Ketsji/KX_PyConstraintBinding.cpp
@@ -362,7 +362,7 @@ static PyObject* gPyRemoveConstraint(PyObject* self,
 	{
 		if (PHY_GetActiveEnvironment())
 		{
-			PHY_GetActiveEnvironment()->removeConstraint((void *)constraintid);
+			PHY_GetActiveEnvironment()->removeConstraint(constraintid);
 		}
 	}
 	Py_INCREF(Py_None); return Py_None;
diff --git a/source/gameengine/Ketsji/KX_PythonInit.cpp b/source/gameengine/Ketsji/KX_PythonInit.cpp
index e2a11c0035e..6f7b73ee4fa 100644
--- a/source/gameengine/Ketsji/KX_PythonInit.cpp
+++ b/source/gameengine/Ketsji/KX_PythonInit.cpp
@@ -39,6 +39,7 @@
 #include <windows.h>
 #endif // WIN32
 #ifdef __APPLE__
+#define GL_GLEXT_LEGACY 1
 #include <OpenGL/gl.h>
 #include <OpenGL/glu.h>
 #else
@@ -277,39 +278,74 @@ static PyObject *pyPrintExt(PyObject *,PyObject *,PyObject *)
 #define pprint(x) std::cout << x << std::endl;
 	bgl::BL_EXTInfo ext = bgl::RAS_EXT_support;
 	bool count=0;
+	bool support=0;
 	pprint("Supported Extensions...");
-	#ifdef GL_ARB_shader_objects
-	pprint(" GL_ARB_shader_objects supported?       "<< (ext._ARB_shader_objects?		"yes.":"no."));
+#ifdef GL_ARB_shader_objects
+	pprint(" GL_ARB_shader_objects supported?       "<< (ext._ARB_shader_objects?"yes.":"no."));
 	count = 1;
-	#endif
-	#ifdef GL_ARB_vertex_shader
-	pprint(" GL_ARB_vertex_shader supported?        "<< (ext._ARB_vertex_shader?		"yes.":"no."));
-	count = 1;
-	#endif
-	#ifdef GL_ARB_fragment_shader
-	pprint(" GL_ARB_fragment_shader supported?      "<< (ext._ARB_fragment_shader?		"yes.":"no."));
-	count = 1;
-	#endif
-	#ifdef GL_ARB_texture_cube_map
-	pprint(" GL_ARB_texture_cube_map supported?     "<< (ext._ARB_texture_cube_map?		"yes.":"no."));
+#endif
+
+#ifdef GL_ARB_vertex_shader
+	support= ext._ARB_vertex_shader;
+	pprint(" GL_ARB_vertex_shader supported?        "<< (support?"yes.":"no."));
 	count = 1;
-	#endif
-	#ifdef GL_EXT_texture3D
-	pprint(" GL_EXT_texture3D supported?            "<< (ext._EXT_texture3D?			"yes.":"no."));
+	if(support){
+		pprint(" ----------Details----------");
+		int max=0;
+		glGetIntegerv(GL_MAX_VERTEX_UNIFORM_COMPONENTS_ARB, (GLint*)&max);
+		pprint("  Max uniform components." << max);
+
+		glGetIntegerv(GL_MAX_VARYING_FLOATS_ARB, (GLint*)&max);
+		pprint("  Max varying floats." << max);
+
+		glGetIntegerv(GL_MAX_VERTEX_TEXTURE_IMAGE_UNITS_ARB, (GLint*)&max);
+		pprint("  Max vertex texture units." << max);
+	
+		glGetIntegerv(GL_MAX_COMBINED_TEXTURE_IMAGE_UNITS_ARB, (GLint*)&max);
+		pprint("  Max combined texture units." << max);
+		pprint("");
+	}
+#endif
+#ifdef GL_ARB_fragment_shader
+	support=ext._ARB_fragment_shader;
+	pprint(" GL_ARB_fragment_shader supported?      "<< (support?"yes.":"no."));
 	count = 1;
-	#endif
-	#ifdef GL_EXT_blend_color
-	pprint(" GL_EXT_blend_color supported?          "<< (ext._EXT_blend_color?			"yes.":"no."));
+	if(support){
+		pprint(" ----------Details----------");
+		int max=0;
+		glGetIntegerv(GL_MAX_FRAGMENT_UNIFORM_COMPONENTS_ARB, (GLint*)&max);
+		pprint("  Max uniform components." << max);
+		pprint("");
+	}
+#endif
+#ifdef GL_ARB_texture_cube_map
+	support = ext._ARB_texture_cube_map;
+	pprint(" GL_ARB_texture_cube_map supported?     "<< (support?"yes.":"no."));
 	count = 1;
-	#endif
-	#ifdef GL_ARB_multitexture
-	pprint(" GL_ARB_multitexture supported?         "<< (ext._ARB_multitexture?			"yes.":"no."));
+	if(support){
+		pprint(" ----------Details----------");
+		int size=0;
+		glGetIntegerv(GL_MAX_CUBE_MAP_TEXTURE_SIZE_ARB, (GLint*)&size);
+		pprint("  Max cubemap size." << size);
+		pprint("");
+	}
+#endif
+#ifdef GL_ARB_multitexture
+	support = ext._ARB_multitexture;
 	count = 1;
-	#endif
-	#ifdef GL_ARB_texture_env_combine
-	pprint(" GL_ARB_texture_env_combine supported?  "<< (ext._ARB_texture_env_combine?	"yes.":"no."));
+	pprint(" GL_ARB_multitexture supported?         "<< (support?"yes.":"no."));
+	if(support){
+		pprint(" ----------Details----------");
+		int units=0;
+		glGetIntegerv(GL_MAX_TEXTURE_UNITS_ARB, (GLint*)&units);
+		pprint("  Max texture units available.  " << units);
+		pprint("");
+	}
+#endif
+#ifdef GL_ARB_texture_env_combine
+	pprint(" GL_ARB_texture_env_combine supported?  "<< (ext._ARB_texture_env_combine?"yes.":"no."));
 	count = 1;
-	#endif
+#endif
 	if(!count)
 		pprint("No extenstions are used in this build");
 
@@ -707,6 +743,19 @@ PyObject* initGameLogic(KX_Scene* scene) // quick hack to get gravity hook
 	KX_MACRO_addTypesToDict(d, KX_ACTIONACT_LOOPEND,     BL_ActionActuator::KX_ACT_ACTION_LOOPEND);
 	KX_MACRO_addTypesToDict(d, KX_ACTIONACT_PROPERTY,     BL_ActionActuator::KX_ACT_ACTION_PROPERTY);
 	
+	/*8. GL_BlendFunc */
+	KX_MACRO_addTypesToDict(d, BL_ZERO, GL_ZERO);
+	KX_MACRO_addTypesToDict(d, BL_ONE, GL_ONE);
+	KX_MACRO_addTypesToDict(d, BL_SRC_COLOR, GL_SRC_COLOR);
+	KX_MACRO_addTypesToDict(d, BL_ONE_MINUS_SRC_COLOR, GL_ONE_MINUS_SRC_COLOR);
+	KX_MACRO_addTypesToDict(d, BL_DST_COLOR, GL_DST_COLOR);
+	KX_MACRO_addTypesToDict(d, BL_ONE_MINUS_DST_COLOR, GL_ONE_MINUS_DST_COLOR);
+	KX_MACRO_addTypesToDict(d, BL_SRC_ALPHA, GL_SRC_ALPHA);
+	KX_MACRO_addTypesToDict(d, BL_ONE_MINUS_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
+	KX_MACRO_addTypesToDict(d, BL_DST_ALPHA, GL_DST_ALPHA);
+	KX_MACRO_addTypesToDict(d, BL_ONE_MINUS_DST_ALPHA, GL_ONE_MINUS_DST_ALPHA);
+	KX_MACRO_addTypesToDict(d, BL_SRC_ALPHA_SATURATE, GL_SRC_ALPHA_SATURATE);
+
 	// Check for errors
 	if (PyErr_Occurred())
     {
diff --git a/source/gameengine/Ketsji/Makefile b/source/gameengine/Ketsji/Makefile
index 963031d9686..ee0b1e42f22 100644
--- a/source/gameengine/Ketsji/Makefile
+++ b/source/gameengine/Ketsji/Makefile
@@ -39,6 +39,7 @@ include nan_compile.mk
 CCFLAGS += $(LEVEL_1_CPP_WARNINGS)
 
 CPPFLAGS += $(OGL_CPPFLAGS)
+CPPFLAGS += -I$(OPENGL_HEADERS)
 CPPFLAGS += -I$(NAN_PYTHON)/include/python$(NAN_PYTHON_VERSION) -I../../blender/python
 CPPFLAGS += -I$(NAN_STRING)/include    
 CPPFLAGS += -I$(NAN_SOUNDSYSTEM)/include