Improved OpenGL Shader Language support for game engine. The python interface is much simplified. Drawback is that scripts need to be updated next release. Testfiles:

http://www.continuousphysics.com/ftp/pub/test/index.php?dir=blender/&file=demos-2.42.zip

patch by Charlie Carley (snailrose @ elysiun.com)

1 files changed, 104 insertions, 386 deletions

diff --git a/source/gameengine/Ketsji/KX_BlenderMaterial.cpp b/source/gameengine/Ketsji/KX_BlenderMaterial.cpp
index b530edbd17c..d416ef55613 100644
--- a/source/gameengine/Ketsji/KX_BlenderMaterial.cpp
+++ b/source/gameengine/Ketsji/KX_BlenderMaterial.cpp
@@ -91,13 +91,11 @@ KX_BlenderMaterial::KX_BlenderMaterial(
 	m_flag |=(mMaterial->ras_mode & USE_LIGHT)!=0?RAS_MULTILIGHT:0;
 	
 	// figure max
-	#ifdef GL_ARB_multitexture
 	int enabled = mMaterial->num_enabled;
-	mMaterial->num_enabled = enabled>=bgl::max_texture_units?bgl::max_texture_units:enabled;
-	#else
-	mMaterial->num_enabled=0;
-	#endif
+	int max = BL_Texture::GetMaxUnits();
+	mMaterial->num_enabled = enabled>=max?max:enabled;
 
+	// base class
 	m_enabled = mMaterial->num_enabled;
 
 	// test the sum of the various modes for equality
@@ -114,7 +112,6 @@ KX_BlenderMaterial::KX_BlenderMaterial(
 
 }
 
-
 KX_BlenderMaterial::~KX_BlenderMaterial()
 {
 	// cleanup work
@@ -132,204 +129,100 @@ TFace* KX_BlenderMaterial::GetTFace(void) const
 void KX_BlenderMaterial::OnConstruction()
 {
 	// for each unique material...
-	#ifdef GL_ARB_multitexture
-/*	will be used to switch textures
-	if(!gTextureDict)
-		gTextureDict = PyDict_New();
-*/
 	int i;
 	for(i=0; i<mMaterial->num_enabled; i++) {
-	bgl::blActiveTextureARB(GL_TEXTURE0_ARB+i);
-		#ifdef GL_ARB_texture_cube_map
+		BL_Texture::ActivateUnit(i);
 		if( mMaterial->mapping[i].mapping & USEENV ) {
 			if(!RAS_EXT_support._ARB_texture_cube_map) {
 				spit("CubeMap textures not supported");
 				continue;
 			}
-			if(!mTextures[i].InitCubeMap( mMaterial->cubemap[i] ) )
+			if(!mTextures[i].InitCubeMap(i, mMaterial->cubemap[i] ) )
 				spit("unable to initialize image("<<i<<") in "<< 
 						mMaterial->matname<< ", image will not be available");
 		} 
 	
 		else {
-		#endif//GL_ARB_texture_cube_map
 			if( mMaterial->img[i] ) {
-				if( ! mTextures[i].InitFromImage(mMaterial->img[i], (mMaterial->flag[i] &MIPMAP)!=0 ))
+				if( ! mTextures[i].InitFromImage(i, mMaterial->img[i], (mMaterial->flag[i] &MIPMAP)!=0 ))
 					spit("unable to initialize image("<<i<<") in "<< 
 						 mMaterial->matname<< ", image will not be available");
 			}
-		#ifdef GL_ARB_texture_cube_map
 		}
-		#endif//GL_ARB_texture_cube_map
-		/*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 ) {
+	if( mShader ) {
 		 //note, the shader here is allocated, per unique material
 		 //and this function is called per face
-		bgl::blUseProgramObjectARB(0);
+		mShader->SetProg(0);
 		delete mShader;
 		mShader = 0;
 	}
-	#endif //GL_ARB_shader_objects
 
+	BL_Texture::ActivateFirst();
 	for(int i=0; i<mMaterial->num_enabled; i++) {
-		bgl::blActiveTextureARB(GL_TEXTURE0_ARB+i);
-
+		BL_Texture::ActivateUnit(i);
 		mTextures[i].DeleteTex();
-
-		glMatrixMode(GL_TEXTURE);
-		glLoadIdentity();
-		glMatrixMode(GL_MODELVIEW);
-
-		#ifdef GL_ARB_texture_cube_map
-		if(RAS_EXT_support._ARB_texture_cube_map)
-			glDisable(GL_TEXTURE_CUBE_MAP_ARB);
-		#endif//GL_ARB_texture_cube_map
-
-		glDisable(GL_TEXTURE_2D);
-		glDisable(GL_TEXTURE_GEN_S);
-		glDisable(GL_TEXTURE_GEN_T);
-		glDisable(GL_TEXTURE_GEN_R);
-		glTexEnvf(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_MODULATE );
+		mTextures[i].DisableUnit();
 	}
-	
-	/*if (gTextureDict) {
-		PyDict_Clear(gTextureDict);
-		Py_DECREF(gTextureDict);
-		gTextureDict = 0;
-	}*/
-
-	bgl::blActiveTextureARB(GL_TEXTURE0_ARB);
-
-	#ifdef GL_ARB_texture_cube_map
-	if(RAS_EXT_support._ARB_texture_cube_map)
-		glDisable(GL_TEXTURE_CUBE_MAP_ARB);
-	#endif//GL_ARB_texture_cube_map
-
-	glDisable(GL_TEXTURE_2D);
 
-	#endif//GL_ARB_multitexture
-
-	// make sure multi texture units 
-	// revert back to blender...
-	// --
 	if( mMaterial->tface ) 
 		set_tpage(mMaterial->tface);
 }
 
 
-void KX_BlenderMaterial::DisableTexData()
+void KX_BlenderMaterial::setShaderData( bool enable, RAS_IRasterizer *ras)
 {
-	glDisable(GL_BLEND);
-	#ifdef GL_ARB_multitexture
-	int i=(MAXTEX>=bgl::max_texture_units?bgl::max_texture_units:MAXTEX)-1;
-	for(; i>=0; i--) {
-		bgl::blActiveTextureARB(GL_TEXTURE0_ARB+i);
-		glMatrixMode(GL_TEXTURE);
-		glLoadIdentity();
-		glMatrixMode(GL_MODELVIEW);
-
-		#ifdef GL_ARB_texture_cube_map
-		if(RAS_EXT_support._ARB_texture_cube_map)
-			glDisable(GL_TEXTURE_CUBE_MAP_ARB);
-		#endif//GL_ARB_texture_cube_map
-
-		glDisable(GL_TEXTURE_2D);	
-		glDisable(GL_TEXTURE_GEN_S);
-		glDisable(GL_TEXTURE_GEN_T);
-		glDisable(GL_TEXTURE_GEN_R);
-		glTexEnvf(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_MODULATE );
-	}
-	#endif//GL_ARB_multitexture
-}
-
-
-void KX_BlenderMaterial::setShaderData( bool enable )
-{
-	#ifdef GL_ARB_multitexture 
-	#ifdef GL_ARB_shader_objects 
-
 	MT_assert(RAS_EXT_support._ARB_shader_objects && mShader);
 
 	int i;
 	if( !enable || !mShader->Ok() ) {
 		// frame cleanup.
-		bgl::blUseProgramObjectARB( 0 );
-		DisableTexData();
+		mShader->SetProg(false);
+		BL_Texture::DisableAllTextures();
 		return;
 	}
 
-	DisableTexData();
-	bgl::blUseProgramObjectARB( mShader->GetProg() );
+	BL_Texture::DisableAllTextures();
+	mShader->SetProg(true);
 	
+	BL_Texture::ActivateFirst();
+
 	// for each enabled unit
 	for(i=0; i<mMaterial->num_enabled; i++) {
-
 		const uSampler *samp = mShader->getSampler(i);
-		if( samp->loc == -1 || samp->glTexture == 0 ) continue;
-
-		bgl::blActiveTextureARB(GL_TEXTURE0_ARB+i);
-
-		#ifdef GL_ARB_texture_cube_map
-		if( mMaterial->mapping[i].mapping &USEENV ) {
-			glBindTexture( GL_TEXTURE_CUBE_MAP_ARB, samp->glTexture	/* mTextures[i]*/ );	
-			glEnable( GL_TEXTURE_CUBE_MAP_ARB );
-		} 
-		else {
-		#endif//GL_ARB_texture_cube_map
-			glBindTexture( GL_TEXTURE_2D, samp->glTexture	/*mTextures[i]*/ );	
-			glEnable( GL_TEXTURE_2D );
-		#ifdef GL_ARB_texture_cube_map
-		}
-		#endif//GL_ARB_texture_cube_map
-		// use a sampler
-		bgl::blUniform1iARB(samp->loc, i );
+		BL_Texture *tex = samp->gl_texture;
+		if( samp->loc == -1 || !tex || !tex->Ok() ) 
+			continue;
+		tex->ActivateTexture();
+		mShader->SetSampler(samp->loc, i);
 	}
-
 	if(!mUserDefBlend) {
 		setDefaultBlending();
 	}else
 	{
-		glEnable(GL_BLEND);
 		// tested to be valid enums
+		glEnable(GL_BLEND);
 		glBlendFunc(mBlendFunc[0], mBlendFunc[1]);
 	}
-
-	#endif//GL_ARB_shader_objects
-	#endif//GL_ARB_multitexture
 }
 
 
-void KX_BlenderMaterial::setTexData( bool enable )
+void KX_BlenderMaterial::setTexData( bool enable, RAS_IRasterizer *ras)
 {
-	#ifdef GL_ARB_multitexture
-	int i;
-
-	#ifdef GL_ARB_shader_objects
-	if(RAS_EXT_support._ARB_shader_objects) {
-		// switch back to fixed func
-		bgl::blUseProgramObjectARB( 0 );
-	}
-	#endif//GL_ARB_shader_objects
+	if(RAS_EXT_support._ARB_shader_objects && mShader) 
+		mShader->SetProg(false);
 
-	if( !enable ) {
-		 // frame cleanup.
-		DisableTexData();
+	BL_Texture::DisableAllTextures();
+	if( !enable )
 		return;
-	}
-	
-	DisableTexData();
+
+	BL_Texture::ActivateFirst();
 
 	if( mMaterial->IdMode == DEFAULT_BLENDER ) {
 		setDefaultBlending();
@@ -337,71 +230,40 @@ void KX_BlenderMaterial::setTexData( bool enable )
 	}
 
 	if( mMaterial->IdMode == TEXFACE ) {
-
 		// no material connected to the object
-		if( mTextures[0] ) {
-			if( !mTextures[0].Ok() ) return;
-			bgl::blActiveTextureARB(GL_TEXTURE0_ARB);
-			glBindTexture( GL_TEXTURE_2D, mTextures[0] );	
-			glEnable(GL_TEXTURE_2D);
-			setTextureEnvironment( -1 ); // modulate
-			setEnvMap( (mMaterial->mapping[0].mapping &USEREFL)!=0 );
+		if( mTextures[0].Ok() ) {
+			mTextures[0].ActivateTexture();
+			mTextures[0].setTexEnv(0, true);
+			mTextures[0].SetMapping(mMaterial->mapping[0].mapping);
 			setDefaultBlending(); 
 		}
 		return;
 	}
 
-	// for each enabled unit
+	int mode = 0,i=0;
 	for(i=0; (i<mMaterial->num_enabled); i++) {
 		if( !mTextures[i].Ok() ) continue;
 
-		bgl::blActiveTextureARB(GL_TEXTURE0_ARB+i);
-
-		#ifdef GL_ARB_texture_cube_map
-		// use environment maps
-		if( mMaterial->mapping[i].mapping &USEENV && RAS_EXT_support._ARB_texture_cube_map ) {
-			glBindTexture( GL_TEXTURE_CUBE_MAP_ARB, mTextures[i] );	
-			glEnable(GL_TEXTURE_CUBE_MAP_ARB);
-			setTextureEnvironment( i );
-
-			if( mMaterial->mapping[i].mapping &USEREFL )
-				setEnvMap( true, true );
-			else if(mMaterial->mapping[i].mapping &USEOBJ)
-				setObjectMatrixData(i);
-			else
-				setTexMatrixData( i );
-		} 
-		// 2d textures
-		else { 
-		#endif//GL_ARB_texture_cube_map
-			glBindTexture( GL_TEXTURE_2D, mTextures[i] );	
-			glEnable( GL_TEXTURE_2D );
-			setTextureEnvironment( i );
-			
-			if( mMaterial->mapping[i].mapping &USEREFL ){
-				setEnvMap( true );
-			}
-			else if(mMaterial->mapping[i].mapping &USEOBJ){
-				setObjectMatrixData(i);
-			}
-			else {
-				setTexMatrixData( i );
-			}
+		mTextures[i].ActivateTexture();
+		mTextures[i].setTexEnv(mMaterial);
+		mode = mMaterial->mapping[i].mapping;
 
-		#ifdef GL_ARB_texture_cube_map
-		}
-		#endif//GL_ARB_texture_cube_map
+		if(mode &USEOBJ)
+			setObjectMatrixData(i, ras);
+		else
+			mTextures[i].SetMapping(mode);
+		
+		if(!(mode &USEOBJ))
+			setTexMatrixData( i );
 	}
+
 	if(!mUserDefBlend) {
 		setDefaultBlending();
-	}else
-	{
+	}
+	else {
 		glEnable(GL_BLEND);
-		// tested to be valid enums
 		glBlendFunc(mBlendFunc[0], mBlendFunc[1]);
 	}
-
-	#endif//GL_ARB_multitexture
 }
 
 void
@@ -409,20 +271,25 @@ KX_BlenderMaterial::ActivatShaders(
 	RAS_IRasterizer* rasty, 
 	TCachingInfo& cachingInfo)const
 {
+	KX_BlenderMaterial *tmp = const_cast<KX_BlenderMaterial*>(this);
+	
+	// reset... 
+	if(tmp->mMaterial->IsShared()) 
+		cachingInfo =0;
+	
 	if (GetCachingInfo() != cachingInfo) {
-		KX_BlenderMaterial *tmp = const_cast<KX_BlenderMaterial*>(this);
 
 		if (!cachingInfo)
-			tmp->setShaderData( false );
+			tmp->setShaderData( false, rasty);
 		
 		cachingInfo = GetCachingInfo();
 	
 		if (rasty->GetDrawingMode() == RAS_IRasterizer::KX_TEXTURED ) {
-			tmp->setShaderData( true );
+			tmp->setShaderData( true, rasty);
 			rasty->EnableTextures(true);
 		}
 		else {
-			tmp->setShaderData( false );
+			tmp->setShaderData( false, rasty);
 			rasty->EnableTextures(false);
 		}
 
@@ -463,12 +330,13 @@ KX_BlenderMaterial::ActivatShaders(
 		1.0
 		);
 
-	// Lagan's patch...
-	// added material factor
 	rasty->SetAmbient(mMaterial->amb);
 
 	if (mMaterial->material)
 		rasty->SetPolygonOffset(-mMaterial->material->zoffs, 0.0);
+
+	tmp->applyTexGen(rasty);
+
 }
 
 void
@@ -477,20 +345,19 @@ KX_BlenderMaterial::ActivateMat(
 	TCachingInfo& cachingInfo
 	)const
 {
+	KX_BlenderMaterial *tmp = const_cast<KX_BlenderMaterial*>(this);
 	if (GetCachingInfo() != cachingInfo) {
-		KX_BlenderMaterial *tmp = const_cast<KX_BlenderMaterial*>(this);
-
 		if (!cachingInfo) 
-			tmp->setTexData( false );
+			tmp->setTexData( false,rasty );
 		
 		cachingInfo = GetCachingInfo();
 
 		if (rasty->GetDrawingMode() == RAS_IRasterizer::KX_TEXTURED) {
-			tmp->setTexData( true );
+			tmp->setTexData( true,rasty  );
 			rasty->EnableTextures(true);
 		}
 		else{
-			tmp->setTexData( false );
+			tmp->setTexData( false,rasty);
 			rasty->EnableTextures(false);
 		}
 
@@ -526,15 +393,14 @@ KX_BlenderMaterial::ActivateMat(
 		mMaterial->matcolor[2]*mMaterial->emit,
 		1.0
 		);
-	
-	// Lagan's patch...
-	// added material factor
 	rasty->SetAmbient(mMaterial->amb);
-
 	if (mMaterial->material)
 		rasty->SetPolygonOffset(-mMaterial->material->zoffs, 0.0);
+
+	tmp->applyTexGen(rasty);
 }
 
+
 bool 
 KX_BlenderMaterial::Activate( 
 	RAS_IRasterizer* rasty,  
@@ -542,24 +408,20 @@ KX_BlenderMaterial::Activate(
 	)const
 {
 	bool dopass = false;
-	#ifdef GL_ARB_shader_objects
-	if( RAS_EXT_support._ARB_shader_objects &&
-		( mShader && mShader->Ok() ) ) {
-
+	if( RAS_EXT_support._ARB_shader_objects && ( mShader && mShader->Ok() ) ) {
 		if( (mPass++) < mShader->getNumPass() ) {
 			ActivatShaders(rasty, cachingInfo);
 			dopass = true;
 			return dopass;
 		}
 		else {
-			bgl::blUseProgramObjectARB( 0 );
+			mShader->SetProg(false);
 			mPass = 0;
 			dopass = false;
 			return dopass;
 		}
 	}
 	else {
-	#endif//GL_ARB_shader_objects
 		switch (mPass++)
 		{
 			case 0:
@@ -571,143 +433,17 @@ KX_BlenderMaterial::Activate(
 				dopass = false;
 				break;
 		}
-	#ifdef GL_ARB_shader_objects
 	}
-	#endif//GL_ARB_shader_objects
 	return dopass;
 }
 
-void KX_BlenderMaterial::setTextureEnvironment( int textureIndex )
+void KX_BlenderMaterial::ActivateMeshSlot(const KX_MeshSlot & ms, RAS_IRasterizer* rasty) const
 {
-#ifndef GL_ARB_texture_env_combine
-	glTexEnvf(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_MODULATE );
-	return;
-#else
-	if(textureIndex == -1 || !RAS_EXT_support._ARB_texture_env_combine){
-		glTexEnvf(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_MODULATE );
-		return;
-	}
-
-	glTexEnvf(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_COMBINE_ARB );
-
-	GLfloat blend_operand		= GL_SRC_COLOR;
-	GLfloat blend_operand_prev  = GL_SRC_COLOR;
-
-	GLenum combiner = GL_COMBINE_RGB_ARB;
-	GLenum source0 = GL_SOURCE0_RGB_ARB;
-	GLenum source1 = GL_SOURCE1_RGB_ARB;
-	GLenum source2 = GL_SOURCE2_RGB_ARB;
-	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) ) {
-		combiner = GL_COMBINE_ALPHA_ARB;
-		source0	 = GL_SOURCE0_ALPHA_ARB;
-		source1 = GL_SOURCE1_ALPHA_ARB;
-		source2 = GL_SOURCE2_ALPHA_ARB;
-		op0 = GL_OPERAND0_ALPHA_ARB;
-		op1 = GL_OPERAND1_ALPHA_ARB;
-		op2 = GL_OPERAND2_ALPHA_ARB;
-		blend_operand = GL_SRC_ALPHA;
-		
-		// invert
-		if(mMaterial->flag[textureIndex] &TEXNEG) {
-			blend_operand_prev = GL_ONE_MINUS_SRC_ALPHA;
-			blend_operand = GL_ONE_MINUS_SRC_ALPHA;
-		}
-	}
-	else {
-		if(mMaterial->flag[textureIndex] &TEXNEG) {
-			blend_operand_prev=GL_ONE_MINUS_SRC_COLOR;
-			blend_operand = GL_ONE_MINUS_SRC_COLOR;
-		}
-	}
-	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:
-			{
-				// ------------------------------
-				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);
-				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: 
-			{
-				// ------------------------------
-				glTexEnvf(	GL_TEXTURE_ENV, combiner,	GL_MODULATE);
-				glTexEnvf(	GL_TEXTURE_ENV, source0,	GL_PREVIOUS_ARB);
-				glTexEnvf(	GL_TEXTURE_ENV, op0,		blend_operand_prev);
-				glTexEnvf(	GL_TEXTURE_ENV, source1,	GL_TEXTURE );
-				if(using_alpha)
-					glTexEnvf(	GL_TEXTURE_ENV, op1,		alphaOp);
-				else
-					glTexEnvf(	GL_TEXTURE_ENV, op1,		blend_operand);
-			}break;
-		case BLEND_ADD: 
-			{
-				// ------------------------------
-				glTexEnvf(	GL_TEXTURE_ENV, combiner,	GL_ADD_SIGNED_ARB);
-				glTexEnvf(	GL_TEXTURE_ENV, source0,	GL_PREVIOUS_ARB );
-				glTexEnvf(	GL_TEXTURE_ENV, op0,		blend_operand_prev );
-				glTexEnvf(	GL_TEXTURE_ENV, source1,	GL_TEXTURE );
-				if(using_alpha)
-					glTexEnvf(	GL_TEXTURE_ENV, op1,		alphaOp);
-				else
-					glTexEnvf(	GL_TEXTURE_ENV, op1,		blend_operand);
-			}break;
-		case BLEND_SUB: 
-			{
-				// ------------------------------
-				glTexEnvf(	GL_TEXTURE_ENV, combiner,	GL_SUBTRACT_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);
-			}break;
-		case BLEND_SCR: 
-			{
-				// ------------------------------
-				glTexEnvf(	GL_TEXTURE_ENV, combiner,	GL_ADD);
-				glTexEnvf(	GL_TEXTURE_ENV, source0,	GL_PREVIOUS_ARB );
-				glTexEnvf(	GL_TEXTURE_ENV, op0,		blend_operand_prev );
-				glTexEnvf(	GL_TEXTURE_ENV, source1,	GL_TEXTURE );
-				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
+	if(mShader && RAS_EXT_support._ARB_shader_objects)
+		mShader->Update(ms, rasty);
 }
 
+
 bool KX_BlenderMaterial::setDefaultBlending()
 {
 	if( mMaterial->transp &TF_ADD) {
@@ -726,40 +462,6 @@ bool KX_BlenderMaterial::setDefaultBlending()
 	return false;
 }
 
-void KX_BlenderMaterial::setEnvMap(bool val, bool cube)
-{
-	#ifdef GL_ARB_texture_cube_map
-	if( cube && RAS_EXT_support._ARB_texture_cube_map ) 
-	{
-		glTexGeni(GL_S, GL_TEXTURE_GEN_MODE, GL_REFLECTION_MAP_ARB );
-		glTexGeni(GL_T, GL_TEXTURE_GEN_MODE, GL_REFLECTION_MAP_ARB);
-		glTexGeni(GL_R, GL_TEXTURE_GEN_MODE, GL_REFLECTION_MAP_ARB);
-
-		glEnable(GL_TEXTURE_GEN_S);
-		glEnable(GL_TEXTURE_GEN_T);
-		glEnable(GL_TEXTURE_GEN_R);
-	}
-	else {
-	#endif//GL_ARB_texture_cube_map
-		if( val ) {
-			glTexGeni(GL_S, GL_TEXTURE_GEN_MODE, GL_SPHERE_MAP );
-			glTexGeni(GL_T, GL_TEXTURE_GEN_MODE, GL_SPHERE_MAP);
-			
-			glEnable(GL_TEXTURE_GEN_S);
-			glEnable(GL_TEXTURE_GEN_T);
-			glEnable(GL_TEXTURE_GEN_R);
-		}
-		else {
-			glDisable(GL_TEXTURE_GEN_S);
-			glDisable(GL_TEXTURE_GEN_T);
-			glDisable(GL_TEXTURE_GEN_R);
-		}
-	#ifdef GL_ARB_texture_cube_map
-	}
-	#endif//GL_ARB_texture_cube_map
-}
-
-
 void KX_BlenderMaterial::setTexMatrixData(int i)
 {
 	glMatrixMode(GL_TEXTURE);
@@ -791,17 +493,13 @@ static void GetProjPlane(BL_Material *mat, int index,int num, float*param)
 		param[2] = 1.f;
 }
 
-
-void KX_BlenderMaterial::setObjectMatrixData(int i)
+void KX_BlenderMaterial::setObjectMatrixData(int i, RAS_IRasterizer *ras)
 {
-	// will work without cubemaps
-	// but a cubemap will look the best
 	KX_GameObject *obj = 
 		(KX_GameObject*)
 		mScene->GetObjectList()->FindValue(mMaterial->mapping[i].objconame);
 
-	if(!obj)
-		return;
+	if(!obj) return;
 
 	glTexGeni(GL_S, GL_TEXTURE_GEN_MODE, GL_EYE_LINEAR );
 	glTexGeni(GL_T, GL_TEXTURE_GEN_MODE, GL_EYE_LINEAR );
@@ -824,9 +522,8 @@ void KX_BlenderMaterial::setObjectMatrixData(int i)
 	glEnable(GL_TEXTURE_GEN_T);
 	glEnable(GL_TEXTURE_GEN_R);
 
-	float matr[16];
-	glGetFloatv(GL_MODELVIEW_MATRIX, matr);
-	MT_Matrix4x4 mvmat(matr);
+	MT_Matrix4x4 mvmat;
+	ras->GetViewMatrix(mvmat);
 
 	glMatrixMode(GL_TEXTURE);
 	glLoadIdentity();
@@ -846,6 +543,28 @@ void KX_BlenderMaterial::setObjectMatrixData(int i)
 
 }
 
+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(
@@ -877,9 +596,6 @@ 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 ),
-
 	{NULL,NULL} //Sentinel
 };
 
@@ -956,14 +672,15 @@ 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(SAMP_CUBE, i, 0, &mTextures[i]);
 				else
-					mShader->InitializeSampler(SAMP_2D, i, 0, mTextures[i]);
+					mShader->InitializeSampler(SAMP_2D, i, 0, &mTextures[i]);
 			}
 			mModified = true;
 		}
 
 		if(mShader && !mShader->GetError()) {
+			mMaterial->SetSharedMaterial(true);
 			Py_INCREF(mShader);
 			return mShader;
 		}else
@@ -992,6 +709,7 @@ KX_PYMETHODDEF_DOC( KX_BlenderMaterial, getShader , "getShader()")
 #endif//GL_ARB_shader_objects
 }
 
+
 KX_PYMETHODDEF_DOC( KX_BlenderMaterial, getMaterialIndex, "getMaterialIndex()")
 {
 	return PyInt_FromLong( mMaterial->material_index );