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

GLEW
====

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

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

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

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

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

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

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

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

10 files changed, 183 insertions, 152 deletions

diff --git a/source/gameengine/Converter/BL_ArmatureObject.cpp b/source/gameengine/Converter/BL_ArmatureObject.cpp
index d4712efda9e..f73d5b42a01 100644
--- a/source/gameengine/Converter/BL_ArmatureObject.cpp
+++ b/source/gameengine/Converter/BL_ArmatureObject.cpp
@@ -144,7 +144,7 @@ void BL_ArmatureObject::GetPose(bPose **pose)
 {
 	/* If the caller supplies a null pose, create a new one. */
 	/* Otherwise, copy the armature's pose channels into the caller-supplied pose */
-
+		
 	if (!*pose) {
 		/*	probably not to good of an idea to
 			duplicate everying, but it clears up 
diff --git a/source/gameengine/Converter/BL_BlenderDataConversion.cpp b/source/gameengine/Converter/BL_BlenderDataConversion.cpp
index cb981f55c5a..0ad9258bcc0 100644
--- a/source/gameengine/Converter/BL_BlenderDataConversion.cpp
+++ b/source/gameengine/Converter/BL_BlenderDataConversion.cpp
@@ -510,6 +510,7 @@ BL_Material* ConvertMaterial(
 				}
 			}
 		}
+
 		// above one tex the switches here
 		// are not used
 		switch(valid_index) {
@@ -588,6 +589,9 @@ BL_Material* ConvertMaterial(
 	MT_Point2 uv[4];
 	MT_Point2 uv2[4];
 
+	uv[0]= uv[1]= uv[2]= uv[3]= MT_Point2(0.0f, 0.0f);
+	uv2[0]= uv2[1]= uv2[2]= uv2[3]= MT_Point2(0.0f, 0.0f);
+
 	if( validface ) {
 
 		material->ras_mode |= !( 
@@ -731,14 +735,14 @@ static MT_Vector4*  BL_ComputeMeshTangentSpace(Mesh* mesh)
 	MT_Vector3 *tan1 = new MT_Vector3[mesh->totvert];
 	MT_Vector3 *tan2 = new MT_Vector3[mesh->totvert];
 	
-	unsigned int v;
+	int v;
 	for (v = 0; v < mesh->totvert; v++)
 	{
 		tan1[v] = MT_Vector3(0.0, 0.0, 0.0);
 		tan2[v] = MT_Vector3(0.0, 0.0, 0.0);
 	}
 	
-	for (unsigned int p = 0; p < mesh->totface; p++, mface++, tface++)
+	for (int p = 0; p < mesh->totface; p++, mface++, tface++)
 	{
 		MT_Vector3 	v1(mesh->mvert[mface->v1].co),
 				v2(mesh->mvert[mface->v2].co),
@@ -830,9 +834,10 @@ RAS_MeshObject* BL_ConvertMesh(Mesh* mesh, Object* blenderobj, RAS_IRenderTools*
 		}
 	}
 
-
 	meshobj->SetName(mesh->id.name);
 	meshobj->m_xyz_index_to_vertex_index_mapping.resize(mesh->totvert);
+	if(skinMesh)
+		((BL_SkinMeshObject*)meshobj)->m_mvert_to_dvert_mapping.resize(mesh->totvert);
 	for (int f=0;f<mesh->totface;f++,mface++)
 	{
 		
@@ -882,7 +887,7 @@ RAS_MeshObject* BL_ConvertMesh(Mesh* mesh, Object* blenderobj, RAS_IRenderTools*
 				Material* ma = 0;
 				bool polyvisible = true;
 				RAS_IPolyMaterial* polymat = NULL;
-				BL_Material *bl_mat;
+				BL_Material *bl_mat = NULL;
 
 				if(converter->GetMaterials()) 
 				{	
@@ -892,6 +897,7 @@ RAS_MeshObject* BL_ConvertMesh(Mesh* mesh, Object* blenderobj, RAS_IRenderTools*
 						ma = give_current_material(blenderobj, 1);
 
 					bl_mat = ConvertMaterial(mesh, ma, tface, mface, mmcol, lightlayer, blenderobj, layers);
+					bl_mat->glslmat = converter->GetGLSLMaterials();
 					// set the index were dealing with
 					bl_mat->material_index =  (int)mface->mat_nr;
 
@@ -1066,19 +1072,19 @@ RAS_MeshObject* BL_ConvertMesh(Mesh* mesh, Object* blenderobj, RAS_IRenderTools*
 					d3=((BL_SkinMeshObject*)meshobj)->FindOrAddDeform(vtxarray, mface->v3, &mesh->dvert[mface->v3], polymat);
 					if (nverts==4)
 						d4=((BL_SkinMeshObject*)meshobj)->FindOrAddDeform(vtxarray, mface->v4, &mesh->dvert[mface->v4], polymat);
-					poly->SetVertex(0,((BL_SkinMeshObject*)meshobj)->FindOrAddVertex(vtxarray,pt0,uv0,uv20,tan0,rgb0,no0,d1,flat, polymat));
-					poly->SetVertex(1,((BL_SkinMeshObject*)meshobj)->FindOrAddVertex(vtxarray,pt1,uv1,uv21,tan1,rgb1,no1,d2,flat, polymat));
-					poly->SetVertex(2,((BL_SkinMeshObject*)meshobj)->FindOrAddVertex(vtxarray,pt2,uv2,uv22,tan2,rgb2,no2,d3,flat, polymat));
+					poly->SetVertex(0,((BL_SkinMeshObject*)meshobj)->FindOrAddVertex(vtxarray,pt0,uv0,uv20,tan0,rgb0,no0,d1,flat,polymat,mface->v1));
+					poly->SetVertex(1,((BL_SkinMeshObject*)meshobj)->FindOrAddVertex(vtxarray,pt1,uv1,uv21,tan1,rgb1,no1,d2,flat,polymat,mface->v2));
+					poly->SetVertex(2,((BL_SkinMeshObject*)meshobj)->FindOrAddVertex(vtxarray,pt2,uv2,uv22,tan2,rgb2,no2,d3,flat,polymat,mface->v3));
 					if (nverts==4)
-						poly->SetVertex(3,((BL_SkinMeshObject*)meshobj)->FindOrAddVertex(vtxarray,pt3,uv3,uv23,tan3,rgb3,no3,d4, flat,polymat));
+						poly->SetVertex(3,((BL_SkinMeshObject*)meshobj)->FindOrAddVertex(vtxarray,pt3,uv3,uv23,tan3,rgb3,no3,d4,flat,polymat,mface->v4));
 				}
 				else
 				{
-					poly->SetVertex(0,meshobj->FindOrAddVertex(vtxarray,pt0,uv0,uv20,tan0,rgb0,no0,polymat,mface->v1));
-					poly->SetVertex(1,meshobj->FindOrAddVertex(vtxarray,pt1,uv1,uv21,tan1,rgb1,no1,polymat,mface->v2));
-					poly->SetVertex(2,meshobj->FindOrAddVertex(vtxarray,pt2,uv2,uv22,tan2,rgb2,no2,polymat,mface->v3));
+					poly->SetVertex(0,meshobj->FindOrAddVertex(vtxarray,pt0,uv0,uv20,tan0,rgb0,no0,false,polymat,mface->v1));
+					poly->SetVertex(1,meshobj->FindOrAddVertex(vtxarray,pt1,uv1,uv21,tan1,rgb1,no1,false,polymat,mface->v2));
+					poly->SetVertex(2,meshobj->FindOrAddVertex(vtxarray,pt2,uv2,uv22,tan2,rgb2,no2,false,polymat,mface->v3));
 					if (nverts==4)
-						poly->SetVertex(3,meshobj->FindOrAddVertex(vtxarray,pt3,uv3,uv23,tan3,rgb3,no3,polymat,mface->v4));
+						poly->SetVertex(3,meshobj->FindOrAddVertex(vtxarray,pt3,uv3,uv23,tan3,rgb3,no3,false,polymat,mface->v4));
 				}
 				meshobj->AddPolygon(poly);
 				if (poly->IsCollider())
@@ -1116,6 +1122,9 @@ RAS_MeshObject* BL_ConvertMesh(Mesh* mesh, Object* blenderobj, RAS_IRenderTools*
 			layer.face++;
 		}
 	}
+	meshobj->m_xyz_index_to_vertex_index_mapping.clear();
+	if(skinMesh)
+		((BL_SkinMeshObject*)meshobj)->m_mvert_to_dvert_mapping.clear();
 	meshobj->UpdateMaterialList();
 
 	// pre calculate texture generation
diff --git a/source/gameengine/Converter/BL_MeshDeformer.cpp b/source/gameengine/Converter/BL_MeshDeformer.cpp
index ab31179b047..85ba894f9a5 100644
--- a/source/gameengine/Converter/BL_MeshDeformer.cpp
+++ b/source/gameengine/Converter/BL_MeshDeformer.cpp
@@ -43,27 +43,25 @@
 #include "BL_SkinMeshObject.h"
 #include "DNA_mesh_types.h"
 #include "DNA_meshdata_types.h"
-#include "BLI_arithb.h"
 
 #include "GEN_Map.h"
 #include "STR_HashedString.h"
 
-
 bool BL_MeshDeformer::Apply(RAS_IPolyMaterial *mat)
 {
 	size_t			i, j, index;
 	vecVertexArray	array;
 	vecIndexArrays	mvarray;
 	vecIndexArrays	diarray;
-	
+
 	RAS_TexVert *tv;
 	MVert	*mvert;
-	
+
 	// For each material
 	array = m_pMeshObject->GetVertexCache(mat);
 	mvarray = m_pMeshObject->GetMVertCache(mat);
 	diarray = m_pMeshObject->GetDIndexCache(mat);
-	
+
 	// For each array
 	for (i=0; i<array.size(); i++){
 		//	For each vertex
@@ -81,9 +79,9 @@ bool BL_MeshDeformer::Apply(RAS_IPolyMaterial *mat)
 BL_MeshDeformer::~BL_MeshDeformer()
 {	
 	if (m_transverts)
-		delete []m_transverts;
+		delete [] m_transverts;
 	if (m_transnors)
-		delete []m_transnors;
+		delete [] m_transnors;
 };
 
 /**
@@ -91,65 +89,123 @@ BL_MeshDeformer::~BL_MeshDeformer()
  */
 void BL_MeshDeformer::RecalcNormals()
 {
-	int v, f;
-	float fnor[3], co1[3], co2[3], co3[3], co4[3];
+	/* We don't normalize for performance, not doing it for faces normals
+	 * gives area-weight normals which often look better anyway, and use
+	 * GL_NORMALIZE so we don't have to do per vertex normalization either
+	 * since the GPU can do it faster
+	 *
+	 * There's a lot of indirection here to get to the data, can this work
+	 * with less arrays/indirection? */
 
-	/* Clear all vertex normal accumulators */
-	for (v =0; v<m_bmesh->totvert; v++){
-		m_transnors[v]=MT_Point3(0,0,0);
-	}
-	
-	/* Find the face normals */
-	for (f = 0; f<m_bmesh->totface; f++){
-		// Make new face normal based on the transverts
-		MFace *mf= &((MFace*)m_bmesh->mface)[f];
-		
-		if (mf->v3) {
-			for (int vl=0; vl<3; vl++){
-				co1[vl]=m_transverts[mf->v1][vl];
-				co2[vl]=m_transverts[mf->v2][vl];
-				co3[vl]=m_transverts[mf->v3][vl];
-				if (mf->v4)
-					co4[vl]=m_transverts[mf->v4][vl];
+	vecIndexArrays indexarrays;
+	vecIndexArrays mvarrays;
+	vecIndexArrays diarrays;
+	vecVertexArray vertexarrays;
+	size_t i, j;
+
+	/* set vertex normals to zero */
+	for (i=0; i<(size_t)m_bmesh->totvert; i++)
+		m_transnors[i] = MT_Vector3(0.0f, 0.0f, 0.0f);
+
+	/* add face normals to vertices. */
+	for(RAS_MaterialBucket::Set::iterator mit = m_pMeshObject->GetFirstMaterial();
+		mit != m_pMeshObject->GetLastMaterial(); ++ mit) {
+		RAS_IPolyMaterial *mat = (*mit)->GetPolyMaterial();
+
+		indexarrays = m_pMeshObject->GetIndexCache(mat);
+		vertexarrays = m_pMeshObject->GetVertexCache(mat);
+		diarrays = m_pMeshObject->GetDIndexCache(mat);
+		mvarrays = m_pMeshObject->GetMVertCache(mat);
+
+		for (i=0; i<indexarrays.size(); i++) {
+			KX_VertexArray& vertexarray = (*vertexarrays[i]);
+			const KX_IndexArray& mvarray = (*mvarrays[i]);
+			const KX_IndexArray& diarray = (*diarrays[i]);
+			const KX_IndexArray& indexarray = (*indexarrays[i]);
+			int nvert = mat->UsesTriangles()? 3: 4;
+
+			for(j=0; j<indexarray.size(); j+=nvert) {
+				MT_Point3 mv1, mv2, mv3, mv4, fnor;
+				int i1 = indexarray[j];
+				int i2 = indexarray[j+1];
+				int i3 = indexarray[j+2];
+				RAS_TexVert& v1 = vertexarray[i1];
+				RAS_TexVert& v2 = vertexarray[i2];
+				RAS_TexVert& v3 = vertexarray[i3];
+
+				/* compute face normal */
+				mv1 = MT_Point3(v1.getLocalXYZ());
+				mv2 = MT_Point3(v2.getLocalXYZ());
+				mv3 = MT_Point3(v3.getLocalXYZ());
+
+				if(nvert == 4) {
+					int i4 = indexarray[j+3];
+					RAS_TexVert& v4 = vertexarray[i4];
+					mv4 = MT_Point3(v4.getLocalXYZ());
+
+					fnor = (((mv2-mv1).cross(mv3-mv2))+((mv4-mv3).cross(mv1-mv4))); //.safe_normalized();
+				}
+				else
+					fnor = ((mv2-mv1).cross(mv3-mv2)); //.safe_normalized();
+
+				/* add to vertices for smooth normals */
+				m_transnors[mvarray[diarray[i1]]] += fnor;
+				m_transnors[mvarray[diarray[i2]]] += fnor;
+				m_transnors[mvarray[diarray[i3]]] += fnor;
+
+				/* in case of flat - just assign, the vertices are split */
+				if(v1.getFlag() & TV_CALCFACENORMAL) {
+					v1.SetNormal(fnor);
+					v2.SetNormal(fnor);
+					v3.SetNormal(fnor);
+				}
+
+				if(nvert == 4) {
+					int i4 = indexarray[j+3];
+					RAS_TexVert& v4 = vertexarray[i4];
+
+					/* same as above */
+					m_transnors[mvarray[diarray[i4]]] += fnor;
+
+					if(v4.getFlag() & TV_CALCFACENORMAL)
+						v4.SetNormal(fnor);
+				}
 			}
+		}
+	}
 
-			/* FIXME: Use moto */
-			if (mf->v4)
-				CalcNormFloat4(co1, co2, co3, co4, fnor);
-			else
-				CalcNormFloat(co1, co2, co3, fnor);
-	
-			/* Decide which normals are affected by this face's normal */
-			m_transnors[mf->v1]+=MT_Point3(fnor);
-			m_transnors[mf->v2]+=MT_Point3(fnor);
-			m_transnors[mf->v3]+=MT_Point3(fnor);
-			if (mf->v4)
-				m_transnors[mf->v4]+=MT_Point3(fnor);
+	/* assign smooth vertex normals */
+	for(RAS_MaterialBucket::Set::iterator mit = m_pMeshObject->GetFirstMaterial();
+		mit != m_pMeshObject->GetLastMaterial(); ++ mit) {
+		RAS_IPolyMaterial *mat = (*mit)->GetPolyMaterial();
+
+		vertexarrays = m_pMeshObject->GetVertexCache(mat);
+		diarrays = m_pMeshObject->GetDIndexCache(mat);
+		mvarrays = m_pMeshObject->GetMVertCache(mat);
+
+		for (i=0; i<vertexarrays.size(); i++) {
+			KX_VertexArray& vertexarray = (*vertexarrays[i]);
+			const KX_IndexArray& mvarray = (*mvarrays[i]);
+			const KX_IndexArray& diarray = (*diarrays[i]);
+			
+			for(j=0; j<vertexarray.size(); j++)
+				if(!(vertexarray[j].getFlag() & TV_CALCFACENORMAL))
+					vertexarray[j].SetNormal(m_transnors[mvarray[diarray[j]]]); //.safe_normalized()
 		}
 	}
-	
-	for (v =0; v<m_bmesh->totvert; v++){
-//		float nor[3];
-
-		m_transnors[v]=m_transnors[v].safe_normalized();
-//		nor[0]=m_transnors[v][0];
-//		nor[1]=m_transnors[v][1];
-//		nor[2]=m_transnors[v][2];
-		
-	};
 }
 
 void BL_MeshDeformer::VerifyStorage()
 {
 	/* Ensure that we have the right number of verts assigned */
-	if (m_tvtot!=m_bmesh->totvert+m_bmesh->totface){
+	if (m_tvtot!=m_bmesh->totvert+m_bmesh->totface) {
 		if (m_transverts)
-			delete []m_transverts;
+			delete [] m_transverts;
 		if (m_transnors)
-			delete []m_transnors;
+			delete [] m_transnors;
 		
-		m_transnors =new MT_Point3[m_bmesh->totvert+m_bmesh->totface];
 		m_transverts=new float[(sizeof(*m_transverts)*m_bmesh->totvert)][3];
+		m_transnors=new MT_Vector3[m_bmesh->totvert];
 		m_tvtot = m_bmesh->totvert;
 	}
 }
diff --git a/source/gameengine/Converter/BL_MeshDeformer.h b/source/gameengine/Converter/BL_MeshDeformer.h
index a6be11d786e..88dc2500859 100644
--- a/source/gameengine/Converter/BL_MeshDeformer.h
+++ b/source/gameengine/Converter/BL_MeshDeformer.h
@@ -48,9 +48,9 @@ public:
 	BL_MeshDeformer(struct Object* obj, class BL_SkinMeshObject *meshobj ):
 		m_pMeshObject(meshobj),
 		m_bmesh((struct Mesh*)(obj->data)),
+		m_transverts(0),
+		m_transnors(0),
 		m_objMesh(obj),
-		m_transnors(NULL),
-		m_transverts(NULL),
 		m_tvtot(0)
 	{};
 	virtual ~BL_MeshDeformer();
@@ -62,12 +62,11 @@ public:
 protected:
 	class BL_SkinMeshObject*	m_pMeshObject;
 	struct Mesh*				m_bmesh;
-	MT_Point3*					m_transnors;
 	
-	//MT_Point3*				m_transverts;
 	// this is so m_transverts doesn't need to be converted
 	// before deformation
 	float						(*m_transverts)[3];
+	MT_Vector3*					m_transnors;
 	struct Object*				m_objMesh; 
 	// --
 	int							m_tvtot;
diff --git a/source/gameengine/Converter/BL_SkinDeformer.cpp b/source/gameengine/Converter/BL_SkinDeformer.cpp
index 14faa3317d0..0f884674c09 100644
--- a/source/gameengine/Converter/BL_SkinDeformer.cpp
+++ b/source/gameengine/Converter/BL_SkinDeformer.cpp
@@ -57,7 +57,6 @@ extern "C"{
 #define __NLA_DEFNORMALS
 //#undef __NLA_DEFNORMALS
 
-
 BL_SkinDeformer::BL_SkinDeformer(
 	struct Object *bmeshobj_old,	// Blender object that owns the new mesh
 	struct Object *bmeshobj_new,	// Blender object that owns the original mesh
@@ -87,25 +86,15 @@ BL_SkinDeformer::~BL_SkinDeformer()
 		Mat4CpyMat4(m_objMesh->obmat, m_obmat);
 }
 
-/* XXX note, this __NLA_OLDDEFORM define seems to be obsolete */
-
 bool BL_SkinDeformer::Apply(RAS_IPolyMaterial *mat)
 {
 	size_t			i, j, index;
 	vecVertexArray	array;
-#ifdef __NLA_OLDDEFORM
-	vecMVertArray	mvarray;
-#else
 	vecIndexArrays	mvarray;
-#endif
 	vecMDVertArray	dvarray;
 	vecIndexArrays	diarray;
 
 	RAS_TexVert *tv;
-#ifdef __NLA_OLDDEFORM
-	MVert	*mvert;
-	MDeformVert	*dvert;
-#endif
 	MT_Point3 pt;
 //	float co[3];
 
@@ -115,48 +104,24 @@ bool BL_SkinDeformer::Apply(RAS_IPolyMaterial *mat)
 	Update();
 
 	array = m_pMeshObject->GetVertexCache(mat);
-#ifdef __NLA_OLDDEFORM
-	dvarray = m_pMeshObject->GetDVertCache(mat);
-#endif
 	mvarray = m_pMeshObject->GetMVertCache(mat);
 	diarray = m_pMeshObject->GetDIndexCache(mat);
 	
-
 	// For each array
-	for (i=0; i<array.size(); i++){
+	for (i=0; i<array.size(); i++) {
 		//	For each vertex
-		for (j=0; j<array[i]->size(); j++){
+		for (j=0; j<array[i]->size(); j++) {
 
 			tv = &((*array[i])[j]);
 			
 			index = ((*diarray[i])[j]);
-#ifdef __NLA_OLDDEFORM
-			pt = tv->xyz();
-			mvert = ((*mvarray[i])[index]);
-			dvert = ((*dvarray[i])[index]);
-#endif
 			
 			//	Copy the untransformed data from the original mvert
-#ifdef __NLA_OLDDEFORM
-			co[0]=mvert->co[0];
-			co[1]=mvert->co[1];
-			co[2]=mvert->co[2];
-
-			//	Do the deformation
-/* XXX note, doesnt exist anymore */
-//			GB_calc_armature_deform(co, dvert);
-			tv->SetXYZ(co);
-#else
 			//	Set the data
 			tv->SetXYZ(m_transverts[((*mvarray[i])[index])]);
-#ifdef __NLA_DEFNORMALS
-
-			tv->SetNormal(m_transnors[((*mvarray[i])[index])]);
-#endif
-#endif
 		}
 	}
-	
+
 	return true;
 }
 
@@ -197,7 +162,9 @@ void BL_SkinDeformer::Update(void)
 			VECCOPY(m_transverts[v], m_bmesh->mvert[v].co);
 
 		armature_deform_verts( par_arma, m_objMesh, NULL, m_transverts, NULL, m_bmesh->totvert, ARM_DEF_VGROUP, NULL, NULL );
+#ifdef __NLA_DEFNORMALS
 		RecalcNormals();
+#endif
 
 		/* Update the current frame */
 		m_lastUpdate=m_armobj->GetLastFrame();
diff --git a/source/gameengine/Converter/BL_SkinDeformer.h b/source/gameengine/Converter/BL_SkinDeformer.h
index e130dc15dbf..79f6453a25d 100644
--- a/source/gameengine/Converter/BL_SkinDeformer.h
+++ b/source/gameengine/Converter/BL_SkinDeformer.h
@@ -69,8 +69,8 @@ public:
 						m_armobj(arma),
 						m_lastUpdate(-1),
 						m_defbase(&bmeshobj->defbase),
-						m_releaseobject(false),
-						m_restoremat(false)
+						m_restoremat(false),
+						m_releaseobject(false)
 	{
 	};
 
diff --git a/source/gameengine/Converter/BL_SkinMeshObject.cpp b/source/gameengine/Converter/BL_SkinMeshObject.cpp
index 8bc78c7f757..69feb72f5dc 100644
--- a/source/gameengine/Converter/BL_SkinMeshObject.cpp
+++ b/source/gameengine/Converter/BL_SkinMeshObject.cpp
@@ -53,23 +53,27 @@ void BL_SkinMeshObject::AddPolygon(RAS_Polygon* poly)
 	RAS_MeshObject::AddPolygon(poly);
 }
 
-#ifdef __NLA_OLDDEFORM
-int BL_SkinMeshObject::FindOrAddDeform(int vtxarray, struct MVert *mv, struct MDeformVert *dv, RAS_IPolyMaterial* mat)
-#else
 int BL_SkinMeshObject::FindOrAddDeform(unsigned int vtxarray, unsigned int mv, struct MDeformVert *dv, RAS_IPolyMaterial* mat)
-#endif
 {
 	BL_SkinArrayOptimizer* ao = (BL_SkinArrayOptimizer*)GetArrayOptimizer(mat);//*(m_matVertexArrays[*mat]);
 	int numvert = ao->m_MvertArrayCache1[vtxarray]->size();
-	
+
 	/* Check to see if this has already been pushed */
-	for (unsigned int i=0; i<ao->m_MvertArrayCache1[vtxarray]->size(); i++){
-		if (mv == (*ao->m_MvertArrayCache1[vtxarray])[i])
-			return i;
+	for (vector<BL_MDVertMap>::iterator it = m_mvert_to_dvert_mapping[mv].begin();
+	     it != m_mvert_to_dvert_mapping[mv].end();
+	     it++)
+	{
+		if(it->mat == mat)
+			return it->index;
 	}
 
 	ao->m_MvertArrayCache1[vtxarray]->push_back(mv);
 	ao->m_DvertArrayCache1[vtxarray]->push_back(dv);
+
+	BL_MDVertMap mdmap;
+	mdmap.mat = mat;
+	mdmap.index = numvert;
+	m_mvert_to_dvert_mapping[mv].push_back(mdmap);
 	
 	return numvert;
 };
@@ -105,11 +109,7 @@ int	BL_SkinMeshObject::FindVertexArray(int numverts,RAS_IPolyMaterial* polymat)
 		KX_IndexArray *ia = new KX_IndexArray();
 		ao->m_IndexArrayCache1.push_back(ia);
 
-#ifdef __NLA_OLDDEFORM
-		BL_MVertArray *bva = new BL_MVertArray();
-#else
 		KX_IndexArray *bva = new KX_IndexArray();
-#endif
 		ao->m_MvertArrayCache1.push_back(bva);
 
 		BL_DeformVertArray *dva = new BL_DeformVertArray();
diff --git a/source/gameengine/Converter/BL_SkinMeshObject.h b/source/gameengine/Converter/BL_SkinMeshObject.h
index 0ca7428c0f0..2422d4cd4c9 100644
--- a/source/gameengine/Converter/BL_SkinMeshObject.h
+++ b/source/gameengine/Converter/BL_SkinMeshObject.h
@@ -106,6 +106,9 @@ class BL_SkinMeshObject : public RAS_MeshObject
 
 protected:
 public:
+	struct BL_MDVertMap { RAS_IPolyMaterial *mat; int index; };
+	vector<vector<BL_MDVertMap> >	m_mvert_to_dvert_mapping;
+
 	void Bucketize(double* oglmatrix,void* clientobj,bool useObjectColor,const MT_Vector4& rgbavec);
 //	void Bucketize(double* oglmatrix,void* clientobj,bool useObjectColor,const MT_Vector4& rgbavec,class RAS_BucketManager* bucketmgr);
 
@@ -139,37 +142,17 @@ public:
 		const MT_Point2& uv2,
 		const MT_Vector4& tangent,
 		const unsigned int rgbacolor,
-		const MT_Vector3& normal, int defnr, bool flat, RAS_IPolyMaterial* mat)
+		const MT_Vector3& normal, int defnr, bool flat, RAS_IPolyMaterial* mat, int origindex)
 	{
-		RAS_TexVert tempvert(xyz,uv,uv2, tangent,rgbacolor,normal,flat ? TV_CALCFACENORMAL : 0);
-		
-		//		KX_ArrayOptimizer* ao = GetArrayOptimizer(mat);//*(m_matVertexArrays[*mat]);
-		BL_SkinArrayOptimizer* ao = (BL_SkinArrayOptimizer*)GetArrayOptimizer(mat);//*(m_matVertexArrays[*mat]);
-		
-		int numverts = ao->m_VertexArrayCache1[vtxarray]->size();//m_VertexArrayCount[vtxarray];
-		
-		int index=-1;
-		
-		for (int i=0;i<numverts;i++)
-		{
-			const RAS_TexVert&  vtx = (*ao->m_VertexArrayCache1[vtxarray])[i];
-			if (tempvert.closeTo(&vtx))
-			{
-				index = i;
-				break;
-			}
-			
-		}
-		if (index >= 0)
-			return index;
-		
-		// no vertex found, add one
-		ao->m_VertexArrayCache1[vtxarray]->push_back(tempvert);
-		ao->m_DIndexArrayCache1[vtxarray]->push_back(defnr);
-		
-		return numverts;
-		
-		
+		BL_SkinArrayOptimizer* ao = (BL_SkinArrayOptimizer*)GetArrayOptimizer(mat);
+		int numverts = ao->m_VertexArrayCache1[vtxarray]->size();
+		int index = RAS_MeshObject::FindOrAddVertex(vtxarray, xyz, uv, uv2, tangent, rgbacolor, normal, flat, mat, origindex);
+
+		/* this means a new vertex was added, so we add the defnr too */
+		if(index == numverts)
+			ao->m_DIndexArrayCache1[vtxarray]->push_back(defnr);
+
+		return index;
 	}
 
 };
diff --git a/source/gameengine/Converter/KX_BlenderSceneConverter.cpp b/source/gameengine/Converter/KX_BlenderSceneConverter.cpp
index 8640e69102b..de91bce2ab1 100644
--- a/source/gameengine/Converter/KX_BlenderSceneConverter.cpp
+++ b/source/gameengine/Converter/KX_BlenderSceneConverter.cpp
@@ -100,7 +100,8 @@ KX_BlenderSceneConverter::KX_BlenderSceneConverter(
 							m_sipo(sipo),
 							m_ketsjiEngine(engine),
 							m_alwaysUseExpandFraming(false),
-							m_usemat(false)
+							m_usemat(false),
+							m_useglslmat(false)
 {
 	m_newfilename = "";
 }
@@ -449,6 +450,13 @@ void KX_BlenderSceneConverter::RemoveScene(KX_Scene *scene)
 void KX_BlenderSceneConverter::SetMaterials(bool val)
 {
 	m_usemat = val;
+	m_useglslmat = false;
+}
+
+void KX_BlenderSceneConverter::SetGLSLMaterials(bool val)
+{
+	m_usemat = val;
+	m_useglslmat = val;
 }
 
 bool KX_BlenderSceneConverter::GetMaterials()
@@ -456,6 +464,10 @@ bool KX_BlenderSceneConverter::GetMaterials()
 	return m_usemat;
 }
 
+bool KX_BlenderSceneConverter::GetGLSLMaterials()
+{
+	return m_useglslmat;
+}
 
 void KX_BlenderSceneConverter::RegisterBlenderMaterial(BL_Material *mat)
 {
diff --git a/source/gameengine/Converter/KX_BlenderSceneConverter.h b/source/gameengine/Converter/KX_BlenderSceneConverter.h
index a45d7396875..e5d6ccc5caf 100644
--- a/source/gameengine/Converter/KX_BlenderSceneConverter.h
+++ b/source/gameengine/Converter/KX_BlenderSceneConverter.h
@@ -75,6 +75,7 @@ class KX_BlenderSceneConverter : public KX_ISceneConverter
 	class KX_Scene*			m_currentScene;	// Scene being converted
 	bool					m_alwaysUseExpandFraming;
 	bool					m_usemat;
+	bool					m_useglslmat;
 
 	void localDel_ipoCurve ( IpoCurve * icu ,struct SpaceIpo*	sipo);
 //	struct Ipo* findIpoForName(char* objName);
@@ -146,6 +147,10 @@ public:
 	virtual void SetMaterials(bool val);
 	virtual bool GetMaterials();
 
+	// use blender glsl materials
+	virtual void SetGLSLMaterials(bool val);
+	virtual bool GetGLSLMaterials();
+
 };
 
 #endif //__KX_BLENDERSCENECONVERTER_H